//---------------------------------------------------
// Global Javascript Code
//---------------------------------------------------

// Global for browser version branching.
var isIE = (navigator.appName == "Microsoft Internet Explorer");
var isDOM = (document.getElementById ? true : false);
var isIE4 = ((document.all && !isDOM) ? true : false);
var isNS4 = (document.layers ? true : false);
var objUpperArrow;				    // Stores pleloaded upper arrow (triangle) image
var objLowerArrow;				    // Stores pleloaded lower arrow (triangle) image
var objSpacer;    				    // Stores pleloaded spacer image
var objBGIMG;				        	// Stores pleloaded background image for dynamicly genrated pop-up windows.
var aryImages = new Array();	// Stores other pleloaded images
var objPlsWaitWin;		  			// "Please Wait" window handler.

//Preload repetetive images
if (document.images) {
	if (!isNS4) {
		objBGIMG = new Image();
		objBGIMG.src = "/images/blueBG.gif";
		objUpperArrow = new Image();
		objUpperArrow.src = "/images/blue_arrow_up.gif";
		objLowerArrow = new Image();
		objLowerArrow.src = "/images/blue_arrow_down.gif";
		objSpacer = new Image();
		objSpacer.src = "/images/spacer.gif";
	}
}  

// General purpose variable to be evaluated using eval() called from performAction()
var Action;  

// sort variables
var sortByCol = -1;
var sortByDir = "";
var arTable = new Array();
var ColumnCount;
var AlternateLines = false;

// QueryString processing arrays
QueryString.keys = new Array();
QueryString.values = new Array();

// keyCode definitions
var KEY_HOME = 36;
var KEY_END = 35;
var KEY_PGUP = 33;
var KEY_PGDN = 34;
var KEY_UP = 38;
var KEY_DOWN = 40;
var KEY_LEFT = 37;
var KEY_RIGHT = 39;
var KEY_ENTER = 13;

// default search text
var SEARCH_DEFAULT = "";
var resetField;
var resetField2;
var errorArray = new Array();

// tabular data variables
var tableData = new Array();
var arId = new Array();
var arActive = new Array();
var dataIdx = 0;
var lastPageNumber = 0;
var startPageNumber = 0;
var firstPageNumber = 1;
var pagesPerSet = 5;
var finishPageNumber = pagesPerSet;
var pageSize = 0;
var tableOffset = 0;
var linesPerRecord = 1;
var currTableName;
var currPageNumber = 0;
var showEmptyColumn = false;
var showLineNumbers = false;
var columnsPerLine = 0;
var tableColumnCount = 0;
var tableColumnShift = 0;
var isTableReverse = false;
var showStatus = true;
var additionalPageProcessing = null;
var onShowGenericCell = null;
var tableRowOffset = 1;
var paging = true;
var SPECIAL_COLUMN = 15;

// tabular data constants
var MAX_RECORD_COUNT = 1800;
var DEFAULT_PAGE_SIZE = 15;
var EMPTY_CELL = " ";

// variables to handle dynamic tabled for lists
var TableRowCounter = 0;
var ExtraRowCounter = 0;
var selectedRow = null;

// cookies
var PROJECT_LIST_PAGE_COOKIE = "ProjectListPageCookie";
var NO_PAGING_COOKIE = "NoPagingCookie";

//---------------------------------------------------
// Browser-independent util methods
//---------------------------------------------------
function getRefId(id) {
	if (isDOM) {
		return document.getElementById(id);
	}
	if (isIE4) {
		return document.all[id];
	}
	if (isNS4) {
		return document.layers[id];
	}
}
function getStyleId(id) {
	return (isNS4 ? getRefId(id) : (getRefId(id) ? getRefId(id).style : null));
}
function setObjStyle(object, value) {
	if (object) {
		var obj = (isNS4 ? object : object.style);
		obj = value;
	}
} 

//---------------------------------------------------
// Writes in-line data value to the page stream
//---------------------------------------------------
function setTableValue(irow, icol) {
	if (linesPerRecord > 1) {
		setTableValueMultiLine(irow, icol, false);
	} else {
		setTableValueOneLine(irow, icol, false);
	}
}

//---------------------------------------------------
// clear in-line data value to the page stream
//---------------------------------------------------
function clearTableValue(irow, icol) {
	if (linesPerRecord > 1) {
		setTableValueMultiLine(irow, icol, true);
	} else {
		setTableValueOneLine(irow, icol, true);
	}
}

//---------------------------------------------------
// Writes single-line data into the table
//---------------------------------------------------
function setTableValueOneLine(irow, icol, clearField) {
	var oTable = getRefId(currTableName);
	if (oTable) {
		var irow1 = irow - Math.floor(irow / pageSize) * pageSize + 1;
		var icol1 = icol;
		var itablerow = (isTableReverse ? icol1 : irow1) + tableOffset;
		if (itablerow < oTable.rows.length) {
			var itablecol = (isTableReverse ? irow1 : icol1) + tableColumnShift;

			// Show optionally Line Numbers for Vertically positioned table
			if (showLineNumbers && isTableReverse && itablerow == 0 && irow < tableData.length) {
				var irow1 = irow + 1;
				var oCell = getRefId("lineHeader" + itablecol);
				if (oCell) {
					var itablecol_1 = itablecol - 1;
					if (clearField) {
						setCellHTML(oCell, EMPTY_CELL, false);
					} else {
						setCellHTML(oCell, (arId && arId[irow] ? arId[irow] : irow1), false);
					}
				}
			}	
				
			// Fill-in the rest of the table
			if (irow < tableData.length && oTable.rows(itablerow)) {
				var oCell = oTable.rows(itablerow).cells(itablecol);
				if (clearField) {
					setCellHTML(oCell, EMPTY_CELL, true);
				} else {
					if (onShowGenericCell) {
						onShowGenericCell(oCell, irow, icol);
					}
					setCellHTML(oCell, tableData[irow][icol], true);
				}
			}
		}
	}
}

//---------------------------------------------------
// Writes multi-line data into the table
//---------------------------------------------------
function setTableValueMultiLine(irow, icol, clearField) {
	var oTable = getRefId(currTableName);
	if (oTable) {
		var itablerow = irow - Math.floor(irow / pageSize) * pageSize + tableOffset;
		itablerow = linesPerRecord * itablerow + 1;
		if (itablerow < oTable.rows.length) {
			var floorCol = Math.floor(icol / columnsPerLine);
			var itablecol = icol - (floorCol * columnsPerLine) + tableColumnShift;
			for (var j = 0; j < floorCol; j++) {
				itablerow++;
			}
			if (showEmptyColumn || icol > 0) {
				var cell = oTable.rows(itablerow).cells(itablecol);
				if (cell) {
					setCellHTML(cell, (oTable.rows(itablerow) && irow < tableData.length && !clearField ? tableData[irow][icol] : EMPTY_CELL), true);
				}
			}
		}
	}
}

