// ---------------------------------------------------------------------
// Change item order on GridView
// ---------------------------------------------------------------------
function MoveGridViewItem(tableName, fromIndex, toIndex)
{
	var trs = $('table#' + tableName + ' tbody').find(">tr");
	
	var trFrom = trs.eq(fromIndex);
	var trTo = trs.eq(toIndex);
	var arrowsFrom = trFrom.find("a.SortArrow");
	var arrowsTo = trTo.find("a.SortArrow");
	var tdFrom = arrowsFrom.parent();
	var tdTo = arrowsTo.parent();
	var classFrom = trFrom.attr("class");
	var classTo = trTo.attr("class");
	var hddIndexFrom = tdFrom.find("input")[0];
	var hddIndexTo = tdTo.find("input")[0];

	// Preserve class (alternating row, etc.)
	trFrom.removeClass(classFrom).addClass(classTo);
	trTo.removeClass(classTo).addClass(classFrom);

	// Preserve arrows
	tdFrom.append(arrowsTo);
	tdTo.append(arrowsFrom);

	// Set hddIndex field
	var auxIndex = hddIndexFrom.value
	hddIndexFrom.value = hddIndexTo.value;
	hddIndexTo.value = auxIndex;

	trs.eq(fromIndex)['insertAfter'](trs.eq(toIndex));
}

// ---------------------------------------------------------------------
// Loads a drop down list with the xml node list received
// ---------------------------------------------------------------------
function LoadCombo(comboId, nodeList, dataTextField, dataValueField, firstItemText, firstItemValue)
{
	var i = 0;
	var combo = document.getElementById(comboId);

	combo.visible = false;

	ClearCombo(comboId);

	if (firstItemText != "")
	{
		var firstOption = document.createElement("OPTION");

		combo.options.add(firstOption, 0);
		firstOption.innerText = firstItemText;
		firstOption.value = firstItemValue;
		combo.selectedIndex = 0;
	}

	for (i = 0; i < nodeList.length; i++)
	{
		var option = document.createElement("OPTION");

		combo.options.add(option);
		option.innerText = nodeList[i].attributes.getNamedItem(dataTextField).value;
		option.value = nodeList[i].attributes.getNamedItem(dataValueField).value;
	}


	combo.disabled = false;
	combo.visible = true;
	//combo.focus();
}

// ---------------------------------------------------------------------
// Clear the contenst of a drop down list
// ---------------------------------------------------------------------
function ClearCombo(comboId)
{
	var i = 0;
	var combo = document.getElementById(comboId);

	for (i = combo.options.length; i >= 0; i--)
		combo.options.remove(i);

	combo.disabled = true;
}

function ClearSearchCombo(comboId)
{
	var combo = document.getElementById(comboId);
	var firstOption = document.createElement("OPTION");

	ClearCombo(comboId);

	combo.options.add(firstOption, 0);
	firstOption.innerText = "< ALL >";
	firstOption.value = "0";
	combo.selectedIndex = 0;

	combo.disabled = true;
}

// ---------------------------------------------------------------------
// Clear the contenst of a data grid
// ---------------------------------------------------------------------
function ClearDataGrid(dtgId, hasNew, hasHeader, hasFooter)
{
	var table = document.getElementById(dtgId);
	var firstIndex = 0;
	var lastIndex = table.rows.length - 1;

	if (hasHeader) firstIndex++;
	if (hasNew) firstIndex++;
	if (hasFooter) lastRow--;

	for (i = lastIndex; i >= firstIndex; i--)
		table.deleteRow(i);

	table.disabled = true;
}

// ---------------------------------------------------------------------
// Selects an option in the combo based on its value
// ---------------------------------------------------------------------
function SelectComboValue(comboId, value)
{
	var i = 0;
	var combo = document.getElementById(comboId);

	if (value == null)
		return;

	for (i = 0; i < combo.options.length; i++)
		if (combo.options[i].value == value)
	{
		combo.selectedIndex = i;
		break;
	}
}

function SelectOrAddDdl(comboId, text, value)
{
	var i = 0;
	var combo = document.getElementById(comboId);

	if (value == null)
		return;

	for (i = 0; i < combo.options.length; i++)
		if (combo.options[i].value == value)
	{
		combo.selectedIndex = i;
		return;
	}

	var firstOption = document.createElement("OPTION");

	combo.options.add(firstOption, 1);
	firstOption.innerText = text;
	firstOption.value = value;
	combo.selectedIndex = 1;
}

