//-----------------------------------------------------------
// VPI Library
var vpi = {
	version: '0.6',
	author: 'Francis Albar',
	dateCompiled: '2007-05-16',
	init: function() {
		// Internal Extension Prototype Handling
		Object.extend = function(myObject, myProperties) {
			for(i in myProperties)
				myObject[i] = myProperties[i];
			return(myObject);
		}

		// String Prototypes
		Object.extend( String.prototype, {

			stripTags: function() {
				return(this.replace(/<\/?[^>]+>/gi, ''));
			},

			stripScripts: function() {
				return(this.replace(new RegExp('(?:<script.*?>)((\n|\r|.)*?)(?:<\/script>)', 'img'), ''));
			},

			escapeHTML: function() {
				var tempDiv = document.createElement('div');
				var tempText = document.createTextNode(this);
					tempDiv.appendChild(tempText);
				return(tempDiv.innerHTML);
			},

			unescapeHTML: function() {
				var tempDiv = document.createElement('div');
					tempDiv.innerHTML = this.stripTags();
				return(tempDiv.childNodes[0] ? tempDiv.childNodes[0].nodeValue : '');
			},

			toArray: function() {
				return(this.split(''));
			},

			pad: function(l, s, t){
				return s || (s = " "), (l -= this.length) > 0 ? (s = new Array(Math.ceil(l / s.length)
					+ 1).join(s)).substr(0, t = !t ? l : t == 1 ? 0 : Math.ceil(l / 2))
					+ this + s.substr(0, l - t) : this;
			},

			camelize: function() {
				var strArray = this.split('-');
				if(strArray.length == 1)
					return(strArray[0]);

				var camelizedString = (this.indexOf('-') == 0) ?
					strArray[0].charAt(0).toUpperCase() + strArray[0].substring(1) :
					strArray[0];

				for(var i=1; i<strArray.length; i++) {
					var s = strArray[i];
					camelizedString += s.charAt(0).toUpperCase() + s.substring(1);
				}
				return(camelizedString);
			}

		} );

		Object.extend( Array.prototype, {

			inArray: function(item) {
				for(var i=0;i<=this.length;i++)
					if(this[i] == item) return(true);
				return(false);
			},

			indexOf: function(item) {
				for(var i=0;i<=this.length;i++)
					if(this[i] == item) return(i);
				return(-1);
			},

			removeItem: function(item) {
				var i = this.indexOf(item);
				while(i >= 0) {
					this.splice(i, 1);
					i = this.indexOf(item);
				}
			}

		} );

	}

}

//-----------------------------------------------------------
// VPI Browser Class
vpi.Browser = function() {

	this.dataBrowser = [
		{ 	string: navigator.userAgent,
			subString: "OmniWeb",
			versionSearch: "OmniWeb/",
			identity: "OmniWeb"
		},{
			string: navigator.vendor,
			subString: "Apple",
			identity: "Safari"
		},{
			prop: window.opera,
			identity: "Opera"
		},{
			string: navigator.vendor,
			subString: "iCab",
			identity: "iCab"
		},{
			string: navigator.vendor,
			subString: "KDE",
			identity: "Konqueror"
		},{
			string: navigator.userAgent,
			subString: "Firefox",
			identity: "Firefox"
		},{
			string: navigator.vendor,
			subString: "Camino",
			identity: "Camino"
		},{		// for newer Netscapes (6+)
			string: navigator.userAgent,
			subString: "Netscape",
			identity: "Netscape"
		},{
			string: navigator.userAgent,
			subString: "MSIE",
			identity: "Explorer",
			versionSearch: "MSIE"
		},{
			string: navigator.userAgent,
			subString: "Gecko",
			identity: "Mozilla",
			versionSearch: "rv"
		},{ 		// for older Netscapes (4-)
			string: navigator.userAgent,
			subString: "Mozilla",
			identity: "Netscape",
			versionSearch: "Mozilla"
		}
	];

	this.dataOS = [
		{
			string: navigator.platform,
			subString: "Win",
			identity: "Windows"
		},{
			string: navigator.platform,
			subString: "Mac",
			identity: "Mac"
		},{
			string: navigator.platform,
			subString: "Linux",
			identity: "Linux"
		}
	];

	this.searchString = function(data) {
		for (var i=0;i<data.length;i++) {
			var dataString = data[i].string;
			var dataProp = data[i].prop;
			this.versionSearchString = data[i].versionSearch || data[i].identity;
			if (dataString) {
				if (dataString.indexOf(data[i].subString) != -1)
					return data[i].identity;
			}
			else if (dataProp)
				return data[i].identity;
		}
	}

	this.searchVersion = function (dataString) {
		var index = dataString.indexOf(this.versionSearchString);
		if (index == -1) return;
		return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
	}


	this.ie = document.all != null;
	this.moz = !this.ie && document.getElementById!= null;
	this.mac = (navigator.platform.indexOf('Mac') >= 0);

	this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
	this.version = this.searchVersion(navigator.userAgent)
		|| this.searchVersion(navigator.appVersion)
		|| "an unknown version";
	this.OS = this.searchString(this.dataOS) || "an unknown OS";

	return;
}

