/*
	Functions from prototype.js (http://prototype.conio.net/)
	Rewritten just a little bit.
*/

function $() {
	for ( var i = 0, elements = []; i < arguments.length; ++i )
		elements.push ( typeof arguments[i] == 'string' ? document.getElementById ( arguments[i] ) : arguments[i] );
	return elements.length == 1 ? elements[0] : elements;
}

function $A ( array ) {
	if ( !array ) return [];
	if ( array.toArray ) return array.toArray();
	for ( var i = 0, result = []; i < array.length; ++i )
		result.push ( array[i] );
	return result;
}

var Class = {
	create: function() { return function() { this.initialize.apply ( this, arguments ); } }
}

Object.extend = function ( dest, source ) {
	for ( p in source ) dest[p] = source[p];
	return dest;
}

Function.prototype.bind = function() {
	var __method = this, args = $A(arguments), obj = args.shift();
	return function() { return __method.apply ( obj, args.concat ( $A ( arguments ) ) ); }
}

Function.prototype.bindAsEventListener = function ( object ) {
	var __method = this;
	return function ( event ) { return __method.call ( object, event || window.event ); }
}

Object.prototype.shift = function() {
	var result = this[0];
	this.length--;
	for ( var i = 0; i < this.length; ++i )
		this[i] = this[i+1];
	return result;
}

var Try = {
	these: function() {
		for ( var i = 0, retval; i < arguments.length; ++i )
			try { retval = arguments[i](); break; } catch(error){}
		return retval;
	}
}


if (!window.Event) {
	var Event = new Object();
}

Object.extend(Event, {
	KEY_BACKSPACE: 8,
	KEY_TAB:	   9,
	KEY_RETURN:   13,
	KEY_ESC:	  27,
	KEY_LEFT:	 37,
	KEY_UP:	   38,
	KEY_RIGHT:	39,
	KEY_DOWN:	 40,
	KEY_DELETE:   46,

	element: function(event) {
		return event.target || event.srcElement;
	},

	isLeftClick: function(event) {
		return (((event.which) && (event.which == 1)) || ((event.button) && (event.button == 1)));
	},

	pointerX: function(event) {
		return event.pageX || (event.clientX + (document.documentElement.scrollLeft || document.body.scrollLeft));
	},

	pointerY: function(event) {
		return event.pageY || (event.clientY + (document.documentElement.scrollTop || document.body.scrollTop));
	},

	stop: function(event) {
		if (event.preventDefault) {
			event.preventDefault();
			event.stopPropagation();
		} else {
			event.returnValue = false;
			event.cancelBubble = true;
		}
	},

	observers: false,

	_observeAndCache: function(element, name, observer, useCapture) {
		if (!this.observers) this.observers = [];
		if (element.addEventListener) {
			this.observers.push([element, name, observer, useCapture]);
			element.addEventListener(name, observer, useCapture);
		} else if (element.attachEvent) {
			this.observers.push([element, name, observer, useCapture]);
			element.attachEvent('on' + name, observer);
		}
	},

	unloadCache: function() {
		if (!Event.observers) return;
		for (var i = 0; i < Event.observers.length; i++) {
			Event.stopObserving.apply(this, Event.observers[i]);
			Event.observers[i][0] = null;
		}
		Event.observers = false;
	},

	observe: function(element, name, observer, useCapture) {
		var element = $(element);
		useCapture = useCapture || false;
		if (name == 'keypress' && (navigator.appVersion.match(/Konqueror|Safari|KHTML/) || element.attachEvent))
			name = 'keydown';
		this._observeAndCache(element, name, observer, useCapture);
	},

	stopObserving: function(element, name, observer, useCapture) {
		var element = $(element);
		useCapture = useCapture || false;

		if (name == 'keypress' && (navigator.appVersion.match(/Konqueror|Safari|KHTML/) || element.detachEvent))
			name = 'keydown';

		if (element.removeEventListener) {
			element.removeEventListener(name, observer, useCapture);
		} else if (element.detachEvent) {
			element.detachEvent('on' + name, observer);
		}
	}
});


// Event stuffs, don't need these anymore, use prototype's observe instead
function addEvent( obj, type, fn, userCapture ) {
	Event.observe ( obj, type, fn, userCapture );
}

function removeEvent( obj, type, fn, userCapture ) {
	Event.stopObserving ( obj, type, fn, userCapture );
}

function addLoadEvent ( func ) {
	var oldonload = window.onload;
	if (typeof window.onload != 'function') window.onload = func;
	else { window.onload = function() { oldonload(); func(); } }
}

/*
	Others stuffs
*/

