function input_wipe(o, d)
{
	if (o.value==d)o.value='';
}


sfHover = function() {
	var sfEls = document.getElementById("nav").getElementsByTagName("LI");
	for (var i=0; i<sfEls.length; i++) {
		sfEls[i].onmouseover=function() {
			this.className+=" sfhover";
		}
		sfEls[i].onmouseout=function() {
			this.className=this.className.replace(new RegExp(" sfhover\\b"), "");
		}
	}
}
if (window.attachEvent) window.attachEvent("onload", sfHover);

var sponscroll = 0;
var sponscroll_delta = -4;

function scroll_sponsor_div()
{
	var o = document.getElementById('scrollme');
	if (!o)
		return;
	
//	o.style.marginLeft = o.style.marginLeft-1;
	
	sponscroll += sponscroll_delta;
	
	if (sponscroll<=sponscroll_min)
		sponscroll = sponscroll_reset;
	
	o.style.marginLeft = sponscroll+'px';
	
//	alert(o.left);


}



function scroll_sponsor_stop()
{
	sponscroll_delta = 0;
}
function scroll_sponsor_start()
{
	sponscroll_delta = -4;
}
//setTimeout('scroll_sponsor_div()', 100);

function finished_loading()
{
	if (o = document.getElementById('please_wait'))
	{
		o.style.display = 'none';
	}
}


function make_rounded(clname)
{
	var divs = document.getElementsByTagName('DIV');
	var mkrn = new Array();
	var cllist = new Array('c', 't','l','b','r','bl','br','tr','tl','ie_bug');
	var x;
	
	for (x in divs)
		if (divs[x].className==clname)
			mkrn[mkrn.length] = divs[x];
	
	for (x=0; x<mkrn.length; x++)
	{
		var o = mkrn[x];
		if (!o || !o.parentNode)
			continue;
		
		var i;
		var t = document.createElement('div');
		var c = t;

		t.className = clname+'_container';
		o.className = clname+'_internal';

		for (i=0; i<10; i++)
		{
			n = document.createElement('div');
			n.className = cllist[i];
			c.appendChild(n);
			c=n;
		}
		o.parentNode.insertBefore(t,o);
		c.appendChild(o);
		
	}
	
	
}

