// Basic element functions

var strTimeout = "Your connection has timed out.  Press refresh the page and log on again";
var strSync = "Your browser session is out of sync with the server.  Press refresh and try again.";

var blnBrowserHandled = false;
var strBrowserName = "";
var strBrowserVersion = "";

function findBrowser() {

	try {
		if (strBrowserName == "") {

			// Start with the default
			navigator.appName
			navigator.appVersion
			
			// Now with the oddities
			if (/Firefox[\/\s](\d+\.\d+)/.test(navigator.userAgent)) { //test for Firefox/x.x or Firefox x.x (ignoring remaining digits);
				strBrowserName = "Firefox";
				strBrowserVersion = new Number(RegExp.$1) // capture x.x portion and store as a number
				blnBrowserHandled = true;
			}
				
			else if (/MSIE (\d+\.\d+);/.test(navigator.userAgent)) { //test for MSIE x.x;
				strBrowserName = "MSIE";
				strBrowserVersion = new Number(RegExp.$1) // capture x.x portion and store as a number
				blnBrowserHandled = true;
			}
				
			//Note: userAgent in Opera9.24 WinXP returns: Opera/9.24 (Windows NT 5.1; U; en)
			//         userAgent in Opera 8.5 (identified as IE) returns: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1) Opera 8.50 [en]
			//         userAgent in Opera 8.5 (identified as Opera) returns: Opera/8.50 (Windows NT 5.1; U) [en]

			else if (/Opera[\/\s](\d+\.\d+)/.test(navigator.userAgent)) {  //test for Opera/x.x or Opera x.x (ignoring remaining decimal places);
				strBrowserName = "Opera";
				strBrowserVersion = new Number(RegExp.$1) // capture x.x portion and store as a number
				blnBrowserHandled = false;
			}
			
			else if (/(\d+\.\d+).\d+\sSafari/.test(navigator.userAgent)) {  //test for Opera/x.x or Opera x.x (ignoring remaining decimal places);
				strBrowserName = "Safari";
				strBrowserVersion = new Number(RegExp.$1) // capture x.x.x portion and store as a number
				blnBrowserHandled = true;
			}
			
			else {
			}
		}
		return (strBrowserName);
	}
	catch(e) {
		logErr("findBrowser", e)
		throw e;
	}
}

function browserHandled() {
	try {
		if (strBrowserName != "")
			return (blnBrowserHandled)
		else
			return findBrowser();
	}
	catch(e) {
		logErr("browserHandled", e)
		throw e;
	}
}

function browserName() {
	try {
		if (strBrowserName != "")
			return (strBrowserName)
		else {
			findBrowser()
			return (strBrowserName)
		}
	}
	catch(e) {
		logErr("browserName", e)
		throw e;
	}
}

function elementById(strItem) {
	try {
		var objItem = document.getElementById(strItem);
		if (objItem == null)
			throw strItem + " not found in dom";
		else
			return(objItem);
	}
	catch(e) {
		logErr("elementById", e)
		throw e;
	}
}

function elementsByName(strItem) {
	try {
		var objItem = document.getElementsByName(strItem);
		if (objItem == null)
			throw strItem + " not found in dom";
		else
			return(objItem);
	}
	catch(e) {
		logErr("elementsByName", e)
		throw e;
	}
}

function elementByIdIfExists(strItem) {
	try {
		return(document.getElementById(strItem));
	}
	catch(e) {
		logErr("elementByIdIfExists", e)
		throw e;
	}
}

function hide(objItem) {
	try {
	
		switch (browserName()) {
		
			case "Firefox":
				objItem.style.display = "none";
				break;

			case "MSIE":
				objItem.style.display="none";
				objItem.style.visibility="hidden";
				break;

			case "Safari":
				objItem.style.display = "none";
				break;

		}
		return true;

	}
	catch(e) {
		logErrAndObj("hide", objItem, e)
		throw e;
	}
}

// This function is used by infoOut so that the div doesn't end up with a width of 0
function hideNoShrink(objItem) {
	try {
	
		switch (browserName()) {
		
			case "Firefox":
				objItem.style.visibility="hidden";
				break;

			case "MSIE":
				objItem.style.display="none";
				objItem.style.visibility="hidden";
				break;

			case "Safari":
				objItem.style.visibility="hidden";
				break;

		}
		return true;

	}
	catch(e) {
		logErrAndObj("hide", objItem, e)
		throw e;
	}
}

function hideIfExists(objItem) {
	try {
		if (objItem != null) {
			hide(objItem)
		}
	}
	catch(e) {
		logErrAndObj("hideIfExists", objItem, e)
		throw e;
	}
}

function show(objItem) {
	try {
	
		switch (browserName()) {
		
			case "Firefox":
				objItem.style.display="";
				objItem.style.visibility = "visible";
				/* objItem.style.visibility = "visible";
				objItem.style.display = "block"; */
				break;

			case "MSIE":
				objItem.style.display="";
				objItem.style.visibility = "visible";
				break;

			case "Safari":
				objItem.style.display="";
				objItem.style.visibility = "visible";
				/* objItem.style.visibility = "visible";
				objItem.style.display = "block"; */
				break;

		}

	
		return true;
	}
	catch(e) {
		logErrAndObj("show", objItem, e)
		throw e;
	}
}

function showIfExists(objItem) {
	try {
		if (objItem != null) {
			return (show(objItem));
		}
	}
	catch(e) {
		logErrAndObj("showIfExists", objItem, e)
		throw e;
	}
}

function isVisible(objItem) {
	try {
		if (objItem != null) {
			if (objItem.style.display != "none" &&
					objItem.style.visibility != "hidden")
				return (true)
			else
				return (false);
		}
		else
			return (false);
	}
	catch(e) {
		logErrAndObj("isVisible", objItem, e)
		throw e;
	}
}

function toggleVisibility(objItem) {
	try {
		if (objItem.style.display == "")
			hide(objItem)
		else
			show(objItem);
	}
	catch(e) {
		logErrAndObj("toggleVisibility", objItem, e)
		throw e;
	}
}

function width(objItem, intWidth) {
	try {
		switch (browserName()) {
		
			case "Firefox":
				objItem.style.width = intWidth + "px";
				break;

			case "MSIE":
				objItem.style.width = intWidth + "px";
				break;

			case "Safari":
				objItem.style.width = intWidth + "px";
				break;

		}
		return true;
	}
	catch(e) {
		logErrAndObj("width", objItem, e)
		throw e;
	}
}

