// Copyright (c) 2005-2007 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// For details, see the script.aculo.us web site: http://script.aculo.us/

var Scriptaculous={
	Version:"1.8.1",
	require:function(a){
		// inserting via DOM fails in Safari 2.0, so brute force approach
		document.write('<script type="text/javascript" src="'+a+'"><\/script>')
	},
	REQUIRED_PROTOTYPE:"1.6.0",
	load:function(){
		function a(b){
			var c=b.split(".");
			return parseInt(c[0])*100000+parseInt(c[1])*1000+parseInt(c[2])
		}
		if((typeof Prototype=="undefined")||
		   (typeof Element=="undefined")||
		   (typeof Element.Methods=="undefined")||
		   (a(Prototype.Version)<a(Scriptaculous.REQUIRED_PROTOTYPE))){
		   throw ("script.aculo.us requires the Prototype JavaScript framework >= "+Scriptaculous.REQUIRED_PROTOTYPE)
		   }
	}
};
Scriptaculous.load();

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

// script.aculo.us effects.js v1.8.2, Tue Nov 18 18:30:58 +0100 2008

// Copyright (c) 2005-2008 Thomas Fuchs (http://script.aculo.us, http://mir.aculo.us)
// Contributors:
//  Justin Palmer (http://encytemedia.com/)
//  Mark Pilgrim (http://diveintomark.org/)
//  Martin Bialasinki

String.prototype.parseColor=function(){
	var a="#";
	if(this.slice(0,4)=="rgb("){
		var c=this.slice(4,this.length-1).split(",");
		var b=0;do{a+=parseInt(c[b]).toColorPart()}while(++b<3)
	}else{
	if(this.slice(0,1)=="#"){
		if(this.length==4){for(var b=1;b<4;b++){a+=(this.charAt(b)+this.charAt(b)).toLowerCase()}}
		if(this.length==7){a=this.toLowerCase()}
	}
	}
	return(a.length==7?a:(arguments[0]||this))
};
/*---------------------------------------------------*/
Element.collectTextNodes=function(a){
	return $A($(a).childNodes).collect(function(b){
		return(b.nodeType==3?b.nodeValue:(b.hasChildNodes()?Element.collectTextNodes(b):""))
	}).flatten().join("")
};

Element.collectTextNodesIgnoreClass=function(a,b){
	return $A($(a).childNodes).collect(function(c){
		return(c.nodeType==3?c.nodeValue:((c.hasChildNodes()&&!Element.hasClassName(c,b))?Element.collectTextNodesIgnoreClass(c,b):""))
	}).flatten().join("")
};

Element.setContentZoom=function(a,b){
	a=$(a);a.setStyle({
	fontSize:(b/100)+"em"});
	if(Prototype.Browser.WebKit){window.scrollBy(0,0)}
	return a
};

Element.getInlineOpacity=function(a){
	return $(a).style.opacity||""};

Element.forceRerendering=function(a){
	try{
		a=$(a);
		var c=document.createTextNode(" ");
		a.appendChild(c);
		a.removeChild(c)
	}catch(b){}
};
/*---------------------------------------------------*/
var Effect={
	_elementDoesNotExistError:{
		name:"ElementDoesNotExistError",message:"The specified DOM element does not exist, but is required for this effect to operate"
		},
	Transitions:{
		linear:Prototype.K,sinoidal:function(a){
			return(-Math.cos(a*Math.PI)/2)+0.5
		},
		reverse:function(a){
			return 1-a
		},
		flicker:function(a){
			var a=((-Math.cos(a*Math.PI)/4)+0.75)+Math.random()/4;
			return a>1?1:a
		},
		wobble:function(a){
			return(-Math.cos(a*Math.PI*(9*a))/2)+0.5
		},
		pulse:function(b,a){
			a=a||5;
			return(((b%(1/a))*a).round()==0?((b*a*2)-(b*a*2).floor()):1-((b*a*2)-(b*a*2).floor()))
		},
		spring:function(a){
			return 1-(Math.cos(a*4.5*Math.PI)*Math.exp(-a*6))
		},
		none:function(a){
			return 0
		},
		full:function(a){
			return 1
		}
},
DefaultOptions:{
	duration:1,
	fps:100,
	sync:false,
	from:0,
	to:1,
	delay:0,
	queue:"parallel"
},
tagifyText:function(a){
	var b="position:relative";
	if(Prototype.Browser.IE){b+=";zoom:1"}
	
	a=$(a);
	$A(a.childNodes).each(function(c){
		if(c.nodeType==3){
			c.nodeValue.toArray().each(function(d){
				a.insertBefore(new Element("span",{style:b}).update(d==" "?String.fromCharCode(160):d),c)
			});
			Element.remove(c)
		}
	})
},
multiple:function(b,c){
	var e;
	if(((typeof b=="object")||
		Object.isFunction(b))&&(b.length)){
			e=b
			}
	else{
		e=$(b).childNodes
		}
	
	var a=Object.extend({
		speed:0.1,
		delay:0
	},arguments[2]||{});
	
	var d=a.delay;
	$A(e).each(function(g,f){
		new c(g,Object.extend(a,{delay:f*a.speed+d}))
	})
},
PAIRS:{
	slide:["SlideDown","SlideUp"],
	blind:["BlindDown","BlindUp"],
	appear:["Appear","Fade"]
},
toggle:function(b,c){
	b=$(b);
	c=(c||"appear").toLowerCase();
	var a=Object.extend({
		queue:{position:"end",scope:(b.id||"global"),limit:1}
	},arguments[2]||{});
	Effect[b.visible()?
		Effect.PAIRS[c][1]:Effect.PAIRS[c][0]](b,a)
	}
};
Effect.DefaultOptions.transition=Effect.Transitions.sinoidal;

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

Effect.ScopedQueue=Class.create(Enumerable,{
	initialize:function(){
		this.effects=[];
		this.interval=null
	},
	_each:function(a){
		this.effects._each(a)
	},
	add:function(b){
		var c=new Date().getTime();
		
		var a=Object.isString(b.options.queue)?b.options.queue:b.options.queue.position;
		
		switch(a){
			case"front":
        		// move unstarted effects after this effect
				this.effects.findAll(function(d){return d.state=="idle"}).each(function(d){
					d.startOn+=b.finishOn;
					d.finishOn+=b.finishOn
				});
				break;
			case"with-last":
				c=this.effects.pluck("startOn").max()||c;
				break;
			case"end":
        		// start effect after last queued effect has finished
				c=this.effects.pluck("finishOn").max()||c;
				break
		}
		b.startOn+=c;
		b.finishOn+=c;
		
		if(!b.options.queue.limit||(this.effects.length<b.options.queue.limit)){
			this.effects.push(b)
		}
		
		if(!this.interval){
			this.interval=setInterval(this.loop.bind(this),15)
		}
	},
	remove:function(a){
		this.effects=this.effects.reject(function(b){return b==a});
		if(this.effects.length==0){
			clearInterval(this.interval);
			this.interval=null
		}
	},
	loop:function(){
		var c=new Date().getTime();
		for(var b=0,a=this.effects.length;b<a;b++){
			this.effects[b]&&this.effects[b].loop(c)
		}
	}
});

Effect.Queues={
	instances:$H(),
	get:function(a){
		if(!Object.isString(a)){return a}
		
		return this.instances.get(a)||
			this.instances.set(a,new Effect.ScopedQueue())
	}
};
Effect.Queue=Effect.Queues.get("global");

Effect.Base=Class.create({
	position:null,
	start:function(options){
		function codeForEvent(options,eventName){
			return(
				(options[eventName+"Internal"]?"this.options."+eventName+"Internal(this);":"")+
				(options[eventName]?"this.options."+eventName+"(this);":"")
			)
		}
		if(options&&options.transition===false){options.transition=Effect.Transitions.linear}
		this.options=Object.extend(Object.extend({},Effect.DefaultOptions),options||{});
		this.currentFrame=0;
		this.state="idle";
		this.startOn=this.options.delay*1000;
		this.finishOn=this.startOn+(this.options.duration*1000);
		this.fromToDelta=this.options.to-this.options.from;
		this.totalTime=this.finishOn-this.startOn;
		this.totalFrames=this.options.fps*this.options.duration;
		
		eval(
			'this.render = function(pos){ if (this.state=="idle"){this.state="running";'+
			codeForEvent(this.options,"beforeSetup")+
			(this.setup?"this.setup();":"")+
			codeForEvent(this.options,"afterSetup")+'};if (this.state=="running"){pos=this.options.transition(pos)*'+
			this.fromToDelta+"+"+this.options.from+";this.position=pos;"+
			codeForEvent(this.options,"beforeUpdate")+
			(this.update?"this.update(pos);":"")+
			codeForEvent(this.options,"afterUpdate")+"}}"
		);
			this.event("beforeStart");
			if(!this.options.sync){
				Effect.Queues.get(Object.isString(this.options.queue)?"global":this.options.queue.scope).add(this)
			}
	},
	loop:function(c){
		if(c>=this.startOn){
			if(c>=this.finishOn){
				this.render(1);
				this.cancel();
				this.event("beforeFinish");
				if(this.finish){this.finish()}
				this.event("afterFinish");
				return
			}
			var b=(c-this.startOn)/this.totalTime,a=(b*this.totalFrames).round();
			if(a>this.currentFrame){
				this.render(b);
				this.currentFrame=a
			}
		}
	},
	cancel:function(){
		if(!this.options.sync){
			Effect.Queues.get(Object.isString(this.options.queue)?"global":this.options.queue.scope).remove(this)
		}
		this.state="finished"
	},
	event:function(a){
		if(this.options[a+"Internal"]){this.options[a+"Internal"](this)}
		if(this.options[a]){this.options[a](this)}
	},
	inspect:function(){
		var a=$H();
		for(property in this){
			if(!Object.isFunction(this[property])){a.set(property,this[property])}
		}
		return"#<Effect:"+a.inspect()+",options:"+$H(this.options).inspect()+">"
	}
});
Effect.Parallel=Class.create(Effect.Base,{
	initialize:function(a){
		this.effects=a||[];
		this.start(arguments[1])
	},
	update:function(a){
		this.effects.invoke("render",a)
	},
	finish:function(a){
		this.effects.each(function(b){
			b.render(1);
			b.cancel();
			b.event("beforeFinish");
			if(b.finish){b.finish(a)}
			b.event("afterFinish")
		})
	}
});