/*--------------------------------------------------------------*/
// HTML TABLE SORTER
// OBJECT ORIENTED JAVASCRIPT IMPLEMENTATION OF QUICKSORT
// @author	Terrill Dent 
// @source	http://www.terrill.ca
// @date	August 28th, 2006
// Modified for eDTM by Ben Hood for Beyondedge
/*--------------------------------------------------------------*/
function TSorter(){
	var table = Object;
	var trs = Array;
	var ths = Array;
	var curSortCol = Object;
	var prevSortCol = -1;
	var sortType = Object;
	var sortIcon = document.createElement('IMG');

	function get(){}

	function getCell(index){
		return trs[index].cells[curSortCol]
	}

	/*----------------------INIT------------------------------------*/
	// Initialize the variable
	// @param tableName - the name of the table to be sorted
	// @param sort_table - if undefine or true then sorting will be enabled
	//                   - set to false to only put grey lines
	/*--------------------------------------------------------------*/
	this.init = function(tableName, sort_enable)
	{
		if (sort_enable==undefined) sort_enable = true;

		if (typeof tableName == 'object')
			table = tableName;
		else
			table = document.getElementById(tableName);

		if (sort_enable && table && table.tHead)
		{
			ths = table.tHead.getElementsByTagName("th");
			for(var i = 0; i < ths.length ; i++)
			{
				ths[i].onclick = function()
				{
					sort(this);
				}
			}
		}
		redoRows(true);
		return true;
	};
	
	this.sort_id = function(idTH, decr)
	{
		var o = document.getElementById(idTH);
		if (o)
		{
			sort (o);
			if (decr)
				sort (o);
		}
	}
	
	/*----------------------SORT------------------------------------*/
	// Sorts a particular column. If it has been sorted then call reverse
	// if not, then use quicksort to get it sorted.
	// Sets the arrow direction in the headers.
	// @param oTH - the table header cell (<th>) object that is clicked
	/*--------------------------------------------------------------*/
	function sort(oTH)
	{
		curSortCol = oTH.cellIndex;
		sortType = oTH.abbr;
		trs = table.tBodies[0].getElementsByTagName("tr");

		//set the get function
		setGet(sortType)
		
		oTH.appendChild(sortIcon);

		// if already sorted just reverse
		if(prevSortCol == curSortCol)
		{
			sortIcon.src = (sortIcon.src == ASSETS_URL+'images/icons/sort-down.gif') ?
					ASSETS_URL+'images/icons/sort-up.gif' :
					ASSETS_URL+'images/icons/sort-down.gif' ;
//			oTH.className = (oTH.className != 'ascend' ? 'ascend' : 'descend' );
			reverseTable();
		}
		// not sorted - call quicksort
		else
		{
			sortIcon.src = ASSETS_URL+'images/icons/sort-up.gif';
//			oTH.className = 'ascend';
//			if(ths[prevSortCol].className != 'exc_cell'){ths[prevSortCol].className = '';}
			quicksort(0, trs.length);
			reverseTable();
		}
		prevSortCol = curSortCol;
		redoRows();
	}
	
	function redoRows(redoCols)
	{
		if (redoCols == undefined) redoCols = false;
		trs = (redoCols) ? 
				table.getElementsByTagName("tr")
			:	table.tBodies[0].getElementsByTagName("tr");
		var i,j,rj;
		var ri = (redoCols) ? 0:1;
		var trsc = trs.length;
		for(i=0; i<trs.length; i++)
		{
			ri=1-ri;
			
			var ncn = 'd_r_'+ri;

			if (!trs[i].className)
				trs[i].className = ncn;
			else
				if (trs[i].className.match(/d_r_(.)/))
					trs[i].className = trs[i].className.replace(/d_r_./,ncn);
				else
					trs[i].className = trs[i].className + ' ' + ncn;

			rj=1;
			if (redoCols && trs[i].childNodes)
				for(j=trs[i].childNodes.length-1; j>=0; j--)
				{
					if (trs[i].childNodes[j] &&
							( trs[i].childNodes[j].tagName == 'TD'
							|| trs[i].childNodes[j].tagName == 'TH')
						)
					{
						rj = 1-rj;
						if ( trs[i].childNodes[j].className == undefined || trs[i].childNodes[j].className == '')
							trs[i].childNodes[j].className = 'd_c_'+rj;
					}
				}
		}
		if (!table.className)
			table.className = 'sorted_table';
	}
	
	/*--------------------------------------------------------------*/
	// Sets the GET function so that it doesnt need to be 
	// decided on each call to get() a value.
	// @param: colNum - the column number to be sorted
	/*--------------------------------------------------------------*/
	function setGet(sortType)
	{
		switch(sortType)
		{   
			case "link_column":
				get = function(index){
					return  getCell(index).firstChild.firstChild.nodeValue;
				};
				break;
			default:
				get = function(index)
				{
					var g1c = getCell(index);
					var g2c = g1c.getAttribute('sort');
					return g2c ? g2c : g1c.firstChild ? g1c.firstChild.nodeValue : '';
				};
				break;
		};	
	}

	/*-----------------------EXCHANGE-------------------------------*/
	//  A complicated way of exchanging two rows in a table.
	//  Exchanges rows at index i and j
	/*--------------------------------------------------------------*/
	function exchange(i, j)
	{
		if(i == j+1) {
			table.tBodies[0].insertBefore(trs[i], trs[j]);
		} else if(j == i+1) {
			table.tBodies[0].insertBefore(trs[j], trs[i]);
		} else {
			var tmpNode = table.tBodies[0].replaceChild(trs[i], trs[j]);
			if(typeof(trs[i]) == "undefined") {
				table.appendChild(tmpNode);
			} else {
				table.tBodies[0].insertBefore(tmpNode, trs[i]);
			}
		}
	}
	
	/*----------------------REVERSE TABLE----------------------------*/
	//  Reverses a table ordering
	/*--------------------------------------------------------------*/
	function reverseTable()
	{
		for(var i = 1; i<trs.length; i++)
		{
			table.tBodies[0].insertBefore(trs[i], trs[0]);
		}
	}

	/*----------------------QUICKSORT-------------------------------*/
	// This quicksort implementation is a modified version of this tutorial: 
	// http://www.the-art-of-web.com/javascript/quicksort/
	// @param: lo - the low index of the array to sort
	// @param: hi - the high index of the array to sort
	/*--------------------------------------------------------------*/
	function quicksort(lo, hi)
	{
		if(hi <= lo+1) return;
		 
		if((hi - lo) == 2) {
			if(get(hi-1) > get(lo)) exchange(hi-1, lo);
			return;
		}
		
		var i = lo + 1;
		var j = hi - 1;
		
		if(get(lo) > get(i)) exchange(i, lo);
		if(get(j) > get(lo)) exchange(lo, j);
		if(get(lo) > get(i)) exchange(i, lo);
		
		var pivot = get(lo);
		
		while(true) {
			j--;
			while(pivot > get(j)) j--;
			i++;
			while(get(i) > pivot) i++;
			if(j <= i) break;
			exchange(i, j);
		}
		exchange(lo, j);
		
		if((j-lo) < (hi-j)) {
			quicksort(lo, j);
			quicksort(j+1, hi);
		} else {
			quicksort(j+1, hi);
			quicksort(lo, j);
		}
	}
}

function boxIt()
{
	make_rounded('greyboxme');
	// opera had troubles with the scrolly thing after rounded
	// so just dont round it in opera!
	if (typeof opera == 'undefined') make_rounded('borderme');
}

if (window.attachEvent) window.attachEvent("onload", boxIt)
else window.onload = boxIt;