function height(objItem, intHeight) {
	try {
		switch (browserName()) {
		
			case "Firefox":
				objItem.style.height = intHeight + "px";
				break;

			case "MSIE":
				objItem.style.height = intHeight + "px";
				break;

			case "Safari":
				objItem.style.height = intHeight + "px";
				break;

		}
		return true;

	}
	catch(e) {
		logErrAndObj("height", objItem, e)
		throw e;
	}
}

function enable(objItem) {
	try {
		objItem.disabled=false;
	}
	catch(e) {
		logErrAndObj("enable", objItem, e)
		throw e;
	}
}

function disable(objItem) {
	try {
		objItem.disabled=true;
	}
	catch(e) {
		logErrAndObj("disable", objItem, e)
		throw e;
	}
}

function setTitle(objItem, strValue) {
	try {
		objItem.title = strValue;
	}
	catch(e) {
		logErrAndObj("setTitle", objItem, e)
		throw e;
	}
}

function setInnerHtml(objItem, strValue) {
	try {
		objItem.innerHTML = strValue;
	}
	catch(e) {
		logErrAndObj("setInnerHtml", objItem, e)
		throw e;
	}
}

function isSelected(objItem) {
	try {
		return(objItem.checked);
	}
	catch(e) {
		logErrAndObj("isSelected", objItem, e)
		throw e;
	}
}

function selectCheckbox(nodCheckbox) {
	try {
		nodCheckbox.checked = true;
	}
	catch(e) {
		logErrAndObj("selectCheckbox", nodCheckbox, e)
		throw e;
	}
}

function unselectCheckbox(nodCheckbox) {
	try {
		nodCheckbox.checked = false;
	}
	catch(e) {
		logErrAndObj("unselectCheckbox", nodCheckbox, e)
		throw e;
	}
}

function getType(item) {

	try {
		return document.all("QT_" + item).value
	}
	catch(e) {
		logErr("getType: "  + item, e)
	}
}

function getValue(objItem) {
	try {
		return(objItem.value);
	}
	catch(e) {
		logErrAndObj("getValue", objItem, e)
		throw e;
	}
}

function setValue(objItem, strValue) {
	try {
		objItem.value = strValue;
	}
	catch(e) {
		logErrAndObj("setValue", objItem, e)
		throw e;
	}
}

function appendAction(objItem, strValue) {
	try {
		objItem.action += strValue;
	}
	catch(e) {
		logErrAndObj("appendAction", objItem, e)
		throw e;
	}
}

function appendValue(objItem, strValue) {
	try {
		objItem.value += strValue;
	}
	catch(e) {
		logErrAndObj("appendValue", objItem, e)
		throw e;
	}
}

// Multi row functions
/* function setEnabledSubItems(item, value) {
	try {
		for(i = 0; i < document.all.length; i++) {
			var strTag = new String(document.all(i).tagName)
			var strId = new String(document.all(i).id)
		if (strTag.toLowerCase() == "input") {
				if (strId.indexOf(item) == 0) {
					document.all("trace").innerHTML = document.all("trace").innerHTML + "Found" + document.all(i).innerHTML + "<br>"
					if (value = 'True')
						document.all(i).enabled = true
					else
						document.all(i).enabled = false;
				}
			}
		}
	}
	catch(e) {
		logErr("setEnabledSubItems: "  + item, e)
	}
}
*/ 
// This function disables this node and all its children and saves 
// the current disabled status in a local attribute
function disableFamilyIfExists(objItem) {
	try {
	
		if (objItem != null)
			disableFamily(objItem);

	}
	catch(e) {
		logErrAndObj("disableFamilyIfExists", objItem, e)
		throw e;
	}
}
function disableFamily(objItem) {
	try {
	
		try {
			objItem.saveDisabled = objItem.disabled;
			objItem.disabled=true;
		}
		catch(e) {
			// ignore
		}

		// Disable all our children
		var colNodes = objItem.childNodes;
		var i;
		for (i=0; i<colNodes.length; i++) {
			disableFamily(colNodes[i]);
		}

	}
	catch(e) {
		logErrAndObj("disableFamily", objItem, e)
		throw e;
	}
}

// This function enables this node and all its children based on the disabled
// status in a local attribute
function enableFamily(objItem) {
	try {
	
		try {
			if (objItem.saveDisabled == false ||
				objItem.saveDisabled == "false")
				objItem.disabled=false;
		}
		catch(e) {
			// ignore
		}

		// Enable all our children
		var colNodes = objItem.childNodes;
		var i;
		for (i=0; i<colNodes.length; i++) {
			enableFamily(colNodes[i]);
		}

	}
	catch(e) {
		logErrAndObj("enableFamily", objItem, e)
		throw e;
	}
}

function swapSortOrder(objList, intFirst, intSecond) {
	try {
		var arrList = getValue(objList).split(",");
		var intTemp = arrList[intFirst];
		arrList[intFirst] = arrList[intSecond];
		arrList[intSecond] = intTemp;
		var strList = arrList.join(",");
		setValue(objList, strList);
	}
	catch(e) {
		logErr("swapSortOrder", e)
		throw e;
	}
}

function showRow(objTable, intRow) {
	try {
		show(objTable.rows(intRow));
	}
	catch(e) {
		logErrAndObj("showRow", objTable, e)
		throw e;
	}

}

function hideRow(objTable, intRow) {
	try {
		hide(objTable.rows(intRow));
	}
	catch(e) {
		logErrAndObj("hideRow", objTable, e)
		throw e;
	}
}

function moveRowBefore(objTable, intTarget, intSource) {
	try {
		var intSourceUpTo = intSource;
		var blnMoveUp = intTarget < intSource ? true : false;
		var intMovements = Math.abs(intSource - intTarget);
		
		while (intMovements > 0) {
			if (blnMoveUp)
				swapRows(objTable, intSourceUpTo, intSourceUpTo-1)
			else
				swapRows(objTable, intSourceUpTo, intSourceUpTo+1);
			intSourceUpTo--;
			intMovements--;
		}
	}
	catch(e) {
		logErrAndObj("moveRowBefore", objTable, e)
		throw e;
	}
}

function swapRows(objTable, intRow1, intRow2) {
	try {
		objTable.rows(intRow1).swapNode(objTable.rows(intRow2));
	}
	catch(e) {
		logErrAndObj("swapRows", objTable, e)
		throw e;
	}
}