//---------------------------------------------------
// Writes in-line menu (Select/Edit/Delete)
//---------------------------------------------------
function setCellHTML(cell, text, toWrap) {
//alert('cell.innerHTML='+cell.innerHTML+'nntext='+text);	
	if (cell != null) {
		var width = parseInt(cell.width - 2);
		if (toWrap) {
			cell.innerHTML = "<span style=\"width: " + width + "; overflow: hidden;\">" + text + "</span>";
		} else {
			cell.innerHTML = text;
		}
	}
}

//---------------------------------------------------
// Function to plug tabular data into Table
//---------------------------------------------------
function refreshTable() {
	var oPageLinks = getRefId("pageLinks");
	var oPageNumberTD = getRefId("pageNumberTD");
	var irowStart = (currPageNumber - 1) * pageSize;
	var irowEnd = irowStart + pageSize;
	if (tableColumnCount == 0 && tableData.length > 0) {
		if (tableData[0]) {
			tableColumnCount = tableData[0].length;
		}
	}
	if (columnsPerLine == 0) {
		columnsPerLine = (tableColumnCount == 0 ? 1 : tableColumnCount);
	}
    
  //clean-up all cells first 
	if (paging) {
		for (var irow = 0; irow < pageSize; irow++) {
			for (var icol = 0; icol < tableColumnCount; icol++) {
				clearTableValue(irow, icol);
			}
		}
	} 
  //fill-in cells that need to be filled-in, second
	for (var irow = irowStart; irow < irowEnd && tableData.length > 0 && irow <= MAX_RECORD_COUNT; irow++) {
		for (var icol = 0; icol < tableColumnCount; icol++) {
			setTableValue(irow, icol);
		}
	}
	if (oPageLinks) {
		startPageNumber = Math.floor((currPageNumber - 1) / pagesPerSet) * pagesPerSet;
		finishPageNumber = (startPageNumber + pagesPerSet > lastPageNumber ? lastPageNumber : startPageNumber + pagesPerSet);
		var strHtml = "";
		for (var i = startPageNumber; i < finishPageNumber; i++) {
			var i1 = i + 1;
			if (strHtml != "") {
				strHtml += "&nbsp;";
			}
			if (i1 == currPageNumber) {
				strHtml += "[" + currPageNumber + "]";
			} else {
				strHtml += "<a href=\"#\" onclick=\"showPage(" + i1 + ")\" class=\"PageNumber\">" + i1 + "</a>";
			}
		}
		oPageLinks.innerHTML = strHtml;
		setupPageCounterLinks();
		if (oPageNumberTD) {
			if (tableData.length == 0 || lastPageNumber == 1) {
				oPageNumberTD.innerHTML = "&nbsp;";
			}
		}
	}
}

//---------------------------------------------------
// Function to setup page counter links
//---------------------------------------------------
function setupPageCounterLinks() {
	var oPrevSetLink = getRefId("prevSetLink");
	var oPrevPageLink = getRefId("prevPageLink");
	var oNextPageLink = getRefId("nextPageLink");
	var oNextSetLink = getRefId("nextSetLink");
	if (oPrevSetLink) {
		oPrevSetLink.disabled = (startPageNumber == 0);
		oPrevSetLink.title = (oPrevSetLink.disabled ? "no previous pages available" : "show previous " + pagesPerSet + " pages");
	}
	if (oPrevPageLink) {
		oPrevPageLink.disabled = (currPageNumber == 1);
		oPrevPageLink.title = (oPrevPageLink.disabled ? "no previous page available" : "show previous page");
	}
	if (oNextPageLink) {
		oNextPageLink.disabled = (currPageNumber + 1 > lastPageNumber);
		oNextPageLink.title = (oNextPageLink.disabled ? "no next page available" : "show next page");
	}
	if (oNextSetLink) {
		oNextSetLink.disabled = (finishPageNumber == lastPageNumber);
		oNextSetLink.title = (oNextSetLink.disabled ? "no next pages available" : "show next " + pagesPerSet + " pages");
	}
}

//---------------------------------------------------
// Function to set Current Page Number (incl. cookies)
//---------------------------------------------------
function setCurrPageNumber(pageNumber) {
	currPageNumber = pageNumber;
	eraseCookie(PROJECT_LIST_PAGE_COOKIE);
	createCookie(PROJECT_LIST_PAGE_COOKIE, pageNumber, 1);
}

//---------------------------------------------------
// Function to show the Current page of the table
//---------------------------------------------------
function showPage(pageNo) {
	if (pageNo > 0 && pageNo <= lastPageNumber) {
		setCurrPageNumber(pageNo);
		refreshTable();
		if (additionalPageProcessing) {
			additionalPageProcessing();
		}
	}
}

//---------------------------------------------------
// Function to show the previous set of the pages
//---------------------------------------------------
function prevSet() {
	if (currPageNumber > pagesPerSet) {
		setCurrPageNumber(currPageNumber - pagesPerSet);
	} else {
		setCurrPageNumber(1);
	}
	refreshTable();
	if (additionalPageProcessing) {
		additionalPageProcessing();
	}
}

//---------------------------------------------------
// Function to show the previous page of the table
//---------------------------------------------------
function prevPage() {
	if (currPageNumber > 1) {
		setCurrPageNumber(currPageNumber - 1);
		refreshTable();
		if (additionalPageProcessing) {
			additionalPageProcessing();
		}
	}
}

//---------------------------------------------------
// Function to show the next page of the table
//---------------------------------------------------
function nextPage() {
	if (currPageNumber < lastPageNumber) {
		setCurrPageNumber(currPageNumber + 1);
		refreshTable();
		if (additionalPageProcessing) {
			additionalPageProcessing();
		}
	}
}

//---------------------------------------------------
// Function to show the next set of the pages
//---------------------------------------------------
function nextSet() {
	if (currPageNumber + pagesPerSet <= lastPageNumber) {
		setCurrPageNumber(currPageNumber + pagesPerSet);
	} else {
		setCurrPageNumber(lastPageNumber);
	}
	refreshTable();
	if (additionalPageProcessing) {
		additionalPageProcessing();
	}
}

//---------------------------------------------------
// Function to consume click() event
//---------------------------------------------------
function consumeClick() {
//  if (event && window.event)
//  	window.event.returnValue = false;
}	

//---------------------------------------------------
// Function to show the alert message
// and consume click() event
//---------------------------------------------------
function safeAlert(msg) {
	consumeClick();
	alert(msg);
}	