Effect.Tween=Class.create(Effect.Base,{
	initialize:function(c,f,e){
		c=Object.isString(c)?$(c):c;
		var b=$A(arguments),d=b.last(),
			a=b.length==5?b[3]:null;
		this.method=Object.isFunction(d)?d.bind(c):
			Object.isFunction(c[d])?c[d].bind(c):
			function(g){c[d]=g};
		this.start(Object.extend({from:f,to:e},a||{}))
	},
	update:function(a){
		this.method(a)
	}
});

Effect.Event=Class.create(Effect.Base,{
	initialize:function(){
		this.start(Object.extend({duration:0},arguments[0]||{}))
	},
	update:Prototype.emptyFunction
});

Effect.Opacity=Class.create(Effect.Base,{
	initialize:function(b){
		this.element=$(b);
		if(!this.element){throw (Effect._elementDoesNotExistError)}
   		 // make this work on IE on elements without 'layout'
		if(Prototype.Browser.IE&&(!this.element.currentStyle.hasLayout)){
			this.element.setStyle({zoom:1})
		}
		var a=Object.extend({
			from:this.element.getOpacity()||0,
			to:1
		},arguments[1]||{});
		this.start(a)
	},
	update:function(a){
		this.element.setOpacity(a)
	}
});

Effect.Move=Class.create(Effect.Base,{
	initialize:function(b){
		this.element=$(b);
		if(!this.element){throw (Effect._elementDoesNotExistError)}
		var a=Object.extend({
			x:0,
			y:0,
			mode:"relative"
		},arguments[1]||{});
		this.start(a)
	},
	setup:function(){
		this.element.makePositioned();
		this.originalLeft=parseFloat(this.element.getStyle("left")||"0");
		this.originalTop=parseFloat(this.element.getStyle("top")||"0");
		if(this.options.mode=="absolute"){
			this.options.x=this.options.x-this.originalLeft;
			this.options.y=this.options.y-this.originalTop
		}
	},
	update:function(a){
		this.element.setStyle({
			left:(this.options.x*a+this.originalLeft).round()+"px",
			top:(this.options.y*a+this.originalTop).round()+"px"
		})
	}
});

// for backwards compatibility
Effect.MoveBy=function(b,a,c){
	return new Effect.Move(b,Object.extend({x:c,y:a},arguments[3]||{}))
};

Effect.Scale=Class.create(Effect.Base,{
	initialize:function(b,c){
		this.element=$(b);
		if(!this.element){throw (Effect._elementDoesNotExistError)}
		var a=Object.extend({
			scaleX:true,
			scaleY:true,
			scaleContent:true,
			scaleFromCenter:false,
			scaleMode:"box",	// 'box' or 'contents' or { } with provided values
			scaleFrom:100,
			scaleTo:c
		},arguments[2]||{});
		this.start(a)
	},
	setup:function(){
		this.restoreAfterFinish=this.options.restoreAfterFinish||false;
		this.elementPositioning=this.element.getStyle("position");
		
		this.originalStyle={};
		["top","left","width","height","fontSize"].each(function(b){
			this.originalStyle[b]=this.element.style[b]
		}.bind(this));
		
		this.originalTop=this.element.offsetTop;
		this.originalLeft=this.element.offsetLeft;
		
		var a=this.element.getStyle("font-size")||"100%";
		["em","px","%","pt"].each(function(b){
			if(a.indexOf(b)>0){
				this.fontSize=parseFloat(a);
				this.fontSizeType=b
			}
		}.bind(this));
		
		this.factor=(this.options.scaleTo-this.options.scaleFrom)/100;
		
		this.dims=null;
		if(this.options.scaleMode=="box"){
			this.dims=[this.element.offsetHeight,this.element.offsetWidth]
		}
		if(/^content/.test(this.options.scaleMode)){
			this.dims=[this.element.scrollHeight,this.element.scrollWidth]
		}
		if(!this.dims){
			this.dims=[this.options.scaleMode.originalHeight,this.options.scaleMode.originalWidth]
		}
	},
	update:function(a){
		var b=(this.options.scaleFrom/100)+(this.factor*a);
		if(this.options.scaleContent&&this.fontSize){
			this.element.setStyle({fontSize:this.fontSize*b+this.fontSizeType})
		}
		this.setDimensions(this.dims[0]*b,this.dims[1]*b)
	},
	finish:function(a){
		if(this.restoreAfterFinish){this.element.setStyle(this.originalStyle)}
	},
	setDimensions:function(a,e){
		var f={};
		if(this.options.scaleX){f.width=e.round()+"px"}
		if(this.options.scaleY){f.height=a.round()+"px"}
		if(this.options.scaleFromCenter){
			var c=(a-this.dims[0])/2;
			var b=(e-this.dims[1])/2;
			if(this.elementPositioning=="absolute"){
				if(this.options.scaleY){f.top=this.originalTop-c+"px"}
				if(this.options.scaleX){f.left=this.originalLeft-b+"px"}
			}else{
				if(this.options.scaleY){f.top=-c+"px"}
				if(this.options.scaleX){f.left=-b+"px"}
			}
		}
		this.element.setStyle(f)
	}
});

Effect.Highlight=Class.create(Effect.Base,{
	initialize:function(b){
		this.element=$(b);
		if(!this.element){throw (Effect._elementDoesNotExistError)}
		var a=Object.extend({startcolor:"#ffff99"},arguments[1]||{});
		this.start(a)
	},
	setup:function(){
    	// Prevent executing on elements not in the layout flow
		if(this.element.getStyle("display")=="none"){this.cancel();return}
    	// Disable background image during the effect
		this.oldStyle={};
		if(!this.options.keepBackgroundImage){
			this.oldStyle.backgroundImage=this.element.getStyle("background-image");
			this.element.setStyle({backgroundImage:"none"})
		}
		if(!this.options.endcolor){
			this.options.endcolor=this.element.getStyle("background-color").parseColor("#ffffff")
		}
		if(!this.options.restorecolor){
			this.options.restorecolor=this.element.getStyle("background-color")
		}
    	// init color calculations
		this._base=$R(0,2).map(function(a){return parseInt(this.options.startcolor.slice(a*2+1,a*2+3),16)}.bind(this));
		this._delta=$R(0,2).map(function(a){return parseInt(this.options.endcolor.slice(a*2+1,a*2+3),16)-this._base[a]}.bind(this))
	},
	update:function(a){
		this.element.setStyle({backgroundColor:$R(0,2).inject("#",function(b,c,d){
			return b+((this._base[d]+(this._delta[d]*a)).round().toColorPart())}.bind(this))})
	},
	finish:function(){
		this.element.setStyle(Object.extend(this.oldStyle,{
			backgroundColor:this.options.restorecolor
		}))
	}
});

Effect.ScrollTo=function(d){
	var c=arguments[1]||{},
	b=document.viewport.getScrollOffsets(),
	e=$(d).cumulativeOffset(),
	a=(window.height||document.body.scrollHeight)-document.viewport.getHeight();
	
	if(c.offset){e[1]+=c.offset}
	
	return new Effect.Tween(null,
		b.top,
		e[1]>a?a:e[1],
		c,
		function(f){scrollTo(b.left,f.round())}
	)
};

/* ------------- combination effects ------------- */
	
Effect.Fade=function(c){
	c=$(c);
	var a=c.getInlineOpacity();
	var b=Object.extend({
		from:c.getOpacity()||1,
		to:0,
		afterFinishInternal:function(d){
			if(d.options.to!=0){return}
			d.element.hide().setStyle({opacity:a})
		}
	},arguments[1]||{});
	return new Effect.Opacity(c,b)
};

Effect.Appear=function(b){
	b=$(b);
	var a=Object.extend({
	from:(b.getStyle("display")=="none"?0:b.getOpacity()||0),
	to:1,
  	// force Safari to render floated elements properly
	afterFinishInternal:function(c){
		c.element.forceRerendering()
	},
	beforeSetup:function(c){
		c.element.setOpacity(c.options.from).show()
	}},arguments[1]||{});
	return new Effect.Opacity(b,a)
};