//-----------------------------------------------------------
// VPI Utilities Class
vpi.Util = function() {
	var dom = new vpi.DOMParser();

	// Displays and alert box window containing properties and members of passed object
	this.debug = function(myObject) {
		var itemsPerPage = (arguments[1] != null) ? arguments[1] : 15;
		var verbose = (arguments[2] != null) ? arguments[2] : false;
		var myHeader  = '//VPI_JS_Debug-----------------------------------------------' + "\n";

			myHeader += (myObject['tagName'] != null) ? 'Tag Name: ' + myObject['tagName'] + "\n" : '';

			myHeader += 'Type: ' + (typeof myObject) + "\n";
		var myFooter  = "\n\n" + '//----------------------------------------------------------------';
		var z = 0;
		var y = 0;
		var mySplit = 'Page [' + ++y + ']' + "\n" + '//----------------------------------------------------------------' + "\n\n";
		var myMessage = '';
		for(var i in myObject) {
			if (i == 'domConfig' || typeof myObject[i] == 'unknown')
				continue;
			if(!verbose && typeof myObject[i] == 'function')
				continue;
			myMessage += '[' + i + '] -> ' +
				((!verbose && (typeof myObject[i] == 'string') && (myObject[i].length > 200)) ?
					myObject[i].substr(0,200) + ' {...}' :
					myObject[i])
				+ "\n";
			if(z++ > itemsPerPage) {
				alert(myHeader + mySplit + myMessage + myFooter);
				z = 0;
				mySplit = 'Page [' + ++y + ']' + "\n" + '//----------------------------------------------------------------' + "\n\n";
				myMessage = '';
			}
		}
		alert(myHeader + mySplit + myMessage + myFooter);
	}

	this.clone = function(myObject) {
		var theClone = new Array();
		for(var i in myObject)
			theClone[i] = myObject[i];
		return(theClone);
	}

	this.toggle = function(myElementID) {
		var myElement = (typeof myElementID == 'string') ? dom.getElementById(myElementID) : myElementID;
		if(arguments[1])
			myElement.style.display = arguments[1];
		else
			myElement.style.display = (myElement.style.display == 'block') ? 'none' : 'block';
	}

	this.numberPath = function(myStart, myNumber) {
		var cur			= myStart;
		var numberDir	= myNumber;
		var dir			= [];
		for(var i=myStart.toString().length;i>2;i--) {
			var n = parseInt(numberDir/cur, 10);
			for(var j=0;j<cur.toString().length-1;j++)
				n += '0';
			dir.push(n);
			numberDir = numberDir % cur;
			cur = cur * .1;
		}
		dir.push(myNumber);
		return(dir);
	}

	this.hex = function(myString) {
		myString = parseInt(myString).toString(16);
		return(myString.length < 2 ? "0"+myString : myString);
	}

	this.rgb2hex = function(myString) {
		if(myString.indexOf(',') < 0)
			return(myString);
		var rgb = myString.replace(/[^0-9,]/g, '').split(',');
		if(rgb.length != 3)
			return(myString);
		return('#' + this.hex(rgb[0]) + this.hex(rgb[1]) + this.hex(rgb[2]));
	}
}

//-----------------------------------------------------------
// VPI Image Class
vpi.Image = function() {
	var browser = new vpi.Browser();
	var dom = new vpi.DOMParser();
	this.filtered = [];
	this.unfiltered = [];
}