function findParentType(thisItem, strType) {
	try {
		var objItem = thisItem;
		var strItemLower = strType.toLowerCase();
		
		while (objItem.tagName.toLowerCase() != strItemLower &&
			objItem.parentElement != null)
			
			objItem = objItem.parentElement;
			
		if (objItem.parentElement != null) 
			return objItem
		else
			return null;
			
	}
	catch(e) {
		logErrAndObj("findParentType", thisItem, e)
		throw e;
	}
}


// This function finds the row that that this item is a part of.
// Note it skips any nested tables by searching for the rt attribute with a value of "q" which is defined for question rows
function findRowParent(thisItem, strType) {
	try {
		var objItem = thisItem
		while (objItem.tagName.toLowerCase() != "tr" ||
			objItem.rt != strType)
			objItem = objItem.parentElement;
		return objItem;
	}
	catch(e) {
		logErrAndObj("findRowParent", thisItem, e)
		throw e;
	}
}

function getRowNumber(objRow) {
	try {	
		return (objRow.rowIndex);
	}
	catch(e) {
		logErrAndObj("getRowNumber", objRow, e)
		throw e;
	}
}

function getRow(objTable, intRow) {
	try {	
		return (objTable.rows(intRow));
	}
	catch(e) {
		logErrAndObj("getRow", objTable, e)
		throw e;
	}
}

function getTableRowCount(objTable) {
	try {	
		return (objTable.rows.length);
	}
	catch(e) {
		logErrAndObj("getTableRowCount", objTable, e)
		throw e;
	}
}

function rowType(objTable, intRow) {
	try {	
		return (getRow(objTable, intRow).rt);
	}
	catch(e) {
		logErrAndObj("rowType", objTable, e)
		throw e;
	}
}

function getPreviousRowNumber(objTable, intRow, strType) {
	try {	
		var intCurRow = intRow--;
		while (intCurRow > 0 && rowType(objTable, intCurRow) != strType)
			intCurRow--;
		return(intCurRow);
	}
	catch(e) {
		logErrAndObj("getPreviousRowNumber", objTable, e)
		throw e;
	}
}

function getNextRowNumber(objTable, intRow, strType) {
	try {	
		var intCurRow = intRow--;
		var intMaxRow = getTableRowCount(objTable)
		while (intCurRow < intMaxRow && rowType(objTable, intCurRow) != strType)
			intCurRow++;
		if (intCurRow == intMaxRow)
			return (0)
		else
			return(intCurRow);
	}
	catch(e) {
		logErrAndObj("getNextRowNumber", objTable, e)
		throw e;
	}
}

function getLastRowNumberOfType(objTable, intRow, strType) {
	try {	
		var intCurRow = intRow;
		var intLastRow = getTableRowCount(objTable)-1;
		while (intCurRow < intLastRow && rowType(objTable, intCurRow+1) == strType)
			intCurRow++;
		return(intCurRow);
	}
	catch(e) {
		logErrAndObj("getLastRowNumberOfType", objTable, e)
		throw e;
	}
}

function getFirstRowNumberOfType(objTable, intRow, strType) {
	try {	
		var intCurRow = intRow;
		while (intCurRow > 0 && rowType(objTable, intCurRow) == strType)
			intCurRow--;
		return(intCurRow);
	}
	catch(e) {
		logErrAndObj("getFirstRowNumberOfType", objTable, e)
		throw e;
	}
}

// This function finds the sequence of the row type within the table starting at a specific row
function getTypeSequence(objTable,  strType, intStartRow, intRowItem) {
	try {	
		var intCurRow = intStartRow;
		var intSequence = 0;
		var intTableRows = getTableRowCount(objTable)
		while (intCurRow < intTableRows && intCurRow <= intRowItem) {
			if (rowType(objTable, intCurRow) == strType)
				intSequence++;
			intCurRow++;
		}
		return(intSequence);
	}
	catch(e) {
		logErrAndObj("getTypeSequence", objTable, e)
		throw e;
	}
}

function findChildIdStartingWith(nodStart, strPrefix) {
	try {	
		var strPrefixLower = strPrefix.toLowerCase();
		var colNodes = nodStart.childNodes;
		var i;
		for (i=0; i<colNodes.length; i++) {
			var nodNode = colNodes[i];
			try {
				if (nodNode.id.substring(0,strPrefix.length).toLowerCase() == strPrefixLower) {
					return nodNode;
				}
			}
			catch (e) {
			}
	
			var nodChildNode = findChildIdStartingWith(nodNode, strPrefix);
			if (nodChildNode != false) {
				return nodChildNode;
			}
		}
		return false;
	}
	catch(e) {
		logErrAndObj("findChildIdStartingWith", nodStart, e)
		throw e;
	}
}

// Mouse over menu functions

function moi(objItem) {

	try {	
		if (!("originalClass" in objItem))
			objItem.originalClass = objItem.className;
			
		objItem.className = objItem.originalClass + "_h";
		var objPageHead = elementByIdIfExists("PageHead");
		if (objPageHead != null)
			objPageHead.innerHTML = objItem.heading;
	}
	catch(e) {
		logErrAndObj("moi", objItem, e)
	}
}

function moo(objItem) {

	try {	
		objItem.className = objItem.originalClass;
		var objPageHead = elementByIdIfExists("PageHead");
		if (objPageHead != null)
			objPageHead.innerHTML = objPageHead.originalHeading;
	}
	catch(e) {
		logErrAndObj("moo", objItem, e)
	}
}

// Info callout display

function infoIn(objItem) {

	try {	
		var objCallout = elementById("callOut");
		objCallout.innerHTML = objItem.getAttribute("callout");
		var strCalloutInfo = "obj x:" + objectX(objItem) + "; obj y:" + objectY(objItem) + "; obj width:" + objectWidth(objItem) + "objCallout x:" + objectX(objCallout) + "; objCallout y:" + objectY(objCallout) + "; objCallout width:" + objectWidth(objCallout)
		locateResult(objCallout, objectX(objItem), objectY(objItem), objectWidth(objItem));		
		hideAffected(objCallout, false);
		show(objCallout);
		if (objItem.getAttribute("downSrc")) {
			objItem.setAttribute("oldSrc", objItem.getAttribute("src"));
			objItem.setAttribute("src", objItem.getAttribute("downSrc"));
		}
		return (true);
	}
	catch(e) {
		logErrAndObj("infoIn", objItem, e)
	}
}