Effect.Puff=function(b){
	b=$(b);
	var a={
		opacity:b.getInlineOpacity(),
		position:b.getStyle("position"),
		top:b.style.top,
		left:b.style.left,
		width:b.style.width,
		height:b.style.height
	};
	return new Effect.Parallel(
	[new Effect.Scale(b,200,
		{sync:true,scaleFromCenter:true,scaleContent:true,restoreAfterFinish:true}),
	 	 new Effect.Opacity(b,{sync:true,to:0})],
	 Object.extend({duration:1,beforeSetupInternal:function(c){
	 Position.absolutize(c.effects[0].element)
	 },
	 afterFinishInternal:function(c){
		c.effects[0].element.hide().setStyle(a)}
	 },arguments[1]||{})
	)
};

Effect.BlindUp=function(a){
	a=$(a);
	a.makeClipping();
	return new Effect.Scale(a,0,
		Object.extend({scaleContent:false,
			scaleX:false,
			restoreAfterFinish:true,
			afterFinishInternal:function(b){
				b.element.hide().undoClipping()
			}
		},arguments[1]||{})
	)
};

Effect.BlindDown=function(b){
	b=$(b);
	var a=b.getDimensions();
	return new Effect.Scale(b,100,Object.extend({
		scaleContent:false,
		scaleX:false,
		scaleFrom:0,
		scaleMode:{originalHeight:a.height,originalWidth:a.width},
		restoreAfterFinish:true,
		afterSetup:function(c){
			c.element.makeClipping().setStyle({height:"0px"}).show()
		},
		afterFinishInternal:function(c){
			c.element.undoClipping()
		}
	},arguments[1]||{}))
};

Effect.SwitchOff=function(b){
	b=$(b);
	var a=b.getInlineOpacity();
	return new Effect.Appear(b,Object.extend({
		duration:0.4,
		from:0,
		transition:Effect.Transitions.flicker,
		afterFinishInternal:function(c){
			new Effect.Scale(c.element,1,{
				duration:0.3,scaleFromCenter:true,
				scaleX:false,scaleContent:false,restoreAfterFinish:true,
				beforeSetup:function(d){
					d.element.makePositioned().makeClipping()
				},
				afterFinishInternal:function(d){
					d.element.hide().undoClipping().undoPositioned().setStyle({opacity:a})
				}
			})
		}
	},arguments[1]||{}))
};

Effect.DropOut=function(b){
	b=$(b);
	var a={
		top:b.getStyle("top"),
		left:b.getStyle("left"),
		opacity:b.getInlineOpacity()};
	return new Effect.Parallel(
		[new Effect.Move(b,{x:0,y:100,sync:true}),
		 new Effect.Opacity(b,{sync:true,to:0})],
		Object.extend(
			{duration:0.5,
			 beforeSetup:function(c){
				 c.effects[0].element.makePositioned()
			 },
			 afterFinishInternal:function(c){
				 c.effects[0].element.hide().undoPositioned().setStyle(a)
			 }
			},arguments[1]||{}))
};

Effect.Shake=function(d){
	d=$(d);
	var b=Object.extend({
		distance:20,
		duration:0.5
	},arguments[1]||{});
	var e=parseFloat(b.distance);
	var c=parseFloat(b.duration)/10;
	var a={
		top:d.getStyle("top"),
		left:d.getStyle("left")};
		return new Effect.Move(d,
			{x:e,y:0,duration:c,afterFinishInternal:function(f){
		new Effect.Move(f.element,
			{x:-e*2,y:0,duration:c*2,afterFinishInternal:function(g){
		new Effect.Move(g.element,
			{x:e*2,y:0,duration:c*2,afterFinishInternal:function(h){
		new Effect.Move(h.element,
			{x:-e*2,y:0,duration:c*2,afterFinishInternal:function(k){
		new Effect.Move(k.element,
			{x:e*2,y:0,duration:c*2,afterFinishInternal:function(l){
		new Effect.Move(l.element,
			{x:-e,y:0,duration:c,afterFinishInternal:function(m){
			 m.element.undoPositioned().setStyle(a)
	}})}})}})}})}})}})
};

Effect.SlideDown=function(c){
	c=$(c).cleanWhitespace();
  	// SlideDown need to have the content of the element wrapped in a container element with fixed height!
	var a=c.down().getStyle("bottom");
	var b=c.getDimensions();
	return new Effect.Scale(c,100,Object.extend({
		scaleContent:false,
		scaleX:false,
		scaleFrom:window.opera?0:1,
		scaleMode:{originalHeight:b.height,originalWidth:b.width},
		restoreAfterFinish:true,
		afterSetup:function(d){
			d.element.makePositioned();
			d.element.down().makePositioned();
			if(window.opera){d.element.setStyle({top:""})}
			d.element.makeClipping().setStyle({height:"0px"}).show()
		},
		afterUpdateInternal:function(d){
			d.element.down().setStyle({bottom:
				(d.dims[0]-d.element.clientHeight)+"px"})
		},
		afterFinishInternal:function(d){
			d.element.undoClipping().undoPositioned();
			d.element.down().undoPositioned().setStyle({bottom:a})}
		},arguments[1]||{})
	)
};

Effect.SlideUp=function(c){
	c=$(c).cleanWhitespace();
	var a=c.down().getStyle("bottom");
	var b=c.getDimensions();
	return new Effect.Scale(c,window.opera?0:1,
		Object.extend({scaleContent:false,
			scaleX:false,
			scaleMode:"box",
			scaleFrom:100,
			scaleMode:{originalHeight:b.height,originalWidth:b.width},
			restoreAfterFinish:true,
			afterSetup:function(d){
				d.element.makePositioned();
				d.element.down().makePositioned();
				if(window.opera){d.element.setStyle({top:""})}
				d.element.makeClipping().show()
			},
			afterUpdateInternal:function(d){
				d.element.down().setStyle({bottom:
					(d.dims[0]-d.element.clientHeight)+"px"})
			},
			afterFinishInternal:function(d){
				d.element.hide().undoClipping().undoPositioned();
				d.element.down().undoPositioned().setStyle({bottom:a})
			}
		},arguments[1]||{})
	)
};

// Bug in opera makes the TD containing this element expand for a instance after finish
Effect.Squish=function(a){
	return new Effect.Scale(a,window.opera?1:0,{
		restoreAfterFinish:true,
		beforeSetup:function(b){
			b.element.makeClipping()
		},
		afterFinishInternal:function(b){
			b.element.hide().undoClipping()
		}
	})
};

Effect.Grow=function(c){
	c=$(c);
	var b=Object.extend({
		direction:"center",
		moveTransition:Effect.Transitions.sinoidal,
		scaleTransition:Effect.Transitions.sinoidal,
		opacityTransition:Effect.Transitions.full
	},arguments[1]||{});
	var a={
		top:c.style.top,
		left:c.style.left,
		height:c.style.height,
		width:c.style.width,
		opacity:c.getInlineOpacity()};
	
	var g=c.getDimensions();
	var h,f;
	var e,d;
	
	switch(b.direction){
		case"top-left":
			h=f=e=d=0;
			break;
		case"top-right":
			h=g.width;
			f=d=0;
			e=-g.width;
			break;
		case"bottom-left":
			h=e=0;
			f=g.height;
			d=-g.height;
			break;
		case"bottom-right":
			h=g.width;
			f=g.height;
			e=-g.width;
			d=-g.height;
			break;
		case"center":
			h=g.width/2;
			f=g.height/2;
			e=-g.width/2;
			d=-g.height/2;
			break
	}
		
	return new Effect.Move(c,{
		x:h,
		y:f,
		duration:0.01,
		beforeSetup:function(k){
			k.element.hide().makeClipping().makePositioned()
		},
		afterFinishInternal:function(k){
			new Effect.Parallel(
				[new Effect.Opacity(k.element,{sync:true,to:1,from:0,transition:b.opacityTransition}),
				 new Effect.Move(k.element,{x:e,y:d,sync:true,transition:b.moveTransition}),
				 new Effect.Scale(k.element,100,{
					 scaleMode:{originalHeight:g.height,originalWidth:g.width},
					 sync:true,scaleFrom:window.opera?1:0,transition:b.scaleTransition,restoreAfterFinish:true})
				],Object.extend({
					beforeSetup:function(l){
						l.effects[0].element.setStyle({height:"0px"}).show()
					},
					afterFinishInternal:function(l){
						l.effects[0].element.undoClipping().undoPositioned().setStyle(a)
					}
				  },b)
			)
		}
	})
};
			
