// spry.effect.js - version 0.39 - spry pre-release 1.6.1
//
// copyright (c) 2006. adobe systems incorporated.
// all rights reserved.
//
// redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * neither the name of adobe systems incorporated nor the names of its
//     contributors may be used to endorse or promote products derived from this
//     software without specific prior written permission.
//
// this software is provided by the copyright holders and contributors "as is"
// and any express or implied warranties, including, but not limited to, the
// implied warranties of merchantability and fitness for a particular purpose
// are disclaimed. in no event shall the copyright owner or contributors be
// liable for any direct, indirect, incidental, special, exemplary, or
// consequential damages (including, but not limited to, procurement of
// substitute goods or services; loss of use, data, or profits; or business
// interruption) however caused and on any theory of liability, whether in
// contract, strict liability, or tort (including negligence or otherwise)
// arising in any way out of the use of this software, even if advised of the
// possibility of such damage.

(function() { // beginsprycomponent

if (typeof spry == "undefined") window.spry = {}; if (!spry.effect) spry.effect = {};

spry.forwards = 1; // const
spry.backwards = 2; // const

spry.effect.transitions = {
	lineartransition: function(time, begin, change, duration)
	{
		if (time > duration) return change+begin;
		return begin + (time / duration) * change;
	},
	sinusoidaltransition: function(time, begin, change, duration)
	{
		if (time > duration) return change+begin;
		return begin + ((-math.cos((time/duration)*math.pi)/2) + 0.5) * change;
	},
	squaretransition: function(time, begin, change, duration)
	{
		if (time > duration) return change+begin;
		return begin + math.pow(time/duration, 2) * change;
	},
	squareroottransition: function(time, begin, change, duration)
	{
		if (time > duration) return change+begin;
		return begin + math.sqrt(time/duration) * change;
	},
	fifthtransition: function(time, begin, change, duration)
	{
		if (time > duration) return change+begin;
		return begin + math.sqrt((-math.cos((time/duration)*math.pi)/2) + 0.5) * change;
	},
	circletransition: function(time, begin, change, duration)
	{
		if (time > duration) return change+begin;
		var pos = time/duration;
		return begin + math.sqrt(1 - math.pow((pos-1), 2))* change;
	},
	pulsatetransition: function(time, begin, change, duration)
	{
		if (time > duration) return change+begin;
		return begin + (0.5 + math.sin(17*time/duration)/2) * change;
	},
	growspecifictransition: function(time, begin, change, duration)
	{
		if (time > duration) return change+begin;
		var pos = time/duration;
		return begin + (5 * math.pow(pos, 3) - 6.4 * math.pow(pos, 2) + 2 * pos) * change;
	}
};
for (var trans in spry.effect.transitions)
{
	spry[trans] = spry.effect.transitions[trans];
}
//////////////////////////////////////////////////////////////////////
//
// spry.effect.registry
//
//////////////////////////////////////////////////////////////////////

spry.effect.registry = function()
{
	this.effects = [];
};

spry.effect.registry.prototype.getregisteredeffect = function(element, options) 
{
	var a = {};
	a.element = spry.effect.getelement(element);
	a.options = options;

	for (var i=0; i<this.effects.length; i++)
		if (this.effectsarethesame(this.effects[i], a))
			return this.effects[i].effect;

	return false;
};

spry.effect.registry.prototype.addeffect = function(effect, element, options)
{
	if (!this.getregisteredeffect(element, options))
	{
		var len = this.effects.length;
		this.effects[len] = {};
		var eff = this.effects[len];
		eff.effect = effect;
		eff.element = spry.effect.getelement(element);
		eff.options = options;
	}
};

spry.effect.registry.prototype.effectsarethesame = function(effecta, effectb)
{
	if (effecta.element != effectb.element)
		return false;

	var compare = spry.effect.utils.optionsareidentical(effecta.options, effectb.options);
	// reset finish and setup functions
	if (compare)
	{
		if (typeof effectb.options.setup == 'function')
			effecta.options.setup = effectb.options.setup;

		if (typeof effectb.options.finish == 'function')
			effecta.options.finish = effectb.options.finish;
	}		

	return compare;
};

var spryregistry = new spry.effect.registry;

//////////////////////////////////////////////////////////////////////
//
// spry.effect.utils
//
//////////////////////////////////////////////////////////////////////

if (!spry.effect.utils) spry.effect.utils = {};

spry.effect.utils.showerror = function(msg)
{
	alert('spry.effect err: ' + msg);
};
spry.effect.utils.showiniterror = function(effect){
	spry.effect.utils.showerror('the ' + effect + ' class can\'t be accessed as a static function anymore. '+ "\n" + 'please read spry effects migration documentation.');
	return false;
};
spry.effect.utils.position = function()
{
	this.x = 0; // left
	this.y = 0; // top
	this.units = "px";
};

spry.effect.utils.rectangle = function()
{
	this.width = 0;
	this.height = 0;
	this.units = "px";
};

spry.effect.utils.inttohex = function(integernum) 
{
	var result = integernum.tostring(16);
	if (result.length == 1)
		result = "0" + result;
	return result;
};

spry.effect.utils.hextoint = function(hexstr)
{
	return parseint(hexstr, 16);
};

spry.effect.utils.rgb = function(redint, greenint, blueint)
{
	var inttohex = spry.effect.utils.inttohex;
	var redhex = inttohex(redint);
	var greenhex = inttohex(greenint);
	var bluehex = inttohex(blueint);
	compositecolorhex = redhex.concat(greenhex, bluehex).touppercase();
	compositecolorhex = '#' + compositecolorhex;
	return compositecolorhex;
};

spry.effect.utils.longcolorversion = function(color){
	if ( color.match(/^#[0-9a-f]{3}$/i) ){
		var tmp = color.split('');
		var color = '#';
		for (var i = 1; i < tmp.length; i++){
			color += tmp[i] + '' + tmp[i];	
		}
	}
	return color;
};

spry.effect.utils.camelize = function(stringtocamelize)
{
	if (stringtocamelize.indexof('-') == -1){
		return stringtocamelize;	
	}
	var ostringlist = stringtocamelize.split('-');
	var isfirstentry = true;
	var camelizedstring = '';

	for(var i=0; i < ostringlist.length; i++)
	{
		if(ostringlist[i].length>0)
		{
			if(isfirstentry)
			{
				camelizedstring = ostringlist[i];
				isfirstentry = false;
			}
			else
			{
				var s = ostringlist[i];
				camelizedstring += s.charat(0).touppercase() + s.substring(1);
			}
		}
	}

	return camelizedstring;
};

spry.effect.utils.ispercentvalue = function(value)
{
	var result = false;
	if (typeof value == 'string' && value.length > 0 && value.lastindexof("%") > 0)
		result = true;

	return result;
};

spry.effect.utils.getpercentvalue = function(value)
{
	var result = 0;
	try
	{
		result = number(value.substring(0, value.lastindexof("%")));
	}
	catch (e) {spry.effect.utils.showerror('spry.effect.utils.getpercentvalue: ' + e);}
	return result;
};

spry.effect.utils.getpixelvalue = function(value)
{
	var result = 0;
	if (typeof value == 'number') return value;
	var unitindex = value.lastindexof("px");
	if ( unitindex == -1)
		unitindex = value.length;
	try
	{
		result = parseint(value.substring(0, unitindex), 10);
	}
	catch (e){}
	return result;
};

spry.effect.utils.getfirstchildelement = function(node)
{
	if (node)
	{
		var childcurr = node.firstchild;
		while (childcurr)
		{
			if (childcurr.nodetype == 1) // node.element_node
				return childcurr;

			childcurr = childcurr.nextsibling;
		}
	}

	return null;
};

spry.effect.utils.fetchchildimages = function(starteltin, targetimagesout)
{
	if(!starteltin  || starteltin.nodetype != 1 || !targetimagesout)
		return;

	if(starteltin.haschildnodes())
	{
		var childimages = starteltin.getelementsbytagname('img');
		var imagecnt = childimages.length;
		for(var i=0; i<imagecnt; i++)
		{
			var imgcurr = childimages[i];
			var dimensionscurr = spry.effect.getdimensions(imgcurr);
			targetimagesout.push([imgcurr,dimensionscurr.width,dimensionscurr.height]);
		}
	}
};

spry.effect.utils.optionsareidentical = function(optionsa, optionsb)
{
	if(optionsa == null && optionsb == null)
		return true;

	if(optionsa != null && optionsb != null)
	{
		var objectcounta = 0;
		var objectcountb = 0;

		for (var propa in optionsa) objectcounta++;
		for (var propb in optionsb) objectcountb++;

		if(objectcounta != objectcountb)
			return false;

		for (var prop in optionsa)
		{
			var typea = typeof optionsa[prop];
			var typeb = typeof optionsb[prop];
			if ( typea != typeb || (typea != 'undefined' && optionsa[prop] != optionsb[prop]))
				return false;
		}

		return true;
	}

	return false;
};

spry.effect.utils.doeffect = function (effectname, element, options)
{
	if (!options)
		var options = {};

	options.name = effectname;
	var ef = spryregistry.getregisteredeffect(element, options);
	if (!ef)
	{
		ef = new spry.effect[effectname](element, options);
		spryregistry.addeffect(ef, element, options);
	}
	ef.start();
	return true;
};
//////////////////////////////////////////////////////////////////////
//
//  the notification class
//
//////////////////////////////////////////////////////////////////////
if (!spry.utils) spry.utils = {};

spry.utils.notifier = function()
{
	this.observers = [];
	this.suppressnotifications = 0;
};

spry.utils.notifier.prototype.addobserver = function(observer)
{
	if (!observer)
		return;

	// make sure the observer isn't already on the list.

	var len = this.observers.length;
	for (var i = 0; i < len; i++)
		if (this.observers[i] == observer) return;

	this.observers[len] = observer;
};

spry.utils.notifier.prototype.removeobserver = function(observer)
{
	if (!observer)
		return;

	for (var i = 0; i < this.observers.length; i++)
	{
		if (this.observers[i] == observer)
		{
			this.observers.splice(i, 1);
			break;
		}
	}
};

spry.utils.notifier.prototype.notifyobservers = function(methodname, data)
{
	if (!methodname)
		return;

	if (!this.suppressnotifications)
	{
		var len = this.observers.length;
		for (var i = 0; i < len; i++)
		{
			var obs = this.observers[i];
			if (obs)
			{
				if (typeof obs == "function")
					obs(methodname, this, data);
				else if (obs[methodname])
					obs[methodname](this, data);
			}
		}
	}
};

spry.utils.notifier.prototype.enablenotifications = function()
{
	if (--this.suppressnotifications < 0)
	{
		this.suppressnotifications = 0;
		spry.effect.utils.showerror("unbalanced enablenotifications() call!\n");
	}
};

spry.utils.notifier.prototype.disablenotifications = function()
{
	++this.suppressnotifications;
};

//////////////////////////////////////////////////////////////////////
//
// dhtml manipulation
//
//////////////////////////////////////////////////////////////////////

spry.effect.getelement = function(ele)
{
	var element = ele;
	if (typeof ele == "string")
		element = document.getelementbyid(ele);

	if (element == null) 
		spry.effect.utils.showerror('element "' + ele + '" not found.');
	
	return element;
};

spry.effect.getstyleprop = function(element, prop)
{
	var value;
	var camelized = spry.effect.utils.camelize(prop);
	try
	{
		if (element.style)
			value = element.style[camelized];

		if (!value)
		{
			if (document.defaultview && document.defaultview.getcomputedstyle)
			{
				var css = document.defaultview.getcomputedstyle(element, null);
				value = css ? css.getpropertyvalue(prop) : null;
			}
			else if (element.currentstyle) 
			{
					value = element.currentstyle[camelized];
			}
		}
	}
	catch (e) {spry.effect.utils.showerror('spry.effect.getstyleprop: ' + e);}

	return value == 'auto' ? null : value;
};

spry.effect.setstyleprop = function(element, prop, value)
{
	try
	{
		element.style[spry.effect.utils.camelize(prop)] = value;
	}
	catch (e) {spry.effect.utils.showerror('spry.effect.setstyleprop: ' + e);}
};

spry.effect.getstylepropregardlessofdisplaystate = function(element, prop, displayelement)
{
	var refelement = displayelement ? displayelement : element;
	var displayorig = spry.effect.getstyleprop(refelement, 'display');
	var visibilityorig = spry.effect.getstyleprop(refelement, 'visibility');

	if(displayorig == 'none')
	{
		spry.effect.setstyleprop(refelement, 'visibility', 'hidden');
		spry.effect.setstyleprop(refelement, 'display', 'block');

		if(window.opera) // opera needs focus to calculate the size for hidden elements
			refelement.focus();
	}

	var styleprop = spry.effect.getstyleprop(element, prop);

	if(displayorig == 'none') // reset the original values
	{
		spry.effect.setstyleprop(refelement, 'display', 'none');
		spry.effect.setstyleprop(refelement, 'visibility', visibilityorig);
	}
	return styleprop;
};

spry.effect.makepositioned = function(element)
{
	var pos = spry.effect.getstyleprop(element, 'position');
	if (!pos || pos == 'static')
	{
		element.style.position = 'relative';

		// opera returns the offset relative to the positioning context, when an
		// element is position relative but top and left have not been defined
		if (window.opera)
		{
			element.style.top = 0;
			element.style.left = 0;
		}
	}
};

spry.effect.isinvisible = function(element)
{
	var propdisplay = spry.effect.getstyleprop(element, 'display');
	if (propdisplay && propdisplay.tolowercase() == 'none')
		return true;

	var propvisible = spry.effect.getstyleprop(element, 'visibility');
	if (propvisible && propvisible.tolowercase() == 'hidden')
		return true;

	return false;
};

spry.effect.enforcevisible = function(element)
{
	var propdisplay = spry.effect.getstyleprop(element, 'display');
	if (propdisplay && propdisplay.tolowercase() == 'none')
		spry.effect.setstyleprop(element, 'display', 'block');

	var propvisible = spry.effect.getstyleprop(element, 'visibility');
	if (propvisible && propvisible.tolowercase() == 'hidden')
		spry.effect.setstyleprop(element, 'visibility', 'visible');
};

spry.effect.makeclipping = function(element)
{
	var overflow = spry.effect.getstyleprop(element, 'overflow');
	if (!overflow || (overflow.tolowercase() != 'hidden' && overflow.tolowercase() != 'scroll'))
	{
		// ie 7 bug: set overflow property to hidden changes the element height to 0
		// -> therefore we save the height before changing the overflow property and set the old size back
		var heightcache = 0;
		var needscache = /msie 7.0/.test(navigator.useragent) && /windows nt/.test(navigator.useragent);
		if(needscache)
			heightcache = spry.effect.getdimensionsregardlessofdisplaystate(element).height;

		spry.effect.setstyleprop(element, 'overflow', 'hidden');

		if(needscache)
			spry.effect.setstyleprop(element, 'height', heightcache+'px');
	}
};

spry.effect.cleanwhitespace = function(element) 
{
	var childcountinit = element.childnodes.length;
  for (var i = childcountinit - 1; i >= 0; i--) {
  	var node = element.childnodes[i];
		if (node.nodetype == 3 && !/\s/.test(node.nodevalue))
			try
			{
				element.removechild(node);
			}
			catch (e) {spry.effect.utils.showerror('spry.effect.cleanwhitespace: ' + e);}
	}
};

spry.effect.getcomputedstyle = function(element)
{
	return /msie/.test(navigator.useragent) ? element.currentstyle : document.defaultview.getcomputedstyle(element, null);
};

spry.effect.getdimensions = function(element)
{
	var dimensions = new spry.effect.utils.rectangle;
	var computedstyle = null;

	if (element.style.width && /px/i.test(element.style.width))
		dimensions.width = parseint(element.style.width, 10); // without padding
	else
	{
		computedstyle = spry.effect.getcomputedstyle(element);
		var trycomputedstyle = computedstyle && computedstyle.width && /px/i.test(computedstyle.width);

		if (trycomputedstyle)
			dimensions.width = parseint(computedstyle.width, 10); // without padding, includes css

		if (!trycomputedstyle || dimensions.width == 0) // otherwise we might run into problems on safari and opera (mac only)
			dimensions.width = element.offsetwidth;   // includes padding
	}

	if (element.style.height && /px/i.test(element.style.height))
		dimensions.height = parseint(element.style.height, 10); // without padding
	else
	{
		if (!computedstyle)
			computedstyle = spry.effect.getcomputedstyle(element);

		var trycomputedstyle = computedstyle && computedstyle.height && /px/i.test(computedstyle.height);

		if (trycomputedstyle)
			dimensions.height = parseint(computedstyle.height, 10); // without padding, includes css

		if(!trycomputedstyle || dimensions.height == 0) // otherwise we might run into problems on safari and opera (mac only)
			dimensions.height = element.offsetheight;   // includes padding
	}
	return dimensions;
};

spry.effect.getdimensionsregardlessofdisplaystate = function(element, displayelement)
{
	// if the displayelement display property is set to 'none', we temporarily set its
	// visibility state to 'hidden' to be able to calculate the dimension.

	var refelement = displayelement ? displayelement : element;
	var displayorig = spry.effect.getstyleprop(refelement, 'display');
	var visibilityorig = spry.effect.getstyleprop(refelement, 'visibility');

	if(displayorig == 'none')
	{
		spry.effect.setstyleprop(refelement, 'visibility', 'hidden');
		spry.effect.setstyleprop(refelement, 'display', 'block');

		if(window.opera) // opera needs focus to calculate the size for hidden elements
			refelement.focus();
	}

	var dimensions = spry.effect.getdimensions(element);

	if(displayorig == 'none') // reset the original values
	{
		spry.effect.setstyleprop(refelement, 'display', 'none');
		spry.effect.setstyleprop(refelement, 'visibility', visibilityorig);
	}
	return dimensions;
};

spry.effect.getopacity = function(element)
{
  var o = spry.effect.getstyleprop(element, "opacity");
  if (typeof o == 'undefined' || o == null)
    o = 1.0;
  return o;
};

spry.effect.getbgcolor = function(ele)
{
  return spry.effect.getstyleprop(ele, "background-color");
};

spry.effect.intpropstyle = function(e, prop){
		var i = parseint(spry.effect.getstyleprop(e, prop), 10);
		if (isnan(i))
			return 0;
		return i;
};

spry.effect.getposition = function(element)
{
	var position = new spry.effect.utils.position;
	var computedstyle = null;

	if (element.style.left  && /px/i.test(element.style.left))
		position.x = parseint(element.style.left, 10); // without padding
	else
	{
		computedstyle = spry.effect.getcomputedstyle(element);
		var trycomputedstyle = computedstyle && computedstyle.left && /px/i.test(computedstyle.left);

		if (trycomputedstyle)
			position.x = parseint(computedstyle.left, 10); // without padding, includes css

		if(!trycomputedstyle || position.x == 0) // otherwise we might run into problems on safari and opera (mac only)
			position.x = element.offsetleft;   // includes padding
	}

	if (element.style.top && /px/i.test(element.style.top))
		position.y = parseint(element.style.top, 10); // without padding
	else
	{
		if (!computedstyle)
			computedstyle = spry.effect.getcomputedstyle(element);

    var trycomputedstyle = computedstyle && computedstyle.top && /px/i.test(computedstyle.top);

		if (trycomputedstyle)
			position.y = parseint(computedstyle.top, 10); // without padding, includes css

		if(!trycomputedstyle || position.y == 0) // otherwise we might run into problems on safari and opera (mac only)
			position.y = element.offsettop;   // includes padding
	}
	return position;
};

spry.effect.getoffsetposition = spry.effect.getposition; // deprecated

//////////////////////////////////////////////////////////////////////
//
// spry.effect.animator
// (base class)
//
//////////////////////////////////////////////////////////////////////

spry.effect.animator = function(options)
{
	spry.utils.notifier.call(this);
	
	this.name = 'animator';
	this.element = null;
	this.startmilliseconds = 0;
	this.repeat = 'none';
	this.isrunning = false;
	this.timer = null;
	this.cancelremaining = 0;

	if (!options)
		var options = {};

	if (options.toggle)
		this.direction = false;
	else
		this.direction = spry.forwards;
	
	var self = this;
	if (options.setup != null)
		this.addobserver({onpreeffect: function(){try{self.options.setup(self.element, self);}catch(e){spry.effect.utils.showerror('spry.effect.animator.prototype.start: setup callback: ' + e);}}});

	if (options.finish != null)
		this.addobserver({onposteffect: function(){try{self.options.finish(self.element, self);}catch(e){spry.effect.utils.showerror('spry.effect.animator.prototype.stop: finish callback: ' + e);}}});

	this.options = {
		duration: 1000,
		toggle: false,
		transition: spry.lineartransition,
		interval: 16 // ca. 62 fps
	};

	this.setoptions(options);
	if (options.transition)
		this.settransition(options.transition);

	if (options.fps)
		this.setfps(options.fps);
};
spry.effect.animator.prototype = new spry.utils.notifier();
spry.effect.animator.prototype.constructor = spry.utils.animator;

spry.effect.animator.prototype.notstaticanimator = true;

spry.effect.animator.prototype.setoptions = function(options)
{
	if (!options)
		return;
	for (var prop in options)
		this.options[prop] = options[prop];
};
spry.effect.animator.prototype.settransition = function(transition){
	if (typeof transition == 'number' || transition == "1" || transition == "2")
		switch (parseint(transition,10))
		{
			case 1: transition = spry.lineartransition; break;
			case 2: transition = spry.sinusoidaltransition; break;
			default: spry.effect.utils.showerror('unknown transition');
		}

	else if (typeof transition == 'string')
	{
		if (typeof window[transition] == 'function')
			transition = window[transition];
		else if (typeof spry[transition] == 'function')
			transition = spry[transition];
		else
			spry.effect.utils.showerror('unknown transition');
	}

	this.options.transition = transition;
	if (typeof this.effectsarray != 'undefined'){
		var l = this.effectsarray.length;
		for (var i = 0; i < l; i++)
				this.effectsarray[i].effect.settransition(transition);
	}
};

spry.effect.animator.prototype.setduration = function(duration){
	this.options.duration = duration;
	if (typeof this.effectsarray != 'undefined')
	{
		var l = this.effectsarray.length;
		for (var i = 0; i < l; i++)
		{
			this.effectsarray[i].effect.setduration(duration);
		}
	}
};

spry.effect.animator.prototype.setfps = function(fps){
	this.options.interval = parseint(1000 / fps, 10);
	this.options.fps = fps;
	if (typeof this.effectsarray != 'undefined')
	{
		var l = this.effectsarray.length;
		for (var i = 0; i < l; i++)
		{
			this.effectsarray[i].effect.setfps(fps);
		}
	}
};

spry.effect.animator.prototype.start = function(withouttimer)
{
	if (!this.element)
		return;

	if (arguments.length == 0)
		withouttimer = false;

	if (this.isrunning)
		this.cancel();

	this.preparestart();
	var currdate = new date();
	this.startmilliseconds = currdate.gettime();

	if (this.element.id)
		this.element = document.getelementbyid(this.element.id);

	if (this.cancelremaining != 0 && this.options.toggle)
	{
		if (this.cancelremaining < 1 && typeof this.options.transition == 'function')
		{
			var starttime = 0;
			var stoptime = this.options.duration;
			var start = 0;
			var stop = 1;
			var emergency = 0;
			this.cancelremaining = math.round(this.cancelremaining * 1000) / 1000;
			var found = false;
			var middle = 0;
			while (!found)
			{
				if (emergency++ > this.options.duration) break;
				var half = starttime + ((stoptime - starttime) / 2);
				middle = math.round(this.options.transition(half, 1, -1, this.options.duration) * 1000) / 1000;
				if (middle == this.cancelremaining)
				{
					this.startmilliseconds -= half;
					found = true;
				}
				if (middle < this.cancelremaining)
				{
					stoptime = half;
					stop = middle;
				}
				else
				{
					starttime = half;
					start = middle;
				}
			}
		}
		this.cancelremaining = 0;
	}
	this.notifyobservers('onpreeffect', this);

	if (withouttimer == false)
	{
		var self = this;
		this.timer = setinterval(function() { self.draweffect(); }, this.options.interval);
	}
	this.isrunning = true;
};
spry.effect.animator.prototype.stopflagreset = function()
{
	if (this.timer)
	{
		clearinterval(this.timer);
		this.timer = null;
	}
	this.startmilliseconds = 0;
};
spry.effect.animator.prototype.stop = function()
{
	this.stopflagreset();
	this.notifyobservers('onposteffect', this);
	this.isrunning = false;
};

spry.effect.animator.prototype.cancel = function()
{
	var elapsed = this.getelapsedmilliseconds();
	if (this.startmilliseconds > 0 && elapsed < this.options.duration)
		this.cancelremaining = this.options.transition(elapsed, 0, 1, this.options.duration);

	this.stopflagreset();
	this.notifyobservers('oncancel', this);
	this.isrunning = false;
};

spry.effect.animator.prototype.draweffect = function()
{
	var isrunning = true;

	this.notifyobservers('onstep', this);
	var timeelapsed = this.getelapsedmilliseconds();

	if (typeof this.options.transition != 'function'){
		spry.effect.utils.showerror('unknown transition');
		return;
	}
	this.animate();

	if (timeelapsed > this.options.duration)
	{
		isrunning = false;
		this.stop();
	}
	return isrunning;
};

spry.effect.animator.prototype.getelapsedmilliseconds = function()
{
	if (this.startmilliseconds > 0)
	{
		var currdate = new date();
		return (currdate.gettime() - this.startmilliseconds);
	}
	return 0;
};

spry.effect.animator.prototype.dotoggle = function()
{
	if (!this.direction)
	{
		this.direction = spry.forwards;
		return;
	}
	if (this.options.toggle == true)
	{
		if (this.direction == spry.forwards)
		{
			this.direction = spry.backwards;
			this.notifyobservers('ontoggle', this);
		} 
		else if (this.direction == spry.backwards)
		{
			this.direction = spry.forwards;
		}
	}
};

spry.effect.animator.prototype.preparestart = function()
{
		if (this.options && this.options.toggle)
			this.dotoggle();
};

spry.effect.animator.prototype.animate = function(){};
spry.effect.animator.prototype.onstep = function(el)
{
	if (el != this)
		this.notifyobservers('onstep', this);
};
//////////////////////////////////////////////////////////////////////
//
// spry.effect.move
//
//////////////////////////////////////////////////////////////////////

spry.effect.move = function(element, frompos, topos, options)
{
	this.dynamicfrompos = false;
	if (arguments.length == 3)
	{
		options = topos;
		topos = frompos;
		frompos = spry.effect.getposition(element);
		this.dynamicfrompos = true;
	}

	spry.effect.animator.call(this, options);

	this.name = 'move';
	this.element = spry.effect.getelement(element);
	if (!this.element)
		return;

	if (frompos.units != topos.units)
		spry.effect.utils.showerror('spry.effect.move: conflicting units (' + frompos.units + ', ' + topos.units + ')');

	this.units = frompos.units;
	this.startx = number(frompos.x);
	this.stopx = number(topos.x);
	this.starty = number(frompos.y);
	this.stopy = number(topos.y);
};

spry.effect.move.prototype = new spry.effect.animator();
spry.effect.move.prototype.constructor = spry.effect.move;

spry.effect.move.prototype.animate = function()
{
	var left = 0;
	var top = 0;
	var floor = math.floor;
	var elapsed = this.getelapsedmilliseconds();
	if (this.direction == spry.forwards)
	{
		left = floor(this.options.transition(elapsed, this.startx, this.stopx - this.startx, this.options.duration));
		top = floor(this.options.transition(elapsed, this.starty, this.stopy - this.starty, this.options.duration));
	}
	else if (this.direction == spry.backwards)
	{
		left = floor(this.options.transition(elapsed, this.stopx, this.startx - this.stopx, this.options.duration));
		top = floor(this.options.transition(elapsed, this.stopy, this.starty - this.stopy, this.options.duration));
	}

	this.element.style.left = left + this.units;
	this.element.style.top = top + this.units;
};

spry.effect.move.prototype.preparestart = function()
{
	if (this.options && this.options.toggle)
		this.dotoggle();

	if (this.dynamicfrompos == true)
	{
		var frompos = spry.effect.getposition(this.element);
		this.startx = frompos.x;
		this.starty = frompos.y;
		
		this.rangemovex = this.startx - this.stopx;
		this.rangemovey= this.starty - this.stopy;
	}
};

//////////////////////////////////////////////////////////////////////
//
// spry.effect.size
//
//////////////////////////////////////////////////////////////////////

spry.effect.size = function(element, fromrect, torect, options)
{
	this.dynamicfromrect = false;

	if (arguments.length == 3)
	{
		options = torect;
		torect = fromrect;
		fromrect = spry.effect.getdimensionsregardlessofdisplaystate(element);
		this.dynamicfromrect = true;
	}

	spry.effect.animator.call(this, options);

	this.name = 'size';
	this.element = spry.effect.getelement(element);
	if (!this.element)
		return;

	element = this.element;

	if (fromrect.units != torect.units)
	{
		spry.effect.utils.showerror('spry.effect.size: conflicting units (' + fromrect.units + ', ' + torect.units + ')');
		return false;
	}

	this.units = fromrect.units;

	var originalrect = spry.effect.getdimensionsregardlessofdisplaystate(element);
	this.originalwidth = originalrect.width;
	this.originalheight = originalrect.height;

	this.startwidth = fromrect.width;
	this.startheight = fromrect.height;
	this.stopwidth = torect.width;
	this.stopheight = torect.height;
	this.childimages = new array();

	if (this.options.usecssbox){
		spry.effect.makepositioned(this.element);
		var intprop = spry.effect.intpropstyle;
		this.startfromborder_top = intprop(element, 'border-top-width');
		this.startfromborder_bottom = intprop(element, 'border-bottom-width');
		this.startfromborder_left = intprop(element, 'border-left-width');
		this.startfromborder_right = intprop(element, 'border-right-width');
		this.startfrompadding_top = intprop(element, 'padding-top');
		this.startfrompadding_bottom = intprop(element, 'padding-bottom');
		this.startfrompadding_left = intprop(element, 'padding-left');
		this.startfrompadding_right = intprop(element, 'padding-right');
		this.startfrommargin_top = intprop(element, 'margin-top');
		this.startfrommargin_bottom = intprop(element, 'margin-bottom');
		this.startfrommargin_right = intprop(element, 'margin-right');
		this.startfrommargin_left = intprop(element, 'margin-left');
		this.startleft = intprop(element, 'left');
		this.starttop = intprop(element, 'top');
	}

	if(this.options.scalecontent)
		spry.effect.utils.fetchchildimages(element, this.childimages);

	this.fontfactor = 1.0;
	var fontsize = spry.effect.getstyleprop(this.element, 'font-size');
	if(fontsize && /em\s*$/.test(fontsize))
		this.fontfactor = parsefloat(fontsize);

	var ispercent = spry.effect.utils.ispercentvalue;

	if (ispercent(this.startwidth))
	{
		var startwidthpercent = spry.effect.utils.getpercentvalue(this.startwidth);
		this.startwidth = originalrect.width * (startwidthpercent / 100);
	}

	if (ispercent(this.startheight))
	{
		var startheightpercent = spry.effect.utils.getpercentvalue(this.startheight);
		this.startheight = originalrect.height * (startheightpercent / 100);
	}

	if (ispercent(this.stopwidth))
	{
		var stopwidthpercent = spry.effect.utils.getpercentvalue(this.stopwidth);
		this.stopwidth = originalrect.width * (stopwidthpercent / 100);
	}

	if (ispercent(this.stopheight))
	{
		var stopheightpercent = spry.effect.utils.getpercentvalue(this.stopheight);
		this.stopheight = originalrect.height * (stopheightpercent / 100);
	}

	this.enforcevisible = spry.effect.isinvisible(this.element);
};

spry.effect.size.prototype = new spry.effect.animator();
spry.effect.size.prototype.constructor = spry.effect.size;

spry.effect.size.prototype.animate = function()
{
	var width = 0;
	var height = 0;
	var fontsize = 0;
	var direction = 0;
	var floor = math.floor;
	var elapsed = this.getelapsedmilliseconds();

	if (this.direction == spry.forwards) {
		width = floor(this.options.transition(elapsed, this.startwidth, this.stopwidth - this.startwidth, this.options.duration));
		height = floor(this.options.transition(elapsed, this.startheight, this.stopheight - this.startheight, this.options.duration));
		direction = 1;
	} else if (this.direction == spry.backwards) {
		width = floor(this.options.transition(elapsed, this.stopwidth, this.startwidth - this.stopwidth, this.options.duration));
		height = floor(this.options.transition(elapsed, this.stopheight, this.startheight - this.stopheight, this.options.duration));
		direction = -1;
	}

	var propfactor = width/this.originalwidth;
	fontsize = this.fontfactor * propfactor;

	var elstyle = this.element.style;
	if (width < 0)
		width = 0;
	
	if (height < 0)
		height = 0;

	elstyle.width = width + this.units;
	elstyle.height = height + this.units;

	if (typeof this.options.usecssbox != 'undefined' && this.options.usecssbox == true)
	{
		var intprop = spry.effect.intpropstyle;
		var origtop = intprop(this.element, 'top');
		var origleft = intprop(this.element, 'left');
		var origmargintop = intprop(this.element, 'margin-top');
		var origmarginleft = intprop(this.element, 'margin-left');

		var widthfactor = propfactor;
		var heightfactor = height / this.originalheight;
		var border_top = floor(this.startfromborder_top * heightfactor);
		var border_bottom = floor(this.startfromborder_bottom * heightfactor);
		var border_left = floor(this.startfromborder_left * widthfactor);
		var border_right = floor(this.startfromborder_right * widthfactor);
		var padding_top = floor(this.startfrompadding_top * heightfactor);
		var padding_bottom = floor(this.startfrompadding_bottom * heightfactor);
		var padding_left = floor(this.startfrompadding_left * widthfactor);
		var padding_right = floor(this.startfrompadding_right * widthfactor);
		var margin_top = floor(this.startfrommargin_top * heightfactor);
		var margin_bottom = floor(this.startfrommargin_bottom * heightfactor);
		var margin_right = floor(this.startfrommargin_right * widthfactor);
		var margin_left = floor(this.startfrommargin_left * widthfactor);

		elstyle.bordertopwidth = border_top + this.units;
		elstyle.borderbottomwidth = border_bottom + this.units;
		elstyle.borderleftwidth = border_left + this.units;
		elstyle.borderrightwidth = border_right + this.units;
		elstyle.paddingtop = padding_top + this.units;
		elstyle.paddingbottom = padding_bottom + this.units;
		elstyle.paddingleft = padding_left + this.units;
		elstyle.paddingright = padding_right + this.units;
		elstyle.margintop  = margin_top + this.units;
		elstyle.marginbottom = margin_bottom + this.units;
		elstyle.marginleft = margin_left + this.units;
		elstyle.marginright = margin_right + this.units;

		// compensate the margin shrinking
		elstyle.left = floor(origleft + origmarginleft - margin_left) + this.units;
		elstyle.top = floor(origtop + origmargintop - margin_top) + this.units;
	}

	if (this.options.scalecontent)
	{

		for(var i=0; i < this.childimages.length; i++)
		{
			this.childimages[i][0].style.width = propfactor * this.childimages[i][1] + this.units;
			this.childimages[i][0].style.height = propfactor * this.childimages[i][2] + this.units;
		}
		this.element.style.fontsize = fontsize + 'em';
	}

	if(this.enforcevisible)
	{
		spry.effect.enforcevisible(this.element);
		this.enforcevisible = false;
	}
};

spry.effect.size.prototype.preparestart = function()
{
	if (this.options && this.options.toggle)
		this.dotoggle();	

	if (this.dynamicfromrect == true)
	{
		var fromrect = spry.effect.getdimensions(this.element);
		this.startwidth = fromrect.width;
		this.startheight = fromrect.height;

		this.widthrange = this.startwidth - this.stopwidth;
		this.heightrange = this.startheight - this.stopheight;
	}
};

//////////////////////////////////////////////////////////////////////
//
// spry.effect.opacity
//
//////////////////////////////////////////////////////////////////////

spry.effect.opacity = function(element, startopacity, stopopacity, options)
{
	this.dynamicstartopacity = false;
	if (arguments.length == 3)
	{
		options = stopopacity;
		stopopacity = startopacity;
		startopacity = spry.effect.getopacity(element);
		this.dynamicstartopacity = true;
	}

	spry.effect.animator.call(this, options);

	this.name = 'opacity';
	this.element = spry.effect.getelement(element);
	if (!this.element)
		return;

 	// make this work on ie on elements without 'layout'
	if(/msie/.test(navigator.useragent) && (!this.element.haslayout))
		spry.effect.setstyleprop(this.element, 'zoom', '1');

	this.startopacity = startopacity;
	this.stopopacity = stopopacity;
	this.enforcevisible = spry.effect.isinvisible(this.element);
};

spry.effect.opacity.prototype = new spry.effect.animator();
spry.effect.opacity.prototype.constructor = spry.effect.opacity;

spry.effect.opacity.prototype.animate = function()
{
	var opacity = 0;
	var elapsed = this.getelapsedmilliseconds();
	if (this.direction == spry.forwards) 
		opacity = this.options.transition(elapsed, this.startopacity, this.stopopacity - this.startopacity, this.options.duration);
	else if (this.direction == spry.backwards) 
		opacity = this.options.transition(elapsed, this.stopopacity, this.startopacity - this.stopopacity, this.options.duration);

	if (opacity < 0)
		opacity = 0;

	if(/msie/.test(navigator.useragent))
	{
		var tmpval = spry.effect.getstyleprop(this.element,'filter');
		if (tmpval){
			tmpval = tmpval.replace(/alpha\(opacity=[0-9]{1,3}\)/g, '');
		}
		this.element.style.filter = tmpval + "alpha(opacity=" + math.floor(opacity * 100) + ")";
	}
	else
		this.element.style.opacity = opacity;

	if(this.enforcevisible)
	{
		spry.effect.enforcevisible(this.element);
		this.enforcevisible = false;
	}
};

spry.effect.opacity.prototype.preparestart = function()
{
	if (this.options && this.options.toggle)
		this.dotoggle();	

	if (this.dynamicstartopacity == true)
	{
		this.startopacity = spry.effect.getopacity(this.element);
		this.opacityrange = this.startopacity - this.stopopacity;
	}
};

//////////////////////////////////////////////////////////////////////
//
// spry.effect.color
//
//////////////////////////////////////////////////////////////////////

spry.effect.color = function(element, startcolor, stopcolor, options)
{
	this.dynamicstartcolor = false;
	if (arguments.length == 3)
	{
		options = stopcolor;
		stopcolor = startcolor;
		startcolor = spry.effect.getbgcolor(element);
		this.dynamicstartcolor = true;
	}
	
	spry.effect.animator.call(this, options);

	this.name = 'color';
	this.element = spry.effect.getelement(element);
	if (!this.element)
		return;

	this.startcolor = startcolor;
	this.stopcolor = stopcolor;
	this.startredcolor = spry.effect.utils.hextoint(startcolor.substr(1,2));
	this.startgreencolor = spry.effect.utils.hextoint(startcolor.substr(3,2));
	this.startbluecolor = spry.effect.utils.hextoint(startcolor.substr(5,2));
	this.stopredcolor = spry.effect.utils.hextoint(stopcolor.substr(1,2));
	this.stopgreencolor = spry.effect.utils.hextoint(stopcolor.substr(3,2));
	this.stopbluecolor = spry.effect.utils.hextoint(stopcolor.substr(5,2));
};

spry.effect.color.prototype = new spry.effect.animator();
spry.effect.color.prototype.constructor = spry.effect.color;

spry.effect.color.prototype.animate = function()
{
	var redcolor = 0;
	var greencolor = 0;
	var bluecolor = 0;
	var floor = math.floor;
	var elapsed = this.getelapsedmilliseconds();

	if (this.direction == spry.forwards)
	{
		redcolor = floor(this.options.transition(elapsed, this.startredcolor, this.stopredcolor - this.startredcolor, this.options.duration));
		greencolor = floor(this.options.transition(elapsed, this.startgreencolor, this.stopgreencolor - this.startgreencolor, this.options.duration));
		bluecolor = floor(this.options.transition(elapsed, this.startbluecolor, this.stopbluecolor - this.startbluecolor, this.options.duration));
	}
	else if (this.direction == spry.backwards)
	{
		redcolor = floor(this.options.transition(elapsed, this.stopredcolor, this.startredcolor - this.stopredcolor, this.options.duration));
		greencolor = floor(this.options.transition(elapsed, this.stopgreencolor, this.startgreencolor - this.stopgreencolor, this.options.duration));
		bluecolor = floor(this.options.transition(elapsed, this.stopbluecolor, this.startbluecolor - this.stopbluecolor, this.options.duration));
	}

	this.element.style.backgroundcolor = spry.effect.utils.rgb(redcolor, greencolor, bluecolor);
};

spry.effect.color.prototype.preparestart = function() 
{
	if (this.options && this.options.toggle)
		this.dotoggle();

	if (this.dynamicstartcolor == true)
	{
		this.startcolor = spry.effect.getbgcolor(element);
		this.startredcolor = spry.effect.utils.hextoint(startcolor.substr(1,2));
		this.startgreencolor = spry.effect.utils.hextoint(startcolor.substr(3,2));
		this.startbluecolor = spry.effect.utils.hextoint(startcolor.substr(5,2));
		this.redcolorrange = this.startredcolor - this.stopredcolor;
		this.greencolorrange = this.startgreencolor - this.stopgreencolor;
		this.bluecolorrange = this.startbluecolor - this.stopbluecolor;
	}
};

//////////////////////////////////////////////////////////////////////
//
// spry.effect.cluster
//
//////////////////////////////////////////////////////////////////////

spry.effect.cluster = function(options)
{
	spry.effect.animator.call(this, options);

	this.name = 'cluster';
	this.effectsarray = new array();
	this.curridx = -1;
	var _clusteredeffect = function(effect, kind)
	{
		this.effect = effect;
		this.kind = kind; // "parallel" or "queue"
		this.isrunning = false;
	};

	this.clusteredeffect = _clusteredeffect;
};

spry.effect.cluster.prototype = new spry.effect.animator();
spry.effect.cluster.prototype.constructor = spry.effect.cluster;

spry.effect.cluster.prototype.setinterval = function(interval){
	var l = this.effectsarray.length;
	this.options.interval = interval;
	for (var i = 0; i < l; i++)
	{
		this.effectsarray[i].effect.setinterval(interval);
	}
};
spry.effect.cluster.prototype.draweffect = function()
{
	var isrunning = true;
	var alleffectsdidrun = false;
	var baseeffectisstillrunning = false;
	var evalnexteffectsrunning = false;

	if ((this.curridx == -1 && this.direction == spry.forwards) || (this.curridx == this.effectsarray.length && this.direction == spry.backwards))
		this.initnexteffectsrunning();

	var start = this.direction == spry.forwards ? 0 : this.effectsarray.length-1;
	var stop = this.direction == spry.forwards ? this.effectsarray.length : -1;
	var step = this.direction == spry.forwards ? 1 : -1;
	for (var i = start; i != stop; i+=step)
	{
		if (this.effectsarray[i].isrunning == true)
		{
			baseeffectisstillrunning = this.effectsarray[i].effect.draweffect();
			if (baseeffectisstillrunning == false && i == this.curridx)
			{
				this.effectsarray[i].isrunning = false;
				evalnexteffectsrunning = true;
			}
		}
	}

	if (evalnexteffectsrunning == true)
		alleffectsdidrun = this.initnexteffectsrunning();

	if (alleffectsdidrun == true) {
		this.stop();
		isrunning = false;
		for (var i = 0; i < this.effectsarray.length; i++)
			this.effectsarray[i].isrunning = false;

		this.curridx = this.direction == spry.forwards ? this.effectsarray.length: -1;
	}
	return isrunning;
};

spry.effect.cluster.prototype.initnexteffectsrunning = function()
{
	var alleffectsdidrun = false;
	var step = this.direction == spry.forwards ? 1 : -1;
	var stop = this.direction == spry.forwards ? this.effectsarray.length : -1;
	this.curridx+=step;
	if ( (this.curridx > (this.effectsarray.length - 1) && this.direction == spry.forwards) || (this.curridx < 0 && this.direction == spry.backwards))
		alleffectsdidrun = true;
	else
		for (var i = this.curridx; i != stop; i+=step)
		{
			if ((i > this.curridx && this.direction == spry.forwards || i < this.curridx && this.direction == spry.backwards) && this.effectsarray[i].kind == "queue")
				break;
			this.effectsarray[i].effect.start(true);
			this.effectsarray[i].isrunning = true;
			this.curridx = i;
		}

	return alleffectsdidrun;
};

spry.effect.cluster.prototype.togglecluster = function()
{
	if (!this.direction)
	{
		this.direction = spry.forwards;
		return;
	}

	if (this.options.toggle == true)
	{
		if (this.direction == spry.forwards)
		{
			this.direction = spry.backwards;
			this.notifyobservers('ontoggle', this);
			this.curridx = this.effectsarray.length;
		}
		else if (this.direction == spry.backwards)
		{
			this.direction = spry.forwards;
			this.curridx = -1;
		}
	}
	else
	{
		if (this.direction == spry.forwards)
			this.curridx = -1;
		else if (this.direction == spry.backwards)
			this.curridx = this.effectsarray.length;
	}
};

spry.effect.cluster.prototype.dotoggle = function()
{
	this.togglecluster();

	// toggle all effects of the cluster, too
	for (var i = 0; i < this.effectsarray.length; i++)
	{
		if (this.effectsarray[i].effect.options && (this.effectsarray[i].effect.options.toggle != null))
			if (this.effectsarray[i].effect.options.toggle == true)
				this.effectsarray[i].effect.dotoggle();
	}
};

spry.effect.cluster.prototype.cancel = function()
{
	for (var i = 0; i < this.effectsarray.length; i++)
		if (this.effectsarray[i].effect.isrunning)
			this.effectsarray[i].effect.cancel();
	
	var elapsed = this.getelapsedmilliseconds();
	if (this.startmilliseconds > 0 && elapsed < this.options.duration)
		this.cancelremaining = this.options.transition(elapsed, 0, 1, this.options.duration);
	this.stopflagreset();
	this.notifyobservers('oncancel', this);
	this.isrunning = false;
};

spry.effect.cluster.prototype.addnexteffect = function(effect)
{
	effect.addobserver(this);
	this.effectsarray[this.effectsarray.length] = new this.clusteredeffect(effect, "queue");
	if (this.effectsarray.length == 1)
	{
		// with the first added effect we know the element
		// that the cluster is working on
		this.element = effect.element;
	}
};

spry.effect.cluster.prototype.addparalleleffect = function(effect)
{
	if (this.effectsarray.length == 0 || this.effectsarray[this.effectsarray.length-1].kind != 'parallel')
		effect.addobserver(this);

	this.effectsarray[this.effectsarray.length] = new this.clusteredeffect(effect, "parallel");
	if (this.effectsarray.length == 1)
	{
		// with the first added effect we know the element
		// that the cluster is working on
		this.element = effect.element;
	}
};

spry.effect.cluster.prototype.preparestart = function()
{
	this.togglecluster();
};

//////////////////////////////////////////////////////////////////////
//
// combination effects
// custom effects can be build by combining basic effect bahaviour
// like move, size, color, opacity
//
//////////////////////////////////////////////////////////////////////

spry.effect.fade = function (element, options) 
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('fade');

	spry.effect.cluster.call(this, options);

	this.name = 'fade';
	var element = spry.effect.getelement(element);
	this.element = element;
	if (!this.element)
		return;
	var durationinmilliseconds = 1000;
	var fromopacity = 0.0;
	var toopacity = 100.0;
	var dotoggle = false;
	var transition = spry.fifthtransition;
	var fps = 60;
	var originalopacity = 0;
	if(/msie/.test(navigator.useragent))
		originalopacity = parseint(spry.effect.getstylepropregardlessofdisplaystate(this.element, 'filter').replace(/alpha\(opacity=([0-9]{1,3})\)/g, '$1'), 10);
	else
		originalopacity = parseint(spry.effect.getstylepropregardlessofdisplaystate(this.element, 'opacity') * 100, 10);

	if (isnan(originalopacity))
		originalopacity = 100;

	if (options)
	{
		if (options.duration != null) durationinmilliseconds = options.duration;
		if (options.from != null){
			if (spry.effect.utils.ispercentvalue(options.from))
				fromopacity = spry.effect.utils.getpercentvalue(options.from) * originalopacity / 100;
			else
				fromopacity = options.from;
		}
		if (options.to != null)
		{	
			if (spry.effect.utils.ispercentvalue(options.to))
				toopacity = spry.effect.utils.getpercentvalue(options.to) * originalopacity / 100;
			else
				toopacity = options.to;
		}
		if (options.toggle != null) dotoggle = options.toggle;
		if (options.transition != null) transition = options.transition;
		if (options.fps != null) fps = options.fps;
		else this.options.transition = transition;
	}

	fromopacity = fromopacity/ 100.0;
	toopacity = toopacity / 100.0;

	options = {duration: durationinmilliseconds, toggle: dotoggle, transition: transition, from: fromopacity, to: toopacity, fps: fps};
	var fadeeffect = new spry.effect.opacity(element, fromopacity, toopacity, options);
	this.addnexteffect(fadeeffect);
};

spry.effect.fade.prototype = new spry.effect.cluster();
spry.effect.fade.prototype.constructor = spry.effect.fade;

spry.effect.blind = function (element, options)
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('blind'); 

	spry.effect.cluster.call(this, options);

	this.name = 'blind';
	var element = spry.effect.getelement(element);
	this.element = element;
	if (!this.element)
		return;
	var durationinmilliseconds = 1000;
	var dotoggle = false;
	var kindoftransition = spry.circletransition;
	var fps = 60;
	var doscalecontent = false;

	spry.effect.makeclipping(element);

	var originalrect = spry.effect.getdimensionsregardlessofdisplaystate(element);
	var fromheightpx  = originalrect.height;
	var toheightpx    = 0;
	var optionfrom = options ? options.from : originalrect.height;
	var optionto   = options ? options.to : 0;
	var fullcssbox = false;


	if (options)
	{
		if (options.duration != null) durationinmilliseconds = options.duration;
		if (options.from != null)
		{
			if (spry.effect.utils.ispercentvalue(options.from))
				fromheightpx = spry.effect.utils.getpercentvalue(options.from) * originalrect.height / 100;
			else
				fromheightpx = spry.effect.utils.getpixelvalue(options.from);
		}
		if (options.to != null)
		{
			if (spry.effect.utils.ispercentvalue(options.to))
				toheightpx = spry.effect.utils.getpercentvalue(options.to) * originalrect.height / 100;
			else
				toheightpx = spry.effect.utils.getpixelvalue(options.to);
		}
		if (options.toggle != null) dotoggle = options.toggle;
		if (options.transition != null) kindoftransition = options.transition;
		if (options.fps != null) fps = options.fps;
		if (options.usecssbox != null) fullcssbox = options.usecssbox;
	}

	var fromrect = new spry.effect.utils.rectangle;
	fromrect.width = originalrect.width;
	fromrect.height = fromheightpx;

	var torect = new spry.effect.utils.rectangle;
	torect.width = originalrect.width;
	torect.height = toheightpx;

	options = {duration:durationinmilliseconds, toggle:dotoggle, transition:kindoftransition, scalecontent:doscalecontent, usecssbox: fullcssbox, from: optionfrom, to: optionto, fps: fps};
	var blindeffect = new spry.effect.size(element, fromrect, torect, options);
	this.addnexteffect(blindeffect);
};

spry.effect.blind.prototype = new spry.effect.cluster();
spry.effect.blind.prototype.constructor = spry.effect.blind;

spry.effect.highlight = function (element, options) 
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('highlight'); 

	spry.effect.cluster.call(this, options);

	this.name = 'highlight';
	var durationinmilliseconds = 1000;
	var tocolor = "#ffffff";
	var dotoggle = false;
	var kindoftransition = spry.sinusoidaltransition;
	var fps = 60;
	var element = spry.effect.getelement(element);
	this.element = element;
	if (!this.element)
		return;
	var fromcolor = spry.effect.getbgcolor(element);
	if (fromcolor == "transparent") fromcolor = "#ffff99";

	if (options)
	{
		if (options.duration != null) durationinmilliseconds = options.duration;
		if (options.from != null) fromcolor = options.from;
		if (options.to != null) tocolor = options.to;
		if (options.toggle != null) dotoggle = options.toggle;
		if (options.transition != null) kindoftransition = options.transition;
		if (options.fps != null) fps = options.fps;
	}

	if ( fromcolor.indexof('rgb') != -1 )
		var fromcolor = spry.effect.utils.rgb(parseint(fromcolor.substring(fromcolor.indexof('(')+1, fromcolor.indexof(',')),10), parseint(fromcolor.substring(fromcolor.indexof(',')+1, fromcolor.lastindexof(',')),10), parseint(fromcolor.substring(fromcolor.lastindexof(',')+1, fromcolor.indexof(')')),10));

	if ( tocolor.indexof('rgb') != -1 )
		var tocolor = spry.effect.utils.rgb(parseint(tocolor.substring(tocolor.indexof('(')+1, tocolor.indexof(',')),10), parseint(tocolor.substring(tocolor.indexof(',')+1, tocolor.lastindexof(',')),10), parseint(tocolor.substring(tocolor.lastindexof(',')+1, tocolor.indexof(')')),10));

	var fromcolor = spry.effect.utils.longcolorversion(fromcolor);
	var tocolor = spry.effect.utils.longcolorversion(tocolor);

	this.restorebackgroundimage = spry.effect.getstyleprop(element, 'background-image');

	options = {duration: durationinmilliseconds, toggle: dotoggle, transition: kindoftransition, fps: fps};
	var highlighteffect = new spry.effect.color(element, fromcolor, tocolor, options);
	this.addnexteffect(highlighteffect);

	this.addobserver({
		onpreeffect:
		function(effect){
			spry.effect.setstyleprop(effect.element, 'background-image', 'none');
		},
		onposteffect:
		function(effect){
			spry.effect.setstyleprop(effect.element, 'background-image', effect.restorebackgroundimage);

			if (effect.direction == spry.forwards && effect.options.restorecolor)
				spry.effect.setstyleprop(element, 'background-color', effect.options.restorecolor);		
		}
	});
};