// ---------------------------------------------------------------------
// Selects all values in a listbox 
// ---------------------------------------------------------------------
function SelectAllListBoxValue(listboxId, selValue)
{
	var i = 0;
	var listbox = document.getElementById(listboxId);

	for (i = 0; i < listbox.length; i++)
	{
		listbox.options[i].selected = selValue;
	}
}

// ---------------------------------------------------------------------
// Move one list item to another list. Source item need to have focus.
// ---------------------------------------------------------------------
function MoveOptionToList(lstSrceId, lstDestId)
{
	var lstSrce = $(lstSrceId)[0];
	var lstDest = $(lstDestId)[0];

	if (lstSrce.selectedIndex < 0 || lstSrce.options.length == 0)
		return false;

	var option = lstSrce.options[lstSrce.selectedIndex];
	var fieldName = option.innerText;
	var fieldValue = option.value;

	lstSrce.options.remove(lstSrce.selectedIndex);

	var newOption = document.createElement("OPTION");

	lstDest.options.add(newOption, 0);
	newOption.innerText = fieldName;
	newOption.value = fieldValue;

	if (lstSrce.options.length > 0)
		lstSrce.selectedIndex = 0;

	return true;
}

function MoveOptionUp(selectId)
{
	var selectList = $(selectId)[0];
	var selectOptions = selectList.getElementsByTagName('option');

	for (var i = 1; i < selectOptions.length; i++)
	{
		var opt = selectOptions[i];

		if (opt.selected)
		{
			selectList.removeChild(opt);
			selectList.insertBefore(opt, selectOptions[i - 1]);
		}
	}
}

function MoveOptionDown(selectId)
{
	var selectList = $(selectId)[0];
	var selectOptions = selectList.getElementsByTagName('option');

	for (var i = selectOptions.length - 2; i >= 0; i--)
	{
		var opt = selectOptions[i];

		if (opt.selected)
		{
			var nextOpt = selectOptions[i + 1];
			opt = selectList.removeChild(opt);
			nextOpt = selectList.replaceChild(opt, nextOpt);
			selectList.insertBefore(nextOpt, opt);
		}
	}
}

// ---------------------------------------------------------------------
// Focus
// ---------------------------------------------------------------------
function SetFocus(elementId)
{
	element = document.getElementById(elementId);

	if (element != undefined)
		if (!element.disabled)
		element.focus();
}

function Select(elementId)
{
	element = document.getElementById(elementId);

	if (element != undefined)
		if (!element.disabled)
		element.select();
}

// ---------------------------------------------------------------------
// Enablig / Disabling
// ---------------------------------------------------------------------
function DisableTextBox(textboxId)
{
	txt = document.getElementById(textboxId).readOnly = true;
}

function EnableTextBox(textboxId)
{
	txt = document.getElementById(textboxId).readOnly = false;
}

function SetEnabled(elementId, enabled)
{
	var element = document.getElementById(elementId);

	element.disabled = !enabled;
}

function Disable(elementId)
{
	var element = document.getElementById(elementId);

	if (element.disabled == false)
	{
		element.attachEvent("onclick", DisabledFunction);
		element.disabled = true;

		if (document.getElementById('calendar_' + elementId) != null)
		{
			Disable('calendar_' + elementId);
			SetImage('img_calendar_' + elementId, 'img_calendar_' + elementId + '_I');
		}
		else
		{
			SetImage('img_' + elementId, 'img_' + elementId + '_I');
		}
	}
}

function Enable(elementId)
{
	var element = document.getElementById(elementId);

	if (element.disabled == true)
	{
		element.detachEvent("onclick", DisabledFunction);
		element.disabled = false;

		if (document.getElementById('calendar_' + elementId) != null)
		{
			Enable('calendar_' + elementId);
			SetImage('img_calendar_' + elementId, 'img_calendar_' + elementId + '_N');
		}
		else
		{
			SetImage('img_' + elementId, 'img_' + elementId + '_N');
		}
	}
}

function SetImage(destination, source)
{
	if (document[destination] != undefined)
		document[destination].src = eval(source + '.src');
}

function DisabledFunction()
{
	return false;
}

function SetLinkPopup(linkId, href)
{
	var link = document.getElementById(linkId.replace('$', '_'));

	link.href = "javascript:ButtonPopup('" + href + "', '" + linkId + "', '', true);";
}

// ---------------------------------------------------------------------
// Show / Hide objects
// ---------------------------------------------------------------------
function Show(id)
{
	var element = document.getElementById(id);
	element.style.visibility = "visible";
}