function getCookie( name ) {
	var start = document.cookie.indexOf( name + "=" );
	var len = start + name.length + 1;
	if ( ( !start ) && ( name != document.cookie.substring( 0, name.length ) ) ) return null;
	if ( start == -1 ) return null;
	var end = document.cookie.indexOf( ";", len );
	if ( end == -1 ) end = document.cookie.length;
	return unescape( document.cookie.substring( len, end ) );
}

function setCookie( name, value, expires, path, domain, secure ) {
	var today = new Date();
	today.setTime( today.getTime() );
	if ( expires )
		expires = expires * 1000 * 60 * 60 * 24;
	var expires_date = new Date( today.getTime() + (expires) );
	document.cookie = name+"="+escape( value ) +
		( ( expires ) ? ";expires="+expires_date.toGMTString() : "" ) + //expires.toGMTString()
		( ( path ) ? ";path=" + path : "" ) + ( ( domain ) ? ";domain=" + domain : "" ) + ( ( secure ) ? ";secure" : "" );
}

function deleteCookie( name, path, domain ) {
	if ( getCookie( name ) ) document.cookie = name + "=" + ( ( path ) ? ";path=" + path : "") +
	( ( domain ) ? ";domain=" + domain : "" ) + ";expires=Thu, 01-Jan-1970 00:00:01 GMT";
}


if ( typeof Array.prototype.push == 'undefined' ) {
	Array.prototype.push = function() {
		for ( var i = 0, l = this.length; i < arguments.length; ++i )
			this[l+i] = arguments[i];
		return this.length;
	}
}

Array.prototype.remove = function(v)
{
	for ( var i = 0; i < this.length; ++i )
		if ( this[i] == v )
			return this.splice(i, 1);
	return false;
}

Object.prototype.toQueryString = function() {
	var query = [];
	for ( var x in this ) {
		var type = typeof this[x];
		if ( type != 'function' && type != 'object' )
			query.push([x, encodeURIComponent(this[x])].join('='));
	}
	return query.join('&');
}

// from: http://jsfromhell.com/string/wordwrap
String.prototype.wordWrap = function(m, b, c){ //v1.0
	var i, j, l, s, r = this.split("\n");
	if(m > 0) for(i = -1, l = r.length; ++i < l;){
		for(s = r[i], r[i] = ""; s.length > m;
			j = c ? m : (j = s.substr(0, m).match(/\S*$/)).input.length - j[0].length
			|| j.input.length + (j = s.substr(m).match(/^\S*/)).input.length + j[0].length,
			r[i] += s.substr(0, j) + ((s = s.substr(j)).length ? b : "")
		);
		r[i] += s;
	}
	return r.join("\n");
};

Object.extend ( String.prototype, {
	escapeHTML: function() {
		var div = document.createElement('div');
		var text = document.createTextNode(this);
		div.appendChild(text);
		return div.innerHTML;
	},

	getTextWidth: function(){
		var span = document.createElement('span');
		Object.extend(span.style, {visibiliy:'hidden', position:'absolute', left:'0px', top:'0px'});
		span.innerHTML = this;
		document.body.appendChild(span);
		var width = span.offsetWidth;
		document.body.removeChild(span);
		return width;
	},

	// from: http://jsfromhell.com/string/wordwrap
	wordWrap: function(m, b, c) {
		var i, j, l, s, r = this.split("\n");
		if(m > 0) for(i = -1, l = r.length; ++i < l;){
			for(s = r[i], r[i] = ""; s.length > m;
				j = c ? m : (j = s.substr(0, m).match(/\S*$/)).input.length - j[0].length
				|| j.input.length + (j = s.substr(m).match(/^\S*/)).input.length + j[0].length,
				r[i] += s.substr(0, j) + ((s = s.substr(j)).length ? b : "")
			);
			r[i] += s;
		}
		return r.join("\n");
	}
});


/* Basic funcs & objs */
function Timer()
{
	this.t=false;
	this.intv=false;
	this.start=function(func,delay){this.stop();this.t=window.setTimeout(func,delay);};
	this.stop=function(){if(this.t)window.clearTimeout(this.t);}
	this.startInterval=function(func,delay){this.intv=window.setInterval(func,delay);};
	this.stopInterval=function(){if(this.intv)window.clearInterval(this.intv);}
}