spry.effect.highlight.prototype = new spry.effect.cluster();
spry.effect.highlight.prototype.constructor = spry.effect.highlight;

spry.effect.slide = function (element, options) 
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('slide'); 

	spry.effect.cluster.call(this, options);

	this.name = 'slide';
	var element = spry.effect.getelement(element);
	this.element = element;
	if (!this.element)
		return;
	var durationinmilliseconds = 1000;
	var dotoggle = false;
	var kindoftransition = spry.sinusoidaltransition;
	var fps = 60;
	var slidehorizontally = false;
	var firstchildelt = spry.effect.utils.getfirstchildelement(element);
	var direction = -1;

	// ie 7 does not clip static positioned elements -> make element position relative
	if(/msie 7.0/.test(navigator.useragent) && /windows nt/.test(navigator.useragent))
		spry.effect.makepositioned(element);

	spry.effect.makeclipping(element);

	// for ie 6 on win: check if position is static or fixed -> not supported and would cause trouble
	if(/msie 6.0/.test(navigator.useragent) && /windows nt/.test(navigator.useragent))
	{
		var pos = spry.effect.getstyleprop(element, 'position');
		if(pos && (pos == 'static' || pos == 'fixed'))
		{
			spry.effect.setstyleprop(element, 'position', 'relative');
			spry.effect.setstyleprop(element, 'top', '');
			spry.effect.setstyleprop(element, 'left', '');
		}
	}

	if(firstchildelt)
	{
		spry.effect.makepositioned(firstchildelt);
		spry.effect.makeclipping(firstchildelt);
  
		var childrect = spry.effect.getdimensionsregardlessofdisplaystate(firstchildelt, element);
		spry.effect.setstyleprop(firstchildelt, 'width', childrect.width + 'px');
	}

	var fromdim = spry.effect.getdimensionsregardlessofdisplaystate(element);

	var initdim = new spry.effect.utils.rectangle();
	var todim = new spry.effect.utils.rectangle();
	initdim.width = todim.width = fromdim.width;
	initdim.height = todim.height = fromdim.height;

	if (!this.options.to){
		if (!options)
			options = {};

		options.to = '0%';
	}

	if (options && options.horizontal !== null && options.horizontal === true)
		slidehorizontally = true;

	if (options.duration != null) durationinmilliseconds = options.duration;

	if (options.from != null)
	{
		if(slidehorizontally)
		{
				if (spry.effect.utils.ispercentvalue(options.from))
					fromdim.width = initdim.width * spry.effect.utils.getpercentvalue(options.from) / 100;
				else
					fromdim.width = spry.effect.utils.getpixelvalue(options.from);
		}
		else
		{
				if (spry.effect.utils.ispercentvalue(options.from))
					fromdim.height = initdim.height * spry.effect.utils.getpercentvalue(options.from) / 100;
				else
					fromdim.height = spry.effect.utils.getpixelvalue(options.from);
		}
	}

	if (options.to != null)
	{
			if(slidehorizontally)
			{
				if (spry.effect.utils.ispercentvalue(options.to))
					todim.width = initdim.width * spry.effect.utils.getpercentvalue(options.to) / 100;
				else
					todim.width = spry.effect.utils.getpixelvalue(options.to);
			}
			else
			{
				if (spry.effect.utils.ispercentvalue(options.to))
					todim.height = initdim.height * spry.effect.utils.getpercentvalue(options.to) / 100;
				else
					todim.height = spry.effect.utils.getpixelvalue(options.to);
		}
	}
	if (options.toggle != null) dotoggle = options.toggle;
	if (options.transition != null) kindoftransition = options.transition;
	if (options.fps != null) fps = options.fps;

	options = {duration: durationinmilliseconds, transition: kindoftransition, scalecontent: false, toggle:dotoggle, fps: fps};
	var size = new spry.effect.size(element, fromdim, todim, options);
	this.addparalleleffect(size);

	if ( (fromdim.width < todim.width && slidehorizontally) || (fromdim.height < todim.height && !slidehorizontally))
		direction = 1;
	
	var frompos = new spry.effect.utils.position();
	var topos = new spry.effect.utils.position();
	topos.x = frompos.x = spry.effect.intpropstyle(firstchildelt, 'left');
	topos.y = frompos.y = spry.effect.intpropstyle(firstchildelt, 'top');
	topos.units = frompos.units;

	if (slidehorizontally)
		topos.x = parseint(frompos.x + direction * (fromdim.width - todim.width), 10);
	else
		topos.y = parseint(frompos.y + direction * (fromdim.height - todim.height), 10);

	if (direction == 1){
		var tmp = frompos;
		var frompos = topos;
		var topos = tmp;
	}

	options = {duration: durationinmilliseconds, transition: kindoftransition, toggle:dotoggle, from: frompos, to: topos, fps: fps};
	var move = new spry.effect.move(firstchildelt, frompos, topos, options);
	this.addparalleleffect(move);
};

