function Left(str, n)
{
	if (n <= 0)
	    return "";
	else if (n > String(str).length)
	    return str;
	else
	    return String(str).substring(0,n);
}

function Right(str, n)
{
    if (n <= 0)
       return "";
    else if (n > String(str).length)
       return str;
    else
	{
       var iLen = String(str).length;
       return String(str).substring(iLen, iLen - n);
    }
}

function GetInnerHtmlText(el)
{
	if ("string" == typeof el.textContent) return el.textContent;
	if ("string" == typeof el.innerText) return el.innerText;
	return el.innerHTML.replace(/<[^>]*>/g,"");
}

function GetOffsetTop(item)
{
	var ended = false;
	var offset_top = document.getElementById(item).offsetTop;
	var parentObj = null;

	// Loop through parent objects
	while (ended == false)
	{	
		// Check if first time through loop
		if (parentObj == null)
			parentObj = document.getElementById(item).parentNode;
		else
			parentObj = parentObj.parentNode;

		// Add top offset of this object
		if (parentObj.tagName != "TD")
			offset_top = offset_top + parentObj.offsetTop;

		// Check if top parent
		if (parentObj.tagName == "HTML")
			ended = true;
	}	

	return offset_top;
}

function GetOffsetLeft(item)
{
	var ended = false;
	var offset_left = document.getElementById(item).offsetLeft;
	var parentObj = null;

	// Loop through parent objects
	while (ended == false)
	{	
		// Check if first time through loop
		if (parentObj == null)
			parentObj = document.getElementById(item).parentNode;
		else
			parentObj = parentObj.parentNode;

		// Add offset of this object
		offset_left = offset_left + parentObj.offsetLeft;
		
		// Check if top parent
		if (parentObj.tagName == "HTML")
			ended = true;
	}	

	return offset_left;
}

function AddClientTimeToLogin()
{
	var cdate = new Date();
	document.getElementById("clienttime").value = (cdate.getUTCMonth() + 1) + "/" + cdate.getUTCDate() + "/" + cdate.getUTCFullYear() + "|" + cdate.getUTCHours() + ":" + cdate.getUTCMinutes() + ":" + cdate.getUTCSeconds();

	return true;
}

function DoLogin()
{
	try
	{
		document.getElementById("frmLogin").submit();
	}
	catch (e1)
	{
		alert("DoLogin(e1) - An Error Has Occurred!");
	}
}

function DateDiff(date1, time1, date2, time2)
{
	try
	{
		d1 = new Date();
		d2 = new Date();
		diff  = new Date();
		var tstamp;

		if (IsValidDate(date1) && IsValidTime(time1))
		{
			date1temp = new Date(date1 + " " + time1);
			d1.setTime(date1temp.getTime());
		}
		else return 0

		if (IsValidDate(date2) && IsValidTime(time2))
		{
			date2temp = new Date(date2 + " " + time2);
			d2.setTime(date2temp.getTime());
		}

		// sets difference date to difference of first date and second date

		diff.setTime(Math.abs(d1.getTime() - d2.getTime()));

		timediff = diff.getTime();
		return timediff;
	}
	catch (e1)
	{
		alert("DateDiff(e1) - An Error Has Occurred!");
	}
}

function IsValidDate(dateStr)
{
	try
	{
		// Format : MM/DD/YY   MM/DD/YYYY   MM-DD-YY   MM-DD-YYYY

		var datePat = /^(\d{1,2})(\/|-)(\d{1,2})\2(\d{4})$/; // requires 4 digit year

		var matchArray = dateStr.match(datePat); // is the format ok?
		if (matchArray == null) {
		//alert(dateStr + " Date is not in a valid format.")
		return false;
		}
		month = matchArray[1]; // parse date into variables
		day = matchArray[3];
		year = matchArray[4];
		if (month < 1 || month > 12) { // check month range
		//alert("Month must be between 1 and 12.");
		return false;
		}
		if (day < 1 || day > 31) {
		alert("Day must be between 1 and 31.");
		return false;
		}
		if ((month==4 || month==6 || month==9 || month==11) && day==31) {
		//alert("Month "+month+" doesn't have 31 days!")
		return false;
		}
		if (month == 2) { // check for february 29th
		var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
		if (day>29 || (day==29 && !isleap)) {
		//alert("February " + year + " doesn't have " + day + " days!");
		return false;
		   }
		}
		return true;
	}
	catch (e1)
	{
		alert("IsValidDate(e1) - An Error Has Occurred!");
	}
}