function infoOut(objItem) {

	try {	
		var objCallout = elementById("callOut")
		// var strCalloutInfo = "obj x:" + objectX(objItem) + "; obj y:" + objectY(objItem) + "; obj width:" + objectWidth(objItem) + "objCallout x:" + objectX(objCallout) + "; objCallout y:" + objectY(objCallout) + "; objCallout width:" + objectWidth(objCallout)
		hideNoShrink(objCallout);
		// var strCalloutInfo = "obj x:" + objectX(objItem) + "; obj y:" + objectY(objItem) + "; obj width:" + objectWidth(objItem) + "objCallout x:" + objectX(objCallout) + "; objCallout y:" + objectY(objCallout) + "; objCallout width:" + objectWidth(objCallout)
		showAffected();
		if (objItem.getAttribute("downSrc")) {
			objItem.setAttribute("src", objItem.getAttribute("oldSrc"));
		}
		return (true);
	}
	catch(e) {
		logErrAndObj("infoOut", objItem, e)
	}
}

// Object moving and sizing functions
function cursorX() {
	try {	
		return (window.event.x + document.body.scrollLeft)
	}
	catch(e) {
		logErr("cursorX", e)
	}
}

function cursorY() {
	try {	
		return (window.event.y + document.body.scrollTop)
	}
	catch(e) {
		logErr("cursorY", e)
	}
}

function objectX(objItem) {
	try {	
		var intLeft = objItem.offsetLeft;
		var objParent = objItem.offsetParent;
		while (objParent) {
			intLeft += objParent.offsetLeft;
			objParent = objParent.offsetParent;
		}
		return (intLeft)
	}
	catch(e) {
		logErrAndObj("objectX", objItem, e)
	}
}

function objectY(objItem) {
	try {	
		var intTop = objItem.offsetTop;
		var objParent = objItem.offsetParent;
		while (objParent) {
			intTop += objParent.offsetTop;
			objParent = objParent.offsetParent;
		}
		return (intTop)
	}
	catch(e) {
		logErrAndObj("objectY", objItem, e)
	}
}

function objectWidth(objItem) {
	try {	
		return (objItem.offsetWidth)
	}
	catch(e) {
		logErrAndObj("objectWidth", objItem, e)
	}
}

function objectHeight(objItem) {
	try {	
		return (objItem.offsetHeight)
	}
	catch(e) {
		logErrAndObj("objectHeight", objItem, e)
	}
}

function shiftTo(objItem, x, y) {
	try {
	
		switch (browserName()) {
		
			case "Firefox":
				objItem.style.left = x;
				objItem.style.top = y;
				break;

			case "MSIE":
				objItem.style.posLeft = x;
				objItem.style.posTop = y;
				break;

			case "Safari":
				objItem.style.left = x;
				objItem.style.top = y;
				break;

		}
		
		return (true)
	
	}
	catch(e) {
		logErrAndObj("shiftTo", objItem, e)
	}
}

function locateResult(objItem, x, y, iconWidth) {

	try {
		var newX, newY
		
		// Calculate and set the width of the object to make it square
		var newWidth = Math.ceil(Math.sqrt(objItem.clientWidth * objItem.clientHeight));
//		if (newWidth==0) {
//			newWidth = Math.ceil(Math.sqrt(objItem.innerHTML.length * 5))
//			width(objItem, newWidth);
//			height(objItem, newWidth);
//		}
//		else {
			width(objItem, newWidth);
			//objItem.style.width = newWidth;

			// Do it again as extreme values can result in an undesireable result
			var newWidth = Math.ceil(Math.sqrt(objItem.clientWidth * objItem.clientHeight));
			width(objItem, newWidth);
			// objItem.style.width = newWidth;
//		}

		// Is it too wide to fit to the right
		if (x + iconWidth + objectWidth(objItem) + 2 - document.body.scrollLeft > document.body.clientWidth) {
		
			// Will it fit on the left
			if (x > iconWidth + objectWidth(objItem) + 2)
				newX = x - (iconWidth + objectWidth(objItem)) + 2
			else { // Try and make it narower
				newX = x + 2;
				newWidth =  document.body.scrollWidth - objectX(objItem) - 2;
				width(objItem, newWidth);
				// objItem.style.width = newWidth;
			}
		}
		else
			newX = x + iconWidth;
			
		// Is it too far down move up
		if (y + objectHeight(objItem) - document.body.scrollTop > document.body.clientHeight) {
		
			newY = y - objectHeight(objItem);
			if (newY < document.body.scrollTop)
				newY = document.body.scrollTop;
		}
		else
			newY = y;
			
		var strCalloutInfoCurrent = "x:" + objectX(objItem) + "; y:" + objectY(objItem) + "; width:" + objectWidth(objItem)
		var strCalloutInfoNew = "newX:" + newX + "; newY:" + newY + "; width:" + objectWidth(objItem)
		shiftTo(objItem, newX, newY);
	}
	catch(e) {
		logErrAndObj("locateResult", objItem, e)
	}
}

function locateResultWide(objItem, x, y, iconWidth) {

	try {
		var newX, newY;

		var strOldDisplay = objItem.style.display;
		var strOldVisibility = objItem.style.visibility;
		
		show(objItem);
		
		if (objItem.resize == "no") {
			newX = x;
			newY = y;
		}
		else {

			objItem.style.width = 800;
			
			var intInitialHeight = objectHeight(objItem);
			
			while (objectHeight(objItem) == intInitialHeight) {
				var intLastWidth = objectWidth(objItem);
				objItem.style.width = intLastWidth - 10;
				// Ensure that it is getting narrower
				if (intLastWidth == objectWidth(objItem))
					break;
			}
			
			objItem.style.width = objectWidth(objItem) + 20;
			
			// Is it too wide to fit to the right
			if (x + iconWidth + objectWidth(objItem) + 2 - document.body.scrollLeft > document.body.clientWidth) {
			
				// Will it fit on the left
				if (x > iconWidth + objectWidth(objItem) + 2)
					newX = x - (iconWidth + objectWidth(objItem)) + 2
				else
					newX = 0;	// align to the left
			}
			else
				newX = x + iconWidth;
				
			// Is it too far down move up
			if (y + objectHeight(objItem) - document.body.scrollTop > document.body.clientHeight) {
			
				newY = y - objectHeight(objItem);
				if (newY < document.body.scrollTop)
					newY = document.body.scrollTop;
			}
			else
				newY = y;
		}
			
		shiftTo(objItem, newX, newY);
		objItem.style.display = strOldDisplay;
		objItem.style.visibility = strOldVisibility;
		
	}
	catch(e) {
		logErrAndObj("locateResultWide", objItem, e)
	}
}