//---------------------------------------------------
// Function to show the "Not implemented yet!" message
// and consume click() event
//---------------------------------------------------
function notImplemented() {
	safeAlert("Not implemented yet!");
}	
//---------------------------------------------------
// Function to open new modal window
//---------------------------------------------------
function openNewModalWindow(url, param, width, height) {
	var feature = " status=no dependent=yes scrollbars=no titlebar=no toolbar=no menubar=no";
	if (param > "") {
		url += param;
	}
	openDialog(url, "", width, height, "", feature);
	blockEvents();
}

//---------------------------------------------------
// Function to open new modal window
//---------------------------------------------------
function openNewModalResizableWindow(url, param, width, height) {
	var feature = " status=no dependent=yes scrollbars=no titlebar=no toolbar=no menubar=no";
	if (param > "") {
		url += param;
	}
	openGenericDialog(url, "", width, height, "", feature, true);
	blockEvents();
}

//---------------------------------------------------
// Function to open new non-modal window
//---------------------------------------------------
function openNewNonModalResizableWindow(url, param, width, height) {
	var feature = " status=no dependent=yes scrollbars=no titlebar=no toolbar=no menubar=no";
	if (param > "") {
		url += param;
	}
	openNewResizableWindow(url, "", width, height, "", feature);
}

//---------------------------------------------------
// Function to go to a page outside of the application
//---------------------------------------------------
function gotoExternalUrl(urlPage) {
	consumeClick();
	location.href = urlPage;
}

//---------------------------------------------------
// Function to get current index from selected row
//---------------------------------------------------
function getCurrentIndexFromRow() {
	return getIndexFromRow(selectedRow);
}
//---------------------------------------------------
// Function to get a index from selected row
//---------------------------------------------------
function getIndexFromRow(row) {
	var idx = -1;
	if (row) {
		idx = getPagedIndex(row.rowIndex);
	}
	return idx;
}

//---------------------------------------------------
// Function to get an array index from the row index
//---------------------------------------------------
function getPagedIndex(index) {
	var idx = index - tableOffset;
	idx += (currPageNumber - 1) * pageSize;
	return idx;
}

//---------------------------------------------------
// Function to open new modal window
//---------------------------------------------------
function openNewModalWindowMS(url, param, width, height) {
	var top = (screen.height - height) / 2;
	var left = (screen.width - width) / 2;
	var feature = "dialogWidth: " + width + "px;";
	feature += "dialogHeight: " + height + "px;";
	feature += "status: off; scroll: off; center: yes; resizable: off; help: off;";
	if (param > "") {
		url += param;
	}
	window.showModalDialog(url, "", feature);
}

//---------------------------------------------------
// Function to highlight a row in the table
//---------------------------------------------------
function highlightRow(row) {
	highlightRowNoFocus(row);
	if (selectedRow) {
		selectedRow.focus();
	}
}

//---------------------------------------------------
// Function to highlight a row in the table without focus
//---------------------------------------------------
function highlightRowNoFocus(row) {
	if (row) {
		if (selectedRow) {
			selectedRow.className = savedClassName;
			if (treeMode) {
				assignClassToChildren(selectedRow, selectedRow.className);
			}
		}
		savedClassName = row.className;
		row.className = "TableRowSelected";
		if (treeMode) {
			assignClassToChildren(row, row.className);
		}
		if (viewDetail) {
			if (reveal) {
				reveal(row);
			}
		}
		selectedRow = row;
	}
}
//---------------------------------------------------
// Function to highlight a row in the table
//  and consume event that cause this action
//---------------------------------------------------
function highlightRowConsumeEvent(row) {
	if (row.rowIndex >= tableOffset) {
		highlightRow(row);
	}
	consumeClick();
}

//---------------------------------------------------
// Function to toggle a checkbox
//---------------------------------------------------
function toggleRow(row, name) {
	if (row) {
		var idx = row.rowIndex;
		if (row.parentNode) {
			if (row.parentNode.rows.length == 1) {
				eval("document.forms[0]. " + name + ".checked = !document.forms[0]. " + name + ".checked;");
			} else {
				if (row.parentNode.rows.length > 1) {
					eval("document.forms[0]. " + name + "[" + idx + "].checked = !document.forms[0]. " + name + "[" + idx + "].checked;");
				}
			}
		}
	}
}

//---------------------------------------------------
// Function to highlight the 1st row in the table
//---------------------------------------------------
function highlight1stRow(tableName) {
	var oTable = getRefId(tableName);
	if (oTable) {
		if (oTable.rows.length > 0) {
			highlightRow(oTable.rows(0));
		}
		oTable.focus();
	}
}
//---------------------------------------------------
// Function to synchronize scrolling position of the
// Header table (tableName + 'Header') with the table
//---------------------------------------------------
function scrollDiv(DivName) {
	var oDiv = getRefId(DivName);
	if (oDiv && event) {
		oDiv.scrollLeft = event.srcElement.scrollLeft;
	}
}

//---------------------------------------------------
// Function to move highlight in the Grid (up and down)
//---------------------------------------------------
function moveGridHighlight(tableName) {
	moveGridHighlightGen(tableName, true);
}
function moveGridHighlightGen(tableName, usePositioning) {
//alert('in moveGridHighlightGen()');
	if (selectedRow) {
		var oTable = getRefId(tableName);
		if (oTable && event) {
			switch (event.keyCode) {
			  case KEY_UP:
				if (selectedRow.rowIndex > 0) {
					highlightRowConsumeEvent(oTable.rows(selectedRow.rowIndex - 1));
				}
				break;
			  case KEY_DOWN:
				if (selectedRow.rowIndex < oTable.rows.length - 1) {
					highlightRowConsumeEvent(oTable.rows(selectedRow.rowIndex + 1));
				}
				break;
			  case KEY_PGUP:
				if (selectedRow.rowIndex - gridPageSize >= 0) {
					highlightRowConsumeEvent(oTable.rows(selectedRow.rowIndex - gridPageSize));
				} else {
					highlightRowConsumeEvent(oTable.rows(0));
				}
				break;
			  case KEY_PGDN:
				if (selectedRow.rowIndex + gridPageSize < oTable.rows.length - 1) {
					highlightRowConsumeEvent(oTable.rows(selectedRow.rowIndex + gridPageSize));
				} else {
					highlightRowConsumeEvent(oTable.rows(oTable.rows.length - 1));
				}
				break;
			  case KEY_HOME:
				if (event.ctrlKey) {
					highlightRowConsumeEvent(oTable.rows(0));
				}
				break;
			  case KEY_END:
				if (event.ctrlKey) {
					highlightRowConsumeEvent(oTable.rows(oTable.rows.length - 1));
				}
				break;
			}
			if (usePositioning) {
				selectedRow.scrollIntoView(false);
			}
		}
	}
}