//-----------------------------------------------------------
// VPI DOM Parser Class
vpi.DOMParser = function() {
	var browser = new vpi.Browser();
	var doc;

	// Gets and element by ID.
	// Overloaded with $
	this.getElementById = function(myID) {
		return(this.doc.getElementById(myID));
	}
	this.getById = this.getElementById;
	this.$ = this.getElementById;

	// Created a new element with properties as 2nd parameter and styles as third.
	// Overloaded with $n
	this.createElement = function(myTag, myProperties, myStyles) {
		var myElement = this.doc.createElement(myTag);
		for(i in myProperties)
			myElement[(i == 'class') ? 'className' : i] = myProperties[i];
		for(i in myStyles)
			myElement.style[i] = myStyles[i];
		return(myElement);
	}
	this.$n = this.createElement;

	// Returns an array of all the elements with a certain class name.
	// You can specify the root element as the first parameter, otherwise, defaults to document
	// Overloaded with $c
	this.getElementsByClassName = function(myElement, myClassName) {
		if(!myElement)
			myElement = this.doc;
		var myTagName = arguments[2] != null ? arguments[2] : '*';

		var myElements = new Array();
		var myTags = myElement.getElementsByTagName(myTagName);

		for(var w = 0; w < myTags.length; w++)
			if(this.hasClassName(myTags[w], myClassName))
				myElements.push(myTags[w]);

		return(myElements);
	}
	this.getByClass = this.getElementsByClassName;
	this.$c = this.getElementsByClassName;

	// Checks whether or not the passed element has a particular class
	this.hasClassName = function(myElement, myClassName) {
		return((myElement.className != null) && myElement.className.match(new RegExp("(^|\\s)" + myClassName + "(\\s|$)")));
	}
	this.hasClass = this.hasClassName;

	this.addClassName = function(myElement, myClassName) {
		var classes = myElement.className.split(' ');
		if(!classes.inArray(myClassName))
			classes.push(myClassName);
		return(myElement.className = classes.join(' '));
	}
	this.addClass = this.addClassName;

	this.removeClassName = function(myElement, myClassName) {
		var classes = myElement.className.split(' ');
		if(classes.inArray(myClassName))
			classes.removeItem(myClassName);
		return(myElement.className = classes.join(' '));
	}
	this.removeClass = this.removeClassName;

	// Returns the closest parent with a particular class
	// Overloaded with $p
	this.getParentWithClass = function(myElement, myClassName) {
		if(myElement == this.doc)
			return(myElement);
		if(this.hasClassName(myElement.parentNode, myClassName))
			return(myElement.parentNode);
		else
			return(this.getParentWithClass(myElement.parentNode, myClassName));
	}
	this.$p = this.getParentWithClass;

	this.getCurrentStyle = function(myElement, myStyleProperty) {
		try{
			if(document.defaultView && document.defaultView.getComputedStyle)
				return(document.defaultView.getComputedStyle(myElement,null).getPropertyValue(myStyleProperty));
		} catch(e) {
			alert(e);
			util.debug(myElement);
			return(false);
		}
		if(myElement.currentStyle)
			return(myElement.currentStyle[myStyleProperty.camelize()]);
		return(null);
	}

	// Sets the root document of the DOM Parser instance
	this.setDocument = function(myDocument) {
		if(typeof myDocument == 'string') {
			if (browser.ie) {
				this.doc = new ActiveXObject("Microsoft.XMLDOM");
				this.doc.async = 'false';
				this.doc.loadXML(myDocument);
			}
			else {
				var parser = new DOMParser();
				this.doc = parser.parseFromString(myDocument, "text/xml");
			}
		} else {
			this.doc = myDocument;
		}
	}

	// Constructor call, setting root document based on arguments[0]
	this.setDocument(arguments[0] ? arguments[0] : document);
}
//vpi.DOMParser.inherits(document);

//-----------------------------------------------------------
// VPI Cursor Class
vpi.Cursor = function(myEvent) {
	var browser = new vpi.Browser();

	this._x = (browser.ie) ?
		window.event.clientX + document.documentElement.scrollLeft + document.body.scrollLeft :
		myEvent.clientX + window.scrollX;
	this._y = (browser.ie) ?
		window.event.clientY + document.documentElement.scrollTop + document.body.scrollTop :
		myEvent.clientY + window.scrollY;
	return;
}

//-----------------------------------------------------------
// VPI Events Class
vpi.Event = function() {
	var browser = new vpi.Browser();

	this.addEvent = function(myElement, myEventName, myCallback) {
		return (browser.ie) ?
			myElement.attachEvent('on' + myEventName, myCallback) :
			myElement.addEventListener(myEventName, myCallback, true);
	}

	this.removeEvent = function(myElement, myEventName, myCallback) {
		return (browser.ie) ?
			myReturn = myElement.detachEvent('on' + myEventName, myCallback) :
			myReturn = myElement.removeEventListener(myEventName, myCallback, true);
	}

	// Prevents the default action in the browser to occur (selecting text for example)
	this.cancelEventBubble = function(myEvent) {
		if(browser.ie) {
			window.event.cancelBubble = true;
			window.event.returnValue = false;
		} else
			myEvent.preventDefault();
	}
}