spry.effect.slide.prototype = new spry.effect.cluster();
spry.effect.slide.prototype.constructor = spry.effect.slide;

spry.effect.grow = function (element, options) 
{
	if (!element)
		return;
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('grow');

	spry.effect.cluster.call(this, options);

	this.name = 'grow';
	var durationinmilliseconds = 1000;
	var dotoggle = false;
	var doscalecontent = true;
	var calcheight = false;
	var growfromcenter = true;
	var fullcssbox = false;
	var kindoftransition = spry.squaretransition;
	var fps = 60;
	var element = spry.effect.getelement(element);
	this.element = element;
	if (!this.element)
		return;

	spry.effect.makeclipping(element);

	var dimrect = spry.effect.getdimensionsregardlessofdisplaystate(element);
	var originalwidth = dimrect.width;
	var originalheight = dimrect.height;
	var propfactor = (originalwidth == 0) ? 1 :originalheight/originalwidth;

	var fromrect = new spry.effect.utils.rectangle;
	fromrect.width = 0;
	fromrect.height = 0;

	var torect = new spry.effect.utils.rectangle;
	torect.width = originalwidth;
	torect.height = originalheight;

	var optionfrom = options ? options.from : dimrect.width;
	var optionto   = options ? options.to : 0;
	var pixelvalue = spry.effect.utils.getpixelvalue;

	if (options)
	{
		if (options.growcenter != null) growfromcenter = options.growcenter;
		if (options.duration != null) durationinmilliseconds = options.duration;
		if (options.usecssbox != null) fullcssbox = options.usecssbox;
		if (options.scalecontent != null) doscalecontent = options.scalecontent;
		if (options.from != null) 
		{
			if (spry.effect.utils.ispercentvalue(options.from))
			{
				fromrect.width = originalwidth * (spry.effect.utils.getpercentvalue(options.from) / 100);
				fromrect.height = originalheight * (spry.effect.utils.getpercentvalue(options.from) / 100);
			}
			else
			{
				if(calcheight)
				{
					fromrect.height = pixelvalue(options.from);
					fromrect.width  = pixelvalue(options.from) / propfactor;
				}
				else
				{
					fromrect.width = pixelvalue(options.from);
					fromrect.height = propfactor * pixelvalue(options.from);
				}
			}
		}
		if (options.to != null)
		{
			if (spry.effect.utils.ispercentvalue(options.to))
			{
				torect.width = originalwidth * (spry.effect.utils.getpercentvalue(options.to) / 100);
				torect.height = originalheight * (spry.effect.utils.getpercentvalue(options.to) / 100);
			}
			else
			{
				if(calcheight)
				{
					torect.height = pixelvalue(options.to);
					torect.width  = pixelvalue(options.to) / propfactor;
				}
				else
				{
					torect.width = pixelvalue(options.to);
					torect.height = propfactor * pixelvalue(options.to);
				}
			}
		}
		if (options.toggle != null) dotoggle = options.toggle;
		if (options.transition != null) kindoftransition = options.transition;
		if (options.fps != null) fps = options.fps;
	}

	options = {duration:durationinmilliseconds, toggle:dotoggle, transition:kindoftransition, scalecontent:doscalecontent, usecssbox: fullcssbox, fps: fps};
	var sizeeffect = new spry.effect.size(element, fromrect, torect, options);
	this.addparalleleffect(sizeeffect);

	if(growfromcenter)
	{
		spry.effect.makepositioned(element);

		var startoffsetposition = new spry.effect.utils.position();
		startoffsetposition.x = parseint(spry.effect.getstylepropregardlessofdisplaystate(element, "left"), 10);
		startoffsetposition.y = parseint(spry.effect.getstylepropregardlessofdisplaystate(element, "top"), 10);	
		if (!startoffsetposition.x) startoffsetposition.x = 0;
		if (!startoffsetposition.y) startoffsetposition.y = 0;

		options = {duration:durationinmilliseconds, toggle:dotoggle, transition:kindoftransition, from: optionfrom, to: optionto, fps: fps};
		var frompos = new spry.effect.utils.position;
		frompos.x = startoffsetposition.x + (originalwidth - fromrect.width) / 2.0;
		frompos.y = startoffsetposition.y + (originalheight - fromrect.height) / 2.0;

		var topos = new spry.effect.utils.position;
		topos.x = startoffsetposition.x + (originalwidth - torect.width) / 2.0;
		topos.y = startoffsetposition.y + (originalheight - torect.height) / 2.0;

		var moveeffect = new spry.effect.move(element, frompos, topos, options);
		this.addparalleleffect(moveeffect);
	}
};