//---------------------------------------------------
// Function to alternate style for rows in the table
//---------------------------------------------------
function alternateRowStyles(tableName) {
	var oTable = getRefId(tableName);
	if (oTable) {
		var alt = 0;
		for (var j = 0; j < oTable.rows.length; j++) {
			if (alt == 0) {
				oTable.rows(j).className = "TableRow";
			} else {
				oTable.rows(j).className = "TableRowAlt";
			}
			if (useSpecStyle) {
				useSpecStyle(oTable.rows(j), j);
			}
			alt = 1 - alt;
		}
	}
}

//---------------------------------------------------
// Function to clear-up the the search box.
//---------------------------------------------------
function initFindLine(obj) {
	if (obj) {
		if (obj.value) {
			if (obj.value == SEARCH_DEFAULT) {
				obj.value = "";
			}
		}
	}
}


//---------------------------------------------------
// Function to initialize Project List
//---------------------------------------------------
function initProjectList(tableName) {
	var ck = readCookie(PROJECT_LIST_PAGE_COOKIE);
	if (ck) {
		firstPageNumber = parseInt(ck);
	}
	setCurrPageNumber(firstPageNumber > lastPageNumber ? 1 : firstPageNumber);
	currTableName = tableName;
	ColumnCount = 14;
	onShowGenericCell = formatProjectListCell;
	if (paging) {
		refreshTable();
	} else {
		oLinks = getRefId("pageNumberTD");
		if (oLinks) {
			oLinks.innerHTML = "&nbsp;";
		}
	}
	initList(tableName, pageSize, false, null, 0);
}

//---------------------------------------------------
// Function to initialize Project List
//---------------------------------------------------
function togglePaging(oCheckbox) {
	var showAllParam = "&showAll=true";
	var checked = oCheckbox && oCheckbox.checked;
	var param = (checked ? showAllParam : "");
	var url = location.href.replace("#", "").replace(showAllParam, "") + param;
	var value = (checked ? "true" : "false");
	eraseCookie(NO_PAGING_COOKIE);
	createCookie(NO_PAGING_COOKIE, value, 1);
	location.href = url;
}

//---------------------------------------------------
// Function to initialize Paging Mode
//---------------------------------------------------
function initPaging() {
	var result = (QueryString("showAll") == null);
	if (result) {
		var ck = readCookie(NO_PAGING_COOKIE);
		if (ck) {
			result = (ck != "true");
		}
	}
	return result;
}

//---------------------------------------------------
// Function to format Project List Cell
//---------------------------------------------------
function formatProjectListCell(oCell, irow, icol) {
	var oStyle = (oCell.style ? oCell.style : oCell);
	if (oStyle && tableData[irow][SPECIAL_COLUMN]) {
	}
	oStyle.backgroundColor = tableData[irow][SPECIAL_COLUMN];
}

//---------------------------------------------------
// Generic Function to initialize a list
//---------------------------------------------------
function initList(tableName, pageSize, viewDet, revealFunc, colCount) {
	gridPageSize = pageSize;
	viewDetail = viewDet;

//  var row = initSelectedRow(tableName);
	if (revealFunc) {
		reveal = revealFunc;
	}
	if (AlternateLines) {
		alternateRowStyles(tableName);
	}
//  highlightRow(row);
	if (selectedRow) {
		getRefId(tableName).click();
		selectedRow.scrollIntoView(true);
	}
	if (colCount > 0) {
		ColumnCount = colCount;
	}
//  prepareSort(tableName);
}

//---------------------------------------------------
// Function to consume Enter key pressing event
//---------------------------------------------------
function consumeEnterKey() {
	if (event && event.keyCode == KEY_ENTER) {
		event.returnValue = false;
	}
}

//---------------------------------------------------
// Function to assign className to the children
// nodes of the node obj.
//---------------------------------------------------
function assignClassToChildren(obj, className) {
	if (obj) {
		if (obj.childNodes) {
			for (var i = 0; i < obj.childNodes.length; i++) {
				var child = obj.childNodes[i];
				if (child.nodeName == "TR") {
					child.className = className;
				}
				assignClassToChildren(child, className);
			}
		}
	}
}

//---------------------------------------------------
// Function to show context-sensitive help
//---------------------------------------------------
function printPage() {
	window.print();
}

//---------------------------------------------------
// Function to show (hide outside of the visible area)
// the printer-ready page
//---------------------------------------------------
function printPrinterReadyPage(page, winName) {
	if (page) {
		var param = " status=no dependent=yes scrollbars=yes titlebar=no toolbar=no menubar=no";
		printWin = openNewWindowGeneral(page, winName, 750, 500, 0, 100, null, param);
		printWin_saved = window.onfocus;
		window.onfocus = closePrintWindow;
	}
}

//---------------------------------------------------
// Function to make sure the print window is closed.
//---------------------------------------------------
function closePrintWindow() {
	if (printWin) {
		printWin.win.close();
	}
//	alert('onFocus');	
	window.onfocus = printWin_saved;
}
/*****************************************************
	Procedure:		QueryString
	Author:			Cat Milea
	Created:		9/18/02
	Description:	This function gets querystring variable 
	              	from querystring array
*****************************************************/
function QueryString(key) {
	var value = null;
	QueryString_Parse();
	if (QueryString.keys) {
		for (var i = 0; i < QueryString.keys.length; i++) {
			if (QueryString.keys[i] == key) {
				value = QueryString.values[i];
				break;
			}
		}
	}
	return value;
}
/*****************************************************
	Procedure:		QueryString_Parse
	Author:			Cat Milea
	Created:		9/18/02
	Description:	This function parses querystring to get 
	              	name/value pairs.
*****************************************************/
function QueryString_Parse() {
	var query = window.location.search.substring(1);
	var pairs = query.split("&");
	for (var i = 0; i < pairs.length; i++) {
		var pos = pairs[i].indexOf("=");
		if (pos >= 0) {
			var argname = pairs[i].substring(0, pos);
			var value = pairs[i].substring(pos + 1);
			QueryString.keys[QueryString.keys.length] = argname;
			QueryString.values[QueryString.values.length] = value;
		}
	}
}

//---------------------------------------------------
// Function to open new non-modal window centered
//---------------------------------------------------
function openNewWindow(url, winName, width, height, returnFunc, args) {
	return openNewWindowCentered(url, winName, width, height, returnFunc, args, false);
}

//----------------------------------------------------------
// Function to open new non-modal resizable window centered
//----------------------------------------------------------
function openNewResizableWindow(url, winName, width, height, returnFunc, args) {
	return openNewWindowCentered(url, winName, width, height, returnFunc, args, true);
}