function resizeImage() {

	try {
		// Get size of page
		var intPageHeight = document.body.clientHeight;
		
		// Get size of view area
		var intViewHeight = document.body.scrollHeight;
		
		// Add the difference to the iFrame size
		var objIframe = elementById("ifrDisplay");
		
		// Resize to the new size if it is > 20 pixels
		var intNewSize = objectHeight(objIframe) + intPageHeight - intViewHeight
		if (intNewSize > 20)
			objIframe.style.height = intNewSize;
		if (intNewSize < objIframe.parentElement.scrollHeight)
			objIframe.style.height = objIframe.parentElement.offsetHeight;

	}
	catch(e) {
		logErr("resizeImage", e)
	}
}

var intIntialWidth
function resizeIframe(objIframe) {

	try {
	//	if (typeof intInitialWidth == "undefined" && objIframe.style.width != "")
	//		intIntialWidth = objIframe.style.width;
		objIframe.style.height = 50;
		objIframe.style.width = "100%";
		objIframe.style.height = objIframe.contentWindow.document.body.scrollHeight + 5;
		if (objIframe.contentWindow.document.body.scrollWidth + 5 > objIframe.scrollWidth)
			objIframe.style.width = objIframe.contentWindow.document.body.scrollWidth + 5;
	}
	catch(e) {
		logErrAndObj("resizeIframe", objIframe, e)
	}
}

function increaseIframe(objIframe) {

	try {
		if (objIframe.style.height.replace("px", "") < objIframe.contentWindow.document.body.scrollHeight)
			objIframe.style.height = objIframe.contentWindow.document.body.scrollHeight + 5;
	}
	catch(e) {
		if (e.number != -2147024891) // Access is denied to secure / other web sites
			logErrAndObj("increaseIframe", objIframe, e);
	}
}

// Hide selectors when the callout is displayed over them
var arrHiddenItems = new Array();

function hideAffected(objCallout, blnIncrement) {

	try {
		showCursorHourglass();
		
		if (!blnIncrement)
			showAffected(); // Firstly show anything we have already hidden
		
		var strOldDisplay = objCallout.style.display;
		
		objCallout.style.display = "";

		var x = objCallout.offsetLeft;
		var y = objCallout.offsetTop;
		var width = objCallout.offsetWidth;
		var height = objCallout.offsetHeight;
			
		var x1 = x, x2 = x+width, y1 = y, y2 = y+height;
		var colNodes = document.body.getElementsByTagName("SELECT");
		var length = colNodes.length;
		for (var i = 0; i < length; i++) {
			var objItem = colNodes[i];

			var objX = objectX(objItem);
			var objY = objectY(objItem);
			if (objX <= x2 && objX + objectWidth(objItem) >= x1 &&
				objY <= y2 && objY + objectHeight(objItem) >= y1) {
	
				if (isVisible(objItem)) {
					if (!isChildObject(objCallout, objItem)) {
						if (blnIncrement) {
							objWindowState.push(objItem);
//							if (arrWindowState.length > 0)
//								arrWindowState[arrWindowState.length-1].push(objItem)
						}
						else
//							objWindowState.push(objItem);
							arrHiddenItems.push(objItem);
						objItem.style.visibility="HIDDEN";
					}
				}
			}
		}
		
		showCursorNormal();

		objCallout.style.display = strOldDisplay;

	}
	catch(e) {
		logErrAndObj("hideAffected", objCallout, e)
	}
}

// returns true if the descendent object is within the children objects in the dom
function isChildObject(objParent, objDescendant) {
	
	try {
		var conChildNodes = objParent.childNodes;
		var length = conChildNodes.length;
		for (var i = 0; i < length; i++) {
			if (conChildNodes[i] == objDescendant)
				return (true);
			if (isChildObject(conChildNodes[i], objDescendant))
				return (true);
		}
		return (false);
	}
	catch(e) {
		logErrAndObj("isChildObject", objItem, e)
	}
	
}

function showAffected() {

	try {
		var objItem
		objItem = arrHiddenItems.pop()
		
		while (typeof(objItem) != "undefined") {
			objItem.style.visibility = "";
			objItem = arrHiddenItems.pop();
		}
	}
	catch(e) {
		logErr("showAffected", e)
	}
}

// checks if the string strItem is at the end of the string strBase
function isEndOf(strBase, strItem) {
	try {
		if (strBase.substring(strBase.length - strItem.length) == strItem)
			return (true)
		else
			return (false);
	}
	catch(e) {
		logErr("isEndOf", e)
	}
}

// Log any javascript errors for storing on the server
function logErr(strSource, e) {
	if (e.hasOwnProperty("length")) {
		try {
			setValue(elementById("jse"), getValue(elementById("jse")) + "\n" + strSource + ":" + e)
		}
		catch (e1) {
		}
		if (window.location.host == "localhost") alert(strSource + " error " + e);
	}
	else {
		try {
			setValue(elementById("jse"), getValue(elementById("jse")) + "\t" + strSource + ":" + e.name + " (" + e.number + ") " + e.message + "; " + e.description)
		}
		catch (e1) {
		}
		if (window.location.host == "localhost") alert(strSource + " error " + e.name + " (" + e.number + ") " + e.message + "; " + e.description);
	}
}

function logErrAndObj(strSource, objItem, e) {

	var strError = strSource + ": "
	
	if (e.hasOwnProperty("length")) {
		try {
			strError += e;
		}
		catch (e1) {
		}
	}
	else {
		try {
			strError += e.name + " (" + e.number + ") " + e.message + "; " + e.description;
		}
		catch (e1) {
		}
	}

	try {
//		if (objItem.hasOwnProperty("outerHTML"))
			strError += objItem.outerHTML + " : ";
	}
	catch (e1) {
	}

	setValue(elementById("jse"), getValue(elementById("jse")) + "\n" + strError)

	if (window.location.host == "localhost") alert(strError);

}

window.onerror=fnErrorTrap;