Effect.Shrink=function(c){
	c=$(c);
	var b=Object.extend({
		direction:"center",
		moveTransition:Effect.Transitions.sinoidal,
		scaleTransition:Effect.Transitions.sinoidal,
		opacityTransition:Effect.Transitions.none
	},arguments[1]||{});
	var a={
		top:c.style.top,
		left:c.style.left,
		height:c.style.height,
		width:c.style.width,
		opacity:c.getInlineOpacity()};
	
	var f=c.getDimensions();
	var e,d;
	
	switch(b.direction){
		case"top-left":
			e=d=0;
			break;
		case"top-right":
			e=f.width;
			d=0;
			break;
		case"bottom-left":
			e=0;
			d=f.height;
			break;
		case"bottom-right":
			e=f.width;
			d=f.height;
			break;
		case"center":
			e=f.width/2;
			d=f.height/2;
			break
	}
	
	return new Effect.Parallel(
		[new Effect.Opacity(c,{sync:true,to:0,from:1,transition:b.opacityTransition}),
		 new Effect.Scale(c,window.opera?1:0,{sync:true,transition:b.scaleTransition,restoreAfterFinish:true}),
		 new Effect.Move(c,{x:e,y:d,sync:true,transition:b.moveTransition})
		],Object.extend({
			beforeStartInternal:function(g){
				g.effects[0].element.makePositioned().makeClipping()
			},
			afterFinishInternal:function(g){
				g.effects[0].element.hide().undoClipping().undoPositioned().setStyle(a)}
		  },b)
	)
};

Effect.Pulsate=function(c){
	c=$(c);
	var b=arguments[1]||{};
	var a=c.getInlineOpacity();
	var e=b.transition||Effect.Transitions.sinoidal;
	var d=function(f){
		return e(1-Effect.Transitions.pulse(f,b.pulses))
	};
	d.bind(e);
	
	return new Effect.Opacity(c,
		Object.extend(Object.extend({duration:2,from:0,
			afterFinishInternal:function(f){f.element.setStyle({opacity:a})}
		},b),{transition:d}))
};

Effect.Fold=function(b){
	b=$(b);
	var a={
		top:b.style.top,
		left:b.style.left,
		width:b.style.width,
		height:b.style.height};
	b.makeClipping();
	return new Effect.Scale(b,5,Object.extend({
		scaleContent:false,
		scaleX:false,
		afterFinishInternal:function(c){
			new Effect.Scale(b,1,{
				scaleContent:false,
				scaleY:false,
				afterFinishInternal:function(d){
					d.element.hide().undoClipping().setStyle(a)
				}
			})
		}
	},arguments[1]||{}))
};

Effect.Morph=Class.create(Effect.Base,{
	initialize:function(c){
		this.element=$(c);
		if(!this.element){throw (Effect._elementDoesNotExistError)}
		var a=Object.extend({
			style:{}
		},arguments[1]||{});
		
		if(!Object.isString(a.style)){this.style=$H(a.style)}
		else{
			if(a.style.include(":")){
				this.style=a.style.parseStyle()
			}else{
				this.element.addClassName(a.style);
				this.style=$H(this.element.getStyles());
				this.element.removeClassName(a.style);
				var b=this.element.getStyles();
				this.style=this.style.reject(function(d){
					return d.value==b[d.key]
				});
				a.afterFinishInternal=function(d){
					d.element.addClassName(d.options.style);
					d.transforms.each(function(e){
						d.element.style[e.style]=""
					})
				}
			}
		}
		this.start(a)
	},
	
	setup:function(){
		function a(b){
			if(!b||["rgba(0, 0, 0, 0)","transparent"].include(b)){b="#ffffff"}
			b=b.parseColor();
			return $R(0,2).map(function(c){
				return parseInt(b.slice(c*2+1,c*2+3),16)
			})
		}
		this.transforms=this.style.map(function(g){
			var f=g[0],e=g[1],d=null;
			
			if(e.parseColor("#zzzzzz")!="#zzzzzz"){
				e=e.parseColor();
				d="color"
			}else{
				if(f=="opacity"){
					e=parseFloat(e);
					if(Prototype.Browser.IE&&(!this.element.currentStyle.hasLayout)){
						this.element.setStyle({zoom:1})
					}
				}else{
					if(Element.CSS_LENGTH.test(e)){
						var c=e.match(/^([\+\-]?[0-9\.]+)(.*)$/);
						e=parseFloat(c[1]);
						d=(c.length==3)?c[2]:null
					}
				}
			}
			var b=this.element.getStyle(f);
			return{
				style:f.camelize(),
				originalValue:d=="color"?a(b):parseFloat(b||0),
				targetValue:d=="color"?a(e):e,
				unit:d
			}
		}.bind(this)).reject(function(b){
			return(
				(b.originalValue==b.targetValue)||
				(
				 b.unit!="color"&&
					(isNaN(b.originalValue)||isNaN(b.targetValue))
				)
			)
		})
	},
	update:function(a){
		var d={},b,c=this.transforms.length;
		while(c--){
			d[(b=this.transforms[c]).style]=b.unit=="color"?"#"+
			(Math.round(b.originalValue[0]+(b.targetValue[0]-b.originalValue[0])*a)).toColorPart()+
			(Math.round(b.originalValue[1]+(b.targetValue[1]-b.originalValue[1])*a)).toColorPart()+
			(Math.round(b.originalValue[2]+(b.targetValue[2]-b.originalValue[2])*a)).toColorPart():
			(b.originalValue+(b.targetValue-b.originalValue)*a).toFixed(3)+(b.unit===null?"":b.unit)
		}
		this.element.setStyle(d,true)
	}
});

Effect.Transform=Class.create({
	initialize:function(a){
		this.tracks=[];
		this.options=arguments[1]||{};
		this.addTracks(a)
	},
	addTracks:function(a){
		a.each(function(b){
			b=$H(b);
			var c=b.values().first();
			this.tracks.push($H({
				ids:b.keys().first(),
				effect:Effect.Morph,
				options:{style:c}
			}))
		}.bind(this));
		return this
	},
	play:function(){
		return new Effect.Parallel(
			this.tracks.map(function(a){
				var d=a.get("ids"),c=a.get("effect"),b=a.get("options");
				var e=[$(d)||$$(d)].flatten();
				return e.map(function(f){return new c(f,Object.extend({sync:true},b))})
			}).flatten(),
			this.options
		)
	}
});

Element.CSS_PROPERTIES=$w(
	"backgroundColor backgroundPosition borderBottomColor borderBottomStyle"+
	"borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth"+
	"borderRightColor borderRightStyle borderRightWidth borderSpacing"+
	"borderTopColor borderTopStyle borderTopWidth bottom clip color"+
	"fontSize fontWeight height left letterSpacing lineHeight"+
	"marginBottom marginLeft marginRight marginTop markerOffset maxHeight"+
	"maxWidth minHeight minWidth opacity outlineColor outlineOffset"+
	"outlineWidth paddingBottom paddingLeft paddingRight paddingTop"+
	"right textIndent top width wordSpacing zIndex");

Element.CSS_LENGTH=/^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;

String.__parseStyleElement=document.createElement("div");
String.prototype.parseStyle=function(){
	var b,a=$H();
	if(Prototype.Browser.WebKit){
		b=new Element("div",{style:this}).style
	}else{
		String.__parseStyleElement.innerHTML='<div style="'+this+'"></div>';
		b=String.__parseStyleElement.childNodes[0].style
	}
	
	Element.CSS_PROPERTIES.each(function(c){
		if(b[c]){a.set(c,b[c])}
	});
	
	if(Prototype.Browser.IE&&this.include("opacity")){
		a.set("opacity",this.match(/opacity:\s*((?:0|1)?(?:\.\d*)?)/)[1])
	}
	
	return a
};

if(document.defaultView&&document.defaultView.getComputedStyle){
	Element.getStyles=function(b){
		var a=document.defaultView.getComputedStyle($(b),null);
		return Element.CSS_PROPERTIES.inject({},function(c,d){
			c[d]=a[d];
			return c
		})
	}
}else{
	Element.getStyles=function(b){
		b=$(b);
		var a=b.currentStyle,c;
		c=Element.CSS_PROPERTIES.inject({},function(d,e){
			d[e]=a[e];
			return d
		});
		if(!c.opacity){c.opacity=b.getOpacity()}
		return c
	}
}

Effect.Methods={
	morph:function(a,b){
		a=$(a);
		new Effect.Morph(a,Object.extend({style:b},arguments[2]||{}));
		return a
	},
	visualEffect:function(c,e,b){
		c=$(c);
		var d=e.dasherize().camelize(),a=d.charAt(0).toUpperCase()+d.substring(1);
		new Effect[a](c,b);
		return c
	},
	highlight:function(b,a){
		b=$(b);
		new Effect.Highlight(b,a);
		return b
	}
};

$w("fade appear grow shrink fold blindUp blindDown slideUp slideDown pulsate shake puff squish switchOff dropOut").each(
	function(a){
		Effect.Methods[a]=function(c,b){
			c=$(c);
			Effect[a.charAt(0).toUpperCase()+a.substring(1)](c,b);
			return c
		}
	}
);

$w("getInlineOpacity forceRerendering setContentZoom collectTextNodes collectTextNodesIgnoreClass getStyles").each(
	function(a){Effect.Methods[a]=Element[a]}
);

Element.addMethods(Effect.Methods);/**
 * @author Ryan Johnson <http://syntacticx.com/>
 * @copyright 2008 PersonalGrid Corporation <http://personalgrid.com/>
 * @package LivePipe UI
 * @license MIT
 * @url http://livepipe.net/core
 * @require prototype.js
 */