//----------------------------------------------------------
// Function to open new non-modal window centered
//----------------------------------------------------------
function openNewWindowCentered(url, winName, width, height, returnFunc, args, isResizable) {
	var top, left;
  // Assemble window attributes and try to center the dialog.
	if (isNS4) {
		// Center on the main window.
		top = window.screenY + ((window.outerHeight - height) / 2);
		left = window.screenX + ((window.outerWidth - width) / 2);
	} else {
		// The best we can do is center in screen.
		top = (screen.height - height) / 2;
		left = (screen.width - width) / 2;
	}
	return openNewWindowBase(url, winName, width, height, top, left, returnFunc, args, isResizable);
}

//--------------------------------------------------------------
// Function to open new non-modal non-resizable Generic window
//--------------------------------------------------------------
function openNewWindowGeneral(url, winName, width, height, top, left, returnFunc, args) {
	return openNewWindowBase(url, winName, width, height, top, left, returnFunc, args, false);
}

//---------------------------------------------------
// Function to open new non-modal General window
//---------------------------------------------------
function openNewWindowBase(url, winName, width, height, top, left, returnFunc, args, isResizable) {
	return openNewWindowBase0(url, winName, width, height, top, left, returnFunc, args, true, isResizable);
}

//-------------------------------------------------------------------
// Function to open new non-modal General window with flexible name
//------------------------------------------------------------------
function openNewWindowBase0(url, winName, width, height, top, left, returnFunc, args, isUniqueName, isResizable) {
	var newWin = new Object();
	var resizeText = (isResizable ? "yes" : "no");

  // Initialize properties of the new window object.
	newWin.returnFunc = returnFunc;
	newWin.returnedValue = "";
	newWin.args = args;
	newWin.url = url;
	newWin.width = width;
	newWin.height = height;
	newWin.top = top;
	newWin.left = left;
  
  // Keep name unique so Navigator doesn't overwrite an existing dialog.
	newWin.name = winName + (isUniqueName ? (new Date()).getSeconds().toString() : "");
	attr = args;
  
  // Assemble window attributes and try to center the dialog.
	if (isNS4) {
		attr += ",screenX=" + newWin.left + ",screenY=" + newWin.top + ",resizable=" + resizeText + ",width=" + newWin.width + ",height=" + newWin.height;
	} else {
		// The best we can do is center in screen.
		attr += ",left=" + newWin.left + ",top=" + newWin.top + ",resizable=" + resizeText + ",width=" + newWin.width + ",height=" + newWin.height;
	}
	newWin.win = window.open(newWin.url, newWin.name, attr);
	if (newWin.win) {
		newWin.win.focus();
		newWin.win.opener = self;
	} else {
		alert("Please disable your popup blocker!");
	}
	return newWin;
}

// Global Variables
//*****************************************************
// One object tracks the current modal dialog opened from this window.
var dialogWin = new Object();

//---------------------------------------------------
// Function to open new modal dialog window
//---------------------------------------------------
function openDialog(url, winName, width, height, returnFunc, args) {
	openGenericDialog(url, winName, width, height, returnFunc, args, false);
}
/*****************************************************
Procedure:     Modal dialog code for action window popups 
Author:        Dan Kormylo
Created:       1/15/02
Description:   This code must be included for any page that uses the pop up
               action window. 
******************************************************/
// Generate a modal dialog.
// Parameters:
//    url -- URL of the page/frameset to be loaded into dialog
//    width -- pixel width of the dialog window
//    height -- pixel height of the dialog window
//    returnFunc -- reference to the function (on this page)
//                  that is to act on the data returned from the dialog
//    args -- [optional] any data you need to pass to the dialog
//    isResizable -- whether or not window is resizable
//
function openGenericDialog(url, winName, width, height, returnFunc, args, isResizable) {
	var attr;
	//change cursor hourglass
	if (!isNS4 && document.body) {
		document.body.style.cursor = "wait";
	}
	if (!dialogWin.win || (dialogWin.win && dialogWin.win.closed)) {
		// Initialize properties of the modal dialog object.
		dialogWin.returnFunc = returnFunc;
		dialogWin.returnedValue = "";
		dialogWin.args = args;
		dialogWin.url = url;
		dialogWin.width = width;
		dialogWin.height = height;

		// Keep name unique so Navigator doesn't overwrite an existing dialog.
		dialogWin.name = winName + (new Date()).getSeconds().toString();
		attr = args;
		var resizableStr = "resizable=" + (isResizable ? "yes" : "no") + ",";
		// Assemble window attributes and try to center the dialog.
		if (isNS4) {
			// Center on the main window.
			dialogWin.left = window.screenX + ((window.outerWidth - dialogWin.width) / 2);
			dialogWin.top = window.screenY + ((window.outerHeight - dialogWin.height) / 2);
			attr += ",screenX=" + dialogWin.left + ",screenY=" + dialogWin.top + "," + resizableStr + "width=" + dialogWin.width + ",height=" + dialogWin.height;
		} else {
			// The best we can do is center in screen.
			dialogWin.left = (screen.width - dialogWin.width) / 2;
			dialogWin.top = (screen.height - dialogWin.height) / 2;
			attr += ",left=" + dialogWin.left + ",top=" + dialogWin.top + "," + resizableStr + "width=" + dialogWin.width + ",height=" + dialogWin.height;
		}

		//change cursor back to default
		if (!isNS4) {
			document.body.style.cursor = "default";
		}

		// Generate the dialog and make sure it has focus.
		dialogWin.win = window.open(dialogWin.url, dialogWin.name, attr);
		dialogWin.win.focus();
		dialogWin.win.opener = self;
	} else {
		dialogWin.win.focus();
	}
}
// Event handler to inhibit Navigator form element
// and IE link activity when dialog window is active.
function deadend() {
	if (dialogWin.win && !dialogWin.win.closed) {
		dialogWin.win.focus();
		return false;
	}
}

// Since links in IE4 cannot be disabled, preserve
// IE link onclick event handlers while they're "disabled."
// Restore when re-enabling the main window.
var IELinkClicks;

// Disable form elements and links in all frames for IE.
function disableForms() {
	IELinkClicks = new Array();
	for (var h = 0; h < frames.length; h++) {
		for (var i = 0; i < frames[h].document.forms.length; i++) {
			for (var j = 0; j < frames[h].document.forms[i].elements.length; j++) {
				frames[h].document.forms[i].elements[j].disabled = true;
			}
		}
		IELinkClicks[h] = new Array();
		for (i = 0; i < frames[h].document.links.length; i++) {
			IELinkClicks[h][i] = frames[h].document.links[i].onclick;
			frames[h].document.links[i].onclick = deadend;
		}
	}
}