//-----------------------------------------------------------
// VPI Animation Class
vpi.Animation = function() {
	var browser = new vpi.Browser();
	this._z = 1;

	//-----------------------------------------------------------
	// Move Element
	this.move = function(myElement, _x, _y) {
		_x = !isNaN(parseInt(_x)) ? parseInt(_x, 10) : 0;
		_y = !isNaN(parseInt(_y)) ? parseInt(_y, 10) : 0;
		myElement.style.position = 'absolute';
		myElement.style.left = _x + 'px';
		myElement.style.top = _y + 'px';
	}

	//-----------------------------------------------------------
	// Resize Element
	this.resize = function(myElement, myWidth, myHeight) {
		myWidth = !isNaN(parseInt(myWidth)) ? parseInt(myWidth) : 0;
		myHeight = !isNaN(parseInt(myHeight)) ? parseInt(myHeight) : 0;
		myElement.style.width = myWidth + 'px';
		myElement.style.height = myHeight + 'px';
	}

	//-----------------------------------------------------------
	// Allows the element to be draggable
	this.setDraggable = function(myEvent, myElement) {
		var dragElement = null;
		var dragCursor = null;
		var dragEvent = new vpi.Event();

		if(typeof myElement == 'string')
			myElement = document.getElementById(myElement);

		if(myElement)
			dragElement = myElement;
		else {
			if(browser.ie)
				dragElement = window.event.srcElement;
			else
				dragElement = myEvent.target;

			if(dragElement.nodeType == 3)
				dragElement = dragElement.parentNode;
		}

		dragCursor = new vpi.Cursor(myEvent);

		switch( DragType ){
			case 'Center':
				dragElement.style.left = (dragCursor._x - parseInt(dragElement.offsetWidth/2, 10)) + 'px';
				dragElement.style.top = (dragCursor._y - parseInt(dragElement.offsetHeight/2, 10)) + 'px';
			break;

			case 'CursorLocation':
				var dragStartLeft = 0;
				var dragStartTop = 0;
				dragStartLeft = !isNaN(parseInt(dragElement.style.left, 10)) ? parseInt(dragElement.style.left, 10) : dragCursor._x;
				dragStartTop = !isNaN(parseInt(dragElement.style.top, 10)) ? parseInt(dragElement.style.top, 10) : dragCursor._y;
			break;

		}

		dragElement.style.zIndex = ++this._z;
		dragElement.style.position = 'absolute';

		dragEvent.addEvent(document, 'mousemove', dragStart);
		dragEvent.addEvent(document, 'mouseup', dragStop);
		dragEvent.cancelEventBubble(myEvent);

		function dragStart(myEvent) {
			var cursor = new vpi.Cursor(myEvent);

		switch( DragType ){
			case 'Center':
				dragElement.style.left = (cursor._x - parseInt(dragElement.offsetWidth/2, 10)) + 'px';
				dragElement.style.top = (cursor._y - parseInt(dragElement.offsetHeight/2, 10)) + 'px';
			break;

			case 'CursorLocation':
				dragElement.style.left = ((cursor._x - dragCursor._x) + dragStartLeft) + 'px';
				dragElement.style.top = ((cursor._y - dragCursor._y) + dragStartTop) + 'px';
			break;
		}

			dragEvent.cancelEventBubble(myEvent);

			if(dragElement.onmove != null)
				dragElement.onmove(myEvent);

			return;
		}

		function dragStop(myEvent) {

			if(dragElement.onmouseup != null)
				dragElement.onmouseup(myEvent);
			dragEvent.removeEvent(document, 'mousemove', dragStart);
			dragEvent.removeEvent(document, 'mouseup', dragStop);
			dragEvent.cancelEventBubble(myEvent);

			dragElement = null;
			dragCursor = null;
			return;
		}

		return;
	}

	//-----------------------------------------------------------
	// Get Bounds
	this.getBounds = function(myElement) {
		var bounds = {};
		bounds.width = myElement.offsetWidth;
		bounds.height = myElement.offsetHeight;
		bounds.left = myElement.offsetLeft;
		bounds.top = myElement.offsetTop;
		while(myElement = myElement.offsetParent) {
			bounds.left += myElement.offsetLeft;
			bounds.top += myElement.offsetTop;
		}
		bounds.right = bounds.left + bounds.width;
		bounds.bottom = bounds.top + bounds.height;
		bounds.centerX = bounds.left + parseInt(bounds.width/2, 10);
		bounds.centerY = bounds.top + parseInt(bounds.height/2, 10);
		return(bounds);
	}

	return;
}