spry.effect.grow.prototype = new spry.effect.cluster();
spry.effect.grow.prototype.constructor = spry.effect.grow;

spry.effect.shake = function (element, options) 
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('shake'); 

	spry.effect.cluster.call(this, options);

	// toggle is not supported
	this.options.direction = false;
	if (this.options.toggle)
		this.options.toggle = false;

	this.name = 'shake';

	var element = spry.effect.getelement(element);
	this.element = element;
	if (!this.element)
		return;
	var durationinmilliseconds = 100;
	var kindoftransition = spry.lineartransition;
	var fps = 60;
	var steps = 4;

	if (options)
	{
		if (options.duration != null) steps = math.ceil(this.options.duration / durationinmilliseconds) - 1;
		if (options.fps != null) fps = options.fps;
		if (options.transition != null) kindoftransition = options.transition;
	}

	spry.effect.makepositioned(element);
	
	var startoffsetposition = new spry.effect.utils.position();
	startoffsetposition.x = parseint(spry.effect.getstyleprop(element, "left"), 10);
	startoffsetposition.y = parseint(spry.effect.getstyleprop(element, "top"), 10);
	if (!startoffsetposition.x) startoffsetposition.x = 0;
	if (!startoffsetposition.y) startoffsetposition.y = 0;

	var centerpos = new spry.effect.utils.position;
	centerpos.x = startoffsetposition.x;
	centerpos.y = startoffsetposition.y;

	var rightpos = new spry.effect.utils.position;
	rightpos.x = startoffsetposition.x + 20;
	rightpos.y = startoffsetposition.y + 0;

	var leftpos = new spry.effect.utils.position;
	leftpos.x = startoffsetposition.x + -20;
	leftpos.y = startoffsetposition.y + 0;

	options = {duration:math.ceil(durationinmilliseconds / 2), toggle:false, fps: fps, transition: kindoftransition};
	var effect = new spry.effect.move(element, centerpos, rightpos, options);
	this.addnexteffect(effect);

	options = {duration:durationinmilliseconds, toggle:false, fps:fps, transition: kindoftransition};
	var effecttoright = new spry.effect.move(element, rightpos, leftpos, options);
	var effecttoleft = new spry.effect.move(element, leftpos, rightpos, options);

	for (var i=0; i < steps; i++)
	{
		if (i % 2 == 0)
			this.addnexteffect(effecttoright);
		else
			this.addnexteffect(effecttoleft);
	}
	var pos = (steps % 2 == 0) ? rightpos: leftpos;

	options = {duration:math.ceil(durationinmilliseconds / 2), toggle:false, fps: fps, transition: kindoftransition};
	var effect = new spry.effect.move(element, pos, centerpos, options);
	this.addnexteffect(effect);
};
spry.effect.shake.prototype = new spry.effect.cluster();
spry.effect.shake.prototype.constructor = spry.effect.shake;
spry.effect.shake.prototype.dotoggle = function(){};