function fnErrorTrap(sMsg,sUrl,sLine){
	
	try {

		var strError = "Error: " + sMsg +
		   				";Line: " + sLine +
   						";URL: " + sUrl;

		setValue(elementById("jse"), getValue(elementById("jse")) + "\n" + strError)

		if (window.location.host == "localhost") alert(strError);

	   return false;
	}
	catch (e1) {
	}
}

// Preload images
function preloadImages() {
	try {
	  	if(document.images){ 
	  		if(!document.imageArray) document.imageArray = new Array();
	    	var i, images=document.imageArray.length, args=preloadImages.arguments; 
			for(i=0; i<args.length; i++)
	    		if (args[i].indexOf("#")!=0){ 
					document.imageArray[images] = new Image; 
					document.imageArray[images++].src=args[i];
				}
		}
	}
	catch(e) {
		logErr("preloadImages", e)
	}
}

function showCursorHourglass() {
	// window.setCursor("wait");
}

function showCursorNormal() {
	// window.setCursor("");
}

// Highlight items when in focus

var strOverColor = "CCCCCC";
var strOverBold = "999999";

var objOver, objOverBold;

function popItemOv(objItem) { // Called when mouse is over a menu item
	try {
		addTraceObj("popItemOv", objItem);
		
		// If we aren't hiding popups
		if (!blnHidePopup) {
		
			// If we haven't saved the background colour then save it
			if (typeof objItem.oldBackgroundColor == "undefined")
				objItem.oldBackgroundColor = objItem.style.backgroundColor;

			// If the background color has not been set
			if (objItem.style.backgroundColor != strOverColor &&
				objItem.style.backgroundColor != strOverBold) {
				
				// If we have set the over color elsewhere then clear
				if (objOver)
					popItemOu(objOver);
				
				objOver = objItem;
				objItem.style.backgroundColor = strOverColor;
				
			}
		}
	}
	catch(e) {
		logErrAndObj("popItemOv", objItem, e)
	}
}

function popItemOvBold(objItem) {
	try {
		addTraceObj("popItemOvBold", objItem);

		// If we haven't saved the background colour then save it
		if (typeof objItem.oldBackgroundColor == "undefined")
			objItem.oldBackgroundColor = objItem.style.backgroundColor;

		// If we have set the over color elsewhere then clear
		if (objOver)
			popItemOu(objOver);

		// If we have set the bold color elsewhere then clear
		if (objOverBold) {
			objOverBold.dontPopout = false;
			popItemOu(objOverBold);
		}

		objOverBold = objItem;
		objItem.dontPopout = true;
		objItem.style.backgroundColor = strOverBold;
	}
	catch(e) {
		logErrAndObj("popItemOvBold", objItem, e)
	}
}

function popItemOu(objItem) {  // Called when mouse leaves a menu item
	try {
		addTraceObj("popItemOu", objItem);
		if (typeof objItem == "object") {
			if (!objItem.dontPopout) {
				objItem.style.backgroundColor = objItem.oldBackgroundColor;
				objItem = false;
			}
		}
	}
	catch(e) {
		logErrAndObj("popItemOv", objItem, e)
	}
}

function showItem(objItem) {

	try {
		var objIframe = elementById("ifrDisplay");
	
		objIframe.src=objItem.href;
		
		var objLinkItems = elementsByName("navItem");
		var intLength, intIndex
		
		intLength = objLinkItems.length
		
		for (intIndex =0 ; intIndex < intLength; intIndex++) {
			if (objLinkItems(intIndex).className == "navCur") {
				objLinkItems(intIndex).className = "navPost";
			}
		}
		objItem.className = "navCur";
		
		return(false)
	}
	catch(e) {
		logErrAndObj("showItem", objItem, e)
	}
}

function maxLength(objItem, intLength) {
	try {
	  	if (objItem.value.length > intLength) {
			objItem.value = objItem.value.substring(0,intLength);
		}
	}
	catch(e) {
		logErrAndObj("maxLength", objItem, e)
	}
}

// Radio function that allows a radio to be unselected
function myR(objItem) {
	try {
		if (objItem.preChecked) {
			objItem.checked = false;
			objItem.preChecked = false;
		}
		else {

			var arrItems = elementsByName(objItem.name)
			var i
			
			for (i=0; i < arrItems.length; i++)
				arrItems[i].preChecked = false;

			objItem.checked = true;	
			objItem.preChecked = true;
			
		}
	}
	catch(e) {
		logErrAndObj("myR", objItem, e)
	}
}

// The next few functions validate fields on the screen.
function validate(objItem) {
	return(validateItem(objItem, false));
}

function validateItem(objItem, blnAlert) {
	
	try {
	
		var strFieldLabel
		if (objItem.Label)
			strFieldLabel = objItem.Label
		else {
			if (objItem.name)
				strFieldLabel = objItem.name
			else
				if (objItem.id)
					strFieldLabel = objItem.id
				else
					strFieldLabel = objItem.tagName;
		}
			
		if (objItem.required == "1" && 
			((objItem.tagName == "INPUT" && objItem.type == "text" && objItem.value == "") ||
			(objItem.tagName == "TEXTAREA" && objItem.innerHTML == "") ||
			(objItem.tagName == "SELECT" && objItem.value == "0")))
			return (errorField(objItem, strFieldLabel + ": Field is required", blnAlert))
		else
			clearErrorField(objItem);
			
		if (objItem.value != "" && objItem.valType) {
			switch (objItem.valType) {
			
				case "Date":
			
					var strError = strFieldLabel + ": Date must match format dd/mm/yyyy";
					var re = /\d+/g;
					var r = objItem.value.match(re);
					if (r == null)
						return (errorField(objItem, strError, blnAlert))
					else {
						if (r.length != 3)
							return (errorField(objItem, strError, blnAlert))
						else {
							var intYear = new Number(r[2])
							if (intYear < 2000) intYear += 2000;
							var dteValue = new Date(intYear, r[1]-1, r[0]);
							
							if (dteValue.getDate() != r[0])
								return (errorField(objItem, strError, blnAlert))
							else {
								var strResult = dteValue.getDate() < 10 ? "0" + dteValue.getDate() : dteValue.getDate();
								strResult += "/" 
								strResult += dteValue.getMonth() < 9 ? "0" + (dteValue.getMonth() + 1) : (dteValue.getMonth() + 1);
								strResult += "/" 
								strResult += dteValue.getYear();
								
								objItem.value = strResult;
								
								return (clearErrorField(objItem));
							}
						}
	
					}
					break;
					
				case "URL":
			
					var re = /https?:\/\/.*/;
					if (regExChecker(re, objItem.value))
						return (errorField(objItem, strFieldLabel + ": URL must match the format http://www.yourSite.com/page (or https)", blnAlert))
					else
						return (clearErrorField(objItem));
					break;
					
				case "Email":
			
					var re = /^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/;
					
					if (regExChecker(re, objItem.value))
						return (errorField(objItem, strFieldLabel + ": must be an email address", blnAlert))
					else
						return (clearErrorField(objItem));
					break;
					
				case "Number":
			
					var re = /[0-9]*\.{0,1}[0-9]*/;
					if (regExChecker(re, objItem.value))
						return (errorField(objItem, strFieldLabel + ": must be numeric", blnAlert))
					else
						return (clearErrorField(objItem));
					break;
					
				case "Integer":
			
					var re = /[0-9]*/;
					if (regExChecker(re, objItem.value))
						return (errorField(objItem, strFieldLabel + ": must be an integer", blnAlert))
					else
						return (clearErrorField(objItem));
					break;
					
				default :
					logErr("validate", "Format type " + objItem.valType + " unknown")
					break;
			}
	
		}

		else
			return (clearErrorField(objItem));
	}
	catch(e) {
		logErrAndObj("validateItem", objItem, e)
	}
}