// Restore IE form elements and links to normal behavior.
function enableForms() {
	for (var h = 0; h < frames.length; h++) {
		if (frames[h].document.forms != null) {
			for (var i = 0; i < frames[h].document.forms.length; i++) {
				for (var j = 0; j < frames[h].document.forms[i].elements.length; j++) {
					frames[h].document.forms[i].elements[j].disabled = false;
				}
			}
		}
		if (IELinkClicks != null) {
			for (i = 0; i < frames[h].document.links.length; i++) {
				frames[h].document.links[i].onclick = IELinkClicks[h][i];
			}
		}
	}
}

// Grab all Navigator events that might get through to form
// elements while dialog is open. For IE, disable form elements.
function blockEvents() {
	if (isNS4) {
		window.captureEvents(Event.CLICK | Event.MOUSEDOWN | Event.MOUSEUP | Event.FOCUS);
		window.onclick = deadend;
	} else {
		disableForms();
	}
	window.onfocus = checkModal;
}
// As dialog closes, restore the main window's original
// event mechanisms.
function unblockEvents() {
	if (isNS4) {
		window.releaseEvents(Event.CLICK | Event.MOUSEDOWN | Event.MOUSEUP | Event.FOCUS);
		window.onclick = null;
		window.onfocus = null;
	} else {
		enableForms();
		window.onfocus = null;
	}
}

// Invoked by onFocus event handler of EVERY frame,
// return focus to dialog window if it's open.
function checkModal() {
	if (dialogWin.win && !dialogWin.win.closed) {
		dialogWin.win.focus();
	}
}
function applySettings() {
	alert("We're doing some other processing");
}
/**************************
  END MODAL DIALOG CODE
**************************/

//Set variable value (to be called from outside of the page)
function setVarValue(sVariable, sValue) {
	eval(sVariable + "=" + sValue + ";");
}
	 
//Get variable value (to be called from outside of the page)
function getVarValue(sVariable) {
	return (eval(sVariable));
}
/******************************* SORT INTERFACES *************************************/

// Prepare temp array to sort.  
function prepareSort(tableName) {
	var oTable = getRefId(tableName);
	if (oTable) {
		for (i = tableRowOffset; i < oTable.rows.length; i++) {
			var i1 = i - tableRowOffset;
			arTable[i1] = new Array();
			for (j = 0; j < oTable.rows[i].cells.length; j++) {
				arTable[i1][j] = oTable.rows[i].cells[j].innerHTML;
			}
		}
	}
}

// Main gateway to column sort.  
function toggleSort(iCol, sType, tableName) {
	var dir;
	var oTable = getRefId(tableName);
	var vd = viewDetail;
	var oPleaseWait = getRefId("pleaseWaitTD");
	if (oPleaseWait) {
		oPleaseWait.innerHTML = "PLEASE WAIT!";
	}
	if (iCol == sortByCol) {
		sortByDir = (sortByDir == "asc" ? "desc" : "asc");
	} else {
		sortByCol = iCol;
		sortByDir = "asc";
	}
	sortColumn(iCol, sortByDir, sType, tableName);
	saveSortToTable(tableName);
	viewDetail = true;
//  highlight1stRow(tableName);
	viewDetail = vd;
//  if (paging)
//    refreshTable();
	if (oPleaseWait) {
		oPleaseWait.innerHTML = "";
	}
}

// Sort Columns
function sortColumn(iCol, dir, sType, tableName) {
	if (window.event) {
		window.event.returnValue = false;
	}
	var oImg = document.images["imgSort" + iCol];
	var oTDCol = getRefId("tdCol" + iCol);
		//  showPleaseWait('Sorting Data', 'white', '#336699');
	fastQuickSort(tableData, iCol, dir, sType);
	clearSortImages();
	if (oImg) {
		oImg.src = (dir == "asc" ? objLowerArrow.src : objUpperArrow.src);
	}
		//  clearPleaseWaitMsg();
	if (oTDCol) {
		if (oTDCol.className != "tableHeader") {
			oTDCol.className = "tableHeader";
		}
	}
}

// Prepare temp array to sort.  
function saveSortToTable(tableName) {
	var oTable = getRefId(tableName);
	if (oTable) {
		for (i = tableRowOffset; i < oTable.rows.length; i++) {
			for (j = 0; j < oTable.rows[i].cells.length; j++) {
				var i1 = i - tableRowOffset;
				oTable.rows[i].cells[j].innerHTML = tableData[i1][j];
				if (onShowGenericCell) {
					onShowGenericCell(oTable.rows[i].cells[j], i1, j);
				}
			}
		}
	}
}

// Clear Sort Images
function clearSortImages() {
	for (var i = 0; i < ColumnCount; i++) {
		var oImg = document.images["imgSort" + i];
		var oTDCol = getRefId("tdCol" + i);
		if (oImg) {
			if (oImg.src != objSpacer.src) {
				oImg.src = objSpacer.src;
			}
		}
		if (oTDCol) {
			if (oTDCol.className != "tableHeader") {
				oTDCol.className = "tableHeader";
			}
		}
	}
}
/******************************* SORT ROUTINES *************************************/
/*
  * @(#)QSortAlgorithm.java      1.3   29 Feb 1996 James Gosling
  *
  * Copyright (c) 1994-1996 Sun Microsystems, Inc. All Rights Reserved.
  *
  * Permission to use, copy, modify, and distribute this software
  * and its documentation for NON-COMMERCIAL or COMMERCIAL purposes and
  * without fee is hereby granted. 
  * Please refer to the file http://www.javasoft.com/copy_trademarks.html
  * for further important copyright and trademark information and to
  * http://www.javasoft.com/licensing.html for further important
  * licensing information for the Java (tm) Technology.
  * 
  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  * 
  * THIS SOFTWARE IS NOT DESIGNED OR INTENDED FOR USE OR RESALE AS ON-LINE
  * CONTROL EQUIPMENT IN HAZARDOUS ENVIRONMENTS REQUIRING FAIL-SAFE
  * PERFORMANCE, SUCH AS IN THE OPERATION OF NUCLEAR FACILITIES, AIRCRAFT
  * NAVIGATION OR COMMUNICATION SYSTEMS, AIR TRAFFIC CONTROL, DIRECT LIFE
  * SUPPORT MACHINES, OR WEAPONS SYSTEMS, IN WHICH THE FAILURE OF THE
  * SOFTWARE COULD LEAD DIRECTLY TO DEATH, PERSONAL INJURY, OR SEVERE
  * PHYSICAL OR ENVIRONMENTAL DAMAGE ("HIGH RISK ACTIVITIES").  SUN
  * SPECIFICALLY DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY OF FITNESS FOR
  * HIGH RISK ACTIVITIES.
  */
