/* Handy Objects
--------------------------------------------------------------------------*/
var Cookie = {
	get: function(name) {
		var cookies = document.cookie.split('; ');
		for (var x=0; x<cookies.length; x++) {
			var cookie = cookies[x].split('='); 
			if (cookie[0] == name) return cookie[1];
		}
		return false;
	},

	set: function(name, value, expDate) {
		document.cookie = name+"="+escape(value) + ";expires="+expDate.toGMTString();
	},

	remove: function(name) {
		Cookie.set(name, '', new Date(Date.parse('Thu, 01-Jan-1970 00:00:01 GMT')));
	}
};

var Request = {
	getVar: function(name) {
		var getvars = document.location.search.substring(1).split('&');
		for (var x=0; x<getvars.length; x++) {
			var getvar = getvars[x].split('=');
			if (getvar[0] == name) return getvar[1];
		}
		return false;
	}
};

// Legacy function names
var getCookie = Cookie.get;
var getGet = Request.getVar;

/* Extensions to native JS objects
--------------------------------------------------------------------------*/
Object.extend(String.prototype, {
	/**
	 * Extends the .substring() method to allow negative numbers to
	 * reference indices from the end of the string rather than the beginning.
	 */
	substring: function(start, end) {
		if (start < 0) start = this.length + start;
		if (end < 0) end = this.length + end;
		if (end !== 0 && !end) end = this.length;
		var newString = '';
		for (var ssi=start; ssi<end; ssi++) {
			newString += this.charAt(ssi);
		}
		return newString;
	},

	// Deprecated
	// See Prototype's String.escapeHTML()
	// http://www.prototypejs.org/api/string/escapeHTML
	/**
	 * Converts special characters to their HTML entities
	 */
	 htmlEntities: function() {
		var chars = {
			'&': 'amp',	'<': 'lt', '>': 'gt', '\"': 'quot'
		};

		var newString = this;
		for (var chacacter in chars) {
			var regExp = new RegExp();
			regExp.compile(chacacter,'g');
			newString = newString.replace(regExp, '&'+chars[chacacter]+';');
		}
		return newString;
	},

	// Deprecated
	// Don't hide JS data inside HREF ever again.
	// Use DOM.getCommentData() instead.
	/**
	 * Get Url Argument
	 * Turns a URL into an argument for links which function
	 * purely as event launchers.
	 */
	getUrlArgument: function() {
		// Parses a URL like "javascript:void(42);" and returns "42"
		if (val = this.match(/[Jj]avascript:void\(\'?(.*?)\'?\);?/i)) {
			if (val[1]) return val[1];
		}
		return this;
	},

	// Deprecated by Prototype's String.strip()
	// See: http://www.prototypejs.org/api/string/strip
	/**
	 * Trims a string
	 */
	trim: function() {
		return this.replace(/^\s+/g, '').replace(/\s+$/g, '');
	},

	/**
	 * Is Numeric
	 * checks if a string is a number
	 */
	isNumeric: function () {
		return !this.match(/\D/);
	},

	toDOMNodes: function() {
		var wrapper = document.createElement('div');
		wrapper.innerHTML = this;
		return $(wrapper).immediateDescendants();
	}
});

Object.extend(Form.Element, {
	setValue: function(inputElement, newValue) {
		inputElement = $(inputElement);
		switch(inputElement.type) {
			case 'text':
			case 'password':
				inputElement.value = newValue;
			break;
			case 'select':
			case 'select-one':
				for (var x=0; x<inputElement.options.length; x++) {
					if (inputElement.options[x].value == newValue) {
						inputElement.selectedIndex = x;
						return true;
					}
				}
				return false;
			break;
			case 'checkbox':
				inputElement.checked = bool(newValue);
			break;
			default:
				alert('setValue() can\'t yet handle input type: '+inputElement.type);
				return false;
			break;
		}
		return true;
	}
});

Object.extend(Form.Element, {
	getForm: function(element) {
    element = $(element);
    while (element.tagName != 'FORM') {
    	element = element.parentNode;
    	if (element == document) return false;
    }
    return element;
	}
});

Object.extend(Number.prototype, {
	// Deprecated
	// See Prototype's Number.toPaddedString(length)
	// http://www.prototypejs.org/api/number/toPaddedString
	/**
	 * Pads a number with zeroes until it is the desired length (digits)
	 * (Caution: Returns a string, not a float, out of necessity)
	 * Example: (7).zeroPad(3) == '007'
	 */
	zeroPad: function(digits) {
		var str = this.toString();
		while (str.length < digits) {
			str = '0'+str;
		}
		return str;
	}
});

Object.extend(Array.prototype, {
	// Deprecated
	// See Prototype's Array.without(Array)
	// http://www.prototypejs.org/api/array/without
	/**
	 * Deletes any occurrences of needle from Array
	 * Not recommended for use on multidimensional arrays.
	 */
	deleteVals: function(needle) {
		var newValue = [];
		if (this.length > 0) {
			for (var n=0; n<this.length; n++) {
				if (this[n] != needle) newValue.push(this[n]);
			}
		}
		return newValue;
	},

	// Deprecated
	// See Prototype's Array.uniq()
	// http://www.prototypejs.org/api/array/uniq
	/**
	 * Weeds out duplicate values in an array.
	 * Not recommended for use on multidimensional arrays.
	 */
	unique: function() {
		newArray = new Array();
		for (key in this) {
			if (typeof(this[key]) != 'function') {
				if (newArray.inArray(this[key]) == -1) newArray.push(this[key]);
			}
		}
		return newArray;
	},

	// Deprecated
	// See JavaScript's native Array.indexOf()
	/**
	 * In Array
	 * Finds a value in an array
	 */
	inArray: function(needle) {
		if (this.length > 0) {
			for (var n=0; n<this.length; n++) {
				if (this[n] == needle) return n;
			}
		}
		return -1;
	}
});



/* Patches to Prototype
--------------------------------------------------------------------------*/
Object.extend(Position, {
	distanceBetween: function(coords0, coords1) {
		// Determines the straight distance between two points.
		// coords1 = [x: 1, y: 1]
		// or
		// coords1 = [1,1]
		if (coords0 instanceof Array) {
			var x0=coords0[0];
			var y0=coords0[1];
		} else {
			var x0=coords0.x;
			var y0=coords0.y;
		}
		if (coords1 instanceof Array) {
			var x1=coords1[0];
			var y1=coords1[1];
		} else {
			var x1=coords1.x;
			var y1=coords1.y;
		}
		return Math.sqrt((x0-x1)*(x0-x1) + (y0-y1)*(y0-y1));
	}
});

Object.extend(Object, {
	extendProperties: function(originalObject, extendingObject) {
		// Tries to intelligently extend an object's properties based
		// on direction given in the property names of the extending
		// object.
		for (var originalKeyName in extendingObject) {
			var modifier = originalKeyName.substring(0,1);
			var keyName = originalKeyName.substring(1);
			if (extendingObject[originalKeyName] instanceof Array) {
				// - Prune: Remove from it
				// + Merge: Add to it
				// ! Overwrite: Replace it entirely
				switch(modifier) {
					case '-':
						for (var x=0; x<extendingObject[originalKeyName].length; x++) {
							originalObject[keyName] = originalObject[keyName].deleteVals(extendingObject[originalKeyName][x]);
						}
					break;
					case '+':
						originalObject[keyName] = originalObject[keyName].concat(extendingObject[originalKeyName]);
					break;
					default:
						keyName = originalKeyName; // No valid modifier, so we need to restore the wrongly clipped keyName
					case '!':
						originalObject[keyName] = extendingObject[originalKeyName];
					break;
				}
			} else if (extendingObject[originalKeyName] instanceof Object) {
				// - Prune: Remove from it
				// + Merge: Add to it or overwrite preexisting conflicting values.
				// ! Overwrite: Replace it entirely
				switch(modifier) {
					case '-':
						for (var key in extendingObject[originalKeyName]) {
							if (typeof(Object.prototype[key]) == 'undefined') {
								delete(originalObject[keyName][key]);
							}
						}
					break;
					case '+':
						Object.extend(originalObject[keyName], extendingObject[originalKeyName]);
					break;
					default:
						keyName = originalKeyName; // No valid modifier, so we need to restore the wrongly clipped keyName
					case '!':
						originalObject[keyName] = extendingObject[originalKeyName];
					break;
				}
			} else {
				originalObject[originalKeyName] = extendingObject[originalKeyName];
			}
		}
	}
});

Object.extend(Element, {
	/**
	 * Tons faster and simpler than Prototype's
	 */
	hasClassName: function(element, className) {
		return Element.manipulateClass(element, className, 'find');
	},

	addClassName: function(element, className) {
		return Element.manipulateClass(element, className, 'add');
	},

	removeClassName: function(element, className) {
		return Element.manipulateClass(element, className, 'remove');
	},

	clearClassNames: function(element) {
		element.className = '';
		return element;
	},

	manipulateClass: function(element, className, action) {
		if (typeof(element.tagName) != 'undefined') {
			var classes = element.className;
			if (action == 'add') {
				if (!Element.hasClassName(element, className)) {
					element.className += ' '+className;
					return element;
				}
			}
			var cNames = classes.split(' ');
			if (cNames.length > 0) {
				if (action == 'remove') {
					cNames = cNames.deleteVals(className);
				} else if (action == 'find') {
					return (cNames.indexOf(className) != -1);
				}
			}
			if (action == 'add') {
				if (typeof(className) == 'array') {
					cNames = cNames.concat(className);
				} else {
					cNames.push(className);
				}
			}
			if (action == 'add' || action == 'remove') element.className = cNames.join(' ').trim();
			if (action == 'find') return false;
		} else {
			return false;
		}
	},

	/**
	 * Element.visible
	 * By Kramer
	 *
	 * I was disappointed that Prototype's Element.visible really only
	 * reports on the status of element.style.display. What I really
	 * wanted to know was "can the user see this element, or is it
	 * contained inside a hidden element?" This extension fixes that with
	 * the new "recursive" option.
	 *
	 * Recursive option added to seek up the tree to make sure
	 * all parent nodes are visible, too. This should effectively
	 * return a true/false indicating whether the given element is
	 * indeed VISIBLE TO THE USER.
	 */
	visible: function(element, recursive) {
		if (!recursive) return $(element).style.display != 'none';
		var search = element;
		while (search = search.parentNode) {
			if ($(search).style.display == 'none') return false;
		}
		return true;
	},
	insertedNodes: [],
	insertNode: function(node, tagName, key){
		for(var x=0; x<Element.insertedNodes.length; x++){
			if(Element.insertedNodes[x].node == node){
				return false;
			}
		}
		var insertedNode = {
			node: node,
			key: (key)? key : null
		};

		/* Create and place container */
		insertedNode.container = document.createElement('span');
		Element.addClassName(insertedNode.container, "iFrameHackContainer");
		insertedNode.node.parentNode.insertBefore(insertedNode.container, insertedNode.node);
		insertedNode.container.appendChild(insertedNode.node);

		/* Create and place throbber */
		insertedNode.newNode = document.createElement(tagName);
		Element.addClassName(insertedNode.newNode, "newNode");
		insertedNode.container.appendChild(insertedNode.newNode);

		var dims = Element.getDimensions(insertedNode.container);

		/* Add essential styles to container and throbber */
		Object.extend(insertedNode.container.style, {
			position: "relative",
			display: "block",
			zoom: "1"
		});
		Object.extend(insertedNode.newNode.style, {
			position: "absolute",
			top: "0",
			left: "0",
			width: (document.all)?dims['width']+"px" : "100%",
			height: (document.all)?dims['height']+"px" : "100%"
		});

		Element.insertedNodes.push(insertedNode);
		return insertedNode;
	},
	removeNode: function(node, key){
		var insertedNode = null;
		for(var x=0; x<Element.insertedNodes.length; x++){
			if(Element.insertedNodes[x].node == node && ((!key && !Element.insertedNodes[x].key) || Element.insertedNodes[x].key == key)){
				insertedNode = Element.insertedNodes.splice(x, 1);
				break;
			}
		}
		if(!insertedNode){
			return false;
		}
		insertedNode = insertedNode[0];
		insertedNode.container.parentNode.insertBefore(node, insertedNode.container);
		insertedNode.container.parentNode.removeChild(insertedNode.container);
		return true;
	},
	iFrameHacks: [],
	iFrameHack: function(node){
		if(!document.all){
			return false;
		}
		var iFrameHack = Element.insertNode(node, 'iframe', 'iFrameHack');
		if(!iFrameHack){
			return false;
		}
		Element.addClassName(iFrameHack.container, "iFrameContainer");
		Element.addClassName(iFrameHack.newNode, "iFrame");
		Object.extend(iFrameHack.newNode.style, {
			filter: "alpha(opacity=0)",
			opacity: "0",
			zIndex: "2"
		});
		if(parseInt(iFrameHack.node.style.zIndex) > 1){
			Object.extend(iFrameHack.newNode.style, {
				zIndex: parseInt(iFrameHack.node.style.zIndex)+1
			});
		}
		return iFrameHack;
	},
	cancelIFrameHack: function(node){
		if(!document.all){
			return false;
		}
		Element.removeNode(node, 'iFrameHack');
	},
	parseClasses: function(el, parseChildren){
		var classes = String(el.className).split(" ");
		var keepClasses = [];
		for(var x=0; x<classes.length; x++){
			if(classes[x].indexOf(':') != -1){
				var matches = classes[x].match(/^(\w*):{1,2}\{(.*)\}$/);
				var ob = {};
				var vars = matches[2].split(",");
				for(var y=0; y<vars.length; y++){
					vars[y] = vars[y].split(/::?/);
					if(!vars[y][1]) vars[y][1] = '';
					ob[vars[y][0]] = vars[y][1];
				}
				el[matches[1]] = ob;
			}else{
				keepClasses.push(classes[x]);
			}
		}
		el.className = keepClasses.join(" ");
		if(parseChildren){
			var eles = el.getElementsByTagName('*');
			for(var x=0; x<eles.length; x++){
				this.parseClasses(eles[x]);
			}
		}
	}
});


Event._observe = Event.observe;
Object.extend(Event, {
	/**
	 * Returns the keycode related to an event, browser-independent
	 */
	keyCode: function(event) {
		if (typeof(event.which) == 'undefined') return event.keyCode;
		return Math.max(event.which, event.keyCode);
	},

	/**
	 * Event.observe now returns an ID which can be sent to Event.stopObserving to terminate that event handler.
	 */
	registry: [],

	id: 0,

	observe: function(element, name, observer, useCapture) {
		Event.id++;
		var regEntry = {
			id: Event.id,
			element: element,
			name: name,
			observer: observer,
			useCapture: useCapture
		};
		Event.registry.push(regEntry);
		Event._observe(element, name, observer, useCapture);
		return regEntry;
	},

	unObserve: function(regEntry) {
		for (var x=0; x<Event.registry.length; x++) {
			var a = Event.registry[x];
			if (a.id == regEntry.id) {
				Event.registry.splice(x, 1);
				Event.stopObserving(a.element, a.name, a.observer, a.useCapture);
				return true;
			}
		}
		return false;
	},

	fire: function(el, name) {
		for(var x=0; x<Event.registry.length; x++){
			if(Event.registry[x].element == el && Event.registry[x].name == name){
				Event.registry[x].observer();
			}
		}
	}
});


/* Plain old functions
--------------------------------------------------------------------------*/
document.getElementsBySelector = function(selectors, withinNodes) {
	if (!(selectors instanceof Array)) selectors = [selectors];
	if (typeof(withinNodes) == 'undefined') {
		var withinNodes = [document.getElementsByTagName('body')[0]];
	} else if (!(withinNodes instanceof Array)) {
		var withinNodes = [withinNodes];
	}
	var resultNodes = [];
	for (var cSel=0; cSel<selectors.length; cSel++) {
		for (var cNodes=0; cNodes<withinNodes.length; cNodes++) {
			var resultNodes = resultNodes.concat(Element.getElementsBySelector(withinNodes[cNodes], selectors[cSel]));
		}
	}
	return resultNodes.unique();
};

function getCoordsCenter(coords) {
	return {
		x: coords.x/2,
		y: coords.y/2
	};
};
function getViewportSize() {
	var retVal = {
		x: self.innerWidth || (document.documentElement.clientWidth || document.body.clientWidth),
		y: self.innerHeight || (document.documentElement.clientHeight || document.body.clientHeight)
	};
	// Legacy property names
	retVal.height = retVal.y;
	retVal.width = retVal.x;
	return retVal;
};
function getViewportCenter() {
	return getCoordsCenter(getViewportSize());
};
function getScreenSize() {
	var screenW = 640, screenH = 480;
	if (parseInt(navigator.appVersion)>3) {
	 screenW = screen.width;
	 screenH = screen.height;
	}
	else if (navigator.appName == "Netscape"
	    && parseInt(navigator.appVersion)==3
	    && navigator.javaEnabled()
	   )
	{
	 var jToolkit = java.awt.Toolkit.getDefaultToolkit();
	 var jScreenSize = jToolkit.getScreenSize();
	 screenW = jScreenSize.width;
	 screenH = jScreenSize.height;
	}

	return {
		x: screenW,
		y: screenH
	};
};
function getScreenCenter() {
	return getCoordsCenter(getScreenSize());
}

/**
 * Changes pretty much any variable into its boolean equivalent
 * Strings like yes, no, true, false, y, n
 * Numbers like 0, 1, 2...
 * @return bool
 */
function bool(arg) {
	// Returns true or false
	// Does everything concievable to make arg into a boolean value
	if (typeof(arg) == 'undefined') return false;
	if (typeof(arg) == 'boolean') return arg;
	switch(arg.toLowerCase()) {
		case 'yes':
		case 'true':
		case 'y':
			return true;
		break;
		case 'false':
		case 'no':
		case 'n':
			return false;
		break;
		default:
			if (arg === true) return true;
			if (arg === false) return false;
			if (parseInt(arg) > 0) return true;
			if (parseInt(arg) == 0) return false;
		break;
	}
	return null; // Inconclusive
}

/**
 * Converts a UNIX timestamp into a JS Date object
 */
function unixToDate(unixtime) {
	var time = new Date();
	time.setTime(unixtime*1000);
	return time;
}

// Deprecated (partially)
// See Prototype's each()
// http://www.prototypejs.org/api/hash/each
// Although I don't think each() is recursive, not sure.
/**
 * For-each within an object. Recursive if you want it to be.
 **/
function foreach(obj, func, recursive) {
	for (var key in obj) {
		if (!Object.prototype[key]) {
			if (obj[key] instanceof Object && recursive) {
				foreach(obj[key], func);
			}
			func(obj[key], obj);
		}
	}
}

/**
 * Executes the given command within a different thread
 **/
Function.prototype.newThread = function(delay) {
	if (typeof(delay) == 'undefined') delay = 1;
	setTimeout(this, delay);
};
newThread = function(toExec, delay) {
	toExec.newThread(delay);
};

/* Adam added 5-22-07 to fix getElementsBySelector in IE */
Object.extend(Selector.prototype, {
	buildMatchExpression: function() {
		var params = this.params, conditions = [], clause;
		
		if (params.wildcard)
			conditions.push('true');
		if (clause = params.id)
			conditions.push('Element.readAttribute(element, "id") == ' + clause.inspect());
		if (clause = params.tagName)
			conditions.push('element.tagName.toUpperCase() == ' + clause.inspect());
		if ((clause = params.classNames).length > 0)
			for (var i = 0, length = clause.length; i < length; i++)
				conditions.push('Element.hasClassName(element, ' + clause[i].inspect() + ')');
		if (clause = params.attributes) {
			clause.each(function(attribute) {
				var value = 'Element.readAttribute(element, ' + attribute.name.inspect() + ')';
				var splitValueBy = function(delimiter) {
					return value + ' && ' + value + '.split(' + delimiter.inspect() + ')';
				}
				switch (attribute.operator) {
					case '=':       conditions.push(value + ' == ' + attribute.value.inspect()); break;
					case '~=':      conditions.push(splitValueBy(' ') + '.include(' + attribute.value.inspect() + ')'); break;
					case '|=':      conditions.push(splitValueBy('-') + '.first().toUpperCase() == ' + attribute.value.toUpperCase().inspect()); break;
					case '!=':      conditions.push(value + ' != ' + attribute.value.inspect()); break;
					case '':
					case undefined: conditions.push('Element.hasAttribute(element, ' + attribute.name.inspect() + ')'); break;
					default:        throw 'Unknown operator ' + attribute.operator + ' in selector';
				}
			});
		}
		return conditions.join(' && ');
	}
});
/* End added */