function regExChecker(re, strValue) {
	try {
	
		var r = strValue.match(re);
		if (strValue != "") {
			if (r == null)
				return (true)
			else
				if (r[0] != strValue)
					return (true);
		}
		else
			return (false);
	}
	catch(e) {
		logErr("regExChecker", e)
	}
}

function errorField(objItem, strMessage, blnAlert) {

	try {
	
		if (objItem.getAttributeNode("iBackgroundColor") == null)
			objItem.iBackgroundColor = objItem.style.backgroundColor;
	
		objItem.style.backgroundColor = "#ffcccc";
	
		if (objItem.getAttributeNode("iBorderColor") == null)
			objItem.iBorderColor = objItem.style.borderColor;
	
		objItem.style.borderColor = "#ff0000";
	
		if (strMessage != "" && blnAlert)
			alert (strMessage);
		
		return (strMessage + "\n");
	}
	catch(e) {
		logErrAndObj("validate", objItem, e)
	}
}

function clearErrorField(objItem) {

	try {
	
		if (objItem.getAttributeNode("iBackgroundColor") != null)
			objItem.style.backgroundColor = objItem.iBackgroundColor;
	
		if (objItem.getAttributeNode("iBorderColor") != null)
			objItem.style.borderColor = objItem.iBorderColor;
	
		return ("");
	}
	catch(e) {
		logErrAndObj("validate", objItem, e)
	}
}

// The next few functions are used to store the first error field on a page so
// that the focus can be set to that field
var objError;
function clearFirstError() {
	try {
		objError = null;
	}
	catch(e) {
		logErr("clearFirstError", e)
	}
}

function validateAndSetFirstError(objItem, blnAlert) {
	try {

		if (objItem != null) {
			var strError = validateItem(objItem, blnAlert);
			if (strError != "")
				setFirstError(objItem);
			return(strError);
		}
		else {
			clearFirstError();
			return("");
		}
	}
	catch(e) {
		logErrAndObj("validateAndSetFirstError", objItem, e)
	}
}

function setFirstError(objItem) {
	try {
		if (objError == null)
			objError = objItem;
	}
	catch(e) {
		logErr("getFirstError", e)
	}
}

function getFirstError() {
	try {
	 	return(objError);
	}
	catch(e) {
		logErr("getFirstError", e)
	}
}

// Clears the windows default return event handler

function clearReturnEvent() {
	try {
		window.event.returnValue = false;
	}
	catch(e) {
		logErr("clearReturnEvent", e)
	}
}

// Key up function checks for enter key
function ku(objItem) {
	try {
		if (event.keyCode == 13) {
		 	var objItem = elementById(objItem.EnterButton)
			objItem.click();
			clearReturnEvent();
		}
	}
	catch(e) {
		logErrAndObj("ku", objItem, e)
	}
}

// Replace href with submit

function doSub(objItem) {
	try {
		setValue(elementById("SubItem"), objItem.href);
		// If there is no submit button on the form then just let the a href do the job
		try {
			Form.submit();
			return(false);
		}
		catch (el) {
			return(true);
		}
	}
	catch(e) {
		logErrAndObj("doSub", objItem, e)
	}
}

// Remote Scripting Functions

var serverURL = "rScriptServices.asp";

// Format the return code from a remote function call when co.return value is not 0
function myCallBack(co) {

	try {
		var now = new Date()
		
		if (co.message == "'aspObject' is null or not an object") {
			alert("Could not connect to remote website.\n" +
					"If you have not used this page for a while your session may have timed out:  Refresh the page and try again.\n" +
					"If this is the first time you have tried to use this page then see the FAQ page (? on the menu) for technical browser issues")
		}
		else {
			alert("CALLBACK\n\n" +
					"status = " + co.status + "\n\n" +
					"message = " + co.message + "\n\n" +
					"context = " + co.context + "\n\n" +
					"data = " + co.data + "\n\n" +
					"return_value = " + co.return_value + "\n\n" +
					"at = " + now.toLocaleString());
		}
	}
	catch(e) {
		logErr("myCallBack", e)
	}
} 
var blnRsEnabled, tmrTimeout, tmrRetry

function setupRs() {
	try {
		var strQueryDebug = getQueryString("debug");
		if (strQueryDebug.toLowerCase() == "yes") {
			blnTrace = true;
			if (elementByIdIfExists("traceControl") != null)
				elementById("traceControl").style.visibility = "visible";
			if (elementByIdIfExists("tracelog") != null)
				elementById("tracelog").style.visibility = "visible";
		}
	
		addTrace("setupRs");

		blnRsEnabled = false;

		RSEnableRemoteScripting('_ScriptLibrary');
		RSAspProxyApplet.style.display='none';

		tmrRetry = window.setInterval("sendRsTest()", 1000);
		tmrTimeout = window.setTimeout("sendRsTimeout()", 30000);
	}
	catch(e) {
		logErr("setupRs", e)
	}
}