spry.effect.squish = function (element, options) 
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('squish');

	if (!options)
		options = {};
	if (!options.to)
		options.to = '0%';
	if (!options.from)
		options.from = '100%';

	options.growcenter = false;
	spry.effect.grow.call(this, element, options);
	this.name = 'squish';
};
spry.effect.squish.prototype = new spry.effect.grow();
spry.effect.squish.prototype.constructor = spry.effect.squish;

spry.effect.pulsate = function (element, options) 
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('pulsate');

	spry.effect.cluster.call(this, options);

	// toggle is not supported
	this.options.direction = false;
	if (this.options.toggle)
		this.options.toggle = false;

	var element = spry.effect.getelement(element);
	var originalopacity = 0;
	this.element = element;
	if (!this.element)
		return;

	this.name = 'pulsate';
	var durationinmilliseconds = 100;
	var fromopacity = 100.0;
	var toopacity = 0.0;
	var dotoggle = false;
	var kindoftransition = spry.lineartransition;
	var fps = 60;
	if(/msie/.test(navigator.useragent))
		originalopacity = parseint(spry.effect.getstylepropregardlessofdisplaystate(this.element, 'filter').replace(/alpha\(opacity=([0-9]{1,3})\)/g, '$1'), 10);
	else
		originalopacity = parseint(spry.effect.getstylepropregardlessofdisplaystate(this.element, 'opacity') * 100, 10);

	if (isnan(originalopacity)){
		originalopacity = 100;
	}

	if (options)
	{
		if (options.from != null){
			if (spry.effect.utils.ispercentvalue(options.from))
				fromopacity = spry.effect.utils.getpercentvalue(options.from) * originalopacity / 100;
			else
				fromopacity = options.from;
		}
		if (options.to != null)
		{	
			if (spry.effect.utils.ispercentvalue(options.to))
				toopacity = spry.effect.utils.getpercentvalue(options.to) * originalopacity / 100;
			else
				toopacity = options.to;
		}
		if (options.transition != null) kindoftransition = options.transition;
		if (options.fps != null) fps = options.fps;
	}

	options = {duration:durationinmilliseconds, toggle:dotoggle, transition:kindoftransition, fps:fps};
	fromopacity = fromopacity / 100.0;
	toopacity = toopacity / 100.0;

	var fadeeffect = new spry.effect.opacity(element, fromopacity, toopacity, options);
	var appeareffect = new spry.effect.opacity(element, toopacity, fromopacity, options);
	var steps = parseint(this.options.duration / 200, 10);
	for (var i=0; i < steps; i++){ 
		this.addnexteffect(fadeeffect);
		this.addnexteffect(appeareffect);
	}
};
spry.effect.pulsate.prototype = new spry.effect.cluster();
spry.effect.pulsate.prototype.constructor = spry.effect.pulsate;
spry.effect.pulsate.prototype.dotoggle = function(){};