var quickEditBase = Class.create();
quickEditBase.prototype =
{
	initialize : function() {
		this.options = {inputSize:50, maxInput:255, maxCharsVisible:100, textAlign:'left', maxWidth:100, style:{}};
	},

	setOptions : function(options) {
		Object.extend(this.options, options||{});
	},

	initContainer : function()
	{
		if(!this.container) return false;
		this.oldStyles = { backgroundColor: this.container.style.backgroundColor, color: this.container.style.color };

		this.observers = {
			mouseover: function(){Object.extend(this.container.style, {backgroundColor:'#FFFFE6',cursor:'text',color:'#000'});}.bind(this),
			mouseout: function() { Object.extend(this.container.style, this.oldStyles); }.bind(this),
			mouseclick: this.showEditable.bind(this)
		};

		Event.observe ( this.container, 'mouseover', this.observers.mouseover );
		Event.observe ( this.container, 'mouseout', this.observers.mouseout );
		Event.observe ( this.container, 'click', this.observers.mouseclick );
	},

	restoreContainer: function()
	{
		if(!this.container) return false;
		Object.extend(this.container.style, this.oldStyles);
		this.container.onmouseover = null;
		Event.stopObserving ( this.container, 'mouseover', this.observers.mouseover );
		Event.stopObserving ( this.container, 'mouseout', this.observers.mouseout );
		Event.stopObserving ( this.container, 'click', this.observers.mouseclick );
	},

	showEditable : function()
	{
		this.editBox = document.createElement('span');
		this.inputField = document.createElement('input');
		if(!this.editBox||!this.inputField)return false;
		this.inputField.value = this.value;
		this.inputField.size = this.options.inputSize;
		this.inputField.onkeypress = this.keyPressHandler.bindAsEventListener(this);
		this.inputField.onblur = this.doUpdate.bind(this);
		this.inputField.maxLength = this.options.maxInput;
		this.inputField.style.textAlign = this.options.textAlign;
		this.editBox.className = 'qinput';
		Object.extend(this.editBox.style, this.options.style||{});
		this.editBox.appendChild(this.inputField);
		this.container.parentNode.insertBefore(this.editBox, this.container);
		this.container.style.display = 'none';
		this.inputField.setAttribute('autocomplete', 'off');

		var width = this.inputField.value.getTextWidth();
		this.inputField.style.width = ( width > this.options.maxWidth ? this.options.maxWidth : ( width < 40 ? 40 : width ) ) + 'px';

		this.inputField.focus();
		this.inputField.select();
	},

	hideEditable : function(value)
	{
		var str = value || this.value;
		str = str_slice ( str.escapeHTML(), this.options.maxCharsVisible );
		this.container.innerHTML = str;
		this.container.style.display = '';
		if(this.editBox.parentNode) this.editBox.parentNode.removeChild(this.editBox);
	},

	keyPressHandler : function ( event )
	{
		event = event || window.event;
		var key = event.keyCode;
		if ( key == Event.KEY_RETURN ) {
			this.inputField.onblur = function(){};
			window.setTimeout(this.doUpdate.bind(this), 50);
			return false;
		}
		if ( key == Event.KEY_ESC ) {
			this.hideEditable();
			return;
		}
		var str = this.inputField.value + String.fromCharCode(key);
		var width = str.getTextWidth();
		this.inputField.style.width = ( width > this.options.maxWidth ? this.options.maxWidth : ( width < 40 ? 40 : width ) ) + 'px';
		return true;
	},

	doUpdate : function() {
		alert ( 'doUpdate() must be implemented' );
		this.hideEditable();
	}
};

// Ajax stuffs
var Ajax = {
	events: ['uninitialized', 'loading', 'loaded', 'interactive', 'complete'],
	enabled: ( typeof XMLHttpRequest != 'undefined' || typeof ActiveXObject != 'undefined' ),
	getXMLHttpObject: function ( ) {
		return Try.these (
			function() {return new ActiveXObject('Msxml2.XMLHTTP')},
			function() {return new ActiveXObject('Microsoft.XMLHTTP')},
			function() {return new XMLHttpRequest()}
		) || false;
	}
}