function Hide(id)
{
	var element = document.getElementById(id);
	element.style.visibility = "hidden";
}

function DisplayBlock(id)
{
	var element = document.getElementById(id);
	element.style.display = "block";
}

function DisplayNone(id)
{
	var element = document.getElementById(id);
	element.style.display = "none";
}

function CollapseDiv(divId)
{
	var element = document.getElementById(divId);

	if (element.style.display != "none")
		element.style.display = "none";
	else
		element.style.display = "block";
}

function IsVisible(id)
{
	var element = document.getElementById(id);

	if (element == undefined)
		return false;

	if (element.style.display == "none")
		return false;

	if (element.style.visibility == "hidden")
		return false;

	return true;
}


// ---------------------------------------------------------------------
// Functions used in the Tab control
// ---------------------------------------------------------------------
function mOvr(src, clrOver)
{
	if (!src.contains(event.fromElement))
	{
		src.style.cursor = 'hand';
	}
}

function mOut(src, clrIn)
{
	if (!src.contains(event.toElement))
	{
		src.style.cursor = 'default';
	}
}

function mClk(src)
{
	if (event.srcElement.tagName == 'TD')
	{
		src.children.tags('A')[0].click();
	}
}


// ---------------------------------------------------------------------
// Popups
// ---------------------------------------------------------------------
function ResizeWindow(width, height)
{
	var left;
	var top;

	left = screen.width / 2 - width / 2;
	top = screen.height / 2 - height / 2;

	window.moveTo(left, top);
	window.resizeTo(width, height);
}

function ResizeDialog(width, height)
{
	var left;
	var top;

	left = screen.width / 2 - width / 2;
	top = screen.height / 2 - height / 2;

	window.dialogLeft = left + 'px';
	window.dialogTop = top + 'px';
	window.dialogWidth = width + 'px';
	window.dialogHeight = height + 'px';
}

// ---------------------------------------------------------------------
// TextBox currency & percent formatting
// ---------------------------------------------------------------------
function FormatTextBoxCurrency(txt)
{
	// If the user leaves this field blank, then just exit
	if (txt.value == "")
		return false;

	// Validate number
	if (!IsValidNumber(txt.value))
	{
		alert("Entry must be numeric.");
		txt.value = "";
		txt.select();
		return false;
	}
	else
	{
		txt.value = FormatCurrency(GetNumberFromString(txt.value));
		return true;
	}
}

function FormatTextBoxPercent(txt)
{
	// If the user leaves this field blank, then just exit
	if (txt.value == "")
		return false;

	// Validate commission percent
	if (IsValidNumber(txt.value))
	{
		var prct = GetNumberFromString(txt.value);

		if (prct < 0 || prct > 100)
		{
			alert("Percent should not be less than 0 or greater than 100.");
			txt.value = "";
			txt.select();
			return false;
		}
		else
		{
			txt.value = FormatPercent(GetNumberFromString(txt.value));
			return true;
		}
	}
	else
	{
		alert("Entry should be a numeric percent.");
		txt.value = "";
		txt.select();
		return false;
	}
}

function FormatTextBoxPercentWithDecimals(txt)
{
	// If the user leaves this field blank, then just exit
	if (txt.value == "")
		return false;

	// Validate commission percent
	if (IsValidNumber(txt.value))
	{
		var prct = GetNumberFromString(txt.value);

		if (prct < 0 || prct > 100)
		{
			alert("Percent should not be less than 0 or greater than 100.");
			txt.value = "";
			txt.select();
			return false;
		}
		else
		{
			txt.value = FormatPercentWithDecimals(GetNumberFromString(txt.value));
			return true;
		}
	}
	else
	{
		alert("Entry should be a numeric percent.");
		txt.value = "";
		txt.select();
		return false;
	}
}


/******************************** Mask ************************************/

var reOneOrMoreDigits = /[\d+]/;
var reNoDigits = /[^\d]/gi;

function doMask(textBox)
{
	var keyCode = event.which ? event.which : event.keyCode;

	// enter, backspace, delete and tab keys are allowed thru
	if (keyCode == 13 || keyCode == 8 || keyCode == 9 || keyCode == 46)
		return true;

	// get character from keyCode....dealing with the "Numeric KeyPad" 
	// keyCodes so that it can be used
	var keyCharacter = cleanKeyCode(keyCode);

	// grab the textBox value and the mask
	var val = textBox.value;
	var mask = textBox.mask;

	// simple Regex to check if key is a digit
	if (reOneOrMoreDigits.test(keyCharacter) == false)
		return false;

	// get value minus any masking by removing all non-numerics
	val = val.replace(reNoDigits, '');

	// add current keystroke
	val += keyCharacter;

	// mask it...val holds the existing TextBox.value + the current keystroke
	textBox.value = val.maskValue(mask);

	setCaretAtEnd(textBox);

	return false;
}