if(Object.isUndefined(Effect)){
	throw ("dragdrop.js requires including script.aculo.us' effects.js library")
}
var Droppables={
	drops:[],
	
	remove:function(a){
		this.drops=this.drops.reject(function(b){return b.element==$(a)})
	},
	add:function(b){
		b=$(b);
		var a=Object.extend({
			greedy:true,
			hoverclass:null,
			tree:false
		},arguments[1]||{});
		
		// cache containers
		if(a.containment){
			a._containers=[];
			var c=a.containment;
			if(Object.isArray(c)){
				c.each(function(d){a._containers.push($(d))})
			}else{
				a._containers.push($(c))
			}
		}
		
		if(a.accept){a.accept=[a.accept].flatten()}
		
		Element.makePositioned(b);	// fix IE
		a.element=b;
		this.drops.push(a)
	},
	
	findDeepestChild:function(a){
		deepest=a[0];
		
		for(i=1;i<a.length;++i){
			if(Element.isParent(a[i].element,deepest.element)){
				deepest=a[i]
			}
		}
		return deepest
	},
	
	isContained:function(b,a){
		var c;
		if(a.tree){
			c=b.treeNode
		}else{
			c=b.parentNode
		}
		return a._containers.detect(function(d){return c==d})
	},
	
	isAffected:function(a,c,b){
		return(
			(b.element!=c)&&
			((!b._containers)||
				this.isContained(c,b))&&
			((!b.accept)||
				(Element.classNames(c).detect(
					function(d){return b.accept.include(d)})))&&
			Position.within(b.element,a[0],a[1]))
	},
	
	deactivate:function(a){
		if(a.hoverclass){
			Element.removeClassName(a.element,a.hoverclass)
		}
		this.last_active=null
	},
	
	activate:function(a){
		if(a.hoverclass){
			Element.addClassName(a.element,a.hoverclass)
		}
		this.last_active=a
	},
	
	show:function(a,c){
		if(!this.drops.length){return}
		var b,d=[];
		
		this.drops.each(function(e){
			if(Droppables.isAffected(a,c,e)){d.push(e)}
		});
		
		if(d.length>0){
			b=Droppables.findDeepestChild(d)
		}
		if(this.last_active&&this.last_active!=b){this.deactivate(this.last_active)}
		if(b){
			Position.within(b.element,a[0],a[1]);
			if(b.onHover){
				b.onHover(c,b.element,Position.overlap(b.overlap,b.element))
			}
			if(b!=this.last_active){Droppables.activate(b)}
		}
	},
	
	fire:function(b,a){
		if(!this.last_active){return}
		Position.prepare();
		
		if(this.isAffected([Event.pointerX(b),Event.pointerY(b)],a,this.last_active)){
			if(this.last_active.onDrop){
				this.last_active.onDrop(a,this.last_active.element,b);
				return true
			}
		}
	},
	
	reset:function(){
		if(this.last_active){
			this.deactivate(this.last_active)
		}
	}
};