spry.effect.puff = function (element, options)
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('puff'); 

	spry.effect.cluster.call(this, options);

	var element = spry.effect.getelement(element);
	this.element = element;	
	if (!this.element)
		return;
	this.name = 'puff';
	var dotoggle = false;
	var doscalecontent = false;
	var durationinmilliseconds = 1000;
	var kindoftransition = spry.fifthtransition;
	var fps = 60;

	spry.effect.makepositioned(element); // for move

	if (options){
		if (options.toggle != null) dotoggle = options.toggle;
		if (options.duration != null) durationinmilliseconds = options.duration;
		if (options.transition != null) kindoftransition = options.transition;
		if (options.fps != null) fps = options.fps;
	}
	var originalrect = spry.effect.getdimensions(element);
	var startwidth = originalrect.width;
	var startheight = originalrect.height;

	options = {duration:durationinmilliseconds, toggle:dotoggle, transition: kindoftransition, fps: fps};

	var fromopacity = 1.0;
	var toopacity = 0.0;
	var opacityeffect = new spry.effect.opacity(element, fromopacity, toopacity, options);
	this.addparalleleffect(opacityeffect);

	var frompos = spry.effect.getposition(element);

	var topos = new spry.effect.utils.position;
	topos.x = startwidth / 2.0 * -1.0;
	topos.y = startheight / 2.0 * -1.0;

	options = {duration:durationinmilliseconds, toggle:dotoggle, transition:kindoftransition, from: frompos, to: topos, fps: fps};
	var moveeffect = new spry.effect.move(element, frompos, topos, options);
	this.addparalleleffect(moveeffect);

	var self = this;
	this.addobserver({
		onpreeffect:function(){if (self.direction == spry.backwards){self.element.style.display = 'block';}},
		onposteffect: function(){if (self.direction == spry.forwards){self.element.style.display = 'none';}}
	});
};
spry.effect.puff.prototype = new spry.effect.cluster;
spry.effect.puff.prototype.constructor = spry.effect.puff;