function IsValidTime(timeStr)
{
	try
	{
		// Format : HH:MM:SS AM/PM
		// Seconds and AM/PM are optional

		var timePat = /^(\d{1,2}):(\d{2})(:(\d{2}))?(\s?(AM|am|PM|pm))?$/;

		var matchArray = timeStr.match(timePat);
		if (matchArray == null)
			return false;

		hour = matchArray[1];
		minute = matchArray[2];
		second = matchArray[4];
		ampm = matchArray[6];

		if (second=="") { second = null; }
		if (ampm=="") { ampm = null }

		if (hour < 0  || hour > 23)
			return false;

		if  (hour > 12 && ampm != null)
			return false;

		if (minute < 0 || minute > 59)
			return false;
	
		if (second != null && (second < 0 || second > 59))
			return false;

		return true;
	}
	catch (e)
	{
		return false;
	}
}

function GetMonthName(value)
{
	try
	{
		var retval = "";

		switch (parseInt(value))
		{
			case 1:
				retval = "January";
			break;

			case 2:
				retval = "February";
			break;

			case 3:
				retval = "March";
			break;

			case 4:
				retval = "April";
			break;

			case 5:
				retval = "May";
			break;

			case 6:
				retval = "June";
			break;

			case 7:
				retval = "July";
			break;

			case 8:
				retval = "August";
			break;

			case 9:
				retval = "September";
			break;

			case 10:
				retval = "October";
			break;

			case 11:
				retval = "November";
			break;

			case 12:
				retval = "December";
			break;

			default:
				retval = "Invalid Month";
			break;
		}

		return retval;
	}
	catch (e)
	{
		return "";
	}
}

function GetWeekDay(value)
{
	try
	{
		var retval = "";

		switch (value)
		{
			case 1:
				retval = "Sunday";
			break;

			case 2:
				retval = "Monday";
			break;

			case 3:
				retval = "Tuesday";
			break;

			case 4:
				retval = "Wednesday";
			break;

			case 5:
				retval = "Thursday";
			break;

			case 6:
				retval = "Friday";
			break;

			case 7:
				retval = "Saturday";
			break;

			default:
				retval = "Invalid Day";
			break;
		}

		return retval;
	}
	catch (e)
	{
		return "";
	}
}

function MakeAJAXRequest(id, url, callback_function, return_xml)
{
	try
	{
		var http_request, response, i; 

		var activex_ids = ["MSXML2.XMLHTTP.3.0","MSXML2.XMLHTTP","Microsoft.XMLHTTP"]; 

		// Mozilla, Safari, IE7+
		if (window.XMLHttpRequest)
		{
			http_request = new XMLHttpRequest();

			if (http_request.overrideMimeType)
				http_request.overrideMimeType("text/xml"); 
		}
		else if (window.ActiveXObject)
		{ // IE6 and older 
			for (i = 0; i < activex_ids.length; i++)
			{
				try
				{
					http_request = new ActiveXObject(activex_ids[i]); 
				}
				catch (e) {}
			}
		} 

		if (!http_request)
		{
			alert("Unfortunately your browser doesn't support this feature."); 
			return false;
		}

		http_request.onreadystatechange = function(){ 

				if (http_request.readyState != 4)
				{ 
					// not ready yet 
					return;
				}

				if (http_request.status != 200)
				{
					// ready, but not OK 
					alert("There was a problem with the request.(Code: " + http_request.status + ")");
					//document.getElementById("tbMessagePanel").style.display = "none";
					return;
				}

				if (return_xml)
					response = http_request.responseXML; 
				else
					response = http_request.responseText; 

				// invoke the callback 
				callback_function(id, response); 
			};

		http_request.open("GET", url, true);
		http_request.send(null);
	}
	catch (e1)
	{
		//LogError("/global/inc/js/globalfunctions.js", "MakeAJAXRequest()", e1.description);
		alert("Error : MakeAJAXRequest() - An Error Occurred!");
	}
}

function trim(str, chars)
{
	return ltrim(rtrim(str, chars), chars);
}

function ltrim(str, chars)
{
	chars = chars || "\\s";
	return str.replace(new RegExp("^[" + chars + "]+", "g"), "");
}

function rtrim(str, chars)
{
	chars = chars || "\\s";
	return str.replace(new RegExp("[" + chars + "]+$", "g"), "");
}

function InputKeyPressWasEnter(e)
{
	// Check if the enter key was pressed
	if (e.keyCode==13)
		return true;
	else
		return false;
}

function GetInteger(value)
{
	var retval = "";
	var validChars = "0123456789";

	for (index = 0; index < value.length; index++)
	{
		if (validChars.indexOf(value.substring(index, index + 1)) != -1)
			retval = retval.toString() + value.substring(index, index + 1).toString();
	}

	return parseInt(retval, 0);
}

function GetClientWidth()
{
	return FilterResults(
		window.innerWidth ? window.innerWidth : 0,
		document.documentElement ? document.documentElement.clientWidth : 0,
		document.body ? document.body.clientWidth : 0
	);
}

function GetClientHeight()
{
	return FilterResults(
		window.innerHeight ? window.innerHeight : 0,
		document.documentElement ? document.documentElement.clientHeight : 0,
		document.body ? document.body.clientHeight : 0
	);
}