var Draggables={
	drags:[],
	observers:[],
	
	register:function(a){
		if(this.drags.length==0){
			this.eventMouseUp=this.endDrag.bindAsEventListener(this);
			this.eventMouseMove=this.updateDrag.bindAsEventListener(this);
			this.eventKeypress=this.keyPress.bindAsEventListener(this);
			
			Event.observe(document,"mouseup",this.eventMouseUp);
			Event.observe(document,"mousemove",this.eventMouseMove);
			Event.observe(document,"keypress",this.eventKeypress)
		}
		this.drags.push(a)
	},
	
	unregister:function(a){
		this.drags=this.drags.reject(function(b){return b==a});
		if(this.drags.length==0){
			Event.stopObserving(document,"mouseup",this.eventMouseUp);
			Event.stopObserving(document,"mousemove",this.eventMouseMove);
			Event.stopObserving(document,"keypress",this.eventKeypress)
		}
	},
	
	activate:function(a){
		if(a.options.delay){
			this._timeout=setTimeout(function(){
				Draggables._timeout=null;
				window.focus();
				Draggables.activeDraggable=a
			}.bind(this),a.options.delay)
		}else{
			window.focus();	// allows keypress events if window isn't currently focused, fails for Safari
			this.activeDraggable=a
		}
	},
	
	deactivate:function(){
		this.activeDraggable=null
	},
	
	updateDrag:function(a){
		if(!this.activeDraggable){return}
		var b=[Event.pointerX(a),Event.pointerY(a)];
		// Mozilla-based browsers fire successive mousemove events with
		// the same coordinates, prevent needless redrawing (moz bug?)
		if(this._lastPointer&&(this._lastPointer.inspect()==b.inspect())){return}
		this._lastPointer=b;
		
		this.activeDraggable.updateDrag(a,b)
	},
	
	endDrag:function(a){
		if(this._timeout){
			clearTimeout(this._timeout);
			this._timeout=null
		}
		if(!this.activeDraggable){return}
		this._lastPointer=null;
		this.activeDraggable.endDrag(a);
		this.activeDraggable=null
	},
	
	keyPress:function(a){
		if(this.activeDraggable){
			this.activeDraggable.keyPress(a)
		}
	},
	
	addObserver:function(a){
		this.observers.push(a);
		this._cacheObserverCallbacks()
	},
	
	removeObserver:function(a){	// element instead of observer fixes mem leaks
		this.observers=this.observers.reject(function(b){return b.element==a});
		this._cacheObserverCallbacks()
	},
	
	notify:function(b,a,c){	// 'onStart', 'onEnd', 'onDrag'
		if(this[b+"Count"]>0){
			this.observers.each(function(d){
				if(d[b]){d[b](b,a,c)}
			})
		}
		if(a.options[b]){a.options[b](a,c)}
	},
	
	_cacheObserverCallbacks:function(){
		["onStart","onEnd","onDrag"].each(function(a){
			Draggables[a+"Count"]=Draggables.observers.select(
				function(b){return b[a]}
			).length
		})
	}
};
/*--------------------------------------------------------------------------*/
var Draggable=Class.create({
	initialize:function(b){
		var c={
			handle:false,
			reverteffect:function(f,e,d){
				var g=Math.sqrt(Math.abs(e^2)+Math.abs(d^2))*0.02;
				new Effect.Move(f,{x:-d,y:-e,duration:g,queue:{scope:"_draggable",position:"end"}})
			},
			endeffect:function(e){
				var d=Object.isNumber(e._opacity)?e._opacity:1;
				new Effect.Opacity(e,{duration:0.2,from:0.7,to:d,
					queue:{scope:"_draggable",position:"end"},
					afterFinish:function(){
						Draggable._dragging[e]=false
					}
				})
			},
			zindex:1000,
			revert:false,
			quiet:false,
			scroll:false,
			scrollSensitivity:20,
			scrollSpeed:15,
			snap:false,	// false, or xy or [x,y] or function(x,y){ return [x,y] }
			delay:0
		};
		
		if(!arguments[1]||Object.isUndefined(arguments[1].endeffect)){
			Object.extend(c,{
				starteffect:function(d){
					d._opacity=Element.getOpacity(d);
					Draggable._dragging[d]=true;
					new Effect.Opacity(d,{duration:0.2,from:d._opacity,to:0.7})
				}
			})
		}
		
		var a=Object.extend(c,arguments[1]||{});
		
		this.element=$(b);
		
		if(a.handle&&Object.isString(a.handle)){
			this.handle=this.element.down("."+a.handle,0)}
		if(!this.handle){this.handle=$(a.handle)}
		if(!this.handle){this.handle=this.element}
		if(a.scroll&&!a.scroll.scrollTo&&!a.scroll.outerHTML){
			a.scroll=$(a.scroll);
			this._isScrollChild=Element.childOf(this.element,a.scroll)
		}
		
		Element.makePositioned(this.element); // fix IE 
		
		this.options=a;
		this.dragging=false;
		this.eventMouseDown=this.initDrag.bindAsEventListener(this);
		Event.observe(this.handle,"mousedown",this.eventMouseDown);
		Draggables.register(this)
	},
	
	destroy:function(){
		Event.stopObserving(this.handle,"mousedown",this.eventMouseDown);
		Draggables.unregister(this)
	},
	
	currentDelta:function(){
		return([
			parseInt(Element.getStyle(this.element,"left")||"0"),
			parseInt(Element.getStyle(this.element,"top")||"0")])
	},
	
	initDrag:function(a){
		if(!Object.isUndefined(Draggable._dragging[this.element])&&Draggable._dragging[this.element]){return}
		if(Event.isLeftClick(a)){
			// abort on form elements, fixes a Firefox issue
			var c=Event.element(a);
			if((tag_name=c.tagName.toUpperCase())&&(
				tag_name=="INPUT"||
				tag_name=="SELECT"||
				tag_name=="OPTION"||
				tag_name=="BUTTON"||
				tag_name=="TEXTAREA")){return}
			
			var b=[Event.pointerX(a),Event.pointerY(a)];
			var d=Position.cumulativeOffset(this.element);
			this.offset=[0,1].map(function(e){return(b[e]-d[e])});
			
			Draggables.activate(this);
			Event.stop(a)
		}
	},
	
	startDrag:function(b){
		this.dragging=true;
		if(!this.delta){
			this.delta=this.currentDelta()
		}
		
		if(this.options.zindex){
			this.originalZ=parseInt(Element.getStyle(this.element,"z-index")||0);
			this.element.style.zIndex=this.options.zindex
		}
		
		if(this.options.ghosting){
			this._clone=this.element.cloneNode(true);
			this.element._originallyAbsolute=(this.element.getStyle("position")=="absolute");
			if(!this.element._originallyAbsolute){
				Position.absolutize(this.element)
			}
			this.element.parentNode.insertBefore(this._clone,this.element)
		}
		
		if(this.options.scroll){
			if(this.options.scroll==window){
				var a=this._getWindowScroll(this.options.scroll);
				this.originalScrollLeft=a.left;
				this.originalScrollTop=a.top
			}else{
				this.originalScrollLeft=this.options.scroll.scrollLeft;
				this.originalScrollTop=this.options.scroll.scrollTop
			}
		}
		
		Draggables.notify("onStart",this,b);
		
		if(this.options.starteffect){this.options.starteffect(this.element)}
	},
	
	updateDrag:function(event,pointer){
		if(!this.dragging){this.startDrag(event)}
		
		if(!this.options.quiet){
			Position.prepare();
			Droppables.show(pointer,this.element)
		}
		
		Draggables.notify("onDrag",this,event);
		
		this.draw(pointer);
		if(this.options.change){this.options.change(this)}
		
		if(this.options.scroll){
			this.stopScrolling();
			
			var p;
			if(this.options.scroll==window){
				with(this._getWindowScroll(this.options.scroll)){p=[left,top,left+width,top+height]}
			}else{
				p=Position.page(this.options.scroll);
				p[0]+=this.options.scroll.scrollLeft+Position.deltaX;
				p[1]+=this.options.scroll.scrollTop+Position.deltaY;
				p.push(p[0]+this.options.scroll.offsetWidth);
				p.push(p[1]+this.options.scroll.offsetHeight)
			}
			var speed=[0,0];
			if(pointer[0]<(p[0]+this.options.scrollSensitivity)){speed[0]=pointer[0]-(p[0]+this.options.scrollSensitivity)}
			if(pointer[1]<(p[1]+this.options.scrollSensitivity)){speed[1]=pointer[1]-(p[1]+this.options.scrollSensitivity)}
			if(pointer[0]>(p[2]-this.options.scrollSensitivity)){speed[0]=pointer[0]-(p[2]-this.options.scrollSensitivity)}
			if(pointer[1]>(p[3]-this.options.scrollSensitivity)){speed[1]=pointer[1]-(p[3]-this.options.scrollSensitivity)}
			this.startScrolling(speed)
		}
		
		// fix AppleWebKit rendering
		if(Prototype.Browser.WebKit){window.scrollBy(0,0)}
		
		Event.stop(event)
	},
	
	finishDrag:function(b,f){
		this.dragging=false;
		
		if(this.options.quiet){
			Position.prepare();
			var e=[Event.pointerX(b),Event.pointerY(b)];
			Droppables.show(e,this.element)
		}
		
		if(this.options.ghosting){
			if(!this.element._originallyAbsolute){
				Position.relativize(this.element)
			}
			delete this.element._originallyAbsolute;
			Element.remove(this._clone);
			this._clone=null
		}
		
		var g=false;
		if(f){
			g=Droppables.fire(b,this.element);
			if(!g){g=false}
		}
		if(g&&this.options.onDropped){this.options.onDropped(this.element)}
		Draggables.notify("onEnd",this,b);
		
		var a=this.options.revert;
		if(a&&Object.isFunction(a)){a=a(this.element)}
		
		var c=this.currentDelta();
		if(a&&this.options.reverteffect){
			if(g==0||a!="failure"){
				this.options.reverteffect(this.element,
					c[1]-this.delta[1],c[0]-this.delta[0])
			}
		}else{
			this.delta=c
		}
		
		if(this.options.zindex){
			this.element.style.zIndex=this.originalZ
		}
		
		if(this.options.endeffect){
			this.options.endeffect(this.element)
		}
		
		Draggables.deactivate(this);
		Droppables.reset()
	},
	
	keyPress:function(a){
		if(a.keyCode!=Event.KEY_ESC){return}
		this.finishDrag(a,false);
		Event.stop(a)
	},
	
	endDrag:function(a){
		if(!this.dragging){return}
		this.stopScrolling();
		this.finishDrag(a,true);
		Event.stop(a)
	},
	
	draw:function(a){
		var g=Position.cumulativeOffset(this.element);
		if(this.options.ghosting){
			var c=Position.realOffset(this.element);
			g[0]+=c[0]-Position.deltaX;g[1]+=c[1]-Position.deltaY
		}
		
		var f=this.currentDelta();
		g[0]-=f[0];g[1]-=f[1];
		
		if(this.options.scroll&&(this.options.scroll!=window&&this._isScrollChild)){
			g[0]-=this.options.scroll.scrollLeft-this.originalScrollLeft;
			g[1]-=this.options.scroll.scrollTop-this.originalScrollTop
		}
		
		var e=[0,1].map(function(d){
			return(a[d]-g[d]-this.offset[d])
		}.bind(this));
		
		if(this.options.snap){
			if(Object.isFunction(this.options.snap)){
				e=this.options.snap(e[0],e[1],this)
			}else{
			if(Object.isArray(this.options.snap)){
				e=e.map(function(d,h){
					return(d/this.options.snap[h]).round()*this.options.snap[h]}.bind(this))
			}else{
				e=e.map(function(d){
					return(d/this.options.snap).round()*this.options.snap}.bind(this))
			}
		}}
		
		var b=this.element.style;
		if((!this.options.constraint)||(this.options.constraint=="horizontal")){
			b.left=e[0]+"px"}
		if((!this.options.constraint)||(this.options.constraint=="vertical")){
			b.top=e[1]+"px"}
		if(b.visibility=="hidden"){b.visibility=""}	// fix gecko rendering
	},
	
	stopScrolling:function(){
		if(this.scrollInterval){
			clearInterval(this.scrollInterval);
			this.scrollInterval=null;
			Draggables._lastScrollPointer=null
		}
	},
	
	startScrolling:function(a){
		if(!(a[0]||a[1])){return}
		this.scrollSpeed=[a[0]*this.options.scrollSpeed,a[1]*this.options.scrollSpeed];
		this.lastScrolled=new Date();
		this.scrollInterval=setInterval(this.scroll.bind(this),10)
	},
	
	scroll:function(){
		var current=new Date();
		var delta=current-this.lastScrolled;
		this.lastScrolled=current;
		if(this.options.scroll==window){
			with(this._getWindowScroll(this.options.scroll)){
				if(this.scrollSpeed[0]||this.scrollSpeed[1]){
					var d=delta/1000;
					this.options.scroll.scrollTo(left+d*this.scrollSpeed[0],top+d*this.scrollSpeed[1])
				}
			}
		}else{
			this.options.scroll.scrollLeft+=this.scrollSpeed[0]*delta/1000;
			this.options.scroll.scrollTop+=this.scrollSpeed[1]*delta/1000
		}
		
		Position.prepare();
		Droppables.show(Draggables._lastPointer,this.element);
		Draggables.notify("onDrag",this);
		if(this._isScrollChild){
			Draggables._lastScrollPointer=Draggables._lastScrollPointer||$A(Draggables._lastPointer);
			Draggables._lastScrollPointer[0]+=this.scrollSpeed[0]*delta/1000;
			Draggables._lastScrollPointer[1]+=this.scrollSpeed[1]*delta/1000;
			if(Draggables._lastScrollPointer[0]<0){
				Draggables._lastScrollPointer[0]=0}
			if(Draggables._lastScrollPointer[1]<0){
				Draggables._lastScrollPointer[1]=0}
			this.draw(Draggables._lastScrollPointer)
		}
		
		if(this.options.change){this.options.change(this)}
	},
	
	_getWindowScroll:function(w){
		var T,L,W,H;
		with(w.document){
			if(w.document.documentElement&&documentElement.scrollTop){
				T=documentElement.scrollTop;
				L=documentElement.scrollLeft
			}else{
				if(w.document.body){
					T=body.scrollTop;
					L=body.scrollLeft
				}
			}
			if(w.innerWidth){
				W=w.innerWidth;
				H=w.innerHeight
			}else{
				if(w.document.documentElement&&documentElement.clientWidth){
					W=documentElement.clientWidth;
					H=documentElement.clientHeight
				}else{
					W=body.offsetWidth;
					H=body.offsetHeight
				}
			}
		}
		return{top:T,left:L,width:W,height:H}
	}
});

Draggable._dragging={};

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

var SortableObserver=Class.create({
	initialize:function(b,a){
		this.element=$(b);
		this.observer=a;
		this.lastValue=Sortable.serialize(this.element)
	},
	
	onStart:function(){
		this.lastValue=Sortable.serialize(this.element)
	},
	
	onEnd:function(){
		Sortable.unmark();
		if(this.lastValue!=Sortable.serialize(this.element)){
			this.observer(this.element)}
	}
});