// var aspObject;
function sendRsTest() {
	try {

		addTrace("sendRsTest: Send");
		if (RSAspProxyApplet.readyState != 4) {
			aspObject = RSGetASPObject("rScriptServices.asp");
	
	// 		checkRsEnabled();
	
			var co = aspObject.rsTestFunction("Test")
			
			addTrace("sendRsTest: Returned " + co.return_value);
	
			window.clearTimeout(tmrTimeout);
	
			if (co.status != 0) 
				myCallBack(co)
			else {
				if (co.return_value == "Test")
					blnRsEnabled = true
				else
					throw("Invalid response from server " + co.return_value);
			}
		}
	}
	catch(e) {
		logErr("sendRsTest", e)
	}
}

function sendRsTimeout() {
	try {
		window.clearTimeout(tmrRetry);
		alert("Remote service is not available. If this persists, see out Frequently asked questions page (? above) for more information.")
	}
	catch(e) {
		logErr("sendRsTimeout", e)
	}
}

var blnTrace=false;
function addTrace(strMessage) {
	try {
		if (blnTrace) {
			var objTraceLog = elementByIdIfExists("traceLog");
			if (typeof objTraceLog == "object"  && objTraceLog != null) {
				var reLt = /</g;
				var reGt = />/g;
				strMessage = strMessage.replace(reLt, "&lt;");
				strMessage = strMessage.replace(reGt, "&gt;");
				objTraceLog.innerHTML += strMessage + "<br>";
			}
		}
	}
	catch(e) {
		logErr("addTrace", e)
	}
}

function addTraceObj(strMessage, objItem) {
	try {

		if (blnTrace) {
			var objTraceLog = elementByIdIfExists("traceLog");
			if (typeof objTraceLog == "object"  && objTraceLog != null) {
				switch (typeof objItem) {
					case "undefined":
						objTraceLog.innerHTML += strMessage + ": object undefined [" + timeToMs(new Date()) + "]<br>";
						break;
					case "object":
						var strRes = "<div title='" + objItem.outerHTML + "'>";
						if (objItem.id == "")
							objTraceLog.innerHTML += strRes + strMessage + ": " + objItem.innerHTML + " [" + timeToMs(new Date()) + "]<div>"
						else
							objTraceLog.innerHTML += strRes + strMessage + ": (" + objItem.id + ") [" + timeToMs(new Date()) + "]<div>";
						break;
					case "string":
						objTraceLog.innerHTML += strMessage + ": " + objItem + " [" + timeToMs(new Date()) + "]<br>";
						break;
					case "boolean":
						objTraceLog.innerHTML += strMessage + ": " + objItem + " [" + timeToMs(new Date()) + "]<br>";
						break;
					default:					
						objTraceLog.innerHTML += strMessage + ": objItem typeof: " + typeof objItem + " [" + timeToMs(new Date()) + "]<br>";
				}
			}
		}
	}
	catch(e) {
		logErr("addTrace", e)
	}
}

 function timeToMs(dteItem) {
	return (dteItem.getFullYear()		* 10000000000000 +
			(dteItem.getMonth() + 1)	* 100000000000 +
			dteItem.getDate()			* 1000000000 +
			dteItem.getHours() 			* 10000000 +
			dteItem.getMinutes() 		* 100000 +
			dteItem.getSeconds() 		* 1000 +
			dteItem.getMilliseconds())
}

function selectText(objSelector, strValue) {
	try {
		var colOptions = objSelector.options
		for (var i=0; i< colOptions.length; i++) {
			if (colOptions(i).value == strValue)
				return (colOptions(i).text);
		}
		return ""
	}
	catch(e) {
		logErr("addTrace", e)
	}
}

function getQueryString(strItem) {
	try {
		var strItemLower = strItem.toLowerCase();
		var arrQuests = document.location.href.split("?")
		if (arrQuests.length > 1) {
			var arrQueryOptions = arrQuests[1].split("&")
			for (var i=0; i< arrQueryOptions.length ; i++) {
				var arrQueryItem = arrQueryOptions[i].split("=")
				if (arrQueryItem.length == 2) {
					if (arrQueryItem[0].toLowerCase() == strItemLower)
						return (arrQueryItem[1]);
				}
			}
		}

		return ""
	}
	catch(e) {
		logErr("queryString", e)
	}
}

function testAspObject() {
	try {
		while (typeof aspObject == "undefined")
			alert("Page still loading.  Please wait until it has finished, and try again.");
	}
	catch(e) {
		logErr("testAspObject", e)
	}
}

function clearTextAreas() {

	try {
		var colNodes = document.body.getElementsByTagName("TEXTAREA");
		var length = colNodes.length;
		for (var i = 0; i < length; i++) {
			colNodes[i].value = "";
		}
	}
	catch(e) {
		logErr("clearTextAreas", e)
	}
}

function toggleDiv(objItem) {
	try {
		var objParent = elementById(objItem.parentItem)
		var objOtherObjectItem = elementById(objItem.otherObjectItem)
		if (typeof objItem.viewState == "undefined") {
			objItem.viewState = "show";
			objItem.showSrc = objItem.src;
			// objItem.parentOriginalWidth = elementById(objItem.parentItem).scrollWidth;
			objItem.parentOriginalWidth = objParent.style.width;
		}
		if (objItem.viewState == "show") {
		
			objItem.viewState = "hide";
			objItem.src = objItem.altSrc;

			objOtherObjectItem.oldHeight = objOtherObjectItem.style.height;
			objParent.oldWidth = objectWidth(objParent);
			objOtherObjectItem.oldWidth = objOtherObjectItem.style.width;
			
			objOtherObjectItem.style.height = objectHeight(objOtherObjectItem);
			
			hide(elementById(objItem.hideItem));
			objParent.style.width = objItem.parentHideWidth;
			objOtherObjectItem.style.width = objItem.otherObjectWidth;
		}
		else {
		
			objItem.viewState = "show";
			objItem.src = objItem.showSrc;
			
			objOtherObjectItem.style.height = objOtherObjectItem.oldHeight;
			objParent.style.width = objItem.parentOriginalWidth;
			show(elementById(objItem.hideItem));
			objParent.style.maxWidth = objItem.parentHideWidth;
			objItem.style.maxWidth = objItem.oldmaxWidth;
		}
	}
	catch(e) {
		logErr("toggleDiv", e)
	}
}

function printPage() {
	try {
		window.print();
		window.close();
	}
	catch(e) {
		logErr("toggleDiv", e)
	}
}

function refreshParent() {
	try {
		if (window.parent != null)
			window.parent.location.href = window.parent.location.href;
	}
	catch(e) {
		logErr("refreshParent", e)
	}
}