function GetScrollLeft()
{
	return FilterResults(
		window.pageXOffset ? window.pageXOffset : 0,
		document.documentElement ? document.documentElement.scrollLeft : 0,
		document.body ? document.body.scrollLeft : 0
	);
}

function GetScrollTop()
{
	return FilterResults(
		window.pageYOffset ? window.pageYOffset : 0,
		document.documentElement ? document.documentElement.scrollTop : 0,
		document.body ? document.body.scrollTop : 0
	);
}

function FilterResults(n_win, n_docel, n_body)
{
	var n_result = n_win ? n_win : 0;
	if (n_docel && (!n_result || (n_result > n_docel)))
		n_result = n_docel;
	return n_body && (!n_result || (n_result > n_body)) ? n_body : n_result;
}

function RandomNumber(max)
{
	var max_val = 0;
	var retval = 0;

	if (max < 1)
		max_val = 1;
	else
		max_val = max + 1;

	retval = Math.floor(Math.random() * max_val);
	return retval;
}

function DateAdd(date_value, interval, increment)
{
	try
	{
		if ((interval != "M") && (interval != "D") && (interval != "Y") && (interval != "h") && (interval != "m") && (interval != "uM") && (interval != "uD") && (interval != "uY") && (interval != "uh") && (interval != "um") && (interval != "us"))
			throw("DateAdd: Second parameter must be M, D, Y, h, m, uM, uD, uY, uh, um or us");

		if(typeof(increment) != "number")
			throw("DateAdd: Third parameter must be a number");

		switch(interval)
		{
			case "M":
				date_value.setMonth(parseInt(this.getMonth()) + parseInt(increment));
				break;
			case "D":
				date_value.setDate(parseInt(this.getDate()) + parseInt(increment));
				break;
			case "Y":
				date_value.setYear(parseInt(this.getYear()) + parseInt(increment));
				break;
			case "h":
				date_value.setHours(parseInt(this.getHours()) + parseInt(increment));
				break;
			case "m":
				date_value.setMinutes(parseInt(this.getMinutes()) + parseInt(increment));
				break;
			case "s":
				date_value.setSeconds(parseInt(this.getSeconds()) + parseInt(increment));
				break;
			case "uM":
				date_value.setUTCMonth(parseInt(this.getUTCMonth()) + parseInt(increment));
				break;
			case "uD":
				date_value.setUTCDate(parseInt(this.getUTCDate()) + parseInt(increment));
				break;
			case "uY":
				date_value.setUTCFullYear(parseInt(this.getUTCFullYear()) + parseInt(increment));
				break;
			case "uh":
				date_value.setUTCHours(parseInt(this.getUTCHours()) + parseInt(increment));
				break;
			case "um":
				date_value.setUTCMinutes(parseInt(this.getUTCMinutes()) + parseInt(increment));
				break;
			case "us":
				date_value.setUTCSeconds(parseInt(this.getUTCSeconds()) + parseInt(increment));
				break;
		}

		return date_value;
	}
	catch (e1)
	{
		//LogError("/global/inc/js/globalfunctions.js", "DateAdd()", e1.description);
		throw("DateAdd: An Error Occurred!");
	}
}

function GetNumberPositionText(value)
{
	try
	{
		var retval = "";

		retval = trim(value)

		if (retval == "")
			retval = value;
		else
		{
			var ret_right_1 = Right(retval, 1);
			var ret_right_2 = Right(retval, 2);

			if ((ret_right_1 == "0") || (ret_right_1 == "4") || (ret_right_1 == "5") || (ret_right_1 == "6") || (ret_right_1 == "7") || (ret_right_1 == "8") || (ret_right_1 == "9") || (ret_right_2 == "11") || (ret_right_2 == "12") || (ret_right_2 == "13"))
			{
				retval = retval + "th";
			}
			else
			{
				if ((ret_right_1 == "1") && (ret_right_2 != "11"))
				{
					retval = retval + "st";
				}
				else
				{
					if ((ret_right_1 == "2") && (ret_right_2 != "12"))
					{
						retval = retval + "nd";
					}
					else
					{
						if ((ret_right_1 == "3") && (ret_right_2 != "13"))
						{
							retval = retval + "rd";
						}
					}
				}
			}
		}

		return retval;
	}
	catch (e1)
	{
		//LogError("/global/inc/js/globalfunctions.js", "GetNumberPositionText()", e1.description);
		return "";
	}
}

