/*


	The effects in this file are used in:


	


	* categoryproductsflyout.isml


	


	FYI:


		"restoreAfterFinish" is only used by Scale and all its subclasses and puts the element 


			back where it was the size that it was.


 


	Bugs:


		SlideLeftIn still doesn't work on IE ???


		mblechschmidt 2009-01-22: The down function was the problem. It has be commented


		out. Now it also works in internet explorer 


		'delete' does not work on IE


 


		Cannot set styles of table items in Builder.node due to IE bug


 


		stray commas after last item in lists causes IE to fail


 


 


		Effect.toggle on these effects doesn't seem to work quite right


			(  Effect.toggle('demo-effect-curtainopen','slideleft')  )


 


		Not allowing Effect.Curtain* to finish before clicking again causes a problem.


 


		Not allowing MOST effects to finish before clicking again causes a problem.


*/


 


 


/* This declaration doesn't show up correctly when using Firebug */


/* 


	Also, these toggles don't seem to work right either


	OK:  slideup, slidedown, slideright


	NOT: slideleft, curtain


*/


Effect.PAIRS = Object.extend(


	Effect.PAIRS, { 


		'slidedown':  ['SlideDownIn',  'SlideDownOut'],


		'slideup':    ['SlideUpIn',    'SlideUpOut'],


		'slideleft':  ['SlideLeftIn',  'SlideLeftOut'],


		'slideright': ['SlideRightIn', 'SlideRightOut'],


		'curtain':    ['CurtainClose', 'CurtainOpen']


	}


);


 


 


Object.extend(


	Effect, {


		_elementIsNotAListError: {


			name: 'ElementIsNotAListError',


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


		}


  }


);


 


 


Effect.PulseList = Class.create();