var Sortable={
	SERIALIZE_RULE:/^[^_\-](?:[A-Za-z0-9\-\_]*)[_](.*)$/,
	
	sortables:{},
	
	_findRootElement:function(a){
		while(a.tagName.toUpperCase()!="BODY"){
			if(a.id&&Sortable.sortables[a.id]){return a}
			a=a.parentNode
		}
	},
	
	options:function(a){
		a=Sortable._findRootElement($(a));
		if(!a){return}
		return Sortable.sortables[a.id]
	},
	
	destroy:function(a){
		var b=Sortable.options(a);
		
		if(b){
			Draggables.removeObserver(b.element);
			b.droppables.each(function(c){Droppables.remove(c)});
			b.draggables.invoke("destroy");
			
			delete Sortable.sortables[b.element.id]
		}
	},
	
	create:function(c){
		c=$(c);
		var b=Object.extend({
			element:c,
			tag:"li",				// assumes li children, override with tag: 'tagname'
			dropOnEmpty:false,
			tree:false,
			treeTag:"ul",
			overlap:"vertical",		// one of 'vertical', 'horizontal'
			constraint:"vertical",	// one of 'vertical', 'horizontal', false
			containment:c,			// also takes array of elements (or id's); or false
			handle:false,			// or a CSS class
			only:false,
			delay:0,
			hoverclass:null,
			ghosting:false,
			quiet:false,
			scroll:false,
			scrollSensitivity:20,
			scrollSpeed:15,
			format:this.SERIALIZE_RULE,
			
			// these take arrays of elements or ids and can be 
			// used for better initialization performance
			elements:false,
			handles:false,
			
			onChange:Prototype.emptyFunction,
			onUpdate:Prototype.emptyFunction
		},arguments[1]||{});
		
		// clear any old sortable with same element
		this.destroy(c);
		
		// build options for the draggables
		var a={
			revert:true,
			quiet:b.quiet,
			scroll:b.scroll,
			scrollSpeed:b.scrollSpeed,
			scrollSensitivity:b.scrollSensitivity,
			delay:b.delay,
			ghosting:b.ghosting,
			constraint:b.constraint,
			handle:b.handle
		};
		
		if(b.starteffect){
			a.starteffect=b.starteffect}
			
		if(b.reverteffect){
			a.reverteffect=b.reverteffect
		}else{
			if(b.ghosting){
				a.reverteffect=function(f){
					f.style.top=0;
					f.style.left=0
				}
			}
			
		}if(b.endeffect){
			a.endeffect=b.endeffect}
		if(b.zindex){
			a.zindex=b.zindex}
		
		// build options for the droppables  
		var d={
			overlap:b.overlap,
			containment:b.containment,
			tree:b.tree,
			hoverclass:b.hoverclass,
			onHover:Sortable.onHover
		};
		
		var e={
			onHover:Sortable.onEmptyHover,
			overlap:b.overlap,
			containment:b.containment,
			hoverclass:b.hoverclass
		};
		
		// fix for gecko engine
		Element.cleanWhitespace(c);
		
		b.draggables=[];
		b.droppables=[];
		
		// drop on empty handling
		if(b.dropOnEmpty||b.tree){
			Droppables.add(c,e);
			b.droppables.push(c)
		}
		
		(b.elements||this.findElements(c,b)||[]).each(function(h,f){
			var g=b.handles?$(b.handles[f]):
				(b.handle?$(h).select("."+b.handle)[0]:h);
			b.draggables.push(
				new Draggable(h,Object.extend(a,{handle:g})));
			Droppables.add(h,d);
			if(b.tree){h.treeNode=c}
			b.droppables.push(h)
		});
		
		if(b.tree){
			(Sortable.findTreeElements(c,b)||[]).each(function(f){
				Droppables.add(f,e);
				f.treeNode=c;
				b.droppables.push(f)
			})
		}
		
		// keep reference
		this.sortables[c.id]=b;
		
		// for onupdate
		Draggables.addObserver(new SortableObserver(c,b.onUpdate))
	},
	
	// return all suitable-for-sortable elements in a guaranteed order
	findElements:function(b,a){
		return Element.findChildren(
			b,a.only,a.tree?true:false,a.tag)
	},
	
	findTreeElements:function(b,a){
		return Element.findChildren(
			b,a.only,a.tree?true:false,a.treeTag)
	},
	
	onHover:function(e,d,a){
		if(Element.isParent(d,e)){return}
		
		if(a>0.33&&a<0.66&&Sortable.options(d).tree){
			return
		}else{if(a>0.5){
			Sortable.mark(d,"before");
			if(d.previousSibling!=e){
				var b=e.parentNode;
				e.style.visibility="hidden";// fix gecko rendering
				d.parentNode.insertBefore(e,d);
				if(d.parentNode!=b){
					Sortable.options(b).onChange(e)}
				Sortable.options(d.parentNode).onChange(e)
			}
		}else{
			Sortable.mark(d,"after");
			var c=d.nextSibling||null;
			if(c!=e){
				var b=e.parentNode;
				e.style.visibility="hidden";// fix gecko rendering
				d.parentNode.insertBefore(e,c);
				if(d.parentNode!=b){
					Sortable.options(b).onChange(e)}
				Sortable.options(d.parentNode).onChange(e)
			}
		}
	}
},

onEmptyHover:function(e,g,h){
	var k=e.parentNode;
	var a=Sortable.options(g);
	
	if(!Element.isParent(g,e)){
		var f;
		
		var c=Sortable.findElements(g,{tag:a.tag,only:a.only});
		var b=null;
		
		if(c){
			var d=Element.offsetSize(g,a.overlap)*(1-h);
			
			for(f=0;f<c.length;f+=1){
				if(d-Element.offsetSize(c[f],a.overlap)>=0){
					d-=Element.offsetSize(c[f],a.overlap)
				}else{
					if(d-(Element.offsetSize(c[f],a.overlap)/2)>=0){
						b=f+1<c.length?c[f+1]:null;
						break
					}else{
						b=c[f];
						break
					}
				}
			}
		}
		
		g.insertBefore(e,b);
		
		Sortable.options(k).onChange(e);
		a.onChange(e)
	}
},

unmark:function(){
	if(Sortable._marker){Sortable._marker.hide()}
},

mark:function(b,a){
	// mark on ghosting only
	var d=Sortable.options(b.parentNode);
	if(d&&!d.ghosting){return}
	
	if(!Sortable._marker){
		Sortable._marker=($("dropmarker")||Element.extend(document.createElement("DIV"))).
			hide().addClassName("dropmarker").setStyle({position:"absolute"});
		document.getElementsByTagName("body").item(0).appendChild(Sortable._marker)
	}
	var c=Position.cumulativeOffset(b);
	Sortable._marker.setStyle({left:c[0]+"px",top:c[1]+"px"});
	
	if(a=="after"){
		if(d.overlap=="horizontal"){
			Sortable._marker.setStyle({left:(c[0]+b.clientWidth)+"px"})
		}else{
			Sortable._marker.setStyle({top:(c[1]+b.clientHeight)+"px"})
		}
	}
	Sortable._marker.show()
},

_tree:function(e,b,f){
	var d=Sortable.findElements(e,b)||[];
	
	for(var c=0;c<d.length;++c){
		var a=d[c].id.match(b.format);
		if(!a){continue}
		
		var g={
			id:encodeURIComponent(a?a[1]:null),
			element:e,
			parent:f,
			children:[],
			position:f.children.length,
			container:$(d[c]).down(b.treeTag)
		};
		
		/* Get the element containing the children and recurse over it */
		if(g.container){
			this._tree(g.container,b,g)}
		
		f.children.push(g)
	}
	return f
},

tree:function(d){
	d=$(d);
	var c=this.options(d);
	var b=Object.extend({
		tag:c.tag,
		treeTag:c.treeTag,
		only:c.only,
		name:d.id,
		format:c.format
	},arguments[1]||{});
	
	var a={
		id:null,
		parent:null,
		children:[],
		container:d,
		position:0
	};
	
	return Sortable._tree(d,b,a)
},

/* Construct a [i] index for a particular node */
_constructIndex:function(b){
	var a="";
	do{
		if(b.id){a="["+b.position+"]"+a}
	}while((b=b.parent)!=null);
	return a
},

sequence:function(b){
	b=$(b);
	var a=Object.extend(this.options(b),arguments[1]||{});
	
	return $(this.findElements(b,a)||[]).map(function(c){
		return c.id.match(a.format)?c.id.match(a.format)[1]:""
	})
},

setSequence:function(b,c){
	b=$(b);
	var a=Object.extend(this.options(b),arguments[2]||{});
	
	var d={};
	this.findElements(b,a).each(function(e){
		if(e.id.match(a.format)){
			d[e.id.match(a.format)[1]]=[e,e.parentNode]}
		e.parentNode.removeChild(e)
	});
	
	c.each(function(e){
		var f=d[e];
		if(f){
			f[1].appendChild(f[0]);
			delete d[e]
		}
	})
},

serialize:function(c){
	c=$(c);
	var b=Object.extend(Sortable.options(c),arguments[1]||{});
	var a=encodeURIComponent((arguments[1]&&arguments[1].name)?arguments[1].name:c.id);
	
	if(b.tree){
		return Sortable.tree(c,arguments[1]).children.map(function(d){
			return[a+Sortable._constructIndex(d)+"[id]="+encodeURIComponent(d.id)].concat(d.children.map(arguments.callee))
		}).flatten().join("&")
	}else{
		return Sortable.sequence(c,arguments[1]).map(function(d){
			return a+"[]="+encodeURIComponent(d)}).join("&")}
	}
};