function HtmlDecode(s)
{
      var out = "";

      if (s==null) return;

      var l = s.length;

      for (var i=0; i<l; i++)
      {
            var ch = s.charAt(i);

            if (ch == '&')
            {
                  var semicolonIndex = s.indexOf(';', i+1);

            if (semicolonIndex > 0)
            {
                        var entity = s.substring(i + 1, semicolonIndex);

                        if (entity.length > 1 && entity.charAt(0) == '#')
                        {
                              if (entity.charAt(1) == 'x' || entity.charAt(1) == 'X')
                                    ch = String.fromCharCode(eval('0'+entity.substring(1)));
                              else
                                    ch = String.fromCharCode(eval(entity.substring(1)));
                        }
						else
						{

                              switch (entity) 
                              { 
                                    case 'quot': ch = String.fromCharCode(0x0022); break;
                                    case 'amp': ch = String.fromCharCode(0x0026); break;
                                    case 'lt': ch = String.fromCharCode(0x003c); break;
                                    case 'gt': ch = String.fromCharCode(0x003e); break;
                                    case 'nbsp': ch = String.fromCharCode(0x00a0); break;
                                    case 'iexcl': ch = String.fromCharCode(0x00a1); break;
                                    case 'cent': ch = String.fromCharCode(0x00a2); break;
                                    case 'pound': ch = String.fromCharCode(0x00a3); break;
                                    case 'curren': ch = String.fromCharCode(0x00a4); break;
                                    case 'yen': ch = String.fromCharCode(0x00a5); break;
                                    case 'brvbar': ch = String.fromCharCode(0x00a6); break;
                                    case 'sect': ch = String.fromCharCode(0x00a7); break;
                                    case 'uml': ch = String.fromCharCode(0x00a8); break;
                                    case 'copy': ch = String.fromCharCode(0x00a9); break;
                                    case 'ordf': ch = String.fromCharCode(0x00aa); break;
                                    case 'laquo': ch = String.fromCharCode(0x00ab); break;
                                    case 'not': ch = String.fromCharCode(0x00ac); break;
                                    case 'shy': ch = String.fromCharCode(0x00ad); break;
                                    case 'reg': ch = String.fromCharCode(0x00ae); break;
                                    case 'macr': ch = String.fromCharCode(0x00af); break;
                                    case 'deg': ch = String.fromCharCode(0x00b0); break;
                                    case 'plusmn': ch = String.fromCharCode(0x00b1); break;
                                    case 'sup2': ch = String.fromCharCode(0x00b2); break;
                                    case 'sup3': ch = String.fromCharCode(0x00b3); break;
                                    case 'acute': ch = String.fromCharCode(0x00b4); break;
                                    case 'micro': ch = String.fromCharCode(0x00b5); break;
                                    case 'para': ch = String.fromCharCode(0x00b6); break;
                                    case 'middot': ch = String.fromCharCode(0x00b7); break;
                                    case 'cedil': ch = String.fromCharCode(0x00b8); break;
                                    case 'sup1': ch = String.fromCharCode(0x00b9); break;
                                    case 'ordm': ch = String.fromCharCode(0x00ba); break;
                                    case 'raquo': ch = String.fromCharCode(0x00bb); break;
                                    case 'frac14': ch = String.fromCharCode(0x00bc); break;
                                    case 'frac12': ch = String.fromCharCode(0x00bd); break;
                                    case 'frac34': ch = String.fromCharCode(0x00be); break;
                                    case 'iquest': ch = String.fromCharCode(0x00bf); break;
                                    case 'Agrave': ch = String.fromCharCode(0x00c0); break;
                                    case 'Aacute': ch = String.fromCharCode(0x00c1); break;
                                    case 'Acirc': ch = String.fromCharCode(0x00c2); break;
                                    case 'Atilde': ch = String.fromCharCode(0x00c3); break;
                                    case 'Auml': ch = String.fromCharCode(0x00c4); break;
                                    case 'Aring': ch = String.fromCharCode(0x00c5); break;
                                    case 'AElig': ch = String.fromCharCode(0x00c6); break;
                                    case 'Ccedil': ch = String.fromCharCode(0x00c7); break;
                                    case 'Egrave': ch = String.fromCharCode(0x00c8); break;
                                    case 'Eacute': ch = String.fromCharCode(0x00c9); break;
                                    case 'Ecirc': ch = String.fromCharCode(0x00ca); break;
                                    case 'Euml': ch = String.fromCharCode(0x00cb); break;
                                    case 'Igrave': ch = String.fromCharCode(0x00cc); break;
                                    case 'Iacute': ch = String.fromCharCode(0x00cd); break;
                                    case 'Icirc': ch = String.fromCharCode(0x00ce ); break;
                                    case 'Iuml': ch = String.fromCharCode(0x00cf); break;
                                    case 'ETH': ch = String.fromCharCode(0x00d0); break;
                                    case 'Ntilde': ch = String.fromCharCode(0x00d1); break;
                                    case 'Ograve': ch = String.fromCharCode(0x00d2); break;
                                    case 'Oacute': ch = String.fromCharCode(0x00d3); break;
                                    case 'Ocirc': ch = String.fromCharCode(0x00d4); break;
                                    case 'Otilde': ch = String.fromCharCode(0x00d5); break;
                                    case 'Ouml': ch = String.fromCharCode(0x00d6); break;
                                    case 'times': ch = String.fromCharCode(0x00d7); break;
                                    case 'Oslash': ch = String.fromCharCode(0x00d8); break;
                                    case 'Ugrave': ch = String.fromCharCode(0x00d9); break;
                                    case 'Uacute': ch = String.fromCharCode(0x00da); break;
                                    case 'Ucirc': ch = String.fromCharCode(0x00db); break;
                                    case 'Uuml': ch = String.fromCharCode(0x00dc); break;
                                    case 'Yacute': ch = String.fromCharCode(0x00dd); break;
                                    case 'THORN': ch = String.fromCharCode(0x00de); break;
                                    case 'szlig': ch = String.fromCharCode(0x00df); break;
                                    case 'agrave': ch = String.fromCharCode(0x00e0); break;
                                    case 'aacute': ch = String.fromCharCode(0x00e1); break;
                                    case 'acirc': ch = String.fromCharCode(0x00e2); break;
                                    case 'atilde': ch = String.fromCharCode(0x00e3); break;
                                    case 'auml': ch = String.fromCharCode(0x00e4); break;
                                    case 'aring': ch = String.fromCharCode(0x00e5); break;
                                    case 'aelig': ch = String.fromCharCode(0x00e6); break;
                                    case 'ccedil': ch = String.fromCharCode(0x00e7); break;
                                    case 'egrave': ch = String.fromCharCode(0x00e8); break;
                                    case 'eacute': ch = String.fromCharCode(0x00e9); break;
                                    case 'ecirc': ch = String.fromCharCode(0x00ea); break;
                                    case 'euml': ch = String.fromCharCode(0x00eb); break;
                                    case 'igrave': ch = String.fromCharCode(0x00ec); break;
                                    case 'iacute': ch = String.fromCharCode(0x00ed); break;
                                    case 'icirc': ch = String.fromCharCode(0x00ee); break;
                                    case 'iuml': ch = String.fromCharCode(0x00ef); break;
                                    case 'eth': ch = String.fromCharCode(0x00f0); break;
                                    case 'ntilde': ch = String.fromCharCode(0x00f1); break;
                                    case 'ograve': ch = String.fromCharCode(0x00f2); break;
                                    case 'oacute': ch = String.fromCharCode(0x00f3); break;
                                    case 'ocirc': ch = String.fromCharCode(0x00f4); break;
                                    case 'otilde': ch = String.fromCharCode(0x00f5); break;
                                    case 'ouml': ch = String.fromCharCode(0x00f6); break;
                                    case 'divide': ch = String.fromCharCode(0x00f7); break;
                                    case 'oslash': ch = String.fromCharCode(0x00f8); break;
                                    case 'ugrave': ch = String.fromCharCode(0x00f9); break;
                                    case 'uacute': ch = String.fromCharCode(0x00fa); break;
                                    case 'ucirc': ch = String.fromCharCode(0x00fb); break;
                                    case 'uuml': ch = String.fromCharCode(0x00fc); break;
                                    case 'yacute': ch = String.fromCharCode(0x00fd); break;
                                    case 'thorn': ch = String.fromCharCode(0x00fe); break;
                                    case 'yuml': ch = String.fromCharCode(0x00ff); break;
                                    case 'OElig': ch = String.fromCharCode(0x0152); break;
                                    case 'oelig': ch = String.fromCharCode(0x0153); break;
                                    case 'Scaron': ch = String.fromCharCode(0x0160); break;
                                    case 'scaron': ch = String.fromCharCode(0x0161); break;
                                    case 'Yuml': ch = String.fromCharCode(0x0178); break;
                                    case 'fnof': ch = String.fromCharCode(0x0192); break;
                                    case 'circ': ch = String.fromCharCode(0x02c6); break;
                                    case 'tilde': ch = String.fromCharCode(0x02dc); break;
                                    case 'Alpha': ch = String.fromCharCode(0x0391); break;
                                    case 'Beta': ch = String.fromCharCode(0x0392); break;
                                    case 'Gamma': ch = String.fromCharCode(0x0393); break;
                                    case 'Delta': ch = String.fromCharCode(0x0394); break;
                                    case 'Epsilon': ch = String.fromCharCode(0x0395); break;
                                    case 'Zeta': ch = String.fromCharCode(0x0396); break;
                                    case 'Eta': ch = String.fromCharCode(0x0397); break;
                                    case 'Theta': ch = String.fromCharCode(0x0398); break;
                                    case 'Iota': ch = String.fromCharCode(0x0399); break;
                                    case 'Kappa': ch = String.fromCharCode(0x039a); break;
                                    case 'Lambda': ch = String.fromCharCode(0x039b); break;
                                    case 'Mu': ch = String.fromCharCode(0x039c); break;
                                    case 'Nu': ch = String.fromCharCode(0x039d); break;
                                    case 'Xi': ch = String.fromCharCode(0x039e); break;
                                    case 'Omicron': ch = String.fromCharCode(0x039f); break;
                                    case 'Pi': ch = String.fromCharCode(0x03a0); break;
                                    case ' Rho ': ch = String.fromCharCode(0x03a1); break;
                                    case 'Sigma': ch = String.fromCharCode(0x03a3); break;
                                    case 'Tau': ch = String.fromCharCode(0x03a4); break;
                                    case 'Upsilon': ch = String.fromCharCode(0x03a5); break;
                                    case 'Phi': ch = String.fromCharCode(0x03a6); break;
                                    case 'Chi': ch = String.fromCharCode(0x03a7); break;
                                    case 'Psi': ch = String.fromCharCode(0x03a8); break;
                                    case 'Omega': ch = String.fromCharCode(0x03a9); break;
                                    case 'alpha': ch = String.fromCharCode(0x03b1); break;
                                    case 'beta': ch = String.fromCharCode(0x03b2); break;
                                    case 'gamma': ch = String.fromCharCode(0x03b3); break;
                                    case 'delta': ch = String.fromCharCode(0x03b4); break;
                                    case 'epsilon': ch = String.fromCharCode(0x03b5); break;
                                    case 'zeta': ch = String.fromCharCode(0x03b6); break;
                                    case 'eta': ch = String.fromCharCode(0x03b7); break;
                                    case 'theta': ch = String.fromCharCode(0x03b8); break;
                                    case 'iota': ch = String.fromCharCode(0x03b9); break;
                                    case 'kappa': ch = String.fromCharCode(0x03ba); break;
                                    case 'lambda': ch = String.fromCharCode(0x03bb); break;
                                    case 'mu': ch = String.fromCharCode(0x03bc); break;
                                    case 'nu': ch = String.fromCharCode(0x03bd); break;
                                    case 'xi': ch = String.fromCharCode(0x03be); break;
                                    case 'omicron': ch = String.fromCharCode(0x03bf); break;
                                    case 'pi': ch = String.fromCharCode(0x03c0); break;
                                    case 'rho': ch = String.fromCharCode(0x03c1); break;
                                    case 'sigmaf': ch = String.fromCharCode(0x03c2); break;
                                    case 'sigma': ch = String.fromCharCode(0x03c3); break;
                                    case 'tau': ch = String.fromCharCode(0x03c4); break;
                                    case 'upsilon': ch = String.fromCharCode(0x03c5); break;
                                    case 'phi': ch = String.fromCharCode(0x03c6); break;
                                    case 'chi': ch = String.fromCharCode(0x03c7); break;
                                    case 'psi': ch = String.fromCharCode(0x03c8); break;
                                    case 'omega': ch = String.fromCharCode(0x03c9); break;
                                    case 'thetasym': ch = String.fromCharCode(0x03d1); break;
                                    case 'upsih': ch = String.fromCharCode(0x03d2); break;
                                    case 'piv': ch = String.fromCharCode(0x03d6); break;
                                    case 'ensp': ch = String.fromCharCode(0x2002); break;
                                    case 'emsp': ch = String.fromCharCode(0x2003); break;
                                    case 'thinsp': ch = String.fromCharCode(0x2009); break;
                                    case 'zwnj': ch = String.fromCharCode(0x200c); break;
                                    case 'zwj': ch = String.fromCharCode(0x200d); break;
                                    case 'lrm': ch = String.fromCharCode(0x200e); break;
                                    case 'rlm': ch = String.fromCharCode(0x200f); break;
                                    case 'ndash': ch = String.fromCharCode(0x2013); break;
                                    case 'mdash': ch = String.fromCharCode(0x2014); break;
                                    case 'lsquo': ch = String.fromCharCode(0x2018); break;
                                    case 'rsquo': ch = String.fromCharCode(0x2019); break;
                                    case 'sbquo': ch = String.fromCharCode(0x201a); break;
                                    case 'ldquo': ch = String.fromCharCode(0x201c); break;
                                    case 'rdquo': ch = String.fromCharCode(0x201d); break;
                                    case 'bdquo': ch = String.fromCharCode(0x201e); break;
                                    case 'dagger': ch = String.fromCharCode(0x2020); break;
                                    case 'Dagger': ch = String.fromCharCode(0x2021); break;
                                    case 'bull': ch = String.fromCharCode(0x2022); break;
                                    case 'hellip': ch = String.fromCharCode(0x2026); break;
                                    case 'permil': ch = String.fromCharCode(0x2030); break;
                                    case 'prime': ch = String.fromCharCode(0x2032); break;
                                    case 'Prime': ch = String.fromCharCode(0x2033); break;
                                    case 'lsaquo': ch = String.fromCharCode(0x2039); break;
                                    case 'rsaquo': ch = String.fromCharCode(0x203a); break;
                                    case 'oline': ch = String.fromCharCode(0x203e); break;
                                    case 'frasl': ch = String.fromCharCode(0x2044); break;
                                    case 'euro': ch = String.fromCharCode(0x20ac); break;
                                    case 'image': ch = String.fromCharCode(0x2111); break;
                                    case 'weierp': ch = String.fromCharCode(0x2118); break;
                                    case 'real': ch = String.fromCharCode(0x211c); break;
                                    case 'trade': ch = String.fromCharCode(0x2122); break;
                                    case 'alefsym': ch = String.fromCharCode(0x2135); break;
                                    case 'larr': ch = String.fromCharCode(0x2190); break;
                                    case 'uarr': ch = String.fromCharCode(0x2191); break;
                                    case 'rarr': ch = String.fromCharCode(0x2192); break;
                                    case 'darr': ch = String.fromCharCode(0x2193); break;
                                    case 'harr': ch = String.fromCharCode(0x2194); break;
                                    case 'crarr': ch = String.fromCharCode(0x21b5); break;
                                    case 'lArr': ch = String.fromCharCode(0x21d0); break;
                                    case 'uArr': ch = String.fromCharCode(0x21d1); break;
                                    case 'rArr': ch = String.fromCharCode(0x21d2); break;
                                    case 'dArr': ch = String.fromCharCode(0x21d3); break;
                                    case 'hArr': ch = String.fromCharCode(0x21d4); break;
                                    case 'forall': ch = String.fromCharCode(0x2200); break;
                                    case 'part': ch = String.fromCharCode(0x2202); break;
                                    case 'exist': ch = String.fromCharCode(0x2203); break;
                                    case 'empty': ch = String.fromCharCode(0x2205); break;
                                    case 'nabla': ch = String.fromCharCode(0x2207); break;
                                    case 'isin': ch = String.fromCharCode(0x2208); break;
                                    case 'notin': ch = String.fromCharCode(0x2209); break;
                                    case 'ni': ch = String.fromCharCode(0x220b); break;
                                    case 'prod': ch = String.fromCharCode(0x220f); break;
                                    case 'sum': ch = String.fromCharCode(0x2211); break;
                                    case 'minus': ch = String.fromCharCode(0x2212); break;
                                    case 'lowast': ch = String.fromCharCode(0x2217); break;
                                    case 'radic': ch = String.fromCharCode(0x221a); break;
                                    case 'prop': ch = String.fromCharCode(0x221d); break;
                                    case 'infin': ch = String.fromCharCode(0x221e); break;
                                    case 'ang': ch = String.fromCharCode(0x2220); break;
                                    case 'and': ch = String.fromCharCode(0x2227); break;
                                    case 'or': ch = String.fromCharCode(0x2228); break;
                                    case 'cap': ch = String.fromCharCode(0x2229); break;
                                    case 'cup': ch = String.fromCharCode(0x222a); break;
                                    case 'int': ch = String.fromCharCode(0x222b); break;
                                    case 'there4': ch = String.fromCharCode(0x2234); break;
                                    case 'sim': ch = String.fromCharCode(0x223c); break;
                                    case 'cong': ch = String.fromCharCode(0x2245); break;
                                    case 'asymp': ch = String.fromCharCode(0x2248); break;
                                    case 'ne': ch = String.fromCharCode(0x2260); break;
                                    case 'equiv': ch = String.fromCharCode(0x2261); break;
                                    case 'le': ch = String.fromCharCode(0x2264); break;
                                    case 'ge': ch = String.fromCharCode(0x2265); break;
                                    case 'sub': ch = String.fromCharCode(0x2282); break;
                                    case 'sup': ch = String.fromCharCode(0x2283); break;
                                    case 'nsub': ch = String.fromCharCode(0x2284); break;
                                    case 'sube': ch = String.fromCharCode(0x2286); break;
                                    case 'supe': ch = String.fromCharCode(0x2287); break;
                                    case 'oplus': ch = String.fromCharCode(0x2295); break;
                                    case 'otimes': ch = String.fromCharCode(0x2297); break;
                                    case 'perp': ch = String.fromCharCode(0x22a5); break;
                                    case 'sdot': ch = String.fromCharCode(0x22c5); break;
                                    case 'lceil': ch = String.fromCharCode(0x2308); break;
                                    case 'rceil': ch = String.fromCharCode(0x2309); break;
                                    case 'lfloor': ch = String.fromCharCode(0x230a); break;
                                    case 'rfloor': ch = String.fromCharCode(0x230b); break;
                                    case 'lang': ch = String.fromCharCode(0x2329); break;
                                    case 'rang': ch = String.fromCharCode(0x232a); break;
                                    case 'loz': ch = String.fromCharCode(0x25ca); break;
                                    case 'spades': ch = String.fromCharCode(0x2660); break;
                                    case 'clubs': ch = String.fromCharCode(0x2663); break;
                                    case 'hearts': ch = String.fromCharCode(0x2665); break;
                                    case 'diams': ch = String.fromCharCode(0x2666); break;
                                    default: ch = ''; break;
                              }

                        }

                        i = semicolonIndex;
                  }
            }

            out += ch;
      }

      return out;
}