AjaxRequest = Class.create();
AjaxRequest.prototype = {
	initialize: function ( url, options ) {
		this.options	= Object.extend ( { method: 'post', async: true, postData: {}, response: 'json' }, options || {} );
		this.onloading  = null;
		this.onloaded   = null;
		this.oncomplete = null;
		this.response   = null;
		this.xmlhttp	= Ajax.getXMLHttpObject();
		this.url		= url;
	},

	setOptions: function ( options ) {
		this.options = Object.extend ( this.options, options || {} );
	},

	request: function ( url )
	{
		this.url = url || this.url;
		this.xmlhttp.open ( this.options.method, this.url + (this.url.indexOf('?')<0?'?':'&') + 'ajax=' + this.getRand(), this.options.async );
		if ( this.options.async )
			this.xmlhttp.onreadystatechange = this.stateChange.bind(this);
		if ( this.options.method == 'post' )
			this.xmlhttp.setRequestHeader ( 'Content-type','application/x-www-form-urlencoded; charset=utf-8' )
		this.xmlhttp.send ( this.options.method == 'post' ? this.options.postData.toQueryString() : null );
	},

	stateChange: function ( )
	{
		var state = Ajax.events[this.xmlhttp.readyState];
		if ( state == 'loading' && this.onloading != null )
			this.onloading.bind(this)();
		if ( state == 'loaded' && this.onloaded != null )
			this.onloaded.bind(this)();
		if ( state == 'complete' && this.xmlhttp.status == 200 )
		{
			this.response = this.getResponse();
			this.xmlhttp.onreadystatechange = function(){};
			if ( this.oncomplete != null )
				this.oncomplete.bind(this)();
		}
	},

	getResponse: function ( type ) {
		var type = type || this.options.response;
		if ( type == 'json' ) {
			try { eval ( 'var resp = ' + this.xmlhttp.responseText ); return resp; }
			catch (error) { return { result: 'failed', message: 'Returned result is not proper JSON format. Probably parse error.' }; }
		}
		return type == 'xml' ? this.xmlhttp.responseXML : this.xmlhttp.responseText;
	},

	getRand: function ( ) {
		for ( var i = 0, rand = ''; i < 5; ++i )
			rand += String(Math.floor(Math.random()*10000000000));
		return rand;
	}
};

Element = new Object();
Object.extend(Element,
{
	position: function ( element, type )
	{
		element = $(element);
		if ( !element ) return;
		if ( type == 'absolute' && !element._absolute )
		{
			var offset = Element.getOffset ( element, false );
			Object.extend ( element.style, { position: 'absolute', top: offset.offsetTop + 'px', left: offset.offsetLeft } );
			element._absolute = true;
		}
	},

	cumulativeOffset: function(element)
	{
		var valueT = 0, valueL = 0;
		do {
			valueT += element.offsetTop  || 0;
			valueL += element.offsetLeft || 0;
			element = element.offsetParent;
		} while (element);
		return [valueL, valueT];
	},

	setOpacity: function(element, opacity)
	{
		element = $(element);
		if(!element) return false;
		if(element.filters)
		{
			try { element.filters.alpha.opacity = opacity; }
			catch (error) { element.style.filter = "alpha(opacity=" + opacity + ")"; }
		}
		Object.extend ( element.style, { 'opacity': opacity / 100, MozOpacity: opacity / 100, visibility: opacity <= 0 ? 'hidden' : 'visible' } );
	},

	getOffset: function(element, absolute)
	{
		absolute = absolute || false;
		element = $(element);
		if(!element) return false;
		var offset = Object.extend ( Element.cumulativeOffset ( element ) );
		var retval = {offsetWidth: element.offsetWidth, offsetHeight:element.offsetHeight, offsetLeft: offset[0], offsetTop: offset[1]};
		retval.offsetRight = retval.offsetLeft + retval.offsetWidth;
		retval.offsetBottom = retval.offsetTop + retval.offsetHeight;
		return retval;
	},

	fade: function(element, from, to, step)
	{
		element = $(element);
		if(!element) return false;
		if(from == null) from = 100;
		step = step || 10;
		if ( from == to )
		{
			if(typeof element.onfadefinish == 'function')
				element.onfadefinish();
			return true;
		}
		from = Element.__getNextStepValue(from, to, step);
		Element.setOpacity(element, from);
		window.setTimeout ( Element.fade.bind ( this, element, from, to, step ), 10 );
	},

	__getNextStepValue: function(from, to, step)
	{
		if(from > to) from -= (from - to) > step ? step : from - to;
		else from += (to - from) > step ? step : to - from;
		return from;
	}
});

var Form = {
	disable: function(element, disabled) {
		element = $(element);
		if(!element) return false;
		var tagName = element.tagName.toLowerCase();

		if ( tagName == 'form' || tagName == 'input' || tagName == 'textarea' || (tagName == 'fieldset' && document.all) ) {
			element.disabled = disabled;
			return true;
		}
		if(typeof disabled == 'undefined') disabled = true;
		var inputs = element.getElementsByTagName('input');
		for(var i = 0; i < inputs.length; ++i)
			inputs[i].disabled = disabled;
		var inputs = element.getElementsByTagName('textarea');
		for(var i = 0; i < inputs.length; ++i)
			inputs[i].disabled = disabled;
	}
};