// Returns true if child is contained within element
Element.isParent=function(b,a){
	if(!b.parentNode||b==a){return false}
	if(b.parentNode==a){return true}
	return Element.isParent(b.parentNode,a)
};

Element.findChildren=function(d,b,a,c){
	if(!d.hasChildNodes()){return null}
	c=c.toUpperCase();
	if(b){b=[b].flatten()}
	var e=[];
	$A(d.childNodes).each(function(g){
		if(g.tagName&&g.tagName.toUpperCase()==c&&
			(!b||(Element.classNames(g).detect(function(h){return b.include(h)})))){e.push(g)}
		if(a){
			var f=Element.findChildren(g,b,a,c);
			if(f){e.push(f)}
		}
	});
	
	return(e.length>0?e.flatten():[])
};

Element.offsetSize=function(a,b){
	return a["offset"+((b=="vertical"||b=="height")?"Height":"Width")]
};

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

menuClassName="menuNavigation";
var HomeMenu=Class.create({
	inizialize:function(a){
		this.menu=a
	},
	closeSub:function(b){
		for(var a=0;a<b.childNodes.length;a++){
			if(b.childNodes[a].nodeName.toLowerCase()=="li"){
				li=b.childNodes[a];
				li.onmouseover=li.onactivate=li.onfocus=function(){
					if(this.subMenu){
						elem=this;
						elem.className=elem.className+" currentSel";
						this.subMenu.className=this.subMenu.className.replace(/subMenu-off/g,"subMenu-on")
					}
				};
				li.onmouseout=li.ondeactivate=li.onblur=function(){
					if(this.subMenu){
						elem=this;
						elem.className=elem.className.replace(/currentSel/g,"");
						menuObj.closeSub(this.subMenu)
					}
				};
				for(j=0;j<li.childNodes.length;j++){
					if(li.childNodes[j].nodeName.toLowerCase()=="ul"||li.childNodes[j].nodeName.toLowerCase()=="ol"){
						this.closeSub(li.subMenu=li.childNodes[j])
					}
				}
			}
		}
		b.className=b.className.replace(/\s?subMenu-on/g,"")+" subMenu-off"
	}
});

var menuObj;
var onFocusManager={
	process:function(a){
		menuObj=new HomeMenu();
		if(tags_=document.getElementsByTagName("ul")){
			for(i=0;i<tags_.length;i++){
				if(tags_[i].className==menuClassName){
					menuObj.closeSub(tags_[i])
				}
			}
		}
		if(tags_=document.getElementsByTagName("ol")){
			for(i=0;i<tags_.length;i++){
				if(tags_[i].className==menuClassName){
					menuObj.closeSub(tags_[i])
				}
			}
		}
	}
};

Event.observe(window,"load",onFocusManager.process);
var Menu=Class.create();
Menu.prototype={
	initialize:function(b,a){
		this.name=a;
		this.type="menu";
		this.closeDelayTimer=null;
		this.closingMenuItem=null;
		this.collapseBorders=true;
		this.quickCollapse=true;
		this.closeDelayTime=300;
		this.rootContainer=new MenuContainer(b,this)
	}
};
var MenuContainer=Class.create();
MenuContainer.prototype={
	initialize:function(b,a){
		this.type="menuContainer";
		this.menuItems=[];
		this.setup(b,a)
	},
	setup:function(d,b){
		this.element=$(d);
		this.parent=b;
		this.parentMenu=(this.type=="menuContainer")?((b)?b.parent:null):b;
		this.root=b instanceof Menu?b:b.root;
		this.id=this.element.id;
		if(this.type=="menuContainer"){
			if(this.element.hasClassName("firstSel")){
				this.menuType="horizontal"
			}else{
				if(this.element.hasClassName("secondSel")){
					this.menuType="dropdown"
				}else{
					this.menuType="flyout"
				}
			}
			if(this.menuType=="flyout"||this.menuType=="dropdown"){
				this.isOpen=false;
				Element.setStyle(this.element,{position:"absolute",top:"0px",left:"0px",display:"none"})
			}else{
				this.isOpen=true
			}
		}else{
			this.isOpen=this.parentMenu.isOpen
		}
		var e=this.element.childNodes;
		if(e==null){return}
		for(var a=0;a<e.length;a++){
			var c=e[a];
			if(c.nodeType==1){
				if(this.type=="menuContainer"){
					if(c.tagName.toLowerCase()=="li"){
						this.menuItems.push(new MenuItem(c,this))
					}
				}else{
					if(c.tagName.toLowerCase()=="ul"){
						this.subMenu=new MenuContainer(c,this)
					}
				}
			}
		}
	},
	getBorders:function(d){
		var b=["Left","Top","Right","Bottom"];
		var a={};
		for(var c=0;c<b.length;++c){
			if(this.element.currentStyle){
				var e=parseInt(this.element.currentStyle["border"+b[c]+"Width"])
			}else{
				if(window.getComputedStyle){
					var e=parseInt(window.getComputedStyle(this.element,"").getPropertyValue("border-"+b[c].toLowerCase()+"-width"))
				}else{
					var e=parseInt(this.element.style["border"+b[c]])
				}
			}
			a[b[c].toLowerCase()]=isNaN(e)?0:e
		}
		return a
	},
	open:function(){
		if(this.root.closeDelayTimer){
			window.clearTimeout(this.root.closeDelayTimer)
		}
		this.parentMenu.closeAll(this);
		this.isOpen=true;
		if(this.menuType=="dropdown"){
			var c=0;
			if(this.parent.element.className=="lastFilter"){
				c=Element.getWidth(this.element)-Element.getWidth(this.parent.element)-12
			}
			Element.setStyle(this.element,{
				left:(Element.positionedOffset(this.parent.element)[0]-c)+"px",
				top:(Element.positionedOffset(this.parent.element)[1]+Element.getHeight(this.parent.element))+"px"
			})
		}else{
			if(this.menuType=="flyout"){
				var b=this.parentMenu?this.parentMenu.getBorders():new Object();
				var a=this.getBorders();
				if((Position.positionedOffset(this.parentMenu.element)[0]+this.parentMenu.element.offsetWidth+this.element.offsetWidth+20)>(window.innerWidth?window.innerWidth:document.body.offsetWidth)){
					Element.setStyle(this.element,{
						left:(-this.element.offsetWidth-(this.root.collapseBorders?0:b.left))+"px"
					})
				}else{
					Element.setStyle(this.element,{
						left:(this.parentMenu.element.offsetWidth-b.left-(this.root.collapseBorders?Math.min(b.right,a.left):0))+"px"
					})
				}
				Element.setStyle(this.element,{
					top:(this.parent.element.offsetTop-b.top-this.menuItems[0].element.offsetTop)+"px"
				})
			}
		}
		Element.setStyle(this.element,{display:"block"})
	},
	close:function(){
		Element.setStyle(this.element,{display:"none"});
		this.isOpen=false;this.closeAll()
	},
	closeAll:function(a){
		for(var b=0;b<this.menuItems.length;++b){
			this.menuItems[b].closeItem(a)
		}
	}
};

var MenuItem=Class.create();

Object.extend(Object.extend(MenuItem.prototype,MenuContainer.prototype),{
	initialize:function(idOrElement,parent){
		var menuItem=this;
		this.type="menuItem";
		this.subMenu;
		this.setup(idOrElement,parent);
		if(this.subMenu){
			this.element.onmouseover=function(){
				menuItem.subMenu.open()
			}
		}else{
			if(this.root.quickCollapse){
				this.element.onmouseover=function(){
					menuItem.parentMenu.closeAll()
				}
			}
		}
		var linkTag=this.element.getElementsByTagName("A")[0];
		if(linkTag){
			linkTag.onfocus=this.element.onmouseover;
			this.link=linkTag;
			this.text=linkTag.text
		}
		if(this.subMenu){
			this.element.onmouseout=function(){
				if(menuItem.root.openDelayTimer){
					window.clearTimeout(menuItem.root.openDelayTimer)
				}
				if(menuItem.root.closeDelayTimer){
					window.clearTimeout(menuItem.root.closeDelayTimer)
				}
				eval(menuItem.root.name+".closingMenuItem = menuItem");
				menuItem.root.closeDelayTimer=window.setTimeout(menuItem.root.name+".closingMenuItem.subMenu.close()",menuItem.root.closeDelayTime)
			}
		}
	},
	openItem:function(){
		this.isOpen=true;
		if(this.subMenu){
			this.subMenu.open()
		}
	},
	closeItem:function(a){
		this.isOpen=false;
		if(this.subMenu&&this.subMenu!=a){
			this.subMenu.close()
		}
	}
});

/*var menu,menuFilter;
var MenuManager={
	process:function(){
		Logger.debug("process");
		if($("menu")){
			menu=new Menu("menu","menu")
		}
		if($("menuFilter")){
			menuFilter=new Menu("menuFilter","menuFilter")
		}
	}
};
Event.observe(window,"load",MenuManager.process); */

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

// Google Analytics
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-16222107-8']);
_gaq.push(['_trackPageview']);

(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();

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


function openCopyright() {
	window.open('copyright.html','CopyrightPopup','width=430,height=350,resizable=yes,scrollbars=no,menubar=no,toolbar=no');
};