spry.effect.dropout = function (element, options)
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('dropout');

	spry.effect.cluster.call(this, options);

	var element = spry.effect.getelement(element);
	this.element = element;
	if (!this.element)
		return;
	var durationinmilliseconds = 1000;
	var fps = 60;
	var kindoftransition = spry.fifthtransition;
	var direction = spry.forwards;
	var dotoggle = false;
	this.name = 'dropout';

	spry.effect.makepositioned(element);

	if (options)
	{
		if (options.duration != null) durationinmilliseconds = options.duration;
		if (options.toggle != null) dotoggle = options.toggle;
		if (options.fps != null) fps = options.fps;
		if (options.transition != null) kindoftransition = options.transition;
		if (options.dropin != null) direction = -1;
	}

	var startoffsetposition = new spry.effect.utils.position();
	startoffsetposition.x = parseint(spry.effect.getstyleprop(element, "left"), 10);
	startoffsetposition.y = parseint(spry.effect.getstyleprop(element, "top"), 10);	
	if (!startoffsetposition.x) startoffsetposition.x = 0;
	if (!startoffsetposition.y) startoffsetposition.y = 0;

	var frompos = new spry.effect.utils.position;
	frompos.x = startoffsetposition.x + 0;
	frompos.y = startoffsetposition.y + 0;

	var topos = new spry.effect.utils.position;
	topos.x = startoffsetposition.x + 0;
	topos.y = startoffsetposition.y + (direction * 160);

	options = {from:frompos, to:topos, duration:durationinmilliseconds, toggle:dotoggle, transition: kindoftransition, fps: fps};
	var moveeffect = new spry.effect.move(element, options.from, options.to, options);
	this.addparalleleffect(moveeffect);

	var fromopacity = 1.0;
	var toopacity = 0.0;
	options = {duration:durationinmilliseconds, toggle:dotoggle, transition: kindoftransition, fps: fps};
	var opacityeffect = new spry.effect.opacity(element, fromopacity, toopacity, options);
	this.addparalleleffect(opacityeffect);

	var self = this;
	this.addobserver({
		onpreeffect:function(){self.element.style.display = 'block';},
		onposteffect: function(){if (self.direction == spry.forwards){self.element.style.display = 'none';}}
	});

};
spry.effect.dropout.prototype = new spry.effect.cluster();
spry.effect.dropout.prototype.constructor = spry.effect.dropout;