var Drag = Class.create();
Drag.prototype = {
	initialize: function(element, options) {
		this.dragObj = $(element);
		if ( !this.dragObj ) return false;
		this.options = { zIndex: 1, horizontal: true, vertical: true, leftBound: 0, rightBound: -1, topBound: 0, bottomBound: -1 };
		Object.extend ( this.dragObj.style, { position: 'absolute' } );
		this.setOptions ( options || this.options );
		this.lastMousePos = [0, 0]; // [x, y]
		this.observers = {
			mouseMove: this.mouseMoveListener.bindAsEventListener(this),
			mouseDown: this.startDrag.bindAsEventListener(this),
			mouseUp: this.stopDrag.bindAsEventListener(this)
		};
		this.ondrag = null;
		this.ondragstart = null;
		this.ondragend = null;
		Event.observe ( this.dragObj, 'mousedown', this.observers.mouseDown );
		Event.observe ( this.dragObj, 'mouseup', this.observers.mouseUp );

		this.dragObj.onmousedown = function(){ return false; }
	},

	setBoundary: function(top, right, bottom, left) {
		this.setOptions({leftBound:left, rightBound:right, topBound:top, bottomBound:bottom});
	},

	setBoundingObject: function(element)
	{
		element = $(element);
		if(!element) return false;
		var offset = Element.getOffset(element);
		this.setBoundary(offset.offsetTop, offset.offsetRight, offset.offsetBottom, offset.offsetLeft);
	},

	setOptions: function(options) {
		Object.extend(this.options, options || {});
	},

	startDrag: function(event)
	{

		if ( !Event.isLeftClick ( event ) ) return false;
		Object.extend ( this.dragObj.style, { zIndex: this.options.zIndex + 1 } );
		Event.observe ( document, 'mousemove', this.observers.mouseMove );
		Event.observe ( document, 'mouseup', this.observers.mouseUp );
		document.onselectstart = function(){return false;};
		document.ondragstart = function(){return false;}

		var offset = Element.getOffset ( this.dragObj, true );
		var mousePosX = ( event.pageX || event.pageY ) ? event.pageX : event.clientX + document.body.scrollLeft;
		var mousePosY = ( event.pageY || event.pageY ) ? event.pageY : event.clientY + document.body.scrollTop;
		this.relativeX = mousePosX - offset.offsetLeft;
		this.relativeY = mousePosY - offset.offsetTop;
		this.dragObjOffset = offset;
		if ( typeof this.ondragstart == 'function' ) this.ondragstart ( Element.getOffset ( this.dragObj, true ) );

		Element.position ( this.dragObj, 'absolute' );
		return false;
	},

	stopDrag: function(event)
	{
		Object.extend ( this.dragObj.style, { zIndex: this.options.zIndex } );
		Event.stopObserving ( document, 'mousemove', this.observers.mouseMove );
		Event.stopObserving ( document, 'mouseup', this.observers.mouseUp );
		document.onselectstart = function(){return true;};
		if ( typeof this.ondragend == 'function' ) this.ondragend ( Element.getOffset ( this.dragObj, true ) );
		Element.position ( this.dragObj, 'relative' );
	},

	mouseMoveListener: function(event)
	{
		var mousePosX = Event.pointerX(event);
		var mousePosY = Event.pointerY(event);
		if ( this.lastMousePos[0] == mousePosX && this.lastMousePos[1] == mousePosY ) return;
		var pos = {
			left: mousePosX - this.relativeX, right: (mousePosX - this.relativeX) + this.dragObjOffset.offsetWidth,
			top: mousePosY - this.relativeY, bottom: (mousePosY - this.relativeY) + this.dragObjOffset.offsetHeight
		};
		// boundary constraints
		if ( pos.left < this.options.leftBound ) pos.left = this.options.leftBound;
		else if ( this.options.rightBound > -1 && ( pos.right > this.options.rightBound ) ) pos.left = ( this.options.rightBound  - this.dragObjOffset.offsetWidth );
		if ( pos.top < this.options.topBound ) pos.top = this.options.topBound;
		else if ( this.options.bottomBound > -1 && ( pos.bottom > this.options.bottomBound ) ) pos.top = ( this.options.bottomBound - this.dragObjOffset.offsetHeight );
		// direction constraints
		if ( this.options.horizontal ) this.dragObj.style.left = pos.left + 'px';
		if ( this.options.vertical ) this.dragObj.style.top = pos.top + 'px';
		if ( typeof this.ondrag == 'function' ) this.ondrag ( Element.getOffset ( this.dragObj, true ) );
		this.lastMousePos = [mousePosX, mousePosY];
	}
};