Object.extend(Object.extend(Effect.PulseList.prototype, Effect.Base.prototype), {


	initialize: function(element) {


		this.element = $(element);


		if(!this.element) throw(Effect._elementDoesNotExistError);


//		if( (this.element.tagName != "UL") && (this.element.tagName != "OL") )


		if( ! ['UL','OL'].include(this.element.tagName) )


			throw(Effect._elementIsNotAListError);


		if ( ! this.element.effectOn ) {


			this.element.effectOn = true;


			var options = Object.extend({


				_pulse: 1,


				direction: "down",		// up or down


				pulses: 1,


				continuous: false,


				bounce: false,


				duration: 2,


				min_opacity: 0.1


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


			this.start(options);


		}


	},


	setup: function() {


		var num_items = this.element.immediateDescendants().size();


		var i = 1;


		var self = this;


		this.element.immediateDescendants().each( function(myitem){


			var mydelay = (self.options.direction == "down" ) 


				? (i++ - 1)/num_items


				: (num_items - i++)/num_items;


			var reverser   = function(pos){ return Effect.Transitions.sinoidal(1-Effect.Transitions.pulse(pos, 1)) }


			new Effect.Opacity(myitem, 


				Object.extend(Object.extend({


					delay: mydelay, 


					duration: self.options.duration, 


					from: self.options.min_opacity,


					afterFinishInternal: function(effect) {


						if ( ! ( self.options.direction == 'down' ? myitem.next() : myitem.previous() ) ) {


							if ( ( self.options.continuous ) || ( self.options._pulse++ < self.options.pulses ) ){


								if ( self.options.bounce) 


									self.options.direction = ( self.options.direction == 'up' ) ? 'down' : 'up';


								new Effect.PulseList(effect.element.parentNode, self.options || {} );


							}


						}


					}


				}, {}), {transition: reverser})


			);


		});


	},


	finish: function() {


//		delete(this.element.effectOn);


		this.element.effectOn = false;


	}


});


 


 


Effect.Gradient = Class.create();


Object.extend(Object.extend(Effect.Gradient.prototype, Effect.Base.prototype), {


	initialize: function(element) {


		this.element = $(element);


		if(!this.element) throw(Effect._elementDoesNotExistError);


		var options = Object.extend({


			duration: 5,


			rows: 10,


			cols: 10,


			type: 'diagonal',		/*	vertical, horizontal, diagonal */


			colors: [ 'black', 'white', 'white', 'black' ]


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


		if (options.type == 'horizontal') options.rows = 1;


		else if (options.type == 'vertical') options.cols = 1;


 


		dims = this.element.getDimensions();


		cellwidth  = dims.width  / options.cols;


		cellheight = dims.height / options.rows;


		this.cellids = [];


		var self = this;


		this.table = Builder.node('table', {


			border: 0, cellpadding: 0, cellspacing: 0,


			style:"margin: 0px; padding: 0px;"


		});


		tbody = Builder.node('tbody');


		$(tbody).setStyle({ margin: 0, padding: 0 });


		$R(1,options.rows).each( function(row){


			tr = Builder.node('tr');


			$(tr).setStyle({ margin: 0, padding: 0 });


			if (options.type == 'vertical') {


				cellcolor = Color.shade( 


					Color.string2hex(options.colors[0]), 


					Color.string2hex(options.colors[1]), 


					(row-1)/(options.rows-1) 


				);


			}


			$R(1,options.cols).each( function(col){


				cellid = "grcell-"+row+"-"+col;


				if (options.type == 'diagonal') {


					cellcolor = Color.shade( 


						Color.shade( 


							Color.string2hex(options.colors[0]), 


							Color.string2hex(options.colors[1]), 


							(col-1)/(options.cols-1) 


						), 


						Color.shade( 


							Color.string2hex(options.colors[2]), 


							Color.string2hex(options.colors[3]), 


							(col-1)/(options.cols-1) 


						),


						(row-1)/(options.rows-1) 


					);


				} else if (options.type == 'horizontal') {


					cellcolor = Color.shade( 


						Color.string2hex(options.colors[0]), 


						Color.string2hex(options.colors[1]), 


						(col-1)/(options.cols-1) 


					);


				}


				td = Builder.node('td',{


					id: cellid


				}, "" );


				$(td).setStyle({ margin: '0px', padding: '0px',


					height: cellheight+'px', 


					width:  cellwidth+'px', 


					backgroundColor: cellcolor


				});


				tr.appendChild(td);


				self.cellids.push(cellid);


			});


			tbody.appendChild(tr);


		});


		this.table.appendChild(tbody);


 


		this.start(options);


	},


	setup: function(){


		Position.absolutize(this.element);


		this.element.parentNode.appendChild(this.table);


		Position.absolutize(this.table);


	},


	finish: function(){


		new Effect.Fade( this.table , {


			afterFinish: function(effect) {


				effect.element.parentNode.removeChild(effect.element);


			}


		});


	}


});


 


Effect.ORIGGradient = Class.create();


Object.extend(Object.extend(Effect.ORIGGradient.prototype, Effect.Base.prototype), {


	initialize: function(element) {


		this.element = $(element);


		if(!this.element) throw(Effect._elementDoesNotExistError);


		var options = Object.extend({


			duration: 5,


			rows: 10,


			cols: 10,


			type: 'diagonal',		/*	vertical, horizontal, diagonal */


			colors: [ 'black', 'white', 'white', 'black' ]


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


		if (options.type == 'horizontal') options.rows = 1;


		else if (options.type == 'vertical') options.cols = 1;


 


		dims = this.element.getDimensions();


		cellwidth  = dims.width  / options.cols;


		cellheight = dims.height / options.rows;


		this.cellids = [];


		var self = this;


		this.table = Builder.node('table', {


			border: 0, cellpadding: 0, cellspacing: 0,


			style:"margin: 0px; padding: 0px;"


		});


		tbody = Builder.node('tbody', { style:"margin: 0px; padding: 0px;" });


		$R(1,options.rows).each( function(row){


			tr = Builder.node('tr', { style:"margin: 0px; padding: 0px;" });


			if (options.type == 'vertical') {


				cellcolor = Color.shade( 


					Color.string2hex(options.colors[0]), 


					Color.string2hex(options.colors[1]), 


					(row-1)/(options.rows-1) 


				);


			}


			$R(1,options.cols).each( function(col){


				cellid = "grcell-"+row+"-"+col;


				if (options.type == 'diagonal') {


					cellcolor = Color.shade( 


						Color.shade( 


							Color.string2hex(options.colors[0]), 


							Color.string2hex(options.colors[1]), 


							(col-1)/(options.cols-1) 


						), 


						Color.shade( 


							Color.string2hex(options.colors[2]), 


							Color.string2hex(options.colors[3]), 


							(col-1)/(options.cols-1) 


						),


						(row-1)/(options.rows-1) 


					);


				} else if (options.type == 'horizontal') {


					cellcolor = Color.shade( 


						Color.string2hex(options.colors[0]), 


						Color.string2hex(options.colors[1]), 


						(col-1)/(options.cols-1) 


					);


				}


				td = Builder.node('td',{


					id: cellid,


					style:"margin: 0px; padding: 0px; "


						+"height: "+cellheight+"px; "


						+"width: "+cellwidth+"px; "


						+"background-color: "+cellcolor


				}, "" );


				tr.appendChild(td);


				self.cellids.push(cellid);


			});


			tbody.appendChild(tr);


		});


		this.table.appendChild(tbody);


 


		Position.absolutize(this.element);


		this.element.parentNode.appendChild(this.table);


		Position.absolutize(this.table);


		this.start(options);


	},


	finish: function(){


		new Effect.Fade( this.table , {


			afterFinish: function(effect) {


				effect.element.parentNode.removeChild(effect.element);


			}


		});


	}


});


 


 


Effect.Pixelate = Class.create();


Object.extend(Object.extend(Effect.Pixelate.prototype, Effect.Base.prototype), {


	initialize: function(element) {


		this.element = $(element);


		if(!this.element) throw(Effect._elementDoesNotExistError);


		var options = Object.extend({


			duration: 5,


			rows: 30,


			cols: 30,


			startcolor: 'transparent',


			endcolor: 'white'


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


		options.cells = options.rows * options.cols;


 


		dims = this.element.getDimensions();


		cellwidth  = dims.width  / options.cols;


		cellheight = dims.height / options.rows;


		this.cellids = [];


		this.table = Builder.node('table', {


			border: 0, cellpadding: 0, cellspacing: 0,


			style:"margin: 0px; padding: 0px;"


		});


		/*	Cannot set styles of table items in Builder.node due to IE bug */


		var self = this;


		tbody = Builder.node('tbody');


		$(tbody).setStyle({ margin: 0, padding: 0 });


		$R(1,options.rows).each( function(row){


			tr = Builder.node('tr');


			$(tr).setStyle({ margin: '0px', padding: '0px' });


			$R(1,options.cols).each( function(col){


				cellid = "pxcell-"+row+"-"+col;


				td = Builder.node('td',{


					id: cellid


				}, '');


				$(td).setStyle({ margin: '0px', padding: '0px',


					height: cellheight+'px', 


					width:  cellwidth+'px', 


					backgroundColor: options.startcolor


				});


				tr.appendChild(td);


				self.cellids.push(cellid);


			});


			tbody.appendChild(tr);


		});


		this.cellids.sort( function(a,b){return (0.5 - Math.random());} );


		this.table.appendChild(tbody);


		this.start(options);


	},


	setup: function() {


		Position.absolutize(this.element);


		this.element.parentNode.appendChild(this.table);


		Position.absolutize(this.table);


	},


	update: function(position) {


		while ( this.cellids.size() && (this.cellids.size()/this.options.cells) > (1-position) ) {


			$(this.cellids.pop()).setStyle({ backgroundColor: this.options.endcolor });


		}


	},


	finish: function(){


		new Effect.Fade( this.table , {


			afterFinish: function(effect) {


				effect.element.parentNode.removeChild(effect.element);


			}


		});


	}


});


 


 


 


Effect.Duplicate = Class.create();


Object.extend(Object.extend(Effect.Duplicate.prototype, Effect.Base.prototype), {


	initialize: function(element) {


		this.element = $(element);


		if(!this.element) throw(Effect._elementDoesNotExistError);


 


		this.element.makePositioned();


		this.elecopy = this.element.cloneNode(true);


		this.elecopy.setStyle({ color: 'red', backgroundColor: 'red', backgroundImage: '' });


		this.elecopy.id = element.id + '-copy';


		this.element.parentNode.appendChild(this.elecopy);


		Position.relativize(this.element);


		Position.relativize(this.elecopy);


		Position.absolutize(this.element);


		Position.absolutize(this.elecopy);


 


		var options = Object.extend({


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


		this.start(options);


	},


	asetup: function() {


		return new Effect.Parallel ( [


			new Effect.SlideRightIn(this.element, { sync:true }),


			new Effect.SlideLeftIn( this.elecopy, { sync:true }) 


			], Object.extend({ 


				duration: 2


			}, arguments[1] || {})


		);


	},


	update: function(position) {


	},


	finish: function() {


		this.elecopy.undoClipping().undoPositioned().remove();


	}


});


 


Effect.Flicker = Class.create();


Object.extend(Object.extend(Effect.Flicker.prototype, Effect.Base.prototype), {


	initialize: function(element) {


		this.element = $(element);


		if(!this.element) throw(Effect._elementDoesNotExistError);


		if ( ! this.element.effectOn ) {


			this.element.effectOn = true;


			var options = Object.extend({


				threshold: 0.5,


				endvisibility: "visible"


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


			this.start(options);


		}


	},


	update: function(position) {


		var visibility = ( Math.random() < this.options.threshold ) ? "hidden" : "visible";


		this.element.setStyle({


			visibility: visibility


		});


	},


	finish: function() {


		this.element.setStyle({


			visibility: this.options.endvisibility


		});


//		delete(this.element.effectOn);


		this.element.effectOn = false;


	}


});


 


 


Effect.CurtainClose = function(element) {


/* 


	CurtainClose need to have the content of the element wrapped in a container element with fixed width AND height!


*/


	element = $(element).cleanWhitespace();


	var elementDimensions = element.getDimensions();


 


	element.makeClipping().makePositioned();


	element.parentNode.makeClipping();	//	stops SlideLeftIn flicker


	elecopy = $(element.cloneNode(true));


	elecopy.setStyle({ top: '0px', left: '0px' });


	elecopy.id = element.id + '-copy';


	element.parentNode.appendChild(elecopy);


	elecopy.makeClipping().makePositioned();


	Position.absolutize(element);


 


	return new Effect.Parallel ( [


		new Effect.SlideRightIn(element, { sync:true }),


		new Effect.SlideLeftIn( elecopy, { sync:true }) 


		], Object.extend({ 


			duration: 2,


			afterFinishInternal: function(effect){


				elecopy.undoClipping().undoPositioned().remove();


/*	why does the above work and the below does not? */


//				effect.effects[1].element.undoClipping().undoPositioned().remove();


				effect.effects[0].element.parentNode.undoClipping();


			}


		}, arguments[1] || {})


	);


}


 


Effect.CurtainOpen = function(element) {


/* 


	CurtainOpen need to have the content of the element wrapped in a container element with fixed width AND height!


*/


	element = $(element).cleanWhitespace();


 


	element.makeClipping().makePositioned();


	element.parentNode.makeClipping();


	elecopy = element.cloneNode(true);


	elecopy.setStyle({ top: '0px' });


	elecopy.id = element.id + '-copy';


	element.parentNode.appendChild(elecopy);


	Position.absolutize(element);


	Position.absolutize(elecopy);


 


	var elementDimensions = element.getDimensions();


	return new Effect.Parallel ( [


		new Effect.SlideRightOut(element, { sync:true }),


		new Effect.SlideLeftOut( elecopy, { sync:true })


		], Object.extend({ 


			duration: 2,


			beforeSetup: function(effect){


				effect.effects[1].element.makeClipping().makePositioned().show();


			},


			afterFinishInternal: function(effect){


				element.undoClipping().undoPositioned();


/*	why does the above work and the below does not? */


//				effect.effects[0].element.undoClipping().undoPositioned();	


				effect.effects[1].element.parentNode.undoClipping();


				effect.effects[1].element.undoClipping().undoPositioned().remove();


			}


		}, arguments[1] || {})


	);


}


 


 


Effect.SlideLeftIn = function(element) {


/* 


	SlideLeftIn need to have the content of the element wrapped in a container element with fixed width!


*/


	element = $(element).cleanWhitespace();


	if ( ! element.effectOn ) {


		element.effectOn = true;


		var elementDimensions = element.getDimensions();


		return new Effect.Parallel ( [


			new Effect.Move(element, 


				Object.extend({ 


					x: -(elementDimensions.width), 


					sync: true, 


					mode: 'relative', 


					beforeStartInternal: function(effect) {


						if(window.opera) effect.element.setStyle({left: ''});


						effect.element.setStyle({left: elementDimensions.width + 'px' });


						effect.element.show();


					}


				}, arguments[1] || {})


			),


			new Effect.Scale(element, 100,


				Object.extend({ scaleContent: false, 


					/* why does the use of sync: true make this flicker? */


					scaleY: false,


					scaleFrom: window.opera ? 0 : 1


				}, arguments[1] || {})


			)


			], Object.extend({


				beforeSetup: function(effect){


					effect.effects[0].element.parentNode.makeClipping();


					effect.effects[0].element.makeClipping();


				},


				afterFinishInternal: function(effect){


					effect.effects[0].element.parentNode.undoClipping();


					effect.effects[0].element.undoClipping();


				},


				afterFinish: function(effect){


//					delete(effect.effects[0].element.effectOn);


					effect.effects[0].element.effectOn = false;


				}


			}, arguments[1] || {})


		);


	}


}


 


 


Effect.SlideRightOut = function(element) {


/* 


	SlideRightOut need to have the content of the element wrapped in a container element with fixed width!


*/


	element = $(element).cleanWhitespace();


	var elementDimensions = element.getDimensions();


	return new Effect.Parallel ( [


		new Effect.Move(element, { x: element.getWidth(), sync: true, mode: 'relative' }),


		new Effect.Scale(element, window.opera ? 0 : 1, {	


			sync: true, 


			scaleContent: false, 


			scaleY: false,


			scaleFrom: 100,


			restoreAfterFinish: true


		})


		], Object.extend({ 


			beforeSetup: function(effect){


				effect.effects[0].element.makeClipping();


			},


			afterFinishInternal: function(effect){


				effect.effects[0].element.undoClipping().hide();


			}


		}, arguments[1] || {})


	);


}


 


 


 


/* from SlideUp */


Effect.SlideLeftOut = function(element) {


/*


	SlideLeftOut needs to have the content of the element wrapped in a container element with fixed width


	otherwise any text or images begin to wrap in stange ways!


*/


	element = $(element).cleanWhitespace();


	return new Effect.Scale(element, window.opera ? 0 : 1,


		Object.extend({ 


			scaleContent: false, 


			scaleY: false, 


			scaleMode: 'box',


			scaleFrom: 100,


			restoreAfterFinish: true,


			beforeStartInternal: function(effect) {


				effect.element.makePositioned();


				// This line causes Internet Explorer to suck.


				// The problem is that the loop function is not part of


				// an object which I weren't able to identify


				// effect.element.down().makePositioned();


				if(window.opera) effect.element.setStyle({left: ''});


				effect.element.makeClipping().show();


			},  


			afterUpdateInternal: function(effect) {


				// This line causes Internet Explorer to suck.


				// The problem is that the loop function is not part of


				// an object which I weren't able to identify


				// effect.element.down().setStyle(


				//	{right: (effect.dims[1] - effect.element.clientWidth) + 'px' }


				// );


			},


			afterFinishInternal: function(effect) {


				effect.element.hide().undoClipping().undoPositioned();


				// This line causes Internet Explorer to suck.


				// The problem is that the loop function is not part of


				// an object which I weren't able to identify


				// effect.element.down().undoPositioned();


			}


		}, arguments[1] || {})


	);


}


 


 


/* from SlideDown */


Effect.SlideRightIn = function(element) {


/*


	SlideRightIn needs to have the content of the element wrapped in a container element with fixed width!


*/


	element = $(element).cleanWhitespace();


	var elementDimensions = element.getDimensions();


	// Perhaps Safari bug: element.style.overflow is not set if box is hidden


	var originalOverflow = element.style.overflow == "" ? 'hidden' : element.style.overflow;


	return new Effect.Scale(element, 100, 


		Object.extend({ 


			scaleContent: false, 


			scaleY: false, 


			scaleFrom: window.opera ? 0 : 1,


			scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},


			restoreAfterFinish: true,


			afterSetup: function(effect) {


				effect.element.makePositioned();


				// This line causes Internet Explorer to suck.


				// The problem is that the loop function is not part of


				// an object which I weren't able to identify


				// effect.element.down().makePositioned();


				if(window.opera) effect.element.setStyle({left: ''});


				effect.element.makeClipping().setStyle({width: '0px'}).show(); 


			},


			afterUpdateInternal: function(effect) {


				// effect.element.down().setStyle({right: (effect.dims[1] - effect.element.clientWidth) + 'px' }); 


			},


			afterFinishInternal: function(effect) {


				effect.element.undoClipping().undoPositioned();


				//effect.element.down().undoPositioned();


				effect.element.setStyle({overflow:originalOverflow});


			}


		}, arguments[1] || {})


	);


}


 


 


 


Effect.SlideUpIn = function(element) {


/* 


	SlideUpIn need to have the content of the element wrapped in a container element with fixed height!


*/


	element = $(element).cleanWhitespace();


	var elementDimensions = element.getDimensions();


	return new Effect.Parallel ( [


		new Effect.Move(element, { y: -(element.getHeight()), sync: true, mode: 'relative' }),


		new Effect.Scale(element, 100, 


			Object.extend({


				sync: true,


				scaleContent: false,


				scaleX: false,


				scaleFrom: 0,


				scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},


				beforeSetup: function(effect) {


					effect.element.hide();


				},


				afterSetup: function(effect) {


					effect.element.makeClipping().setStyle({height: '0px'}).show();


				},


				afterFinishInternal: function(effect) {


					effect.element.undoClipping();


				}


			}, arguments[1] || {})


		)


	], Object.extend({


		afterSetup: function(effect) {


			effect.effects[0].element.setStyle({top: elementDimensions.height + 'px' });


		}


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


}


 


 


Effect.SlideDownOut = function(element) {


/* 


	SlideDown need to have the content of the element wrapped in a container element with fixed height!


*/


	element = $(element).cleanWhitespace();


	var elementDimensions = element.getDimensions();


	return new Effect.Parallel ( [


		new Effect.Move(element, { y: element.getHeight(), sync: true, mode: 'relative' }),


		new Effect.Scale(element, 0,


			Object.extend({ 


				sync: true,


				scaleContent: false,


				scaleX: false,


				restoreAfterFinish: true,


				beforeSetup: function(effect){


					effect.element.makeClipping();


				},


				afterFinishInternal: function(effect) {


					effect.element.hide().undoClipping();


				}


			}, arguments[1] || {})


		)


	], Object.extend({


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


}


 


 


 


/* this is the original SlideDown */


Effect.SlideDownIn = function(element) {


	element = $(element).cleanWhitespace();


	// SlideDown need to have the content of the element wrapped in a container element with fixed height!


	var oldInnerBottom = element.down().getStyle('bottom');


	var elementDimensions = element.getDimensions();


	return new Effect.Scale(element, 100, 


		Object.extend({ 


			scaleContent: false, 


			scaleX: false, 


			scaleFrom: window.opera ? 0 : 1,


			scaleMode: {originalHeight: elementDimensions.height, originalWidth: elementDimensions.width},


			restoreAfterFinish: true,


			afterSetup: function(effect) {


				effect.element.makePositioned();


				effect.element.down().makePositioned();


				if(window.opera) effect.element.setStyle({top: ''});


				effect.element.makeClipping().setStyle({height: '0px'}).show(); 


			},


			afterUpdateInternal: function(effect) {


				effect.element.down().setStyle({bottom:


				(effect.dims[0] - effect.element.clientHeight) + 'px' }); 


			},


			afterFinishInternal: function(effect) {


				effect.element.undoClipping().undoPositioned();


				effect.element.down().undoPositioned().setStyle({bottom: oldInnerBottom}); 


			}


		}, arguments[1] || {})


	);


}


 


/* this is the original SlideUp */


Effect.SlideUpOut = function(element) {


	element = $(element).cleanWhitespace();


	var oldInnerBottom = element.down().getStyle('bottom');


	return new Effect.Scale(element, window.opera ? 0 : 1,


		Object.extend({ 


			scaleContent: false, 


			scaleX: false, 


			scaleMode: 'box',


			scaleFrom: 100,


			restoreAfterFinish: true,


			beforeStartInternal: function(effect) {


				effect.element.makePositioned();


				effect.element.down().makePositioned();


				if(window.opera) effect.element.setStyle({top: ''});


				effect.element.makeClipping().show();


			},  


			afterUpdateInternal: function(effect) {


				effect.element.down().setStyle({bottom:


				(effect.dims[0] - effect.element.clientHeight) + 'px' });


			},


			afterFinishInternal: function(effect) {


				effect.element.hide().undoClipping().undoPositioned().setStyle({bottom: oldInnerBottom});


				effect.element.down().undoPositioned();


			}


		}, arguments[1] || {})


	);


}





// script.aculo.us slider.js v1.6.5, Wed Nov 08 14:17:49 CET 2006





// Copyright (c) 2005, 2006 Marty Haught, Thomas Fuchs 


//


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


// For details, see the script.aculo.us web site: http://script.aculo.us/





if(!Control) var Control = {};


Control.Slider = Class.create();





// options:


//  axis: 'vertical', or 'horizontal' (default)


//


// callbacks:


//  onChange(value)


//  onSlide(value)


Control.Slider.prototype = {


  initialize: function(handle, track, options) {


    var slider = this;


    


    if(handle instanceof Array) {


      this.handles = handle.collect( function(e) { return $(e) });


    } else {


      this.handles = [$(handle)];


    }


    


    this.track   = $(track);


    this.options = options || {};





    this.axis      = this.options.axis || 'horizontal';


    this.increment = this.options.increment || 1;


    this.step      = parseInt(this.options.step || '1');


    this.range     = this.options.range || $R(0,1);


    


    this.value     = 0; // assure backwards compat


    this.values    = this.handles.map( function() { return 0 });


    this.spans     = this.options.spans ? this.options.spans.map(function(s){ return $(s) }) : false;


    this.options.startSpan = $(this.options.startSpan || null);


    this.options.endSpan   = $(this.options.endSpan || null);





    this.restricted = this.options.restricted || false;





    this.maximum   = this.options.maximum || this.range.end;


    this.minimum   = this.options.minimum || this.range.start;





    // Will be used to align the handle onto the track, if necessary


    this.alignX = parseInt(this.options.alignX || '0');


    this.alignY = parseInt(this.options.alignY || '0');


    


    this.trackLength = this.maximumOffset() - this.minimumOffset();





    this.handleLength = this.isVertical() ? 


      (this.handles[0].offsetHeight != 0 ? 


        this.handles[0].offsetHeight : this.handles[0].style.height.replace(/px$/,"")) : 


      (this.handles[0].offsetWidth != 0 ? this.handles[0].offsetWidth : 


        this.handles[0].style.width.replace(/px$/,""));





    this.active   = false;


    this.dragging = false;


    this.disabled = false;





    if(this.options.disabled) this.setDisabled();





    // Allowed values array


    this.allowedValues = this.options.values ? this.options.values.sortBy(Prototype.K) : false;


    if(this.allowedValues) {


      this.minimum = this.allowedValues.min();


      this.maximum = this.allowedValues.max();


    }





    this.eventMouseDown = this.startDrag.bindAsEventListener(this);


    this.eventMouseUp   = this.endDrag.bindAsEventListener(this);


    this.eventMouseMove = this.update.bindAsEventListener(this);





    // Initialize handles in reverse (make sure first handle is active)


    this.handles.each( function(h,i) {


      i = slider.handles.length-1-i;


      slider.setValue(parseFloat(


        (slider.options.sliderValue instanceof Array ? 


          slider.options.sliderValue[i] : slider.options.sliderValue) || 


         slider.range.start), i);


      Element.makePositioned(h); // fix IE


      Event.observe(h, "mousedown", slider.eventMouseDown);


    });


    


    Event.observe(this.track, "mousedown", this.eventMouseDown);


    Event.observe(document, "mouseup", this.eventMouseUp);


    Event.observe(document, "mousemove", this.eventMouseMove);


    


    this.initialized = true;


  },


  dispose: function() {


    var slider = this;    


    Event.stopObserving(this.track, "mousedown", this.eventMouseDown);


    Event.stopObserving(document, "mouseup", this.eventMouseUp);


    Event.stopObserving(document, "mousemove", this.eventMouseMove);


    this.handles.each( function(h) {


      Event.stopObserving(h, "mousedown", slider.eventMouseDown);


    });


  },


  setDisabled: function(){


    this.disabled = true;


  },


  setEnabled: function(){


    this.disabled = false;


  },  


  getNearestValue: function(value){


    if(this.allowedValues){


      if(value >= this.allowedValues.max()) return(this.allowedValues.max());


      if(value <= this.allowedValues.min()) return(this.allowedValues.min());


      


      var offset = Math.abs(this.allowedValues[0] - value);


      var newValue = this.allowedValues[0];


      this.allowedValues.each( function(v) {


        var currentOffset = Math.abs(v - value);


        if(currentOffset <= offset){


          newValue = v;


          offset = currentOffset;


        } 


      });


      return newValue;


    }


    if(value > this.range.end) return this.range.end;


    if(value < this.range.start) return this.range.start;


    return value;


  },


  setValue: function(sliderValue, handleIdx){


    if(!this.active) {


      this.activeHandleIdx = handleIdx || 0;


      this.activeHandle    = this.handles[this.activeHandleIdx];


      this.updateStyles();


    }


    handleIdx = handleIdx || this.activeHandleIdx || 0;


    if(this.initialized && this.restricted) {


      if((handleIdx>0) && (sliderValue<this.values[handleIdx-1]))


        sliderValue = this.values[handleIdx-1];


      if((handleIdx < (this.handles.length-1)) && (sliderValue>this.values[handleIdx+1]))


        sliderValue = this.values[handleIdx+1];


    }


    sliderValue = this.getNearestValue(sliderValue);


    this.values[handleIdx] = sliderValue;


    this.value = this.values[0]; // assure backwards compat


    


    this.handles[handleIdx].style[this.isVertical() ? 'top' : 'left'] = 


      this.translateToPx(sliderValue);


    


    this.drawSpans();


    if(!this.dragging || !this.event) this.updateFinished();


  },


  setValueBy: function(delta, handleIdx) {


    this.setValue(this.values[handleIdx || this.activeHandleIdx || 0] + delta, 


      handleIdx || this.activeHandleIdx || 0);


  },


  translateToPx: function(value) {


    return Math.round(


      ((this.trackLength-this.handleLength)/(this.range.end-this.range.start)) * 


      (value - this.range.start)) + "px";


  },


  translateToValue: function(offset) {


    return ((offset/(this.trackLength-this.handleLength) * 


      (this.range.end-this.range.start)) + this.range.start);


  },


  getRange: function(range) {


    var v = this.values.sortBy(Prototype.K); 


    range = range || 0;


    return $R(v[range],v[range+1]);


  },


  minimumOffset: function(){


    return(this.isVertical() ? this.alignY : this.alignX);


  },


  maximumOffset: function(){


    return(this.isVertical() ? 


      (this.track.offsetHeight != 0 ? this.track.offsetHeight :


        this.track.style.height.replace(/px$/,"")) - this.alignY : 


      (this.track.offsetWidth != 0 ? this.track.offsetWidth : 


        this.track.style.width.replace(/px$/,"")) - this.alignY);


  },  


  isVertical:  function(){


    return (this.axis == 'vertical');


  },


  drawSpans: function() {


    var slider = this;


    if(this.spans)


      $R(0, this.spans.length-1).each(function(r) { slider.setSpan(slider.spans[r], slider.getRange(r)) });


    if(this.options.startSpan)


      this.setSpan(this.options.startSpan,


        $R(0, this.values.length>1 ? this.getRange(0).min() : this.value ));


    if(this.options.endSpan)


      this.setSpan(this.options.endSpan, 


        $R(this.values.length>1 ? this.getRange(this.spans.length-1).max() : this.value, this.maximum));


  },


  setSpan: function(span, range) {


    if(this.isVertical()) {


      span.style.top = this.translateToPx(range.start);


      span.style.height = this.translateToPx(range.end - range.start + this.range.start);


    } else {


      span.style.left = this.translateToPx(range.start);


      span.style.width = this.translateToPx(range.end - range.start + this.range.start);


    }


  },


  updateStyles: function() {


    this.handles.each( function(h){ Element.removeClassName(h, 'selected') });


    Element.addClassName(this.activeHandle, 'selected');


  },


  startDrag: function(event) {


    if(Event.isLeftClick(event)) {


      if(!this.disabled){


        this.active = true;


        


        var handle = Event.element(event);


        var pointer  = [Event.pointerX(event), Event.pointerY(event)];


        var track = handle;


        if(track==this.track) {


          var offsets  = Position.cumulativeOffset(this.track); 


          this.event = event;


          this.setValue(this.translateToValue( 


           (this.isVertical() ? pointer[1]-offsets[1] : pointer[0]-offsets[0])-(this.handleLength/2)


          ));


          var offsets  = Position.cumulativeOffset(this.activeHandle);


          this.offsetX = (pointer[0] - offsets[0]);


          this.offsetY = (pointer[1] - offsets[1]);


        } else {


          // find the handle (prevents issues with Safari)


          while((this.handles.indexOf(handle) == -1) && handle.parentNode) 


            handle = handle.parentNode;


            


          if(this.handles.indexOf(handle)!=-1) {


            this.activeHandle    = handle;


            this.activeHandleIdx = this.handles.indexOf(this.activeHandle);


            this.updateStyles();


            


            var offsets  = Position.cumulativeOffset(this.activeHandle);


            this.offsetX = (pointer[0] - offsets[0]);


            this.offsetY = (pointer[1] - offsets[1]);


          }


        }


      }


      Event.stop(event);


    }


  },


  update: function(event) {


   if(this.active) {


      if(!this.dragging) this.dragging = true;


      this.draw(event);


      // fix AppleWebKit rendering


      if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);


      Event.stop(event);


   }


  },


  draw: function(event) {


    var pointer = [Event.pointerX(event), Event.pointerY(event)];


    var offsets = Position.cumulativeOffset(this.track);


    pointer[0] -= this.offsetX + offsets[0];


    pointer[1] -= this.offsetY + offsets[1];


    this.event = event;


    this.setValue(this.translateToValue( this.isVertical() ? pointer[1] : pointer[0] ));


    if(this.initialized && this.options.onSlide)


      this.options.onSlide(this.values.length>1 ? this.values : this.value, this);


  },


  endDrag: function(event) {


    if(this.active && this.dragging) {


      this.finishDrag(event, true);


      Event.stop(event);


    }


    this.active = false;


    this.dragging = false;


  },  


  finishDrag: function(event, success) {


    this.active = false;


    this.dragging = false;


    this.updateFinished();


  },


  updateFinished: function() {


    if(this.initialized && this.options.onChange) 


      this.options.onChange(this.values.length>1 ? this.values : this.value, this);


    this.event = null;


  }


}