/*
============================================================================================

	File: common.js
	
	Version: 1.5.15 (07 Apr 2006)
	
	(c) TANDBERG 2006

	Author: Ailene Nichol, Jeremy Mould (original location of this file was /tcs/js/common.js.  Ideally this would be merged with common2.js.

    SVN $Id: common.js 3884 2007-04-01 20:49:38Z jmo $
	
============================================================================================
*/

// Debugging vars
gTraceWindow = null;
gDebug = 0;
gSelectedCount=0;

// define client constants
var AGENT = navigator.userAgent;

var IS_IE = 		AGENT.indexOf('MSIE') != -1;
var IS_WINDOWS = 	AGENT.indexOf('Windows') != -1;
var IS_GECKO = 		AGENT.indexOf('Gecko') != -1;
var IS_NAVIGATOR = 	AGENT.indexOf('Netscape') != -1;
var IS_FIREFOX = 	AGENT.indexOf('Firefox') != -1;	
var IS_MOZILLA = 	IS_GECKO && !IS_NAVIGATOR && !IS_FIREFOX;
var APP_VERSION=	parseInt(navigator.appVersion);

var gAllowRightClick = true;
function validUserName(userName)
{
	if(userName == '')
		return false;
	else if( userName.match(/^\s+$/ig) )
		return false;
	else
		return true;
}
function htmlDecode(s)
{
	var str = new String(s);
	str = str.replace(/\&amp\;/ig, "&");
	str = str.replace(/\&lt\;/ig, "<");
	str = str.replace(/\&gt\;/ig, ">");
	str = str.replace(/\&quot\;/ig, '"');
	return str;
}
function htmlEncode(s) 
{
	
	var str = new String(s);
	str = str.replace(/&/g, "&amp;");
	str = str.replace(/</g, "&lt;");
	str = str.replace(/>/g, "&gt;");
	str = str.replace(/"/g, "&quot;");
	return str;
}

function XmlEncode(s)
{
	var str = new String(s);
	str = str.replace(/&(?![(amp)(lt)(gt)])/ig, "&amp;");
	str = str.replace(/</g, "&lt;");
	str = str.replace(/>/g, "&gt;");
	str = str.replace(/"/g, "&quot;");
	return str;
}

function disableRightClick()
{
	gAllowRightClick = false;

	function stopRightClick_IE() 
	{
		if (document.all) 
		{
			return false;
		}
	}

	function stopRightClick_NS(e) 
	{
		if(document.layers
			||(document.getElementById && !document.all)) 
		{
			if (e.which > 1) 
			{
				return false;
			}
		}
	}

	if (document.layers) 
	{
		document.captureEvents(Event.MOUSEDOWN);
		document.onmousedown=stopRightClick_NS;
	}
	else
	{
		document.onmouseup=stopRightClick_NS;
		document.oncontextmenu=stopRightClick_IE;
	}

	document.oncontextmenu = function()
	{
		return false;
	}


}

function trace(string)
{
	try
	{
		if (!gTraceWindow)
		{
			gTraceWindow = window.open('', 'gTraceWindow', 'resizeable, status, width=600, height=400');
		}
		
		var traceDoc = gTraceWindow.document;
		
		if(traceDoc)
		{
			traceDoc.body.innerHTML = ('<p>' + string + '</p>\n') + traceDoc.body.innerHTML;
		}
	}
	catch(e){}
}


function track(string, debugLevel)
{ 
	try
	{
		var undefined;
		
		debugLevel = (debugLevel == undefined) ? 1 : debugLevel;
	
		if (gDebug >= debugLevel)
		{
			trace(string);
		}
	}
	catch(e){}
	
}


function httpPost(url, content, callBackFunction)
{
	var request;
	
	content = content ? content : '';
	
	// try IE on windows support
	/*@cc_on @*/
	/*@if (@_jscript_version >= 5)
	// JScript gives us Conditional compilation, we can cope with old IE versions.
	// and security blocked creation of the objects.
	try 
	{
		request = new ActiveXObject("Msxml2.XMLHTTP");
	} 
	catch (e) 
	{
		try 
		{
			request = new ActiveXObject("Microsoft.XMLHTTP");
		}
		catch (E)
		{
			request = false;
		}
	 }
	@else
		request = false;
	@end @*/
	
	if (!request)
	{
		// try Mozilla and Safari support
		try 
		{
			request = new XMLHttpRequest();
		}
		catch (e)
		{
			request = false;
		}
	}

	if (request)
	{
		request.open("POST", url, true);
		request.setRequestHeader("Content-type", "application/xhtml+xml");
		request.setRequestHeader("Content-Length", content.length);
		
		if (callBackFunction)
		{
			request.onreadystatechange = 
				function ()
				{
					processReqChange(request, callBackFunction);
				}
		}
		
		request.send(content);
	}

	return request;
}

			
function processReqChange(request, callBackFunction)
{
	var reportStr='';
	reportStr += 'request=' + request + '</br>';
	reportStr += 'callBackFunction=' + callBackFunction + '</br>';
	reportStr += 'request.readyState=' + request.readyState + '</br>';

	// only if req shows "loaded"
	if (request.readyState == 4)
	{	
		try
		{   
			reportStr += 'request.responseText=' + request.responseText + '</br>';
			callBackFunction(request.responseText);
		}
		catch(e)
		{
			
			reportStr += 'error=' + e + '</br>';
			try
			{
			   alert("There was a problem with httpPost:\n" + request.statusText);
			}
			catch(e2)
			{
			   alert("There was a problem with httpPost:\n" + e2);
			}
		}  
	}
	
	var statusElement = document.getElementById('trace');
	if(statusElement)
	{
		statusElement.innerHTML = reportStr;
	}
}



String.prototype.trim =	function(whiteSpace)
{
	
	var string = this.toString();
	var left;
	var right; 
	var checkChar;
	var undefined;

	if (whiteSpace == undefined) whiteSpace = '\n\r\t ' ;

	// Go from the left of the string till you hit a non white space char			
	for (left=0 ; left < string.length ; left++)
	{
		checkChar = string.charAt(left);
		if ( whiteSpace.indexOf(checkChar) < 0 ) break;
	}
	
	// Go from the right of the string till you hit a non white space char
	for (right = string.length - 1 ; right > left ; right--)
	{
		checkChar = string.charAt(right);
		if ( whiteSpace.indexOf(checkChar) < 0 ) break;
	}
		
	// Return the non white space string in the middle
	return string.substring(left, right +1);

}


function getFunctionName(object)
{
	if (typeof(object) != 'function')
	{
		return null;
	}
	
	return  object.toString().split(' ')[1].split('(')[0];	
}


function getConstructorName(object)
{	
	if ( typeof(object) == 'object' 
			&& object != null 
			&& object.constructor )
	{
		return  getFunctionName(object.constructor);								
	}
	
	return typeof(object);	
}


function jsEncode(object)
{	
	var string = '';
	var type = getConstructorName(object);
	type = type.toLowerCase();
	
	switch(type)
	{
		case "array":
			string += '[';
			for (var i = 0; i < object.length ; i++)
			{
				string += ( i > 0 ) ? ', ' : '';
				string += jsEncode(object[i]);
				
			}
			string += ']';
			break;
			
		case "boolean":
			string += (object == true) ? 'true' : false;
			break;

		case "number":
			string += object;
			break;

		case "string":
			object = object.replace(/\"/g, '\\"');
			string += '"' + object + '"';
			break;
	
		case "object":
			string += '{';
			var i = 0;
			for (var name in object)
			{
				string += ( i > 0 ) ? ', ' : '';
				string += name + ': ' + jsEncode(object[name]);
				i++;
				
			}
			string += '}';
			break;
  }
  
  return string;
}


function onMouseUp(event, onMouseUpFunction)
{	


	function onMouseUp_Dom(e)
	{
		gOnMouseUpFunction();
	
		document.removeEventListener("mouseup", onMouseUp_Dom, true);
	}
		
		
	function onMouseUp_IE_5()
	{
		var e = window.event;
		
		gOnMouseUpFunction();
		
		e.cancelBubble = true;
		e.returnValue = false;
	}

	function onMouseUp_IE_4()
	{
		var e = window.event;
		
		gOnMouseUpFunction();
		
		e.cancelBubble = true;
		e.returnValue = false;
	}
	
	
	gOnMouseUpFunction = onMouseUpFunction;

	if (document.addEventListener)
	{
		// DOM level 2
		
	
		document.addEventListener("mouseup", onMouseUp_Dom, true);
		
		event.stopPropagation(); /* stop other handlers */
		event.preventDefault();  /* stop default action */
		
	}
	else if (document.attachEvent)
	{
		// IE 5
		
		document.attachEvent("onmouseup", onMouseUp_IE_5);
		
		event.cancelBubble = true; /* stop other handlers */
		event.returnValue = false; /* stop default action */
		
	} 
	else
	{
		// IE 4
		
		oldMoveHandler = document.onmousemove;
		oldUpHandler = document.onmouseup;
		
		document.onmouseup = onMouseUp_IE_4;
					
		event.cancelBubble = true; /* stop other handlers */
		event.returnValue = false; /* stop default action */
	
	}
}


function submitForm_old(buttonName, buttonValue, formAction)
{

	var form = document.serverLogs;
	
	if (!formAction)
	{
		formAction = form.action;
	}
	
	formAction += '?' + buttonName + '=' + buttonValue;
	
	form.action = formAction;
	form.submit();
}

function submitForm(formName, elementNames, elementValues)
{

	for (var i = 0; i < elementNames.length; i++)
	{
		document.getElementById(elementNames[i]).value = elementValues[i];
	}

	document.forms[formName].submit();
}
						
								
function checkEnter(e)
{
	var charCode;

	if(e && e.which)
	{ 
		// Nav
		charCode = e.which;
	}
	else
	{
		// IE
		e = event;
		charCode = e.keyCode;
	}
	
	if(charCode == 13)
	{ 
		// ascii 13 is enter key
	
		if (e.stopPropagation)
		{
			e.stopPropagation(); 	/* stop other handlers */
			e.preventDefault();  	/* stop default action */
		}
		else
		{
			e.cancelBubble = true; /* stop other handlers */
			e.returnValue = false;  /* stop default action */
		}
		
		return true; 
	}
	else
	{
		return false;
	}
}


function exclusiveItem(itemElement)
{
	var otherItem, index = 0;
	var baseClass = itemElement.className.split('_')[0]
	
	itemElement.className = baseClass + '_selected';
	
	while ( otherItem = getElementByRef(itemElement, index++, 1) )
	{
		if (otherItem == itemElement)
		{
			continue;
		}
		
		otherItem.className = baseClass;
		
		if (index > 1000)
		{
			// just in case
			break;
		}
	
	}
	
}



function getElementByRef(refElement, newIndex, indexPos)
{
	var indexArray = refElement.name.split('_');
	var elementName;
	
	indexArray[indexPos] = newIndex;
	
	elementName = indexArray.join('_');
	
	return document.getElementsByName( elementName )[0];
}




function entify(string)
{
	string = string.replace(/\'/g, "&#39;");
	string = string.replace(/\"/g, "&#34;");

    return string;
}


function deentify(string)
{
	string = string.replace(/\&\#39\;/g, "'");
	string = string.replace(/\&\#34\;/g, '"');

    return string;
}



function getRadioValue(form, radioName)
{
	
	var radioElements = form[radioName];
	
	if (radioElements != null)
	{
		for (var i = 0 ; i < radioElements.length ; i++)
		{
			if (radioElements[i].checked)
			{
				return radioElements[i].value;
			}	
		}
	}
	
	return null;
}


function setRadioValue(form, radioName, value)
{
	var radioElements = form[radioName];
	var checked = false;
	
	if (radioElements != null)
	{
		for (var i = 0 ; i < radioElements.length ; i++)
		{
			if (radioElements[i].value == value)
			{
				radioElements[i].checked = true;
				checked = true;
			}
			else
			{
				radioElements[i].checked = false;
			}
		}	
	}
		
	return checked;
}

function SetCheckBoxValue(form, checkBoxName, value)
{
	var checkBoxElements = form[checkBoxName];
	var checked = false;
	
	if (checkBoxElements != null)
	{
		for (var i = 0 ; i < checkBoxElements.length ; i++)
		{
			if (checkBoxElements[i].value == value)
			{
				checkBoxElements[i].checked = true;
				checked = true;
			}
			else
			{
				checkBoxElements[i].checked = false;
			}
		}	
	}
		
	return checked;
}



function ChangeAllCheckBoxValues(formName,value,checkBoxPrefix)
{

	var formElement = document.forms[formName];
	var formElements = formElement.elements;

	gSelectedCount = 0;

	for(var i = 0; i<formElements.length; i++)
	{
		var elementType = formElements[i].type;
		
		if(elementType == 'checkbox')
		{
			
			if(checkBoxPrefix && formElements[i].name.match(checkBoxPrefix) || !checkBoxPrefix)
			{
				if(!formElements[i].disabled)
				{
					formElements[i].checked=value;
						if(value)
						{
							gSelectedCount ++;
						}
				}
			}

		}
	}
}

function DeleteSelectedPressed(deleteType,deleteTypePlural)
{
	var additionalText = '';
	
	if( gSelectedCount > 0 )  
	{  

		if(deleteType == 'user')
		{

			additionalText = ( gSelectedCount > 1) ? '\nAny recording aliases associated with these users will also be deleted.' : '\nAny recording aliases assosiated with this user will also be deleted.';
		}
		deleteText = ( gSelectedCount > 1 )	? 'Are you sure you want to delete the ' + gSelectedCount + ' selected ' + deleteTypePlural + '?' 
											: 'Are you sure you want to delete the selected ' + deleteType + '?' ;

		deleteText += additionalText;

		if( confirm(deleteText)  )	
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	else
	{
		alert('You haven\'t selected any ' + deleteTypePlural + ' to delete.');
		return false;  	
	}
}


function formatTime(millisec, shortFlag)
{
	var millisec = millisec ? new Date( parseInt(millisec) ) : new Date(0) ;
	
	var h = millisec.getUTCHours() ;
	var m = millisec.getUTCMinutes() ;
	var s = millisec.getUTCSeconds() ;
	var f = Math.round( millisec.getUTCMilliseconds() / 10 ) ; // 10ths of secs

	// add leading 0 to 1 digit numbers
	h = h < 10 ? '0' + h : h ; 
	m = m < 10 ? '0' + m : m ;
	s = s < 10 ? '0' + s : s ;
	f = f < 10 ? '0' + f : f ;	
	
	if (shortFlag)
	{
		// hh:mm:ss
		return ( h + ':' + m + ':' + s ) ;
	}
		
	// hh:mm:ss.ff
	return ( h + ':' + m + ':' + s + '.' + f ) ;
}
									
function getX(element)
{
	var x = 0;
	if (element.offsetParent)
	{
		while (element.offsetParent)
		{
			x += element.offsetLeft
			element = element.offsetParent;
		}
	}
	else if (obj.x)
	{
		x += obj.x;
	}
	return x;
}

function getY(element)
{
	var y = 0;
	if (element.offsetParent)
	{
		while (element.offsetParent)
		{
			y += element.offsetTop
			element = element.offsetParent;
		}
	}
	else if (element.y)
	{
		y += element.y;
	}
	return y;
}

Array.indexOf = function(array, item)
{
	if (!array)
	{
	 	return -1;
	}
   	
	for(var i = 0; i < array.length; i++)
	{
		if (item === array[i]) 
		{
			return i;
		}
	}

	return -1;
} 

Array.contains = function(array, item)
{
	return ( this.indexOf(array, item) > -1 );
} 



Array.deleteItem = function(array, item)
{
	var index = Array.indexOf(array, item);

	if(index != -1)
	{
		return Array.deleteItemAt(array, index);
	}
	
	return null;
}

Array.deleteItemAt = function(array, index)
{
	if(index >= array.length || index < 0)
	{
		return null;
	} 

	var deletedItem = array[index];	
	var newLength = array.length -1

	for(var i = index; i < newLength ; i++)
	{
		array[i] = array[i+1];
	}

	array.length = newLength;

	return deletedItem;
}

function submitFormViaIframe(originDoc, destinationDoc)
{

	var newInnerHTML='';
	// loop through all input fields
	var inputs = originDoc.getElementsByTagName('input');
	for(var i in inputs)
	{
		input = inputs[i];

		
		if(input.type=='checkbox')
		{
			if(input.checked==true)
			{
				newInnerHTML += '<input type="hidden" name="' + input.name + '" value="' + input.value + '">';
			}
		}
		else if(input.type=='radio')
		{
			if(input.checked == true)
			{
				newInnerHTML += '<input type="hidden" name="' + input.name + '" value="' + input.value + '">';
			}
		}
		else if(input.type=='image')
		{
			var imageProps = '';
			for(var j in input)
			{
				
					imageProps += '(' + j + ':)  ';
				
			}
			//alert('NODEVALUE: ' + input['click']);
			//alert('IMAGE PROPS:\n' + imageProps);
			//alert('type(' + input.type + ') name(' + input.name + ') value('+input.value+') width('+input.width+') x('+input.x +')');
		}
		else
		{	
	
			if(input.name && input.value)
			{
				newInnerHTML += '<input type="hidden" name="' + input.name + '" value="' + input.value + '">';
			}
		}

	}


	// Loop through all textarea fields	
	var textareas = originDoc.getElementsByTagName('textarea');
	for(var i in textareas)
	{

		
		//alert(input.name + ' - ' + input.value);

		newInnerHTML += '<input type="hidden" name="' + textareas[i].name + '" value="' + textareas[i].value + '">';

	}

	alert(newInnerHTML);
	destinationDoc.getElementById('hiddenFields').innerHTML=newInnerHTML;
	destinationDoc.processUserManagement.submit();
return false;
	//alert('originDocument('.originDocument.') destinationDocument('.destinationDocument.')' );

}


function checkMaxLength(thisElement)
{
	/*

		Restricts the maxlength of a textarea

		Usage: <textarea name="test" maxlength="255" onChange="checkMaxLength(this)" onKeyUp="checkMaxLength(this)">
	
	*/
	var maxLength = thisElement.getAttribute('maxlength');
	var elementValue = thisElement.value;
	var currentLength = elementValue.length;
	if (currentLength > maxLength)
	{
		alert('You have exceeded the maximum number of characters of ' + maxLength + ' allowed for this text field.');
		thisElement.value = (elementValue).substring(0,maxLength);
	}
}


function combinations(sourceArray, numInSet, setFunction, resultArray, setArray) 
{
	// create new result and set arrays if not given (trunk of tree)
	resultArray = (resultArray!=null) ? resultArray : [];
	setArray = (setArray!=null) ? setArray : [];

	// if top of tree, add set array (or result of set function if present)
	// to resultArray and return
	if (numInSet == 0)
	{
		resultArray[resultArray.length] = (setFunction != null)
											? setFunction(setArray) 
											: setArray;
		return resultArray;
	}
	
	// otherwise branch of tree, for each item in source array:
	// - duplicate source and set arrays
	// - remove item from new source array and add to new set array
	// - perform combinations() on new arrays (with decremented numInSet)
	for (var i = 0; i < sourceArray.length; i++)
	{
		var newSourceArray = Object.copy(sourceArray)
		var newSetArray = Object.copy(setArray)
		
		newSetArray[newSetArray.length] = Array.deleteItemAt(newSourceArray, i);
		
		combinations(newSourceArray, numInSet-1, setFunction, resultArray, newSetArray);
	}
	
	return resultArray;
}


function allCombinations(sourceArray, setFunction)
{
	var resultArray = []

	for (var numInSet = 1; numInSet <= sourceArray.length; numInSet++)
	{
		combinations(sourceArray, numInSet, setFunction, resultArray);
	}
	
	return resultArray;
}


Object.copy = function(oldObject, deep, newObject)
{
	if( typeof(oldObject) != 'object' || oldObject == null )
	{
		return oldObject;		
	} 
	
	var constructor = oldObject.constructor;
	
	switch (constructor)
	{			
		case String:
		case Number:
		case Boolean:
		case Date:
			return oldObject;
			 
	}

	if (!newObject)
	{
		if (!constructor)
		{
			constructor = Object;
		}

		newObject = new constructor();
	}

	var propName, propValue;	
	for (propName in oldObject)
	{
		propValue = oldObject[propName];

		try
		{
			newObject[propName] = (deep == null || deep)
				? Object.copy(propValue)
				: propValue;
		}
		catch (e){}
	}	
	
	return newObject;
}


Object.addInterface = function(object, anInterface)
{
	for (name in anInterface)
	{
		object[name] = anInterface[name];
	}
}


function Listeners(){}

Listeners.prototype = 
	Listeners_Interface = 
{
	getListeners: function()
	{
		if (!this._listeners)
		{
			this._listeners = [];
		}

		return this._listeners;
	},


	register: function(listener)
	{
		var listeners = this.getListeners();
		listeners.push(listener)
	},


	registerOnce: function(listener)
	{
		var listeners = this.getListeners();
		
		var callOnce = listener;
		var allListeners = this;
		var callAndDeredister = function(event)
		{
			var result = callOnce(event)
			allListeners.deregister(callAndDeredister);
			return result;
		}

		listeners.push(callAndDeredister);
	},

	deregister: function(listener)
	{
		var listeners = this.getListeners();
		Array.deleteItem(listeners, listener);
	},

	notifyListeners: function(event)
	{
		var listeners = this.getListeners();
		var resultArray = [];

		for ( var i=0 ; i < listeners.length ; i++ )
		{
			resultArray[resultArray.length] = listeners[i](event);
		}

		return resultArray;
	}

}

TypedListeners_Interface = 
{
	getEventTypes: function()
	{
		var listenerTypes = this.getListenerTypes();
		var eventTypes = [];

		for (eventType in listenerTypes)
		{
			eventTypes[eventTypes.length]
				= eventType;
		}

		return eventTypes;
	},


	getListenerTypes: function()
	{
		if (!this._listenerTypes)
		{
			this._listenerTypes = {};
		}

		return this._listenerTypes;
	},

	addListenerType: function()
	{
		var listenerTypes = this.getListenerTypes();
		var type, i;
		for (i = 0 ; i < arguments.length ; i++)
		{
			type = arguments[i]; 
			listenerTypes[type] = new Listeners();
		}	
	},

	register: function(type, listener)
	{
		var listenerTypes = this.getListenerTypes();

		listenerTypes[type].register(listener);

		if (listenerTypes['register'])
		{
			this.notifyListeners('register', listener)
		}
	},

	registerOnce: function(type, listener)
	{
		var listenerTypes = this.getListenerTypes();

		listenerTypes[type].registerOnce(listener);

		if (listenerTypes['register'])
		{
			this.notifyListeners('register', listener)
		}
	},

	deregister: function(type, listener)
	{
		var listenerTypes = this.getListenerTypes();

		listenerTypes[type].deregister(listener);

		if (listenerTypes['deregister'])
		{
			this.notifyListeners('deregister', listener)
		}
	},

	deregisterAll: function()
	{
		this.listenerTypes = {};
	},

	notifyListeners: function(type, event)
	{
		var listenerTypes = this.getListenerTypes();
		return listenerTypes[type].notifyListeners(event);
	},	
		
	
	_registerForward: function(type, toObject)
	{
		var listenerTypes = this.getListenerTypes();
		var object = toObject;;
					
		listenerTypes[type].register( function(event)
			{
				return object.notifyListeners(type, event)
			}
		)
	},
	
	
	forwardEvents: function(toObject)
	{
		var listenerTypes = this.getListenerTypes();

		// register forwarding function with all
		// listener types
		for (var type in listenerTypes)
		{
			this._registerForward(type, toObject);
		}

		// add toObject to forwardTo list
		var forwardTo = this._forwardTo;
		if (!forwardTo)
		{
			forwardTo = this.forwardTo = []
		}
		forwardTo[forwardTo.length] = toObject;
	}
}



function correctRect(element, parentWidth, parentHeight)
{
	if (!IS_IE)
	{
		return;
	}

	var width, height;

	if (!element)
	{
		element = document.body
		width = element.offsetWidth;
		height = element.offsetHeight;
	}
	else 
	{
		if (!parentWidth)
		{
			parentWidth = element.offsetParent.offsetWidth;
		}

		if (!parentHeight)
		{
			parentHeight = element.offsetParent.offsetHeight;
		}


		var css = ToolMan.css();
		var position = css.readStyle(element, 'position');

		if (position == 'relative' || position == 'absolute')
		{
			var left = css.readStyle(element, 'left'); 
			var right = css.readStyle(element, 'right');

			if ( left && left != 'auto'
					&& right && right != 'auto' )
			{
				left = parseInt(left) 
					+ css.getEdgeOffset(element, 'left', 'content');

				right = parseInt(right)
					- css.getEdgeOffset(element, 'right', 'content');

				width = parentWidth - left - right;
				element.style.width = width;

				//trace (element.tagName + ' id=' + element.id + ' w=' + width + ' l=' + left + ' r=' + right + ' pw=' + parentWidth)
			}
				
			var top = css.readStyle(element, 'top'); 
			var bottom = css.readStyle(element, 'bottom');
			if ( top && top != 'auto'
					&& bottom && bottom != 'auto' )
			{
				top = parseInt(top);
					+ css.getEdgeOffset(element, 'top', 'content');

				bottom = parseInt(bottom);
					+ css.getEdgeOffset(element, 'bottom', 'content');

				height = parentHeight - top - bottom;
				element.style.height = height + 'px'

				//trace (element.tagName + ' id=' + element.id + ' h=' + height + ' t=' + top + ' b=' + bottom + ' ph=' + parentHeight)
			}
		}
	}


	for (var i=0 ; i < element.children.length ; i++)
	{
		correctRect(element.children[i], width, height);
	}
	
}

function hideShow(areaId, headerTxt) 
{
	var area = document.getElementById(areaId);
	var img = document.getElementById(areaId + '_img');
	//var viewState = document.getElementById(areaId + '_viewState');
	
	if (area && img)
	{
		if (area.style.display == 'none')
		{
			area.style.display = 'block';
			area.style.overflow = 'visible';
			img.src  = '/tcs/images/minimise.gif';
			img.alt = 'Hide ' + headerTxt + ' Area';
			//viewState.value = 'block';
			//viewState.value = 'hidden';
		}
		else
		{
			area.style.display = 'none';
			area.style.overflow = 'auto';
			img.src = '/tcs/images/maximise.gif';
			img.alt = 'Show ' + headerTxt + ' Area';
			//viewState.value = 'none';
			//viewState.value = 'hidden';
		}
	}
}

var gNumRows = 0;

function GenerateCollapsibleSection(id,heading,body)
{
	gNumRows = 0;
	returnHTML = '<span id="' + id + '_span">';
	returnHTML += getCollapsibleHeader(id, heading,'/tcs/images/');
	returnHTML += body;
	returnHTML += getTableFooter();
	returnHTML += '</span>';
	return returnHTML;
}


function getCollapsibleHeader(id, heading, imageFolder)
{
	gNumRows = 0;

	var returnHTML = '<table cellspacing="0" class="collapsibleHeader">';
	returnHTML += '	<tr onClick="hideShow(\'' + id + '\', \'' + heading + '\');">';
	returnHTML += '		<th>';
	returnHTML += '			<img id="' + id + '_img" src="' + imageFolder + 'minimise.gif"><span class="heading">&nbsp;' + heading + '</span>';
	returnHTML += '		</th>';
	returnHTML += '	</tr>';
	returnHTML += '</table>';
	returnHTML += '<div class="collapsible" id="' + id + '">';
	returnHTML += '	<table cellspacing="0" class="collapsibleContent">';

	return returnHTML;
}
function getNonCollapsibleHeader(heading)
{
	gNumRows = 0;

	var returnHTML = '<table cellspacing="0" class="collapsibleHeader">';
	returnHTML += '	<tr>';
	returnHTML += '		<th>';
	returnHTML += '			<span class="heading">&nbsp;' + heading + '</span>';
	returnHTML += '		</th>';
	returnHTML += '	</tr>';
	returnHTML += '</table>';
	returnHTML += '<div class="collapsible">';
	returnHTML += '	<table cellspacing="0" class="collapsibleContent">';

	return returnHTML;
}

function getTableFooter()
{
	var returnHTML = '	</table>';
	returnHTML += '</div><br>';

	return returnHTML;
}

function getTableRow(leftHTML, rightHTML, leftWidth, rightWidth)
{
	if(!leftWidth) leftWidth = '20';
	if(!rightWidth) rightWidth = '80';
	var returnHTML = '';

	returnHTML += '<tr bgcolor="' + getRowColour(gNumRows) + '">';
	returnHTML += '	<td class="leftSide" height="22" width="' + leftWidth + '%">';
	returnHTML += leftHTML;
	returnHTML += '	</td>';
	returnHTML += '	<td width="' + rightWidth + '%">';
	returnHTML += rightHTML;
	returnHTML += '	</td>';
	returnHTML += '</tr>';

	gNumRows++;

	return returnHTML;
}

function getTableRowColspan(contentHTML)
{
	var returnHTML = '';

	returnHTML += '<tr bgcolor="' + getRowColour(gNumRows) + '">';
	returnHTML += '	<td class="leftSide" colspan="2">';
	returnHTML += contentHTML;
	returnHTML += '	</td>';
	returnHTML += '</tr>';

	gNumRows++;

	return returnHTML;
}

function getTableRow4Columns(leftHTML, leftMiddleHTML, rightMiddleHTML, rightHTML)
{
	var returnHTML = '';

	returnHTML += '<tr bgcolor="' + getRowColour(gNumRows) + '">';
	returnHTML += '	<td class="leftSide">';
	returnHTML += leftHTML;
	returnHTML += '	</td>';
	returnHTML += '	<td class="leftSide">';
	returnHTML += leftMiddleHTML;
	returnHTML += '	</td>';
	returnHTML += '	<td class="leftSide">';
	returnHTML += rightMiddleHTML;
	returnHTML += '	</td>';
	returnHTML += '	<td>';
	returnHTML += rightHTML;
	returnHTML += '	</td>';
	returnHTML += '</tr>';

	gNumRows++;

	return returnHTML;
}

function getRowColour(numRows)
{
	var rowBgcolor = "white";
	if (numRows % 2 == 1)
	{
		rowBgcolor = "#F4F8FA";
	}

	return rowBgcolor;
}