// Spry.Effect.js - version 0.38 - 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.







var Spry;







if (!Spry) Spry = {};







Spry.forwards = 1; // const



Spry.backwards = 2; // const







if (!Spry.Effect) Spry.Effect = {};







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) + ")";

		if(opacity == 1) try{ this.element.style.removeAttribute("filter"); } catch(err) {}

	}



	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);



};