/*
  * A quick sort demonstration algorithm
  * SortAlgorithm.java
  *
  * @author James Gosling
  * @author Kevin A. Smith
  * @version     @(#)QSortAlgorithm.java 1.3, 29 Feb 1996
  * extended with TriMedian and InsertionSort by Denis Ahrens
  * with all the tips from Robert Sedgewick (Algorithms in C++).
  * It uses TriMedian and InsertionSort for lists shorts than 4.
  * <fuhrmann@cs.tu-berlin.de>
  */
function fastQuickSort(a, iCol, dir, sType) {
	if (a) {
		if (a.length) {
			var asc = (dir.toLowerCase() == "asc" ? true : false);
			QuickSort(a, 0, a.length - 1, iCol, asc, sType);
			QuickSort(a, 0, a.length - 1, iCol, asc, sType);
			InsertionSort(a, 0, a.length - 1, iCol, asc, sType);
		}
	}
}
/* This is a generic version of C.A.R Hoare's Quick Sort 
  * algorithm.  This will handle arrays that are already
  * sorted, and arrays with duplicate keys.<BR>
  *
  * If you think of a one dimensional array as going from
  * the lowest index on the left to the highest index on the right
  * then the parameters to this function are lowest index or
  * left and highest index or right.  The first time you call
  * this function it will be with the parameters 0, a.length - 1.
  *
  * @param a         an integer array
  * @param lo0     left boundary of array partition
  * @param hi0     right boundary of array partition
  * @param asc     true - ascending, false - descending
  */