spry.effect.fold = function (element, options)
{
	if (!this.notstaticanimator)
		return spry.effect.utils.showiniterror('fold');

	spry.effect.cluster.call(this, options);

	var element = spry.effect.getelement(element);
	this.element = element;
	if (!this.element)
		return;
	this.name = 'fold';
	var durationinmilliseconds = 1000;
	var dotoggle = false;
	var doscalecontent = true;
	var fullcssbox = false;
	var kindoftransition = spry.fifthtransition;
	var fps = fps;
	
	spry.effect.makeclipping(element);

	var originalrect = spry.effect.getdimensionsregardlessofdisplaystate(element);
	var startwidth = originalrect.width;
	var startheight = originalrect.height;

	var stopwidth = startwidth;
	var stopheight = startheight / 5;

	var fromrect = new spry.effect.utils.rectangle;
	fromrect.width = startwidth;
	fromrect.height = startheight;

	var torect = new spry.effect.utils.rectangle;
	torect.width = stopwidth;
	torect.height = stopheight;

	if (options)
	{
		if (options.duration != null) durationinmilliseconds = math.ceil(options.duration/2);
		if (options.toggle != null) dotoggle = options.toggle;
		if (options.usecssbox != null) fullcssbox = options.usecssbox; 
		if (options.fps != null) fps = options.fps;
		if (options.transition != null) kindoftransition = options.transition;
	}

	options = {duration:durationinmilliseconds, toggle:dotoggle, scalecontent:doscalecontent, usecssbox: fullcssbox, transition: kindoftransition, fps: fps};
	var sizeeffect = new spry.effect.size(element, fromrect, torect, options);
	this.addnexteffect(sizeeffect);

	fromrect.width = torect.width;
	fromrect.height = torect.height;
	torect.width = '0%';
	var sizeeffect = new spry.effect.size(element, fromrect, torect, options);
	this.addnexteffect(sizeeffect);
};

spry.effect.fold.prototype = new spry.effect.cluster();
spry.effect.fold.prototype.constructor = spry.effect.fold;

//////////////////////////////////////////////////////////////
// 																													//
// the names of some of the static effect functions 		 		//
// changed in spry 1.5. these wrappers will insure that we 	//
// remain compatible with previous versions of spry.				//
// 																													//
//////////////////////////////////////////////////////////////

spry.effect.dofade = function (element, options)
{
	return spry.effect.utils.doeffect('fade', element, options);
};

spry.effect.doblind = function (element, options)
{
	return spry.effect.utils.doeffect('blind', element, options);
};

spry.effect.dohighlight = function (element, options)
{
	return spry.effect.utils.doeffect('highlight', element, options);
};

spry.effect.doslide = function (element, options)
{
	return spry.effect.utils.doeffect('slide', element, options);
};

spry.effect.dogrow = function (element, options)
{
	return spry.effect.utils.doeffect('grow', element, options);
};

spry.effect.doshake = function (element, options)
{
	return spry.effect.utils.doeffect('shake', element, options);
};

spry.effect.dosquish = function (element, options)
{
	return spry.effect.utils.doeffect('squish', element, options);
};

spry.effect.dopulsate = function (element, options)
{
	return spry.effect.utils.doeffect('pulsate', element, options);
};

spry.effect.dopuff = function (element, options)
{
	return spry.effect.utils.doeffect('puff', element, options);
};

spry.effect.dodropout = function (element, options)
{
	return spry.effect.utils.doeffect('dropout', element, options);
};

spry.effect.dofold = function (element, options)
{
	return spry.effect.utils.doeffect('fold', element, options);
};

})(); // endsprycomponent