//-----------------------------------------------------------
// VPI XMLHTTP Class
vpi.XH = function() {
	var browser = new vpi.Browser();
	var dom = new vpi.DOMParser();
	var util = new vpi.Util();
	var MyXHResponseFunction = null;
	this.async = true;

	this.createXH = function() {
		var myXH = null;
		try {
			myXH = new ActiveXObject("Msxml2.XMLHTTP");
		} catch(e) {
			try {
				myXH = new ActiveXObject("Microsoft.XMLHTTP");
			} catch(oc) {
				myXH = null;
			}
		}
		if(!myXH && (typeof XMLHttpRequest != "undefined")) {
			myXH = new XMLHttpRequest();
		}
		return(myXH);
	}

	this.loadSection = function(mySectionID, myURL) {
		var mySection = (typeof mySectionID == 'string') ? dom.getElementById(mySectionID) : mySectionID;

		var myXH = this.createXH();

		myXH.onreadystatechange = function() {
			if(myXH.readyState == 4)
				mySection.innerHTML = myXH.responseText;
			else
				mySection.innerHTML = '<div style="text-align: center; padding: 3px;"><img src="/images/e1/t1/ajx.load.round.gif" /></div>';
		}

		myXH.open('GET', myURL, this.async);
		myXH.send(null);

	}

	this.loadJSON = function(callbackFunction, myURL) {
		var myXH = this.createXH();

		myXH.onreadystatechange = function() {
			if(myXH.readyState == 4)
				eval(callbackFunction + '(' + myXH.responseText + ');');
		}

		myXH.open('GET', myURL, this.async);
		myXH.send(null);
	}

	this.loadXML = function(mySectionID, myURL) {
		var mySection = (typeof mySectionID == 'string') ? dom.getElementById(mySectionID) : mySectionID;

		var myXH = this.createXH();

		myXH.onreadystatechange = function() {
			if(myXH.readyState == 4) {
				util.debug(myXH.responseXML.childNodes[0].firstChild.data);
			}
		}

		myXH.open('GET', myURL, this.async);
		myXH.send(null);

	}

	this.partialResponse = function(myFunction, myURL) {
		var myXH = this.createXH();
		var previousResponse = '';

		myXH.onreadystatechange = function() {
			switch(myXH.readyState) {
				case 0: case 1: case 2: break;
				case 3:
					eval(myFunction + '(' + myXH.responseText.replace(previousResponse, '') + ')');
					previousResponse = myXH.responseText;
				break;
				case 4:
					eval(myFunction + '(null)');
				break;
			}
		}

		myXH.open('GET', myURL, this.async);
		myXH.send(null);
	}

	this.postResponse = function(myURL, myVars) {
		var myXH = this.createXH();

		myXH.onreadystatechange = function() {
			switch(myXH.readyState) {
				case 0: case 1: case 2: case 3: break;
				case 4:
					if(MyXHResponseFunction != null){
						setTimeout(MyXHResponseFunction + "('" + myXH.responseText + "'); MyXHResponseFunction = null;", 100);
					}
				break;
				default: break;
			}
		}

		var myPostString = '';

		for(var i in myVars)
			if(typeof myVars[i] != 'function')
				myPostString += escape(i) + '=' + escape(myVars[i]) + '&';

		myPostString += 't=' + Math.random();

		MyXHResponseFunction = (arguments[2]) ? arguments[2] : null;

		myXH.open('POST', myURL, this.async);
		myXH.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8');
		myXH.send(myPostString);

		return(true);
	}

	this.postForm = function(myForm) {
		var action = myForm.action != null ? myForm.action : '/';
		var formData = {};
		var formCallback = arguments[1];

		for (var i=0;i<myForm.elements.length;i++) {
			if (myForm.elements[i].type == 'radio' || myForm.elements[i].type == 'checkbox') {
				if(myForm.elements[i].checked == true)
					formData[myForm.elements[i].name] = myForm.elements[i].value;
			} else
				formData[myForm.elements[i].name] = myForm.elements[i].value;
		}
		this.postResponse(action, formData, formCallback);
	}

}

vpi.init();
var util = new vpi.Util();
var animation = new vpi.Animation();
var browser = new vpi.Browser();
var dom = new vpi.DOMParser();
var image = new vpi.Image();
var xh = new vpi.XH();
var DragType = 'CursorLocation';