function GetBrowserType()
{
	try
	{
		var browser = navigator.userAgent;

		if (/MSIE (\d+\.\d+);/.test(navigator.userAgent))
		{
			return "Internet Explorer";
		}
		else if (/Firefox[\/\s](\d+\.\d+)/.test(navigator.userAgent))
		{
			return "Firefox";
		}
		else if (/Chrome[\/\s](\d+\.\d+)/.test(navigator.userAgent))
		{
			return "Google Chrome";
		}
		else if (/Opera[\/\s](\d+\.\d+)/.test(navigator.userAgent))
		{
			return "Opera";
		}
		else if (browser.toLowerCase().indexOf('safari') > 0)
		{
			return "Safari";
		}
		else
			return "Unknown Browser";
	}
	catch(err)
	{
		return "";
	}
}

function MouseX(e)
{
	if (e.pageX) return e.pageX;
	else if (e.clientX)
		return e.clientX + (document.documentElement.scrollLeft ?
		document.documentElement.scrollLeft :
		document.body.scrollLeft);
	else return null;
}

function MouseY(e)
{
	if (e.pageY) return e.pageY;
	else if (e.clientY)
		return e.clientY + (document.documentElement.scrollTop ?
		document.documentElement.scrollTop :
		document.body.scrollTop);
	else return null;
}
function HtmlEncode(source, display, tabs){/**
 * HTML-Encode the supplied input
 * 
 * Parameters:
 *
 * (String)  source    The text to be encoded.
 * 
 * (boolean) display   The output is intended for display.
 *
 *                     If true:
 *                     * Tabs will be expanded to the number of spaces 
 *                       indicated by the 'tabs' argument.
 *                     * Line breaks will be converted to <br />.
 *
 *                     If false:
 *                     * Tabs and linebreaks get turned into &#____;
 *                       entities just like all other control characters.
 *
 * (integer) tabs      The number of spaces to expand tabs to.  (Ignored 
 *                     when the 'display' parameter evaluates to false.)
 */ 	var i, s, ch, peek, line, result,
		next, endline, push,
		spaces;
	
	// Stash the next character and advance the pointer
	next = function () {
		peek = source.charAt(i);
		i += 1;
	};
	
	// Start a new "line" of output, to be joined later by <br />
	endline = function () {
		line = line.join('');
		if (display) {
			// If a line starts or ends with a space, it evaporates in html
			// unless it's an nbsp.
			line = line.replace(/(^ )|( $)/g, '&nbsp;');
		}
		result.push(line);
		line = [];
	};
	
	// Push a character or its entity onto the current line
	push = function () {
		if (ch < ' ' || ch > '~') {
			line.push('&#' + ch.charCodeAt(0) + ';');
		} else {
			line.push(ch);
		}
	};
	
	// Use only integer part of tabs, and default to 4
	tabs = (tabs >= 0) ? Math.floor(tabs) : 4;
	
	result = [];
	line = [];

	i = 0;
	next();
	while (i <= source.length) { // less than or equal, because i is always one ahead
		ch = peek;
		next();
		
		// HTML special chars.
		switch (ch) {
		case '<':
			line.push('&lt;');
			break;
		case '>':
			line.push('&gt;');
			break;
		case '&':
			line.push('&amp;');
			break;
		case '"':
			line.push('&quot;');
			break;
		case "'":
			line.push('&#39;');
			break;
		default:
			// If the output is intended for display,
			// then end lines on newlines, and replace tabs with spaces.
			if (display) {
				switch (ch) {
				case '\r':
					// If this \r is the beginning of a \r\n, skip over the \n part.
					if (peek === '\n') {
						next();
					}
					endline();
					break;
				case '\n':
					endline();
					break;
				case '\t':
					// expand tabs
					spaces = tabs - (line.length % tabs);
					for (s = 0; s < spaces; s += 1) {
						line.push(' ');
					}
					break;
				default:
					// All other characters can be dealt with generically.
					push();
				}
			} else {
				// If the output is not for display,
				// then none of the characters need special treatment.
				push();
			}
		}
	}
	endline();
	result = result.join('<br />');
	if (display) {
		// Break up contiguous blocks of spaces with non-breaking spaces
		result = result.replace(/ {2}/g, ' &nbsp;');
	}
	return result;
};