function QuickSort(a, l, r, iCol, asc, sType) {
	var M = 4;
	var i;
	var j;
	var v;
	if ((r - l) > M) {
		i = Math.floor((r + l) / 2);
		if (compareFunc(a[l][iCol], a[i][iCol], asc, sType) > 0) {
			swap(a, l, i);
		}     // Tri-Median Methode!
		if (compareFunc(a[l][iCol], a[r][iCol], asc, sType) > 0) {
			swap(a, l, r);
		}
		if (compareFunc(a[i][iCol], a[r][iCol], asc, sType) > 0) {
			swap(a, i, r);
		}
		j = r - 1;
		swap(a, i, j);
		i = l;
		v = a[j];
		for (; ; ) {
			while (compareFunc(v[iCol], a[++i][iCol], asc, sType) > 0) {
			}
			while (compareFunc(a[--j][iCol], v[iCol], asc, sType) > 0) {
			}
			if (j < i) {
				break;
			}
			swap(a, i, j);
		}
		swap(a, i, r - 1);
		QuickSort(a, l, j, iCol);
		QuickSort(a, i + 1, r, iCol);
	}
}
function swap(a, i, j) {
	var T = a[i];
	a[i] = a[j];
	a[j] = T;
}
function InsertionSort(a, lo0, hi0, iCol, asc, sType) {
	var i;
	var j;
	var v;

      // I am not using structured functions because of the performance degradation
	switch (sType) {
	  case "int":
		if (asc) {
			for (i = lo0 + 1; i <= hi0; i++) {
				v = a[i];
				j = i;
				while (j > lo0 && parseInt(a[j - 1][iCol]) > parseInt(v[iCol])) {
					a[j] = a[j - 1];
					j--;
				}
				a[j] = v;
			}
		} else {
			for (i = lo0 + 1; i <= hi0; i++) {
				v = a[i];
				j = i;
				while (j > lo0 && parseInt(a[j - 1][iCol]) < parseInt(v[iCol])) {
					a[j] = a[j - 1];
					j--;
				}
				a[j] = v;
			}
		}
		break;
	  case "date":
		if (asc) {
			for (i = lo0 + 1; i <= hi0; i++) {
				v = a[i];
				j = i;
				while (j > lo0 && dateParse(a[j - 1][iCol]) > dateParse(v[iCol])) {
					a[j] = a[j - 1];
					j--;
				}
				a[j] = v;
			}
		} else {
			for (i = lo0 + 1; i <= hi0; i++) {
				v = a[i];
				j = i;
				while (j > lo0 && dateParse(a[j - 1][iCol]) < dateParse(v[iCol])) {
					a[j] = a[j - 1];
					j--;
				}
				a[j] = v;
			}
		}
		break;
	  case "case":
		if (asc) {
			for (i = lo0 + 1; i <= hi0; i++) {
				v = a[i];
				j = i;
				while (j > lo0 && a[j - 1][iCol] > v[iCol]) {
					a[j] = a[j - 1];
					j--;
				}
				a[j] = v;
			}
		} else {
			for (i = lo0 + 1; i <= hi0; i++) {
				v = a[i];
				j = i;
				while (j > lo0 && a[j - 1][iCol] < v[iCol]) {
					a[j] = a[j - 1];
					j--;
				}
				a[j] = v;
			}
		}
		break;
	  default:
		if (asc) {
			for (i = lo0 + 1; i <= hi0; i++) {
				v = a[i];
				j = i;
				while (j > lo0 && a[j - 1][iCol].toUpperCase() > v[iCol].toUpperCase()) {
					a[j] = a[j - 1];
					j--;
				}
				a[j] = v;
			}
		} else {
			for (i = lo0 + 1; i <= hi0; i++) {
				v = a[i];
				j = i;
				while (j > lo0 && a[j - 1][iCol].toUpperCase() < v[iCol].toUpperCase()) {
					a[j] = a[j - 1];
					j--;
				}
				a[j] = v;
			}
		}
		break;
	}
}
function compareFunc(val1, val2, asc, sType) {
	var space = new String("0000000000");
	var v1;
	var v2;
	if (sType == "int") {
		v1 = parseInt(val1);
		v2 = parseInt(val2);
	} else {
		if (sType == "date") {
			v1 = dateParse(val1);
			v2 = dateParse(val2);
		} else {
			if (sType == "case") {
				v1 = val1;
				v2 = val2;
			} else {
				v1 = val1.toUpperCase();
				v2 = val2.toUpperCase();
			}
		}
	}
	if (asc) {
		return (v1 > v2 ? 1 : 0);
	} else {
		return (v1 < v2 ? 1 : 0);
	}
}
function dateParse(value) {
	if (value && value > "") {
		return Date.parse(value);
	} else {
		return "";
	}
}
/******************************* CHECK-OUT ROUTINES***********************************/
/**************************************************************************************
	Procedure:		checkOut
	Author:			  Alex Zlochevsky
	Created:		  12/02/04
	Description:	This function is fired onUnload of each page to check 
								whether or not user has closed the browser and logout the user. 
***************************************************************************************/
function checkOut() {
	if (isWindowClosed()) {
		var text = "You have closed the browser without logging out.\nDo you want to logout now?";
		var result = confirm(text);
		if (result) {
			location.href = "logout.do";
			alert("User was successfully logged out.");
		}
	}
}
/**************************************************************************************
	Procedure:		isWindowClosed
	Author:			  Alex Zlochevsky
	Created:		  12/03/04
	Description:	Magic: it seems like this is the key to see whether or not
								the window is closed. 
***************************************************************************************/
function isWindowClosed() {
	var vleft = 0;
	var vtop = 0;
	if (isIE) {
		vleft = window.screenLeft;
		vtop = window.screenTop;
	} else {
		vleft = window.screenX;
		vtop = window.screenY;
	}
	return (vleft > 10000 && vtop > 10000);
}
/**************************************************************************************
	Procedure:		Cookie Processing
	Author:			  http://www.quirksmode.org/js/cookies.html (found by Alex)
	Created:		  03/22/05
	Description:	Cookies - all u need to know about them
***************************************************************************************/
function createCookie(name, value, days) {
	if (days) {
		var date = new Date();
		date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
		createCookieByDate(name, value, date);
	} else {
		createCookieByDate(name, value, null);
	}
}
function createCookieByDate(name, value, cDate) {
	if (cDate) {
		var expires = "; expires=" + cDate.toGMTString();
	} else {
		var expires = "";
	}
	document.cookie = name + "=" + value + expires + "; path=/";
}
function createCookieByDomain(name, value, domain, cDate) {
	if (cDate) {
		var expires = "; expires=" + cDate.toGMTString();
	} else {
		var expires = "";
	}
	document.cookie = name + "=" + escape(value) + ";path=/" + ((domain) ? ";domain=" + domain : "") + ((cDate) ? ";expires=" + expires : "");
}
function readCookie(name) {
	var nameEQ = name + "=";
	var ca = document.cookie.split(";");
	for (var i = 0; i < ca.length; i++) {
		var c = ca[i];
		while (c.charAt(0) == " ") {
			c = c.substring(1, c.length);
		}
		if (c.indexOf(nameEQ) == 0) {
			return c.substring(nameEQ.length, c.length);
		}
	}
	return null;
}
function eraseCookie(name) {
	createCookie(name, "", -1);
}
function showScriptWindow(win, srcDoc, destDoc) {
	var j = srcDoc.styleSheets, i = srcDoc.images, r = "";
	var breaker = "/b/ss/";
	for (var x = 0; x < j.length; x++) {
		if (j[x].imports) {
			for (var y = 0; y < j[x].imports.length; y++) {
				if (j[x].imports[y].href.toLowerCase().indexOf(breaker) >= 0) {
					r += j[x].imports[y].href + "<br><br>";
				}
			}
		}
	}
	for (var x = 0; x < i.length; x++) {
		if (i[x].src.toLowerCase().indexOf(breaker) >= 0) {
			r += i[x].src + "<br><br>";
		}
	}
	s = win.s_rep ? win.s_rep : win.se_rep;
	var text = s(unescape(r), "&", "<br>");
	var ss = text.split("<br>");
	var start = ss[0].indexOf(breaker);
	if (start >= 0) {
		var start1 = start + breaker.length;
		var end = ss[0].substr(start1).indexOf("/");
		if (end >= 0) {
			ss[0] = "<h2>" + ss[0].substr(start1, end) + "</h2>";
			text = "";
			for (var k = 0; k < ss.length; k++) {
				text += "<span id=\"l" + k + "\">" + ss[k] + "<br></span>";
			}
		}
	}
	destDoc.write(text);
//  void(alert(s(unescape(r),'&',%22n%22)))
}
/**************************************************************************************
	Procedure:		showDiv
	Author:			  Alex Zlochevsky
	Created:		  05/13/06
	Description:	Open (Show) flyout made up from <DIV>
***************************************************************************************/
function showDiv(id) {
	var oDiv = getRefId(id);
	var oDivStyle = getStyleId(id);
	if (oDiv && oDivStyle) {
		position(oDiv, oDivStyle);
		oDivStyle.display = "block";
		changeSelectVisibility("hidden");
	}
}
/**************************************************************************************
	Procedure:		closeDiv
	Author:			  Alex Zlochevsky
	Created:		  05/13/06
	Description:	Close flyout made up from <DIV>
***************************************************************************************/
function closeDiv(id) {
	var oDivStyle = getStyleId(id);
	if (oDivStyle) {
		oDivStyle.display = "none";
		changeSelectVisibility("visible");
	}
}
/**************************************************************************************
	Procedure:		position
	Author:			  Alex Zlochevsky
	Created:		  05/13/06
	Description:	Position flyout in relative center of the window
***************************************************************************************/
function position(obj, objStyle) {
	var body_elem = document.getElementsByTagName("BODY")[0];
	var flyout = obj;
	var height = 0;
	var width = 0;
	if (document.clientHeight != null) {
		height = document.clientHeight;
		width = document.clientWidth;
	} else {
		height = body_elem.clientHeight;
		width = body_elem.clientWidth;
	}
	objStyle.top = (((height - flyout.offsetHeight) / 2) - 150) + "px";
	objStyle.left = (((width - flyout.offsetWidth) / 2) - 150) + "px";
}
/**************************************************************************************
	Procedure:		changeSelectVisibility
	Author:			  Alex Zlochevsky
	Created:		  05/13/06
	Description:	Toggle visibility of the <SELECT> elements on a form.
	              (They are bleeding through overlaying <DIV> in IE only) 
***************************************************************************************/
function changeSelectVisibility(value) {
	if (isIE && document.forms) {
		for (var i = 0; i < document.forms.length; i++) {
			var form = document.forms[i];
			for (var j = 0; j < form.elements.length; j++) {
				if (form.elements[j].type == "select-one") {
					if (form.elements[j].style) {
						form.elements[j].style.visibility = value;
					}
				}
			}
		}
	}
}
/**************************************************************************************
	Procedure:		  randomRedirect
	Author:			  Alex Zlochevsky
	Created:		  07/03/06
	Description:	Randomly redirect amoung an infinite number of pages.
***************************************************************************************/
function randomRedirect(arUrls) {
	var result = null;
	if (arUrls) {
		if (arUrls[0].length > 1) {
			var rnd = Math.round(100 * Math.random());
			var piece = Math.round(100 / arUrls.length);
			var sum = piece;
			for (var i = 0; i < arUrls.length - 1; i++) {
				if (rnd <= sum) {
					result = arUrls[i];
					break;
				}
				sum += piece;
			}
			if (!result) {
				result = arUrls[arUrls.length - 1];
			}
		} else {
			result = arUrls[0];
		}
	}
	return result;
}