// puts starting chars in field
function onFocusMask(textBox)
{
	var val = textBox.value;
	var mask = textBox.mask;

	if (val.length == 0 || val == null)
	{
		var i = mask.indexOf('#');

		textBox.value = mask.substring(0, i);
	}

	setCaretAtEnd(textBox);

	// set just in case.
	textBox.maxlength = mask.length;
}

// blank field if no digits entered
function onBlurMask(textBox)
{
	var val = textBox.value;

	// if no digits....nada entered.....blank it.
	if (reOneOrMoreDigits.test(val) == false)
	{
		textBox.value = '';
	}
}

String.prototype.maskValue = function(mask)
{
	var retVal = mask;
	var val = this;

	//loop thru mask and replace #'s with current value one at a time

	// better way of doing this ???
	for (var i = 0; i < val.length; i++)
	{
		retVal = retVal.replace(/#/i, val.charAt(i));
	}

	// get rid of rest of #'s
	retVal = retVal.replace(/#/gi, "");

	return retVal;
}

// The Numeric KeyPad returns keyCodes that ain't all that workable.
// ie: KeyPad '1' returns keyCode 97 which String.fromCharCode converts to an 'a'.
// This cheesy way allows the Numeric KeyPad to be used
function cleanKeyCode(key)
{
	switch (key)
	{
		case 96: return "0"; break;
		case 97: return "1"; break;
		case 98: return "2"; break;
		case 99: return "3"; break;
		case 100: return "4"; break;
		case 101: return "5"; break;
		case 102: return "6"; break;
		case 103: return "7"; break;
		case 104: return "8"; break;
		case 105: return "9"; break;
		default: return String.fromCharCode(key); break;
	}

}

function setCaretAtEnd(field)
{
	if (field.createTextRange)
	{
		var r = field.createTextRange();

		r.moveStart('character', field.value.length);

		r.collapse();

		r.select();
	}
}

function Capitalize(string)
{
	var tmpStr, tmpChar, preString, postString, strlen;
	tmpStr = string.toLowerCase();
	stringLen = tmpStr.length;

	if (stringLen > 0)
	{
		for (i = 0; i < stringLen; i++)
		{
			if (i == 0)
			{
				tmpChar = tmpStr.substring(0, 1).toUpperCase();
				postString = tmpStr.substring(1, stringLen);
				tmpStr = tmpChar + postString;
			}
			else
			{
				tmpChar = tmpStr.substring(i, i + 1);

				if (tmpChar == " " && i < (stringLen - 1))
				{
					tmpChar = tmpStr.substring(i + 1, i + 2).toUpperCase();
					preString = tmpStr.substring(0, i + 1);
					postString = tmpStr.substring(i + 2, stringLen);
					tmpStr = preString + tmpChar + postString;
				}
			}
		}
	}

	return tmpStr;
}

// ---------------------------------------------------------------------
// URLEncode
// ---------------------------------------------------------------------
function URLEncode(value)
{
	var SAFECHARS = "0123456789" + 				        // Numeric
									"ABCDEFGHIJKLMNOPQRSTUVWXYZ" + // Alphabetic
									"abcdefghijklmnopqrstuvwxyz" +
									"-_.!~*'()"; 				          // RFC2396 Mark characters

	var HEX = "0123456789ABCDEF";

	var plaintext = value;
	var encoded = "";
	for (var i = 0; i < plaintext.length; i++)
	{
		var ch = plaintext.charAt(i);
		if (ch == " ")
		{
			encoded += "+"; 			// x-www-urlencoded, rather than %20
		} else if (SAFECHARS.indexOf(ch) != -1)
		{
			encoded += ch;
		} else
		{
			var charCode = ch.charCodeAt(0);
			if (charCode > 255)
			{
				alert("Unicode Character '"
												+ ch
												+ "' cannot be encoded using standard URL encoding.\n" +
									"(URL encoding only supports 8-bit characters.)\n" +
							"A space (+) will be substituted.");
				encoded += "+";
			} else
			{
				encoded += "%";
				encoded += HEX.charAt((charCode >> 4) & 0xF);
				encoded += HEX.charAt(charCode & 0xF);
			}
		}
	}

	return encoded;
}


// ---------------------------------------------------------------------
// Begin Functions for showing and hidding "Loading..." message
// ---------------------------------------------------------------------
function ShowUnloadMessage()
{
	// If unload message ("Loading...") is not disabled then show it
	if ((typeof (loading_message_enabled) != "undefined" && loading_message_enabled))
	{
		if (typeof (loading) == "undefined")
		{
			loading = "Loading..."
		}

		var message_container_height = 44;
		var message_container_width = 304;

		var message_container = find_object('loading_div_container');
		var message_text_container = find_object('loading_text_container');

		if (message_text_container != null)
		{
			message_text_container.innerText = unescape(loading);
		}

		document.body.style.cursor = 'wait';

		var screen_width = getViewportWidth();
		var screen_height = getViewportHeight();

		var new_x = ((screen_width - message_container_width) / 2) + getHorizontalOffset();
		var new_y = ((screen_height - message_container_height) / 2) + getVerticalOffset() - 10;

		//set_object_position (message_container, new_y, new_x);
		set_object_display_mode(message_container, 'block');
	}
}

function HideUnloadMessage()
{
	var message_container = find_object('loading_div_container');
	set_object_display_mode(message_container, 'none');
	document.body.style.cursor = 'default';
}

// -- Helpers
function find_object(n, d)
{
	var p, i, x;

	if (!d)
	{
		d = document;
	}

	if ((p = n.indexOf("?")) > 0 && parent.frames.length)
	{
		d = parent.frames[n.substring(p + 1)].document;
		n = n.substring(0, p);
	}

	if (!(x = d[n]) && d.all)
	{
		x = d.all[n]
	};

	for (i = 0; !x && i < d.forms.length; i++)
	{
		x = d.forms[i][n];
	}

	for (i = 0; !x && d.layers && i < d.layers.length; i++)
	{
		x = find_object(n, d.layers[i].document);
	}

	if (!x && d.getElementById)
	{
		x = d.getElementById(n);
	}
	return x;
}

function set_object_display_mode(domObject, displayMode)
{

	if (domObject != null && typeof (domObject.style) != 'undefined')
	{
		domObject.style.display = displayMode;
	}
}

function set_object_size(domObject, width, height)
{
	if (domObject != null && typeof (domObject.style) != 'undefined')
	{
		domObject.style.width = width;
		domObject.style.height = height;
	}
	else
	{
		// alert ( "undefined");
	}
}

function set_object_position(domObject, top, left)
{
	if (domObject != null && typeof (domObject.style) != 'undefined')
	{
		domObject.style.left = left;
		domObject.style.top = top;
	}
	else
	{
		// alert ( "undefined");
	}
}

function getViewportHeight()
{
	if (window.innerHeight != window.undefined) return window.innerHeight;
	if (document.compatMode == 'CSS1Compat') return document.documentElement.clientHeight;
	if (document.body) return document.body.clientHeight;
	return window.undefined;
}

function getViewportWidth()
{
	if (window.innerWidth != window.undefined) return window.innerWidth;
	if (document.compatMode == 'CSS1Compat') return document.documentElement.clientWidth;
	if (document.body) return document.body.clientWidth;
	return window.undefined;
}

function getVerticalOffset()
{
	if (document.body) return document.body.scrollTop;
	if (window.pageYOffset) return window.pageYOffset;
	return window.undefined;
}

function getHorizontalOffset()
{
	if (document.body) return document.body.scrollLeft;
	if (window.pageXOffset) return window.pageXOffset;
	return window.undefined;
}

// ---------------------------------------------------------------------
// End Functions for showing and hidding "Loading..." message
// ---------------------------------------------------------------------

function ParseDecimal(d)
{
	var str = d.replace(",", "");

	return str * 1.0;
}

// ---------------------------------------------------------------------
// Cross browser ENTER to TAB function
// ---------------------------------------------------------------------
function Tab(obj)
{
	var nextTabIndex = obj.tabIndex + 1;
	var next = $("*[@tabIndex=" + nextTabIndex + "]");

	try
	{
		if (next.length > 0)
		{
			next[0].focus();
		}
		else
		{
			var first = $("*[@tabIndex=1]");
			first[0].focus();
		}
	}
	catch (err) { }
}

function Enter(e)
{
	var key = 0;
	
	if (e.keyCode) { key = e.keyCode; } // for moz/fb, if keyCode==0 use 'which'
	else if (typeof (e.which) != 'undefined') { key = e.which; }

	if (key == 13)
		return true;
	else
		return false;
}