//All Javascript

function gaevt(Category,Action,Label,Value) {
	//console.log("gaevt: "+Category+":"+Action+":"+Label+":"+Value);
	if (typeof ga==="function") {
		try {
			var iValue=0;
			if(Value) iValue=Value;

			//replace commas
			var sCategory=replaceAllSubstrings(Category,","," ");
			var sAction=replaceAllSubstrings(Action,","," ");
			sAction=replaceAllSubstrings(sAction,"\x27"," ");
			sAction=replaceAllSubstrings(sAction,"\x22"," ");
			var sLabel=replaceAllSubstrings(Label,","," ");
			sLabel=replaceAllSubstrings(sLabel,"\x27"," ");
			sLabel=replaceAllSubstrings(sLabel,"\x22"," ");
			var sFunc="ga('send','event','"+sCategory+"','"+sAction+"','"+sLabel+"','"+iValue+"')";
			//appendToLog(sFunc);
			setTimeout(sFunc,100);
		}
		catch(e) {
			appendToLog("Error in gaevt: "+e.message);
		};
	}
	else {
		appendToLog("Error in gaevt: ga is undefined");
	};
};

function initVideoListeners(eVideo) {
	eVideo.addEventListener('ended', videoEnd, false)
	eVideo.addEventListener('timeupdate', videoTimeUpdate, false)
	eVideo.addEventListener('play', videoPlay, false)
	eVideo.addEventListener('pause', videoPause, false)
}

function getVideoTitle(e) {
	var s=e.getAttribute("title");
	if(s) return(s);
	return("Untitled");
};

function getVideoID(e) {
	var s=e.getAttribute("VideoID");
	if(s) return(s);
	return("Undefined");
};

function setKeyFrames(duration) {
	var quarter=(duration / 4).toFixed(1)
	sessionStorage.setItem('one', quarter)
	sessionStorage.setItem('two', (quarter * 2).toFixed(1))
	sessionStorage.setItem('three', (quarter * 3).toFixed(1))
}

function videoTimeUpdate() {
	var curTime=this.currentTime.toFixed(1)
	switch (curTime) {
		case sessionStorage.getItem('one'):
			gaevt('video','25% played',getVideoID(this)+"|"+getVideoTitle(this));
			sessionStorage.setItem('one', null);
			break;
		case sessionStorage.getItem('two'):
			gaevt('video','50% played',getVideoID(this)+"|"+getVideoTitle(this));
			sessionStorage.setItem('two', null);
			break;
		case sessionStorage.getItem('three'):
			gaevt('video','75% played',getVideoID(this)+"|"+getVideoTitle(this));
			sessionStorage.setItem('three', null);
			break;
	}
}

function videoEnd() {
	gaevt('video','100% played',getVideoID(this)+"|"+getVideoTitle(this));
}

function videoPlay() {
	gaevt('video','play',getVideoID(this)+"|"+getVideoTitle(this));
	setKeyFrames(this.duration)
}

function videoPause() {
	gaevt('video','pause',getVideoID(this)+"|"+getVideoTitle(this));
}	

/******************************************************************
Closed the select file dialog by removing the div containing the 
dialog.  The additional div created by the selectFile() function is 
also removed, so the cleanup is complete.
******************************************************************/
function closeSelectFileDialog(salt,fnCancel) {
	var e=document.getElementById(salt+"SelectFile");
	appendToLog("e.id="+e.id);
	eParent=e.parentNode;
	eParent.removeChild(e);
	if(eParent.getAttribute("removeme")) {
		eParent.parentNode.removeChild(eParent);
	};
	if(fnCancel) eval(fnCancel+"('"+salt+"')");
};

/******************************************************************
Called when the user clicks the select button in the dialog used
to select a file or directory
******************************************************************/
function fileSelected(salt,fnOk) {
	var sFilename=document.getElementById(salt+"SelectFileFileSpec").value;
	closeSelectFileDialog(salt);
	sFilename=replaceAllSubstrings(sFilename,"\\","\\\\");
	if(fnOk) eval(fnOk+"('"+salt+"','"+sFilename+"')");
};

/******************************************************************
Displays a dialog used to select a file or directory.
Params:
	Salt - An identifier that is included with the filename when a selection
			has been made.  The function called is fnOk(Salt,Filename)
	e - An element beneath which the dialog will be displayed.  If null,
			the dialog is centered and 100px down from the top of the page
	Filespec - The default filename or directory
	Select - Either File or Directory
	Exists - If true, the user must select from a list of files and directories.
			If false, the user may type a name, including the name of a file or 
			directory that does not exist.
	fnOk - Name of a javascript function that will be called when the user makes
			a selection.  This is only the function name.  The function will be 
			called using fnOK(Filespec)
	fnCancel - Name of a javascript function to be called if the user closes the 
			dialog without making a selection.
	Center - If true, the dialog will be centered horizontally
	Top - Top position offset
	Left - Left position offset.  The value "center" can be used to center the 
			dialog horizontally.
	Source - HashID of the computer used to process the request
******************************************************************/
function selectFile(Salt,Filespec,Select,Exists,fnOk,fnCancel,Top,Left,Source) {
	var eDiv=document.createElement("div");
	eDiv.id="selectFile"+getSalt(4);
	eDiv.setAttribute("RemoveMe","true");
	eDiv.setAttribute("class","select_file_dialog");

	document.body.appendChild(eDiv);

	var L=0;
	if(typeof(Left)=="string") {
		if(Left.equalsIgnoreCase("center")) {
			var iDivWidth=Math.min(window.outerWidth,550);
			L=Math.max(0,window.outerWidth/2 - iDivWidth/2);
		};
	}
	else {
		L=Left;
	};

	if(Top>=0) eDiv.style.top=Top+"px";
	if(L>=0) eDiv.style.left=L+"px";

	sUrl=getServer()+"/?Network=GreenLight&ID=getWidget&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em";
	sUrl +="&Widget=Notification Container 2&ContainerItemID=648693";
	sUrl +="&Salt="+Salt+"&Filespec="+Filespec+"&Select="+Select+"&Exists="+Exists;
	sUrl +="&FnOk="+fnOk+"&FnCancel="+fnCancel;
	sUrl +="&Source="+Source;
	asynchInclude(eDiv,sUrl,"","");
};

var PositionLatitude=0.0;
var PositionLongitude=0.0;
var PositionAccuracy=0.0;
var PositionAltitude=0.0;
var PositionAltitudeAccuracy=0.0;
var PositionHeading=0;
var PositionSpeed=0;
var PositionTimestamp=0;

function watchPosition() {
	if (navigator.geolocation) {
		navigator.geolocation.watchPosition(updateSharedLocationValues);
	} 
	else {
		appendToLog("Geolocation is not supported by this browser.");
	}
};

function getCurrentPosition() {
	if (navigator.geolocation) {
		navigator.geolocation.getCurrentPosition(updateSharedLocationValues);
	} 
	else {
		appendToLog("Geolocation is not supported by this browser.");
	}
}

function updateSharedLocationValues(position) {
  //alert("Latitude: "+position.coords.latitude+" Longitude: "+position.coords.longitude);
	if(!position) {
		alert("position is undefined");
		return;
	};

	PositionLatitude=position.coords.latitude;
	PositionLongitude=position.coords.longitude;
	PositionAccuracy=position.coords.accuracy;
	PositionAltitude=position.coords.altitude;
	PositionAltitudeAccuracy=position.coords.altitudeAccuracy;
	PositionHeading=position.coords.heading;
	PositionSpeed=position.coords.speed;
	PositionTimestamp=position.coords.timestamp;
}

function getLatitude() {return(PositionLatitude)};
function getLongitude() {return(PositionLongitude)};
function getPositionAccuraryMeters() {return(PositionAccuracy)};
function getPositionAccuraryFeet() {return(PositionAccuracy*3.28084)};
function getPositionAltitudeMeters() {return(PositionAltitude)};
function getPositionAltitudeFeet() {return(PositionAltitude*3.28084)};
function getPositionAltitudeAccuracyMeters() {return(PositionAltitudeAccuracy)};
function getPositionAltitudeAccuracyFeet() {return(PositionAltitudeAccuracy*3.28084)};

function getPositionHeading() {
	if(isNaN(PositionHeading)) return(-1);
	return(PositionHeading)
};

function getPositionSpeedMetersPerSecond() {
	if(isNaN(PositionSpeed)) return(-1);
	{return(PositionSpeed)};
};

function getPositionSpeedMilesPerHour() {
	if(isNaN(PositionSpeed)) return(-1);
	return(PositionSpeed*3.28084/60/60);
};

function getPositionTimestamp() {
	return(PositionTimestamp);
};




/******************************************************************************************************
FUNCTIONS USED TO DISPLAY SYSTEM DIALOG

The showDialog function is called to display the dialog.  params is a & delimited string of 
arguments.  The following arguments can be defined:

icon - If the value is true, a status icon is displayed before the message
msg - the message to be displayed.  
ProgressMax - If specified, a progress bar wll be displayed with a value of ProgressMax
ProgressToken - Must be specified when ProgressMax is defined.  This is a token that wlil be 
	requested at a 1 second interval to update the progress bar.  The token can contain a single 
	number indicating the number of steps (out of max) completed so far or it can be a pipe-delimited 
	string that contains the number followed by a new message to be displayed in the dialog.

Currently ProgressMax and ProgressToken only work when the token is defined on the machine 
	specified by getServer() (i.e. the local computer)

(these arguments cause a button to be displayed when defined.  The argument defines the
 function to be called when the button is pressed.  For example fnOK=myfunction()&fnCancel=
 The value can also be 'close' which will just hide the dialog without calling a function
fnOk
fnYes
fnNo
fnCancel
fnOther1 - Pass a value in Other1 to set the label of the button
fnOther2 - ""			    
fnOther3 - ""			    

Quotes can be included in the function definitions by using $q

examples:
showDialog('icon=true&msg=this is a test')
showDialog('icon=true&msg=this is a test&top=200&left=200&width=400&height=100')
showDialog('icon=true&msg=this is a test&fnOk=alert($qtest$q)&fnCancel=close')
showDialog('icon=true&msg=this is a test&fnOk=alert($qtest$q)&fnOther1=alert($qOther$q)&Other1=Other&fnCancel=close')
showDialog('close')
******************************************************************************************************/
var bShowingSystemDialog=false;

function showDialog(params)
{
	//always close the dialog to avoid multiple ones being opened 
	var e=document.getElementById("SystemDialog");
	if(e) document.body.removeChild(e);

	//if no params were passed, just exit after closing the dialog
	if(!params) return;
	
	var d=document.createElement('div');
	d.id="SystemDialog";
	
	d.style.zIndex=99;
	d.className="showdialog";
	//d.style.width=(bIsMobileDevice) ? "270px" : "300px";
	d.style.width="75%";
	d.style.maxWidth="300px";
	
	var bTopSpecified=false;
	var bLeftSpecified=false;

	var arCommands=new Array("ICON","MSG","LEFT","TOP","WIDTH","HEIGHT","FNOK","FNYES","FNNO","FNCANCEL","FNOTHER1","FNOTHER2","FNOTHER3","POSITION","MAX-WIDTH","PROGRESSMAX","PROGRESSTOKEN");
	aParams=getSubStringArray(params,"&",true);
	var bAddProgressBar=false;
	var ProgressMax=0;
	var sProgressToken="";
	for (var i=0;i<aParams.length;i++) {
		var n=aParams[i].indexOf("=");
		if(n>0) {
			var sName=aParams[i].substring(0,n);
			var sNameUpper=sName.toUpperCase();
			var sValue=aParams[i].substring(n+1);
			if(sValue.equalsIgnoreCase("close")) sValue="showDialog()";
			
			var iCommand=-1;
			for (var j=0;j<arCommands.length;j++) {
				//alert("j="+j+" arCommands[j]="+arCommands[j]);
				if(sName.equalsIgnoreCase(arCommands[j])) iCommand=j;
			};
			
			//alert("sName="+sName+" sValue="+sValue+" iCommand="+iCommand+" len="+arCommands.length);
			switch(iCommand) {
				case  0:	//icon
									var img=new Image();
									bAddProgressBar=true;
									break;
				case  1:	//msg
									var t=document.createElement("span");
									t.id="SystemDialogMsg";
									t.innerHTML=sValue;
									d.appendChild(t);
									break;
				case  2:	//left
									d.style.left=sValue;
									bLeftSpecified=true;
									break;
				case  3:	//top
									d.style.top=sValue;			
									bTopSpecified=true;
									break;
				case  4:	//width
									d.style.width=replaceAllSubstrings(sValue,"pcnt","%");
									break;
				case  5:	//height
									d.style.height=sValue;
									break;
				case  6:	//fnok
				case  7:	//fnyes
				case  8:	//fnno
				case  9:	//fncancel
									var b=document.createElement("input");
									b.setAttribute('type','button');
									b.setAttribute('name',sName.substring(2));
									b.setAttribute('value',sName.substring(2));
									b.setAttribute('class',"systemdialogbutton");
									b.setAttribute("onclick",sValue);	//this works for firefox
									b.onclick=Function(sValue);		//this works for IE
									d.appendChild(b);
									break;
				case 10:	//fnother1
				case 11:	//fnother2
				case 12:	//fnother3
									break;
				case 13: 	//position
									d.style.position=sValue;
									break;
				case 14: 	//max-width
									d.style.maxWidth=replaceAllSubstrings(sValue,"pcnt","%");
									break;
				case 15:	//ProgressMax
									ProgressMax=parseInt(sValue);
									break;
				case 16:	//ProgressToken
									sProgressToken=sValue;
									break;
			};
		};
	};

	//add the progress bar after all other elements
	if((bAddProgressBar) || (ProgressMax>0)) {
		var eProgress=document.createElement("progress");
		eProgress.id="SystemDialogProgress";
		eProgress.style.width="100%";
		if(ProgressMax>0) {
			eProgress.setAttribute("max",ProgressMax);
			eProgress.setAttribute("value",0);
		};
		d.appendChild(eProgress);
	};

	document.body.appendChild(d);

	//set top and left position if not specified
	if(!bLeftSpecified) {
		//position in the middle of the screen
		var Middle=document.body.offsetWidth/2 - d.offsetWidth/2;
		d.style.left=Middle+"px";
	};

	if(!bTopSpecified) {
		d.style.top="100px";
	};

	//if a progress token and max value have been specified, call the function to update the progress bar
	if((ProgressMax>0) && (sProgressToken.length>0)) {
		var sUrl=getServer()+"/?Network=greenlight&id=eval&expression=getToken("+sProgressToken+")";
		var sFunc="updateDialog('"+sProgressToken+"',s)";
		setTimeout("asynchInclude(null,\""+sUrl+"\",\""+sFunc+"\",\""+sFunc+"\");",1000);
	};
};

/************************************************************************
This function is called by showDialog when a progress bar has been specified 
using ProgressMax and ProgressToken.  This function makes a request to the 
server for the given token and then updates the dialog.  The token is a 
number indicating the number of steps (out of max steps) completed.  It can 
also be of the form [steps completed]|[message] which will also update the 
message in the dialog.
************************************************************************/
function updateDialog(_progresstoken,_tokenvalue) {
	//return if the dialog has been closed
	var eDialog=document.getElementById("SystemDialog");
	if(!eDialog) {
		return;
	};
	
	if(_tokenvalue) {
		var iValue=0;
		var sMsg="";

		sTokenValue=_tokenvalue.trim();

		if(sTokenValue.length>0) {
			var n=sTokenValue.indexOf("|");
			if(n<0) {
				iValue=parseInt(sTokenValue);
			}
			else {
				iValue=parseInt(sTokenValue.substring(0,n));
				sMsg=sTokenValue.substring(n+1);
			};

			if(sMsg.length>0) {
				var eMsg=document.getElementById("SystemDialogMsg");
				eMsg.innerHTML=sMsg;
			};

			if(!isNaN(iValue)) {
				var eProgress=document.getElementById("SystemDialogProgress");
				if(eProgress) eProgress.value=iValue;
			};
		};

		var sUrl=getServer()+"/?Network=greenlight&id=eval&expression=getToken("+_progresstoken+")";
		var sFunc="updateDialog('"+_progresstoken+"',s)";
		setTimeout("asynchInclude(null,\""+sUrl+"\",\""+sFunc+"\",\""+sFunc+"\");",1000);
	};
	
};

function showDialogSub(t,top,left,width,height)
{
	//appendToLog("showDialogSub");
	bShowingSystemDialog=false;
	var e=document.getElementById("SystemDialogContainer");
	if(!e) {
		e=document.createElement("div");
		e.id="SystemDialogContainer";
		document.body.appendChild(e);
	};

	e.style.zIndex=99;
	e.innerHTML=t;

	var e2=document.getElementById("SystemDialog");
	if(e2) {
		(top==0) ? e2.style.top="100px" : e2.style.top=top+"px";
		(left==0) ? e2.style.left="100px" : e2.style.left=left+"px";
		(width==0) ? e2.style.width="300px" : e2.style.width=width+"px";
		(height==0) ? e2.style.height="auto" : e2.style.height=height+"px";
	};
	setVisible(e,true);
};

function oldshowDialog(params,count) {
	//appendToLog("showDialog params="+params+" count="+count);

	if(!params) {
		//If the system dialog is still initializing, then wait 1 second and try again to hide it
		//Otherwise, the dialog will not be hidden if the dialog is shown and then hidden before it becomes visible
		(bShowingSystemDialog) ? setTimeout("showDialog()",1000) : setVisible("SystemDialogContainer",false);
		return;
	};

	bShowingSystemDialog=false;

	//var strUrl="http://127.0.0.1:4446/?Network=GreenLight&ID=getCachedWidget&DocumentID=77NaWu0FhKDKXL7C70JpnKmy&Widget=HTML Status Message";
	var strUrl=getServer()+"/?Network=GreenLight&ID=getCachedWidget&DocumentID=77NaWu0FhKDKXL7C70JpnKmy&Widget=HTML Status Message";
	if (params) strUrl +="&"+params;

	//Try to load the dialog up to 5 times if an error occurs
	//Count will only be defined if an error has occurred in asynchInclude
	var n=0;
	if(count) {
		if(count>5) {
			alert("An error has occurred.	Please refresh the page.");
			return;
		};
		n=count+1;
		setTimeout("showDialog(\""+params+"\","+n+")",1000);
		return;
	};

	var t=getElementValue(params,"top","&");
	var l=getElementValue(params,"left","&");
	var w=getElementValue(params,"width","&");
	var h=getElementValue(params,"height","&");

	(t.length>0) ? t=parseInt(t) : t=0;
	(l.length>0) ? l=parseInt(l) : l=0;
	(w.length>0) ? w=parseInt(w) : w=0;
	(h.length>0) ? h=parseInt(h) : h=0;

	var sFuncOk="showDialogSub(req.responseText,"+t+","+l+","+w+","+h+")";
	var sFuncErr="showDialog(\""+params+"\",1)";
	bShowingSystemDialog=true;
	asynchInclude(null,strUrl,sFuncOk,sFuncErr);
};




/******************************************************************************************************
FUNCTIONS USED FOR DROP-DOWN MENUS
******************************************************************************************************/
var timerDropDownMenu=null;

// open drop-down list
function menuOpen(id) {	
	menuCancelTimeout();
	menuCloseAll();
	setVisible(id,true);
};

// close drop-down list
function menuCloseAll() {
	var arMenu=document.getElementsByTagName("div");
	for (var i=0;i<arMenu.length;i++) {
		if (arMenu[i].getAttribute("isMenu")) setVisible(arMenu[i],false);
	};
};

//go close timer
function menuSetTimeout()	{
	//The timeout here is important.  If it is too short, the menu will disappear in IE before the mouse is moved to a selection
	timerDropDownMenu=window.setTimeout("menuCloseAll()",500);
};

// cancel close timer
function menuCancelTimeout() {
	if(timerDropDownMenu) {
		window.clearTimeout(timerDropDownMenu);
		timerDropDownMenu=null;
	};
};



/******************************************************************************
Called on mobile devices to focus the given dialog and hide all the others.  The
current state is recorded so it can be restord.  Called for dialogs used to
edit records in a table and for display dialogs.  Allows for dialogs to be opened
on top of each other.  For example, a dialog used to edit a record may contain
a table with a display dialog and an edit-record dialog.

Information about the current state of all divs is recorded in a string and added to the
arFocusDialog array which acts like a stack.  When the dialog is closed, the string
is pulled from and the state of all divs is restored.  The defocusDialog() function is 
caled to restore the state of the divs.
******************************************************************************/
var arFocusDialog=new Array();
var bInFocusDialog=false;

function focusDialog(ID)
{
	bInFocusDialog=true;
	location.hash="#edit";

	//The first two elements in the string are the dialog ID and the y position of the document
	s=ID+"|"+window.scrollY;;
	var sDebug="";
	
	//add information about the remaining divs
	var arDiv=document.getElementsByTagName("div");
	for (var i=0;i<arDiv.length;i++) {
		if((boolVal(arDiv[i].getAttribute("isItem"))) || (arDiv[i].getAttribute("IsMobileDialog"))) {
			if(!arDiv[i].id.equalsIgnoreCase(ID)) {
				if(isVisible(arDiv[i])) {
					s+="|"+arDiv[i].id+"=true";
					setVisible(arDiv[i],false);
					sDebug+="Hide "+arDiv[i].id+"\r\n";
				}
				else {
					s+="|"+arDiv[i].id+"=false";
				};
			};
		};
	};
	arFocusDialog[arFocusDialog.length]=s;
	sDebug +="Show "+ID+"=true\r\n"
	
	//add an attribute that can be used in the loop above to identify divs that are not items but that should be hidden.
	//This happens when a dialog is opened to edit a record and the dialog contains a table.  When the display options
	//are opened in the tablr or a record is edited, the edit dialog opened from the first table will have been moved
	//to the body and it will no longer be inside a container item.  This attibute is used to hide dialogs like these
	//that have been opened on the way to tue current dialog.
	document.getElementById(ID).setAttribute("IsMobileDialog","true");
	setVisible(ID,true);
	
	sDebug +="arFocusDialog length="+arFocusDialog.length+"\r\n";
	//sDebug +="arFocusDialog["+(arFocusDialog.length-1)+"]="+arFocusDialog[arFocusDialog.length-1]+"\r\n";
	//alert(sDebug);
	//appendToLog(sDebug,false,true);
	bInFocusDialog=false;
};

function defocusDialog()
{
	//abort if this is being called by hashChange when the location is set in focusDialog
	if(bInFocusDialog) return;
	
	//abort if there are no records in arFocusDialog
	if(arFocusDialog.length==0) {
		appendToLog("deFocusDialog Error: length=0",false,true);
		return;
	};
	
	//get the last string recorded in arFocusDialog
	var sDebug="defocusDialog restoring "+arFocusDialog[arFocusDialog.length-1]+"\r\n";
	var a=getSubStringArray(arFocusDialog[arFocusDialog.length-1],"|",true);
	
	//the ID of the dialog is the first element in the array
	sDebug +="defocusDialog setVisible "+a[0]+"=false\r\n";
	setVisible(a[0],false);

	//restore the y position
	sDebug +="defocusDialog scrollto "+parseInt(a[1])+"\r\n";
	window.scrollTo(0,parseInt(a[1]));

	//restore the visibility of the remaining items
	for(var i=2;i<a.length;i++) {
		var n=a[i].indexOf("=");
		var sID=a[i].substring(0,n);
		var bVisible=boolVal(a[i].substring(n+1));
		sDebug +="Show "+sID+"="+bVisible+"\r\n";
		setVisible(sID,bVisible);
	};
	
	//remove the string from the array
	arFocusDialog.length--;

	//alert(sDebug);
	//appendToLog(sDebug,false,true);
};

/******************************************************************************
Called when the edit dialog is closed on a mobile device by pressing the back button
This is implemented by onhashchange="hashChange()" in the body element of the widget
container.  When the dialog is displayed, #edit is added to window.location.  When the 
back button is pressed, the location no longer contains #edit.

This function is not called when the close icon in the top right of a dialog is clicked 
to close the dialog.  Instead, the defocusDialog function is called directly.
******************************************************************************/
function hashChange()
{
	var sLocation=window.location.toString().toUpperCase();
	if(sLocation.indexOf("EDIT")<=0) defocusDialog();
	
	if(false) {
		if(sLocation.toUpperCase().indexOf("EDIT")<=0) {
			var arDiv=document.getElementsByTagName("div");
			for (var i=0;i<arDiv.length;i++) {
				if(arDiv[i].getAttribute("hideafteredit")=="true") {
					setVisible(arDiv[i],false);
				}
				else if(arDiv[i].getAttribute("ShowAfterEdit")=="true") {
					setVisible(arDiv[i],true);
				};
			};
			
			window.scrollTo(0,document.body.getAttribute('RestoreScrollTop'));
		};
	};
};

/******************************************************************************
Opens the edit dialog for a selected row in a table.
******************************************************************************/
function showTableEditDialogForRow(table,RowIndex)
{
	if(!table) {
		alert("Error: showTableEditDialogForRow: Invalid table");
		return;
	};

	//verify that the RowIndex is in bounds
	if((!RowIndex) || (RowIndex<0) || (RowIndex>=table.rows.size)) {
		alert("Error: showTableEditDialogForRow: Invalid RowIndex: "+RowIndex);
		printStackTrace();
		return;
	};

	//record metadata for the table including HashID, DriverID, etc. so data can be submitted
	//even if the table is closed before the data is submitted
	recordTableMetadata(table.getAttribute("ID"));
	
	for(var i=0;i<table.rows[RowIndex].cells.length;i++) {
		var sName=table.rows[RowIndex].cells[i].getAttribute("name");
		if((sName) && (sName.equalsIgnoreCase("editrecord"))) {
			//alert("showing dialog");
			showTableEditDialog(table.rows[RowIndex].cells[i]);
			return;
		};
	};

	//alert("could not find dialog TD");
};

/******************************************************************************
Opens the edit dialog for a record in a table.  e is the icon clicked to being editing.
******************************************************************************/
function showTableEditDialog(e)
{
	//the td element is passed when a cell is clicked in a mobile document
	var td=e;

	//if it isn't a td in a mobile document, it's content inside the td
	if(td.nodeName.equalsIgnoreCase("td")==false) td=e.parentNode;
	
	//if the parent is not a td, look one more level up.  This is used when the function is called by clicking on a field
	//in the table instead of the normal edit icon included in the table.  The field looks like <td><text><span onClick=xxx></span></text></td>
	if(td.nodeName.equalsIgnoreCase("td")==false) td=td.parentNode;
	
	var tr=td.parentNode;
	var tbody=tr.parentNode;
	var table=tbody.parentNode;
	if(table.nodeName.equalsIgnoreCase("table")==false) {
		alert("Error reading driver information");
		return;
	};

	var sTableID=table.getAttribute("ID");
	var sDialogID=table.getAttribute("EditDialogID");
appendToLog("showTableEditDialog sTableID="+sTableID);
	//abort if the row is currently being deleted
	var sDeleted=tr.getAttribute("deleted");
	if((sDeleted) && (sDeleted.equalsIgnoreCase("true"))) {
		appendToLog("showTableEditDialog: Aborted because record is being deleted");
		setVisible(sDialogID,false);
		return;
	};
	
	//record metadata for the table including HashID, DriverID, etc. so data can be submitted
	//even if the table is closed before the data is submitted
	recordTableMetadata(table.getAttribute("ID"));
	
	//initialize the dialog header.  It is initially outside the dialog div and needs to be
	//moved inside the div
	initializeTableDialogHeader(sTableID,sDialogID,tr.getAttribute("KeyValue"));
	
	//hide the disable div 
	if(document.getElementById("EditDialogDisable"+sTableID)) setVisible("EditDialogDisable"+sTableID,false);
	
	//get array of all field ID's and field types from the table header
	sAllFieldID=table.getAttribute("aspectAllFieldID");
	sAllFieldType=table.getAttribute("aspectAllFieldType");
	if((sAllFieldID==null) || (sAllFieldType==null)) {
		alert("No fields included for editing");
		return;
	};
	
	var arFieldID=getSubStringArray(sAllFieldID,",",true);
	var arFieldType=getSubStringArray(sAllFieldType,",",true);

	//get array of all values from the row
	var arValues=getSubStringArray(getAttr(tr,"aspectAllValues"),",",true);
	for(var i=0;i<arValues.length;i++) {
		arValues[i]=tokenizeTableValue(arValues[i],false);
	};

	//set value of all elements in the dialog
	var div=document.getElementById(sDialogID);
	if(!div) {
		alert("Cannot locate dialog: "+sDialogID);
		return;
	};

	var arRefresh=setDialogValues(sTableID,div,arFieldID,arValues);

	//set the table ID and KeyValue in the dialog
	div.setAttribute("TableID",sTableID);
	div.setAttribute("KeyValue",tr.getAttribute("KeyValue"));

	//if it's a mobile device...
	if(bIsMobileDevice) {
		div.parentNode.removeChild(div);
		document.body.appendChild(div);
		
		//Hide all divs on the page and display the dialog.  
		focusDialog(div.id);
		
		/*
			09-18-2015: Don't know why this is disabled.  It may be better to record Informaiton about the scroll position
			of divs in the focusDialog() function
		*/
		if(false) {
			//record the current scrolling position of the page so it can be restored when the dialog is closed
			var iScrollTop=0;
			//iScrollTop=document.pageYOffset;
			iScrollTop=window.scrollY;
			//iScrollTop=document.body.scrollTop;
			//iScrollTop=document.html.scrollTop;
			//iScrollTop=document.documentElement.scrollTop;
			
			appendToLog("iScrollTop="+iScrollTop,false,true);
			
			document.body.setAttribute("RestoreScrollTop",iScrollTop);
			//document.body.setAttribute("RestoreScrollTop",document.body.scrollTop);
			//document.body.setAttribute("RestoreScrollLeft",document.body.scrollLeft);

			//move the dialog to the body element
			div.parentNode.removeChild(div);
			document.body.appendChild(div);
			
			//Hide all other divs.  Set an attribute to indicate the items that should be 
			//displayed when the dialog is closed
			var arDiv=document.getElementsByTagName("div");
			for (var i=0;i<arDiv.length;i++) {
				if (boolVal(arDiv[i].getAttribute("isItem"))) {
					if(isVisible(arDiv[i])) {
						arDiv[i].setAttribute("ShowAfterEdit","true");
						setVisible(arDiv[i],false);
					}
					else {
						arDiv[i].setAttribute("ShowAfterEdit","false");
					};
				};
			};
			
			//set an attribute in the dialog used to identify and hide the dialog
			div.setAttribute("HideAfterEdit","true");
		};
	};
	
	//10-09-2015 Moved setVisible here so the width of the dialog can be calculated
	//before positioning it horizontally
	setVisible(sDialogID,true);
	
	//02-27-2017: Added IsAspectDialog attribute to provide a clean way to locate a dialog div.
	div.setAttribute("isAspectDialog","true");

	//make sure the dialog is positioned
	if(bIsMobileDevice) {
		div.style.position="absolute";
		div.style.left="0px";
		div.style.top="0px";
	}
	else {
		//position the dialog for desktop browsers.  Use either "fixed" or "absolute" positioning.  
		//They both position the dialog immediately to the right of the edit icon.  Fixed 
		//positioning displays the dialog without requiring it to fit within the parent div.  
		//The dialog is displayed over the parent div and can be any size.  Absolute positioning 
		//displays the dialog in the constraints of the parent div's boundaries and it may be 
		//chopped off.  Absolute positioning must be used on mobile devices, otherwise the dialog 
		//will not scroll and it is not possible to move it to view the input fields when the 
		//devices keyboard is displayed.  May need to add the ability to specify when a dialog 
		//should be fixed or absolute.  Could include an attribute in the dialog div
		var sMethod="absolute";
		div.style.position=sMethod;
		//var xy=getPosition2012(e,sMethod,div.parentNode);
		var xy=getPosition2012(e,sMethod,div.parentNode);
		if(isMobileDevice()) {
			div.style.left="0px";
			div.style.top=xy[1]+"px";
		}
		else {
			//div.style.left=xy[0]+"px";

			div.style.left=0;

			//center the dialog if the table width is greater than the dialog width
			var maxwidth=Math.min(documentWidth(),table.tBodies[0].offsetWidth);
			if(maxwidth>div.offsetWidth) {
				//don't shift the dialog toward the center if the left position will be small.
				//Otherwise, a small (e.g. 9px) margin can be introduced for small screens.
				//Might have something to do with the scroll bar
				var left=Math.min(250,(maxwidth-div.offsetWidth)/2);
				if(left>20) div.style.left=left;
			};

			div.style.top=(xy[1]+e.offsetHeight+5)+"px";
		};
	};
	
	//set focus to the input with a DefaultFocus attribute.  Do this before calling the initialization function
	//so the initialization function can override the focus set here
	var arInputElements=new Array();
	getAllInputNodes(div,arInputElements);
	for(var i=0;i<arInputElements.length;i++) {
		if(arInputElements[i].getAttribute("DefaultFocus")) {
			arInputElements[i].focus();
			break;	
		};
	};

	//call initialization function for dialog if one is defined
	var s="initializeDialog"+sDialogID;
	if(eval('typeof '+s)=="function") eval(s+"()");

	//look for initialization function in the aspectinit attribute of the div
	//This is used so a single function can be called even when the dialog ID is random
	//The ID of the dialog div is passed as an argument.  Additional arguments can be
	//made available to the function by including them in the dialog div's attributes or
	//as hidden inputs inside the dialog.
	var sInitFunction=div.getAttribute("aspectinit");
	var bCallPostInit=null;
	if(sInitFunction) {
		if(eval('typeof '+sInitFunction)=="function") {
			bCallPostInit=eval(sInitFunction+"('"+sDialogID+"')");
		};
	};

	//initialize calendar and other controls
	initializeCustomControls();

	//show the dialog.  If it's a mobile device, navigate to the #edit hash in the widget container.  This is done so when
	//the back button is pressed on the device, the hash is removed from the location and the table can be restored
	//setVisible(sDialogID,true);

	//if(bIsMobileDevice) location.hash="#edit";
	
	//12-31-2015 - Set the dialog height.  This is to set a consistent height that encompasses
	//any tabs in the dialog
	//09-18-2016 - Added ability to specify AdjustHeight=false to avoid adjusting the height of a dialog.
	//This allows a dialog to be any height necessary to accommodate the data.  However, it should not be 
	//used when the dialog contains tabs because the height will be different for each tab.  This was added 
	//to address an invoice dialog in which the records are added to the end of the table.
	var s=div.getAttribute("AdjustHeight");
	if((!s) || (!s.equalsIgnoreCase("false"))) {
		setTableDialogHeight(sDialogID);
	};

	//04-27-2016 set the tabsInitialized attribute to false for tabs and select boxes.  This will
	//cause the first tab and first select option to be selected
	//Right now, the last selected tab is displayed when the dialog is opened.  This could 
	//be modified to always return to the first tab when the dialog is opened.
	var a=div.getElementsByTagName("table");
	for(var i=0;i<a.length;i++) {
		if(a[i].getAttribute("tabsInitialized")) {
			a[i].setAttribute("tabsInitialized",false);
			var arTabs=getTabIDs(a[i]);
			if(arTabs.length>=1) a[i].setAttribute("SelectedTab",arTabs[0]);
		};
	};
	a=div.getElementsByTagName("select");
	for(var i=0;i<a.length;i++) {
		if(a[i].getAttribute("tabsInitialized")) {
			a[i].setAttribute("tabsInitialized",false);
			var arTabs=getTabIDs(a[i]);
			if(arTabs.length>=1) a[i].value=arTabs[0];
		};
	};
	initializeTabbedDialogs();

	//scroll the dialog into view	
	scrollElementIntoView(div);

	//refresh tables - It's important that tables be refreshed after the dialog is made visible so the table message
	//is displayed in the correct position.  This is why the setDialogValues returns a list of tables to be refreshed
	//rather than refreshing them as they're found.  If an element was included in the table div, the message could be
	//displayed there and some of this mess would go away.
appendToLog("showTableEditDialog8 arRefresh="+arRefresh);
	if(arRefresh.length>0) {
		for(var i=0;i<arRefresh.length;i++) {
			//check to see if the table still exists.  This is necessary because a dialog might include a table that
			//is created on the fly by an initialization function when the dialog is loaded and the table may no longer exist.
			if(document.getElementById(arRefresh[i])) refreshTable(arRefresh[i]);
		};
	};

	if((sInitFunction) && (bCallPostInit)) {
		eval(sInitFunction+"('"+sDialogID+"',true)");
	};
};

function adjustDialogHeight(e) {
	//go up the parent list until the dialog div is located.  This is the first div with a isAspectDialog attribute 
	var DialogDiv=null;
	var node=e;
	while((node!=null) && (DialogDiv==null) && (node.parentNode)) {
		if((node.getAttribute) && (node.getAttribute("isAspectDialog"))) {
			DialogDiv=node;
		}
		else {
			node=node.parentNode;
		};
	};

	if(DialogDiv) {
		if(DialogDiv.id) {
			var s=DialogDiv.getAttribute("AdjustHeight");
			if((!s) || (!s.equalsIgnoreCase("false"))) {
				appendToLog("adjustDialogHeight calling setTableDialogHeight for ID="+DialogDiv.id);
				setTableDialogHeight(DialogDiv.id);
			};
		};
	};
};

/******************************************************************************
Sets the height of tabbed dialogs so a consistent height is maintained when
switching from one tab to another.  Sets each tab visible to calculate the height
and sets the dialog to the greatest tab height.  Looks for a table with class=TabDialog
and uses the first instance found.  Additional instances are ignored in case
the dialog includes another driver and dialog.
******************************************************************************/
function setTableDialogHeight(ID) 
{
	var d=document.getElementById(ID);

	d.style.height="auto";
	
	var arTable=d.getElementsByTagName("table");
	var Done=false;
	for(var i=0;(!Done) && (i<arTable.length);i++) {
		if(arTable[i].getAttribute("class")) {
			if(arTable[i].getAttribute("class").equalsIgnoreCase("TabDialog")) {
				
				//get the currently selected tab.  These attributes are set by the showTab() function when a tab
				//is selected.  It is important that these values be gotten here because the section below calls 
				//showTab() to make each tab in the dialog visible and these values will be affected.
				var eClickedParent=arTable[i].parentNode.parentNode;
				var sSalectedTab=eClickedParent.getAttribute("SelectedTab");
				var sSelectedTabIDs=eClickedParent.getAttribute("SelectedTabIDs");

				var h=d.offsetHeight;
				//appendToLog("Found TabDialog.  Rows="+arTable[i].rows.length+" cells="+arTable[i].rows[0].cells.length);
				for(var cell=arTable[i].rows[0].cells.length-1;cell>=0;cell--) 
				{
					var arChild=arTable[i].rows[0].cells[cell].childNodes;
					//appendToLog("cell "+cell+" Child len="+arChild.length);
					for (var child=0;child<arChild.length;child++) {
						if ((arChild[child].nodeName.equalsIgnoreCase("A")) || (arChild[child].nodeName.equalsIgnoreCase("SPAN"))) {
							if(arChild[child].onclick) {
								var str1=String(arChild[child].onclick);
								if(str1.toUpperCase().indexOf("SHOWTAB")>=0) {
									var n1=str1.toUpperCase().indexOf("SHOWTAB(");
									var n2=str1.indexOf(")",n1);
									var str2=str1.substring(n1+8,n2);
									var arStr=getSubStringArray(str2,",",true);
									var s=replaceAllSubstrings(replaceAllSubstrings(arStr[1],"'",""),"\x22","");
									showTab(arChild[child],s);
									h=Math.max(h,d.offsetHeight);
									//appendToLog("sTabName="+sTabName+" height="+d.offsetHeight+" h="+h);
								};
							};
						};
					};
				};
				d.style.height=h+"px";
			
				Done=true;
				
				//restore the tab that was active
				//appendToLog("setTableDialogHeight sSalectedTab="+sSalectedTab+" sSelectedTabIDs="+sSelectedTabIDs);
				if(sSalectedTab) showTab(document.getElementById(sSalectedTab,sSelectedTabIDs),sSelectedTabIDs);
			};
		};
	};
};

/******************************************************************************
Initializes fields in the dialog used to edit a record in a table.  If the table
contains a readonly attribute with a value of true, fields in the dialog belonging
to the structure are disabled.  

TableID		ID of the table the dialog is associated with
e			The div containing the dialog to be updated 
ArFieldID	Array of field ID's from the table's aspectAllFieldID attribute
arValues		Array of de-tokenized values from the table's aspectAllValues attribute
ExcludeInputs	If defined and true, only span tags will be updated.  This is done to avoid
			overwriting edits that may not be reflected yet when a record is refreshed
ExcludeTableRefresh - Indicates that the body of any tables included in the dialog should 
			not be set to not visible.  This is used by updateTableRecord() when an input is 
			modified in the dialog and a new set of values is retrieved.  In this case, the table
			should remain visible.  In cases where a dialog is just opened, the table body should 
			be made not visible so a table from a previous record does not appear while the table 
			is being loaded.

This function is called from these functions:			
	showTableEditDialog - used to display a table dialog
	initializeTables2012 - called by asynchIncludesub whenever content is updated
	updateTableRecord - called by updatePendingSubmissions to update a table record and the associated dialog.
		The dialog is only updated if it is associated with the record being refreshed.
	dialogRecordSelected - ??? This function is used when a dialog header is included 
	updateDialogRecord - ??? This function is used when a dialog header is included 
	addDialogRecord - ??? This function is used when a dialog header is included 
			
******************************************************************************/
function setDialogValues(TableID,e,ArFieldID,ArValues,ExcludeInputs,ExcludeTableRefresh)
{
	//NOTE: This function is called recursively to look for inputs in every child element in the dialog.
	if(ExcludeInputs==undefined) {
		//appendToLog("setDialogValues(TableID:"+TableID+",ExcludeInputs:"+ExcludeInputs+",ExcludeTableRefresh:"+ExcludeTableRefresh+") ArFieldID="+ArFieldID.toString()+" ArValues="+ArValues.toString());
	};
	
	if(!bContainerLoaded) return(new Array());
	
	var bExcludeInputs=((ExcludeInputs) && (ExcludeInputs==true));
	
//printStackTrace();
//appendToLog("setDialogValues TableID="+TableID+" Fields="+ArFieldID+" Values="+ArValues,false,true);
//appendToLog("setDialogValues TableID="+TableID+" bContainerLoaded="+bContainerLoaded,false,true);
	if(!e) {
		appendToLog("Invalid edit dialog in setDialogValues.  TableID:"+TableID);
		return(new Array());
	};
	
	var eTable=document.getElementById(TableID);
	var attr=eTable.getAttribute("aspectreadonly");
	var bReadOnly=((attr) && (attr.equalsIgnoreCase("true")));
	
	//initialize an array of table ID's that will be updated when the other values have been set.  
	//Tables need to be refreshed last because external filters and driver params may be 
	//included in the dialog values
	var arTablesToRefresh=new Array();
	
	for(var i=0;i<e.childNodes.length;i++) {
		var eChild=e.childNodes[i];
		if(eChild.nodeName.indexOf("\x23")<0) {
			//refresh any driver tables included in the dialog.  Check for 'ver' attribute to exclude 
			//standard tables used to format the dialog
			if((eChild.nodeName.equalsIgnoreCase("table")) && (eChild.getAttribute("aspectver"))) {
				var attrNoRefresh=eChild.getAttribute("norefresh");
				var sNoRefresh=(attrNoRefresh) ? attrNoRefresh : "false";
				if(!sNoRefresh.equalsIgnoreCase("true")) {
					//appendToLog("setDialogValues: will refresh table: "+eChild.id);
					var sID=eChild.getAttribute("ID");
					if(sID) {
						arTablesToRefresh[arTablesToRefresh.length]=sID;

						//09-02-2016 - This is disabled because when data is edited in a dialog, the
						//table record is refreshed after the data has been saved by a call to 
						//updateTableRecord().  However, that function does not read the list of tables
						//to be refreshed returned by this function.  The result is that a table 
						//included in a dialog is hidden by this call and is never refreshed and just
						//appears to go away.

						//09-04-2016 The table body needs to be made not visible when a new record is 
						//selected.  Otherwise, the table from the previous dialog will be displayed 
						//until the table refreshes.  Added the ExcludeTableRefresh parameter so 
						//updateTableRecord() can explicitly indicate that tables should not be updated.
						
						//02-03-2017: Added check of display style to avoid hiding tables for dialogs displayed
						//initially - e.g. a dialog where the table is hidden but the dialog is displayed.  Don't
						//want to hide the table in this case because it will not be made visible
						//appendToLog("setDialogValues eTable.style.display="+eTable.style.display);
						if((!ExcludeTableRefresh) && (eTable.style.display!="none")) {
							setVisible(document.getElementById(sID).tBodies[0],false);
						};
					};
				}
				else {
					//appendToLog("setDialogValues: will not refresh table: "+eChild.id);
				};
			}
			else {
				var sName=eChild.getAttribute("name");
				if(sName) {
					var n=getFieldIndex(sName,ArFieldID);
					if(n>=0) {
//console.log("Setting value of "+sName+"="+ArValues[n]+" eChild.type="+eChild.type+" value="+ArValues[n]);
						if(eChild.nodeName.equalsIgnoreCase("span")) {
							//eChild.innerHTML=ArValues[n];
							eChild.innerHTML=formatField(TableID,eChild,ArValues[n]);
						}
						else if(eChild.nodeName.equalsIgnoreCase("img")) {
							eChild.src="";
							eChild.src=ArValues[n];
						}
						else {
							var bIsActiveElement=false;
							if(document.activeElement) {
								bIsActiveElement=(document.activeElement==eChild);
							};

							if((!bExcludeInputs) && (!bIsActiveElement) && (eChild.type)) {
								if(eChild.type=="hidden") {
									eChild.value=ArValues[n];
								}
								if(eChild.type=="checkbox") {
									eChild.checked=(ArValues[n].equalsIgnoreCase("true")) || (ArValues[n].equalsIgnoreCase("y"));
								}
								else if(eChild.type=="select-one") {
//console.log("Setting value of "+sName+"="+ArValues[n]+" eChild.type="+eChild.type+" value="+ArValues[n]);
									//if a value is not supplied for a drop-down, set it to 0.  This can happen if default values
									//are not specified for a field in the structure
									if(ArValues[n].length>0) {
										//This is a quick fix for a problem that occurs when the AspectAllValues attribute is updated when a record is edited.
										//The updated values include lookups instead of the value (e.g. --select-- instead of 0).
										
										//NOTE:	03-17-2013
										//This is because TAspectDriver.getRecordValues was calling getEmbeddedFieldInfo with InfoType set to 4
										//which causes it to use getFieldForHtml instead of getField.  
										//The InfoTypeis now 2 which should work properly.
										//This also affects select-multiple below
										var bSetIt=false;
										
										//try to match the value
										for (var j=0;j<eChild.options.length;j++) {
											if(eChild.options[j].value.equalsIgnoreCase(ArValues[n])) {
												eChild.value=ArValues[n];
												//eChild.selectedIndex=n;
												//eChild.options[n].selected=true;
												bSetIt=true;
//console.log("bSetIt1 value="+eChild.value);
											};
										};
										
										//if no match found, set it to the option with text matching the value
										if(bSetIt==false) {
											for (var j=0;j<eChild.options.length;j++) {
												if(eChild.options[j].text.equalsIgnoreCase(ArValues[n])) {
													eChild.value=eChild.options[j].value;
													bSetIt=true;
//console.log("bSetIt2");
												};
											};
										};

										if(bSetIt==false) {
											eChild.options[eChild.options.length]=new Option(ArValues[n],ArValues[n],false,false); 
											eChild.value=ArValues[n];
//console.log("bSetIt3");
										};
									}
									else {
										eChild.value="0";
//console.log("set value to 0");
									};
								} 
								else if(eChild.type=="select-multiple") {
									//NOTE:	03-17-2013
									//See note above for select box values

//console.log("select-multiple value="+ArValues[n]);
									//select each option for which a matching value is found
									var a=getSubStringArray(ArValues[n],"|",true);
									for (var j=0;j<eChild.options.length;j++) {
//console.log("value="+eChild.options[j].value+" index="+a.indexOf(eChild.options[j].value),false,true);
										eChild.options[j].selected=((a!=null) && (a.indexOf(eChild.options[j].value)>=0));
									};
								}
								else if(eChild.type=="textarea") {
									eChild.value=replaceAllSubstrings(ArValues[n],"//co"+"mma//",",");
								}
								//else if((eChild.type.equalsIgnoreCase("text")) || (eChild.type.equalsIgnoreCase("password")) || (eChild.type.equalsIgnoreCase("hidden"))){
								else if((eChild.nodeName=="INPUT") && (isHTMLInput(eChild))) {
									//Note: Weirdness in Javascript considers an empty string as "not defined".  The formatField function uses the
									//value of the element as a starting point if a value is not defined.  Have to set the value of the element
									//before calling the function
									eChild.value=replaceAllSubstrings(ArValues[n],"//co"+"mma//",",");
//console.log("eChild.value="+eChild.value+" name="+eChild.getAttribute("name"));
									//see if it's an input associated with a datalist
									var sDataListID=eChild.getAttribute("List");
//console.log("eChild.name="+eChild.name+" List="+sDataListID);
									if((sDataListID) && (eChild.type.equalsIgnoreCase("hidden"))) {
										var eInput=document.getElementById(sDataListID+"_input");
										if(eInput) {
											//get the value from the datalist.  Need to use the text that would
											//appear in a select box, not the value
											var eDataList=document.getElementById(sDataListID);
											if(eDataList) {
												eInput.value="";
												for(var j=0;j<eDataList.options.length;j++) {
													if(eDataList.options[j].getAttribute("AspectID").equalsIgnoreCase(eChild.value)) {
														if(eDataList.options[j].value.toUpperCase().startsWith("-- SELECT")) {
															eInput.value="";
														}
														else {
															eInput.value=eDataList.options[j].value;
														};
//console.log("set value of "+eInput.id+"="+eDataList.options[j].value);
													};
												};
											}
											else {
												alert("Error: Cannot locate datalist with ID="+sDataListID);
											};
										}
										else {
											alert("Error: Cannot locate datalist input with ID="+sDataListID+"_input");
										};
									}
									else {
										if(eChild.type.equalsIgnoreCase("datetime-local")) {
											if(ArValues[n].startsWith("12-31-1969")) {
												var sValue="";
											}
											else {
												if(!eChild.getAttribute("pattern")) {
													eChild.setAttribute("pattern","yyyy-MM-ddTHH:mm");
												};
												var sValue=formatField(TableID,eChild,ArValues[n]);
											};
											appendToLog("setDialogValues formatted ["+ArValues[n]+"] as "+sValue);
										}
										else {
											var sValue=formatField(TableID,eChild,ArValues[n]);
										};
	
										/* This is a quick hack to avoid putting 0.00 into input fields */
										if(sValue=="0.00") sValue="";
	
										eChild.value=sValue;
									};
								}
								else if(eChild.type.equalsIgnoreCase("date")) {
									eChild.value=formatField(TableID,eChild,ArValues[n]);
								}
								else {
									console.log("Error in setDialogValues: Unknown type - "+eChild.type,false,true);
								};
								
								eChild.disabled=bReadOnly;
							};
						};
					};
				};
				
				//Need to set values in child nodes of the current child node.  This is a recursive 
				//function that sets values in all divs, tables, etc. included in the div containing 
				//the dialog.  Some time can be saved by not checking child nodes like option, select,
				//etc. that will have no child nodes.
				if((eChild.nodeName!="INPUT") && (eChild.nodeName!="OPTION") && (eChild.nodeName!="SELECT") && (eChild.nodeName!="UL") && (eChild.nodeName!="SCRIPT") && (eChild.nodeName!="HR")) {
					//appendToLog("Calling setDialogValues for node "+eChild.nodeName,false,true);
					var b1=(ExcludeInputs) ? ExcludeInputs : false;
					var b2=(ExcludeTableRefresh) ? ExcludeTableRefresh : false;
					arTablesToRefresh=arTablesToRefresh.concat(setDialogValues(TableID,eChild,ArFieldID,ArValues,b1,b2));
				};
			};
		};
	};
	
//appendToLog("setDialogValues arTablesToRefresh="+arTablesToRefresh,false,true); 
	return(arTablesToRefresh);
};

/******************************************************************************
Submits data edited in a dialog.  The TableID and KeyExpression are recorded as attributes in the
dialog when it is displayed.  

The ADialogID parameter is not required.  The parent dialog will
be determined by checking the parent nodes of e until a dialog div is found.  However, ADialogID
can be passed to explicitly indicate the parent dialog div.  This can be used when a dialog contains
a 2nd dialog inside of it with data from another driver (e.g. the BackOffice registration container).
The format might be
[div dialog1]
	field from 1
	[div dialog2]
		field from 2
	[/div]
	field from 1
[/div]
******************************************************************************/
function OldsubmitDialogCell(e,ADialogID)
{
	//appendToLog("submitDialogCell: "+e.getAttribute("name"));
	
	if(!ADialogID) {
		//go up the parent list until the dialog div is located.  This is the first div with a TableID attribute 
		var div=null;
		var node=e;
		while((node!=null) && (div==null) && (e.parentNode)) {
			if((node.getAttribute) && (node.getAttribute("TableID"))) {
				div=node;
			}
			else {
				node=node.parentNode;
			};
		};
	}
	else {
		div=document.getElementById(ADialogID);
	};

	if(div==null) {
		//This can happen during development when editing a dialog that is to be used in a table 
		//since there is no table, just the dialog
		//alert("could not locate dialog div.");
		return;
	};

	//set the background color of the cell and the attribute indicating it's saving
	var eParent=e.parentNode;
	if((eParent.nodeName.equalsIgnoreCase("td")) || (eParent.nodeName.equalsIgnoreCase("span"))) {
		//appendToLog("submitDialogCell setting pending status for "+eParent+" Name="+e.getAttribute("name"));;
		setPendingSubmissionStyle(e,false,true);
		//eParent.style.backgroundColor=PendingSubmissionBackgroundColor;
		eParent.setAttribute("AspectSubmissionPending","new");
	};
	
	//get the table ID from the dialog div
	sTableID=div.getAttribute("TableID");
	sKeyValue=div.getAttribute("KeyValue");
	sFieldID=e.getAttribute("name");
	var sValue="";
	if (e.type=="select-multiple") {
		for (var i=0;i<e.options.length;i++) {
			if(e.options[i].selected) {
				if(sValue.length>0) sValue +="|";
				sValue +=e.options[i].value;
			};
		};
	}
	else {
		sValue=(e.type=="checkbox") ? e.checked : e.value;
	};
	
	//format the contents of the cell
	if((e.type!="select-one") && (e.type!="select-multiple") && (e.type!="checkbox") && (e.type!="date")) {
		//appendToLog("submitDialogCell: e.type="+e.type+" formatting value");
		e.value=formatField(sTableID,e);
	};

	//update the corresponding cell in the table if there is one.  Setting the value of the control
	//in the table does not cause the onChange event to fire so the data is not submitted twice
	var table=document.getElementById(sTableID);
	var Control=getTableCellControl(table,sKeyValue,sFieldID);

	var sDebug="";
	if(Control!=null) {
		sDebug="submitDialogCell setting table cell Control="+Control+" type="+Control.type+" nodename="+Control.nodeName;
		if((Control.nodeName.equalsIgnoreCase("text")) || (Control.nodeName.equalsIgnoreCase("date")) || (Control.nodeName.equalsIgnoreCase("password"))) {
			if(e.type=="select-one") {
				//set the table cell to the description of the lookup, not the value
				for (var i=0;i<e.options.length;i++) {
					if(e.options[i].value.equalsIgnoreCase(e.value)) Control.innerHTML=e.options[i].innerHTML;
				};
				sDebug +=" set select-one"
			}
			else if(e.type=="select-muliple") {
				//set the table cell to the description of the lookup, not the value
				Control.innerHTML="";
				for (var i=0;i<e.options.length;i++) {
					if(e.options[i].selected) Control.innerHTML +=e.options[i].innerHTML;
				};
				sDebug +=" set select-multiple"
			}
			else if((e.nodeName.equalsIgnoreCase("input")) && (e.getAttribute("list")!=null)) {
				//set the table cell to the value of the datalist, not the value
				var sListID=e.getAttribute("list");
				if(sListID) {
					var eDatalistInput=document.getElementById(sListID+"_input");
					if(eDatalistInput) Control.innerHTML=eDatalistInput.value;
				};
			}
			else {
				if(Control.nodeName.equalsIgnoreCase("text")) {
					Control.innerHTML=e.value;
					sDebug +=" set other innerHTML"
				}
				else {
					Control.value=e.value;
					sDebug +=" set other value"
				};
			};
		}
		else {
			(Control.type=="checkbox") ? Control.checked=sValue : Control.value=e.value;
			sDebug +=" set checkbox"
		};

		var td=Control.parentNode;
		if(td.nodeName.equalsIgnoreCase("td")) {
			setPendingSubmissionStyle(Control,true,true);
			//td.style.backgroundColor=PendingSubmissionBackgroundColor;
			td.setAttribute("AspectSubmissionPending","new");
		};
	}
	else {
		sDebug="submitDialogCell setting table cell control was null";
	};

	//alert("submitDialogCell: "+sDebug,false,true);
	
	var s="";
	//appendToLog("submitDialogCell: sValue="+sValue);
	((typeof sValue)=="boolean") ? s=sValue.toString() : s=replaceAllSubstrings(sValue,",","//co"+"mma//");
	//appendToLog("submitDialogCell: submitTableData.  TableID:"+sTableID+" KeyValue:"+sKeyValue+" FieldID:"+sFieldID+" Value="+s);
	submitTableData(sTableID,sKeyValue,sFieldID,s);
};

function advanceToNextInput(e) {
	var Done=false;
	var eParent=e.parentNode;
	var cLoop=0;
	while((!Done) && (cLoop<5) && (eParent)) {
		var arInput=eParent.getElementsByTagName("input");
		//appendToLog("cLoop="+cLoop+" arInput.length="+arInput.length);
		for(var i=0;i<arInput.length;i++) {
			if(arInput[i]==e) {
				//appendToLog("advanceToNextInput arInput["+i+"].type="+arInput[i].type+" arInput.length="+arInput.length);
				j=i+1;
				while(j<arInput.length) {
					var bIsTabStop=false;
					if(arInput[j].nodeName=="SELECT") {
						bIsTabStop=true;
					}
					else if(arInput[j].nodeName=="TEXTAREA") {
						bIsTabStop=true;
					}
					else if(arInput[j].nodeName=="INPUT") {
						bIsTabStop=("TEXT|NUMBER|DATE|CHECKBOX|BUTTON".indexOf(arInput[j].type.toUpperCase())>=0);
					};
				
					//appendToLog("bIsTabStop1="+bIsTabStop);

					//don't stop on checkbox in table used to select records
					if(arInput[j].type.equalsIgnoreCase("checkbox")) {
						//appendToLog("found checkbox");
						var eCheckboxParent=arInput[j].parentNode;
						if(eCheckboxParent) {
							if(eCheckboxParent.nodeName=="TD") {
								//appendToLog("Parent is TD.  Name="+eCheckboxParent.getAttribute("name"));
								if(eCheckboxParent.getAttribute("name")) {
									if(eCheckboxParent.getAttribute("name").equalsIgnoreCase("selectrecord")) {
										bIsTabStop=false;
										//appendToLog("not focusing checkbox");
									};
								};
							};
						};
					};
					
					//see if a tabstop attribute is specified
					var s=arInput[j].getAttribute("TabStop");
					if(s) {
						bIsTabStop=(s.equalsIgnoreCase("true"));
					};

					//don't stop if the control is not visible
					if(bIsTabStop) {
						var style=window.getComputedStyle(arInput[j]);
						if((style.display=="none") || (arInput[j].offsetWidth==0)) bIsTabStop=false;
					};

					//don't stop if the control is disabled
					if(arInput[j].disabled) {
						bIsTabStop=false;
					};

					//don't stop if the control is read-only
					if(arInput[j].getAttribute("readonly")) {
						bIsTabStop=false;
					};
						
					//appendToLog("arInput["+j+"].type="+arInput[j].type+" ID="+arInput[j].id+" bIsTabStop="+bIsTabStop);
					if(bIsTabStop) {
						try {
							//appendToLog("set focus j="+j+" ID="+arInput[j].id+" name="+arInput[j].name);
							arInput[j].focus();
							arInput[j].select();
							return(arInput[j]);
						}
						catch(e) {
							//appendToLog("Error: could not set focus: "+e.toString());
							return(null);
						};
					};
					j++;
				};
			};
		};
		eParent=eParent.parentNode;
		cLoop++;
	};
};

function advanceToPrevInput(e) {
	var Done=false;
	var eParent=e.parentNode;

	//if the parent is a TD, need to go up to TABLE.  Otherwise, this routine
	//will only act on the table row and will not allow the focus to be set to a 
	//previous table row.
	if(eParent.nodeName=="TD") {
		//n is used just to avoid a potential infinite loop
		n=0;
		while((n<10) && (eParent.nodeName!="TABLE")) {
			eParent=eParent.parentNode;
			n++;
		};
	};

	var cLoop=0;
	while((!Done) && (cLoop<5) && (eParent)) {
		var arInput=eParent.getElementsByTagName("input");
		for(var i=0;i<arInput.length;i++) {
			if(arInput[i]==e) {
				j=i-1;
				while(j>=0) {
					if("TEXT|NUMBER|DATE".indexOf(arInput[j].type.toUpperCase())>=0) {
						arInput[j].focus();
						arInput[j].select();
						return(arInput[j]);
					}
					j--;
				};
				return;
			};
		};
		eParent=eParent.parentNode;
		cLoop++;
	};
};

/*****************************************************************
There is a problem advancing to the next input when the enter key is pressed.  
It seems to be a conflict with  submitTableCell() and submitDialogCell().  As a workaround,
keyDown() records the last keypress and aborts when the enter key is pressed.  

The submitTableCell() function checks the value of the last key pressed.  If it is 13,
submitTableCell() clears the value of LastKeyPress and calls advanceToNextInput().

02-04-2017: Aborting when the enter key is pressed prevents advancing to the next field
in a dialog.  Things appear to work properly if the keyDown() function does not abort
when the enter key is pressed AND submitTableCell still advances when enter was the last
key pressed.  This allows the input to advance in both tables and dialogs and for the input 
to advance in a table when enter is pressed but onChange is not fired because the data
in the cell has not changed.
*****************************************************************/
var LastKeyPress=0;

function keyDown(evt,e) {
	var key=evt.keyCode ? evt.keyCode : evt.which ? evt.which : evt.charCode;
	LastKeyPress=key
	//if(key==13) return;
	//appendToLog("keyDown key="+key+" list="+e.getAttribute("list"));
	if(e.getAttribute("list")) {
		if(key==40) return;	
		if(key==13) {
			var eList=document.getElementById(e.getAttribute("list"));
			if(isDatalistSelectionValid(e.value,eList)) {
				advanceToNextInput(e);
			};
			return key;
		};
	};

	//don't advance on cursor keys for number inputs
	if((key==38) || (key==40)) {
		if((e.nodeName=="INPUT") && (e.type)) {
			if(e.type.equalsIgnoreCase("number")) return;
			if(e.type.equalsIgnoreCase("date")) return;
		};
	};

	var eFocus=null;
	switch(key) {
		case 13:	//enter
							eFocus=advanceToNextInput(e);
							break;
		case 38:	//up
							eFocus=advanceToPrevInput(e);
							break;
		case 40:	//down
							eFocus=advanceToNextInput(e);
							break;
	};


	if(eFocus) {
		//appendToLog("eFocus.type="+eFocus.type);
		if(eFocus.type.equalsIgnoreCase("BUTTON")) {
			//appendToLog("Returning false");
			return(false);
		};
	};

	return key;
};


function switchToDesktop() {
	window.open(getServer()+"/?Network=Greenlight&ID=getWidget&RequestDesktop=true","_self");
};

function switchToMobile() {
	window.open(getServer()+"/?Network=Greenlight&ID=getWidget&RequestMobile=true","_self");
};

/*********************************************************************************
Used to set the left and top bars to display content from the back-office package instead
of the support package.  Used to view pages from the customer's perspective.
*********************************************************************************/
function setDeployedView(s) 
{
	if(s) {
		loadContent("top_bar",getLeftBarArgs());
		loadContent("left_bar",getLeftBarArgs());
		return;
	};
	
	var eCheck=document.getElementById("SetDeployedView");
	if(!eCheck) {
		alert("Element not found: SetDeployedView");
		return;
	};
	
	var sUrl=getServer()+"/?Network=GreenLight&ID=setToken&Name=Aspect_Support_Show_Deployed_View&Value="+eCheck.checked;
	var sFuncOk="setDeployedView(s)";
	var sFuncErr="setDeployedView(s)";
	asynchInclude(null,sUrl,sFuncOk,sFuncErr);
};

/********************************************************************************
Functions for the left menu bar
********************************************************************************/
function getLeftBarSelectedCompany()
{
	var e=document.getElementById("left_bar_select_company");
	if(e) return(e.value);
	return("");
};

function getLeftBarSelectedComputer()
{
	var e=document.getElementById("left_bar_select_computer");
	if(e) return(e.value);
	return("");
};

function getLeftBarSelectedPackage()
{
	var sPackageID=document.getElementById("select_menu").value;
	if(sPackageID.indexOf("^")>0) {
		var a=getSubStringArray(sPackageID,"^",true);
		return(a[0]);
	};
	return(sPackageID);
};

function getLeftBarSelectedMenu()
{
	var sPackageID=document.getElementById("select_menu").value;
	var sMenu="home";
	if(sPackageID.indexOf("^")>0) {
		var a=getSubStringArray(sPackageID,"^",true);
		return(a[1]);
	};
	return(sMenu);
};

function getLeftBarArgs()
{
	var s="Package="+getLeftBarSelectedPackage();
	s +="&Menu="+getLeftBarSelectedMenu();
	s +="&LeftBarCompany="+getLeftBarSelectedCompany();
	s +="&LeftBarComputer="+getLeftBarSelectedComputer();
	return(s);
};

function leftBarCompanySelected(eSelect)
{
	applyOverlay("left_bar");
	
	//clear the selected computer so if doesn't cause the associated company to be 
	//selected when the content loads.
	document.getElementById("left_bar_select_computer").value="0";
	
	//appendToLog("leftBarCompanySelected args="+getLeftBarArgs(),false,true);
	loadContent("left_bar",getLeftBarArgs());
};

function leftBarComputerSelected(eSelect)
{
	//applyOverlay("left_bar");
	//appendToLog("leftBarComputerSelected args="+getLeftBarArgs(),false,true);
	//loadContent("left_bar",getLeftBarArgs());
	refreshLeftBarMenu();
};

function updateCompanyList()
{
	applyOverlay("left_bar");
	loadContent("left_bar",getLeftBarArgs()+"&updateCompanyList=true");
};

function refreshLeftBarMenu()
{
	var e=document.getElementById("left_bar_menu_div");
	var sUrl=e.getAttribute("urlbase");
	var arParam=getSubStringArray(sUrl,"&",false);
	sUrl="";
	for(var i=0;i<arParam.length;i++) {
		if((!arParam[i].startsWith("Package")) && (!arParam[i].startsWith("Menu")) && (!arParam[i].startsWith("LeftBarCompany")) && (!arParam[i].startsWith("LeftBarComputer"))) {
			if(sUrl.length>0) sUrl +="&";
			sUrl +=arParam[i];
		};
	};
	sUrl +="&"+getLeftBarArgs();
	e.setAttribute("url",sUrl);
	setInterval(e,0,true,"");
	refreshWidgets();
//appendToLog("refreshLeftBarMenu args="+getLeftBarArgs());
	//show the menu select box
	var s=getLeftBarSelectedComputer();
	if((s) && (s.length>0) && (s!="0")) {
		setVisible("menu_header",true);
		setVisible("select_menu",true);
	}
	else {
		setVisible("menu_header",false);
		setVisible("select_menu",false);
	};
};

function menuSelected()
{
	//applyOverlay("left_bar");
	//loadContent("left_bar",getLeftBarArgs(),"refreshWidgets()","refreshWidgets()");
	
	//get new url for div
	var sValue=document.getElementById("select_menu").value;
	var a=getSubStringArray(sValue,"^",false);
	var sPackage=a[0];
	var sMenu=a[1];
	
	var e=document.getElementById("left_bar_menu_div");
	var sUrl=e.getAttribute("urlbase");
	//sUrl +="&package="+sPackage+"&menu="+sMenu;
	var arParam=getSubStringArray(sUrl,"&",false);
	sUrl="";
	for(var i=0;i<arParam.length;i++) {
		if((!arParam[i].startsWith("Package")) && (!arParam[i].startsWith("Menu")) && (!arParam[i].startsWith("LeftBarCompany")) && (!arParam[i].startsWith("LeftBarComputer"))) {
			if(sUrl.length>0) sUrl +="&";
			sUrl +=arParam[i];
		};
	};
	sUrl +="&"+getLeftBarArgs();

	e.setAttribute("url",sUrl);
	setInterval(e,0,true,"");
	refreshWidgets();
};

function menuOptionSelected(sMenu,sDescription,sActionType,sTarget,sArgs)
{
	if(sArgs.startsWith("/?")) sArgs=getServer()+sArgs;
	
	if(sActionType.equalsIgnoreCase("URL")) {
		window.open(sArgs,"_self");
	}
	else if(sActionType.equalsIgnoreCase("UpdateContent")) {
		sArgs+="&Package="+getLeftBarSelectedPackage();
		sArgs+="&LeftBarCompany="+getLeftBarSelectedCompany();
		sArgs+="&LeftBarComputer="+getLeftBarSelectedComputer();
		appendToLog("LoadContent "+sTarget+" "+sArgs,false,true);
		loadContent(sTarget,sArgs,"","");
	};
};

/**************************************************************
Called when text is entered to search for a customer ID
in the Aspect Support left bar
**************************************************************/
var arLeftBarAllCompany=null;
var arLeftBarAllCustomer=null;
var arLeftBarCompanyLookup=null;

function HashIDSearchUpdated(ClearSearch) 
{
	if(ClearSearch) {
		document.getElementById("search_customer_id").value="";
		loadContent("left_bar","");
		return;
	};

	if(arLeftBarAllCompany==null) {
		var arLeftBarAllCustomer=document.getElementById("Collection_AllCustomer").innerHTML;

		//These are not currently used
		//var arLeftBarAllCompany=document.getElementById("Collection_AllCompany").innerHTML;
		//var arLeftBarCompanyLookup=document.getElementById("Collection_CompanyLookup").innerHTML;
	};

	var arSelections="0=-- Select1 --";
	var strTyped=document.getElementById("search_customer_id").value.toUpperCase().trim();
	var arCustomer=getSubStringArray(arLeftBarAllCustomer,"|");

	var sSelected=null;
	var cMatch=0;
	for (var i=0;i<arCustomer.length;i++) {
		arValues=getSubStringArray(arCustomer[i],"=");
		//if(arValues[0].toUpperCase().indexOf(strTyped)>=0) {
		if(arCustomer[i].toUpperCase().indexOf(strTyped)>=0) {
			arSelections=addElement(arSelections,arCustomer[i],"|");
			if(sSelected==null) sSelected=arValues[0];
			cMatch++;
		};
	};

	//clear the connection info
	var eConnectionInfo=document.getElementById("LeftBarConnectionInfo");
	if(eConnectionInfo) eConnectionInfo.innerHTML="";

	var eSelect=document.getElementById("left_bar_select_computer");
	setOptions(eSelect,arSelections);
	eSelect.value="0";

	//if only a single match was found, select it and refresh the left bar to update
	//the menu items
	if(cMatch==1) {
		eSelect.value=sSelected;
		leftBarComputerSelected(eSelect);
	};
};



/******************************************************************************************************
TEXT FUNCTIONS
******************************************************************************************************/
function keywordMatch(Keys,Str) {
	var bMatch=false;
	if(Keys.trim().length==0) return(true);
	if(Str.trim().length==0) return(false);

	var sString=Str.toUpperCase();

	var arKeys=getSubStringArray(Keys.toUpperCase(),",",true);
	if((arKeys!=null)) {
		var Done=false;
		for(var i=0;(!Done) && (i<arKeys.length);i++) {
			appendToLog("arKeys["+i+"]="+arKeys[i]+" sString="+sString);
			if(arKeys[i].length>0) {
				if(arKeys[i].startsWith("+")) {
					if(arKeys[i].length>1) {
						if(sString.indexOf(arKeys[i].substring(1))<0) {
							bMatch=false;
							appendToLog("Match=false[1]");
							Done=true;
						}
						else {
							appendToLog("Match=true[1]");
							bMatch=true;
						}
					}													
				}
				else if(arKeys[i].startsWith("-")) {
					if(arKeys[i].length>1) {
						if(sString.indexOf(arKeys[i].substring(1))>=0) {
							bMatch=false;
							appendToLog("Match=false[2]");
							Done=true;
						};
					};
				}
				else {
					if(sString.indexOf(arKeys[i])>=0) bMatch=true;
					appendToLog("Match="+bMatch+"[3]");
				};
			};
		};
	};
	return(bMatch);
};

function getSalt(n) {
	var arChars="0123456789abcdefghijklmnopqrstuvwxyz";
	var s="";
	for (var i=0;i<n;i++) {
		r=Math.floor(Math.random()*36);
		s +=arChars.charAt(r);
	};
	return(s);
};

/*
	Returns a unique numberic value for the given string.  The result is limited to 32 bits.
	The result is not guaranteed to be unique since strings can be of any length, but for 
	practical purposes it is.  This function is used to generate widget ID's in the reports
	container using the selected report and stores as the string.
*/
function getHashCode(s)
{
	var h=0;
	var off=0;
	var len=s.length;
	for (var i=0;i<len;i++) {
		h=31*h + s.charCodeAt(off);
		while(h>4294967296)  h -=4294967296;
		off++;
	};
	return(h.toString());
};

Array.prototype.indexOf=function(s){
	for(var i=0;i<this.length;i++) {
		if (typeof(this[i])=="string") {
			if(this[i].equalsIgnoreCase(s)) return(i);
		}
		else {
			if(this[i]==s) return(i);
		};
	};
	return(-1);
};

String.prototype.trim=function() {
	return this.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
};

String.prototype.deleteCharAt=function(index) {
	if (index==0) return(this.substring(1));
	return this.substring(0,index) + this.substring(index+1);
};

String.prototype.startsWith=function(str){
    return (this.toUpperCase().indexOf(str.toUpperCase())===0);
}

String.prototype.equalsIgnoreCase=function(str){
	if(!str) return(false);
    return (this.toUpperCase()==str.toUpperCase());
}

String.prototype.setLength=function(len){
	if (len>this.length) return(this);
	return(this.substring(0,len));
}

	String.prototype.replaceAll=function(str1, str2, ignore) {
		return this.replace(new RegExp(str1.replace(/([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|\<\>\-\&])/g,"\\$&"),(ignore?"gi":"g")),(typeof(str2)=="string")?str2.replace(/\$/g,"$$$$"):str2);
	} ;

function replaceAllSubstrings(str,target,replacement) 
{
	if(!str) return("");
	return(str.toString().replaceAll(target,replacement,false));
};

function oldreplaceAllSubstrings(str,target,replacement) 
{
	if(!str) return("");
	
	if (replacement.toUpperCase().indexOf(target.toUpperCase())>=0) {
		var s="The replacement: "+replacement+" includes the target: "+target+" while replacing\n"
		s +=target+"\nwith\n"+replacement;
		alert(s);
		return(str);
	};

	var n=-1;
	do {
		n=str.indexOf(target);
		if(n>=str.length) {
			appendToLog("replaceAllSubstrings target="+target+" replacement="+replacement+" n="+n+" str="+str,false,true);
			n=-1;
		}
		else {
			if (n>=0) str=str.substring(0,n)+replacement+str.substring((n+target.length),str.length);
		};
	} while (n>=0);

	return(str);
};

function quote(str) {
	return("\x22"+str+"\x22");
};

Object.prototype.toType=function() {
  return ({}).toString.call(this).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
};

function getSubStringArray(Src,ADelimit,ARemoveQuotes)
{
	if(Src=="") {
		var arString=new Array();
		arString[0]="";
		return(arString);
	};

	if((!Src) || (Src==null)) {
		appendToLog("Src is null in getSubStringArray1",false,true);
		printStackTrace();
		return(null);
	};
	
	//check for non-string variable
	try {
		var Ch=Src.charAt(0);
	}
	catch(e) {
		printStackTrace();
		appendToLog("getSubStringArray: Error: "+e.toString(),false,true);
	};
	
	var Str1="";
	var Len=Src.length;
	var cDelimiters	=0;
	var LastIndex=0;
	var InQuotes=false;

	if (Len==0) return("");
	
	//initialize array for recording location of commas
	var arDelimit=new Array(Len+1);

	//get locations of delimiters
	for (var i=0;i<Len;i++) {
		var Ch=Src.charAt(i);
		if (Ch=='\x22') {
			InQuotes=!InQuotes;
		}
		else {
			if ((Ch==ADelimit) && (!InQuotes)) {
				arDelimit[cDelimiters]=i;
				cDelimiters++;
			};
		};
	};

	//fake a delimiter at the end of the string
	arDelimit[cDelimiters]=Len;
	cDelimiters++;
	
	var arString=new Array(cDelimiters);
	
	for (var i=0;i<cDelimiters;i++)	
	{
		Str1="";
		
		if (arDelimit[i]>LastIndex) 
		{
			Str1 +=Src.substring(LastIndex,arDelimit[i]);

			//remove quotes
			if (ARemoveQuotes) {
				if (Str1.length>0) {
					if (Str1.charAt(0)=="\x22") {
						Str1=Str1.deleteCharAt(0);
						if ((Str1.length>0) && (Str1.charAt(Str1.length-1)=='\x22')) {
							Str1=Str1.setLength(Str1.length-1);
						};
					};
				}
			};

			//trim
			Str1=Str1.trim();
			//while ((Str1.length>0) && (Str1.charAt(0)==' ')) Str1=Str1.deleteCharAt(0);
			//while ((Str1.length>0) && (Str1.charAt(Str1.length-1)==' ')) Str1=Str1.setLength(Str1.length-1);

			arString[i]=Str1;
		}
		else {
			arString[i]="";
		}

		LastIndex=arDelimit[i]+1;
	};

	if (false) {
		String1="";
		for (var i=0;i<arString.length;i++) String1 +=arString[i]+"\n";
		alert("arString="+String1);
	};

	return(arString);
};

//returns the element at the given index from the delimited array in str
function getElement(str,index,delimiter)
{
	arString=getSubStringArray(str,delimiter,true);
	if (index>=arString.length) {
		alert("index out of bounds in getElement("+str+","+index+","+delimiter+")");
		return("");
	};
	return(arString[index]);
};

//returns the value of the element with the given name in a delimited string of the form "name1=value2|name2=value2..."
function getElementValue(str,name,delimiter)
{
	if(str==null) {
		appendToLog("str is null in getElementValue for "+name,false,true);
		return("");
	};
	
	var arElement=getSubStringArray(str,delimiter,true);
	for (var i=0;i<arElement.length;i++) {
		var arString=getSubStringArray(arElement[i],"=",true);
		if (arString.length>0) {
			if (arString[0].equalsIgnoreCase(name)) {
				var strValue="";
				for (var j=1;j<arString.length;j++) strValue=addElement(strValue,arString[j],"=");
				return(strValue);
			};
		};
	};

	return("");
};

function addElement(str,name,Delimiter)
{
	if (!Delimiter) Delimiter=",";
	if (str.length>0) str +=Delimiter;
	str +=name;
	return(str);
};

function padLeft(str,ch,len)
{
	var strResult=str.toString();
	while (strResult.length<len) strResult=ch + strResult;
	return(strResult);
};

function formatDate(dt,Pattern)
{
	//set a default pattern used to pass time to Aspect
	var strResult="MM-dd-yyyy HH:mm:ss z";
	if (Pattern) strResult=Pattern;
	
	strResult=replaceAllSubstrings(strResult,"MM",padLeft(dt.getMonth()+1,"0",2));
	strResult=replaceAllSubstrings(strResult,"dd",padLeft(dt.getDate(),"0",2));
	strResult=replaceAllSubstrings(strResult,"yyyy",padLeft(dt.getFullYear(),"0",4));
	strResult=replaceAllSubstrings(strResult,"HH",padLeft(dt.getHours(),"0",2));
	strResult=replaceAllSubstrings(strResult,"mm",padLeft(dt.getMinutes(),"0",2));
	strResult=replaceAllSubstrings(strResult,"ss",padLeft(dt.getSeconds(),"0",2));
	strResult=replaceAllSubstrings(strResult,"SSS",padLeft(dt.getMilliseconds(),"0",3));

	var Hour=dt.getHours();
	var Hourhh=(Hour<=12) ? Hour : Hour-12;
	strResult=replaceAllSubstrings(strResult,"hh",padLeft(Hourhh,"0",2));
	
	if(strResult.toUpperCase().indexOf("A")>=0) {
		var s="PM";
		if(Hour<12) s="AM";
		
		if(strResult.toUpperCase().indexOf("AA")<0) {
			s=s.substring(0,1);
			if(strResult.indexOf("A")>=0) {
				strResult=replaceAllSubstrings(strResult,"A",s);
			}
			else {
				strResult=replaceAllSubstrings(strResult,"a",s);
			};
		}
		else {
			if(strResult.indexOf("AA")>=0) { 
				strResult=replaceAllSubstrings(strResult,"AA",s);
			}
			else {
				strResult=replaceAllSubstrings(strResult,"aa",s);
			};
		};
	};
	
	switch(dt.getTimezoneOffset()) {
		case 300: strResult=replaceAllSubstrings(strResult,"tz","(EST)"); break;
		case 360: strResult=replaceAllSubstrings(strResult,"tz","(CST)"); break;
		case 420: strResult=replaceAllSubstrings(strResult,"tz","(MST)"); break;
		case 480: strResult=replaceAllSubstrings(strResult,"tz","(PST)"); break;
		default: strResult=replaceAllSubstrings(strResult,"tz","GMT-"+padLeft((dt.getTimezoneOffset()/60),"0",2)+"00");
	};
	
	strResult=replaceAllSubstrings(strResult,"z","-"+padLeft((dt.getTimezoneOffset()/60),"0",2)+"00");
	strResult=replaceAllSubstrings(strResult,"Z","-"+padLeft((dt.getTimezoneOffset()/60),"0",2)+"00");
//appendToLog("formatDate dt="+dt+" pattern="+Pattern+" result="+strResult,false,true);
	return(strResult);
};

function formatNumber(n,Pattern) 
{
	var Num;

	if (typeof(n)=="string") {
		Num=parseFloat(n);
	}
	else if ((typeof(n)=="int") || (typeof(n)=="float") || (typeof(n)=="number")) {
		Num=n;
	}
	else {
		return("Unrecognized type: "+n+" type: "+typeof(n));
	};
	
	//for right now, just look for a decimal in the pattern and return two digits if there's a decimal.
	//Otherwise return no digits after the decimal
	var strResult="";
	var n=Pattern.indexOf(".");
	if (n>=0) {
		var NumDecimals=Pattern.length-n-1;
		strResult=Num.toFixed(NumDecimals);
	}
	else {
		strResult=Num.toFixed(0);
	};
	
	return(strResult);
};

//Replaces special characters with tokens and vice versa
function tokenizeSpecialChars(str,bool) 
{
	//alert("tokenizeSpecialChars "+bool+" "+str);
	if (bool) {
		var strResult=replaceAllSubstrings(str,"&","\\\\am"+"p\\\\");
		strResult=replaceAllSubstrings(strResult,"+","\\\\pl"+"us\\\\");
		strResult=replaceAllSubstrings(strResult,"\x22","\\\\qu"+"ot\\\\");
		strResult=replaceAllSubstrings(strResult,"'","\\\\ap"+"os\\\\");
		strResult=replaceAllSubstrings(strResult,"#","\\\\pou"+"nd\\\\");
	}
	else {
		var strResult=replaceAllSubstrings(str,"\\\\am"+"p\\\\","&");
		strResult=replaceAllSubstrings(strResult,"\\\\pl"+"us\\\\","+");
		strResult=replaceAllSubstrings(strResult,"\\\\qu"+"ot\\\\","\x22");
		strResult=replaceAllSubstrings(strResult,"\\\\ap"+"os\\\\","'");
		strResult=replaceAllSubstrings(strResult,"\\\\pou"+"nd\\\\","#");

		strResult=replaceAllSubstrings(strResult,"//am"+"p//","&");
		strResult=replaceAllSubstrings(strResult,"//pl"+"us//","+");
		strResult=replaceAllSubstrings(strResult,"//qu"+"ot//","\x22");
		strResult=replaceAllSubstrings(strResult,"//ap"+"os//","'");
		strResult=replaceAllSubstrings(strResult,"//pou"+"nd//","#");
	};
	
	//alert("strResult="+strResult);
	return(strResult);
};

//Use this in place of Boolean(value).  IE and Firefox handle booleans differently.
function boolVal(s) {
	if(!s) return(false);
	if(s=="true") return(true);
	if(s==true) return(true);
	return(false);
};




/*****************************************************************************
Toggles display of a section.  The optional b parameter can be used to show
or hide the section
*****************************************************************************/
function sectionSelected(e,b) {
	var Chapter=e.getAttribute("chapter");
	var Section=e.getAttribute("section");
	var NewSelected=(e.getAttribute("selected")=="true") ? "false" : "true";

	//override the toggle if b is defined
	if(b) {
		NewSelected=(b) ? "true" : false;
	};

	e.setAttribute("selected",NewSelected);
	var a=document.getElementsByTagName("div");
	for(var i=0;i<a.length;i++) {
		if(a[i].getAttribute("subsection")) {
			if((a[i].getAttribute("chapter")==Chapter) && (a[i].getAttribute("section")==Section)) {
				//show or hide the section
				setVisible(a[i],(NewSelected=="true"));

				//if the section is being shown, set the interval to 0 for any div's that contain a url
				//and an interval of -1 or no interval is defined.  This allows divs to be defined 
				//without actually loading the contents until the section is made visible.  
				//Requiring that the interval be undefined or set to -1 allows for other divs that
				//may have a non-zero interval - e.g. a div that updates every 60 seconds.  This routine
				//should not change an existing interval (like 60) to 0.
				if(NewSelected=="true") {
					var arDiv=a[i].getElementsByTagName("div");
					for(var j=0;j<arDiv.length;j++) {
						if(arDiv[j].getAttribute("url")) {
							var Interval=arDiv[j].getAttribute("interval");
							if((!Interval) || (Interval=="-1")) {
								setVisible(arDiv[j],true,0,true);
								//setInterval(arDiv[j],"0",false,"");
							}; 

							//if SetInterval is defined, set the interval for the div.  This is for divs that are 
							//initially collapsed with load after processing enabled
							var sSetInterval=arDiv[j].getAttribute("SetInterval");
console.log("sSetInterval="+sSetInterval)
							if(sSetInterval) {
								var Interval=parseInt(sSetInterval);
console.log("Interval="+Interval)
								if(Interval>0) {
									arDiv[j].setAttribute("Interval",Interval)
								};
							};
						};
					};
				};
			};
		};
	};
	makeScrollingTable(); 
};

/*****************************************************************************
Refreshes divs with urls contained in a section.  Called when the refresh icon
is clicked in a section header
*****************************************************************************/
function refreshSection(event,e) {
  //Don't propogate the event to the document.  This keeps the onclick event from 
	//being passed to the div behind the refresh icon.  Otherwise, the div would 
	//expand or collapse when the refresh icon is clicked.
  if (event.stopPropagation) {
      event.stopPropagation();   // W3C model
  } else {
      event.cancelBubble=true; // IE model
  }

	var Chapter=e.getAttribute("chapter");
	var Section=e.getAttribute("section");

	var a=document.getElementsByTagName("div");
	for(var i=0;i<a.length;i++) {
		if(a[i].getAttribute("subsection")) {
			if((a[i].getAttribute("chapter")==Chapter) && (a[i].getAttribute("section")==Section)) {

				//show the section whenever the refresh icon is clicked.  This causes a collapsed section to 
				//be expanded when the icon is clicked
				setVisible(a[i],true);

				var arDiv=a[i].getElementsByTagName("div");
				for(var j=0;j<arDiv.length;j++) {
					if(arDiv[j].getAttribute("url")) {
						var sUpdating=arDiv[j].getAttribute("updating");
						if((!sUpdating) || (sUpdating=="false")) {
							setInterval(arDiv[j],"0",true,"");
						};
					};
				};
			};
		};
	};
	makeScrollingTable(); 
};



/******************************************************************************************************
FUNCTIONS USED FOR TABBED DIALOG
******************************************************************************************************/
function setDialogTabStyle(aCell,aLink,bSelected) {
	if(!aCell) return;
	
	if (bSelected) {
		aLink.className="tabdialogtabselected";
		//aLink.style.color="black";
		//aLink.style.fontWeight="bold";
		//aCell.style.backgroundColor="#e9e9e9";
	}
	else {
		aLink.className="tabdialogtabunselected";
		//aLink.style.color="black";
		//aLink.style.fontWeight="normal";
		//aCell.style.backgroundColor="#e9e9e9";
	};
};

//Searches for tabbed dialogs and sets the style of the default tab.  Called directly and by refreshWidgets() every second.
function initializeTabbedDialogs() {
//appendToLog("initializeTabbedDialogs started",false,true);
	//initialize all tabbed dialogs
	var arTable=document.getElementsByTagName("TABLE");

	for (var i=0;i<arTable.length;i++) {
		if(!boolVal(arTable[i].getAttribute("tabsInitialized")))
		{
			var bAllTabsLoaded=true;
			var bInitialized=false;
			var arTableRow=arTable[i].getElementsByTagName("tr");
			for (var j=0;j<arTableRow.length;j++) {
				var arTableCell=arTableRow[j].getElementsByTagName("td");
				for (var k=0;k<arTableCell.length;k++) {
					var arChild=arTableCell[k].childNodes;
					for (var l=0;l<arChild.length;l++) {
						if ((arChild[l].nodeName.equalsIgnoreCase("A")) || (arChild[l].nodeName.equalsIgnoreCase("SPAN"))) {

							//Modified 6/14/17 to address error getting onclick text of a section header in a table
							if(arChild[l].hasAttribute("onclick")) {
							//if(arChild[l].onclick) {

								//Modified 6/14/17 to address error getting onclick text of a section header in a table
								//var str1=String(arChild[l].onclick);
								var str1=String(arChild[l].getAttribute("onclick"));

								if(str1.toUpperCase().indexOf("SHOWTAB")>=0) {
									var n1=str1.toUpperCase().indexOf("SHOWTAB(");
									var n2=str1.indexOf(")",n1);
									var str2=str1.substring(n1+8,n2);
									var arStr=getSubStringArray(str2,",",true);
									var s=replaceAllSubstrings(replaceAllSubstrings(arStr[1],"'",""),"\x22","");
									var arTabName=getSubStringArray(s,"|");

									//see if all tabs have been loaded completely before setting the TabsInitialized attribute to true
									for(var cTab=0;cTab<arTabName.length;cTab++) {
										if(arTabName[cTab].length>0) {
											var eCheckLoaded=document.getElementById(arTabName[cTab]);
											if(!eCheckLoaded) {
												//the item has not been loaded at all
												bAllTabsLoaded=false;
											}
											else {
												//sLoaded is defined when the element is a container item.  This extra check makes sure the item
												//has been completely loaded by the container, including items that may require processing.  Not
												//all elements will have sLoaded defined.  For example, the dialog used to edit an item in a container
												//will not have sLoaded defined.
												var sLoaded=eCheckLoaded.getAttribute("IsLoaded");
												if(sLoaded) {
													//the item has been loaded but has not been flagged as completely loaded by the container
													if(sLoaded.equalsIgnoreCase("true")==false) bAllTabsLoaded=false;
												};
											};
										};
									};

									if(bInitialized) {
										setDialogTabStyle(arTableCell[j],arChild[l],false);
										for(var cTab=0;cTab<arTabName.length;cTab++) setVisible(arTabName[cTab],false);
									}
									else {
										setDialogTabStyle(arTableCell[j],arChild[l],true);
										for(var cTab=0;cTab<arTabName.length;cTab++) {
											//give consideration to widget containers and don't display tabs that are not flagged as visible
											var eItem=document.getElementById(arTabName[cTab]);
											if(eItem) {
												var sAttr=eItem.getAttribute("visible");
												if(sAttr) {
													if(sAttr instanceof String) {
														if(sAttr.equalsIgnoreCase("true")) setVisible(arTabName[cTab],true);
													}
													else {
														if(sAttr==true) setVisible(arTabName[cTab],true);
													}
												}
												else {
													setVisible(arTabName[cTab],true);
												};
											}
											else {
												setVisible(arTabName[cTab],true);
											};
										};

										//record the currently selected tab so it can be displayed if the table and it's tab contents are hidden
										arTable[i].setAttribute("SelectedTab",s);
										
										//appendToLog(strTabName+" visible");
										bInitialized=true;
									};
								};
							};
						};
					};
				};
			};
			arTable[i].setAttribute("tabsInitialized",bAllTabsLoaded);
		};
	};

	//initialize all select boxes
	var arSelect=document.getElementsByTagName("SELECT");
	for (i=0;i<arSelect.length;i++) 
	{
		var s=String(arSelect[i].onchange);
		if(s.toUpperCase().indexOf("SHOWTAB")>=0) 
		{
			//The dialog header includes a select box containing the ID of every record in the table.  Do not treat this as a tab selector
			//because spans or divs used in the table with the record ID as the ID will be hidden.  This occurs in the notifications table
			//when the ID of the record is used to create a span tag used to view a notification
			var bIsDialogHeader=false;
			if(arSelect[i].onchange) {
				var sOnChange=String(arSelect[i].onchange);
				bIsDialogHeader=sOnChange.toUpperCase().indexOf("DIALOGRECORDSELECTED")>=0;
			};

			if((bIsDialogHeader==false) && (arSelect[i].options.length>0)) {
				if(!boolVal(arSelect[i].getAttribute("tabsInitialized"))) {
					bAllTabsLoaded=true;
					for (var j=0;j<arSelect[i].options.length;j++) 
					{
						if(arSelect[i].options[j].value.length>0) {
							var arItems=getSubStringArray(arSelect[i].options[j].value,"|",true);
							for(var k=0;k<arItems.length;k++) {
								if (document.getElementById(arItems[k])) {
									setVisible(arItems[k],arSelect[i].options[j].selected);
								}
								else {
									bAllTabsLoaded=false;
								};
							};
						};
					};
					arSelect[i].setAttribute("tabsInitialized",bAllTabsLoaded);
				};
			};
		};
	};

	//initialize all drop-down menus
	menuCloseAll();
//appendToLog("initializeTabbedDialogs complete",false,true);
};

/*
Returns an array of all child elements in e where e is a table of tabs, a select element
or a span element containing a drop-down menu.  The child elements are the ID's 
associated with each element in the control.  An ID may contain one or more ID's
separated by pipes (e.g. div1|div2|div3.  
*/
function getTabIDs(e)
{
	var arChildID=new Array();
	
	if(e.nodeName.equalsIgnoreCase("table")) {
		var arTableRow=e.getElementsByTagName("tr");
		for (var i=0;i<arTableRow.length;i++) {
			var arTableCell=arTableRow[i].getElementsByTagName("td");
			for (var j=0;j<arTableCell.length;j++) {
				var arChild=arTableCell[j].childNodes;
				for (var k=0;k<arChild.length;k++) {
					if ((arChild[k].nodeName.equalsIgnoreCase("A")) || (arChild[k].nodeName.equalsIgnoreCase("SPAN")))
					{
						var str1=String(arChild[k].onclick);
						var n1=str1.toUpperCase().indexOf("SHOWTAB(");
						var n2=str1.indexOf(")",n1);
						var str2=str1.substring(n1+8,n2);
						var arStr=getSubStringArray(str2,",",true);
						arChildID[arChildID.length]=replaceAllSubstrings(replaceAllSubstrings(arStr[1],"'",""),"\x22","");
					};
				};
			};
		};
	}
	else if(e.nodeName.equalsIgnoreCase("span")) {
		var arLink=eDiv.getElementsByTagName("a");
		for (var i=0;i<arLink.length;i++) {
			var str1=String(arLink[i].onclick);
			var n1=str1.toUpperCase().indexOf("SHOWTAB(");
			var n2=str1.indexOf(")",n1);
			var str2=str1.substring(n1+8,n2);
			var arStr=getSubStringArray(str2,",",true);
			arChildID[arChildID.length]=replaceAllSubstrings(replaceAllSubstrings(arStr[1],"'",""),"\x22","");
		};
	}
	else if(e.nodeName.equalsIgnoreCase("select")) {
		for (var i=0;i<e.options.length;i++) {
			var arStr=getSubStringArray(e.options[i].value,"|",true);
			for (var j=0;j<arStr.length;j++) {
				arChildID[arChildID.length]=arStr[j];
			};
		};
	};

	return(arChildID);
};

/*
Hides all child elements defined in e where e is a table of tabs, a select element
or a span element containing a drop-down menu
*/
function hideTabElements(e) {
	var arTabs=getTabIDs(e);
	if(arTabs) {
		for (var i=0;i<arTabs.length;i++) {
			var ar=getSubStringArray(arTabs[i],"|",true);
			//if(ar==null) alert("ar=null in hideTabElements");
			for (var j=0;j<ar.length;j++) {
				setVisible(ar[j],false);
			};
		};
	};
};

/******************************************************************************
Shows a tab in a tabbed dialog.

02-27-2017 - Added ability to record the last selected tab in the dialog.  This is 
used by setTableDialogHeight() to restore the selected tab after resizing the height
of the dialog.

An ID is assigned to the item that was clicked.  These items will not have an ID by 
default.  A parent item is determined based on the clicked item.  If the item is a td 
in a tabbed dialog table, the parent will be the item containing the table.  The ID of 
the clicked item and the value of aName, which is a pipe-delimited list of IDs to be 
displayed, is recorded in the parent.  The setTableDialogHeight() function gets the 
parent of the table when setting the dialog height and restores the active tab after 
cycling through all of the tabs to set the height.

The selected tab is recorded in the parent node rather than in the table or the select 
element because it must be shared between the two.  For example, selecting a tab in 
a dialog should set the selected tab for the select element as well.  The selected tab 
is actually stored in the parent node of the parent node because the tabbed dialog and 
select box will each be wrapped in their own div.  Using the parent of the parent 
causes the value to be stored in a shared element.
******************************************************************************/
function showTab(eClicked,aName,InitializeTab) 
{
	//add an ID to the clicked control if it doesn't have one
	if(!eClicked.id) eClicked.id=getSalt(6);
	var eClickedParent=null;

	//appendToLog("showTab: "+eClicked+" Name: "+aName);
	if((eClicked.nodeName.equalsIgnoreCase("a")) || (eClicked.nodeName.equalsIgnoreCase("span")))
	{
		//get the table the hyperlink belongs to
		var eTable=null;
		var eDiv=null;
		var e=eClicked.parentNode;
		while ((e) && (!eTable) && (!eDiv)) {
			if(e.nodeName.equalsIgnoreCase("table")) eTable=e;
			if(e.nodeName.equalsIgnoreCase("div")) eDiv=e;
			e=e.parentNode;
		};
		
		if((!eTable) && (!eDiv)) {
			appendToLog("Cannot locate table containing tabs or div containing menu");
			return;
		};

		if(eTable)
		{
			//record the selected tab in the parent of the table
			eClickedParent=eTable.parentNode.parentNode;
			eClickedParent.setAttribute("SelectedTab",eClicked.id);
			eClickedParent.setAttribute("SelectedTabIDs",aName);

			//hide all divs and set the font for the selected/unselected tabs
			var arTableRow=eTable.getElementsByTagName("tr");
			for (var i=0;i<arTableRow.length;i++) {
				var arTableCell=arTableRow[i].getElementsByTagName("td");
				for (var j=0;j<arTableCell.length;j++) {
					var arChild=arTableCell[j].childNodes;
					for (var k=0;k<arChild.length;k++) {
						if ((arChild[k].nodeName.equalsIgnoreCase("A")) || (arChild[k].nodeName.equalsIgnoreCase("SPAN")))
						{
							//hide all divs except the selected one
							var str1=String(arChild[k].onclick);
							var n1=str1.toUpperCase().indexOf("(THIS");
							var n2=str1.indexOf(")",n1);
							var str2=str1.substring(n1+1,n2);
							var arStr=getSubStringArray(str2,",",true);
							var sTabs=replaceAllSubstrings(replaceAllSubstrings(arStr[1],"'",""),"\x22","");
							var arTabName=getSubStringArray(sTabs,"|");
							for(var cTab=0;cTab<arTabName.length;cTab++) {
								var bShow=(("|"+aName).toUpperCase().indexOf("|"+arTabName[cTab].toUpperCase())>=0);
								if(arTabName[cTab].length>0) {
									setVisible(arTabName[cTab],bShow);
									//appendToLog("setVisible: "+arTabName[cTab]+" Show="+bShow+" Equals aName:"+arTabName[cTab].equalsIgnoreCase(aName));
								};
								
								if(bShow) {
									eTable.setAttribute("SelectedTab",sTabs);
									if(InitializeTab) {
										var s="loadContent";
										if(eval('typeof '+s)=="function") {
											var eTab=document.getElementById(arTabName[cTab]);
											if(eTab) {
												var sInitialized=eTab.getAttribute("AspectTabInitialized");
												if((!sInitialized) || (!sInitialized.equalsIgnoreCase("true"))) {
													loadContent(arTabName[cTab],"InitializeTab=true");
													eTab.setAttribute("AspectTabInitialized",true);
												};
											};
										};
									};
								};
							};
							
							setDialogTabStyle(arTableCell[j],arChild[k],arChild[k]==eClicked);
							if(false) {
								//set the font for the tab
								if (arChild[k]==eClicked) {
									arChild[k].style.color="black";
									arChild[k].style.fontWeight="bold";
									arTableCell[j].style.backgroundColor="#48f";
								}
								else {
									arChild[k].style.color="black";
									arChild[k].style.fontWeight="normal";
									arTableCell[j].style.backgroundColor="#bdf";
								};
							};
						};
					};
				};
			};

			//Set the tabsinitialized flag.  This is for when a tab is selected manually before content has been fully loaded
			//If it is not set, the table will keep defaulting back to the original tab
			eTable.setAttribute("tabsInitialized",true);
		}
		else {
			//the control is a drop-down menu, so hide the menu and show the tab
			menuCloseAll();
			var arLink=eDiv.getElementsByTagName("a");
			for (var i=0;i<arLink.length;i++) {
				var str1=String(arLink[i].onclick);
				var n1=str1.toUpperCase().indexOf("SHOWTAB(");
				var n2=str1.indexOf(")",n1);
				var str2=str1.substring(n1+8,n2);
				var arStr=getSubStringArray(str2,",",true);
				var strTabName=replaceAllSubstrings(replaceAllSubstrings(arStr[1],"'",""),"\x22","");
				setVisible(strTabName,strTabName.equalsIgnoreCase(aName));
			};
			
			var arSpan=eDiv.getElementsByTagName("span");
			for (var i=0;i<arSpan.length;i++) {
				var str1=String(arSpan[i].onclick);
				var n1=str1.toUpperCase().indexOf("SHOWTAB(");
				var n2=str1.indexOf(")",n1);
				var str2=str1.substring(n1+8,n2);
				var arStr=getSubStringArray(str2,",",true);
				var strTabName=replaceAllSubstrings(replaceAllSubstrings(arStr[1],"'",""),"\x22","");
				setVisible(strTabName,strTabName.equalsIgnoreCase(aName));
			};
		};
	}
	else if (eClicked.nodeName.equalsIgnoreCase("select")) 
	{
		//the contol is a select box - so show the selected tab

		//record the selected tab in the parent of the table
		eClickedParent=eClicked.parentNode.parentNode;
		eClickedParent.setAttribute("SelectedTab",eClicked.id);
		eClickedParent.setAttribute("SelectedTabIDs",eClicked.value);

		for (var i=0;i<eClicked.options.length;i++) {
			if(eClicked.options[i].value.length>0) {
				var arTabName=getSubStringArray(replaceAllSubstrings(replaceAllSubstrings(eClicked.options[i].value,"'",""),"\x22",""),"|");
				for(var cTab=0;cTab<arTabName.length;cTab++) {
					if(arTabName[cTab].length>0) {
						var e=document.getElementById(arTabName[cTab]);
						if(e) {
							//show/hide elements
							setVisible(e,eClicked.options[i].selected);
						};
					};
				};
			};
		};
	};

	makeScrollingTable();
};



/******************************************************************************************************
XMLHTTPREQUEST FUNCTIONS
******************************************************************************************************/
function getxmlHttpRequestObject()
{
	var req=false;

	// For Safari, Firefox, and other non-MS browsers
	if (window.XMLHttpRequest) {
		try {req=new XMLHttpRequest();} 
		catch (e) {req=false;}
	} 
	else if (window.ActiveXObject) {
		// For Internet Explorer on Windows
		try {
			req=new ActiveXObject("Msxml2.XMLHTTP");
		} 
		catch (e) {
			try {req=new ActiveXObject("Microsoft.XMLHTTP");} 
			catch (e) {req=false;}
		}
	}
	
	return(req);
};

//Executes a synchrounous request for content and returns the result.  This method waits until the content is received before returning.
//The asynchInclude function can be used to make an asynchronous request.
function getxmlHttpRequest(url)
{
	var req=getxmlHttpRequestObject();

	if (req) {
		var strUrl=url;
		if(strUrl.indexOf("127.0.0.1")>=0) {
			strUrl +="&random="+Math.floor(Math.random()*99999999);
			strUrl +="&HashID=v8k3ey5q1";
		};
		
		try {
			req.open('GET',strUrl,false);

			if (getBrowserName().toUpperCase().indexOf("EXPLORER")<0) {
				//req.timeout=60000; //not recognized by IE (IE6 at least)
			};
			
			//chrome doesn't like accept-encoding
			if(getBrowserUserAgent().toUpperCase().indexOf("CHROME")<0) {
				//neither does firefox
				var isFirefox=typeof InstallTrigger !=='undefined';
				if(!isFirefox) req.setRequestHeader("Accept-Encoding","gzip");
			};
			req.send(null);
			return(req.responseText);
		}
		catch(e) {
			//A false error is returned when a display is deleted.  Don't show an alert until this is worked out.  
			//alert("Error getting request. ["+e+"]\nPlease refresh the page and try again.");
			return("");
		};
	} 
	else {
		alert("Error getting request.  Please refresh the page and try again.");
		return("");
	}
	
	return("Error in getxmlHttpRequest: "+url);
};

/************************************************************************
	Using asynchInclue to return a result:
	
	Basically, this function calls itself again after the request is complete.
	
	function myfunc(arg) {
		if (!arg) {
			asynchInclude(null,url,"myfunc(req.responseText)");
		}
		else {
			alert("Results: "+arg);
		};
	};
************************************************************************/

//Entry for asynchInclude.  Used to allow recursion in asynchIncludesub so that an include can be tried a 2nd time if an empty string is returned
function asynchInclude(element,url,func,errfunc) {
	//for some reason, href="#" gets mangled in firefox.  The # symbol is replaced with a goofy url.  This prevents that from happening.
	var strUrl=replaceAllSubstrings(url,"href=\x22#\x22","href=\x22#\x22");
	strUrl=replaceAllSubstrings(url,"href='#'","href='#'");
	//appendToLog("asynchInclude: "+url);

	//12-27-2016: added this dummy call before executing the actual call.  While working on the login script 
	//in Registration 2017, there were sometimes long delays processing the asynchinclude used to refresh the 
	//content after the first asynchinclude was called to submit the form data (login or logout).
	//This did not seem to be a problem in Aspect.  Additional asynchinclude calls would be processed by Aspect 
	//while the login request was pending for 2 to 3 minutes.  Adding a dummy asynchinclude call seemed to 
	//solve the problem.  It may have something to do with the way the browser submits requests.
	
	//12-05-2017: Removed this call to asynchInclude because it generates a lot of traffic when customers are 
	//working remotely.  It may also increase the likelihood of too many active sockets in the browser.
	//May still need to look into the original problem that led to adding it in the first place
	//asynchIncludesub(0,null,getServer()+"/?network=greenlight&id=ping");

	asynchIncludesub(0,element,strUrl,func,errfunc);
};

//Does an asynchronous request to set the content for the given element.  This method allows the content of an element to be set
//without waiting for the server to return the content.  
function asynchIncludesub(count,element,url,func,errfunc)
{
	var req=getxmlHttpRequestObject();

	//Post is used because long urls required to submit a container item to the Aspect server
	//are truncated with get.  However, they are not truncated when the request is made to the local machine.
	var sMethod="post";
	
	var sUserAgent=getBrowserUserAgent();
	var bSafari=(sUserAgent.toUpperCase().indexOf("SAFARI")>=0) ? true : false;
	var bChrome=(sUserAgent.toUpperCase().indexOf("CHROME")>=0) ? true : false;
	
	//appendToLog("sUserAgent="+sUserAgent);
	//appendToLog("bSafari="+bSafari);
	//Safari on IPOD doesn't seem to support Post method.  Throws errors on content-length and connection headers
	if(bSafari) {
		//06-19-2017 Disabled this because Chrome uses safari in the user-agent and processitem 
		//requests are chopped off by the get method
		//if(sUserAgent.toUpperCase().indexOf("ANDROID")<0) sMethod="get"; 
	};
	
	if (req) {
		//var strUrl=url+"&random="+Math.floor(Math.random()*99999999);
		//strUrl +="&HashID=v8k3ey5q1";
		var strUrl=url;
		if(strUrl.indexOf("127.0.0.1")>=0) {
			strUrl +="&random="+Math.floor(Math.random()*99999999);
			strUrl +="&HashID=v8k3ey5q1";
		};

		strUrl=replaceAllSubstrings(strUrl,'\n','');
		strUrl=replaceAllSubstrings(strUrl,'\r','');
		strUrl=replaceAllSubstrings(strUrl,'\t','');
		
		//01-2017.  Add cookie.  This is done to pass session information to the server
		//to confirm that the session is valid
		strUrl +="&cookie=session="+getCookie("session")+";webid="+getCookie("webid");

		var n=strUrl.indexOf("?");
		if(n<1) alert("Error getting host and params in asynchInclude");
		var sHost=strUrl.substring(0,n-1);
		var sParams=strUrl.substring(n+1);
		//appendToLog("sHost1="+sHost+" sParams="+sParams);
		if((sHost.length<=1) || (sHost.equalsIgnoreCase("_"+"_RequestServer__")) || (sHost.equalsIgnoreCase("_"+"_SourceServer__"))) sHost=getServer();
		//appendToLog("sHost2="+sHost);
		//alert("Host="+sHost+"\nParams="+sParams);
		//appendToLog("asynchInclude: Method="+sMethod);
		//appendToLog("asynchInclude: "+strUrl);

		//=====================================================================================================
		//02-23-2017: Added the AsynchIncludeID attribute to handle situations in which content is updated 
		//multiple times.  A random value is recorded in the AsynchIncludeID attribute each time a call is 
		//made to update content.  If the attribute has been changed by the time the content is received from 
		//the server, then the element is not updated and will be updated by a subsequent call.  
		//=====================================================================================================
		var sSalt=getSalt(4);
		if(element) element.setAttribute("AsynchIncludeID",sSalt);
		
		req.onreadystatechange=function()
		{ 
			if(req.readyState==4) {
				if (req.status==200) {
					var s=req.responseText;
					if (element!=null) {
						
						if ((s.length==0) && (count<5) && (url.toUpperCase().indexOf("REFRESHTABLEONINTERVAL=TRUE")<0)) {
							appendToLog("asynchInclude failed.  Making attempt: "+(count+2),false,true);
							asynchIncludesub(count+1,element,url,func,errfunc);
							return;
						};
						
						if(s.trim().length==0) {
							//appendToLog("asynchinclude request failed.  url="+url,false,true);
						}
						else {
							//set a flag indicating the item has been successfully updated.
							element.setAttribute("AspectASynchInclude",new Date().getTime());
						};
						
						//=====================================================================================================
						//02-23-2017: The content of the element is only updated if the AsynchIncludeID attribute of the element is still
						//the same as it was when the call was made to get the content.  If the attribute has changed, it means
						//another call has been made to update the element while the previous call was still being handled.
						//=====================================================================================================
						if(element.getAttribute("AsynchIncludeID")==sSalt) {
							//appendToLog("asynchInclude updating content attr="+element.getAttribute("AsynchIncludeID")+" sSalt="+sSalt);
							//appendToLog("asynchInclude got "+s.length+" bytes");
							//appendToLog("s="+s.substring(0,Math.min(128,s.length)));
							element.innerHTML=replaceAllSubstrings(s,"__Request"+"Server__",getServer());
							element.setAttribute("updating",false);

							//=====================================================================================================
							//02-23-2017: Previously, the following function calls were made regardless of whether there were
							//subsequent calls being handled.  If the content of the element is being replaced by another successive
							//call, it shouldn't be necessary to execute these functions.  Watch for special cases.  For example,
							//is it ever necessary to execute func every time the call is made?  Keep in mind that many calls will 
							//use a null element and this will not be a factor.  It is only a factor when content is being loaded 
							//into an element.
							//=====================================================================================================
							
							//initialize tables if a table is included in the content.  This is necessary to initialize the
							//dialog for a table.  Otherwise, the dialog will not be initialized if the table is hidden and 
							//the dialog is shown initially.
							if(s.toUpperCase().indexOf("ASPECTVER")>=0) {
								//appendToLog("asynchInclude calling initializeTables2012()");
								initializeTables2012();
							};

							//adjust the height of the dialog containing the element if there is one.  The adjustDialogHeight traverses the parent nodes, starting
							//with element to see if element is contained in a dialog.  If it is, the dialog is resized if necessary to contain the updated content.
							//For example, a dialog's height may be increased to contain a table that is loaded into the dialog after the dialog is initialized or
							//when records are added to the table.
							adjustDialogHeight(element);

							addScripts();
							addStyles();
							addAnimations();
							if (func) eval(func);
						}
						else {
							//appendToLog("asynchInclude not updating content attr="+element.getAttribute("AsynchIncludeID")+" sSalt="+sSalt);
						};
					}
					else {
						if (func) eval(func);
					};
				}
				else {
					//Remember: Browser security prevents request across different domains
					if((count<5) && (url.toUpperCase().indexOf("REFRESHTABLEONINTERVAL=TRUE")<0)) {
						//appendToLog("asynchInclude failed.  Making attempt: "+(count+2),false,true);
						asynchIncludesub(count+1,element,url,func,errfunc);
						return;
					};

					//alert("asynchInclude error: "+req.status+" url: "+strUrl);
					if (element!=null) {
						element.setAttribute("updating",false);
						element.setAttribute("counter",60);
					};
					if (errfunc) eval(errfunc);
				};
			};
		}; 
		
		try {
			//appendToLog("asynchInclude opening connection to "+sHost);
			if(sMethod=="post") {
				req.open('POST',sHost,true);
				req.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
				//req.setRequestHeader("Content-length",sParams.length);
				//req.setRequestHeader("Connection", "close");
			}
			else {
				req.open('GET',strUrl, true);
			};
		}
		catch(e) {
			if (errfunc) eval(errfunc);
		};

		//chrome doesn't like accept-encoding
		try {
			//neither does firefox
			var isFirefox=typeof InstallTrigger !=='undefined';
			if((!isFirefox) && (bChrome==false) && (bSafari==false)) req.setRequestHeader("Accept-Encoding","gzip");
		}
		catch(e) {
			appendToLog("Error setting encoding in request "+e);
		};
		
		try {
			if(sMethod=="post") {
				req.send(sParams);
			}
			else {
				req.send(null);
			};
		}
		catch(e) {appendToLog("Error sending request: "+e);};
	} 
	else {
		element.innerHTML="Sorry, your browser does not support XMLHTTPRequest objects. This page requires Internet Explorer 5 or better for Windows, or Firefox for any system, or Safari. Other compatible browsers may also exist.";
	}
};



function inspectFAQ(FaqID,Dir,Name,FaqName) {
	var sParams="ViewID=sicv2e3W&Dir="+Dir+"&name="+Name+"&ListType=faq&taskID="+FaqID;
	if((Dir.toUpperCase().indexOf("SUPPORT")>=0) || (Dir.toUpperCase().indexOf("BACKOFFICE")>=0)) {
		sParams+="&source=v8k3ey5q1";
	};
	openInspectWindow(FaqName,sParams);
};


function inspectProcedure(ProcedureID,Dir,Name,ProcedureName) {
	var sParams="ViewID=sicv2e3W&Dir="+Dir+"&name="+Name+"&ListType=procedure&taskID="+ProcedureID;
	if((Dir.toUpperCase().indexOf("SUPPORT")>=0) || (Dir.toUpperCase().indexOf("BACKOFFICE")>=0)) {
		sParams+="&source=v8k3ey5q1";
	};
	openInspectWindow(ProcedureName,sParams);
};


function openVideoView(salt,VideoID,VideoTitle) {
	if(VideoID=="0") return;
	var sTitle=VideoTitle;
	if(!sTitle.toUpperCase().startsWith("VIDEO: ")) sTitle="Video: "+sTitle;
	openInspectWindow(sTitle,"ViewID=Sc3wxX77&VideoID="+VideoID+"&VideoTitle="+sTitle);
};


function playVideo2017(salt,VideoID,VideoTitle) 
{
	if(VideoID=="0") return;

	var eVideoFrame=document.getElementById(salt+"VideoFrame");
	if(!eVideoFrame) {
		appendToLog("Error: Cannot locate video container: "+salt+"VideoFrame");
		return;
	};

	var eVideoContainer=document.getElementById(salt+"VideoContainer");

	//show the video player
	setVisible(salt+"VideoFrame",true);

	var eVideoSource=document.getElementById(salt+"VideoSource");
	//var sNewSrc="http://img.aspectserver.com/videos/"+VideoID+".mp4";
	var sNewSrc="http://192.169.215.186/videos/"+VideoID+".mp4";
	var sCurrentSrc=eVideoSource.getAttribute("src");
	if(!sNewSrc.equalsIgnoreCase(sCurrentSrc)) {
		eVideoSource.setAttribute("src",sNewSrc);
		eVideoContainer.load();
		eVideoContainer.setAttribute("title",VideoTitle);
		eVideoContainer.setAttribute("VideoID",VideoID);
		initVideoListeners(eVideoContainer);
	};

};

function isMobileDevice()
{
	if(navigator.userAgent.toUpperCase().indexOf("MOBILE")>=0) return(true);
	if(navigator.userAgent.toUpperCase().indexOf("ANDROID")>=0) return(true);
	return(false);
};


function isHTMLInput(e) {
	return(("text,password,hidden,color,date,datetime,datetime-local,email,month,number,range,search,tel,time,url,week,".indexOf(e.type+",")>=0));
};

/******************************************************************************************************
DOCUMENT FUNCTIONS
******************************************************************************************************/
function documentWidth() {
	var w=630;

	if (parseInt(navigator.appVersion)>3) {
		if (navigator.appName=="Netscape") w=window.innerWidth;
		if (navigator.appName.indexOf("Microsoft")!=-1) w=document.body.offsetWidth;
	};
	
	return(w);
};

function documentHeight() {
	var h=460;

	if (parseInt(navigator.appVersion)>3) {
		if (navigator.appName=="Netscape") h=window.innerHeight;
		if (navigator.appName.indexOf("Microsoft")!=-1) h=document.body.offsetHeight;
	};

	return(h);
};

function setInnerHtml(strID,strValue)
{
	e=document.getElementById(strID);
	if (e) e.innerHTML=strValue;
};

function getBrowserCodeName() {
	return(navigator.appCodeName);
};

function getBrowserName() {
	return(navigator.appName);
};

function getBrowserVersion() {
	return(navigator.appVersion);
};

function getBrowserCookiesEnabled() {
	return(navigator.cookieEnabled);
};

function getBrowserPlatform() {
	return(navigator.platform);
};

function getBrowserUserAgent() {
	return(navigator.userAgent);
};

/*******************************************************************************
These two routines provide a replacement for setAttribute and getAttribute 
which don't seem reliable in IE.

Compatibility is provided for setAttribute and getAttribute.  For example,
calling getAttr will return the same value as getAttribute unless a value
has been recorded by setAttr.  This allows the two original routines to 
be replaced with the new ones without breaking existing code.

A unique identifier is created for the element by assigning it an ID if it
does not already have one.  

Unfortunately, IE does not support prototyping of elements either.  So
the functions are done again without prototyping.
*******************************************************************************/
/*
Element.prototype._setAttr=function(akey,avalue) {
	if(!this.id) this.id=getSalt(6);
	hashPut(this.id+":"+akey,avalue);
};

Element.prototype._getAttr=function(akey) {
	if(!this.id) return(this.getAttribute(akey));
	var o=hashGet(this.id+":"+akey);
	if(o) return(o);
	return(this.getAttribute(akey));
};
*/
function setAttr(e,akey,avalue) {
	if(!e.id) e.id=getSalt(6);
	hashPut(e.id+":"+akey,avalue);
};

function getAttr(e,akey) {
	if(!e.id) return(e.getAttribute(akey));
	var o=hashGet(e.id+":"+akey);
	if(o) return(o);
	return(e.getAttribute(akey));
};

function getViewportWidth() {
	// the more standards compliant browsers (mozilla/netscape/opera/IE7) use window.innerWidth and window.innerHeight
	if (typeof window.innerWidth !='undefined') return(window.innerWidth);

	// IE6 in standards compliant mode (i.e. with a valid doctype as the first line in the document)
	if (typeof document.documentElement !='undefined' && typeof document.documentElement.clientWidth !=
	 'undefined' && document.documentElement.clientWidth !=0) return(document.documentElement.clientWidth);

	// older versions of IE
	return(document.getElementsByTagName('body')[0].clientWidth);
};

function getViewportHeight() {
	// the more standards compliant browsers (mozilla/netscape/opera/IE7) use window.innerWidth and window.innerHeight
	if (typeof window.innerHeight !='undefined') return(window.innerHeight);

	// IE6 in standards compliant mode (i.e. with a valid doctype as the first line in the document)
	if (typeof document.documentElement !='undefined' && typeof document.documentElement.clientWidth !=
	 'undefined' && document.documentElement.clientHeight !=0) return(document.documentElement.clientHeight);

	// older versions of IE
	return(document.getElementsByTagName('body')[0].clientHeight);
};

function getViewportSize() {
	// the more standards compliant browsers (mozilla/netscape/opera/IE7) use window.innerWidth and window.innerHeight
	if (typeof window.innerWidth !='undefined') return(window.innerHeight);

	// IE6 in standards compliant mode (i.e. with a valid doctype as the first line in the document)
	if (typeof document.documentElement !='undefined' && typeof document.documentElement.clientWidth !=
	 'undefined' && document.documentElement.clientWidth !=0) return(document.documentElement.clientHeight);

	// older versions of IE
	return(document.getElementsByTagName('body')[0].clientHeight);
};

/*************************************************************************************
Returns the name of the currently selected option in the given select element
**************************************************************************************/
function getOptionName(eSelect) {
	if(!eSelect) return("");
	for (var i=0;i<eSelect.options.length;i++) {
		if (eSelect.options[i].value.equalsIgnoreCase(eSelect.value)) return(eSelect.options[i].innerHTML);
	};
	return("");
};

function getOptions(eSelect) {
	var s="";
	for(var i=0;i<eSelect.options.length;i++) {
		if(i>0) s +="|";
		s+=eSelect.options[i].value+"="+eSelect.options[i].text;
	};
	return(s);
};

function sizeTextareaHeight(e) {
	var iStartRows=e.rows;

	while ((e.rows > 1) && (e.scrollHeight < e.offsetHeight)) e.rows--;
	
	var h=0;
	while ((e.scrollHeight > e.offsetHeight) && (h!==e.offsetHeight)) {
		h=e.offsetHeight;
		e.rows++;
	}
	
	if (getBrowserName().toUpperCase().indexOf("EXPLORER")>=0) e.rows++;

	if(e.rows!=iStartRows) positionItems();
};

/******************************************************************************
Enables or disables all elements in the given element.  
e	- the element containing the elements to be enabled or disabled.  
b 	- true/false to enable or disable the elements.  
types- optional comma-delimited string indicating the types of elements to be affected
******************************************************************************/
function enableElements(e,b,types) { 
	var arType=getSubStringArray("input,select,textarea,button",",",true);
	if(types) arType=getSubStringArray("input,select,textarea,button",",",true);
	
	for (var i=0;i<arType.length;i++) {
		var arElements=e.getElementsByTagName(arType[i]); 
		for (var j=0; j<arElements.length; j++) { 
			arElements[j].disabled=(b==false);
		};
	};
}	

var arHashKey=new Array();
var arHashValue=new Array();

/*******************************************************************************
Adds a value to the hashtable.  The key must be a string.  The value may
be any type.
*******************************************************************************/
function hashPut(akey,avalue) {
	var n=arHashKey.indexOf(akey);
	if(n<0) n=arHashKey.length;
	arHashKey[n]=akey;
	arHashValue[n]=avalue;
	return(akey);
};

/*******************************************************************************
Retrieves a value from the hashtable
*******************************************************************************/
function hashGet(akey) {
	var n=arHashKey.indexOf(akey);
	if(n<0) return(null);
	return(arHashValue[n]);
};

function setWrap(e,b)
{
	if (e.wrap) {
		(b) ? e.wrap="hard" : e.wrap="off";
	} else { // wrap attribute not supported - try Mozilla workaround
		(b) ? e.setAttribute("wrap","hard") : e.setAttribute("wrap","off");
		var e2=e.cloneNode(true);
		e2.value=e.value;
		e.parentNode.replaceChild(e2,e);
	};
};

/*************************************************************************************
Validates the value of a date input and formats the input according to the pattern
specified in the input or its parent element
*************************************************************************************/
function validateDateInput(e) {
	var t=parseTime(e.value);
	var sPattern=e.getAttribute("pattern");

	//if a pattern is not found, look in the parent node.  In tables, the pattern will
	//be in the TD element and not the input element
	if(!sPattern) sPattern=e.parentNode.getAttribute("pattern");

	if(!sPattern) sPattern="MM-dd-yyyy HH:mm:ss";
	e.value=formatDate(t,sPattern);
};

/*************************************************************************************
Parses a time, allowing for HH:mm and HH:mm:ss strings
*************************************************************************************/
function parseTime(s){
	//get millisecond portion.  This is not parsed by javascript and needs to be added back here
	//MM-dd-yyyy HH:mm:ss:SSS-0700
	var sParse=s;
	var Milliseconds=0;
	if(s.length>=23) {
		Milliseconds=parseInt(s.substring(20,23));
		if(sParse.length>24) {
			sParse=replaceAllSubstrings(sParse.substring(0,19),"-","/")+sParse.substring(23,28);
		}
		else {
			sParse=replaceAllSubstrings(sParse.substring(0,19),"-","/");
		};
		var dt=new Date(Date.parse(sParse));
		return(new Date(dt.getTime()+Milliseconds));
	};

	//replace dash and backslash with forward slash 
	sParse=replaceAllSubstrings(sParse,"-","/");
	sParse=replaceAllSubstrings(sParse,"\x5C","/");
	sParse=sParse.trim();

	var sDate="12/31/1969";
	var sTime="00:00";

	if(sParse.indexOf(" ")>0) {
		//it's a date and time 
		var n=sParse.indexOf(" ");
		sDate=sParse.substring(0,n);
		sTime=sParse.substring(n+1);

		if(sDate.length==8) {
		//it's a date - MMddyyyy
			sDate=sDate.substring(0,2)+"/"+sDate.substring(2,4)+"/"+sDate.substring(4);
		}
		else if(sDate.length==4) {
			//it's a date - MMdd
			sDate=sDate.substring(0,2)+"/"+sDate.substring(2)+"/"+new Date().getFullYear();
		}

		//see if there is only one slash or two
		var n1=sDate.indexOf("/");
		var n2=sDate.indexOf("/",n1+1);
appendToLog("parseTime sDate="+sDate+" n1="+n1+" n2="+n2);
		if(n2<0) {
			//if only one slash (MM/dd) add the year
			sDate=sDate.substring(0,n1)+"/"+sDate.substring(n1+1)+"/"+new Date().getFullYear();
		}
		else {
			//check for 2 digit year.  The first slash must be in position n=2 to avoid 
			//including yyyy/mm/dd format in these lines.
			if(n1==2) {
				sMonth=sDate.substring(0,n1);
				sDay=sDate.substring(n1+1,n2);
				sYear=sDate.substring(n2+1);
				if(sYear.length==2) {
					sYear=new Date().getFullYear().toString().substring(0,2)+sYear;
					sDate=sMonth+"/"+sDay+"/"+sYear;
				};
			};
		};
	}
	else if(sParse.indexOf("/")>0) {
		//it's a date only
		sDate=sParse;

		//see if it's in yyyy-MM-dd format
		if(sDate.charAt(4)=="/") {
			//if a two digit year was entered, it will start with 00.  Convert it to a four digit year.
			var sYear=sDate.substring(0,4);
			if(sYear.startsWith("00")) {
				sYear="20"+sYear.substring(2);
			};
			sDate=sDate.substring(5)+"/"+sYear;
		}
		else {
			//see if there is only one slash or two
			var n1=sParse.indexOf("/");
			var n2=sParse.indexOf("/",n1+1);
			if(n2<0) {
				//if only one slash (MM/dd) add the year
				sDate=sDate.substring(0,n1)+"/"+sDate.substring(n1+1)+"/"+new Date().getFullYear();
			}
			else {
				//check for 2 digit year
				sMonth=sDate.substring(0,n1);
				sDay=sDate.substring(n1+1,n2);
				sYear=sDate.substring(n2+1);
				if(sYear.length==2) {
					sYear=new Date().getFullYear().toString().substring(0,2)+sYear;
					sDate=sMonth+"/"+sDay+"/"+sYear;
				};
			};
		};
	}
	else if(sParse.indexOf(":")>0) {
		//it's a time only
		sTime=sParse;
	}
	else if(sParse.length==8) {
		//it's a date - MMddyyyy
		sDate=sParse.substring(0,2)+"/"+sParse.substring(2,4)+"/"+sParse.substring(4);
	}
	else if(sParse.length==4) {
		//it's a date - MMdd
		sDate=sParse.substring(0,2)+"/"+sParse.substring(2)+"/"+new Date().getFullYear();
	}
	else {
		//the format is invalid
		return(new Date(0));
	};
	
	appendToLog("parsing "+sDate+" "+sTime);
	printStackTrace();
	var dt=new Date(Date.parse(sDate+" "+sTime));
	if (isNaN(dt)) dt=new Date();
	return(new Date(dt.getTime()));
};

function oldparseTime(s){
	if((s.length==5) && (s.charAt(2)==":")) {
		s="12/31/1969 "+s+":00";
	}
	else if((s.length==8) && (s.charAt(2)==":")) {
		s="12/31/1969 "+s;
	};
	return(new Date(Date.parse(s)));
};

function isNumberField(FieldType) {
	if((FieldType==2) || (FieldType==4) || (FieldType==5) || (FieldType==6) || (FieldType==7) || (FieldType==8) || (FieldType==9) || (FieldType==12)) return(true);
	return(false);
};

function isTimeField(FieldType) {
	if((FieldType==10) || (FieldType==13) || (FieldType==18) || (FieldType==21)) return(true);
	return(false);
};

/******************************************************************************************************
MISCELLANEOUS UTILITIES
******************************************************************************************************/
//Returns a property for the border of the given element.  
//sborder is top, left, right or bottom
//sprop is width, style or color.  "px" is removed from the width in the return value
function getBorderProperty(e,sborder,sprop) {
	if(sborder.equalsIgnoreCase("top")) {
		var s=e.style.borderTop;
	}
	else if(sborder.equalsIgnoreCase("left")) {
		var s=e.style.borderLeft;
	}
	else if(sborder.equalsIgnoreCase("bottom")) {
		var s=e.style.borderBottom;
	}
	else if(sborder.equalsIgnoreCase("right")) {
		var s=e.style.borderRight;
	}
	else {
		return("error");
	};
//alert("border="+s);	
	//Get array of properties.  Of course, they're in a different order in each browser (e.g. 1px solid #ffffff or solid 1px #ffffff
	var arString=getSubStringArray(s," ",true);
	if(arString!=null) {
		if(sprop.equalsIgnoreCase("width")) {
			for (var i=0;i<arString.length;i++) {
				if(arString[i].toUpperCase().indexOf("PX")>0) return(parseInt(replaceAllSubstrings(arString[i],"px","")));
			};
			return("error");
		};

		if(sprop.equalsIgnoreCase("style")) {
			for (var i=0;i<arString.length;i++) {
				if((arString[i].toUpperCase().indexOf("PX")<0) && (arString[i].indexOf("#")<0) && (arString[i].toUpperCase().indexOf("RGB")<0)) return(arString[i]);
			};
			return("error");
		};

		if(sprop.equalsIgnoreCase("color")) {
			for (var i=0;i<arString.length;i++) {
				if((arString[i].toUpperCase().indexOf("RGB")>=0) || (arString[i].indexOf("#")>=0)) return(arString[i]);
			};
			return("error");
		};
	};
	return("error");
};

/*	Gets the xy position of an element relative to the body of the document */
function getPosition(e){
	var topValue=0,leftValue=0;
	while(e){
		leftValue+=e.offsetLeft;
		topValue+=e.offsetTop;
		e=e.offsetParent;
	}
	var arXY=new Array(leftValue,topValue);
	return arXY;
};

/*	Gets the description associated with the selected option in a select input */
function getOptionDescription(strFormName,strElementName)
{
	var e=document.forms[strFormName];
	if (e) {
		e=document.forms[strFormName].elements[strElementName];
		if (e) {
			for (var i=0;i<e.options.length;i++) {
				if (e.options[i].value.equalsIgnoreCase(e.value)) return(e.options[i].innerHTML);
			};
		};
	};
	
	return("");
};

/******************************************************************************
Adds a div on top of an element.  Used to disable controls in the element.
e	-	Element to which overlay will be added
ID	-	An optional ID to be given to the overlay.  This can be used to 
		remove the overlay.
******************************************************************************/
function removeOverlay(el)
{
	var e=document.getElementById(el);
	if(!e) e=el;
	if(!e) return;
	
	e.parentNode.removeChild(e);
};

function applyOverlay(el,ID)
{
	var e=document.getElementById(el);
	if(!e) e=el;
	if(!e) {
		appendToLog("Error in applyOverlay.  e is null",false,true);
		printStackTrace();
		return;
	};
	var img=document.createElement("img");
	img.src=imgOverlay.src;
	img.style.position="absolute";
	img.style.left="0px";
	img.style.top="0px";

	//modified 04-13-2013.  The intent is to add a new element at the start of the div containing the table
	//and set the positionubg,  The positioning of the overlay may be unpredictable if the positioning of the 
	//parent is not specified.
	var div=document.createElement("div");
	div.style.position="relative";
	e.insertBefore(div,e.firstChild)
	var xy=getPosition2012(div,"absolute",div);
	img.style.position="absolute";
	img.style.left=xy[0]+"px";
	img.style.top=xy[1]+"px";

	img.width=e.offsetWidth-2;
	img.height=e.offsetHeight-2;
	//img.style.width="100%";
	//img.style.height="100%";
	//img.style.filter="alpha(opacity=50)";
	//img.style.opacity="0.5";
	img.style.overflow="hidden";
	if(ID) div.id=ID;

	//modified 04-13-2013.  The image is added to the new div instead of the table div
	//e.appendChild(img);
	div.appendChild(img);
	
	if(false) {
		var d=document.createElement("div");
		if(ID) d.id=ID;
		d.style.position="absolute";
		d.style.left="0px";
		d.style.top="0px";
		d.style.background="#eaeaea";
		d.style.width=e.offsetWidth+"px";
		d.style.zIndex="98"; //don't hide the message dialog with uses 99 as the z index.
		d.style.height=e.offsetHeight+"px";
		d.style.opacity="0.5";
		d.style.border="none";
		d.style.margin="0px";
		d.style.padding="0px";
		d.style.overflow="hidden";
		d.appendChild(img);
		e.appendChild(d);
	};
};

/*********************************************************************************
Clears the innerHTML of the given item and displays the status icon.  Used to 
display the status icon when refreshing content of an element
*********************************************************************************/
function showStatusIcon(aitem)
{
	var e=document.getElementById(aitem);
	if(!e) e=aitem;
	if(!e.nodeName) {
		alert("Error in setVisible: "+aitem);
		return;
	};
	
	e.innerHTML="";

	//var img=document.createElement("img");
	//img.src=imageStatusActive.src;
	//e.appendChild(img);

	var eProgress=document.createElement("progress");
	e.appendChild(eProgress);
};

function setElementValue(strElementID,strValue)
{
	e=document.getElementById(strElementID);
	if (e) {
		e.value=strValue;
	}
	else {
		alert("Cannot locate element: "+strElementID+" in setElementValue()");
	};
};

/* Inserts a node after another  node */
function insertAfter( referenceNode, newNode ) {
	if(referenceNode==null) {
		appendToLog("Error in insertAfter.  reference=null newNode="+newNode.ID);
		printStackTrace();
		return;
	};
	
	if(referenceNode.parentNode) {
		referenceNode.parentNode.insertBefore( newNode, referenceNode.nextSibling );
	}
	else {
		alert("Missing parent node when adding node "+newNode.ID+" before: "+referenceNode+"\n\n"+referenceNode.innerHTML);
	};
};


/*	Concatenates all elements in a form to create a string used to submit the form.  E.g. param1=value1&param2=value2...
	The result does not include the server address or the /?
	One way this can be used it to submit a form to an Aspect script for processing without reloading the page.
	See the form named sendFilesForm in the Send Files widget in the Customer Support library for an example.
*/
function getFormSubmissionUrl(f)
{
	var strUrl="";
	for (var i=0;i<f.elements.length;i++) {
		if ((f.elements[i].name) && (f.elements[i].value) && ((f.elements[i].type!="button"))) {
			if (f.elements[i].type=='checkbox') {	
				//don't submit checkboxes that aren't checked
				if (f.elements[i].checked) strUrl=addElement(strUrl,f.elements[i].name+"="+tokenizeSpecialChars(f.elements[i].value,true),"&");
			}
			else {
				strUrl=addElement(strUrl,f.elements[i].name+"="+tokenizeSpecialChars(f.elements[i].value,true),"&");
			};
		};
	};
	return(strUrl);
};
	
/******************************************************************************
Returns a list of all child nodes belonging directly or indirectly to the given 
parent.  arNodes must be initialized before the call.  
******************************************************************************/
function getAllChildNodes(e,arNodes)
{
	for(var i=0;i<e.childNodes.length;i++) {
		var eChild=e.childNodes[i];
		if(eChild.nodeName.indexOf("#")<0) {
			arNodes[arNodes.length]=eChild;
			getAllChildNodes(eChild,arNodes);
		};		
	};
};

/******************************************************************************
Returns a list of all input nodes (checkbox, select, text) belonging directly or indirectly to the given 
parent.
******************************************************************************/
function getAllInputNodes(e,arNodes)
{
	for(var i=0;i<e.childNodes.length;i++) {
		var eChild=e.childNodes[i];
		if(eChild.nodeName.indexOf("#")<0) {
			//09-14-2016 Modified this to include all nodes with nodeName=INPUT to include html5 inputs like
			//date and number
			//if((eChild.type=="checkbox") || (eChild.type=="select-one") || (eChild.type=="select-multiple") || (eChild.type=="text") || (eChild.type=="date") || (eChild.type=="password") || (eChild.type=="textarea")) {
			if((eChild.nodeName=="INPUT")  || (eChild.type=="select-one") || (eChild.type=="select-multiple") || (eChild.type=="textarea")) {
				arNodes[arNodes.length]=eChild;
			}
			else {
				getAllInputNodes(eChild,arNodes);
			};
		};		
	};
};

function setDimensions(e) {
	var bDebug=((e.id) && (e.id.equalsIgnoreCase("588702")));
	if((e.getAttribute("AutoWidth")) && (boolVal(e.getAttribute("AutoWidth")))) {
		e.style.width="auto";
	};
	if((e.getAttribute("AutoHeight")) && (boolVal(e.getAttribute("AutoHeight")))) {
		e.style.height="auto";
	};

	if (bDebug) appendToLog(e.id+" w1="+e.style.width+" h1="+e.style.height+" offsetw="+e.offsetWidth+" offseth="+e.offsetHeight);
	
	if((e.offsetWidth>0) && (e.offsetHeight>0)) {
		if(e.getAttribute("minwidth")) {
			var n=parseInt(e.getAttribute("minwidth"));
			if((n>0) && (e.offsetWidth<n)) e.style.width=n+"px";
		};
		if(e.getAttribute("maxwidth")) {
			var n=parseInt(e.getAttribute("maxwidth"));
			if((n>0) && (e.offsetWidth>n)) e.style.width=n+"px";
		};
		if(e.getAttribute("minheight")) {
			var n=parseInt(e.getAttribute("minheight"));
			if((n>0) && (e.offsetHeight<n)) e.style.height=n+"px";
		};
		if(e.getAttribute("maxheight")) {
			var n=parseInt(e.getAttribute("maxheight"));
			if((n>0) && (e.offsetHeight>n)) e.style.height=n+"px";
		};
	};
	
	if (bDebug) appendToLog(e.id+" w2="+e.style.width+" h2="+e.style.height);
};



//======================================================================================================
//Refreshes all span and div tags that have an interval and url defined.  Also initiates refreshing of tables that have an interval
//specified.
//======================================================================================================
var bRefreshWidgetsInitialized=false;

function refreshWidgets(bIsInitialized) {

	//console.log(new Date()+" refreshWidgets bIsInitialized="+bIsInitialized);

	if(!bIsInitialized) {
		//this function has been called by the widget container and not by a timeout set in this function
		if(!bRefreshWidgetsInitialized) {
			//console.log(new Date()+" setTimeout1 for refreshWidgets");
			bRefreshWidgetsInitialized=true;
			setTimeout("refreshWidgets(true)",10000);
		};
		return;
	};

	if(bContainerLoaded==true) {
		//console.log(new Date()+" calling refreshWidgetsSub");
		refreshWidgetsSub();
	};

	//console.log(new Date()+" setTimeout2 for refreshWidgets");
	setTimeout("refreshWidgets(true)",10000);
};

function refreshWidgetsSub() {
	//enable refresh on interval for any tables that have an interval specified
	var arTable=document.getElementsByTagName("table");
	for(var i=0;i<arTable.length;i++) {
		var bRefreshOnIntervalInitiated=false;
		if(arTable[i].getAttribute("AspectRefreshOnIntervalInitiated")) {
			bRefreshOnIntervalInitiated=arTable[i].getAttribute("AspectRefreshOnIntervalInitiated").equalsIgnoreCase("true");
		};
		
		if(!bRefreshOnIntervalInitiated) {
			var iRefreshIntervalLocal=0;
			var iRefreshIntervalRemote=0;
			if(arTable[i].getAttribute("AspectRefreshInterval")) iRefreshIntervalLocal=parseInt(arTable[i].getAttribute("AspectRefreshInterval"));
			if(arTable[i].getAttribute("AspectRefreshIntervalRemote")) iRefreshIntervalRemote=parseInt(arTable[i].getAttribute("AspectRefreshIntervalRemote"));
			
			if((iRefreshIntervalLocal>0) || (iRefreshIntervalRemote>0)) {
				var iActiveInterval=0;
				var sActiveRefreshWhenHidden=false;
				if(arTable[i].getAttribute("AspectHashID").equalsIgnoreCase("v8k3ey5q1")) {
					iActiveInterval=iRefreshIntervalLocal*1000;
					sActiveRefreshWhenHidden=arTable[i].getAttribute("RefreshWhenHidden");
				}
				else {
					iActiveInterval=iRefreshIntervalRemote*1000;
					sActiveRefreshWhenHidden=arTable[i].getAttribute("RefreshWhenHiddenRemote");
				};

				if(iActiveInterval>0) {
					arTable[i].setAttribute("AspectActiveRefreshInterval",iActiveInterval);
					arTable[i].setAttribute("AspectActiveRefreshWhenHidden",sActiveRefreshWhenHidden);
					arTable[i].setAttribute("AspectRefreshOnIntervalInitiated","true");
					setTimeout("refreshTableOnInterval(\x22"+arTable[i].id+"\x22)",iActiveInterval);
				};
			};
		};
	};
	
	//see if an edit window is open and don't refresh if it is (this is for dialogs used to edit an item in a widget container)
	var arDiv=document.getElementsByTagName("div");
	for (var i=0;i<arDiv.length;i++) {
		var strID=arDiv[i].getAttribute("ID");
		if (strID) {
			if ((strID.toUpperCase().indexOf("EDITOVERLAY")>0) || (strID.toUpperCase().indexOf("DELETEOVERLAY")>0)) {
				if (arDiv[i].style.display.equalsIgnoreCase("block")) {
					intRefreshingWidgets--;
					if(intRefreshingWidgets<0) intRefreshingWidgets=0;
					//Don't refresh too frequently because initializeTabbedDialogs() might be costly
					setTimeout("refreshWidgets()",10000);
					return;
				};
			};
		};
	};
	
	var arTagNames=new Array(2);
	arTagNames[0]="span";
	arTagNames[1]="div";
	
	var tNow=new Date().getTime();
	
	for(var i=0;i<arTagNames.length;i++) {
		var e=document.getElementsByTagName(arTagNames[i]);
		//appendToLog("refreshWidgets e.length="+e.length);
		for (var j=0;j<e.length;j++) {
			var strUrl=e[j].getAttribute("url");
			if (strUrl) {
			
				//check for any tables in the item and see if a dialog is opened for a table
				//Note:  This takes too long.  Can't initialize a list of dialog ID's one time
				//because they may change if new items are added to the page.  
				var bDialogOpen=false;
				/*
				var arTable=e[j].getElementsByTagName("table");
				for(var k=0;k<arTable.length;k++) {
					var sDialogID=arTable[k].getAttribute("EditDialogID");
					if(sDialogID) {
						var sDisplay=document.getElementById(sDialogID).style.display;
						if((sDisplay) && (sDisplay.equalsIgnoreCase("block"))) {
							bDialogOpen=true;
						};
					};
				};
				*/
				
				if(!bDialogOpen) {
					strUrl=replaceAllSubstrings(strUrl,"\n","");
					strUrl=replaceAllSubstrings(strUrl,"\r","");
					strUrl=replaceAllSubstrings(strUrl,"\t","");

					var intInterval=e[j].getAttribute("interval");
					
					//determine if the item is visible.  If not, only update if the interval is set to 0
					var bIsVisible=(e[j].offsetWidth>0)
//console.log("refreshWidgetsSub bIsVisible="+bIsVisible+" intInterval="+intInterval);
					//only update if an interval has been specified and if it's >=0
					if (((intInterval) && (intInterval>=0)) && ((bIsVisible) || (intInterval=0)))
					{
//console.log("getting url for ID: "+e[j].id+" url=["+strUrl+"]");
						//if it's 0, set it to -1 so it's only updated one time and does not repeat
						if(intInterval==0) e[j].setAttribute("interval","-1");
						
						var intCntr=e[j].getAttribute("counter");
						if (!intCntr) {
							e[j].setAttribute("counter","0");
							intCntr=0;
						};
						
						var boolUpdating=e[j].getAttribute("updating");
						//appendToLog("Counter="+intCntr+" updating="+boolUpdating+" url="+strUrl);
						
						//NOTE: 10-08-2012 It looks like this function may be running twice because the 
						//timeout is set to 10,000 but it appears to be running twice that fast.
						//The counter is decremented by 5 instead of 10 below for now to account for it.
						if((boolUpdating==null) || (boolUpdating=="false") || (boolUpdating==false))
						{
							if (intCntr<=0) {
								var bShouldUpdate=true;
								var LastUpdate=e[j].getAttribute("AspectASynchInclude");
								if(LastUpdate) {
									var tElapsed=(tNow-parseInt(LastUpdate))/1000;
									if(tElapsed<intInterval) {
										bShouldUpdate=false;
										//alert("aborting update because only "+tElapsed+" seconds have elapsed of "+intInterval+"\nUrl="+strUrl);
									}
									else {
										//alert("Allowing update because "+tElapsed+" seconds have elapsed of "+intInterval+"\nUrl="+strUrl);
									};
								};
								
								if(bShouldUpdate) {
									e[j].setAttribute("counter",intInterval);
									e[j].setAttribute("updating",true);
									var sFuncOk="initializeReport()";
									var sUrlFunc=e[j].getAttribute("urlfunc");
									if(sUrlFunc) sFuncOk +=";"+sUrlFunc;
									var sErrFunc="";
									var sID=e[j].ID;
									asynchInclude(e[j],strUrl,sFuncOk,sFuncOk);
								}
								else {
									intCntr-=10;
									e[j].setAttribute("counter",intCntr);
								};
							}
							else {
								intCntr-=10;
								e[j].setAttribute("counter",intCntr);
							};
						}
						else {
							intCntr-=10;
							
							//if the item has been updating for x minutes, set the updating flag to false
							//This is to correct a situation in which the updating flag is not cleared do to an undetermined error 
							//asynchInclude() sets the update flag to false so this should never happen but it has
							if(intCntr<-240) e[j].setAttribute("updating",false);
							
							e[j].setAttribute("counter",intCntr);
							//alert("already updating");
						};
					}
					else {
//console.log("not updating ID: "+e[j].id+" url=["+strUrl+"]");
					};
				};
			};
		};
	};
};




var JavascriptVer="06.06.2019.02";

var PendingSubmissionBackgroundColor="#f5f5a3"

var imageStatusActive=new Image();
imageStatusActive.src="__RequestServer__/?Network=Greenlight&ID=getImage&filename=/C:/aspect7/aspect7.jar/packages/aspect/core/doc/images/StatusActive01.gif";

var imgOverlay=new Image();
//imgOverlay.src="__RequestServer__/?Network=GreenLight&ID=getImage&filename=disableoverlay.png";
imgOverlay.src=getServer()+"/?Network=GreenLight&ID=getImage&filename=disableoverlay.png";

//This is set to true for mobile devices in TCacheWidget:initializeWidgetContainer()
var bIsMobileDevice=false;

//Set by mergeList() in the widget container when all items have been loaded.  Used to avoid updating url's in refreshWidgets()
//that are in processed items with the ID __processed before they have been moved to the actual item.
var bContainerLoaded=false;


/******************************************************************************************************
INITIALIZATION FUNCTIONS
******************************************************************************************************/
function aspectinit()
{
	refreshWidgets();
	initializeTabbedDialogs();
	
	//set unique identifier for this browser
	var s=getCookie("webid");
	if((!s) || (s.trim().length==0)) {
		setCookie("webid",getSalt(6));
	};

	if(eval('typeof ga')=="function") {
		ga('set','dimension3',getCookie("webid"));
	};
};





/******************************************************************************************************
Cookie functions
******************************************************************************************************/
function setCookie(name,value,exp_y,exp_m,exp_d,path,domain,secure) {
	var sCookie=name + "=" + escape(value);

	if (exp_y) {
		var expires=new Date(exp_y,exp_m,exp_d);
		sCookie +="; expires=" + expires.toGMTString();
	}

	if (path) sCookie +="; path=" + escape(path);
	if (domain) sCookie +="; domain=" + escape(domain);
	if (secure) sCookie +="; secure";
	document.cookie=sCookie;
};

function getCookie(cookie_name) {
	var sResult=document.cookie.match ('(^|;) ?' + cookie_name + '=([^;]*)(;|$)');
	if(sResult) {
		return(unescape(sResult[2]));
	}
	else {
		return null;
	};
};

function deleteCookie(name) {
	setCookie(name,"",1970,1,1);
};



/*************************************************************************
This function is used to scroll a table dialog into view, especially for
mobile devices.  The scrollIntoViewIfNeeded function is only available in 
Chrome and perhaps some other browsers.  It will have to be implemented
with code.  Right now this function has no effect if scrollIntoViewIfNeeded 
is undefined.  
*************************************************************************/
function scrollElementIntoView(e) {
	if(e.scrollIntoViewIfNeeded) {
		e.scrollIntoViewIfNeeded(true);
	}
	else {
		//this needs work.  In particular, dialogs for records near the bottom 
		//of a table where the dialog extends beneath the table jump when this
		//function is called.
		if(false) {
	    var ParentRect=e.parentNode.getBoundingClientRect();
	    var eRect=e.getBoundingClientRect();
			if (eRect.top < ParentRect.top || eRect.bottom > ParentRect.bottom
	       || eRect.right > ParentRect.right || eRect.left < ParentRect.left)
	    e.scrollIntoView();
		};
	};
};

/*************************************************************************
Gets the coordinates that would be used to position the element using 
fixed positioning.  Called by getPosition2012().
*************************************************************************/
//for debugging
var sPositionLog="";

function getOrientation(){
    return((Math.abs(window.orientation) - 90==0) ? "landscape" : "portrait");
};

function getFixedCoord(e) {
	sPositionLog +="getPosition for "+e.id+"\r\n";
	var topValue=0,leftValue=0;

	//get fixed coordinates
	var e2=e;
	var bDone=false;
	while((e2) && (bDone==false)) {
		if(e2.style) {
			var sNodeName=(e2.nodeName) ? e2.nodeName : "";
			leftValue+=e2.offsetLeft;
			topValue+=e2.offsetTop;
			sPosition=e2.style.position;
			if(sPosition.equalsIgnoreCase("fixed")) bDone=true;
			sPositionLog +="offset ["+sNodeName+":"+sPosition+"] "+e2.id+" x="+e2.offsetLeft+" y="+e2.offsetTop+" left="+leftValue+" top="+topValue+"\r\n";
		};
		e2=e2.offsetParent;
	};

	//adjust for scrolling
	bDone=false;
	var e2=e;
	while((e2) && (!bDone)) {
		var sNodeName=(e2.nodeName) ? e2.nodeName : "";
		if(e2.style) {
			if(sNodeName.equalsIgnoreCase("body")) {
				if(e2.scrollLeft) leftValue -=e2.scrollLeft;
				if(e2.scrollTop) topValue -=e2.scrollTop;
				sPositionLog +="scroll ["+sNodeName+":"+sPosition+"] "+e2.id+" x="+e2.scrollLeft+" y="+e2.scrollTop+" left="+leftValue+" top="+topValue+"\r\n";
			}
			else {
				sPosition=e2.style.position;
				if(sPosition.equalsIgnoreCase("fixed")) {
					bDone=true;
				}
				else {
					//Note: Checking for auto in the width and height addresses a situation with items in widget containers that
					//have width and height set to auto but also have the autoscroll property set to true.  If this was not here,
					//an item with a scrollbar would be positioned too high on the page.  Editing the call log item after scrolling
					//down the calls is an example.
					if(e2.scrollLeft) {
						if(e2.style.width.equalsIgnoreCase("auto")) {
						}
						else {
							leftValue -=e2.scrollLeft;
						};
					};
					if(e2.scrollTop) {
						if(e2.style.height.equalsIgnoreCase("auto")) {
						}
						else {
							topValue -=e2.scrollTop;
						};
					};
				};
				sPositionLog +="scroll ["+sNodeName+":"+sPosition+"] "+e2.id+" x="+e2.scrollLeft+" y="+e2.scrollTop+" left="+leftValue+" top="+topValue+"\r\n";
			};
		};
		e2=e2.parentNode;
	};

	return(new Array(leftValue,topValue));
};

/*************************************************************************
Returns an array containing the left and top values for positioning an
element using either fixed or absolute.  
e		- The element on which the positioning is based 
Method	- fixed or absolute
eParent	- The parent element to which the positioned element will be added
*************************************************************************/
function getPosition2012(e,Method,eParent)
{
	var bDebug=false;
	sPositionLog="";

	//get the coordinates that would be used to position the item using "fixed"
	var arXY=getFixedCoord(e);

	if(bDebug) {
		var eFixed1=document.getElementById("DebugPositioning1");
		if(!eFixed1) {
			eFixed1=document.createElement("div");
			eFixed1.id="DebugPositioning1";
			eFixed1.style.position="fixed";
			eFixed1.style.background="yellow";
			eFixed1.style.zIndex="99";
			eFixed1.style.width="60px";
			eFixed1.style.height="10px";
			eFixed1.innerHTML="fixed-1";
			document.getElementsByTagName('BODY')[0].appendChild(eFixed1);
		};
		eFixed1.style.left=arXY[0]+"px";
		eFixed1.style.top=arXY[1]+"px";
	};
	
	//if method is absolute, make coordinates relative to parent
	if(Method.equalsIgnoreCase("absolute")) {
		if(eParent) {
			sPositionLog+="Converting to relative coordinates\r\n";
			var ParentXY=getFixedCoord(eParent);

			if(bDebug) {
				var eFixed2=document.getElementById("DebugPositioning2");
				if(!eFixed2) {
					eFixed2=document.createElement("div");
					eFixed2.id="DebugPositioning2";
					eFixed2.style.position="fixed";
					eFixed2.style.background="yellow";
					eFixed2.style.zIndex="99";
					eFixed2.style.width="60px";
					eFixed2.style.height="10px";
					eFixed2.innerHTML="fixed-2";
					document.getElementsByTagName('BODY')[0].appendChild(eFixed2);
				};
				
				eFixed2.style.left=ParentXY[0]+"px";
				eFixed2.style.top=ParentXY[1]+"px";
			};
			
			sPositionLog +="Parent X="+ParentXY[0]+" Y="+ParentXY[1]+"\r\n";
			arXY[0] -=ParentXY[0];
			arXY[1] -=ParentXY[1];
			sPositionLog +="New X="+arXY[0]+" Y="+arXY[1]+"\r\n";
		}
		else {
			alert("Missing parent element in getPosition()");
		};
	};

		
	if(bDebug) appendToLog(sPositionLog,false,true);
	return arXY;
};

function getPosition2012old(e,Method,eParent)
{
	var topValue=0,leftValue=0;

	//calculate offset
	var e2=e;
	var bDone=false;
	while((e2) && (bDone==false)) {
		leftValue+=e2.offsetLeft;
		topValue+=e2.offsetTop;
		e2=e2.offsetParent;
		if((e2) && (Method.equalsIgnoreCase("absolute"))) {
			var s=e2.style.position;
			if((s) && (s.equalsIgnoreCase("absolute"))) bDone=true;
		};
	};

	//adjust for scrolling
	var e2=e;
	while(e2){
		//This differs from javascript1 because the page is not in an iframe
		var sNodeName=(e2.nodeName) ? e2.nodeName : "";
		
		//only account for scrolling of the body element when the method is fixed.  This was modified then tooltips
		//were changed to fixed positioning.  The tooltips require body scrolling to be included.  However, table
		//dialogs, which use absolute positioning, require scrolling of the body to be ignored
		if((Method.equalsIgnoreCase("fixed")) || (e2.nodeName.equalsIgnoreCase("body")==false)) {
			if(e2.scrollLeft) leftValue -=e2.scrollLeft;
			if(e2.scrollTop) topValue -=e2.scrollTop;
		};
		
		e2=e2.parentNode;
	};
	
	var arXY=new Array(leftValue,topValue);
	return arXY;
};



/******************************************************************************
Returns the protocol and host in the form http://xxx.xxx.xxx.xxx:xxxx/
******************************************************************************/
function getServer() {
	//Get server.  Check for aspect-software.net and override it with the Aspect server.
	//This allows pages to be loaded from aspect-software.net and for them to include a table 
	//using asynchinclude.  When the table is refreshed, getserver() cannot be used because it returns
	//aspect-software.net.  In this case, override the server with the actual Aspect server IP.
	var s=window.location.protocol+"//"+window.location.host;
	if(s.toUpperCase().indexOf("ASPECT-SOFTWARE")>=0) {
		s="http://192.169.215.186:4446";
	};
	return(s);

	//return(window.location.protocol+"//"+window.location.host);
};

/******************************************************************************
Returns the host name and port in the form xxx.xxx.xxx.xxx:xxxx
******************************************************************************/
function getHost() {
	return(window.location.host);
};

/******************************************************************************
Returns the name part of the host
******************************************************************************/
function getHostName() {
	return(window.location.hostname);
};

/******************************************************************************
Returns the port number of host
******************************************************************************/
function getPort() {
	return(window.location.port);
};

/******************************************************************************
Returns the protocol (http: or https:)
******************************************************************************/
function getProtocol() {
	return(window.location.protocol);
};

/******************************************************************************
Returns the path of the current url
******************************************************************************/
function getPathname() {
	return(window.location.pathname);
};




function hideTooltip(e)
{
	if (e) e.style.display="none";
};

function showTooltip(e,Msg,OffsetX,OffsetY,MaxWidth)
{
	//don't show tooltips for mobile devices
	if(bIsMobileDevice) return;
	if(isMobileDevice()) return;
	//alert("user: "+navigator.userAgent);
	if(screen.width<1024) return; //just a guess.  May not work for tablets.
	
	//disable tooltips for Microsoft version 6 (which shows as version 4 in getBrowserVersion) because the tooltips are not z-indexed properly
	//if ((getBrowserName().startsWith("Microsoft")) && (getBrowserVersion().startsWith("4.0"))) return;
	strMsg=replaceAllSubstrings(Msg,"||q"+"uot||","&#34;");
	strMsg=replaceAllSubstrings(strMsg,"||a"+"pos||","&#39;");
	strMsg=replaceAllSubstrings(strMsg,"<","<");
	strMsg=replaceAllSubstrings(strMsg,">",">");

	//these are used to handle tooltips for scheduled tasks.  There is a problem with characters in expressions being turned into
	//greater than/less than symbols rather than staying tokenized.  TTaskScheduler.getTaskTooltip converts the symbols to #60 and #62
	//12-07-2013 - This is still a problem to be resolved.  For a workaround, see the tooltip for the ID field in Aspect_Performance_Profile_DriverStruct_Detail
	strMsg=replaceAllSubstrings(strMsg,"#60","&lt;");
	strMsg=replaceAllSubstrings(strMsg,"#62","&gt;");

	//Follow any commas and right parenthesis with a space so expressions are allowed to wrap
	strMsg=replaceAllSubstrings(strMsg,",","\xFF");
	strMsg=replaceAllSubstrings(strMsg,"\xFF",", ");
	strMsg=replaceAllSubstrings(strMsg,"(","\xFF");
	strMsg=replaceAllSubstrings(strMsg,"\xFF","( ");

	if (OffsetX==0) OffsetX=10;
	if (OffsetY==0) OffsetY=10;
	
	if ((MaxWidth==null) || (MaxWidth==0)) MaxWidth=400;
	
	var div=document.getElementById("tooltip");
	
	if (div==null) {
		tagBody=document.getElementsByTagName('BODY')[0];
		div=document.createElement('div');
		div.id="tooltip";
		div.className="tooltip"; //apparently setAttrubute("class"...) doesn't work in IE
		div.onclick=Function("javascript:hideTooltip(this);");
		tagBody.appendChild(div);		
	};

	div.innerHTML=strMsg;

	//don't use the event (e) if just hiding with a blank message.  This allows the showTooltip method to be called
	//without an event if it needs to be cleared manually.  One example of this is when a div is made visible under
	//a tooltip that is being displayed.  
	if (strMsg.length>0) {
		var W=div.offsetWidth;
		var H=div.offsetHeight;

		//modified 10-23-2012 to get the source element for the event and calculate the position
		//from that.  Otherwise tooltips are positioned incorrectly when the page or elements on the
		//page are scrolled.
		var eTarget=null;
		if (e.target) {
			eTarget=e.target;
		}
		else {
			if (e.srcElement) eTarget=e.srcElement;
		};
		if (eTarget.nodeType==3) eTarget=eTarget.parentNode;// defeat Safari bug

		//div.style.position="fixed";
		var xy=getPosition2012(eTarget,"absolute",document.getElementsByTagName('BODY')[0]);
		var X=xy[0];
		var Y=xy[1]+eTarget.offsetHeight;

		//var X=e.clientX;
		//var Y=e.clientY;
		var Top	=Y+OffsetY;
		var Left=X+OffsetX;
		div.style.border="1pt solid";
		div.style.top=Top+"px";
		div.style.left=Left+"px";

		if (div.offsetWidth>MaxWidth) {
			div.style.width=MaxWidth+"px";
		};
		
		div.style.padding="5px";
		//div.style.border=5;
	}
	else {
		div.style.padding=0;
		//alert("border="+div.style.border);
		div.style.border="none";
		div.style.width="auto";
	};

	//div.innerHTML="W:"+W+" H:"+H+" ScreenX:"+e.screenX+" ScreenY:"+e.screenY+" clientX="+e.clientX+" clientY="+e.clientY;
};



/******************************************************************************
	NOTES ABOUT DISPLAYS

	The Display Dialog is generated by the computer that generates the table.
	If a table is requested from a remote machine, that machine will produce
	the dialog.
	
	The WidgetID of each display is used as the ID for the select box used
	to select a display, both in the table and in the display dialog.  The 
	WidgetID is valid ONLY on the source machine.
	
	Requests to refresh the dialog after a widget has been deleted or a new
	one has been created must be made to the source machine using a notification.
	A request is also made to the remote machine when a display is selected
	in the display dialog to get the settings for the display.
	
	When a widget is saved, created or deleted, the source HashID of the 
	driver is passed in the call to Library acceptWidgetByID.  When a source
	is defined, the library script uses a notification to execute the script
	on the remote machine.
******************************************************************************/

/******************************************************************************
Gets values from display dialog to be passed as a widget
******************************************************************************/
function getDisplayFormValues(sTableID) 
{
	var table=document.getElementById(sTableID);
	var f=document.forms["Display_Dialog_"+sTableID];

	var sContent="";
	
	//get the location the widget will be saved to - aspect, company or local
	var sLocation=f.library_location.value;

	//get sort and subtotal information
	sContent +="|field_sort1="+f.sort1.value+"|field_sort2="+f.sort2.value+"|field_sort3="+f.sort3.value;
	if(f.sort4) sContent +="|field_sort4="+f.sort4.value;
	sContent +="|field_subtotal1="+f.subtotal1.checked+"|field_subtotal2="+f.subtotal2.checked+"|field_subtotal3="+f.subtotal3.checked;
	if(f.subtotal4) sContent +="|field_subtotal4="+f.subtotal4.checked;
	
	for (var i=1;i<5;i++) {
		var e=document.getElementById("SortOrder"+i+"_"+sTableID);
		if(e) {
			var s=e.getAttribute("AspectSortOrder");
			(s.equalsIgnoreCase("ascending")) ? sContent +="|field_SortOrder"+i+"=0" : sContent +="|field_SortOrder"+i+"=1" ;
		};
	};

	//get subtotal, grand total and chart settings
	sContent +="|field_SubtotalsOnly="+f.SubtotalsOnly.checked;
	sContent +="|field_GrandTotals="+f.GrandTotals.checked;
	sContent +="|field_chartType="+f.ChartType.value;
	if(f.ChartSeries) sContent +="|field_ChartSeries="+f.ChartSeries.value;

	//get filter
	sContent +="|field_filter="+f.Filter.value;
	
	//get fields selected in table
	var sFieldsSelected="";
	var FieldsTable=document.getElementById("FieldsSelected_"+sTableID);
	for (var i=0;i<FieldsTable.rows.length;i++) {
		if(FieldsTable.rows[i].cells[0].firstChild.checked) {
			if(sFieldsSelected.length>0) sFieldsSelected +=",";
			sFieldsSelected +=FieldsTable.rows[i].cells[0].getAttribute("AspectFieldID");
			
			var s=FieldsTable.rows[i].cells[1].innerHTML;
			s=replaceAllSubstrings(s,"\\"," ");
			s=replaceAllSubstrings(s,"("," ");
			s=replaceAllSubstrings(s,")"," ");
			s=replaceAllSubstrings(s,"%"," ");
			s=replaceAllSubstrings(s,"."," ");
			s=replaceAllSubstrings(s,"&"," ");

			sFieldsSelected +="^"+s;
		};
	};

	sContent +="|FieldsSelected="+sFieldsSelected;
	
	//get external filters
	var sExternalFilters=getExternalFilters(sTableID);
	if(sExternalFilters.length>0) sContent +="|" + sExternalFilters;
	
	//get pivot fields
	for(var i=1;i<4;i++) {
		var e=document.getElementById("pivotvalue"+i+"_"+sTableID);
		if(e) {
			sContent +="|pivotvalue"+i+"="+e.value;
			sContent +="|pivotname"+i+"="+document.getElementById("pivotname"+i+"_"+sTableID).value;
		};
	};

	//appendToLog("getDisplayFormValues returns "+sContent,false,true);
	return(sContent);
};

function selectTableSort(e)
{
	sOrder=e.getAttribute("AspectSortOrder");
	if(sOrder.equalsIgnoreCase("ascending")) {
		e.setAttribute("AspectSortOrder","descending");
		e.className="DisplayDialogSortDescendingIcon";
	}
	else {
		e.setAttribute("AspectSortOrder","ascending");
		e.className="DisplayDialogSortAscendingIcon";
	};7
};

function oldselectTableSort(e)
{
	sOrder=e.getAttribute("AspectSortOrder");
	if(sOrder.equalsIgnoreCase("ascending")) {
		e.setAttribute("AspectSortOrder","descending");
		if(bIsMobileDevice) {
			e.src="http://72.167.255.169/images/arrowDown32x32white.png";
		}
		else {
			e.src="http://72.167.255.169/images/arrowDown12x12.png";
		};
	}
	else {
		e.setAttribute("AspectSortOrder","ascending");
		if(bIsMobileDevice) {
			e.src="http://72.167.255.169/images/arrowUp32x32white.png";
		}
		else {
			e.src="http://72.167.255.169/images/arrowUp12x12.png";
		};
	};7
};

function getDisplayDialogArguments(sTableID)
{
	var fOptions=document.forms["Display_Dialog_"+sTableID];

	//get all driver fields in table.  This is done to avoid having to re-open the driver to create
	//a new field list when the dialog is refreshed.  The format of the string passed in the url
	//is Name^ID|Name^ID.  This string is processed by the getDisplayDialog() function
	//The fields are taken from the FieldsSelected table in the display dialog
	var sFields="";
	var table=document.getElementById("FieldsSelected_"+sTableID);
	for (var i=0;i<table.rows.length;i++) {
		if(sFields.length>0) sFields +="|";
		var s=replaceAllSubstrings(table.rows[i].cells[1].innerHTML,"\\"," ");
		s=replaceAllSubstrings(s,"("," ");
		s=replaceAllSubstrings(s,")"," ");
		s=replaceAllSubstrings(s,"%"," ");
		s=replaceAllSubstrings(s,"."," ");
		s=replaceAllSubstrings(s,"&"," ");
		sFields +=s;
		sFields +="^"+table.rows[i].cells[0].getAttribute("AspectFieldID");
	};

	//Get the metadata included in the driver params if any.  This value is used to specify the metadata
	//value used to locate displays associated with the driver.  By default, displays use the document id, 
	//widget and item to calculate the metadata.  Overriding it allows tables in different widgets to share
	//the same displays
	table=document.getElementById(sTableID);
	var sParams=table.getAttribute("aspectparams");
	var sMetadata=getElementValue(sParams,"metadata","|");
	var sHashID=table.getAttribute("aspecthashid");
	var sPivotNameFields=table.getAttribute("aspectPivotFields");
	var sPossiblePivotValues=table.getAttribute("aspectPossiblePivotValues");
	var sDialogHeader=table.getAttribute("aspectDialogHeader");
	
	var sArgs="&Source="+sHashID;
	sArgs +="&DriverID="+fOptions.DriverID.value;
	sArgs +="&DocumentID="+fOptions.DocumentID.value;
	sArgs +="&Widget="+fOptions.Widget.value;
	sArgs +="&ContainerItemID="+fOptions.ContainerItemID.value;
	sArgs +="&TableID="+sTableID;
	sArgs +="&AllFields="+sFields;
	sArgs +="&Metadata="+sMetadata;
	if(sPivotNameFields) sArgs +="&PivotNameFields="+sPivotNameFields;
	if(sPossiblePivotValues) sArgs +="&PossiblePivotValues="+sPossiblePivotValues;
	if(sDialogHeader) sArgs +="&DialogHeader="+sDialogHeader;
	return(sArgs);
};

/******************************************************************************
See NOTES ABOUT DISPLAYS comment about how displays are refreshed, saved and deleted
Refresh the display dialog. Called when a display is deleted and when a 
display is selected from the drop-down list in the display dialog
******************************************************************************/
function refreshDisplayDialog(sTableID,sWidgetID,bShowDialog,sResponse)
{
	if(sResponse) {
		showDisplayDialogMessage(sTableID,"");
		if(bShowDialog) openDisplayDialog(sTableID);
		initializeTabbedDialogs(); //initialize tabs in the display dialog
		//appendToLog("refreshDisplayDialog complete.  bShowDialog="+bShowDialog,false,true);
		return;
	};

	//disable all elements in the dialog
	var fOptions=document.forms["Display_Dialog_"+sTableID];
	enableElements(fOptions,false);

	//overlay a div to disable clicking on images
	var eFormWrapper=document.getElementById("Display_Dialog_FormWrapper"+sTableID);
	applyOverlay(eFormWrapper);
	
	//show messagge
	showDisplayDialogMessage(sTableID,"Getting display settings...");

	if(false) {
		//get all driver fields in table.  This is done to avoid having to re-open the driver to create
		//a new field list when the dialog is refreshed.  The format of the string passed in the url
		//is Name^ID|Name^ID.  This string is processed by the getDisplayDialog() function
		var sFields="";
		var table=document.getElementById("FieldsSelected_"+sTableID);
		for (var i=0;i<table.rows.length;i++) {
			if(sFields.length>0) sFields +="|";
			sFields +=table.rows[i].cells[1].innerHTML;
			sFields +="^"+table.rows[i].cells[0].getAttribute("AspectFieldID");
		};

		//Get the metadata included in the driver params if any.  This value is used to specify the metadata
		//value used to locate displays associated with the driver.  By default, displays use the document id, 
		//widget and item to calculate the metadata.  Overriding it allows tables in different widgets to share
		//the same displays
		table=document.getElementById(sTableID);
		var sParams=table.getAttribute("aspectparams");
		var sMetadata=getElementValue(sParams,"metadata","|");
		var sHashID=table.getAttribute("aspecthashid")	
//appendToLog("refreshDisplayDialog Params="+sParams+" Metadata="+sMetadata+" HashID="+sHashID,false,true);
		var sUrl=getServer()+"/?Network=Greenlight&ID=getDisplayDialog";
		sUrl +="&Source="+sHashID;
		sUrl +="&DriverID="+fOptions.DriverID.value;
		sUrl +="&DocumentID="+fOptions.DocumentID.value;
		sUrl +="&Widget="+fOptions.Widget.value;
		sUrl +="&ContainerItemID="+fOptions.ContainerItemID.value;
		sUrl +="&TableID="+sTableID;
		sUrl +="&WidgetID="+sWidgetID;
		sUrl +="&AllFields="+sFields;
		sUrl +="&Metadata="+sMetadata;
	};

	var sUrl=getServer()+"/?Network=Greenlight&ID=getDisplayDialog";
	sUrl +="&WidgetID="+sWidgetID+"&"+getDisplayDialogArguments(sTableID);
	var sFunc="refreshDisplayDialog(\x22"+sTableID+"\x22,\x22"+sWidgetID+"\x22,"+bShowDialog+",req.responseText)";
//appendToLog("refreshDisplayDialog url="+sUrl,false,true);
	asynchInclude(eFormWrapper,sUrl,sFunc,sFunc);
};

/******************************************************************************
See NOTES ABOUT DISPLAYS comment about how displays are refreshed, saved and deleted
Delete a display
******************************************************************************/
function getMetadata(sTableID)
{
	var fOptions=document.forms["Display_Dialog_"+sTableID];

	//see if metadata has been defined in the driver params.  This can be used to override the default metadata
	//so displays can be shared by more than one widget
	var table=document.getElementById(sTableID);
	var sParams=table.getAttribute("AspectParams");
	var sMetadata=getElementValue(sParams,"metadata","|");
	if(sMetadata.trim().length>0) return(sMetadata);
	
	//get the document ID, widget and containerItemID used to make up the metadata
	var sDriverID=fOptions.DriverID.value;
	var sDocumentID=fOptions.DocumentID.value;
	var sWidget=fOptions.Widget.value;
	var sContainerItemID=fOptions.ContainerItemID.value;
	var sMobile=fOptions.MobileDevice.value;
	sMetadata=sDriverID+"|"+sDocumentID+"|"+sWidget+"|"+sContainerItemID+"|Mobile_"+sMobile;
	return(sMetadata);
};

function deleteDisplay2012(sTableID,iStep,sMessage)
{
	var fOptions=document.forms["Display_Dialog_"+sTableID];
	var sWidgetID=fOptions.WidgetMetadataID.value;
	var eDialog=document.getElementById("Display_Dialog_"+sTableID);
	var eFormWrapper=document.getElementById("Display_Dialog_FormWrapper"+sTableID);
	var xy=getPosition2012(eDialog,"fixed",document.getElementsByTagName('BODY')[0]);
	
	switch(iStep)
	{
		case 0:	//get confirmation
				showDialog("msg=Delete this display?<br><br>&fnOk=deleteDisplay2012(\x22"+sTableID+"\x22,1)&fnCancel=close&position=fixed&left="+(xy[0]+30)+"&top="+(xy[1]+20));
				break;
		case 1:	//delete the display
				
				//remove confirmation dialog
				showDialog();
				
				var sUrl=getServer()+"/?Network=Library&ID=acceptWidgetByID";
				sUrl +="&WidgetID="+sWidgetID+"&delete=true";
				sUrl +="&metadata="+getMetadata(sTableID);
				sUrl +="&source="+document.getElementById(sTableID).getAttribute("hashid");

				//add parameters that will be used to generate and return a new display dialog after the widget is deleted
				sUrl +="&DisplayDialogArgs="+replaceAllSubstrings(getDisplayDialogArguments(sTableID),"&","$displaydialogamp$");
				
				//disable all elements in the dialog
				enableElements(fOptions,false);

				//overlay a div to disable clicking on images
				applyOverlay(eFormWrapper,"Overlay_"+sTableID);
				
				//show message
				showDisplayDialogMessage(sTableID,"Deleting display...");

				sFunc="deleteDisplay2012('"+sTableID+"',2,req.responseText);";
				asynchInclude(null,sUrl,sFunc,sFunc);
				break;
		case 2:	//got response from server

				//hide message
				showDisplayDialogMessage(sTableID,"");
				
				if(sMessage.toUpperCase().startsWith("ERROR")) {
					//enable all elements in the dialog
					enableElements(fOptions,true);

					//remove overlay
					var e=document.getElementById("Overlay_"+sTableID);
					if(e) e.parentNode.removeChild(e);

					showDialog("msg="+sMessage+"<br><br>&fnOk=close&position=fixed&left="+(xy[0]+30)+"&top="+(xy[1]+20));
				}
				else {
					eFormWrapper.innerHTML=sMessage;
					initializeTabbedDialogs(); //initialize tabs in the display dialog
				};
				break;
	};
};

/******************************************************************************
See NOTES ABOUT DISPLAYS comment about how displays are refreshed, saved and deleted
Save a display
******************************************************************************/
function saveDisplay2012(sTableID,iStep,sMessage)
{
	var fOptions=document.forms["Display_Dialog_"+sTableID];
	var sWidgetID=fOptions.WidgetMetadataID.value;
	var eDialog=document.getElementById("Display_Dialog_"+sTableID);
	var eFormWrapper=document.getElementById("Display_Dialog_FormWrapper"+sTableID);
	var xy=getPosition2012(eDialog,"fixed",document.getElementsByTagName('BODY')[0]);
	
	//abort if no fields are selected
	if((iStep==0) && (countSelectedFields(sTableID)==0)) {
		showDialog("msg=No fields have been selected for this display&fnOk=close");
		return;
	};

	//if just starting and the WidgetID is 0, indicating no display has been defined, then go to save option
	if((iStep==0) && (sWidgetID=="0")) {
		saveDisplayAs2012(sTableID,iStep);
		return;
	};

	switch(iStep)
	{
		case 0:	//save the display
				//get the location where the display will be saved (local, company or aspect)
				var sLocation=fOptions.library_location.value;

				//get the arguments from the form
				var sArgs=getDisplayFormValues(sTableID);

				//format the url
				var sUrl=getServer()+"/?Network=Library&ID=acceptWidgetByID";
				sUrl +="&WidgetID="+sWidgetID;
				sUrl +="&metadata="+getMetadata(sTableID);
				sUrl +="&Content="+sArgs;
				sUrl +="&mobile="+fOptions.MobileDevice.value;
				sUrl +="&source="+document.getElementById(sTableID).getAttribute("hashid");

				//add parameters that will be used to generate and return a new display dialog after the widget is deleted
				sUrl +="&DisplayDialogArgs="+replaceAllSubstrings(getDisplayDialogArguments(sTableID),"&","$displaydialogamp$");

				sFunc="saveDisplay2012(\x22"+sTableID+"\x22,1,req.responseText);";
				
				//Debugging
				//appendToLog("Url="+sUrl);

				//disable all elements in the dialog
				enableElements(fOptions,false);

				//overlay a div to disable clicking on images
				applyOverlay(eFormWrapper,"Overlay_"+sTableID);
				
				//show message
				showDisplayDialogMessage(sTableID,"Saving display...");

				//showTableMessage(sTableID,"Saving display",true);
				asynchInclude(null,sUrl,sFunc,sFunc);
				break;
		case 1:	//got response from server

				//hide message
				showDisplayDialogMessage(sTableID,"");
				
				//Note: The return value from the asynchInclude call is the html for a new display dialog
				//or an error message
				if(sMessage.toUpperCase().startsWith("ERROR")) {
					//enable all elements in the dialog
					enableElements(fOptions,true);

					//remove overlay
					var e=document.getElementById("Overlay_"+sTableID);
					if(e) e.parentNode.removeChild(e);

					if(sMessage.length==0) sMessage="No response from server.  Try again.";
					showDialog("msg="+sMessage+"<br><br>&fnOk=close&position=fixed&left="+(xy[0]+30)+"&top="+(xy[1]+20));
				}
				else {
					eFormWrapper.innerHTML=sMessage;
					initializeTabbedDialogs(); //initialize tabs in the display dialog
				};
				break;
	};
};

/******************************************************************************
See NOTES ABOUT DISPLAYS comment about how displays are refreshed, saved and deleted
Save a display to a new name
******************************************************************************/
function saveDisplayAs2012(sTableID,iStep,sMessage)
{
	var fSaveAs=document.forms["Save_Display_As_"+sTableID];
	var fOptions=document.forms["Display_Dialog_"+sTableID];
	var sDisplayName=fSaveAs.save_display_as.value;
	var eDialog=document.getElementById("Display_Dialog_"+sTableID);
	var eFormWrapper=document.getElementById("Display_Dialog_FormWrapper"+sTableID);
	var xy=getPosition2012(eDialog,"fixed",document.getElementsByTagName('BODY')[0]);
	
	//stay on step 0 if a name has not been entered		
	if((sDisplayName.length==0) || (sDisplayName.equalsIgnoreCase("New Display"))) iStep=0;

	switch(iStep)
	{
		case 0:	//show Save As dialog
				setVisible("Save_Display_As_"+sTableID,true);
				break;
		case 1:	//save the display
				
				//get the location where the display will be saved (local, company or aspect)
				var sLocation=fSaveAs.save_display_as_location.value;

				//get the arguments from the form
				var sArgs=getDisplayFormValues(sTableID);

				//format the url
				var sTokenizedName=tokenizeSpecialChars(sDisplayName,true);
				var sUrl=getServer()+"/?Network=Library&ID=acceptWidgetByID&new=true";
				sUrl +="&Name="+sTokenizedName+"&Location="+sLocation;
				sUrl +="&metadata="+getMetadata(sTableID);
				sUrl +="&Content="+sArgs;
				sUrl +="&mobile="+fOptions.MobileDevice.value;
				sUrl +="&source="+document.getElementById(sTableID).getAttribute("hashid");

				//add parameters that will be used to generate and return a new display dialog after the widget is deleted
				sUrl +="&DisplayDialogArgs="+replaceAllSubstrings(getDisplayDialogArguments(sTableID),"&","$displaydialogamp$");

				sFunc="saveDisplayAs2012(\x22"+sTableID+"\x22,2,req.responseText);";
				
				//Debugging
				//appendToLog("Url="+sUrl,false,true);

				//hide the save as dialog and show a status message
				setVisible("Save_Display_As_"+sTableID,false);

				//disable all elements in the dialog
				enableElements(fOptions,false);

				//overlay a div to disable clicking on images
				applyOverlay(eFormWrapper,"Overlay_"+sTableID);
				
				//show message
				showDisplayDialogMessage(sTableID,"Saving display...");

				appendToLog("saveDisplayAs2012 sUrl="+sUrl);
				asynchInclude(null,sUrl,sFunc,sFunc);
				break;
		case 2:	//got response from server

				//hide message
				showDisplayDialogMessage(sTableID,"");
				
				//Note: The return value from the asynchInclude call is OK|WidgetID|Display Name
				//or an error message
				if(sMessage.toUpperCase().startsWith("ERROR")) {
					//enable all elements in the dialog
					enableElements(fOptions,true);

					//remove overlay
					var e=document.getElementById("Overlay_"+sTableID);
					if(e) e.parentNode.removeChild(e);

					showDialog("msg="+sMessage+"<br><br>&fnOk=close&position=fixed&left="+(xy[0]+30)+"&top="+(xy[1]+20));
				}
				else {
					eFormWrapper.innerHTML=sMessage;
					initializeTabbedDialogs(); //initialize tabs in the display dialog
				};
				break;
	};
};

/******************************************************************************
Called when a display is selected from the table controls.  Causes the table to refresh immediately
using the new display
******************************************************************************/
function displaySelected1(eSelect,sTableID) 
{
	var sDisplayValue=eSelect.value;
	//alert("displaySelected1: TableID="+sTableID+" Display="+sDisplayValue);
	refreshTable(sTableID,"refresh",eSelect.value,false);
};

/******************************************************************************
Called when a display is selected from the display dialog.  Causes the dialog to be refreshed with
the controls from the selected display
******************************************************************************/
function displaySelected2(eSelect,sTableID) 
{
	var sDisplayValue=eSelect.value;
	//alert("displaySelected: TableID="+sTableID+" Display="+sDisplayValue);
	refreshDisplayDialog(sTableID,sDisplayValue,true);
};

/******************************************************************************
Called when a display is selected from the display dialog.  Causes the dialog to be refreshed with
the controls from the selected display
******************************************************************************/
function restoreDisplay(sTableID) 
{
	var sDisplayValue=document.getElementById("SelectDisplay2"+sTableID).value;
	refreshDisplayDialog(sTableID,sDisplayValue,true);
};

/******************************************************************************
Used by mobile devices when the cancel button is pressed in the display dialog
******************************************************************************/
function displayDialogCancel(sTableID)
{
	setVisible("Display_Dialog_"+sTableID,false);
	if(bIsMobileDevice) {
		defocusDialog();
		if(false) {
			var arDiv=document.getElementsByTagName("div");
			for (var i=0;i<arDiv.length;i++) {
				if(arDiv[i].getAttribute("hideafteredit")=="true") {
					setVisible(arDiv[i],false);
				}
				else if(arDiv[i].getAttribute("ShowAfterEdit")=="true") {
					setVisible(arDiv[i],true);
				};
			};
			
			window.scrollTo(0,document.body.getAttribute('RestoreScrollTop'));
		};
	};
};

/******************************************************************************
Called when the display dialog is closed by pressing okay.  Causes the table to be refreshed using
the display settings in the dialog.
******************************************************************************/
function displayDialogOk(sTableID)
{
	setVisible("Display_Dialog_"+sTableID,false);

	if(bIsMobileDevice) {
		defocusDialog();
		if(false) {
			var arDiv=document.getElementsByTagName("div");
			for (var i=0;i<arDiv.length;i++) {
				if(arDiv[i].getAttribute("hideafteredit")=="true") {
					setVisible(arDiv[i],false);
				}
				else if(arDiv[i].getAttribute("ShowAfterEdit")=="true") {
					setVisible(arDiv[i],true);
				};
			};
			
			window.scrollTo(0,document.body.getAttribute('RestoreScrollTop'));
		};
	};
	
	var fOptions=document.forms["Display_Dialog_"+sTableID];
	var sDisplayID=fOptions.DisplayName.value;
	//alert("displayDialogOk DisplayID="+sDisplayID);
	refreshTable(sTableID,"refresh",sDisplayID,true);

	if(bIsMobileDevice) {
		//remove the display dialog from the body.  A new one will be returned when the table is refreshed.
		var div=document.getElementById("Display_Dialog_"+sTableID);
		div.parentNode.removeChild(div);
	};
};

/******************************************************************************
open the display dialog.  e is the icon used to open the display dialog
and will not be defined if called from refreshDisplayDialog.  Probably is 
not needed
******************************************************************************/
function openDisplayDialog(TableID,e) {
	var div=document.getElementById("Display_Dialog_"+TableID);
	var table=document.getElementById(TableID);

	//position the dialog
	div.style.top=0;
	div.style.left=0;

	setVisible(div,true);

	//make sure the "sort" option is selected in the drop-down used to select the dialog tab
	var eSelect=document.getElementById("SelectDisplayDialogTab"+TableID);
	if(eSelect) {
		eSelect.value="display_sort_"+TableID;
		showTab(eSelect);
		appendToLog("set sort tab visible");
	};

	//make sure the "sort" tab is selected
	var eTab=document.getElementById("DisplayDialogTabSortTab"+TableID);
	if(eTab) {
		showTab(eTab,"display_sort_"+TableID);
	};

	//move it down
	var divContainer=document.getElementById("div"+TableID);
	var xy=getPosition2012(table.tBodies[0],"absolute",divContainer);
	div.style.top=xy[1];

	//center the dialog if the table width is greater than the dialog width
	var maxwidth=Math.min(documentWidth(),table.tBodies[0].offsetWidth);
	if(maxwidth>div.offsetWidth) {
		//don't shift the dialog toward the center if the left position will be small.
		//Otherwise, a small (e.g. 9px) margin can be introduced for small screens.
		//Might have something to do with the scroll bar
		var left=(maxwidth-div.offsetWidth)/2;
		if(left>20) div.style.left=left;
	};

	//set the height of the table used to select fields
	//get the total height of the displays dialog
	var eFormWrapper=document.getElementById("Display_Dialog_FormWrapper"+TableID);
	var TotalHeight=eFormWrapper.offsetHeight;

	//determine the top position of the div surrounding the fields table
	//This is done by looking for the select box used to select a dialog tab and
	//the tab table.  One of them will be visible.

	//look for select box
	var n=0;
	var e=document.getElementById("SelectDisplayDialogTab"+TableID);
	if(e) {
		var xy=getPosition2012(e,"absolute",eFormWrapper);	
		n=xy[1]+e.offsetHeight;
	};

	//look for table of tabs
	var e=document.getElementById("SelectDisplayDialogTabTable"+TableID);
	if(e) {
		var xy=getPosition2012(e,"absolute",eFormWrapper);	
		n=Math.max(n,xy[1]+e.offsetHeight);
	};

	if(n>0) {
		//the difference is the amount of space left for the fields table
		var AvailableHeight=TotalHeight-n-10;
	
		var eFieldsTable=document.getElementById("FieldsSelected_"+TableID);
		//eFieldsTable.style.height=AvailableHeight;

		var eFieldsTableContainer=document.getElementById("DisplayDialogFieldsTableContainer"+TableID);
		if(eFieldsTableContainer) eFieldsTableContainer.style.height=AvailableHeight;
	};
};


function oldopenDisplayDialog(TableID,e)
{
	var div=document.getElementById("Display_Dialog_"+TableID);
	var table=document.getElementById(TableID);
	
	div.style.position="absolute";

	if(bIsMobileDevice) {
		div.style.top="0px";
		div.style.left="0px";
		div.style.width=getViewportWidth()+"px";
	}
	else {
		div.style.top=(table.offsetTop+40)+"px";
		div.style.left=(table.offsetLeft+20)+"px";
	};
	
	//if it's a mobile device...
	if(bIsMobileDevice) {
		//set the width of elements in the dialog
		//SelectDisplay2$tableid$
		
		focusDialog(div.id);
		div.parentNode.removeChild(div);
		document.body.appendChild(div);
		
		if(false) {
			//record the current scrolling position of the page so it can be restored when the dialog is closed
			var iScrollTop=0;
			iScrollTop=window.scrollY;
			document.body.setAttribute("RestoreScrollTop",iScrollTop);

			//move the dialog to the body element
			div.parentNode.removeChild(div);
			document.body.appendChild(div);
			
			//Hide all other divs.  Set an attribute to indicate the items that should be 
			//displayed when the dialog is closed
			var arDiv=document.getElementsByTagName("div");
			for (var i=0;i<arDiv.length;i++) {
				if (boolVal(arDiv[i].getAttribute("isItem"))) {
					if(isVisible(arDiv[i])) {
						arDiv[i].setAttribute("ShowAfterEdit","true");
						setVisible(arDiv[i],false);
					}
					else {
						arDiv[i].setAttribute("ShowAfterEdit","false");
					};
				};
			};
			
			//set an attribute in the dialog used to identify and hide the dialog
			div.setAttribute("HideAfterEdit","true");
		};
	};
	
	setVisible(div,true);
	//if(bIsMobileDevice) location.hash="#edit";
};

/****************************************************************************
Begin compare Javascript1 and Javascript2012 here
****************************************************************************/

//Initializes fields selected when the report is first loaded
function initializeReport() 
{
	//The widget ID is not available at this point, so check every form in the document for field named "starting_fields_initialized" with a value of false
	//This value is set when the widget is initially loaded by a script in the widget.  The widget also sets the fields "starting_fields_list" and "starting_fields_WidgetID"
	//This procedure is only necessary so that the display options can be initialized when the widget is first loaded.
	for (var cntrForm=0;cntrForm<document.forms.length;cntrForm++) {
		f=document.forms[cntrForm];
		if ((f.starting_fields_initialized) && (f.starting_fields_initialized.value=="false"))
		{
			var strWidgetID=f.starting_fields_WidgetID.value;
			var strStartingFields=f.starting_fields_list.value;
			
			//Need to be careful to not crash this function due to a missing field.  Otherwise, remaining forms will
			//not be initialized.
			if(document.forms["Filter"+strWidgetID]) {
				var SelectAll=document.forms["Filter"+strWidgetID].AllFields;
				var Select2=document.forms["Filter"+strWidgetID].FieldsSelected;
			};

			if((!SelectAll) || (!SelectAll.options)) {
				appendToLog("Error in initializeReport.  SelectOptions not valid.  WidgetID="+strWidgetID);
			}
			else {
				//Add the selected fields in the order they are listed 
				if (true) //This was replaced by selectDisplay() above 12/28/10
				{
					var arStartingFields=getSubStringArray(strStartingFields,",",true);
					for (var i=0;i<arStartingFields.length;i++) {
						var boolFound=false;
						for (var j=0;((!boolFound) && (j<SelectAll.options.length));j++) {
							if (SelectAll.options[j].value.equalsIgnoreCase(arStartingFields[i])) {
								Select2.options[Select2.options.length]=new Option(SelectAll.options[j].text,SelectAll.options[j].value,false,false);
								boolFound=true;
							};
						};
						//if(!boolFound) appendToLog("Could not find field in all fields: "+arStartingFields[i]);
					};

					//update the list of fields available to remove those in the selected list
					updateFieldsAvailable(strWidgetID);
				};
				
				//set the field to indicate that the fields selected list has been initiazed
				f.starting_fields_initialized.value="true";
				
				//move the speed filter fields div 
				eInsertBefore=document.getElementById("InsertSpeedFields"+strWidgetID);
				eCustomFields=document.getElementById("FilterSpeedFields"+strWidgetID);
				if((eInsertBefore) && (eCustomFields)) {
					eParent=document.getElementById("SpeedFilter"+strWidgetID);
					eParent.insertBefore(eCustomFields,eInsertBefore);
				};

				//move the custom fields div inside the customize dialog
				//Note: These fields may not be defined if the "filter dialog" widget is not included in the page
				eInsertBefore=document.getElementById("InsertCustomFields"+strWidgetID);
				eCustomFields=document.getElementById("FilterCustomFields"+strWidgetID);
				if((eInsertBefore) && (eCustomFields)) {
					eParent=document.getElementById("CustomFieldsContainer"+strWidgetID);
					if(eParent) {
						eParent.insertBefore(eCustomFields,eInsertBefore);

						//hide the custom fields section inside the custom dialog if none are defined.
						(eCustomFields.innerHTML.trim().length==0) ? setVisible("CustomFieldsContainer"+strWidgetID,false) : setVisible("CustomFieldsContainer"+strWidgetID,true);
					};
				};

				//alert("selectDisplay: "+strWidgetID+" Name: "+document.forms["Filter"+strWidgetID].Display.value);
				//selectDisplay(strWidgetID);
			};
		};
	};
	
	initializeCustomControls();
	
	//This is necessary in case this function is being called by refreshWidgets() after including content using an interval
	initializeTabbedDialogs();
	
	addScripts();
};

//Refresh the table
var arRefreshing="";
function refreshDisplay(strWidgetID,strFormName,status) {
	if (status) {
		arRefreshing=replaceAllSubstrings(arRefreshing,strWidgetID+"|","");
		initializeReport();
		showDialog();
		if(status==-1) {
			showDialog("msg=Error refreshing page.&fnOk=close");
		};
	}
	else {
		//don't allow the refresh button to be pressed more than once
		//Need to consider that there may be multiple calls from different widgets at one time
		if(arRefreshing.indexOf(strWidgetID+"|")>=0) return;
		arRefreshing+=strWidgetID+"|";
		
		//hide the customize dialog
		setVisible("Customize"+strWidgetID,false);
		
		showDialog("icon=true&msg=Loading...");
		var strFuncOk="refreshDisplay('"+strWidgetID+"','"+strFormName+"',1)";
		var strFuncErr="refreshDisplay('"+strWidgetID+"','"+strFormName+"',-1)";
		filterTable(strWidgetID,strFormName,strFuncOk,strFuncErr);
	};
};

//Initializes display settings when a display is selected
function selectDisplay(strWidgetID,boolRefresh) {
	f=document.forms["Filter"+strWidgetID];
	
	//disable buttons
	f.Display.disabled=true;
	//f.Refresh.disabled=true;
	//f.Custom.disabled=true;

	//disable all elements
	for (var i=0;i<f.elements.length;i++) {
		f.elements[i].disabled=true;
	};

	//set the name of the display in the custom dialog
	strDisplayID=f.Display.value;
	for (var i=0;i<f.Display.options.length;i++) {
		if (f.Display.options[i].value==strDisplayID) {
			document.getElementById("display_name_"+strWidgetID).innerHTML=f.Display.options[i].text;
			f.DisplayName.value=f.Display.options[i].text;
		};
	};
	
	//get the location of the widget library that contains the display
	var strDisplayServer=f.display_server.value;
	//var strUrl="https://__server__/?Network=GreenLight&ID=execScript&ScriptID=GreenLight_getDisplayWidgetInfo&WidgetID="+strDisplayID
	var strUrl="https://__server__/?Network=greenlight&ID=getXmlHttpRequest&url=https://"+strDisplayServer+"/?Network=GreenLight|ID=execScript|ScriptID=GreenLight_getDisplayWidgetInfo|WidgetID="+strDisplayID
	var strLocation=getxmlHttpRequest(strUrl);
	f.display_widget_library_location.value=strLocation;
	
	//add the location of the display to the name at the top of the customize dialog
	if(strLocation.toUpperCase().indexOf("ERROR")<0) {
		document.getElementById(strWidgetID+"location").innerHTML=strLocation;
	}
	else {
		document.getElementById(strWidgetID+"location").innerHTML="Error";
	};

	//alert("DisplayID="+strDisplayID);
	//var strUrl="https://"+strDisplayServer+"/?Network=GreenLight&ID=execScript&ScriptID=Aspect_Common_getCachedWidget_By_ID&WidgetID="+strDisplayID
	var strUrl="https://__server__/?Network=greenlight&ID=getXmlHttpRequest&url=https://"+strDisplayServer+"/?Network=GreenLight|ID=execScript|ScriptID=Aspect_Common_getCachedWidget_By_ID|WidgetID="+strDisplayID;
	//alert("strUrl="+strUrl);
	var strContent=getxmlHttpRequest(strUrl);
	//alert("display Content="+replaceAllSubstrings(strContent,"|","\x0A"));
	
	var arArgs=getSubStringArray(strContent,"|",true);
	for (var i=0;i<arArgs.length;i++) {
		var arStr=getSubStringArray(arArgs[i],"=",true);
		if (arStr.length>1) {
			if (arStr[0].equalsIgnoreCase("FieldsSelected")) {
				var options=f.elements["FieldsSelected"].options;
				options.length="";
				arFields=getSubStringArray(arStr[1],",");
				for (var j=0;j<arFields.length;j++) {
					arPair=getSubStringArray(arFields[j],"^");
					if (arPair.length>1) {
						options[options.length]=new Option(arPair[1],arPair[0],false,false);
					};
				};
			}
			else {
				var strName=arStr[0].substring(6); //field_ is prepended to all form field names
				var strValue=arStr[1];
				for (var j=2;j<arStr.length;j++) strValue+="="+arStr[j]; //add any additional elements in case the value field contains an equals sign

				strValue=tokenizeSpecialChars(strValue,false);
				var e=f.elements[strName];
				if (e) {
					if (e.type=='checkbox') {	
						(strValue.equalsIgnoreCase("true")) ? e.checked=true : e.checked=false;
					}
					else {
						//appendToLog("set "+arStr[0]+" to "+strValue);
						//alert("set "+arStr[0]+" to "+strValue);
						e.value=strValue;
					};
				}
				else {
					//alert("Cannot locate field named "+arStr[0]);
				};
			};
		};
	};
	
	//update list of available fields
	updateFieldsAvailable(strWidgetID);
	
	//enable buttons
	f.Display.disabled=false;
	//f.Refresh.disabled=false;
	//f.Custom.disabled=false;

	//enable all elements
	for (var i=0;i<f.elements.length;i++) {
		f.elements[i].disabled=false;
	};

	//Enable/disable the save & delete button depending on the location
	if (f.Aspect_Support_Report_Widgets_User.value.startsWith("\x7B")) {
		if (strLocation.equalsIgnoreCase("Aspect")) {
			f.btndelete.disabled=true;
			f.save.disabled=true;
		}
		else {
			f.btndelete.disabled=false;
			f.save.disabled=false;
		};
	}
	else {
		f.btndelete.disabled=false;
	};

	//refresh the report - but do not refresh if the customize dialog is open
	//This allows different displays to be selected from the drop-down list while the customize dialog is open
	//so they can be modified and saved without generating a new report each time
	if ((boolRefresh) && (!isVisible("Customize"+strWidgetID))) refreshDisplay(strWidgetID,"Filter"+strWidgetID);
};

//Get display widget content.  Reads all of the fields in the form to create the content that will be saved in the widget so the form can be 
//initialized again when the display is selected
function convertFormToWidgetContent(strWidgetID) 
{
	var f=document.forms["Filter"+strWidgetID];

	var strContent="";
	
	//get the location the widget will be saved to - aspect, company or local
	var strLocation=f.display_widget_library_location.value;
	//alert("strLocation="+strLocation);
	
	//get all form fields with the attribute "save"
	for (var i=0;i<f.elements.length;i++) {
		if ((f.elements[i].name) && ((f.elements[i].type!="button"))) {
			var strAttr=f.elements[i].getAttribute("save");
			if (strAttr) {
				//alert("strAttr="+strAttr);
				if ((strAttr.equalsIgnoreCase("aspect")) || (strLocation.equalsIgnoreCase("company")) || (strLocation.equalsIgnoreCase("local"))) 
				{
					if (f.elements[i].type=='checkbox') {	
						(f.elements[i].checked) ? strContent +="field_"+f.elements[i].name+"=true|" : strContent +="field_"+f.elements[i].name+"=false|";
					}
					else {
						strContent +="field_"+f.elements[i].name+"="+tokenizeSpecialChars(f.elements[i].value,true)+"|";
					};
				};
			};
		};
	};

	//get the list of fields selected
	var arFieldsSelected=new Array();
	var Select2=document.forms["Filter"+strWidgetID].FieldsSelected;
	for (var i=0;i<Select2.options.length;i++) {
		arFieldsSelected[arFieldsSelected.length]=Select2.options[i].value+"^"+Select2.options[i].text;
		//arFieldsSelected[arFieldsSelected.length]=Select2.options[i].value;
	};
	strContent +="FieldsSelected="+arFieldsSelected.toString()+"|";
	
	return(strContent);
};

//Shows or hides the div showing the status while saving a widget
function showDisplayOptionsStatus(strWidgetID,strDisplayName,strMsg,boolShow,boolShowCloseButton) {
	if (boolShow) {
		divFilter=document.getElementById("Filter"+strWidgetID);
		divStatus=document.getElementById("Display_Options_Status"+strWidgetID);
		divStatus.style.left=(divFilter.offsetLeft+30)+"px";
		var intTopAdjust=getContainerAdjustment(document.getElementById("Customize"+strWidgetID));
		divStatus.style.top=(divFilter.offsetTop+divFilter.offsetHeight+30-intTopAdjust)+"px";
		divStatus.style.zIndex=4;
		
		document.getElementById("Display_Options_Status_Message"+strWidgetID).innerHTML=strMsg;
		setVisible("Display_Options_Status"+strWidgetID,true);
		(boolShowCloseButton) ? setVisible("Display_Options_Status_Button",boolShowCloseButton) : setVisible("Display_Options_Status_Button",false);

		var arXY=getPosition(divFilter);
		divStatus.style.top=(arXY[1]+60-intTopAdjust)+"px";
	}
	else {
		setVisible("Display_Options_Status"+strWidgetID,false);
	};
};

//Saves display settings to the selected widget.  The documentID and widget name are used to create the metadata field for the widget
//so it can be associated with a particular table.  The script looks up the location of the widget (Aspect, Company Widgets or Local Widgets)
//before saving
function saveDisplay(strWidgetID,strDocumentID,strWidgetName) {
	//alert("save display DocumentID="+strDocumentID+" WidgetID="+strWidgetID+" WidgetName="+strWidgetName);
	var str=convertFormToWidgetContent(strWidgetID);
	str=replaceAllSubstrings(str,"|","\\\\"+"pipe\\\\"); 
	var strDisplayWidgetID=document.forms["Filter"+strWidgetID].Display.value;
	if (strDisplayWidgetID.trim().length==0) {
		alert("Cannot save unnamed display.  Select Save As to enter a name for the display.");
		return;
	};
	
	//show status message
	var strDisplayName=document.getElementById("display_name_"+strWidgetID).innerHTML;
	var strLocation=document.forms["Filter"+strWidgetID].display_widget_library_location.value;
	var strMsg="Saving \x22"+strDisplayName+"\x22 to "+strLocation+" displays."
	showDisplayOptionsStatus(strWidgetID,strWidgetName,strMsg,true);
	
	var strUrl="https://__server__/?Network=Library&ID=acceptWidgetByID&WidgetID="+strDisplayWidgetID+"&metadata="+strDocumentID+"_"+strWidgetName+"&Content="+str;
	
	//need to use xmlhttprequest when the page is served by a remote server.  The problem with this though is that the local widget cache
	//is not updated when the display is saved because acceptWidgetByID is not called locally
	var strDisplayServer=document.forms["Filter"+strWidgetID].display_server.value;
	if (strDisplayServer.indexOf("127.0.0.1")<=0) {
		strUrl="https://__server__/?Network=greenlight&ID=getXmlHttpRequest&url=https://"+strDisplayServer+"/?Network=Library|ID=acceptWidgetByID|WidgetID="+strDisplayWidgetID+"|metadata="+strDocumentID+"_"+strWidgetName+"|Content="+str;
	};

	appendToLog("Saving Display.  Url="+strUrl,false,true);

	strResult=getxmlHttpRequest(strUrl);
	
	//hide status message
	showDisplayOptionsStatus(strWidgetID,strWidgetName,"",false);
	
	//alert("strResult="+strResult);
};

//Used to save a display to a new name.  The boolGetName argument is set to true when the function is first called.
//This displays the dialog used to get the display name and location.  When the function is called again from the
//dialog, boolGetName is false and the display is saved as a widget
function saveDisplayAs(strWidgetID,strDocumentID,strWidgetName,boolGetName) 
{
	var f=document.forms["Filter"+strWidgetID];
	var strDisplayName=f.save_display_as.value;

	if ((boolGetName) || (strDisplayName.trim().length==0)) {
		divFilter=document.getElementById("Filter"+strWidgetID);
		divSaveAs=document.getElementById("Save_Display_As"+strWidgetID);
		divSaveAs.style.left=(divFilter.offsetLeft+30)+"px";
		var intTopAdjust=getContainerAdjustment(document.getElementById("Customize"+strWidgetID));
		divSaveAs.style.top=(divFilter.offsetTop+divFilter.offsetHeight+30-intTopAdjust)+"px";
		divSaveAs.style.zIndex=4;
		setVisible("Save_Display_As"+strWidgetID,true);

		var arXY=getPosition(divFilter);
		divSaveAs.style.top=(arXY[1]+60-intTopAdjust)+"px";
	}
	else {
		setVisible("Save_Display_As"+strWidgetID,false);
		//alert("save display DocumentID="+strDocumentID+" WidgetID="+strWidgetID+" WidgetName="+strWidgetName);

		var strLocation=f.save_display_as_location.value;
		var str=convertFormToWidgetContent(strWidgetID);

		//show status message
		showDisplayOptionsStatus(strWidgetID,strDisplayName,"Saving display: "+strDisplayName,true);
		
		var strTokenizedName=tokenizeSpecialChars(strDisplayName,true);
		var strUrl="https://__server__/?Network=Library&ID=acceptWidgetByID&new=true&Name="+strTokenizedName+"&Location="+strLocation+"&metadata="+strDocumentID+"_"+strWidgetName+"&Content="+str;
		appendToLog("strUrl="+strUrl);

		var strResult="";
		strResult=getxmlHttpRequest(strUrl);
		
		//add the display to the list of displays
		if (strResult.startsWith("ok")) {
			var arString=getSubStringArray(strResult,"|",true);
			if (arString.length>2) {
				var f=document.forms["Filter"+strWidgetID];
				arString[2]=tokenizeSpecialChars(arString[2],false);
				
				//add the display to the drop down list and select it
				f.Display.options[f.Display.options.length]=new Option(arString[2],arString[1],false,false);
				f.Display.value=arString[1];	
				
				//set the name of the display in the customize div
				document.getElementById("display_name_"+strWidgetID).innerHTML=arString[2];
				
				//set the name of the display passed when refreshing the widget
				f.DisplayName.value=arString[2];
			};

			//hide status message
			showDisplayOptionsStatus(strWidgetID,strWidgetName,"",false);
		}
		else {
			showDisplayOptionsStatus(strWidgetID,strWidgetName,strResult,true,true);
		};
	};
};

//Deletes a display.  The boolConfirm argument is set to true the first time this function is called which causes the confirmation
//dialog to be displayed.  When this function is called from the confirmation dialog, the widget is deleted
function deleteDisplay(strWidgetID,boolConfirm) {
	if (boolConfirm) {
		divFilter=document.getElementById("Filter"+strWidgetID);
		divDelete=document.getElementById("Delete_Display"+strWidgetID);
		divDelete.style.left=(divFilter.offsetLeft+30)+"px";
		var intTopAdjust=getContainerAdjustment(document.getElementById("Customize"+strWidgetID));
		divDelete.style.top=(divFilter.offsetTop+divFilter.offsetHeight+30-intTopAdjust)+"px";
		divDelete.style.zIndex=4;
		document.getElementById("Confirm_Delete_Message"+strWidgetID).innerHTML=document.getElementById("display_name_"+strWidgetID).innerHTML;
		setVisible("Delete_Display"+strWidgetID,true);

		var arXY=getPosition(divFilter);
		divDelete.style.top=(arXY[1]+60-intTopAdjust)+"px";
	}
	else {
		setVisible("Delete_Display"+strWidgetID,false);

		//show status message
		var strDisplayName=document.getElementById("display_name_"+strWidgetID).innerHTML;
		showDisplayOptionsStatus(strWidgetID,strDisplayName,"Deleting display: "+strDisplayName,true,false);
		
		var str=convertFormToWidgetContent(strWidgetID);
		var strDisplayWidgetID=document.forms["Filter"+strWidgetID].Display.value;
		var strUrl="https://__server__/?Network=Library&ID=acceptWidgetByID&WidgetID="+strDisplayWidgetID+"&delete=true";

		//need to use xmlhttprequest when the page is served by a remote server.  The problem with this though is that the local widget cache
		//is not updated when the display is saved because acceptWidgetByID is not called locally
		var strDisplayServer=document.forms["Filter"+strWidgetID].display_server.value;
		if (strDisplayServer.indexOf("127.0.0.1")<=0) {
			//strUrl="https://__server__/?Network=greenlight&ID=getXmlHttpRequest&url=https://"+strDisplayServer+"/?Network=Library|ID=acceptWidgetByID|WidgetID="+strDisplayWidgetID+"|delete=true";
			strUrl="https://"+strDisplayServer+"/?Network=Library&ID=acceptWidgetByID&WidgetID="+strDisplayWidgetID+"&delete=true";
		};

		strResult=getxmlHttpRequest(strUrl);

		//alert("delete display Result="+strResult);
		if ((true) || (strResult.startsWith("ok"))) {
			//remove the display from the drop-down list and select the next one up
			var f=document.forms["Filter"+strWidgetID];
			var intNewSelection=-1;
			for (var i=0;i<f.Display.options.length;i++) {
				if (f.Display.options[i].value==strDisplayWidgetID) {
					intNewSelection=i-1;
					f.Display.options[i]=null;
				};
			};
			
			if (intNewSelection<0) intNewSelection=0;
			if (intNewSelection<f.Display.options.length) {
				f.Display.value=f.Display.options[intNewSelection].value;
				selectDisplay(strWidgetID);
			};

			//hide status message
			showDisplayOptionsStatus(strWidgetID,strDisplayName,"",false);
		}
		else {
			showDisplayOptionsStatus(strWidgetID,strDisplayName,strResult,true,true);
		};
	};
};

//Updates tooltips for selected fields
function setTooltipsForFieldsSelected(strWidgetID) {
	if (document.forms["Filter"+strWidgetID]) {
		var SelectAll=document.forms["Filter"+strWidgetID].AllFields;
		var Select2=document.forms["Filter"+strWidgetID].FieldsSelected;
		for (var i=0;i<Select2.options.length;i++) {
			for (var j=0;j<SelectAll.options.length;j++) {
				if (SelectAll.options[j].value==Select2.options[i].value) {
					if (SelectAll.options[j].getAttribute("tooltip")) {
						Select2.options[i].setAttribute("onMouseOver","javascript:showTooltip(event,'"+SelectAll.options[j].getAttribute("tooltip")+"',10,10)");
						Select2.options[i].setAttribute("onMouseOut","javascript:showTooltip(event,'',0,0)");
					};
				};
			};
		};
	};
};

//updates the list of fields available from the AllFields select box
//this provides a single function that can be used to update the list whenever fields are added or removed from the selectd field
//so the list only displays those fields not in the selected field list
function updateFieldsAvailable(strWidgetID) {
	var SelectAll=document.forms["Filter"+strWidgetID].AllFields;
	var Select1=document.forms["Filter"+strWidgetID].FieldsAvailable;
	var Select2=document.forms["Filter"+strWidgetID].FieldsSelected;
	
	//make an array of all the values in the list of fields selected
	var strValues="|";
	for (var i=0;i<Select2.options.length;i++) strValues +=Select2.options[i].value + "|";

	//clear the list of fields available
	Select1.options.length=0;
	
	//add in all fields not in the list of selected fields
	for (var i=0;i<SelectAll.options.length;i++) {
		if (strValues.indexOf("|"+SelectAll.options[i].value+"|")<0) {
			var ndx=Select1.options.length;
			Select1.options[ndx]=new Option(SelectAll.options[i].text,SelectAll.options[i].value,false,false);
			if (SelectAll.options[i].getAttribute("tooltip")) {
				Select1.options[ndx].setAttribute("onMouseOver","javascript:showTooltip(event,'"+SelectAll.options[i].getAttribute("tooltip")+"',10,10)");
				Select1.options[ndx].setAttribute("onMouseOut","javascript:showTooltip(event,'',0,0)");
			};
		};
	};
	
	//set tooltips for all fields selected
	setTooltipsForFieldsSelected(strWidgetID);
};

//adds fields to the list of selected fields.  Called when the 'Add' button is selected
function addSelectedFields(strWidgetID) {
	var Select1=document.forms["Filter"+strWidgetID].FieldsAvailable;
	var Select2=document.forms["Filter"+strWidgetID].FieldsSelected;
	
	//get insertion index - This is the first field selected in the list of selected fields
	var intInsertIndex=-1;
	for (var i=0;(intInsertIndex<0) && (i<Select2.options.length);i++) {
		if (Select1.options[i].selected) intInsertIndex=i;
	};
	
	for (var i=0;i<Select1.options.length;i++) {
		if (Select1.options[i].selected) {
			var intInsertAt=Select2.options.length;
			Select2.options[intInsertAt]=new Option(Select1.options[i].text,Select1.options[i].value,false,false);
			if (Select1.options[i].getAttribute("tooltip")) {
				Select2.options[ndx].setAttribute("onMouseOver","javascript:showTooltip(event,'"+Select1.options[i].getAttribute("tooltip")+"',10,10)");
				Select2.options[ndx].setAttribute("onMouseOut","javascript:showTooltip(event,'',0,0)");
			};
		};
	};
	
	updateFieldsAvailable(strWidgetID);
};

//removes fields from the list of selected fields.  Called when the remove button is pressed
function removeSelectedFields(strWidgetID) {
	var Select2=document.forms["Filter"+strWidgetID].FieldsSelected;
	var Cntr=0;
	do {
		(Select2.options[Cntr].selected) ? Select2.options[Cntr]=null : Cntr++;
	} while (Cntr<Select2.options.length);
				
	updateFieldsAvailable(strWidgetID);
};

//moves a field up or down by one
function moveField(Select,Index,Direction) {
	if (Index>=Select.options.length) return;
	if ((Index+Direction>Select.options.length-1) || (Index+Direction<0)) return;
	
	var strText=Select.options[Index].text;
	var strValue=Select.options[Index].value;
	var boolSelected=Select.options[Index].selected;
	Select.options[Index].text=Select.options[Index+Direction].text;
	Select.options[Index].value=Select.options[Index+Direction].value;
	Select.options[Index].selected=Select.options[Index+Direction].selected;
	Select.options[Index+Direction].text=strText;
	Select.options[Index+Direction].value=strValue;
	Select.options[Index+Direction].selected=boolSelected;
};

//moves selected fields up
function moveFieldsUp(strWidgetID) {
	var Select2=document.forms["Filter"+strWidgetID].FieldsSelected;
	for (var i=0;i<Select2.options.length;i++) {
		if (Select2.options[i].selected) moveField(Select2,i,-1);
	};
	
	//set tooltips for all fields selected
	setTooltipsForFieldsSelected(strWidgetID);
};

//moves selected fields down
function moveFieldsDown(strWidgetID) {
	var Select2=document.forms["Filter"+strWidgetID].FieldsSelected;
	for (var i=Select2.options.length-1;i>=0;i--) {
		if (Select2.options[i].selected) moveField(Select2,i,1);
	};
	
	//set tooltips for all fields selected
	setTooltipsForFieldsSelected(strWidgetID);
};

//Displays the dialog used to customize a display
function editFilter(strWidgetID,e)
{
	//Abort if the display is refreshing
	if(arRefreshing.indexOf(strWidgetID+"|")>=0) return;

	//initialize fields available from the master list (less those in the selected list)
	updateFieldsAvailable(strWidgetID);
	
	divFilter=document.getElementById("Filter"+strWidgetID);	//The div containing the display drop-down and save/delete/refresh buttons
	divCustom=document.getElementById("Customize"+strWidgetID); //The div containing the display settings.  This is the div that will be made visible.
	divCustomFields=document.getElementById("FilterCustomFields"+strWidgetID); //The div containing fields specific to the selected table.  It is contained in the custom div

	//just close the filter dialog if it's already open - this allows the custom option to act as a toggle
	if(isVisible(divCustom)) {
		setVisible(divCustom,false);
		return;
	};
	
	var intTop=divFilter.offsetTop+divFilter.offsetHeight;
	
	//adjust the top coordinate if the widget is being displayed inside an absolutely positioned div in a widget container.
	//The absolute positioning of the div causes the filter dialog to be positioned relative to the container div
	var intTopAdjust=getContainerAdjustment(document.getElementById("Customize"+strWidgetID));
	
	divCustom.style.left=divFilter.offsetLeft+"px";
	//divCustom.style.width=divFilter.offsetLeft+divFilter.offsetWidth+"px";
	divCustom.style.top=intTop-intTopAdjust;
	divCustom.style.zIndex=3;
	setVisible("Customize"+strWidgetID,true);
	divCustom.style.height=(400+divCustomFields.offsetHeight)+"px";

	if (e) {
		var d=document.getElementById("Customize"+strWidgetID);
		var arXY=getPosition(e);
		d.style.top=(arXY[1]+30-intTopAdjust)+"px";
		//(arXY[1]>=20) ? d.style.top=(arXY[1]-20)+"px" : d.style.top="0px";
		//d.style.left=0;
	};
	
	//divCustom.style.width=divContainer.offsetWidth;
};

//Closes the dialog used to customize a display
function closeEditFilter(strWidgetID) {
	setVisible("Customize"+strWidgetID,false)
};

/******************************************************************************
Displays a message on top of the display dialog.  Used to provide a consistent look
******************************************************************************/
function showDisplayDialogMessage(sTableID,msg)
{
	var dMsg=document.getElementById("Display_Dialog_Msg_"+sTableID);
	if(dMsg) {
		if((msg) && (msg.length>0)) {
			dMsg.innerHTML=msg;
			setVisible(dMsg,true);
		}
		else {
			setVisible(dMsg,false);
		};
	};
};

/*************************************************************************
Called when a sort selection is made in the displays dialog
*************************************************************************/
function selectSort(e,TableID)
{
	validateSubtotalSelections(e,TableID);
};

/*************************************************************************
Called when a subtotal checkbox is clicked in the displays dialog
*************************************************************************/
function selectSubtotal(e,TableID)
{
	validateSubtotalSelections(e,TableID);
};

/*************************************************************************
Ensures that the sort and subtotal selectsions in the displays dialog are valid
*************************************************************************/
function validateSubtotalSelections(e,TableID)
{
	var eSort=new Array();
	eSort[0]=document.getElementById("SortBy1_"+TableID);
	eSort[1]=document.getElementById("SortBy2_"+TableID);
	eSort[2]=document.getElementById("SortBy3_"+TableID);
	eSort[3]=document.getElementById("SortBy4_"+TableID);
	
	var eSubtotal=new Array();
	eSubtotal[0]=document.getElementById("Subtotal1_"+TableID);
	eSubtotal[1]=document.getElementById("Subtotal2_"+TableID);
	eSubtotal[2]=document.getElementById("Subtotal3_"+TableID);
	eSubtotal[3]=document.getElementById("Subtotal4_"+TableID);

	var eSubtotalsOnly=document.getElementById("SubtotalsOnly_"+TableID);
	var eGrandtotalsOnly=document.getElementById("GrandtotalsOnly_"+TableID);

	var cSubtotal=0;
	for(var i=0;i<4;i++) {
		if(eSort[i].value=="0") {
			eSubtotal[i].checked=false;
			eSubtotal[i].enabled=false;
		}
		else {
			eSubtotal[i].enabled=true;
		};
		if(eSubtotal[i].checked) cSubtotal++;
	};
		
	if(cSubtotal==0) {
		eSubtotalsOnly.checked=false;
		eSubtotalsOnly.enabled=false;
		eGrandtotalsOnly.checked=false;
		eGrandtotalsOnly.enabled=false;
	}
	else {
		eSubtotalsOnly.enabled=false;
		eGrandtotalsOnly.enabled=false;
	};
};


/***********************************************************************************
Called by various widgets to refresh a widget or execute a command.  For example,
called from the inventory maintenance debugging page when a button is pressed to
execute a command on the remote computer.
Params:
	WidgetArgs - The widget to be retrieved e.g. source=xxx&documentID=xxx...
	OutputID - Optional ID of the element to receive output from the widget
	ShowIcon - If true, a wait icon will be displayed in the OutputID 
***********************************************************************************/
function getEmbeddedWidget(WidgetArgs,OutputID,ShowIcon) {
	var sUrl=getServer()+"/?network=greenlight&id=getWidget&"+WidgetArgs;
	var e=null;
	if(OutputID) {
		e=document.getElementById(OutputID);
		if(ShowIcon) showStatusIcon(e);
	};
	asynchInclude(e,sUrl,"","");
};

/***********************************************************************
Evaluates an Aspect expression and records the result in the element
given by e.  Can be used to update content without having to create
a separate Aspect script to get the content.
***********************************************************************/
function aspectEval(e,Expression,ShowIcon)
{
	if(ShowIcon) showStatusIcon(e);
	var sUrl=getServer()+"/?Network=GreenLight&ID=getWidget";
	sUrl +="&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&Widget=Notification Queries"
	sUrl +="&query=evaluateExpression&Expression="+replaceAllSubstrings(Expression," ","\\x20");
	var sFunc="aspect('',s)";
	asynchInclude(e,sUrl);
};

/***********************************************************************************
opens a document using the default viewer
***********************************************************************************/
function openDocument(Filename,HashID)
{
	var sUrl=getServer()+"/?Network=Greenlight&ID=getWidget";
	sUrl+="&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&Widget=Notification Container&ContainerItemID=543755";
	sUrl+="&Action=openDocument&Filename="+Filename;
	if(HashID) sUrl +="&Source="+HashID;
	asynchInclude(null,sUrl);
};

/***********************************************************************************
Opens the given file in the default viewer for the file type.
Called by the "view" field in the greenlight generic filespec driver
***********************************************************************************/
function launchFileViewer(e,CustomerID,Filename,top,Result)
{
	var left=400;

	if(Result) {
		showDialog();
		if(Result.toUpperCase().startsWith("ERROR")) {
			showDialog("msg="+Result+"<br><br>&fnok=close&left="+left+"&top="+top);
		};
		return;
	};

	var xy=getPosition2012(e,"absolute",document.getElementsByTagName('BODY')[0]);
	var top=xy[1];

	var sUrl=getServer()+"/?Network=Greenlight&ID=getWidget";
	sUrl +="&Source=v8k3ey5q1";
	sUrl +="&DocumentID=CExis5b6ybLmITZ2wF7XmGwk&Widget=Notification Queries";
	sUrl +="&query=launchViewerForRemoteFile&CustomerID="+CustomerID+"&RemoteFilename="+Filename;
	showDialog("icon=true&msg=Opening "+Filename+" from "+CustomerID+"&left="+left+"&top="+top);
	var sFunc="launchFileViewer(null,\x22"+CustomerID+"\x22,\x22"+Filename+"\x22,"+top+",s)";
  asynchInclude(null,sUrl,sFunc,sFunc);
};

function getTextDocumentForEditing(DialogID)
{
	var d=document.getElementById(DialogID);
	var sHashID=d.getAttribute("aspecthashid");

	//get the filename from the span element containing it
	var sFlename="";
	var arSpan=d.getElementsByTagName("span");
	for (var i=0;i<arSpan.length;i++) {
		if(arSpan[i].getAttribute("name").equalsIgnoreCase("filename")) 
		{
			sFilename=arSpan[i].innerHTML;
			var eContent=document.getElementById("statecontent"+DialogID);

			var bIsDirectory=false;
			var e=document.getElementById("RemoteIsDirectory"+DialogID);
			if(e) {
				if(e.value.equalsIgnoreCase("true")) {
					bIsDirectory=true;
				}
				else {
					e=document.getElementById("RemoteIsDirectory"+DialogID);
					if(e) {
						if(e.value.equalsIgnoreCase("true")) bIsDirectory=true;
					};
				};
			};

			if(!bIsDirectory) 
			{
				//show status icon.  Add some padding to the bottom of it so the dialog doesn't 
				//noticeably shrink and expand in height in an annoying way.
				var img=new Image();
				img.src=imageStatusActive.src;
				img.style.paddingBottom="1000px";
				eContent.innerHTML="";
				eContent.appendChild(img);
				eContent.appendChild(document.createTextNode(" Loading..."));
	
				//make a request to load the document into the content div
				var sUrl=getServer()+"/?Network=GreenLight&ID=getWidget&Source="+sHashID+"&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&Widget=Notification Queries";
				sUrl +="&query=fileGetContent&filename="+sFilename;
				//appendToLog("sUrl="+sUrl,false,true);
				asynchInclude(eContent,sUrl);
			}
			else {
				eContent.innerHTML="";
			};
		};
	};
};

/***********************************************************************************
Called by clicking the run icon in the scheduled tasks table
***********************************************************************************/
function runAspectTask(e,CustomerID,DriverID,TaskName,top,left,Result)
{

	if(Result) {
		showDialog("msg="+Result+"<br><br>&fnok=close&left="+left+"&top="+top);
		return;
	};

	var xy=getPosition2012(e,"absolute",document.getElementsByTagName('BODY')[0]);
	var top=xy[1];
	var left=xy[0];

	var sUrl=getServer()+"/?Network=Greenlight&ID=getWidget";
	sUrl +="&Source="+CustomerID;
	sUrl +="&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&Widget=Notification Queries";
	sUrl +="&query=execScheduledTask&TaskDriverID="+DriverID+"&TaskName="+TaskName;
	showDialog("icon=true&msg=Executing "+TaskName+" on "+CustomerID+"&left="+left+"&top="+top);
	var sFunc="runAspectTask(null,\x22"+CustomerID+"\x22,\x22"+DriverID+"\x22,\x22"+TaskName+"\x22,"+top+","+left+",s)";
  asynchInclude(null,sUrl,sFunc,sFunc);
};



/******************************************************************************************************
Videos
******************************************************************************************************/
//Plays the video with the given ID
//Right now, the ID represents a youtube video ID.  In the future, it could be changed to indicate a file on another server
function playVideo(strVideoID) 
{
	//get the div that will display the video
	var div=document.getElementById("video_display");
	
	//add a div if one has not been included on the page
	if (!div) {
		div=document.createElement('div');
		div.className="play_video";
		div.setAttribute("class","play_video");
		div.id="video_display";
		div.style.position="absolute";
		div.style.top="50px";
		div.style.left="0px"; 
		div.style.width="1024px";
		div.style.height="596px";
		div.style.borderStyle="solid";
		div.style.borderWidth="1px";
		div.style.padding="0px";
		div.style.margin="0px";
		div.style.backgroundColor="white";
		div.style.zIndex=99;
		document.body.appendChild(div);
	};

	var str="<div class='close_video'><a href='#home' onClick='setVisible(\x22video_display\x22,false)'>Close this window</a></div>";
	str +="<object ID='embedded_video'>";
	str +="<embed src=http://www.youtube.com/v/"+strVideoID+"?fs=1&amp;hl=en_US type='application/x-shockwave-flash' allowscriptaccess='always' allowfullscreen='true' width='1024' height='576'>";
	str +="</object>";
	div.innerHTML=str;
	setVisible("video_display",true);
};

// This function does not work in IE.  Errors are thrown in the appendChild functions
function playVideo1(strVideoID) 
{
	//create the embed object
	var obj=document.createElement('object');
	obj.setAttribute("ID","embedded_video");

	//set the parameters
	var param=document.createElement('param');
	param.setAttribute("allowFullScreen","true");
	param.setAttribute("allowscriptaccess","always");
	param.setAttribute("name","movie");
	obj.appendChild(param);

	var param=document.createElement('embed');
	param.setAttribute("src","http://www.youtube.com/v/"+strVideoID+"?fs=1&amp;hl=en_US");  
	param.setAttribute("type","application/x-shockwave-flash");
	param.setAttribute("allowscriptaccess","always");
	param.setAttribute("allowfullscreen","true");
	param.setAttribute("width","1024");
	param.setAttribute("height","576");
	obj.appendChild(param);

	//get the div that will display the video
	var div=document.getElementById("video_display");
	
	//add a div if one has not been included on the page
	if (!div) {
		div=document.createElement('div');
		div.setAttribute("class","play_video");
		div.setAttribute("id","video_display");
		var divClose=document.createElement('div');
		divClose.setAttribute("class","close_video");
		var a=document.createElement('a');
		a.setAttribute("href","javascript:setVisible('video_display',false)");
		a.onclick=Function("setVisible('video_display',false)");
		a.innerHTML="Close this window";
		divClose.appendChild(a);
		div.appendChild(divClose);
		
		document.body.appendChild(div);
	};

	//remove any existing video from the div
	var v=document.getElementById("embedded_video");
	if (v) div.removeChild(v);
	
	//add the new video
	div.appendChild(obj);
	setVisible("video_display",true);
};




/******************************************************************************************************
ComboBox
******************************************************************************************************/
function comboBox(aFormName,aInputName,aSelectName)
{
//alert("initializing comboBox("+aFormName+","+aInputName+","+aSelectName+")");
appendToLog("initialize combobox("+aFormName+","+aInputName+","+aSelectName+")");	
	//Array of options originally added to the select box
	this.arOptionName=new Array();
	this.arOptionValue=new Array();
	
	//Create an ID for the combobox and add it to the array of comboboxes
	if (!window.arComboBox) window.arComboBox=[];
	this.ID=window.arComboBox.length;
	window.arComboBox[this.ID]=this;
	
	this.comboBoxShow=f_comboBoxShow;
	this.comboBoxHide=f_comboBoxHide;
	this.comboBoxHideIfNotSelectFocused=f_comboBoxHideIfNotSelectFocused;
	this.comboBoxToggle=f_comboBoxToggle;
	this.comboBoxUpdateList=f_comboBoxUpdateList;
	this.comboBoxSetValue=f_comboBoxSetValue;
	this.comboBoxSelectHasFocus=f_comboBoxSelectHasFocus;

	eForm=document.forms[aFormName];
	if (eForm) {
		this.eInput=eForm.elements[aInputName];
		this.eSelect=eForm.elements[aSelectName];
		if (!this.eInput) alert("Error initializing comboBox.  Input does not exist: "+aInputName);
		if (!this.eSelect) alert("Error initializing comboBox.  Select does not exist: "+aSelectName);
		if ((!this.eInput) || (!this.eSelect)) return;
		
		this.SelectHasFocus=false;
		
		//add functions to the input and select controls
		this.eInput.onclick=Function("arComboBox['" + this.ID + "'].comboBoxShow()");
		this.eInput.onkeyup=Function("arComboBox['" + this.ID + "'].comboBoxUpdateList()");
		this.eInput.onblur=Function("arComboBox['" + this.ID + "'].comboBoxHideIfNotSelectFocused()");
		this.eSelect.onclick=Function("arComboBox['"+ this.ID + "'].comboBoxHide()");
		this.eSelect.onfocus=Function("arComboBox['"+ this.ID + "'].comboBoxSelectHasFocus()");
		this.eSelect.onblur=Function("arComboBox['"+ this.ID + "'].comboBoxHide()");
		
		//save a copy of the options defined in the select input
		for (var i=0;i<this.eSelect.length;i++) {
			this.arOptionName[i]=this.eSelect.options[i].text;
			this.arOptionValue[i]=this.eSelect.options[i].value;
			if ((i==0) || (this.eSelect.options[i].value==this.eSelect.value)) this.eInput.value=this.eSelect.options[i].text;
		};
	}
	else {
		alert("Error initializing comboBox.  Form does not exist: "+aFormName);
	};
};

function f_comboBoxSetValue() 
{
	if ((this.eInput) && (this.eSelect)) {
		for (var i=0;i<this.eSelect.length;i++) {
			if (this.eSelect.options[i].value.equalsIgnoreCase(this.eSelect.value)) {
				this.eInput.value=this.eSelect.options[i].text.trim();
				return;
			};
		};
	};
};

function f_comboBoxUpdateList() 
{
	//clear the select box
	while (this.eSelect.length>0) this.eSelect.remove(0);
	
	//get the text displayed in the input box
	var str=this.eInput.value.toUpperCase();
	
	//add options that contain the text
	for (var i=0;i<this.arOptionName.length;i++) 
	{
		if ((str.length==0) || (this.arOptionName[i].toUpperCase().indexOf(str)>=0))
		{
			var eOption=document.createElement("option");
			eOption.text=this.arOptionName[i];
			eOption.value=this.arOptionValue[i];
			try {
				this.eSelect.add(eOption,null);	// standards compliant; doesn't work in IE
			}
			catch(ex) {
				this.eSelect.add(eOption);	// IE only
			};
		};
	};
};

function f_comboBoxHideIfNotSelectFocused() {
	if (this.SelectHasFocus==false) this.comboBoxHide();
};

function f_comboBoxSelectHasFocus() {
	this.SelectHasFocus=true;
};

function f_comboBoxShow() {
	if (this.eSelect) {
		//position and size the select box
		this.eSelect.style.left=this.eInput.offsetLeft;
		this.eSelect.style.top=this.eInput.offsetTop+this.eInput.offsetHeight;
		this.eSelect.style.zIndex=10000;
		this.eSelect.style.width=this.eInput.offsetWidth;
		
		this.eSelect.style.display="block";
	};
};

function f_comboBoxHide() {
	if (this.eSelect) {
		this.comboBoxSetValue();
		this.eSelect.style.display="none";
		this.SelectHasFocus=false;
	};
};

function f_comboBoxToggle() {
	//alert("toggle combobox");
	if (this.eSelect) {
		if (this.eSelect.style.display=="none") {
			this.comboBoxShow();
		}
		else {
			this.comboBoxHide();
		};
	};
};






/****************************************************************************
Fields:
	TableID			- ID of table for which dawta is being submitted
	HashID			- HashID
	DriverID		- Driver ID
	DriverParams	- Driver params
	KeyExpression	- Key Expression
	AllFieldID		- All Field ID's
	AllFieldType	- All Field Types
****************************************************************************/
var arTableMetadata=new Array();

/****************************************************************************
Fields:
	TableID			- ID of table for which data is being submitted
	KeyValue		- Key value
	FieldID			- Field ID of data
	Value			- Value to be submitted
	Status			- 0 - data has been added to the array.  This is the first step
					  1 - data has been submitted to the server
					  2 - data submission is complete
					  3 - data was replaced by new data before it was submitted
	IsNewRecord		- True if the data is being recorded for a new record
	IsDeletedRecord	- True if the data is being recorded to delete a record
	tAdd			- Time added
	tSubmit			- Time submitted
	tComplete		- Time complete
	tConfirmed		- boolean value indicating that submission of the data to the server has been confirmed
****************************************************************************/
var arPendingDataSubmissions=new Array();

/****************************************************************************
This variable is used to turn debugging information on or off for all functions 
related to submitting of data from a table
****************************************************************************/
var bEnableSubmissionDebugging=false;

/****************************************************************************
Start the data submission loop
****************************************************************************/
initDataSubmissionLoop();

function initDataSubmissionLoop() {
	if(eval("typeof dataSubmissionLoop")=="function") {
		dataSubmissionLoop();
		return;
	};
	
	setTimeout("initDataSubmissionLoop()",3000);
};

/******************************************************************************
This function is called by clicking a checkbox in the UI settings in the support
home widget.  A div with the ID debugDataSubmissionWrapper is defined in the 
Support Home 2015 widget.  This div contains a div with the ID debugDataSubmission_.
When the checkbox is clicked, the wrapper is made visible and the trailing underscore is 
removed ID contained in the div.
******************************************************************************/
function showDataSubmissionStatus(b) {
	var d=document.getElementById("debugDataSubmissionWrapper");
	if(!d) return;

	if(b) {
		setVisible(d,true);
		bEnableSubmissionDebugging=true;
		var d1=document.getElementById("debugDataSubmission_");
		if(d1) d1.id="debugDataSubmission";
		d1=document.getElementById("debugDataSubmissionLog_");
		if(d1) d1.id="debugDataSubmissionLog";
	}
	else {
		setVisible(d,false);
		bEnableSubmissionDebugging=false;
	};
};

/******************************************************************************
Clears the data submission log contained in the div with the ID debugDataSubmissionLog 
and clears the arPendingDataSubmissions array.  
******************************************************************************/
function clearDatasubmissionLog() {
	var d=document.getElementById("debugDataSubmission");
	if(d) d.innerHTML="";
	d=document.getElementById("debugDataSubmissionLog");
	if(d) d.innerHTML="";
	arPendingDataSubmissions.length=0;
};

function appendToSubmitLog(s) {
	var d=document.getElementById("debugDataSubmissionLog");
	if(!d) return;
	
	var s1=replaceAllSubstrings(replaceAllSubstrings(s,"<","&lt;"),">","&gt;");
	var s1=replaceAllSubstrings(s1,"&","@");
	s1=formatDate(new Date(),"HH:mm:ss:SSS")+" "+s1;
	d.innerHTML+=s1+"\r\n";
	if(console) console.log(s1);
};

function debugDataSubmission() {
	var div=document.getElementById("debugDataSubmission");
	if(!div) return;
	var arStatusDescription=new Array('New','Submitted','Complete','Replaced');
	var sTable="";
	sTable="<table class='bordered'>";
	sTable +="<tr>";
	sTable +="<th align='left'>n</th>";
	sTable +="<th align='left'>TableID</th>";
	sTable +="<th align='left'>Key</th>";
	sTable +="<th align='left'>FieldID</th>";
	sTable +="<th align='left'>Value</th>";
	sTable +="<th align='left'>Status</th>";
	sTable +="<th align='left'>Add</th>";
	sTable +="<th align='left'>Submit</th>";
	sTable +="<th align='left'>Submit Confirmed</th>";
	sTable +="<th align='left'>Complete</th>";
	sTable +="<th align='left'>New</th>";
	sTable +="<th align='left'>Delete</th>";
	sTable +="</tr>";
	for(var i=0;i<arPendingDataSubmissions.length;i++) {
		sTable +="<tr>";
		sTable +="<td>"+i+"</td>";
		sTable +="<td>"+arPendingDataSubmissions[i].TableID+"</td>";
		sTable +="<td>"+replaceAllSubstrings(arPendingDataSubmissions[i].KeyValue,",",", ")+"</td>";
		sTable +="<td>"+replaceAllSubstrings(arPendingDataSubmissions[i].FieldID,",",", ")+"</td>";
		sTable +="<td>"+replaceAllSubstrings(arPendingDataSubmissions[i].Value,",",", ")+"</td>";
		sTable +="<td>"+arPendingDataSubmissions[i].Status+"-"+arStatusDescription[arPendingDataSubmissions[i].Status]+"</td>";
		sTable +="<td>"+arPendingDataSubmissions[i].tAdd+"</td>";
		sTable +="<td>"+arPendingDataSubmissions[i].tSubmit+"</td>";
		sTable +="<td>"+arPendingDataSubmissions[i].tConfirmed+"</td>";
		sTable +="<td>"+arPendingDataSubmissions[i].tComplete+"</td>";
		sTable +="<td>"+arPendingDataSubmissions[i].IsNewRecord+"</td>";
		sTable +="<td>"+arPendingDataSubmissions[i].IsDeletedRecord+"</td>";
		sTable +="</tr>";
	};
	sTable +="</table>"
	div.innerHTML=sTable;
};

/******************************************************************************
This counter is used to determine if a call to submitTableData is active.  
The dataSubmissionLoop() will avoid removing completed records from the array 
if a call is in progress.
******************************************************************************/
var cSubmitTableData=0;

/******************************************************************************
This function adds data to the arPendingDataSubmissions arrau.
	ATableID	- ID of the table for which data is being submitted
	AKeyValue	- Comma-delimited list of one or more key values.  
	AFieldID	- Comma-delimited list of field ID's
	AValue		- Comma-delimited list of values.  Commas in the values must be tokenized
				  using the word comma preceeded and followed by two forward slashes.  
				  submitTableCell() and submitDialogCell() tokenize commas before calling 
				  this function.
				  
	The number of FieldID's and Values must be the same.  The number of KeyValues must 
	also equal the number of fields and values or it may be a single key value to record all 
	data using the same key.
	
	Note: Need to overwrite fields that already exist in the array but that have not been submitted yet
******************************************************************************/
function submitTableData(ATableID,AKeyValue,AFieldID,AValue,AIsNewRecord,AIsDeletedRecord) {
	//increment the flag used to determine if this function is active
	cSubmitTableData++;
	
	if(bEnableSubmissionDebugging) appendToSubmitLog("submitTableData: ATableID:"+ATableID+" AKeyValue:"+AKeyValue+" AFieldID:"+AFieldID+" AValue:"+AValue+" AIsNewRecord:"+AIsNewRecord);
	var arKeyValue=getSubStringArray(AKeyValue,",",true);
	var arFieldID=getSubStringArray(AFieldID,",",true);
	var arValue=getSubStringArray(AValue,",",true);
	
	//abort if the number of fields and number of values are not the same
	if(arFieldID.length!=arValue.length) {
		appendToSubmitLog("Error: submitTableData: ATableID:"+ATableID+" AKeyValue:"+AKeyValue+" AFieldID:"+AFieldID+" AValue:"+AValue+" AIsNewRecord:"+AIsNewRecord,false,true);
		appendToSubmitLog("Error: submitTableData: Mismatched number of fieldID and values",false,true); 
		cSubmitTableData--;
		return;
	};

	//add the fields to the array
	for(var i=0;i<arFieldID.length;i++) {
		var sKeyValue=(arKeyValue.length>i) ? arKeyValue[i] : arKeyValue[0];
		var NewDataSubmission={TableID:ATableID,KeyValue:sKeyValue,FieldID:arFieldID[i],Value:arValue[i],Status:0,IsNewRecord:AIsNewRecord,IsDeletedRecord:AIsDeletedRecord,tAdd:formatDate(new Date(),"HH:mm:ss:SSS"),tSubmit:"",tComplete:"",tConfirmed:false};
		if(!AIsNewRecord) NewDataSubmission.IsNewRecord=false;
		if(!AIsDeletedRecord) NewDataSubmission.IsDeletedRecord=false;
		
		//overwrite existng record if one exists that has not been submitted yet
		var bFouncMatch=false;
		for(var j=0;((!bFouncMatch) && (j<arPendingDataSubmissions.length));j++) {
			if(arPendingDataSubmissions[j].Status==0) {
				if(arPendingDataSubmissions[j].TableID==ATableID) {
					if(arPendingDataSubmissions[j].KeyValue==sKeyValue) {
						if(arPendingDataSubmissions[j].FieldID==arFieldID[i]) {
							if(bEnableSubmissionDebugging) {
								appendToSubmitLog("Replaced previous value: "+arPendingDataSubmissions[j].Value+" with new value: "+arValue[i]);
							};
							arPendingDataSubmissions[j].Status=3;
							arPendingDataSubmissions[j].tComplete=formatDate(new Date(),"HH:mm:ss:SSS");
							var r=arPendingDataSubmissions.length;
							arPendingDataSubmissions[r]=NewDataSubmission;
							bFouncMatch=true;
						};
					};
				};
			}
		};
		
		//add a new record if a match was not found
		if(!bFouncMatch) {
			var r=arPendingDataSubmissions.length;
			arPendingDataSubmissions[r]=NewDataSubmission;
			appendToSubmitLog("Added pending submission.  arPendingDataSubmissions len="+arPendingDataSubmissions.length);
		};
	};

	//add informaiton about the table to the arTableMetadata array
	//This is used by submitToServer to allow for the possibility that the table is closed before the data is submitted
	recordTableMetadata(ATableID);
	
	//update the debugging table
	debugDataSubmission();

	cSubmitTableData--;
};

//This flag indicates whether there is an outstanding request to the server to get pending submissions
var WaitingForPendingSubmissions=false;

/******************************************************************************
This function:
	1.	submits pending data to the server.  New data is not submitted to the server until 
		all pending submissions are cleared.
	2.	updates the status of pending submissions by requesting information about pending
		submissions from the server
	
Mode has the following values:
	0 - Submit any pending submissions
	1 - Update status of pending submissions
******************************************************************************/
function dataSubmissionLoop() {
	//appendToSubmitLog("dataSubmissionLoop started");

	//abort if there are no records in the array
	if(arPendingDataSubmissions.length==0) {
		setTimeout("dataSubmissionLoop()",5000);
		return; 
	};
	
	/*	get an array of information about each table in the array including the number
		records with a status of 0 (new) and 1 (submitted).  Each element of the array
		includes the fields: TableID, Status0, Status1.  Status0 and Status1 indicate
		how many records there are with each status	*/
	var arTableSummary=getPendingSubmissionSummary();
	
	//abort if there are no new or incomplete submissions
	if(arTableSummary.length==0) {
		if((cSubmitTableData==0) && (arPendingDataSubmissions.length>0)) {
			//clear the array if it contains only completed items and debugging is not enabled
			if(!bEnableSubmissionDebugging)	arPendingDataSubmissions.length=0;
			debugDataSubmission();
		};
		setTimeout("dataSubmissionLoop()",5000);
		return; 
	};
	
	/* submit data for any tables with records having a status-0 which indicates 
	data that has been added to the array but has not been submitted.  Do not 
	submit data if there are any records for the table with a status of 1 which 
	indicates data has been submitted but has not been recorded on the server
	This is important because new records must be fully initialized before additional
	data is submitted for the record.  It is also important that data is submitted 
	in the order that it is edited.  Don't allow the possibility of a later edit overwriting
	an earlier one.  This is certainly a situation that needs to be checked for because submitToServer()
	will attempt to submit data again if the request fails.  A situation could arise in which submitToServer()
	fails for a set of data, additional data is submitted and the original submitToServer() request is made
	again because it failed.  In this case, the data would be out of order. */
	var bDataSubmitted=false;
	for(var i=0;i<arTableSummary.length;i++) {
		//check that there is data to submit and that there are no submissions still pending
		if(bEnableSubmissionDebugging) appendToSubmitLog("dataSubmissionLoop: arTableSummary["+i+"] TableID="+arTableSummary[i].TableID+" New:"+arTableSummary[i].Status0+" Submitted:"+arTableSummary[i].Status1);
		if((arTableSummary[i].Status0>0) && (arTableSummary[i].Status1==0)) {
			var sTableID=arTableSummary[i].TableID;
			var arKeyValue=new Array();
			var arFieldID=new Array();
			var arValue=new Array();
			var n=0;
			for(var i=0;i<arPendingDataSubmissions.length;i++) {
				if((arPendingDataSubmissions[i].TableID==sTableID) && (arPendingDataSubmissions[i].Status==0)) {
					arKeyValue[n]=arPendingDataSubmissions[i].KeyValue;
					arFieldID[n]=arPendingDataSubmissions[i].FieldID;
					arValue[n]=arPendingDataSubmissions[i].Value;

					//set the status to 1 to indicate the record has been submitted
					//This means that the data has been handed off to the submitToServer() function, not that
					//it has actually made it to the server yet.  The submitToServer function will call itself again if 
					//the request to the server is not successful.  It is possible that the data gets handed from here
					//and then has to wait to be successfully submitted to the server.  Setting the status to 1 here 
					//causes further calls to submitToServer to be postponed until the data is successfully submitted.
					arPendingDataSubmissions[i].Status=1;
					arPendingDataSubmissions[i].tSubmit=formatDate(new Date(),"HH:mm:ss:SSS");
					n++;
				};
			};

			if(n>0) {
				var table=document.getElementById(sTableID);
				var sHashID=null;
				var sDriverID=null;
				
				//allow for the possibility that the table has been closed
				if(table) {
					var sHashID=table.getAttribute("aspectHashID");
					var sDriverID=table.getAttribute("aspectDriver");

					//call listener function if defined.  
					var s="tableDataSubmitted"+sTableID;
					if(eval('typeof '+s)=="function") {
						//appendToLog("Calling "+s);
						eval(s+"('"+sTableID+"')");
					}
					else {
						//appendToLog("Listener not defined: "+s);
					};

					//call listener functions for each field 
					for (var i=0;i<arFieldID.length;i++) {
						//note: periods in field ID's are removed.  Periods appear in field ID's when a structure is included in another structure.
						var sFieldID=replaceAllSubstrings(arFieldID[i],"\x22","%"+"22");
						sFieldID=replaceAllSubstrings(arFieldID[i],".","");
						//appendToLog("checking for listener: dataSubmittedListener"+sFieldID);
						try {
							if(eval('typeof dataSubmittedListener'+sFieldID)=="function") {
								var sValue=replaceAllSubstrings(arValue[i],"\x22","%"+"22");
								var sValue=replaceAllSubstrings(arValue[i],"\x2C","//co"+"mma//");
								var sEval="dataSubmittedListener"+sFieldID+"(\x22"+sHashID+"\x22,\x22"+sTableID+"\x22,\x22"+sDriverID+"\x22,\x22"+arKeyValue[i]+"\x22,\x22"+sValue+"\x22)";
								//appendToLog("calling listener: dataSubmittedListener"+sFieldID);
								//appendToLog("eval: "+sEval);
								eval(sEval); 
							};
						}
						catch(ex) {
							appendToLog("Error executing listener: "+sEval+" error: "+ex);
						};
					};
					
					//flag  select boxes for update
					var arSelect=document.getElementsByTagName("select");
					for(var i=0;i<arSelect.length;i++) {
						var CollectionSource=arSelect[i].getAttribute("Source");
						if((CollectionSource) && (CollectionSource.equalsIgnoreCase(sHashID))) {
							var CollectionDriverID=arSelect[i].getAttribute("DriverID");
							if((CollectionDriverID) && (CollectionDriverID.equalsIgnoreCase(sDriverID))) {
								arSelect[i].setAttribute("update","true");
							};
						};
					};

				};

				if(bEnableSubmissionDebugging) appendToSubmitLog("dataSubmissionLoop: calling submitToServer");
				submitToServer(sTableID,arKeyValue.toString(),arFieldID.toString(),arValue.toString())
				bDataSubmitted=true;
			};
		};
	};
	
	//if no data was submitted, invoke the function used to get a list of pending submissions from the server
	//and update the status of records in arPendingDataSubmissions.  
	//if((!bDataSubmitted) && (!WaitingForPendingSubmissions)) {
	
	/* This needs to work differently depending on whether the table is remote or not.  If the table is local,
		the data will have been saved immediately and the pending submissions can be requested.  Otherwise, it 
		may take a few seconds for the data to be received by the server. 
		
		If the table is local, this still has no useful effect because the values in arTableSummary will not have
		been updated and the count of new and submitted fields will not reflect that data was submitted above.
		Therefore, a call will not be made since arTableSummary[i].Status1 will still be 0 unless there are previously
		submitted records
	*/
	if(!WaitingForPendingSubmissions) {
		var arHashID=new Array();
		var arTableID=new Array();
		var arDriverID=new Array();
		var arDriverParams=new Array();
		n=0;
		for(var i=0;i<arTableSummary.length;i++) {
			if(arTableSummary[i].Status1>0) {
				var sTableID=arTableSummary[i].TableID;
				var table=document.getElementById(sTableID);
				
				//allow for the possibility that the view has been closed and the table no longer exists.
				if(table) {
//appendToLog("dataSubmissionLoop getAttribute5")
					arHashID[n]=table.getAttribute("aspectHashID");
					arTableID[n]=sTableID;
//appendToLog("dataSubmissionLoop getAttribute6")
					arDriverID[n]=table.getAttribute("aspectDriver");
				
					//Note: This needs to use the original driver params, so TCache can locate the object
					//it is not necessary to pass external params
					//var sParams=getTableDriverParams(sTableID);
//appendToLog("dataSubmissionLoop getAttribute7")
					var sParams=document.getElementById(sTableID).getAttribute("aspectParamsActive");
					if(!sParams) sParams=getTableDriverParams(sTableID); //for compatibility before aspectParamsActive is posted
					arDriverParams[n]=sParams;
					n++;
				};
			};
		};

		if(n>0) {
			var sHashID="";
			var sTableID="";
			var sDriverID="";
			var sDriverParams="";
			for(var i=0;i<n;i++) {
				if(i>0) {
					sHashID+="^";
					sTableID+="^";
					sDriverID+="^";
					sDriverParams+="^";
				};
				sHashID+=arHashID[i];
				sTableID+=arTableID[i];
				sDriverID+=arDriverID[i];
				//sDriverParams+=arDriverParams[i];
				sDriverParams+=replaceAllSubstrings(arDriverParams[i],"^","#"+"23");
			};
			
			var sServer=getServer();
			var sUrl=getServer()+"/?Network=GreenLight&ID=getPendingDataSubmissions";
			sUrl +="&SourceHashID="+sHashID+"&DriverID="+sDriverID+"&TableID="+sTableID+"&DriverParams="+sDriverParams;
			sUrl +="&multiple=true";
			sFunc="updatePendingSubmissions(s)";
			asynchInclude(null,sUrl,sFunc,sFunc);
		};
	};
	
	//update the debugging table
	debugDataSubmission();
	
	//call this function again
	setTimeout("dataSubmissionLoop()",3000);
	return;
};

/******************************************************************************
Returns an array of objects containind summary data about each table in the 
array.  Records are not included if they have a status of 2 (complete).

Fields are:
	Status0 - Number of records with a status of 0 (new submissions)
	Status1 - Number of records with a status of 1 (data has been submitted)
******************************************************************************/
function getPendingSubmissionSummary() {
	//appendToSubmitLog("getPendingSubmissionSummary arPendingDataSubmissions.length="+arPendingDataSubmissions.length);


	//get an array of table ID's in the array
	var arTableID=new Array();
	var arSummary=new Array();
	for(var i=0;i<arPendingDataSubmissions.length;i++) {
		//ignore records that have already been recorded (status=2)
		//appendToSubmitLog("getPendingSubmissionSummary: arPendingDataSubmissions[i].Status="+arPendingDataSubmissions[i].Status);
		if(arPendingDataSubmissions[i].Status<2) {
			//get index of table ID in array.  Add the table if necessary
			var sTableID=arPendingDataSubmissions[i].TableID;
			var n=arTableID.indexOf(sTableID);
			if(n<0) {
				n=arTableID.length;
				arTableID[n]=sTableID;
				var oSummary={TableID:sTableID,Status0:0,Status1:0};
				arSummary[n]=oSummary;
			};
			
			switch(arPendingDataSubmissions[i].Status) {
				case 0: arSummary[n].Status0++; break;
				case 1: arSummary[n].Status1++; break;
			};
		};
	};
	
	return(arSummary);
};

/******************************************************************************
Returns a count of records with a status of 0 or 1 for the given table ID and 
KeyValue.  AKeyValue and AFieldID are optional.  For example, this function may 
be called with 
	countPendingSubmissions(TableID)
	countPendingSubmissions(TableID,KeyValue)
	countPendingSubmissions(TableID,KeyValue,FieldID)
******************************************************************************/
function countPendingSubmissions(ATableID,AKeyValue,AFieldID) {
	var c=0;
	for(var i=0;i<arPendingDataSubmissions.length;i++) {
		if(arPendingDataSubmissions[i].Status<2) {
			if((!ATableID) || (arPendingDataSubmissions[i].TableID==ATableID)) {
				if((!AKeyValue) || (arPendingDataSubmissions[i].KeyValue==AKeyValue)) {
					if((!AFieldID) || (arPendingDataSubmissions[i].FieldID==AFieldID)) {
						c++;
					};
				};
			};
		};
	};
	return(c); 
};

/******************************************************************************
Submits data to a server.  Multiple fields and values may be submitted by
separating them with commas.  Any commas contained in the data should be replaced
with "comma" surrounded by "//" before calling this function.

Note: This could be modified to send data directly via a notification.  The
return value could then be used to update the table row.  Right now, data is
added to the cache using TWriteBuffer and a response is not available.  Another
notification is sent when pending data is written to get all values in the record
to update the table row.
******************************************************************************/
function submitToServer(ATableID,AKeyValue,AFieldID,AValue) {
	if(bEnableSubmissionDebugging) appendToSubmitLog("submitToServer: TableID="+ATableID+" KeyValue="+AKeyValue+" FieldID="+AFieldID+" Value="+AValue);
	//appendToLog("submitToServer: TableID="+ATableID+" KeyValue="+AKeyValue+" FieldID="+AFieldID+" Value="+AValue);

	var sServer=getServer();

	/*****************************************************************
	var table=document.getElementById(ATableID);
	var sHashID=table.getAttribute("aspectHashID");
	var sDriverID=table.getAttribute("aspectDriver");
	var sKeyExpression=table.getAttribute("aspectKeyExpression");
	var arFieldID=getSubStringArray(table.getAttribute("aspectAllFieldID"),",",true);
	var arFieldType=getSubStringArray(table.getAttribute("aspectAllFieldType"),",",true);

	//These need to use the driver params in place when the table was created
	//var sParams=getTableDriverParams(ATableID);
	var sParams=document.getElementById(ATableID).getAttribute("aspectParamsActive");
	if(!sParams) sParams=getTableDriverParams(ATableID); //for compatibility before posting aspectParamsActive
	*****************************************************************/
	
	//get the table metadata
	var n=-1;
	for(var i=0;i<arTableMetadata.length;i++) {
		if(arTableMetadata[i].TableID.equalsIgnoreCase(ATableID)) n=i;
	};
	
	if(n>=0) {
		var sHashID=arTableMetadata[n].HashID;
		var sDriverID=arTableMetadata[n].DriverID;
		var sKeyExpression=arTableMetadata[n].KeyExpression;
		var arFieldID=getSubStringArray(arTableMetadata[n].AllFieldID,",",true); 
		var arFieldType=getSubStringArray(arTableMetadata[n].AllFieldType,",",true); 
		var sParams=arTableMetadata[n].DriverParams;
	}
	else {
		console.log("Could not find table metadata for table: "+ATableID);
		showDialog("msg=Error: Unable to save changes.  Please reload the page.<br><br>&fnOk=close");
	};
	
	//make a comma-delimited array of field types for fields being submitted.  
	var arSubmitFieldID=getSubStringArray(AFieldID,",");
	var sFieldIndex="";
	for (var i=0;i<arSubmitFieldID.length;i++) {
		var n=getFieldIndex(arSubmitFieldID[i],arFieldID);
		if(sFieldIndex.length>0) sFieldIndex +=",";
		sFieldIndex +=arFieldType[n];
	};

	var sUrl=getServer()+"/?Network=GreenLight&ID=putDriverData";
	sUrl +="&SourceHashID="+sHashID+"&TableID="+ATableID+"&DriverID="+sDriverID+"&KeyExpression="+sKeyExpression;
	sUrl +="&DriverParams="+sParams+"&KeyValue="+AKeyValue+"&FieldID="+AFieldID;
	sUrl +="&FieldType="+sFieldIndex;
	
	var s=replaceAllSubstrings(AValue,"&","//am"+"p//");
	s=replaceAllSubstrings(s,"\r\n","//cr"+"lf//");
	s=replaceAllSubstrings(s,"\r","//cr"+"lf//");
	s=replaceAllSubstrings(s,"\n","//cr"+"lf//");
	s=replaceAllSubstrings(s,"\t","//ta"+"b//");
	s=replaceAllSubstrings(s,"\x22","//qu"+"ote//");
	s=replaceAllSubstrings(s,"%"+"22","//qu"+"ote//");
	s=replaceAllSubstrings(s,"#","//po"+"und//");
	s=replaceAllSubstrings(s,"\x25","//pc"+"nt//");
	
	//don't replace commas here because it interferes with field delimiters.  For example, when adding a new record,
	//a set of empty values will be converted from a sequence of commas to a sequence of comma tokens
	//s=replaceAllSubstrings(s,"\x2C","//co"+"mma//");
	
	sUrl +="&Value="+s; 
	appendToSubmitLog("submitToServer url="+sUrl,false,true);

	//set the error function so if the call fails it will be tried again
	var sFuncOk="submitToServerOk(\x22"+ATableID+"\x22,\x22"+AKeyValue+"\x22,\x22"+AFieldID+"\x22,\x22"+s+"\x22,s)";
	var sFuncErr="submitToServer(\x22"+ATableID+"\x22,\x22"+AKeyValue+"\x22,\x22"+AFieldID+"\x22,\x22"+s+"\x22)";
	asynchInclude(null,sUrl,sFuncOk,sFuncErr);

	//update the hidden value(s) in the table row.  This is necessary so a dialog is initialized properly if it is opened
	//after values have been edited.  Check to make sure the table exists first.
	if(document.getElementById(ATableID)) {
		setFieldValueInRow(ATableID,AKeyValue,AFieldID,AValue);
	};
};

function old_submitToServer(ATableID,AKeyValue,AFieldID,AValue) {
	if(bEnableSubmissionDebugging) appendToSubmitLog("submitToServer: TableID="+ATableID+" KeyValue="+AKeyValue+" FieldID="+AFieldID+" Value="+AValue);
	//appendToLog("submitToServer: TableID="+ATableID+" KeyValue="+AKeyValue+" FieldID="+AFieldID+" Value="+AValue);

	var table=document.getElementById(ATableID);
	var sServer=getServer();
	var sHashID=table.getAttribute("aspectHashID");
	var sDriverID=table.getAttribute("aspectDriver");
	var sKeyExpression=table.getAttribute("aspectKeyExpression");
	var arFieldID=getSubStringArray(table.getAttribute("aspectAllFieldID"),",",true);
	var arFieldType=getSubStringArray(table.getAttribute("aspectAllFieldType"),",",true);

	//These need to use the driver params in place when the table was created
	//var sParams=getTableDriverParams(ATableID);
	var sParams=document.getElementById(ATableID).getAttribute("aspectParamsActive");
	if(!sParams) sParams=getTableDriverParams(ATableID); //for compatibility before posting aspectParamsActive

	//make a comma-delimited array of field types for fields being submitted.  
	var arSubmitFieldID=getSubStringArray(AFieldID,",");
	var sFieldIndex="";
	for (var i=0;i<arSubmitFieldID.length;i++) {
		var n=getFieldIndex(arSubmitFieldID[i],arFieldID);
		if(sFieldIndex.length>0) sFieldIndex +=",";
		sFieldIndex +=arFieldType[n];
	};

	var sUrl=getServer()+"/?Network=GreenLight&ID=putDriverData";
	sUrl +="&SourceHashID="+sHashID+"&TableID="+ATableID+"&DriverID="+sDriverID+"&KeyExpression="+sKeyExpression;
	sUrl +="&DriverParams="+sParams+"&KeyValue="+AKeyValue+"&FieldID="+AFieldID;
	sUrl +="&FieldType="+sFieldIndex;
	
	var s=replaceAllSubstrings(AValue,"&","//am"+"p//");
	s=replaceAllSubstrings(s,"\r\n","//cr"+"lf//");
	s=replaceAllSubstrings(s,"\r","//cr"+"lf//");
	s=replaceAllSubstrings(s,"\n","//cr"+"lf//");
	s=replaceAllSubstrings(s,"\t","//ta"+"b//");
	s=replaceAllSubstrings(s,"\x22","//qu"+"ote//");
	s=replaceAllSubstrings(s,"%"+"22","//qu"+"ote//");
	s=replaceAllSubstrings(s,"#","//po"+"und//");
	
	//don't replace commas here because it interferes with field delimiters.  For example, when adding a new record,
	//a set of empty values will be converted from a sequence of commas to a sequence of comma tokens
	//s=replaceAllSubstrings(s,"\x2C","//co"+"mma//");
	
	sUrl +="&Value="+s; 
	appendToSubmitLog("submitToServer url="+sUrl,false,true);

	//set the error function so if the call fails it will be tried again
	var sFuncOk="submitToServerOk(\x22"+ATableID+"\x22,\x22"+AKeyValue+"\x22,\x22"+AFieldID+"\x22,\x22"+s+"\x22,s)";
	var sFuncErr="submitToServer(\x22"+ATableID+"\x22,\x22"+AKeyValue+"\x22,\x22"+AFieldID+"\x22,\x22"+s+"\x22)";
	asynchInclude(null,sUrl,sFuncOk,sFuncErr);

	//update the hidden value(s) in the table row.  This is necessary so a dialog is initialized properly if it is opened
	//after values have been edited
	setFieldValueInRow(ATableID,AKeyValue,AFieldID,AValue);
};

function submitToServerOk(ATableID,AKeyValue,AFieldID,AValue,s) {
	var s=","+AFieldID+",";
	var sDebug="";
	for(var i=0;(i<arPendingDataSubmissions.length);i++) {
		if(arPendingDataSubmissions[i].TableID==ATableID) {
			if(AFieldID.indexOf(arPendingDataSubmissions[i].FieldID)>=0) {
				if(arPendingDataSubmissions[i].Status==1) {
					arPendingDataSubmissions[i].tConfirmed=true;
					if(sDebug.length>0) sDebug+=",";
					sDebug+=arPendingDataSubmissions[i].FieldID;
					//appendToSubmitLog("submitToServerok confirm submission of "+arPendingDataSubmissions[i].FieldID+" in table "+arPendingDataSubmissions[i].TableID);
				};
			};
		};
	};

	if(sDebug.length>0) {
		appendToSubmitLog("submitToServerok confirmed submission of "+sDebug+" in table "+ATableID);
	};
};

/******************************************************************************
Updates attributes of cells that have been recorded by the server.  result is a pipe-delimited array
in the form:

HashID^TableID^DriverID^KeyValue^FieldID | 
HashID^TableID^DriverID^KeyValue^FieldID | 
...

The array includes any data submissions that have not yet been recorded.  Any submissions in 
arPendingDataSubmissions with a status of 1 that do not appear in the result have been saved 
by the server and are flagged as complete in the arPendingDataSubmissions array. (see next paragraph)

0300902017 - Modified this by adding a tConfirmed value to the arPendingDataSubmissions array.
A problem can occur if data is submitted and the status is set to 1 and then pending submissions are 
read before the data has been added to TCacheWriteBuffer.  If would appear as if data has been submitted
and there are no pending submissions.  Now, the tConfirmed value is set to false initially and is set to 
true by submitToServerOk.

If the call to getPendingSubmissions fails, the result will be null or an empty string and 
no action is taken and the status of records in arPendingDataSubmissions is unchanged.

The job of this function is to:
	1.	Update the status of records in arPendingDataSubmissions from 1 to 2 to indicate that data
		has been saved on the server.
		
	2.	Update the pending submission style for fields in dialogs.  These need to be enabled or disabled
		depending on the key value that is active in the dialog.  For example, the dialog may be opened
		for another record while data is still pending for a previous record.  The cells in the second
		dialog should not be highlighted
	3.	Turn off the pending submission style for cells in a table
	
	4.	Refresh records in a table when there are no remaining pending submissions.  This should probably 
		also require that there not be any new submissions waiting to be made for the record.
	5.	Remove rows from the table that have been deleted
	6.	Clear the status message indicating that records are being deleted
	7.	Call the tableDataSubmissionCompleteTABLEID function if defined
	8.	Refresh the table if RefreshOnDataSubmit is true.  This is done to update subtotals
******************************************************************************/
function updatePendingSubmissions(result) {
	WaitingForPendingSubmissions=false;
	
	if(bEnableSubmissionDebugging) appendToSubmitLog("updatePendingSubmissions: Pending submissions:"+result);
	
	if((!result) || (result.trim().length==0) || (result.equalsIgnoreCase("error"))) {
		appendToSubmitLog("Error: updatePendingSubmissions: result:"+result);
		return; 
	};
	
	/*	get an array of information about each table in the array including the number
		records with a status of 0 (new) and 1 (submitted).  Each element of the array
		includes the fields: TableID, Status0, Status1.  Status0 and Status1 indicate
		how many records there are with each status	*/
	var arTableSummary=getPendingSubmissionSummary();

	for(var i=0;i<arTableSummary.length;i++) {
		//only include tables for which data has been submitted 
		//appendToSubmitLog("updatePendingSubmissions arTableSummary["+i+"].Status1="+arTableSummary[i].Status1);
		if(arTableSummary[i].Status1>0) {
			var sTableID=arTableSummary[i].TableID;
			var table=document.getElementById(sTableID);
			
			//allow for the possibility that the view has been closed and the table no longer exists
			if(table) {
				var sHashID=table.getAttribute("aspectHashID");
				var sDriverID=table.getAttribute("aspectDriver");
				var sDialogID=table.getAttribute("EditDialogID");
				var eDialog=document.getElementById(sDialogID);
				var sDialogKeyValue=(eDialog) ? eDialog.getAttribute("KeyValue") : "";
				var bCanSelect=(table.getAttribute("aspectCanSelect").equalsIgnoreCase("true"));
				var cSelectIndex=(bCanSelect) ? getTableRecordSelectIndex(sTableID) : -1;
				var sFields=table.getAttribute("aspectFields");
				var arFields=getSubStringArray(sFields,",",true);
				var sAllFields=table.getAttribute("aspectallfieldid");
				var arAllFields=getSubStringArray(sAllFields,",",true);
				
				//get an array of key values for the table.  
				var arKeyValue=new Array();
				for(var j=0;j<arPendingDataSubmissions.length;j++) {
					if((arPendingDataSubmissions[j].TableID==sTableID) && (arPendingDataSubmissions[j].Status==1)) {
						if(arKeyValue.indexOf(arPendingDataSubmissions[j].KeyValue)<0) {
							arKeyValue[arKeyValue.length]=arPendingDataSubmissions[j].KeyValue;
						};
					};
				};
				//appendToSubmitLog("updatePendingSubmissions arKeyValue="+arKeyValue.toString());
				
				var arRecordsToRefresh=new Array();
				var arPendingFieldID=new Array();
				var arCompleteFieldID=new Array();

				//process all records in arPendingDataSubmissions by KeyValue for the current table
				for(var j=0;j<arKeyValue.length;j++) {
					//appendToSubmitLog("updatePendingSubmissions processing KeyValue="+arKeyValue[j]);
					//These arrays are used to accumulate the field ID's that are still pending and those
					//that are complete for the given table and key value.  The length is set to 0 to 
					//avoid creating a new array each time.  This might help with memory.
					arPendingFieldID.length=0;
					arCompleteFieldID.length=0;
					var bIsDelete=false;
					for(var k=0;k<arPendingDataSubmissions.length;k++) {
						//appendToSubmitLog("updatePendingSubmissions: arPendingDataSubmissions["+k+"] TableID="+arPendingDataSubmissions[k].TableID+" KeyValue="+arPendingDataSubmissions[k].KeyValue+" Status="+arPendingDataSubmissions[k].Status);
						if((arPendingDataSubmissions[k].TableID==sTableID) && (arPendingDataSubmissions[k].KeyValue==arKeyValue[j])) {
							if(arPendingDataSubmissions[k].Status==1) {
								//at this point, the record belongs to the current table and keyvalue and has a status of 1
								//See if the field is still pending and update the arrays and status accordingly
								var s=sHashID+"^"+sTableID+"^"+sDriverID+"^"+arKeyValue[j]+"^"+arPendingDataSubmissions[k].FieldID;
								var bIsPending=(result.toUpperCase().indexOf(s.toUpperCase())>=0) || (arPendingDataSubmissions[k].tConfirmed==false);
								//appendToSubmitLog("updatePendingSubmissions: FieldID:"+arPendingDataSubmissions[k].FieldID+" Pending:"+bIsPending);
//console.log("updatePendingSubmissions: "+arKeyValue[j]+" FieldID:"+arPendingDataSubmissions[k].FieldID+" Pending:"+bIsPending+" tConfirmed="+arPendingDataSubmissions[k].tConfirmed);
								if(bIsPending) {
									arPendingFieldID[arPendingFieldID.length]=arPendingDataSubmissions[k].FieldID;
								}
								else {
									arCompleteFieldID[arCompleteFieldID.length]=arPendingDataSubmissions[k].FieldID;
									arPendingDataSubmissions[k].Status=2;
									arPendingDataSubmissions[k].tComplete=formatDate(new Date(),"HH:mm:ss:SSS");
									if(arPendingDataSubmissions[k].IsDeletedRecord) bIsDelete=true;
								};
							};
						};
					};
					
					//add record to array of records to be refreshed if there are fields with a status of complete and 
					//no fields waiting to be recorded
					if(arPendingFieldID.length==0) {
						//don't update table records that are being deleted
						if(!bIsDelete) {
							arRecordsToRefresh[arRecordsToRefresh.length]=arKeyValue[j];
//console.log("adding record "+arKeyValue[j]+" to be updated");
						};
					};
					
					//update pending submission styles in dialog
					if(arKeyValue[j]==sDialogKeyValue) {
						updatePendingSubmissionStylesForDialog(eDialog,arAllFields,arPendingFieldID);
					};
					
					//update pending submission styles in table row.  Or, if the row is being deleted, remove it if there
					//are no remaining submissions
					var eTableRow=getTableRow(table,arKeyValue[j]);
					if(eTableRow) {
						var attr=(cSelectIndex>=0) ? eTableRow.cells[cSelectIndex].getAttribute("AspectSubmissionPending") : "";
						if((attr) && (attr.equalsIgnoreCase("newdelete"))) {
							if(arPendingFieldID.length==0) {
								eTableRow.parentNode.removeChild(eTableRow);
							};
						}
						else {
							updatePendingSubmissionStylesForTableRow(sTableID,eTableRow,arFields,arPendingFieldID);
						};
					};
				};

				//clear pending submission styles in dialog if the dialog was not updated by a call when the keyvalues 
				//were processed
				if(sDialogKeyValue.length>0) {
					if(arKeyValue.indexOf(sDialogKeyValue)<0) {
						updatePendingSubmissionStylesForDialog(eDialog,arAllFields,null);
					};
				};
				
				//refresh table if RefreshOnDataSubmit is true and there are no remaining pending submissions
				//Otherwise, refresh individual records
				var sRefreshOnDataSubmit=table.getAttribute("RefreshOnDataSubmit");
				if((sRefreshOnDataSubmit) && (sRefreshOnDataSubmit.equalsIgnoreCase("true"))) {
					if(countPendingSubmissions(sTableID)==0) {
						if(bEnableSubmissionDebugging) appendToSubmitLog("updatePendingSubmissions: calling refreshTableOnInterval");
						refreshTableOnInterval(sTableID);
					}
					else {
						if(bEnableSubmissionDebugging) appendToSubmitLog("updatePendingSubmissions: skipping call to refreshTableOnInterval because there are outstanding submissions");
					};
				}
				else {
					//refresh any records for which data has been submitted
					if((bEnableSubmissionDebugging) && (arRecordsToRefresh.length>0)) {
						appendToSubmitLog("updatePendingSubmissions: refreshing "+arRecordsToRefresh.length+" records");
					};
					for(var j=0;j<arRecordsToRefresh.length;j++) {
						var cPendingSubmissions=countPendingSubmissions(sTableID,arRecordsToRefresh[j]);
						if(cPendingSubmissions==0) {
							if(bEnableSubmissionDebugging) appendToSubmitLog("updatePendingSubmissions: calling updateTableRecord");
//console.log("updatePendingSubmissions calling updateTableRecord for : "+arRecordsToRefresh[j]);
							updateTableRecord(sTableID,arRecordsToRefresh[j]);
						}
						else {
//console.log("updatePendingSubmissions cPendingSubmissions="+cPendingSubmissions);
							if(bEnableSubmissionDebugging) appendToSubmitLog("updatePendingSubmissions: skipping updateTableRecord for key="+arRecordsToRefresh[j]+" because there are outstanding submissions");
						};
					};
				};

				//call listener function if defined.  
				var s="tableDataSubmissionComplete"+sTableID;
				if(eval('typeof '+s)=="function") {
					if(bEnableSubmissionDebugging) appendToSubmitLog("updatePendingSubmissions calling "+s+"('"+sTableID+"')");
					eval(s+"('"+sTableID+"')");
				};
			};
		};
	};
	
	//update select boxes
	//11-27-2017 Modified this to only update select boxes when there are no remaining submissions.  This cuts down on the 
	//number of calls.  It was creating too many notifications when logged in through the server
	if(countPendingSubmissions()==0) {
		//11-27-2017: do not update options unless working from the local server.  Otherwise, too many 
		//notifications will be generated when logged into a computer through the server.  A separate notification 
		//is generated for each select box and there can be many, as when editing a recipe.  This needs to be 
		//handled more efficiently.
		if(getServer().indexOf("127.0.0.1")>=0) {
			updateSelectBoxes();
		};
	};

	//update the debugging table
	debugDataSubmission();
};

/******************************************************************************
Updates the pending submission styles for fields in a dialog
******************************************************************************/
function updatePendingSubmissionStylesForDialog(eDialog,arAllFields,arPendingFieldID) {
//appendToLog("updatePendingSubmissionStylesForDialog Dialog ID="+eDialog.id+" arAllFields="+arAllFields.toString()+" arPendingFieldID="+arPendingFieldID.toString());
	var arNodes=new Array();
	getAllInputNodes(eDialog,arNodes);

	for (var i=0;i<arNodes.length;i++) {
		var sName=arNodes[i].getAttribute("name");

		//if it's an input for a datalist, get the name from the hidden element used to submit data
		if(arNodes[i].getAttribute("List")) {
			var sDataListID=arNodes[i].getAttribute("List");
			//confirm that it's a datalist input by checking the ID.  It should be the ID of 
			//the datalist plus _input
			if(arNodes[i].id.equalsIgnoreCase(sDataListID+"_input")) {
				//get the name from the input used to submit the data
				var eSubmit=document.getElementById(sDataListID+"_input_submit");
				if(eSubmit) sName=eSubmit.getAttribute("name");
			};
		};

		if(sName) {
			var sFieldID=sName.toUpperCase();
			
			//only update fields that belong to the table.  This is necessary when two tables share a single dialog
			//as in the registration page.  If all fields were updated, one table would turn off fields because they
			//didn't appear to be pending and the other table would turn them back on because they are pending and
			//it would blink like a christmas tree
			if(arAllFields.indexOf(sFieldID)>=0)
			{
				var eParent=arNodes[i].parentNode;
				if((eParent.nodeName.equalsIgnoreCase("td")) || (eParent.nodeName.equalsIgnoreCase("span")))
				{
					var bIsPending=(arPendingFieldID) ? (arPendingFieldID.indexOf(sFieldID)>=0) : false;
					if(bIsPending==true) {
						setPendingSubmissionStyle(arNodes[i],false,true);
						eParent.setAttribute("AspectSubmissionPending","pending");
					}
					else {
						setPendingSubmissionStyle(arNodes[i],false,false);
						eParent.setAttribute("AspectSubmissionPending","false");
					};
				};
			};
		};
	};
};

/******************************************************************************
Updates the pending submission styles for cells in a table row.  Removes row from
table if record has been deleted
******************************************************************************/
function updatePendingSubmissionStylesForTableRow(ATableID,eTableRow,arFields,arPendingFieldID) {
	for(var cell=0;cell<eTableRow.cells.length;cell++) {
		var attr=eTableRow.cells[cell].getAttribute("AspectSubmissionPending");
		if((attr) && (attr.length>0))
		{
			if(attr.equalsIgnoreCase("new")) {
				var sKeyValue=eTableRow.getAttribute("KeyValue").toUpperCase();
				var sCellIndex=eTableRow.cells[cell].getAttribute("CellIndex");
				if(sCellIndex) {
					var iCellIndex=parseInt(sCellIndex);
					var sFieldID=arFields[iCellIndex].toUpperCase();
					
					if(countPendingSubmissions(ATableID,sKeyValue,sFieldID)==0) {
						var bIsPending=(arPendingFieldID) ? (arPendingFieldID.indexOf(sFieldID)>=0) : false;

						if(!bIsPending) {
							setPendingSubmissionStyle(eTableRow.cells[cell].childNodes[0],true,false);
							eTableRow.cells[cell].style.backgroundColor="white";
							eTableRow.cells[cell].setAttribute("AspectSubmissionPending","false");
						};
					};
				};  
			};
		}
	};
};

/********************************************************************
Updates a record in a table by making a request to the server for new values.  The
function is called again with sValues defined when a response is received.
KeyValue is a comma-delimited list of key values for which records will be updated
CallbackFunc can be used to specify a function to be called when the update is complete.
********************************************************************/
function updateTableRecord(ATableID,KeyValue,CallbackFunc,sValues,n) { 
	appendToSubmitLog("updateTableRecord: TableID:"+ATableID+" KeyValue:"+KeyValue+" sValues:"+sValues+" n:"+n);
	var table=document.getElementById(ATableID);
	if(!table) return; //can happen if a page is refreshed immediately after a request has been made for record values
	var sKeyDescription=table.getAttribute("aspectkeydescription");

	//Got values.  Update the record.
	if(sValues)
	{
//console.log("updateTableRecord got values: "+sValues);
		//abort if there are pending submissions for the record
		if(countPendingSubmissions(ATableID,KeyValue)>0) {
			appendToSubmitLog("updateTableRecord aborted because there are pending submissions for keyvalue="+KeyValue);
//console.log("updateTableRecord aborted because there are pending submissions for keyvalue="+KeyValue);
			return;
		};
		
		var arRecord=getSubStringArray(sValues,"\n",true);
//appendToSubmitLog("updateTableRecord got values for "+arRecord.length+" records");
//appendToSubmitLog("Values="+sValues);

		//get the select box containing key descriptions in the edit dialog
		var eSelect=null;
		var sDialogID=table.getAttribute("aspecteditdialogid");
		if(sDialogID) {
			var eDialog=document.getElementById(sDialogID);
			if(eDialog) eSelect=getTableDialogHeaderSelectKeyControl(eDialog);
		};

		for(var i=0;i<arRecord.length;i++) {
			var a=getSubStringArray(arRecord[i],"|",true);
			if(a) {
				var sKeyValue=a[0];
				var sAllValues=a[1];
				var sKeyDescription=a[2];
				//appendToLog("updateTableRecord updating values for Key="+sKeyValue);
				
				///NOTE: 03-17-2013 Html values are now included as a 4th element in the value returned by a call to getRecordValues()
				//There was a conflict between the data recorded in the aspectallvalues attribute and the values needed to update a 
				//row in the table after data had been edited.  Table cells initially contain html values (using getFieldForHtml.  When
				//a record is edited and new values are gotten from the server, data from getField() needs to be recorded in the aspectallvalues
				//attribute so dialogs can be initialized properly after data is edited.  But data from getFieldForHtml also needs to be
				//included so table cells can be displayed properly since they may use html to format the field.
				//The solution is to return values from both getField() and getFieldForHtml().  Data returned by getFieldForHtml is recorded
				//in a new attribute named aspecthtmlvalues.  This attribute is used to update cells in tables.  It is not available until
				//a record has been edited.
				var sHtmlValues="";

				//restore any pipes contained in the values.  Pipes are tokenized by TAspectDriver.getRecordValues because
				//that function returns a string delimited by pipes
				sAllValues=replaceAllSubstrings(sAllValues,"%%pi"+"pe%%","|");
				sAllValues=replaceAllSubstrings(sAllValues,"%%line"+"feed%%","\n");

				if(a.length>3) {
					sHtmlValues=a[3];
					sHtmlValues=replaceAllSubstrings(sHtmlValues,"%%pi"+"pe%%","|");
					sHtmlValues=replaceAllSubstrings(sHtmlValues,"%%line"+"feed%%","\n");
				};

				//locate row containing keyvalue
				var row=getTableRowContainingKey(table,sKeyValue);
				
				//set attributes used for inspect menu
				if(a.length>4) {
					//locate the td containing the inspect menu icon
					if(table.rows[row]) {
						for(var cell=0;cell<table.rows[row].cells.length;cell++) {
							var s=table.rows[row].cells[cell].getAttribute("name");
							if((s) && (s.equalsIgnoreCase("inspectrecord"))) 
							{
								//attributes are in element 4 in the form name=value^name=value^name=value
								arInspectAttributes=getSubStringArray(a[4],"^",false);
								for(var j=0;j<arInspectAttributes.length;j++) {
									var s=replaceAllSubstrings(replaceAllSubstrings(arInspectAttributes[j],"%%pi"+"pe%%","|"),"%%line"+"feed%%","\n");
									var n=s.indexOf("=");
									if(n>0) {
										var sName=s.substring(0,n);
										var sValue=s.substring(n+1);
										table.rows[row].cells[cell].setAttribute(sName,sValue);
									};
								};
								break;
							};
						};
					};
				};
				
				if(row>=0)
				{
					//update the attribute containing all values
					setAttr(table.rows[row],"aspectAllValues",sAllValues);
					//appendToLog("updateTableRecord setting Key="+sKeyValue+" AllValues="+sAllValues);
					
					//update the attribute containing html values
					if(sHtmlValues.length>0) table.rows[row].setAttribute("aspecthtmlvalues",sHtmlValues);
					
					//update the cells in the table row
					updateCellsInRecord(table,sKeyValue);

					//update values in the dialog if the dialog is visible and the record is currently selected
					var sDialogID=table.getAttribute("EditDialogID");
					var eDialog=document.getElementById(sDialogID);
					if(eDialog) {
						var sDialogKeyValue=eDialog.getAttribute("keyvalue");
						if((sDialogKeyValue) && (sDialogKeyValue==sKeyValue)) {
							var arFieldID=getSubStringArray(table.getAttribute("aspectAllFieldID"),",",true);
							var arValues=getSubStringArray(getAttr(table.rows[row],"aspectAllValues"),",",true);
							for(var i=0;i<arValues.length;i++) arValues[i]=tokenizeTableValue(arValues[i],false);
							setDialogValues(ATableID,eDialog,arFieldID,arValues,true,true);
						};
					};
				}
				else {
					appendToSubmitLog("updateTableRecord: Could not find row for key value "+sKeyValue);
				};
				
				//update the key description in the dialog header's drop-down list
				var bDialogHeader=table.getAttribute("aspectdialogheader");
				if((bDialogHeader) && (bDialogHeader.equalsIgnoreCase("true")) && (eSelect)) {
					if(sKeyDescription.length>0)
					{
						var bFound=false;
						for (var j=0;(bFound==false) && (j<eSelect.options.length);j++) {
							if(eSelect.options[j].value.equalsIgnoreCase(sKeyValue)) {
								eSelect.options[j].text=sKeyDescription;
								bFound=true;
							};
						};
						
						//add the description if the key value was not found in the list
						if(bFound==false) {
							var n=0;
							while((n<eSelect.options.length) && (eSelect.options[n].text.toUpperCase()<sKeyDescription.toUpperCase())) n++;
							
							var eNewOption=document.createElement('option');
							eNewOption.text=sKeyDescription;
							eNewOption.value=sKeyValue;
							if(n==eSelect.length) {
								eSelect.options[eSelect.options.length]=eNewOption;
							}
							else {
								try {
									eSelect.add(eNewOption,eSelect.options[n]); // standards compliant; doesn't work in IE
									eSelect.selectedIndex=n;
								}
								catch(ex) {
									eSelect.selectedIndex=n;
									eSelect.add(eNewOption,eSelect.selectedIndex); // IE only
								}					
							};
						};
					};
				};
			}
			else {
				appendToSubmitLog("updateTableRecord: Error: Could not get values for keyvalue="+KeyValue+" in table:"+ATableID,false,true);
			};
		};

		//appendToLog("CallbackFunc="+CallbackFunc);
		if(CallbackFunc.length>0) eval(CallbackFunc);

		return;
	};

	var Attempts=1;
	if(n) {
		Attempts=n+1;
		if(Attempts>9) {
			appendToSubmitLog("updateTableRecord: Error: Aborting updateTableRecord because error getting values Attempts="+n,false,true);
			return;
		}

		appendToSubmitLog("updateTableRecord: Error: updateTableRecord got no values.  Attempts="+Attempts);
	};
	
	appendToSubmitLog("updateTableRecord: updateTableRecord requesting values for Key="+KeyValue+" Attempt="+Attempts);

	//get values
	var sHashID=table.getAttribute("aspecthashid");
	var sDriverID=table.getAttribute("aspectdriver");
	var sInspectMenu=table.getAttribute("aspectInspectMenu");

	//These need to use the driver params in place when the table was created
	//var sDriverParams=getTableDriverParams(ATableID);
	var sDriverParams=table.getAttribute("aspectParamsActive");
	if(!sDriverParams) sDriverParams=getTableDriverParams(ATableID); //for compatibility before posting aspectParamsActive

	var sEmbedValues=table.getAttribute("aspectembedvalues");

	//make a request for values
	var sUrl=getServer()+"/?Network=greenlight&ID=getWidget";
	sUrl +="&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&Widget=Notification Queries";
	sUrl +="&query=getRecordValues";
	sUrl +="&source="+sHashID;
	sUrl +="&Driver_ID="+sDriverID;
	sUrl +="&Driver_Params="+sDriverParams;
	sUrl +="&EmbedValues="+sEmbedValues;
	sUrl +="&KeyValues="+KeyValue;
	sUrl +="&KeyDescription="+sKeyDescription;
	if(sInspectMenu!=null) sUrl +="&InspectMenu="+sInspectMenu;

	var sCallbackFunc=(CallbackFunc) ? CallbackFunc : "";
	var sFunc="updateTableRecord(\x22"+ATableID+"\x22,\x22"+KeyValue+"\x22,\x22"+sCallbackFunc+"\x22,req.responseText,"+Attempts+")";
	//appendToLog("sFunc="+sFunc);
	asynchInclude(null,sUrl,sFunc,sFunc);
};

/***********************************************************************************
Called by insertTableRecord() to initialize the template with a new set of values 
after it has been used to initialize a new record.

The result is created by a call to driverGetNewRecordDefaults() in TFormulaEvaluator.
The result is a pipe-delimited string in the form:
	KeyValue|Value1,Value2,Value3...|IsLookup,IsLookup,IsLookup...|NextVirtualIndex
***********************************************************************************/
function initializeNewRecordTemplate(ATableID,sValues) {

	/*	if this is the initial call, don't make the request until all submissions for the table
		are complete.  When a record is inserted, the record needs to be recorded on the server
		before requesting values for a new record in order for the virtual index value to be 
		correct for the new record
		
		11-24-16: Note: This causes a significant delay when inserting records.  Instead of waiting 
		until all submissions are complete, request the new record and increment the virtual index.
		If it is necessary to implement the delay below, at least change it so it only waits if there
		are pending submissions for a NEW record, not edits for an existing record
	*/
	if((false) && (!sValues)) {
		var c=0;
		for(var i=0;i<arPendingDataSubmissions.length;i++) {
			if(arPendingDataSubmissions[i].TableID==ATableID) {
				if(arPendingDataSubmissions[i].Status<2) {
					if(arPendingDataSubmissions[i].IsNewRecord) {
						//if (bEnableSubmissionDebugging) appendToSubmitLog("initializeNewRecordTemplate: Postponing request for new record template for tableID="+ATableID);
						setTimeout("initializeNewRecordTemplate(\""+ATableID+"\")",1000);
						return;
					};
				};
			};
		};
	};
	
	var table=document.getElementById(ATableID);

	var RowIndex=-1;
	var RowTemplate=null;
	for (var i=0;((RowIndex<0) && (i<table.rows.length));i++) {
		var s=table.rows[i].getAttribute("ID");
		if((s) && (s.equalsIgnoreCase("InsertTemplate"+ATableID))) {
			RowTemplate=table.rows[i];
			RowIndex=i;
		};
	};

	if(RowIndex<0) {
		alert("Cannot locate template for new record");
		return;
	};

	//got values.  Update the template
	if(sValues) {
		if (bEnableSubmissionDebugging) appendToSubmitLog("initializeNewRecordTemplate got values: "+sValues);
		//don't flag the record as initialized if no values were returned.  This would leave the new record
		//using the same key expression as the previous one.  A counter could be implemented here to 
		//try 2 or 3 times if an error occurs
		if(sValues.length==0) {
			alert("Error initializing defaults for new record");
			return;
		};

		//The driverGetNewRecordDefaults() function returns a string in the form:
		//keyvalue|value1,value2,value3...|isLookup1,isLookup2,isLookupn...
		//The third element in the string is used to determine if the field is a lookup.  
		//Values for lookups are not displayed in new records until the record is added 
		//to the driver by submitting the fields contained in it.
		var a=getSubStringArray(sValues,"|",false);

		//update attributes
		RowTemplate.setAttribute("keyvalue",a[0]);
		RowTemplate.setAttribute("aspectAllValues",a[1]);
		//setAttr(RowTemplate,"aspectAllValues",a[1]);

		//update cells
		var arAllFieldID=getSubStringArray(table.getAttribute("aspectallfieldid"),",");
		var arAllValue=getSubStringArray(a[1],",");
		var arTableFieldID=getSubStringArray(table.getAttribute("aspectfields"),",");

		//get array of boolean values indicating whether each value is a lookup.  Values for lookups
		//are not displayed in the table when a new record is added since only the key is available 
		//and not the actual value
		var arIsLookup=null;
		if(a.length>=3) {
			arIsLookup=getSubStringArray(a[2],",",false);
		};

		//get next virtual index field.  This is used when records are added to the end of the table
		var NextVirtualIndex=0;
		if(a.length>=4) {
			var sInsertPosition=table.getAttribute("InsertPosition");
			if((sInsertPosition) && (sInsertPosition.equalsIgnoreCase("bottom"))) {
				table.rows[RowIndex].setAttribute("virtualindex",parseInt(a[3])+1);
			}
			else {
				table.rows[RowIndex].setAttribute("virtualindex","0");
			};
		};
		
		var sDebug="";
		for (var cell=0;cell<table.rows[RowIndex].cells.length;cell++) {
			var s=table.rows[RowIndex].cells[cell].getAttribute("cellindex");
			if(s) {
				var iCellIndex=parseInt(s);
				var sFieldID=arTableFieldID[iCellIndex];
				var Done=false;
				sDebug +=" Cell="+iCellIndex+" FieldID="+sFieldID;
				
				for (var i=0;((Done==false) && (i<arAllFieldID.length));i++) 
				{
					//note: need to allow for full ID in arAllFieldID when looking for a match
					if((arAllFieldID[i].equalsIgnoreCase(sFieldID)) || (arAllFieldID[i].toUpperCase().indexOf("."+sFieldID.toUpperCase())>=0)) {
						sDebug+="childNodes="+table.rows[RowIndex].cells[cell].childNodes.length;
						if(table.rows[RowIndex].cells[cell].childNodes.length==0) {
							table.rows[RowIndex].cells[cell].innerHTML=arAllValue[i];
							sDeubg+=" set Innerhtml";
						}
						else {
							for (var Child=0;Child<table.rows[RowIndex].cells[cell].childNodes.length;Child++) 
							{
								var e=table.rows[RowIndex].cells[cell].childNodes[Child];
								sDebug +=" e["+Child+"].type="+e.type+" e["+Child+"].nodeName="+e.nodeName;
								if(e.nodeName.equalsIgnoreCase("select")) {
									e.value=arAllValue[i];
									sDebug +=" set select";
								}
								else if(e.type=='checkbox') {
									e.checked=(arAllValue[i].equalsIgnoreCase("true"));
									sDebug +=" set checkbox";
								}
								else if(e.nodeName.equalsIgnoreCase("input")) {
									e.value=arAllValue[i];
									sDebug +=" set input";
								}
								else if(e.nodeName.equalsIgnoreCase("text")) {	
									if(arIsLookup) {
										if((arIsLookup.length>i) && (arIsLookup[i].equalsIgnoreCase("t"))) {
											e.innerHTML="";
										}
										else {
											e.innerHTML=arAllValue[i];
										};
									}
									else {
										e.innerHTML=arAllValue[i];
									};
									sDebug +=" set text";
								}
								else if(e.nodeName.equalsIgnoreCase("password")) {	
									e.innerHTML=arAllValue[i];
									sDebug +=" set password";
								}
								else {
									sDebug +=" did not set";
								};
							};
						};
						Done=true;
					};
				};
				sDebug +="\r\n";
			};
		};

		//appendToLog(sDebug,false,true);
		table.rows[RowIndex].setAttribute("IsInitialized","true");

		//change the ID of the TD cell containing the inspect menu and update the onClick function 
		//used to display the menu
		for (var cell=0;cell<table.rows[RowIndex].cells.length;cell++) {
			var sName=table.rows[RowIndex].cells[cell].getAttribute("name");
			if(sName) {
				if(sName.equalsIgnoreCase("inspectrecord")) {
					var sNewID=getSalt(4);
					appendToLog("Setting ID for inspect menu to "+sNewID+" ATableID="+ATableID);
					table.rows[RowIndex].cells[cell].id=sNewID;
					var e=table.rows[RowIndex].cells[cell].childNodes[0];
					if(e) {
						var sFunc="showInspectMenu('"+sNewID+"','"+ATableID+"')";
						e.setAttribute("onclick",sFunc);	//this works for firefox
						e.onclick=Function(sFunc);		//this works for IE
					};
				};
			};
		};
		
		return;
	};

	//make a request to get values for the new record
	var sHashID=table.getAttribute("aspecthashid");
	var sDriverID=table.getAttribute("aspectdriver");

	//These need to use the driver params in place when the table was created
	//var sDriverParams=getTableDriverParams(ATableID);
	var sDriverParams=table.getAttribute("aspectParamsActive");

	var sEmbedValues=table.getAttribute("aspectembedvalues");

	//make a request for a new set of default values
	var sUrl=getServer()+"/?Network=greenlight&ID=getWidget";
	sUrl +="&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&Widget=Notification Queries";
	sUrl +="&query=getNewRecordDefaults";
	sUrl +="&source="+sHashID;
	sUrl +="&Driver_ID="+sDriverID;
	sUrl +="&Driver_Params="+sDriverParams;
	sUrl +="&EmbedValues="+sEmbedValues;
	sUrl +="&KeyDescription="+table.getAttribute("aspectkeydescription");
	if(bEnableSubmissionDebugging) appendToSubmitLog("initializeNewRecordTemplate: requesting new record defaults");
	var sFunc="initializeNewRecordTemplate(\x22"+ATableID+"\x22,req.responseText)";
	asynchInclude(null,sUrl,sFunc,sFunc);
};

/******************************************************************************
Submits data edited in a table.  e is the element used to edit the data (e.g. input, checkbox, select)
******************************************************************************/
function submitTableCell(e) {
//appendToSubmitLog("submitTableCell: "+e.id,false,true);
	var td=e.parentNode;

	//look for text tag and go one more level up
	if(td.nodeName.equalsIgnoreCase("td")==false) td=td.parentNode;

	var tr=td.parentNode;
	var tbody=tr.parentNode;
	var table=tbody.parentNode;

	if(table.nodeName.equalsIgnoreCase("table")==false) {
		alert("Error reading driver information");
		return;
	};

	var sTableID=table.getAttribute("id");
	
	//format the cell
	if(e.type!="checkbox") e.value=formatField(sTableID,e);
	
	//set the background color of the cell and the attribute indicating it's saving
	setPendingSubmissionStyle(e,true,true);
	//td.style.backgroundColor=PendingSubmissionBackgroundColor;
	td.setAttribute("AspectSubmissionPending","new");

	//get the FieldID of the cell
	var iCellIndex=parseInt(td.getAttribute("CellIndex"));
	var arFields=getSubStringArray(table.getAttribute("aspectFields"),",",true);
	var sFieldID=arFields[iCellIndex];
	
	//get the key value for the record
	var sKeyValue=tr.getAttribute("KeyValue");
	
	//get the value of the cell
	var sValue=(e.type=="checkbox") ? e.checked : e.value;

	//appendToSubmitLog("submitTableCell KeyValue="+sKeyValue+" FieldID="+sFieldID+" Value="+sValue);

	//update the corresponding cell in the edit dialog if there is one
	var d=document.getElementById(table.getAttribute("EditDialogID"));
	if(d) {
		var Control=getDialogControl(d,sKeyValue,sFieldID);
		if(Control) {
			(Control.type=="checkbox") ? Control.checked=sValue : Control.value=sValue;
			
			var eParent=Control.parentNode;
			if((eParent.nodeName.equalsIgnoreCase("td")) || (eParent.nodeName.equalsIgnoreCase("span"))){
				setPendingSubmissionStyle(Control,false,true);
				eParent.setAttribute("AspectSubmissionPending","new");
			};
		};
	};

	//var s="";
	//(sValue instanceof String) ? s=replaceAllSubstrings(sValue,",","//co"+"mma//") : s=sValue.toString();
	var s=sValue.toString();
	s=replaceAllSubstrings(sValue,",","//co"+"mma//");
	submitTableData(table.getAttribute("ID"),sKeyValue,sFieldID,s);

	if(LastKeyPress==13) {
		LastKeyPress=0;
		advanceToNextInput(e);
	};
};

/******************************************************************************
Submits data edited in a dialog.  The TableID and KeyExpression are recorded as attributes in the
dialog when it is displayed.  

The ADialogID parameter is not required.  The parent dialog will
be determined by checking the parent nodes of e until a dialog div is found.  However, ADialogID
can be passed to explicitly indicate the parent dialog div.  This can be used when a dialog contains
a 2nd dialog inside of it with data from another driver (e.g. the BackOffice registration container).
The format might be
[div dialog1]
	field from 1
	[div dialog2]
		field from 2
	[/div]
	field from 1
[/div]

02-11-2017: Modified this to call submitDialogCellSub after a delay to work around a conflict that 
occurs when onChange and onKeyDown are defined for a dialog cell.  The onChange function causes the 
input to advance 2 times instead of just to the next field when the enter key is pressed and the 
data in the field has changed.
******************************************************************************/
function submitDialogCell(e,ADialogID) {
	//console.log("submitDialogCell: "+e.getAttribute("name"));
	if(ADialogID) {
		setTimeout(function() {submitDialogCellSub(e,ADialogID);},500);
	}
	else {
		setTimeout(function() {submitDialogCellSub(e);},500);
	};
};

function submitDialogCellSub(e,ADialogID) {
	//console.log("submitDialogCellSub: "+e.getAttribute("name"));
	
	if(!ADialogID) {
		//go up the parent list until the dialog div is located.  This is the first div with a TableID attribute 
		var div=null;
		var node=e;
		//while((node!=null) && (div==null) && (e.parentNode)) {
		while((node!=null) && (div==null) && (node.parentNode)) {
			if((node.getAttribute) && (node.getAttribute("TableID"))) {
				div=node;
			}
			else {
				node=node.parentNode;
			};
		};
	}
	else {
		div=document.getElementById(ADialogID);
	};

	if(div==null) {
		//This can happen during development when editing a dialog that is to be used in a table 
		//since there is no table, just the dialog
		//alert("could not locate dialog div.");
		return;
	};

	//set the background color of the cell and the attribute indicating it's saving
	var eParent=e.parentNode;
	if((eParent.nodeName.equalsIgnoreCase("td")) || (eParent.nodeName.equalsIgnoreCase("span"))) {
		//appendToLog("submitDialogCell setting pending status for "+eParent+" Name="+e.getAttribute("name"));;
		setPendingSubmissionStyle(e,false,true);
		//eParent.style.backgroundColor=PendingSubmissionBackgroundColor;
		eParent.setAttribute("AspectSubmissionPending","new");
	};
	
	//get the table ID from the dialog div
	var sTableID=div.getAttribute("TableID");
	var sKeyValue=div.getAttribute("KeyValue");
	var sFieldID=e.getAttribute("name");
	var sValue="";
	if (e.type=="select-multiple") {
		for (var i=0;i<e.options.length;i++) {
			if(e.options[i].selected) {
				if(sValue.length>0) sValue +="|";
				sValue +=e.options[i].value;
			};
		};
	}
	else {
		sValue=(e.type=="checkbox") ? e.checked : e.value;
	};
	
	//format the contents of the cell
	//if it's a date input, allow for 2 digit year
	if(e.type=="date") {
		if(sValue.length==10) {
			//Look for two digit year in a date formatted as yyyy-MM-dd.  This will happen if a user enters a two digit year
			//in an html5 date input.  if a two digit year was entered, it will start with 00.  Convert it to a four digit year.
			if((sValue.charAt(4)=="-") && (sValue.charAt(7)=="-")) {
				var sYear=sValue.substring(0,4);
				if(sYear.substring(0,2)=="00") {
					sYear="20"+sYear.substring(2);
					sValue=sYear+sValue.substring(4);
					e.value=sValue;
				};
			};
		};
	}
	else {
		if((e.type!="select-one") && (e.type!="select-multiple") && (e.type!="checkbox") && (e.type!="datetime-local")) e.value=formatField(sTableID,e);
	};

	//update the corresponding cell in the table if there is one.  Setting the value of the control
	//in the table does not cause the onChange event to fire so the data is not submitted twice
	var table=document.getElementById(sTableID);
	var Control=getTableCellControl(table,sKeyValue,sFieldID);

	var sDebug="";
	if(Control!=null) {
		sDebug="setting table cell e.type="+e.type+" type="+Control.type+" nodename="+Control.nodeName;
		if((Control.nodeName.equalsIgnoreCase("text")) || (Control.nodeName.equalsIgnoreCase("date")) || (Control.nodeName.equalsIgnoreCase("password"))) {
			if(e.type=="select-one") {
				//set the table cell to the description of the lookup, not the value
				for (var i=0;i<e.options.length;i++) {
					if(e.options[i].value.equalsIgnoreCase(e.value)) Control.innerHTML=e.options[i].innerHTML;
				};
				sDebug +=" set select-one"
			}
			else if(e.type=="select-muliple") {
				//set the table cell to the description of the lookup, not the value
				Control.innerHTML="";
				for (var i=0;i<e.options.length;i++) {
					if(e.options[i].selected) Control.innerHTML +=e.options[i].innerHTML;
				};
				sDebug +=" set select-multiple"
			}
			else if((e.nodeName.equalsIgnoreCase("input")) && (e.getAttribute("list")!=null)) {
				//set the table cell to the value of the datalist, not the value
				var sListID=e.getAttribute("list");
				if(sListID) {
					var eDatalistInput=document.getElementById(sListID+"_input");
					if(eDatalistInput) {
						Control.innerHTML=eDatalistInput.value;
						sDebug +=" set value from list: "+sListID+"_input value:"+eDatalistInput.value;
						sDebug +=" confirm:"+Control.innerHTML;
					}
					else {
						sDebug +=" unable to locate list with ID: "+sListID+"_input";
					};
				}
				else {
					sDebug +=" unable to get list ID from element with ID: "+e.id;
				};
			}
			else {
				if(Control.nodeName.equalsIgnoreCase("text")) {
					//appendToLog("submitDialogCell: e.type="+e.type+" e.value="+e.value);
					if(e.type.equalsIgnoreCase("datetime-local")) {
						//look for yyyy-MM-ddTHH:mm format
						appendToLog("submitDialogCell e.value.indexOf(T)="+e.value.indexOf("T"));
						if(e.value.indexOf("T")==10) {
							var s=replaceAllSubstrings(e.value,"T"," ");
							appendToLog("submitDialogCell s="+s);
							var dt=parseTime(s);
							//appendToLog("submitDialogCell dt="+dt);
							var sPattern=getFieldPattern(sTableID,sFieldID);
							//appendToLog("submitDialogCell sPattern="+sPattern+" formatDate="+formatDate(dt,sPattern));
							Control.innerHTML=formatDate(dt,sPattern);
						}
						else {
							Control.innerHTML=e.value;
						};
					}
					else if(e.type=="date") {
						//look for yyyy-MM-dd and reformat it as MM-dd-yyyy before displaying it in the table
						if(e.value.charAt(4)=="-") {
							var s=e.value.substring(5)+"-"+e.value.substring(0,4);
							Control.innerHTML=s;
						};
					}
					else {
						Control.innerHTML=e.value;
					};
					sDebug +=" set other innerHTML"
				}
				else {
					Control.value=e.value;
					sDebug +=" set other value"
				};
			};
		}
		else {
			(Control.type=="checkbox") ? Control.checked=sValue : Control.value=e.value;
			sDebug +=" set checkbox"
		};

		var td=Control.parentNode;
		if(td.nodeName.equalsIgnoreCase("td")) {
			setPendingSubmissionStyle(Control,true,true);
			//td.style.backgroundColor=PendingSubmissionBackgroundColor;
			td.setAttribute("AspectSubmissionPending","new");
		};
	}
	else {
		sDebug="submitDialogCell setting table cell control was null";
	};

	//appendToLog("submitDialogCell: "+sDebug,false,true); 
	
	//var s="";
	//appendToLog("submitDialogCell: sValue="+sValue);
	//((typeof sValue)=="boolean") ? s=sValue.toString() : s=replaceAllSubstrings(sValue,",","//co"+"mma//");
//console.log("submitDialogCell: submitTableData.  TableID:"+sTableID+" KeyValue:"+sKeyValue+" FieldID:"+sFieldID+" Value="+s);
	var s=sValue.toString();
	s=replaceAllSubstrings(sValue,",","//co"+"mma//");
	submitTableData(sTableID,sKeyValue,sFieldID,s);
};

/****************************************************************************
This function creates a arTableMetadata entry for the given table.  It records the 
table ID, DriverID, HashID and other information required to submit data for the table.
This is done so that data can be submitted even if a table is closed before the submission
takes place.

This function is called from submitTableData() and also from showTableEditDialogForRow() 
and showTableEditDialog().

The calls from showTableEditDialogForRow() and showTableEditDialog() are required in case the 
view is closed while the dialog is still opened.
****************************************************************************/
function recordTableMetadata(ATableID) {
	var n=-1;
	for(var i=0;i<arTableMetadata.length;i++) {
		if(arTableMetadata[i].TableID.equalsIgnoreCase(ATableID)) n=i;
	};
	if(n<0) n=arTableMetadata.length;
	
	var table=document.getElementById(ATableID);
	if(!table) return;
	
	var sHashID=table.getAttribute("aspectHashID");
	var sDriverID=table.getAttribute("aspectDriver");
	var sKeyExpression=table.getAttribute("aspectKeyExpression");
	var sAllFieldID=table.getAttribute("aspectAllFieldID");
	var sAllFieldType=table.getAttribute("aspectAllFieldType"); 
	var sDriverParams=document.getElementById(ATableID).getAttribute("aspectParamsActive");
	if(!sDriverParams) sDriverParams=getTableDriverParams(ATableID); //for compatibility before posting aspectParamsActive

	arTableMetadata[n]={TableID:ATableID,HashID:sHashID,DriverID:sDriverID,KeyExpression:sKeyExpression,AllFieldID:sAllFieldID,AllFieldType:sAllFieldType,DriverParams:sDriverParams};
	
	//remove any records for which there are no pending submissions and for which the table does not currently exist
	n=0;
	while(n<arTableMetadata.length) {
		if((arTableMetadata[n].TableID.equalsIgnoreCase(ATableID)) || (document.getElementById(arTableMetadata[n].TableID))) {
			n++
		}
		else {
			arTableMetadata.splice(n,1);
		};
	};
};


/******************************************************************************
Displays attributes for the element with the given ID
******************************************************************************/
function debugAttributes(sID)
{
	if(sID.length==0) {
		alert("No ID in debugAttributes");
		return;
	};
	
	var d=document.getElementById("TableInfo"+sID.toLowerCase());
	if(!d) {
		//create a new div for the table info
		d=document.createElement("div");
		d.className="TableInfo";
		d.setAttribute("ID","TableInfo"+sID);
		d.id="TableInfo"+sID;
		
		//add the table info div to the div containing the table
		document.getElementById("div"+sID.toLowerCase()).appendChild(d);
	}
	else {
		//clear the already existing div
		d.innerHTML="";
	};
	
	var eTable=document.getElementById(sID);

	var xy=getPosition(eTable,"absolute",document.getElementById("div"+sID.toLowerCase()));
	//d.style.top=xy[1]+"px";
	d.style.top="20px";
	d.style.left=xy[0]+"px";

	//create a title for the div
	var divTitle=document.createElement("div");
	var h1=document.createElement("h1");
	h1.appendChild(document.createTextNode("Information"));
	divTitle.appendChild(h1);
	
	//create a close icon for the div - it will float right
	var divCloseIcon=document.createElement("div");
	divCloseIcon.className="TableInfoCloseIcon";
	var s="setVisible('TableInfo"+sID+"',false)";
	divCloseIcon.setAttribute("onclick",s);	//this works for firefox
	divCloseIcon.onclick=Function(s);		//this works for IE
	
	//add the title, close icon and an hr to the div
	var divTitleContainer=document.createElement("div");
	divTitleContainer.style.overflow="auto";
	divTitleContainer.appendChild(divCloseIcon);
	divTitleContainer.appendChild(divTitle);
	d.appendChild(divTitleContainer);
	d.appendChild(document.createElement("hr"));

	//create a table for general information that will be visible to users
	var h1=document.createElement("h1");
	h1.appendChild(document.createTextNode("General"));
	d.appendChild(h1);
	var table=document.createElement("table");
	table.className="TableInfoGeneral";
	
	//add the table ID
	row=document.createElement("tr");
	var td=document.createElement("td");
	td.appendChild(document.createTextNode("Table ID"));
	row.appendChild(td);
	td=document.createElement("td");
	td.appendChild(document.createTextNode(sID));
	row.appendChild(td);
	table.appendChild(row);
	
	//add the time updated
	row=document.createElement("tr");
	var td=document.createElement("td");
	td.appendChild(document.createTextNode("Updated"));
	row.appendChild(td);
	td=document.createElement("td");
	var eTimestamp=document.getElementById("table_updated_"+sID.toLowerCase());
	td.innerHTML=(eTimestamp) ? eTimestamp.innerHTML : "&nbsp;";
	row.appendChild(td);
	table.appendChild(row);

	//add the source computer
	row=document.createElement("tr");
	var td=document.createElement("td");
	td.appendChild(document.createTextNode("Computer"));
	row.appendChild(td);
	td=document.createElement("td");
	td.innerHTML=eTable.getAttribute("AspectHashID");
	row.appendChild(td);
	table.appendChild(row);

	//add the table to the table info div
	d.appendChild(table);
	
	//get a list of all attributes for the table beginning with "aspect"
	var e=document.getElementById(sID);
	var a=new Array();
	for (var i=0;i<e.attributes.length;i++) {
		var sName=e.attributes.item(i).nodeName;
		if(sName.startsWith("aspect")) {
			a[a.length]=sName.substring(6)+"="+ e.attributes.item(i).nodeValue+"\n";
		};
	};
	a.sort();

	//get a string containing all fields used in the table dialog - This list can be used to create a list of embedded fields to speed things up
	//Specifying embedded fields will cause only those fields to be included in the hidden fields associated with the record
	//in the table.  Using embedded fields also avoids including unneeded calculated fields
	var arAlreadyAdded=new Array();
	var eDialog=document.getElementById(eTable.getAttribute("EditDialogID"));
	var s="";
	if(eDialog) {
		var arFieldID=getSubStringArray(eTable.getAttribute("aspectallfieldid"),",",false);
		var arNodes=new Array();
		getAllChildNodes(eDialog,arNodes);
		for(var i=0;i<arNodes.length;i++) {
			if(arNodes[i].nodeName.indexOf("\x23")<0) {
				var sName=arNodes[i].getAttribute("name");
				if(sName) {
					var n=getFieldIndex(sName,arFieldID);
					if(n>=0) {
						if(arAlreadyAdded.indexOf(sName)<0) {
							if(s.length>0) s +=", ";
							s+=sName;
							arAlreadyAdded[arAlreadyAdded.length]=sName;
						};
					};
				};
			};
		};
		
		if(s.length==0) s="No fields found in dialog.";
	}
	else {
		s="No dialog defined";
	};
	
	//create another table for debugging  information
	var h1=document.createElement("h1");
	h1.appendChild(document.createTextNode("Debugging"));
	d.appendChild(h1);
	var table=document.createElement("table");
	table.className="TableInfoDebug";
	
	row=document.createElement("tr");
	var td=document.createElement("td");
	td.appendChild(document.createTextNode("Dialog Fields"));
	row.appendChild(td);
	var td=document.createElement("td");
	td.appendChild(document.createTextNode(s))
	row.appendChild(td);
	table.appendChild(row);
	
	//screen width
	row=document.createElement("tr");
	var td=document.createElement("td");
	td.appendChild(document.createTextNode("Screen Width"));
	row.appendChild(td);
	var td=document.createElement("td");
	td.appendChild(document.createTextNode(getViewportWidth()))
	row.appendChild(td);
	table.appendChild(row);
	
	//screen height
	row=document.createElement("tr");
	var td=document.createElement("td");
	td.appendChild(document.createTextNode("Screen Height"));
	row.appendChild(td);
	var td=document.createElement("td");
	td.appendChild(document.createTextNode(getViewportHeight()))
	row.appendChild(td);
	table.appendChild(row);

	//add node type (make sure it's a table)
	row=document.createElement("tr");
	var td=document.createElement("td");
	td.appendChild(document.createTextNode("Node Type"));
	row.appendChild(td);
	var td=document.createElement("td");
	td.appendChild(document.createTextNode(table.nodeType))
	row.appendChild(td);
	table.appendChild(row);
	
	//add table ID
	row=document.createElement("tr");
	var td=document.createElement("td");
	td.appendChild(document.createTextNode("Table ID"));
	row.appendChild(td);
	var td=document.createElement("td");
	td.appendChild(document.createTextNode(sID))
	row.appendChild(td);
	table.appendChild(row);

	for(var i=0;i<a.length;i++) {
		var n=a[i].indexOf("=");
		var sName=a[i].substring(0,n);
		var sValue=a[i].substring(n+1);
		row=document.createElement("tr");
		td=document.createElement("td");
		td.appendChild(document.createTextNode(sName));
		row.appendChild(td);
		td=document.createElement("td");
		//td.appendChild(document.createTextNode(replaceAllSubstrings(sValue,",","&#48; ")));
		var s=replaceAllSubstrings(sValue,",","~@~");
		s=replaceAllSubstrings(s,"~@~",", ");
		s=replaceAllSubstrings(s,"|","~@~");
		s=replaceAllSubstrings(s,"~@~","| ");
		td.appendChild(document.createTextNode(s));
		row.appendChild(td);
		table.appendChild(row);
	};
	
	//wrap the debugging table in a div container
	var tableContainer=document.createElement("div");
	tableContainer.className="TableInfoDebugContainer";
	tableContainer.appendChild(table);
	d.appendChild(tableContainer);
	
	setVisible(d,true);

	//position the dialog horizontally
	d.style.left=0;

	//center the dialog if the table width is greater than the dialog width
	var maxwidth=Math.min(documentWidth(),eTable.tBodies[0].offsetWidth);
	if(maxwidth>d.offsetWidth) {
		//don't shift the dialog toward the center if the left position will be small.
		//Otherwise, a small (e.g. 9px) margin can be introduced for small screens.
		//Might have something to do with the scroll bar
		var left=Math.min(250,(maxwidth-d.offsetWidth)/2);
		if(left>20) d.style.left=left;
	};
};



 
function tableRowClicked(e) {
	if(e.getAttribute("borderon")) {
		e.style.borderWidth=0;
		e.style.borderStyle="none";
		e.removeAttribute("borderon");
		console.log("set border off");
	}
	else {
		e.style.borderWidth="5px";
		e.style.borderStyle="solid";
		e.setAttribute("borderon","true");
		console.log("set border on");
	};
};

function getSinicrollBarWidth() {
	var inner=document.createElement('p');
	inner.style.width="100%";
	inner.style.height="200px";

	var outer=document.createElement('div');
	outer.style.position="absolute";
	outer.style.top="0px";
	outer.style.left="0px";
	outer.style.visibility="hidden";
	outer.style.width="200px";
	outer.style.height="150px";
	outer.style.overflow="hidden";
	outer.appendChild (inner);

	document.body.appendChild (outer);
	var w1=inner.offsetWidth;
	outer.style.overflow='scroll';
	var w2=inner.offsetWidth;
	if (w1==w2) w2=outer.clientWidth;

	document.body.removeChild (outer);

	return (w1 - w2);
};

/*******************************************************************
03-28-2016
Moves a table row up or down one row in a table.  A calculated field in
a structure can use this to display icons for moving up/down:

="<span class='keyboard_arrow_up' onClick='moveTableRecordUp(this)'></span>
	<span class='keyboard_arrow_down' onClick='moveTableRecordDown(this)'></span>"

See the "Move" field in the Greenlight_UI_View_Common_Fields structure for
an example.

A virtual index field must be specified for a driver in order for this
function to work.

Error checking is done to determine if the move operation is valid (e.g. 
can't move the first record in a table up).  It is also not possible to 
move records past a section header, although the records could be moved if 
the section header is removed from the display.  This is intentional for now.

e: The element click to initiate the move.  The parent TD, TR and Table
	are determined from this.
Direction: 1 to move down, -1 to move up
*******************************************************************/
function moveTableRecord(e,iDirection) {
	var td=e.parentNode;
	if(td.nodeName.equalsIgnoreCase("td")==false) td=td.parentNode;

	var tr=td.parentNode;
	var tbody=tr.parentNode;
	var table=tbody.parentNode;

	if(table.nodeName.equalsIgnoreCase("table")==false) {
		alert("Error: moveTableRecord cannot locate table");
		return;
	};

	var VirtualIndexField=table.getAttribute("AspectVirtualIndex");
	if(!VirtualIndexField) {
		alert("Error: moveTableRecord missing virtual index field");
		return;
	};

	var RowIndex1=tr.rowIndex;
	var RowIndex2=RowIndex1+iDirection;

	//abort if trying to move the last row down
	if(RowIndex2>=table.rows.length) {
		appendToLog("moveTableRecord: Cannot move row down");
		return;
	};
	
	var VirtualIndex1=table.rows[RowIndex1].getAttribute("virtualindex");
	var VirtualIndex2=table.rows[RowIndex2].getAttribute("virtualindex");
	var sKeyValue1=table.rows[RowIndex1].getAttribute("keyvalue");
	var sKeyValue2=table.rows[RowIndex2].getAttribute("keyvalue");

	//abort if the previous row doesn't have a key value
	if(iDirection==-1) {
		if(!sKeyValue2) {
			appendToLog("moveTableRecord: Missing key value for previous row");
			return;
		};

		if(table.rows[RowIndex2].getAttribute("istemplate")) {
			appendToLog("moveTableRecord: Previous row is a tamplate");
			return;
		};
	};

	//swap the virtual index values in the table rows
	table.rows[RowIndex1].setAttribute("virtualindex",VirtualIndex2);
	table.rows[RowIndex2].setAttribute("virtualindex",VirtualIndex1);

	var arKey=sKeyValue1+","+sKeyValue2;
	var arFieldID=VirtualIndexField+","+VirtualIndexField;
	var arValue=VirtualIndex2+","+VirtualIndex1;

	submitTableData(table.id,arKey,arFieldID,arValue);

	//swap the rows
	var parentNode=table.rows[RowIndex1].parentNode;
	if(iDirection==1) {
		parentNode.insertBefore(table.rows[RowIndex1],table.rows[RowIndex1 + 1].nextSibling)
	}
	else {
		parentNode.insertBefore(table.rows[RowIndex2],table.rows[RowIndex1].nextSibling)
	};
};

function moveTableRecordUp(e) {
	moveTableRecord(e,-1);
};

function moveTableRecordDown(e) {
	moveTableRecord(e,1);
};

/****************************************************************************
Note: 07-18-2016 - It may be possible to improve the performance of this function 
using the colgroup tab.  Some quick experiments were not successful.  The main 
problem is that the tbody element is an inline element which means it's height cannot
be specified.  If it is converted to a block element, the width becomes a problem.

Creates a fixed table header.  
Called from initializeTables2012() and showTab().  The header cannot be fixed
until the table is visible.  This is why the call is made from showTab()

For tables to display properly, the table style should be float:left;width:auto.
Otherwise the column headers may not line up with the table columns and the 
scrollbar may be forced far to the right since the table display is set to block
and it will attempt to take up the whole width.  To constrain the width of a 
table, use width:auto on the table and wrap it in a container with a set width.
****************************************************************************/
function makeScrollingTable()
{
	var arTable=document.getElementsByTagName("table");
	for(var i=0;i<arTable.length;i++) {
		var MaxHeight=arTable[i].getAttribute("AspectMaxHeight");
		var ScrollingInitialized=arTable[i].getAttribute("ScrollingInitialized");
		if((MaxHeight) && (arTable[i].tBodies[0].rows.length>0) && (!ScrollingInitialized)) {
			//don't update unless the table is visible
			if(arTable[i].offsetWidth>0) {
				var Height=arTable[i].getAttribute("AspectHeight");
				if(!Height) Height="auto";

				arTable[i].style.display="block";
				arTable[i].tBodies[0].style.boxSizing="content-box";
				arTable[i].tBodies[0].style.height=Height;
				arTable[i].tBodies[0].style.maxHeight=MaxHeight;
				arTable[i].tBodies[0].style.display="block";
				arTable[i].tBodies[0].style.overflowY="auto";

				var arTHead=arTable[i].getElementsByTagName("thead");

				var scrollbarwidth=0;
				var scrollHeight=arTable[i].tBodies[0].scrollHeight;
				var	offsetHeight=arTable[i].tBodies[0].offsetHeight;
				if(scrollHeight>offsetHeight) scrollbarwidth=getScrollBarWidth();
	
				//these two lines have no effect in firefox on the desktop.
				//but are required for Chrome on the phone
				arTHead[arTHead.length-1].style.display="block";
				arTHead[arTHead.length-1].style.width=(arTable[i].tBodies[0].offsetWidth+scrollbarwidth)+"px";

				arTable[i].tBodies[0].style.width=(arTable[i].tBodies[0].offsetWidth+scrollbarwidth)+"px";

				for(var cell=0;cell<arTable[i].tBodies[0].rows[0].cells.length;cell++) {
					var w1=arTHead[arTHead.length-1].rows[0].cells[cell].offsetWidth;
					var w2=arTable[i].tBodies[0].rows[0].cells[cell].offsetWidth;
					var w=Math.max(w1,w2);

					arTHead[arTHead.length-1].rows[0].cells[cell].style.width=w+"px";
					arTable[i].tBodies[0].rows[0].cells[cell].style.width=w+"px";
				};

				//This is for debugging.  Add a div to the page with the table ID + info to 
				//put debugging information in the div
				var eInfo=document.getElementById(arTable[i].id+"info");
				if(eInfo) {
					eInfo.innerHTML +=" scrollbarwidth="+scrollbarwidth+" scrollHeight="+scrollHeight+" offsetHeight="+offsetHeight;
					eInfo.innerHTML +=" THead w="+arTHead[arTHead.length-1].offsetWidth;
					eInfo.innerHTML +=" TBody w="+arTable[i].tBodies[0].offsetWidth;
				};

				arTable[i].setAttribute("ScrollingInitialized",true);
			};
		};
	};
};

function showTableMenu(e,TableID) {
	//appendToLog("showTableMenu: "+TableID);
	var eMenu=document.getElementById("TableMenu"+TableID.toLowerCase());

	//if the menu is visible, hide it
	if(isVisible(eMenu)) {
		setVisible(eMenu,false);
		return;
	};

	//display the menu
	var xy=getPosition2012(e,"absolute",document.getElementById("div"+TableID));
	eMenu.style.top=xy[1]+e.offsetHeight;
	setVisible(eMenu,true);

	//don't let the left coordinate be less than zero.  This can happen when
	//there are few icons and the menu icon is close to the left of the screen
	eMenu.style.left=Math.max(0,xy[0]+e.offsetWidth-eMenu.offsetWidth);

	//appendToLog("x="+xy[0]+" e.offsetWidth="+e.offsetWidth+" eMenu.offsetWidth="+eMenu.offsetWidth);
	//appendToLog("showTableMenu: "+TableID+" showing top="+(xy[1]+e.offsetHeight)+" left="+Math.max(0,xy[0]+e.offsetWidth-eMenu.offsetWidth));
};

/**************************************************************
Hides all table menus.  Called when the browser is resized.
**************************************************************/
function hideAllTableMenus() {
	var ar=document.getElementsByTagName("div");
	for(var i=0;i<ar.length;i++) {
		if(ar[i].id) {
			if(ar[i].id.startsWith("TableMenu")) setVisible(ar[i],false);
		};
	};
};

function tableMenuitemSelected(FuncName,TableID)
{
	//hide the menu
	setVisible("TableMenu"+TableID,false);

	if(eval("typeof "+FuncName)=="function") {
		//execute the function
		if(FuncName.equalsIgnoreCase("refreshTable")) {
			refreshTable(TableID,"refresh");
		}
		else if(FuncName.equalsIgnoreCase("openDisplayDialog")) {
			openDisplayDialog(TableID,document.getElementById("display_"+TableID));
		}
		else if(FuncName.equalsIgnoreCase("exportTable")) {
			exportTable(TableID.toLowerCase(),'',true);
		}
		else {
			var s=FuncName+"('"+TableID+"')";
			eval(s);
		};
	}
	else {
		//function is invalid
		alert("Invalid function: "+FuncName);
	};
};

/******************************************************************************
Tokenize or de-tokenize a value for a cell in a table
******************************************************************************/
function tokenizeTableValue(sValue,bTokenize)
{
	if(bTokenize) {
		sValue=replaceAllSubstrings(sValue,",","%%com"+"ma%%");
		sValue=replaceAllSubstrings(sValue,"\r\n","%%cr"+"l"+"f%%");
		sValue=replaceAllSubstrings(sValue,"\x22","%%qu"+"ot%%");
		sValue=replaceAllSubstrings(sValue,"'","%%ap"+"os%%");
		sValue=replaceAllSubstrings(sValue,">","%%g"+"t%%");
		sValue=replaceAllSubstrings(sValue,"<","%%l"+"t%%");
		sValue=replaceAllSubstrings(sValue,"\x7B","%%l"+"eftbrace%%");
		sValue=replaceAllSubstrings(sValue,"\x7D","%%r"+"ightbrace%%");
	}
	else {
		sValue=replaceAllSubstrings(sValue,"%%com"+"ma%%",",");
		sValue=replaceAllSubstrings(sValue,"%%cr"+"l"+"f%%","\r\n");
		sValue=replaceAllSubstrings(sValue,"%%qu"+"ot%%","\x22");
		sValue=replaceAllSubstrings(sValue,"%%ap"+"os%%","'");
		sValue=replaceAllSubstrings(sValue,"%%g"+"t%%",">");
		sValue=replaceAllSubstrings(sValue,"%%l"+"t%%","<");
		sValue=replaceAllSubstrings(sValue,"%%l"+"eftbrace%%","\x7B");
		sValue=replaceAllSubstrings(sValue,"%%r"+"ightbrace%%","\x7D");
	};
	return(sValue);
};

function printTable(sTableID,sWrapper)
{
	//Look for a div with the ID print[tableid] and print the contents of that
	//This allows for including content above or below the table
	//If not defined, use the div surrounding the table
	var eTable=document.getElementById(sTableID);
	var eToPrint=document.getElementById("print"+sTableID);
	if(!eToPrint) eToPrint=document.getElementById("div"+sTableID);
	var eTable=document.getElementById(sTableID);

	//abort if surrounding div is not found
	if(!eToPrint) {
		alert("Cannot locate table div with ID=div"+sTableID);
		return;
	};

	//if the printer wrapper was retrieved, open the document in a new window
	if(sWrapper) {
		sWrapper +=eToPrint.innerHTML;
		sWrapper +="</body></html>"

		//show message
		showDialog("icon=true&msg=Preparing report...");

		//apply overlay to disable table
		applyOverlay(eToPrint,"overlay"+sTableID);
		
		var docprint=window.open("","","toolbar=yes,location=no,directories=yes,menubar=yes,scrollbars=yes,width=650, height=600, left=100, top=25"); 
		docprint.document.open(); 
		docprint.document.write(sWrapper); 

		//copy style elements
		var arStyle=document.getElementsByTagName("style");
		for(var i=0;i<arStyle.length;i++) {
			docprint.document.getElementsByTagName("head")[0].appendChild(arStyle[i].cloneNode(true));
		};

		var arTagNames=new Array("div","form","thead");
		for (var i=0;i<arTagNames.length;i++) {
			var arTag=docprint.document.getElementsByTagName(arTagNames[i]);
			var j=0;
			while (j<arTag.length) {
				var attr1=arTag[j].getAttribute("noprint");
				var attr2=arTag[j].getAttribute("print");
				if (((attr1) && (attr1.toString().equalsIgnoreCase("true"))) || ((attr2) && (attr2.toString().equalsIgnoreCase("false")))) {
					arTag[j].style.display="none";
					arTag[j].display="none";
					arTag[j].innerHTML="&nbsp;";
					arTag[j].parentNode.removeChild(arTag[j]); 
				}
				else {
					j++;
				};
			};
		};

		//hide cells in tables used to select and edit records
		var arCells=docprint.document.getElementsByName("selectrecord");
		for(var i=0;i<arCells.length;i++) arCells[i].style.display="none";

		var arCells=docprint.document.getElementsByName("editrecord");
		for(var i=0;i<arCells.length;i++) arCells[i].style.display="none";

		var arCells=docprint.document.getElementsByName("inspectrecord");
		for(var i=0;i<arCells.length;i++) arCells[i].style.display="none";
		
		//remove script tags
		var arTag=docprint.document.getElementsByTagName("script");
		var n=0
		do {
			if((arTag[n].id) && (arTag[n].id.equalsIgnoreCase("JSPrint"))) {
				n++;
			}
			else {
				arTag[n].parentNode.removeChild(arTag[n]); 
			};
		} while(n<arTag.length);

		//hide message
		showDialog();

		//remove overlay
		var eOverlay=document.getElementById("overlay"+sTableID);
		eOverlay.parentNode.removeChild(eOverlay);
		
		docprint.document.close(); 
		docprint.focus(); 
		return;
	}
	
	//get the printer wrapper
	var sUrl=getServer()+"/?Network=GreenLight&ID=getCachedWidget&DocumentID=77NaWu0FhKDKXL7C70JpnKmy&Widget=Printer Wrapper";
	var sFunc="printTable(\x22"+sTableID+"\x22,req.responseText)";
	asynchInclude(null,sUrl,sFunc,sFunc);
};

/******************************************************************************
Formats the data in an input field.  arFieldID and arPattern are optional.  
******************************************************************************/
//function formatInputField(TableID,e,AarFieldID,AarPattern)

/******************************************************************************
Functions to move table rows
******************************************************************************/
function getSelectedTableRow(eTable) {
	for (var r=0;r<eTable.rows.length;r++) {
		if(eTable.rows[r].getAttribute("selected")=="true") return(r);
	};
	return(-1);
};
	
function moveTableRow(TableID,iDirection) {
	var table=document.getElementById(TableID);
	r=getSelectedTableRow(table);
	if((r+iDirection>=0) && (r+iDirection<table.rows.length)){
		var sHtml1=table.rows[r+iDirection].innerHTML;
		var sHtml2=table.rows[r].innerHTML;
		var ckValue1=table.rows[r+iDirection].cells[0].firstChild.checked;
		var ckValue2=table.rows[r].cells[0].firstChild.checked;
		table.rows[r+iDirection].innerHTML=sHtml2;
		table.rows[r].innerHTML=sHtml1;
		table.rows[r+iDirection].cells[0].firstChild.checked=ckValue2;
		table.rows[r].cells[0].firstChild.checked=ckValue1;
		table.rows[r+iDirection].setAttribute("selected","true");
		table.rows[r].setAttribute("selected","false");
	};
};

function tableCellSelected(cell) {
	appendToLog("tableCellSelected");
	tableRowSelected(cell.parentNode);
};

var imgRowSelected=null;

function tableRowSelected(row) {
	appendToLog("tableRowSelected");
	var table=row.parentNode;
	
	for (var r=0;r<table.rows.length;r++) {
		table.rows[r].setAttribute("selected","false");
		var cell=table.rows[r].cells[2];
		if(cell.childNodes.length>0) {
			cell.removeChild(cell.childNodes[0]);
		};
	};

	//initialize image used to indicate selected row	
	if(imgRowSelected==null) {
		imgRowSelected=new Image();
		imgRowSelected.src=getServer()+"/?Network=Greenlight&Id=getImage&filename=c:/aspect7/packages/GreenLight.zip/doc/images/leftarrowgreen12x12.png";
	};
	
	row.setAttribute("selected","true");
	var img=new Image();
	img.src=imgRowSelected.src;
	row.cells[2].appendChild(img);
};

/******************************************************************************
Returns a count of the selected fields.  Used to ensure that at least one field is selected
******************************************************************************/
function countSelectedFields(sTableID)
{
	var table=document.getElementById("FieldsSelected_"+sTableID);
	var cSelected=0;
	for (var i=0;i<table.rows.length;i++) {
		if(table.rows[i].cells[0].firstChild.checked) cSelected++;
	};
	return(cSelected);
};

function enableExternalFilters(TableID,b)
{
	var table=document.getElementById(TableID);
	if(!table) {
		appendToLog("Error in enableExternalFilters.  Invalid table ID: "+TableID,false,true);
		return;
	};
	var sExternalFilter=table.getAttribute("externalfilters");
	if((sExternalFilter) && (sExternalFilter.length>0)) {
		var ar=getSubStringArray(sExternalFilter,",",true)
		for (var i=0;i<ar.length;i++) {
			var e=document.getElementById(ar[i]);
			if(e) e.disabled=!b;
		};
	};
};

function enableExternalParams(TableID,b)
{
	var table=document.getElementById(TableID);
	if(!table) return;
	
	var sExternalParam=table.getAttribute("externalparams");
	if((sExternalParam) && (sExternalParam.length>0)) {
		var arExternalParam=getSubStringArray(sExternalParam,",",true);
		for (var i=0;i<arExternalParam.length;i++) {
			var e=document.getElementById(arExternalParam[i]);
			if(e) e.disabled=!b;
		};
	};
};

function getExternalFilters(TableID)
{
	var sContent="";
	var table=document.getElementById(TableID);
	var sExternalFilter=table.getAttribute("externalfilters");
	if((sExternalFilter) && (sExternalFilter.length>0)) {
		var ar=getSubStringArray(sExternalFilter,",",true)
//console.log("ar="+ar.toString());
		//if(ar==null) alert("ar=null in getExternalFilters");
		for (var i=0;i<ar.length;i++) {
//console.log("ar["+i+"]="+ar[i]);
			var e=document.getElementById(ar[i]);
			if(e) {
				var sExpression=e.getAttribute("Expression");
				if(!sExpression) {
					sExpression="(true)";
					//appendToLog("Missing expression for filter with ID="+ar[i],false,true);
				};

				//if the ID is the [tableID]ContainsText then set the expression automatically
				if(ar[i].equalsIgnoreCase(TableID+"ContainsText")) {
					if(sExpression=="(true)") {
						var sFields=table.getAttribute("aspectfields");
						sFields=replaceAllSubstrings(sFields,",","+\" \"+");
						//sExpression="gte(pos('$value$',"+sFields+"),0,n)";
						sExpression="keywordMatch('$value$',"+sFields+",',',true)";
					};
				};

				//get the conditional expression which is used to determine if the expression should be included in the
				//driver filter.  This is used to speed up processing by eliminating filters that are not in use
				var sCondition=e.getAttribute("Condition");
				if(!sCondition) sCondition="(true)";
				
				//get the operator
				var sOperator=e.getAttribute("operator");
				if(!sOperator) sOperator="and";
				
				//if it's a datalist, get the value from the datalist's hidden element 
				if(e.nodeName=="DATALIST") {
					var sValue="";
					e=document.getElementById(ar[i]+"_input_submit");
					if(e) sValue=e.value;
				}
				else if(e.type=="select-multiple") {
					var sValue="";
					for(var j=0;j<e.options.length;j++) {
						if(e.options[j].selected) {
							if(sValue.length>0) sValue+=",";
							sValue+=e.options[j].value;
						};
					};
				}
				else {
					var sValue=(e.type=="checkbox") ? sValue=(e.checked) : sValue=e.value;
				};
				sContent +="|XFilter_"+ar[i]+"="+sExpression+"^"+sValue+"^"+sCondition+"^"+sOperator;
				//appendToLog("Adding external filter: "+sExpression+"^"+sValue+"^"+sCondition);
			}
			else {
				console.log("Cannot locate external filter with ID="+ar[i]);
			};
		};
	};
	
//console.log("tttgetexternalfilters: "+sContent);
	return(sContent);
};

/*****************************************************************************************************
Returns a pipe-delimited list of external params in the form:
expression^value|expression^value 
where expression is generally in the form xxx=$value$
*****************************************************************************************************/
function getExternalDriverParams(TableID)
{
	//console.log("getExternalDriverParams table="+TableID,false,true);
	var sContent="";
	var table=document.getElementById(TableID);
	var sExternalParam=table.getAttribute("externalparams");
	if((sExternalParam) && (sExternalParam.length>0)) {
		var arExternalParam=getSubStringArray(sExternalParam,",",true);
		for (var j=0;j<arExternalParam.length;j++) {
			var eExternalParam=document.getElementById(arExternalParam[j]);
			if(eExternalParam) {
				var sExpression=eExternalParam.getAttribute("param");
				var sValue="";
				//if it's a datalist, get the value from the datalist's hidden element 
				if(eExternalParam.nodeName=="DATALIST") {
					var e=document.getElementById(arExternalParam[j]+"_input_submit");
					if(e) sValue=e.value;
				}
				else if(eExternalParam.type=="select-multiple") {
					var sValue="";
					for(var i=0;i<eExternalParam.options.length;i++) {
						if(eExternalParam.options[i].selected) {
							if(sValue.length>0) sValue+=",";
							sValue+=eExternalParam.options[i].value;
						};
					};
				}
				else {
					(eExternalParam.type=="checkbox") ? sValue=(eExternalParam.checked) : sValue=eExternalParam.value;
				};
				//console.log("Driver param sValue="+sValue);
				if(sContent.length>0) sContent +="|";
				sContent +=sExpression+"^"+sValue;
			}
			else {
				appendToLog("refreshTable cannot locate external driver param with ID="+arExternalParam[j],false,true);
			};
		};
	};
	//appendToLog("getExternalDriverParams table="+TableID+" returns "+sContent,false,true);
	return(sContent);
};

function getTableDriverParams(TableID,bIncludeExternalParams)
{
	var table=document.getElementById(TableID);
	var sParams=table.getAttribute("aspectParams");
	if(!bIncludeExternalParams) return(sParams);
	
	//add external params, overwriting the 
	var sExternalParams=getExternalDriverParams(TableID);
	if(sExternalParams.length>0) {
		var arExternalParams=getSubStringArray(sExternalParams,"|",true);
		for(var i=0;i<arExternalParams.length;i++) {
			var a=getSubStringArray(arExternalParams[i],"^",true);
			if(a.length==2) {
				if(sParams.length>0) sParams +="|";
				sParams +=replaceAllSubstrings(a[0],"$value$",a[1]);
			};
		};
	};
	appendToLog("getTableDriverParams returns "+sParams,false,true);
	return(sParams);
};

function printIFrame(strElementID)
{ 
	var iframe=document.getElementById(strElementID);
	if (!iframe) {
		alert("No content defined for printing");
		return;
	};

	var strUrl="https://__server__/?Network=GreenLight&ID=getCachedWidget&DocumentID=77NaWu0FhKDKXL7C70JpnKmy&Widget=Printer Wrapper";
	var strDoc=getxmlHttpRequest(strUrl);
	

	//strDoc +="<iframe src=\x22"+iframe.src+"\x22></iframe>"
	strDoc +=window.frames["widget_iframe"].document.body.innerHTML;
	strDoc +="</body></html>"
	var eStyle=document.getElementsByTagName("style")[0];
	strDoc=replaceAllSubstrings(strDoc,"$style$",eStyle.innerHTML);

	var docprint=window.open("","","toolbar=yes,location=no,directories=yes,menubar=yes,scrollbars=yes,width=650, height=600, left=100, top=25"); 
	docprint.document.open(); 
	docprint.document.write(strDoc); 

	var arTagNames=new Array("div","form");
	for (var i=0;i<arTagNames.length;i++) {
		var arTag=docprint.document.getElementsByTagName(arTagNames[i]);
		var j=0;
		while (j<arTag.length) {
			var attr1=arTag[j].getAttribute("noprint");
			var attr2=arTag[j].getAttribute("print");
//alert("attr1="+attr1+" attr2="+attr2);			
			if (((attr1) && (attr1.toString().equalsIgnoreCase("true"))) || ((attr2) && (attr2.toString().equalsIgnoreCase("false")))) {
				arTag[j].style.display="none";
				arTag[j].display="none";
				arTag[j].innerHTML="&nbsp;";
				arTag[j].parentNode.removeChild(arTag[j]); 
			}
			else {
				j++;
			};
		};
	};
	
	//remove script tags
	var arTag=docprint.document.getElementsByTagName("script");
	while (arTag.length>0) {
		arTag[0].parentNode.removeChild(arTag[0]); 
	};

	docprint.document.close(); 
	docprint.focus(); 
}

function printReport(strWidgetID)
{ 
	var e=document.getElementById("Report_Content"+strWidgetID);
	if (!e) {
		alert("No content defined for printing");
		return;
	};
	var strContent=e.innerHTML; 
	var disp_setting="toolbar=yes,location=no,directories=yes,menubar=yes,scrollbars=yes,width=650, height=600, left=100, top=25"; 

	var strUrl="https://__server__/?Network=GreenLight&ID=getCachedWidget&DocumentID=77NaWu0FhKDKXL7C70JpnKmy&Widget=Printer Wrapper";
	var strDoc=getxmlHttpRequest(strUrl);
	strDoc +=strContent;
	strDoc +="</body></html>"

	var docprint=window.open("","",disp_setting); 
	docprint.document.open(); 
	//docprint.document.write('<html><head><title>Aspect Software</title>'); 
	//docprint.document.write('</head><body onLoad="self.print()"><center>');          
	//docprint.document.write(strContent);          
	//docprint.document.write('</center></body></html>'); 
	docprint.document.write(strDoc); 
	docprint.document.close(); 
	docprint.focus(); 
}

//Initializes all custom controls in a document by iterating through each form
//An initialized attribute is used to determine if controls have already been initialized to avoid initializing them twice
function initializeCustomControls() 
{
	for (var cntrForm=0;cntrForm<document.forms.length;cntrForm++) {
		var f=document.forms[cntrForm];
		for (var cntrNode=0;cntrNode<f.elements.length;cntrNode++) {
			var n=f.elements[cntrNode];
			var inputtype=n.getAttribute("control");
			var initialized=n.getAttribute("initialized");
			
			//04-24-2013 - Calendar icons are initialized a number of times when the page is loaded.  For some reason,
			//the control is not initialized properly until the last call.  This function has been modified to 
			//initialize the control during each call.  The previous icon is removed before a new one is created
			//if ((inputtype) && (!initialized)) {
			if (inputtype){
				if (inputtype.equalsIgnoreCase("date")) {
					if((f.name) && (n.name) && (f.name.length>0) && (n.name.length>0)) {
						//remove the current icon if there is one
						var sTcalicon=n.getAttribute("tcalicon");
						if(sTcalicon) {
							var eTcalicon=document.getElementById(sTcalicon);
							if(eTcalicon) eTcalicon.parentNode.removeChild(eTcalicon);
						};
						
						var t=new tcal({formname:f.name,controlname:n.name});
						//appendToLog("Initialize calendar form:"+f.name+" name:"+n.name+" id="+t.e_icon.id,false,true);
						n.setAttribute("tcalicon",t.e_icon.id);
					}
					else {
						appendToLog("Missing form or element name in date control",false,true);
					};
				}
				else if (inputtype.equalsIgnoreCase("combobox")) {
					new comboBox(f.name,"ComboBox"+n.name,n.name);
				};
				n.setAttribute("initialized","true");
			};
		};
	};
};

/******************************************************************************
Shows or hides a table message
******************************************************************************/
function showTableMessage(sTableID,sMessage,bShow)
{
	if(sTableID.length==0) {
		alert("No TableID in showTableMessage");
		return;
	};

	var eDiv=document.getElementById("div"+sTableID);
	var eTable=document.getElementById(sTableID);

	//abort if messages are disabled for the table
	var s=eTable.getAttribute("aspectmessages");
	if((s) && (s.equalsIgnoreCase("false"))) return;
	
	//don't display a message if the table is not visible.  
	if(eDiv.offsetWidth*eDiv.offsetHeight==0) return

	var divMessage=document.getElementById(sTableID+"Message");
	
	if(bShow==false) {
		if(divMessage) setVisible(divMessage,false);
		return;
	};

	//create the message div if it doesn't already exist
	if(!divMessage) {
		divMessage=document.createElement("div");
		divMessage.id=sTableID+"Message";
		divMessage.className="tablemessage";
		eDiv.appendChild(divMessage);
	}
	else {
		divMessage.innerHTML="";
	};

	var t=document.createTextNode(sMessage);
	divMessage.appendChild(t);

	//add progress bar
	var divProgressContainer=document.createElement("div");
	var eProgress=document.createElement("Progress");
	eProgress.style.width="100%";
	divProgressContainer.appendChild(eProgress);
	divMessage.appendChild(divProgressContainer);

	setVisible(divMessage,true);

	var xy=getPosition2012(eTable,"absolute",eDiv);

	//position the message in the center of the table
	//but not more than 200 px to the right of the left side of the table
	var Middle=eTable.offsetWidth/2;
	var Left=Middle - (divMessage.offsetWidth/2);
	Left=Math.min(Left,200);
	divMessage.style.left=Left+"px";

	//position the message 40px down from the top of the table
	divMessage.style.top=(xy[1]+80)+"px";
};


/*******************************************************************************
Called to refresh records in a table at some interval.  Records are merged into the table
rather than refreshing the whole table.  Can also be used to refresh a table that does
not have an interval set.  For example, if a new record is added to a driver, this 
function can be called to add the record to a table.
*******************************************************************************/
function refreshTableOnInterval(TableID,IsRefreshed) {
	var Debug=false;
	
	var eTable=document.getElementById(TableID);
	if(!eTable) return;

	//note: the interval may not be defined.  	
	var iInterval=parseInt(eTable.getAttribute("AspectActiveRefreshInterval"));
	if(isNaN(iInterval)) iInterval=0;

	var bRefreshWhenHidden=false;
	if(eTable.getAttribute("AspectActiveRefreshWhenHidden")) {
		bRefreshWhenHidden=eTable.getAttribute("AspectActiveRefreshWhenHidden").equalsIgnoreCase("true");
	};

	if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval started TableID="+TableID+" iInterval="+iInterval+" IsRefreshed="+IsRefreshed);

	if(IsRefreshed) {
		var eDestTable=document.getElementById(TableID)
		var eTable=document.getElementById(TableID+"intervalrefresh");
		if(!eTable) {
			if(Debug) appendToLog("Could not locate table: "+TableID+"intervalrefresh to refresh content");
			setTimeout("refreshTableOnInterval(\x22"+TableID+"\x22)",iInterval);
			return;
		};
		//appendToLog("got refreshed content Len="+eTable.innerHTML.length);
		//for(var i=0;i<eTable.rows[2].cells.length;i++) {
		//	appendToLog("Cell "+i+"="+eTable.rows[2].cells[i].innerHTML);
		//};
		
		var bMerge=true;
		
		//don't merge if the table is  currently being refreshed
		if(eDestTable.getAttribute("Loading")=="true") bMerge=false;
		
		//don't merge if the crc value for the table has not changed
		var SrcTableCRC="";
		var eSrcTableCRC=document.getElementById(TableID+"intervalrefreshCRC");
		if((eSrcTableCRC) && (iInterval>0)) {
			SrcTableCRC=eSrcTableCRC.innerHTML;
			var DestTableCRC=eDestTable.getAttribute("TableCRC");
			if(DestTableCRC) {
				if(SrcTableCRC==DestTableCRC) {
					if(Debug) appendToLog("Not updating table because CRC values match");

					//update the span containing the time the table was generated
					setTableUpdateTime(eDestTable);

					eDestTable.setAttribute("TimeLastRefreshedOnInterval",new Date().getTime());
					if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval SrcTableCRC="+SrcTableCRC+" DestTableCRC="+DestTableCRC);

					if(iInterval>0) {
						if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval isRefreshed setting timeout because CRC matches");
						setTimeout("refreshTableOnInterval(\x22"+TableID+"\x22)",iInterval);
					};

					if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval returns from IsRefreshed section");
					return;
				}
				else {
					if(Debug) appendToLog("CRC values are different for "+TableID);
				};
			}
			else {
				if(Debug) appendToLog("Cannot locate crc for destination table");
			};
		}
		else {
			if(Debug) appendToLog("Cannot locate table crc in "+TableID+"intervalrefreshCRC");
		};
		
		//don't merge if the crc for the  display options is different from those in the original table
		var sCRCNow=eTable.getAttribute("aspectDisplayOptionsCRC");
		var sCRCOriginal=eDestTable.getAttribute("aspectDisplayOptionsCRC");
		if(sCRCNow!=sCRCOriginal) {
			if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval Not refreshing table because crc for display options is different");
			bMerge=false;
		};
		
		if((bMerge) || (iInterval==0)) {
			if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval Merging table");
			mergeTable2012(TableID,TableID+"intervalrefresh");
			
			//update the span containing the time the table was generated
			setTableUpdateTime(eDestTable);

			highlightSubtotals(eDestTable,false);

			//call the listener function if one is defined
			var s="tableRefreshedOnInterval"+TableID;
			if(eval('typeof '+s)=="function") {
				if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval Calling listener function: "+s);
				eval(s+"('"+TableID+"')");
			}
			else {
				if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval NOT Calling listener function: "+s);
			};
		};

		eDestTable.setAttribute("TableCRC",SrcTableCRC);
		eDestTable.setAttribute("TimeLastRefreshedOnInterval",new Date().getTime());

		//only set the timeout if a refreshInterval is specified.  This function can also be called manually 
		//to refresh a table and it should not continue to refresh if that is the case
		if(iInterval>0) {
			if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval setting timeout for "+TableID+" iInterval="+iInterval);
			setTimeout("refreshTableOnInterval(\x22"+TableID+"\x22)",iInterval);
		};

		if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval returns from IsRefreshed section");
		return;
	};
	
	if((bRefreshWhenHidden) || (isVisible(eTable))) 
	{
		//make sure enough time has elapsed.  The javascript timer is unreliable
		var iElapsed=(eTable.getAttribute("TimeLastRefreshedOnInterval")) ? new Date().getTime()-parseInt(eTable.getAttribute("TimeLastRefreshedOnInterval")) : iInterval;
		//appendToLog("iElapsed="+iElapsed+" iInterval="+iInterval);
		if(iElapsed<iInterval) {
			if(Debug) appendToLog("Aborting refreshTableOnInterval because time elapsed="+new Date().getTime()-t<iInterval);
			setTimeout("refreshTableOnInterval(\x22"+TableID+"\x22)",1000);
			return;
		};

		//appendToLog("Refreshing table: "+TableID);
		///if the table has already been refreshed, get the url that was calculated to do the refreshing
		var sSavedUrl=eTable.getAttribute("RefreshOnIntervalUrl");
		/*
		This is a good idea, but has problems.  For one thing, external driver params and filters are not reflected in the table
		This was disabled on 7/24/15 because the Waste Count List table was not refreshing properly with it enabled.
		*/
		/**************
		if(sSavedUrl) {
			var iStartRecord=parseInt(eTable.getAttribute("aspectstartrecord"));
			sSavedUrl +="&StartRecord="+iStartRecord;
			var sFunc="refreshTableOnInterval(\x22"+TableID+"\x22,true)";
//appendToLog("Updating table using saved url: "+sSavedUrl);
			asynchInclude(document.getElementById("TableRefreshDiv"+TableID),sSavedUrl,sFunc,sFunc);
			return;
		};
		***************/

		//add the start record.  This is not saved in the url
		sUrl +="&StartRecord="+iStartRecord;
		
		var e=document.getElementById("SelectDisplay1"+TableID);
		ADisplayID=(e) ? e.value : "";

		var eDiv=document.getElementById("div"+TableID);
		var iMaxRecords=parseInt(eTable.getAttribute("aspectmaxrecords"));
		var iStartRecord=parseInt(eTable.getAttribute("aspectstartrecord"));

		//construct a driver include tag to be processed by the server
		var sHashID=eTable.getAttribute("aspectHashID");
		var sDocumentID="";
		var sWidget="";

		//The DriverID is recorded in the table as well as a DriverStructID.  The DriverStructID is the driver that was actually used in creating the table.
		//It is normally the same as the Driver ID.  However, it can be different if the driver is opened using a script driver.  The include tag used to create the table will 
		//contain the original driver ID but TCacheDriver routine needs to know the structure used by the final driver so it can transfer and read/write data.
		var sDriverID="";
		var sDriverStructID="";

		//add the attributes for the table to an array.  The array will be sorted to avoid creating duplicate TCacheObj entries for the same display
		var arParams=new Array();
		
		//add an attribute indicating that this is a call to refresh a table.  TAspectDriver.exportToHtml() uses this to avoid creating an edit dialog
		arParams[arParams.length]="REFRESHONINTERVAL: \x22true\x22;";
		var sState="";
		
		var bSystemDriver=false;
		var bKeepDriver=false;
		var sParamsActive="";
		for (var i=0;i<eTable.attributes.length;i++) {
			var sName=eTable.attributes.item(i).nodeName;
			if(sName.startsWith("aspect")) {
				sName=sName.substring(6);
				if((sName.equalsIgnoreCase("RefreshInterval")) || (sName.equalsIgnoreCase("RefreshWhenHidden")) ||
					(sName.equalsIgnoreCase("RefreshIntervalRemote")) || (sName.equalsIgnoreCase("RefreshWhenHiddenRemote"))) {
					//ignore
				}
				else if(sName.equalsIgnoreCase("FieldPattern")) {
					//ignore 
				}
				else if(sName.equalsIgnoreCase("ID")) {
					//don't pass the table ID to avoid creating unncessary TCacheObj
					// - Do need to pass the ID in case a specified ID is defined.  This may be necessary to avoid a conflict with another element's ID
					// since the driver ID is used when an ID is not specified and the driver ID could be the same as the ID of another html element
					arParams[arParams.length]=sName+": \x22"+TableID+"intervalrefresh"+"\x22;";
				}
				else if(sName.equalsIgnoreCase("DisplayID")) {
					if(ADisplayID.length==0) arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
				}
				else if(sName.equalsIgnoreCase("Driver")) {
					sDriverID=eTable.attributes.item(i).nodeValue;
				}
				else if(sName.equalsIgnoreCase("DriverStructID")) {
					sDriverStructID=eTable.attributes.item(i).nodeValue;
				}
				else if(sName.equalsIgnoreCase("SystemDriver")) {
					bSystemDriver=boolVal(eTable.attributes.item(i).nodeValue);
					arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
				}
				else if(sName.equalsIgnoreCase("KeepDriver")) {
					bKeepDriver=boolVal(eTable.attributes.item(i).nodeValue);
					arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
				}
				else if (sName.equalsIgnoreCase("StartRecord")) {
					//arParams[arParams.length]=sName+": \x22"+iStartRecord+"\x22;";
				}
				else if(sName.equalsIgnoreCase("DocumentID")) {
					sDocumentID=eTable.attributes.item(i).nodeValue;
				}
				else if(sName.equalsIgnoreCase("Widget")) {
					sWidget=eTable.attributes.item(i).nodeValue;
				}
				else if(sName.equalsIgnoreCase("ContainerItemID")) {
					sContainerItemID=eTable.attributes.item(i).nodeValue;
					//add the container ID to the include tag to maintain compatibility with the original
					//Widget Container 
					arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
				}
				else if(sName.equalsIgnoreCase("State")) {
					sState=eTable.attributes.item(i).nodeValue;
					sState=replaceAllSubstrings(sState,"\x27","%"+"27");
					sState=replaceAllSubstrings(sState,"\x23","%"+"23");
					sState=replaceAllSubstrings(sState,"\x28","%"+"28");
					sState=replaceAllSubstrings(sState,"\x29","%"+"29");
					sState=replaceAllSubstrings(sState,"\x2F","%"+"2F");
					sState=replaceAllSubstrings(sState,"\x5C","%"+"5C");
					arParams[arParams.length]=sName+": \x22"+sState+"\x22;";
				}
				else if(sName.equalsIgnoreCase("ParamsActive")) {
					sParamsActive=eTable.attributes.item(i).nodeValue;
					arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
				}
				else if(sName.equalsIgnoreCase("ExternalParams")) {
					//include the original externalparams value
					arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
					
					//add an XExternalParamXXX argument for each external parameter
					if(eTable.attributes.item(i).nodeValue!=null) {
						if(eTable.attributes.item(i).nodeValue.length>0) {
							var arExternalParam=getSubStringArray(eTable.attributes.item(i).nodeValue,",",true);
							if(arExternalParam!=null) {
								for (var j=0;j<arExternalParam.length;j++) {
									var eExternalParam=document.getElementById(arExternalParam[j]);
									if(eExternalParam) {
										var sExternalParam=eExternalParam.getAttribute("param");
										var sExternalParamValue="";
										(eExternalParam.type=="checkbox") ? sExternalParamValue=(eExternalParam.checked) : sExternalParamValue=eExternalParam.value;
										arParams[arParams.length]="XExternalParam"+arExternalParam[j]+": \x22"+sExternalParam+"^"+sExternalParamValue+"\x22;";
										//appendToLog("Adding external param: "+arParams[arParams.length-1],false,true);
									}
									else {
										appendToLog("Cannot locate external driver param with ID="+arExternalParam[j]+" in refreshTable()",false,true);
									};
								};
							};
						};
					};
				}
				else {
					arParams[arParams.length]=sName+": \x22"+replaceAllSubstrings(eTable.attributes.item(i).nodeValue,"\x23","//ha"+"sh//")+"\x22;";
				};
			};
		};

		//Use the actual driver ID if one was supplied in DriverStructID.  This is to handle drivers opened using a script in which case the driver ID returned by the script
		//may be different than the original driver ID.  However, use the same ID if it's a system driver because the driver ID in the include tag and the actual driver ID
		//will always be different.
		
		//The KeepDriver argument can also be used to cause the original driver to be used instead of the one in DriverStructID.
		//An example of this is in the POS Viewer which uses Aspect_BackOffice_POSViewer as the driver.  Any number of other drivers might actually
		//be used to create the table depending on the pos and data type.  The KeepDriver argument is used to make sure that Aspect_BackOffice_POSViewer
		//is used as the driver when the table is refreshed.  This became an issue with the Micros E7 interface when temporary system drivers were
		//returned by the call to openDriver in the pos interface.  These system drivers are no longer available when the table is refreshed and
		//a call to Aspect_BackOffice_POSViewer is required.
		((sDriverStructID.length>0) && (bSystemDriver==false) && (bKeepDriver==false) && (sDriverStructID.equalsIgnoreCase("ConsDriverVert")==false) && (sDriverStructID.equalsIgnoreCase("ConsDriverHorz")==false)) ? arParams[arParams.length]="Driver: \x22"+sDriverStructID+"\x22;" : arParams[arParams.length]="Driver: \x22"+sDriverID+"\x22;";

		//add current display settings
		var bPreserveSettings=true;
		if(bPreserveSettings) {
			var sFilterOptions=getDisplayFormValues(TableID);
			if(sFilterOptions.length>0) {
				var arFilterOptions=getSubStringArray(sFilterOptions,"|",false);
				for(var i=0;i<arFilterOptions.length;i++) {
					var n=arFilterOptions[i].indexOf("=");
					var sName=arFilterOptions[i].substring(0,n);
					if(sName.toUpperCase().startsWith("FIELD_")) sName=sName.substring(6);
					var sValue=arFilterOptions[i].substring(n+1);
					arParams[arParams.length]="XDisplay"+sName+": \x22"+replaceAllSubstrings(sValue,"#","//ha"+"sh//")+"\x22;";
				};
			};
		}
		else {
			//get external filters - These need to be included when a table is refreshed by pressing the refresh button 
			var sExternalFilters=getExternalFilters(TableID);
			if(sExternalFilters.length>0) {
				var arExternalFilters=getSubStringArray(sExternalFilters,"|",false);
				for(var i=0;i<arExternalFilters.length;i++) {
					var n=arExternalFilters[i].indexOf("=");
					var sName=arExternalFilters[i].substring(0,n);
					var sValue=arExternalFilters[i].substring(n+1);
					arParams[arParams.length]="XDisplay"+sName+": \x22"+replaceAllSubstrings(sValue,"#","//ha"+"sh//")+"\x22;";
				};
			};
		};
		
		//add state tag
		//07-24-2015 - This was modified to set driver params before the state expression is evaluated.    This was necessary when dependent drivers
		//were introduced because the state tag of a dependent driver will often rely on values passed in the driver params like dates, store ID's and such.
		//The state expression now looks like:
		//	setConstant(Param1,Value1)+setConstant(Param2,Value2)+setConstant(Paramn,Valuen)+State Expression
		
		var s="";
		if(sState.length>0) {
			s+="<"+"state"+">";
			var sExpression="";
			if(sParamsActive.length>0) {
				var a=getSubStringArray(sParamsActive,"|",false);
				for(var i=0;i<a.length;i++) {
					var n=a[i].indexOf("=");
					if(n>=0) {
						var sName=a[i].substring(0,n);
						var sValue=a[i].substring(n+1);
						if("KEYEXPRESSION|CACHETTL|METADATA".indexOf(sName.toUpperCase())<0) {
							if(sExpression.length>0) sExpression +="+";
							sExpression +="setConstant(\x22#"+sName+"\x22,\x22"+sValue+"\x22)"
						};
					};
				};
			};
			if(sExpression.length>0) sExpression +="+";
			sState=replaceAllSubstrings(sState,"%"+"2B","+");
			sExpression +=sState;
			sExpression=replaceAllSubstrings(sExpression,"\x27","%"+"27");
			sExpression=replaceAllSubstrings(sExpression,"\x23","%"+"23");
			sExpression=replaceAllSubstrings(sExpression,"\x28","%"+"28");
			sExpression=replaceAllSubstrings(sExpression,"\x29","%"+"29");
			sExpression=replaceAllSubstrings(sExpression,"\x2F","%"+"2F");
			sExpression=replaceAllSubstrings(sExpression,"\x5C","%"+"5C");
			s +="<"+"include type:expression; expression:"+sExpression+">\r\n";
//			s+="Debug=true\r\n";
			s+="<"+"/state"+">";
		};

		arParams.sort();
		s+="<"+"include ";
		for(var i=0;i<arParams.length;i++) {
			s +=" "+arParams[i]+"\r\n";
		};
		s+=">";

		//appendToLog("Submitting include tag: "+s,true,true);
		//for (var i=0;i<arParams.length;i++) appendToLog("Param["+i+"]="+arParams[i]);
		
		var sUrl=getServer()+"/?Network=GreenLight&ID=processContainerItem&Content="+s
		sUrl=sUrl + "&DocumentID="+sDocumentID+"&Widget="+sWidget+"&ContainerItemID="+sContainerItemID;
		sUrl +="&Source="+sHashID;
		sUrl +="&RefreshTableOnInterval=true"
		
		//add a flag used to indicate this is a request to refresh a table on an interval.  This gives a chance to ignore the request
		//if Aspect is too busy.  

		//add params passed to the page when the driver was created.  These are recorded in a div when the table is created
		var ePageArgs=document.getElementById("div"+TableID+"pageargs");
		if(ePageArgs) {
			var sOmit="|NETWORK|ID|DOCUMENTID|WIDGET|CONTAINERITEMID|SOURCE";
			var arPageArgs=getSubStringArray(ePageArgs.innerHTML,"~",false);
			for(var i=0;i<arPageArgs.length;i++) {
				var n=arPageArgs[i].indexOf("=");
				if(n>=0) {
					var sName=arPageArgs[i].substring(0,n);
					if(sOmit.indexOf("|"+sName.toUpperCase())<0) {
						sUrl +="&"+arPageArgs[i];
						//appendToLog("Added pagearg: "+arPageArgs[i]+" n="+n+" sName="+sName);
					}
					else {
						//appendToLog("Omitted pagearg: "+arPageArgs[i]);
					};
				};
			};
		};
		
		//create a div used to hold the refreshed table.  This is a hidden div.  The table will be updated by merging records from the
		//updated table in the hidden div into the original table
		var sHiddenDivID="TableRefreshDiv"+TableID;
		var eRefreshDiv=document.getElementById(sHiddenDivID);
		if(!eRefreshDiv) {
			eRefreshDiv=document.createElement("div");
			eRefreshDiv.setAttribute("id",sHiddenDivID);
			eRefreshDiv.id=sHiddenDivID;
			eRefreshDiv.style.display="none";
			document.body.appendChild(eRefreshDiv);
		};
		
//var sDebug=replaceAllSubstrings(sUrl,"&","<br>"); 
//sDebug=replaceAllSubstrings(sDebug,"\r\n","%"); 
//sDebug=replaceAllSubstrings(sDebug,"<","["); 
//sDebug=replaceAllSubstrings(sDebug,">","]"); 
//showDialog('msg='+sDebug+"&fnOk=close&width=800&height=800");

		//record the url in the table attributes so it doesn't have to be created again the enxt time
		eTable.setAttribute("RefreshOnIntervalUrl",sUrl);

		//add the start record.  This is not saved in the url
		sUrl +="&StartRecord="+iStartRecord;

		var sFunc="refreshTableOnInterval(\x22"+TableID+"\x22,true)";
		if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval1 calling asynchinclude");
		asynchInclude(eRefreshDiv,sUrl,sFunc,sFunc);
	}
	else {
		if(iInterval>0) {
			if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval first entry setting timeout because not visible");
			setTimeout("refreshTableOnInterval(\x22"+TableID+"\x22)",iInterval);
		}
		else {
			if(bEnableSubmissionDebugging) appendToSubmitLog("refreshTableOnInterval first entry NOT setting timeout because interval=0");
		};
	};
};

/******************************************************************************
Refreshes the table with the given ID.  This routine is called from a number of sources:
- By paging buttons in the table controls (first, last, next and previous)
- By the refresh button next to the paging buttons
- When a new display is selected above the table
- When okay is pressed on the display dialog

The direction is prev, next, first, last when called by a paging button.  It is 'refresh' all other times.

The DisplayID is blank except when called due to a change in either the selection above the table
or when the okay button is pressed on the display dialog.

If bPreserveSettings is true, the options currently selected for the display
will remain in effect, overriding the saved display.  
******************************************************************************/
function refreshTable(sTableID,sDirection,ADisplayID,bPreserveSettings,b,RefreshID)
{
	//appendToLog("refreshTable: "+sTableID+" b="+b);
	//if(!b) printStackTrace();
	var eTable=document.getElementById(sTableID);

	//abort if table is not found
	if(!eTable) {
		printStackTrace();
		return;
	};

	var eDiv=document.getElementById("div"+sTableID);

	//abort if surrounding div is not found
	if(!eDiv) {
		alert("refreshTable() cannot locate table div with ID=div"+sTableID);
		printStackTrace();
		return;
	};

	if(b) {
		appendToLog("Setting display for table: "+sTableID+"=table-row-group");
		eTable.tBodies[0].style.display="table-row-group";
		//appendToLog("Confirm display for table: "+sTableID+"="+eTable.style.display);
		
		enableExternalFilters(sTableID,true);
		enableExternalParams(sTableID,true);
		initializeTabbedDialogs(); //initialize tabs in the display dialog

		//update the span containing the time the table was generated
		setTableUpdateTime(eTable);
		
		//call the listener function if one is defined
		var s="tableRefreshed"+sTableID;
		if(eval('typeof '+s)=="function") eval(s+"('"+sTableID+"')");

		return;
	};

	//hide dialog
	var sDialogID=eTable.getAttribute("EditDialogID");
	if(sDialogID) setVisible(sDialogID,false);

	//remove existing chart if there is one.  This is necessary because the chart is moved from the original div and
	//appended to the body when it is displayed.  If it is not removed, there will be two charts with the same ID 
	//after the table is refreshed
	var eChart=document.getElementById("chart"+sTableID);
	if(eChart) eChart.parentNode.removeChild(eChart);

	var eGoogleChartData=document.getElementById("googlechartdata"+sTableID);
	if(eGoogleChartData) eGoogleChartData.parentNode.removeChild(eGoogleChartData);

	var eGoogleChartOutputWrapper=document.getElementById("googlechartoutputwrapper"+sTableID);
	if(eGoogleChartOutputWrapper) eGoogleChartOutputWrapper.parentNode.removeChild(eGoogleChartOutputWrapper);

	var eChartDiv=document.getElementById(sTableID+"Chart");
	if(eChartDiv) setVisible(eChartDiv,false);

	//if sDirection and ADisplayID are not defined, assume it's from an external filter.  This is used below to get the filter options
	//from the current display rather than loading the original display options, as if bPreserveSettings had been set to true
	var bUpdateFromExternalFilter=(!sDirection) && (!ADisplayID);
	
	//Get default values for direction and display ID if not specified.  This allows an external filter to refresh the
	//table by calling refreshTable(TableID)
	if(!sDirection) sDirection="refresh";
	if(!ADisplayID) {
		var e=document.getElementById("SelectDisplay1"+sTableID);
		ADisplayID=(e) ? e.value : "";
	};
	
	//alert("refreshTable TableID="+sTableID+" Direction="+sDirection+" DisplayID="+ADisplayID);

	//appendToLog("refreshTable "+sTableID);
	if(sTableID.length==0) {
		alert("No TableID in refreshTable");
		return;
	};

	//abort if table is not found
	if(!eTable) {
		alert("Cannot locate table with ID="+sTableID);
		return;
	};
	
	//abort if table is currently being refreshed
/*	
	if(eTable.getAttribute("Loading")=="true") {
		//alert("Already loading.  Table ID: "+sTableID);
		var sFunc="";
		if(bPreserveSettings!=undefined) {
			sFunc="refreshTable('"+sTableID+"','"+sDirection+"','"+ADisplayID+"',"+bPreserveSettings+")";
		}
		else if(ADisplayID!=undefined) {
			sFunc="refreshTable('"+sTableID+"','"+sDirection+"','"+ADisplayID+"')";
		}
		else if(sDirection!=undefined) {
			sFunc="refreshTable('"+sTableID+"','"+sDirection+"')";
		}
		else {
			sFunc="refreshTable('"+sTableID+"')";
		};
		
		appendToLog("already loading.  sFunc="+sFunc);
		setTimeout(sFunc,1000);
		return;
	};
*/	

	//apply overlay
	applyOverlay(eDiv);
	//applyOverlay(eTable);
	
	//show progress bar
	//don't show progress bar if one has already been added to the table.  This is a quick fix
	//for invoice details which appear to refresh the table twice when the invoice is opened
	if(eTable.getAttribute("Loading")!="true") { 
		var divProgressContainer=document.createElement("div");
		divProgressContainer.setAttribute("class","table_refreshing");
		var eProgress=document.createElement("Progress");
		eProgress.style.width="250px";
		divProgressContainer.appendChild(eProgress);
		eDiv.insertBefore(divProgressContainer,eDiv.childNodes[0]); 
	 };
	 
	enableExternalFilters(sTableID,false);
	enableExternalParams(sTableID,false);
	
	//disable inputs in table cells
	eTable.setAttribute("Loading","true");
	for(var row=1;row<eTable.rows.length;row++) {
		var eRow=eTable.rows[row];
		for(var col=0;col<eRow.cells.length;col++) {
			var eCell=eRow.cells[col];
			//eCell.style.background="#eeeeee";
			for(var child=0;child<eCell.childNodes.length;child++) {
				var e=eCell.childNodes[child];
				if(e.nodeName.equalsIgnoreCase("input")) {
					e.disabled=true;
				};	
			};
		};
	};

	//set starting record
	var iStartRecord=0;
	if(sDirection) {
		var iMaxRecords=parseInt(eTable.getAttribute("aspectmaxrecords"));
		var iStartRecord=parseInt(eTable.getAttribute("aspectstartrecord"));
		if(sDirection.equalsIgnoreCase("first")) {
			iStartRecord=0;
		}
		else if(sDirection.equalsIgnoreCase("prev")) {
			iStartRecord=iStartRecord -=iMaxRecords;
			if(iStartRecord<0) iStartRecord=0;
		}
		else if(sDirection.equalsIgnoreCase("next")) {
			iStartRecord +=iMaxRecords;
		}
		else if(sDirection.equalsIgnoreCase("last")) {
			iStartRecord="Last";
		}
		else if(sDirection.equalsIgnoreCase("refresh")) {
			//start record remains the same
		};
	};

	//construct a driver include tag to be processed by the server
	var sHashID=eTable.getAttribute("aspectHashID");
	var sDocumentID="";
	var sWidget="";

	//The DriverID is recorded in the table as well as a DriverStructID.  The DriverStructID is the driver that was actually used in creating the table.
	//It is normally the same as the Driver ID.  However, it can be different if the driver is opened using a script driver.  The include tag used to create the table will 
	//contain the original driver ID but TCacheDriver routine needs to know the structure used by the final driver so it can transfer and read/write data.
	var sDriverID="";
	var sDriverStructID="";

	//add the attributes for the table to an array.  The array will be sorted to avoid creating duplicate TCacheObj entries for the same display
	var arParams=new Array();
	
	//add a display ID if one was passed to this function.  This means a display was selected from above
	//the table or Ok was pressed on the display dialog
	if(ADisplayID.length>0) arParams[arParams.length]="DisplayID:\x22"+ADisplayID+"\x22;";

	var sState="";
	
	var bSystemDriver=false;
	var bKeepDriver=false;
	var sParamsActive="";
	for (var i=0;i<eTable.attributes.length;i++) {
		var sName=eTable.attributes.item(i).nodeName;
		if(sName.startsWith("aspect")) {
			sName=sName.substring(6);
			if(sName.equalsIgnoreCase("FieldPattern")) {
				//ignore 
			}
			else if(sName.equalsIgnoreCase("FilterActive")) {
				//ignore 
			}
			else if(sName.equalsIgnoreCase("allfieldid")) {
				//ignore 
			}
			else if(sName.equalsIgnoreCase("allfieldpattern")) {
				//ignore 
			}
			else if(sName.equalsIgnoreCase("allfieldtype")) {
				//ignore 
			}
			else if(sName.equalsIgnoreCase("displayoptionscrc")) {
				//ignore 
			}
			else if(sName.equalsIgnoreCase("ID")) {
				//Passing the ID causes another TCacheObj to be created but needs to be done because
				//the ID is part of the driver include tag.
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if(sName.equalsIgnoreCase("DisplayID")) {
				if(ADisplayID.length==0) arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if(sName.equalsIgnoreCase("Driver")) {
				sDriverID=eTable.attributes.item(i).nodeValue;
			}
			else if(sName.equalsIgnoreCase("DriverStructID")) {
				sDriverStructID=eTable.attributes.item(i).nodeValue;
			}
			else if(sName.equalsIgnoreCase("SystemDriver")) {
				bSystemDriver=boolVal(eTable.attributes.item(i).nodeValue);
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if(sName.equalsIgnoreCase("KeepDriver")) {
				bKeepDriver=boolVal(eTable.attributes.item(i).nodeValue);
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if (sName.equalsIgnoreCase("StartRecord")) {
				arParams[arParams.length]=sName+": \x22"+iStartRecord+"\x22;";
			}
			else if(sName.equalsIgnoreCase("DocumentID")) {
				sDocumentID=eTable.attributes.item(i).nodeValue;
			}
			else if(sName.equalsIgnoreCase("Widget")) {
				sWidget=eTable.attributes.item(i).nodeValue;
			}
			else if(sName.equalsIgnoreCase("ContainerItemID")) {
				sContainerItemID=eTable.attributes.item(i).nodeValue;
				//add the container ID to the include tag to maintain compatibility with the original
				//Widget Container 

				//11-29-15: removed this because it 
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if(sName.equalsIgnoreCase("State")) {
				sState=eTable.attributes.item(i).nodeValue;
				sState=replaceAllSubstrings(sState,"\x27","%"+"27");
				sState=replaceAllSubstrings(sState,"\x23","%"+"23");
				sState=replaceAllSubstrings(sState,"\x28","%"+"28");
				sState=replaceAllSubstrings(sState,"\x29","%"+"29");
				sState=replaceAllSubstrings(sState,"\x2F","%"+"2F");
				sState=replaceAllSubstrings(sState,"\x5C","%"+"5C");
				//arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
				arParams[arParams.length]=sName+": \x22"+sState+"\x22;";
			}
			else if(sName.equalsIgnoreCase("ParamsActive")) {
				sParamsActive=eTable.attributes.item(i).nodeValue;
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if(sName.equalsIgnoreCase("ExternalParams")) {
				//include the original externalparams value
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
				
				//add an XExternalParamXXX argument for each external parameter
				if(eTable.attributes.item(i).nodeValue!=null) {
					if(eTable.attributes.item(i).nodeValue.length>0) {
						var arExternalParam=getSubStringArray(eTable.attributes.item(i).nodeValue,",",true);
						if(arExternalParam!=null) {
							for (var j=0;j<arExternalParam.length;j++) {
//console.log("getting external param: "+arExternalParam[j]);
								var eExternalParam=document.getElementById(arExternalParam[j]);
								if(eExternalParam) {
//console.log("found param");
									var sExternalParam=eExternalParam.getAttribute("param");
									if(!sExternalParam) {
										console.log("ERROR: Param attribute not found for external param: "+arExternalParam[j]);
									};
									var sExternalParamValue="";
									if(eExternalParam.nodeName=="DATALIST") {
										var einput=document.getElementById(arExternalParam[j]+"_input_submit");
										if(einput) sExternalParamValue=einput.value;
									}
									else if(eExternalParam.type=="select-multiple") {
										var sValue="";
										for(var k=0;k<eExternalParam.options.length;k++) {
											if(eExternalParam.options[k].selected) {
												if(sValue.length>0) sValue+=",";
												sValue+=eExternalParam.options[k].value;
											};
										};
										sExternalParamValue=sValue;
									}
									else {
										(eExternalParam.type=="checkbox") ? sExternalParamValue=(eExternalParam.checked) : sExternalParamValue=eExternalParam.value;
									};
									arParams[arParams.length]="XExternalParam"+arExternalParam[j]+": \x22"+sExternalParam+"^"+sExternalParamValue+"\x22;";
									//console.log("Adding external param: "+arParams[arParams.length-1],false,true);
								}
								else {
									console.log("ERROR: Cannot locate external driver param with ID="+arExternalParam[j]+" in refreshTable()",false,true);
								};
							};
						};
					};
				};
			}
			else {
				arParams[arParams.length]=sName+": \x22"+replaceAllSubstrings(eTable.attributes.item(i).nodeValue,"#","//ha"+"sh//")+"\x22;";
			};
		};
	};

	//Use the actual driver ID if one was supplied in DriverStructID.  This is to handle drivers opened using a script in which case the driver ID returned by the script
	//may be different than the original driver ID.  However, use the same ID if it's a system driver because the driver ID in the include tag and the actual driver ID
	//will always be different.
	
	//The KeepDriver argument can also be used to cause the original driver to be used instead of the one in DriverStructID.
	//An example of this is in the POS Viewer which uses Aspect_BackOffice_POSViewer as the driver.  Any number of other drivers might actually
	//be used to create the table depending on the pos and data type.  The KeepDriver argument is used to make sure that Aspect_BackOffice_POSViewer
	//is used as the driver when the table is refreshed.  This became an issue with the Micros E7 interface when temporary system drivers were
	//returned by the call to openDriver in the pos interface.  These system drivers are no longer available when the table is refreshed and
	//a call to Aspect_BackOffice_POSViewer is required.
	((sDriverStructID.length>0) && (bSystemDriver==false) && (bKeepDriver==false) && (sDriverStructID.equalsIgnoreCase("ConsDriverVert")==false) && (sDriverStructID.equalsIgnoreCase("ConsDriverHorz")==false)) ? arParams[arParams.length]="Driver: \x22"+sDriverStructID+"\x22;" : arParams[arParams.length]="Driver: \x22"+sDriverID+"\x22;";

	//add current display settings
//console.log("bPreserveSettings="+bPreserveSettings+" bUpdateFromExternalFilter="+bUpdateFromExternalFilter);
	if((bPreserveSettings) || (bUpdateFromExternalFilter)) {
		var sFilterOptions=getDisplayFormValues(sTableID);
		if(sFilterOptions.length>0) {
			var arFilterOptions=getSubStringArray(sFilterOptions,"|",false);
			for(var i=0;i<arFilterOptions.length;i++) {
				var n=arFilterOptions[i].indexOf("=");
				var sName=arFilterOptions[i].substring(0,n);
				if(sName.toUpperCase().startsWith("FIELD_")) sName=sName.substring(6);
				var sValue=arFilterOptions[i].substring(n+1);
				sValue=replaceAllSubstrings(sValue,"#","//ha"+"sh//");
				sValue=replaceAllSubstrings(sValue,"&","//a"+"mp//");
				arParams[arParams.length]="XDisplay"+sName+": \x22"+sValue+"\x22;";
				//arParams[arParams.length]="XDisplay"+sName+": \x22"+replaceAllSubstrings(sValue,"#","//ha"+"sh//")+"\x22;";
//console.log("Add param1: "+arParams[arParams.length-1]);
			};
		};
	}
	else {
		//get external filters - These need to be included when a table is refreshed by pressing the refresh button 
		var sExternalFilters=getExternalFilters(sTableID);
		if(sExternalFilters.length>0) {
			var arExternalFilters=getSubStringArray(sExternalFilters,"|",false);
			for(var i=0;i<arExternalFilters.length;i++) {
				var n=arExternalFilters[i].indexOf("=");
				var sName=arExternalFilters[i].substring(0,n);
				var sValue=arExternalFilters[i].substring(n+1);
				sValue=replaceAllSubstrings(sValue,"#","//ha"+"sh//");
				sValue=replaceAllSubstrings(sValue,"&","//a"+"mp//");
				arParams[arParams.length]="XDisplay"+sName+": \x22"+sValue+"\x22;";
//				arParams[arParams.length]="XDisplay"+sName+": \x22"+replaceAllSubstrings(sValue,"#","//ha"+"sh//")+"\x22;";
//console.log("Add param2: "+arParams[arParams.length-1]);
			};
		};
	};
	
	//add state tag
//appendToLog("State="+sState);	
	//06-26-2015 - This was modified to set driver params before the state expression is evaluated.    This was necessary when dependent drivers
	//were introduced because the state tag of a dependent driver will often rely on values passed in the driver params like dates, store ID's and such.
	//The state expression now looks like:
	//	setConstant(Param1,Value1)+setConstant(Param2,Value2)+setConstant(Paramn,Valuen)+State Expression
	
	var s="";
	if(sState.length>0) {
		s+="<"+"state"+">";
		var sExpression="";
		if(sParamsActive.length>0) {
			var a=getSubStringArray(sParamsActive,"|",false);
			for(var i=0;i<a.length;i++) {
				var n=a[i].indexOf("=");
				if(n>=0) {
					var sName=a[i].substring(0,n);
					var sValue=a[i].substring(n+1);
					if("KEYEXPRESSION|CACHETTL|METADATA".indexOf(sName.toUpperCase())<0) {
						if(sExpression.length>0) sExpression +="+";
						sExpression +="setConstant(\x22#"+sName+"\x22,\x22"+sValue+"\x22)";
					};
				};
			};
		};
		if(sExpression.length>0) sExpression +="+";
		sState=replaceAllSubstrings(sState,"%"+"2B","+");
		sExpression +=sState;
		sExpression=replaceAllSubstrings(sExpression,"\x27","%"+"27");
		sExpression=replaceAllSubstrings(sExpression,"\x23","%"+"23");
		sExpression=replaceAllSubstrings(sExpression,"\x28","%"+"28");
		sExpression=replaceAllSubstrings(sExpression,"\x29","%"+"29");
		sExpression=replaceAllSubstrings(sExpression,"\x2F","%"+"2F");
		sExpression=replaceAllSubstrings(sExpression,"\x5C","%"+"5C");
		
		//03-09-17 - Modified this to include values for external filters and driver params.
		//This was done to address a problem with tables included in dialogs.  If an external param is used to 
		//filter the dialog (e.g. filter invoice details to an invoice ID) the external param will not be correct
		//when moving from one dialog to another.  The invoice ID associated with the previous dialog would
		//still be included in the active driver params.
		
		//This state element is of little value for tables included in a dialog that use an external driver param.
		//The active driver params from the existing table will be included in the state when moving to a new dialog
		//with a new table.  For example, opening the dialog for record B after the dialog for record A has been opened
		//will include the active driver params from dialog A in the state expression for dialog B.  This doesn't hurt
		//anything since the current external params are also included below.  However, the cache will only have an 
		//effect when dialog B is opened after dialog A.  Opening dialog B after dialog C will use a different state 
		//expression.
		
		//In summary, adding the external driver params and filters serves the purpose of PREVENTING an invalid cache
		//operation.  The state element is useful for tables in general but it is less useful for tables included in 
		//dialogs.  Prehaps this can be improved to make the state expression work better in dialogs.
		
		s +="<"+"include type:expression; expression:"+sExpression+">\r\n";
		var sExternalFilters=getExternalFilters(sTableID);
		sExternalFilters=replaceAllSubstrings(sExternalFilters,"&","//a"+"mp//");
		s +="Filters: "+sExternalFilters+"\r\n";
		s +="DriverParams: "+getExternalDriverParams(sTableID)+"\r\n";
		s+="<"+"/state"+">";
		//console.log("state="+s);
	};

	arParams.sort();
	s+="<"+"include ";
	for(var i=0;i<arParams.length;i++) {
		s +=" "+arParams[i]+"\r\n";
	};
	s+=">";

	//appendToLog("Submitting include tag: "+s,true,true);
	//for (var i=0;i<arParams.length;i++) appendToLog("Param["+i+"]="+arParams[i]);
	
	//showTableMessage(sTableID,"Loading...",true);
console.log("refreshTable getServer="+getServer());
	var sUrl=getServer()+"/?Network=GreenLight&ID=processContainerItem&Content="+s;
	sUrl=sUrl + "&DocumentID="+sDocumentID+"&Widget="+sWidget+"&ContainerItemID="+sContainerItemID;
	sUrl +="&Source="+sHashID;
	
	//add params passed to the page when the driver was created.  These are recorded in a div when the table is created
	var ePageArgs=document.getElementById("div"+sTableID+"pageargs");
	if(ePageArgs) {
		var sOmit=new Array("USER-AGENT","NETWORK","ID","DOCUMENTID","WIDGET","CONTAINERITEMID","SOURCE");
		//appendToLog("innerhtml="+ePageArgs.innerHTML);
		var arPageArgs=getSubStringArray(ePageArgs.innerHTML,"~",false);
		for(var i=0;i<arPageArgs.length;i++) {
			var n=arPageArgs[i].indexOf("=");
			var s=arPageArgs[i].substring(0,n);
			//appendToLog("s="+s);
			if(sOmit.indexOf(s)<0) {
				sUrl +="&"+arPageArgs[i];
				//appendToLog("Added pagearg: "+arPageArgs[i]);
			};
		};
	};
	
	//sUrl=replaceAllSubstrings(sUrl,"\x22","%"+"22");
	var sDebug=replaceAllSubstrings(replaceAllSubstrings(sUrl,"<","["),">","]");
  //console.log("refreshDisplay sUrl="+sDebug,false,true);
	//console.log("getServer=["+getServer()+"]");
	//console.log("sUrl="+sUrl);
	//return;

	var sFunc="refreshTable(\x22"+sTableID+"\x22,\x22\x22,\x22"+ADisplayID+"\x22,"+bPreserveSettings+",true)";
	asynchInclude(eDiv,sUrl,sFunc,sFunc);
};

function exportTable(sTableID,ADisplayID,bPreserveSettings,sOutput)
{
	if(sOutput) {
		document.getElementById(sTableID).setAttribute("Exporting","false");
		showTableMessage(sTableID,"",false);
		if(true) {
			if (navigator.appName !='Microsoft Internet Explorer'){
				window.open('data:text/csv;charset=utf-8,' + escape(sOutput));
			}  else{
				var popup=window.open('','csv','');
				popup.document.write(sOutput);
			}
		};
		return;
	};

	var sDirection="first";
	
	if(!ADisplayID) {
		var e=document.getElementById("SelectDisplay1"+sTableID);
		ADisplayID=(e) ? e.value : "";
	};
	
	appendToLog("exportTable "+sTableID);
	if(sTableID.length==0) {
		alert("No TableID in exportTable");
		return;
	};

	var eDiv=document.getElementById("div"+sTableID);
	var eTable=document.getElementById(sTableID);

	//abort if surrounding div is not found
	if(!eDiv) {
		alert("Cannot locate table div with ID=div"+sTableID);
		return;
	};

	//abort if table is not found
	if(!eTable) {
		alert("Cannot locate table with ID="+sTableID);
		return;
	};
	
	//abort if table is currently being exported
	if(eTable.getAttribute("Exporting")=="true") {
		alert("Already exporting.  Table ID: "+sTableID);
		return;
	};

	eTable.setAttribute("Exporting","true");

	//set starting record
	var iStartRecord=0;

	//construct a driver include tag to be processed by the server
	var sHashID=eTable.getAttribute("aspectHashID");
	var sDocumentID="";
	var sWidget="";

	//The DriverID is recorded in the table as well as a DriverStructID.  The DriverStructID is the driver that was actually used in creating the table.
	//It is normally the same as the Driver ID.  However, it can be different if the driver is opened using a script driver.  The include tag used to create the table will 
	//contain the original driver ID but TCacheDriver routine needs to know the structure used by the final driver so it can transfer and read/write data.
	var sDriverID="";
	var sDriverStructID="";

	//add the attributes for the table to an array.  The array will be sorted to avoid creating duplicate TCacheObj entries for the same display
	var arParams=new Array();
	
	//add a display ID if one was passed to this function.  This means a display was selected from above
	//the table or Ok was pressed on the display dialog
	if(ADisplayID.length>0) arParams[arParams.length]="DisplayID:\x22"+ADisplayID+"\x22;";

	var bSystemDriver=false;
	for (var i=0;i<eTable.attributes.length;i++) {
		var sName=eTable.attributes.item(i).nodeName;
		if(sName.startsWith("aspect")) {
			sName=sName.substring(6);
			if(sName.equalsIgnoreCase("FieldPattern")) {
				//ignore 
			}
			else if(sName.equalsIgnoreCase("ID")) {
				//don't pass the table ID to avoid creating unncessary TCacheObj
				// - Do need to pass the ID in case a specified ID is defined.  This may be necessary to avoid a conflict with another element's ID
				// since the driver ID is used when an ID is not specified and the driver ID could be the same as the ID of another html element
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if(sName.equalsIgnoreCase("DisplayID")) {
				if(ADisplayID.length==0) arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if(sName.equalsIgnoreCase("Driver")) {
				sDriverID=eTable.attributes.item(i).nodeValue;
			}
			else if(sName.equalsIgnoreCase("DriverStructID")) {
				sDriverStructID=eTable.attributes.item(i).nodeValue;
			}
			else if(sName.equalsIgnoreCase("SystemDriver")) {
				bSystemDriver=boolVal(eTable.attributes.item(i).nodeValue);
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if (sName.equalsIgnoreCase("StartRecord")) {
				arParams[arParams.length]=sName+": \x22"+iStartRecord+"\x22;";
			}
			else if(sName.equalsIgnoreCase("DocumentID")) {
				sDocumentID=eTable.attributes.item(i).nodeValue;
			}
			else if(sName.equalsIgnoreCase("Widget")) {
				sWidget=eTable.attributes.item(i).nodeValue;
			}
			else if(sName.equalsIgnoreCase("ContainerItemID")) {
				sContainerItemID=eTable.attributes.item(i).nodeValue;
				//add the container ID to the include tag to maintain compatibility with the original
				//Widget Container 
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
			}
			else if(sName.equalsIgnoreCase("ExternalParams")) {
				//include the original externalparams value
				arParams[arParams.length]=sName+": \x22"+eTable.attributes.item(i).nodeValue+"\x22;";
				
				//add an XExternalParamXXX argument for each external parameter
				if(eTable.attributes.item(i).nodeValue!=null) {
					if(eTable.attributes.item(i).nodeValue.length>0) {
						var arExternalParam=getSubStringArray(eTable.attributes.item(i).nodeValue,",",true);
						if(arExternalParam!=null) {
							for (var j=0;j<arExternalParam.length;j++) {
								var eExternalParam=document.getElementById(arExternalParam[j]);
								if(eExternalParam) {
									var sExternalParam=eExternalParam.getAttribute("param");
									var sExternalParamValue="";
									if(eExternalParam.nodeName=="DATALIST") {
										var einput=document.getElementById(arExternalParam[j]+"_input_submit");
										if(einput) sExternalParamValue=einput.value;
									}
									else {
										(eExternalParam.type=="checkbox") ? sExternalParamValue=(eExternalParam.checked) : sExternalParamValue=eExternalParam.value;
									};
									arParams[arParams.length]="XExternalParam"+arExternalParam[j]+": \x22"+sExternalParam+"^"+sExternalParamValue+"\x22;";
									//appendToLog("Adding external param: "+arParams[arParams.length-1],false,true);
								}
								else {
									appendToLog("Cannot locate external driver param with ID="+arExternalParam[j]+" in refreshTable()",false,true);
								};
							};
						};
					};
				};
			}
			else {
				arParams[arParams.length]=sName+": \x22"+replaceAllSubstrings(eTable.attributes.item(i).nodeValue,"#","//ha"+"sh//")+"\x22;";
			};
		};
	};

	//Use the actual driver ID if one was supplied in DriverStructID.  This is to handle drivers opened using a script in which case the driver ID returned by the script
	//may be different than the original driver ID.  However, use the same ID if it's a system driver because the driver ID in the include tag and the actual driver ID
	//will always be different.
	((sDriverStructID.length>0) && (bSystemDriver==false) && (sDriverStructID.equalsIgnoreCase("ConsDriverVert")==false) && (sDriverStructID.equalsIgnoreCase("ConsDriverHorz")==false)) ? arParams[arParams.length]="Driver: \x22"+sDriverStructID+"\x22;" : arParams[arParams.length]="Driver: \x22"+sDriverID+"\x22;";

	//add current display settings
	if(bPreserveSettings) {
		var sFilterOptions=getDisplayFormValues(sTableID);
		var arFilterOptions=getSubStringArray(sFilterOptions,"|",false);
		for(var i=0;i<arFilterOptions.length;i++) {
			var n=arFilterOptions[i].indexOf("=");
			var sName=arFilterOptions[i].substring(0,n);
			if(sName.toUpperCase().startsWith("FIELD_")) sName=sName.substring(6);
			var sValue=arFilterOptions[i].substring(n+1);
			arParams[arParams.length]="XDisplay"+sName+": \x22"+replaceAllSubstrings(sValue,"#","//ha"+"sh//")+"\x22;";
		};
	}
	else {
		//get external filters - These need to be included when a table is refreshed by pressing the refresh button 
		var sExternalFilters=getExternalFilters(sTableID);
		if(sExternalFilters.length>0) {
			var arExternalFilters=getSubStringArray(sExternalFilters,"|",false);
			for(var i=0;i<arExternalFilters.length;i++) {
				var n=arExternalFilters[i].indexOf("=");
				var sName=arExternalFilters[i].substring(0,n);
				var sValue=arExternalFilters[i].substring(n+1);
				arParams[arParams.length]="XDisplay"+sName+": \x22"+replaceAllSubstrings(sValue,"#","//ha"+"sh//")+"\x22;";
			};
		};
	};

	//add the EXPORTTABLE argument.  This causes the export file to be generated when the include tag is processed
	arParams[arParams.length]="EXPORTTABLE: \x22true\x22;";
	
	//add the type of export (only csv is supported currently)
	arParams[arParams.length]="EXPORTFORMAT: \x22csv\x22;";
				
	arParams.sort();
	var s="<"+"include ";
	for(var i=0;i<arParams.length;i++) s +=" "+arParams[i];
	s+=">";

	//appendToLog("Submitting include tag:",true,true);
	//for (var i=0;i<arParams.length;i++) appendToLog("Param["+i+"]="+arParams[i]);
	
	showTableMessage(sTableID,"Exporting...",true);

	var sUrl=getServer()+"/?Network=GreenLight&ID=processContainerItemAsCsv&Content="+s
	sUrl=sUrl + "&DocumentID="+sDocumentID+"&Widget="+sWidget+"&ContainerItemID="+sContainerItemID;
	sUrl +="&Source="+sHashID;

	//console.log("sUrl="+sUrl);
	
	var sFunc="exportTable(\x22"+sTableID+"\x22,\x22"+ADisplayID+"\x22,"+bPreserveSettings+",req.responseText)";
	
	if(false) {
		var doc=window.open("","","toolbar=yes,location=no,directories=yes,menubar=yes,scrollbars=yes,width=500, height=100, left=100, top=25"); 
		doc.document.open(); 
		doc.document.write("Exporting..."); 
		doc.document.location=sUrl;
		doc.document.close(); 
		doc.focus(); 
	};

	asynchInclude(null,sUrl,sFunc,sFunc);
};

/***********************************************************************************
Inserts a new record in a table.  Duplicates the hidden template row and requests a 
new set of values from the server for the template.  Fields initialized in the new 
record are submitted to the server with the associated key value to create the record.  
All fields are submitted simultaneously.  This is necessary to make sure that all 
fields that might be included in the keyexpression are written at one time to avoid
creating more than one record.  More than one record would be created if each value 
was sent separately and the keyexpression referenced more than one field.
***********************************************************************************/
function insertTableRecord(ATableID) 
{
	var table=document.getElementById(ATableID);

	//abort if table is refreshing
	if(table.getAttribute("Loading")=="true") {
		appendToLog("Cannot insert record because table is currently loading");
		return;
	};

	//get the index of the template and add the new row
	var index=-1;
	for (var i=0;i<table.rows.length;i++) {
		var s=table.rows[i].getAttribute("ID");
		if((s) && (s.equalsIgnoreCase("InsertTemplate"+ATableID)))
		{
			var RowTemplate=table.rows[i];

			var s=RowTemplate.getAttribute("IsInitialized");
			if((s) && (s.equalsIgnoreCase("true"))) {
				RowTemplate.setAttribute("IsInitialized","false");
	
				//create a new row and make it visible
				var RowNew=RowTemplate.cloneNode(true);
				RowNew.setAttribute("ID","");
				RowNew.style.display="block";
	
				//get the position to insert the row
				var sInsertPosition=table.getAttribute("InsertPosition");
				if(!sInsertPosition) sInsertPosition="top";

				if(sInsertPosition.equalsIgnoreCase("bottom")) {
					//insert the row at the bottom of the table

					//add to the end of the table by default
					var iInsertAt=table.rows.length;

					//if there are records in the table, add the record before any subtotals at the end 
					//of the table.  This is not the best solution, because there may be more than one level
					//of subtotal.  The item may belong above a subtotal that appears earlier in the table.
					//But since the item is not defined when it is first added, there's no way to know.
					//The best approach for now is probably to control the environment (display options) 
					//when records are being added
					if(table.rows.length>0) {
						var n=table.rows.length-1;
						do {
							var sSubtotalLevel=table.rows[n].getAttribute("aspectsubtotallevel");
							var bIsSubtotal=((sSubtotalLevel) && (parseInt(sSubtotalLevel)>=0));
							var sDeleted=sSubtotalLevel=table.rows[n].getAttribute("deleted");
							var bIsDeleted=(sDeleted) && (sDeleted.equalsIgnoreCase("true"));
							if((bIsSubtotal) || (bIsDeleted)) iInsertAt--;
							n--;
						} while((bIsSubtotal) || (bIsDeleted));
						
						var iMinInsertAt=getFirstTableHeader(table);
						iMinInsertAt=(iMinInsertAt<0) ? i : iMinInsertAt+1;

						var iInsertAt=Math.max(iInsertAt,iMinInsertAt);
					};

					table.insertRow(iInsertAt);
					table.rows[iInsertAt].innerHTML=RowNew.innerHTML;
				}
				else {
					//insert the row after the first header
					var iInsertAt=getFirstTableHeader(table);
					iInsertAt=(iInsertAt<0) ? i : iInsertAt+1;
					table.insertRow(iInsertAt);
					table.rows[iInsertAt].innerHTML=RowNew.innerHTML;
				};
				
				//copy the attributes from the template
				setAttr(table.rows[iInsertAt],"aspectAllValues",getAttr(RowNew,"aspectAllValues"));
				table.rows[iInsertAt].setAttribute("keyvalue",RowNew.getAttribute("keyvalue"));
				table.rows[iInsertAt].setAttribute("aspectsubtotallevel",RowNew.getAttribute("aspectsubtotallevel"));

				//submit all values in the record
				var sKeyValue=RowNew.getAttribute("keyvalue");
				var sAllFieldID=table.getAttribute("aspectAllFieldID");
				var sAllValue=getAttr(RowNew,"aspectAllValues");

				//add the virtual index field if one is defined
				var sVirtualIndexField=table.getAttribute("AspectVirtualIndex");
				if((sVirtualIndexField) && (sVirtualIndexField.length>0)) {
					table.rows[iInsertAt].setAttribute("virtualindex",RowNew.getAttribute("virtualindex"));
					sAllFieldID+=","+sVirtualIndexField;
					sAllValue+=","+table.rows[iInsertAt].getAttribute("virtualindex");
				};

				submitTableData(ATableID,sKeyValue,sAllFieldID,sAllValue,true);
				
				//set the background color and pending status of all cells being submitted
				var arAllFieldID=getSubStringArray(sAllFieldID,",",true);
				var arAllValue=getSubStringArray(sAllValue,",",true);
				var arTableFieldID=getSubStringArray(table.getAttribute("aspectfields"),",");
				for (var cell=0;cell<table.rows[iInsertAt].cells.length;cell++) {
					var s=table.rows[iInsertAt].cells[cell].getAttribute("cellindex");
					if(s) {
						var iCellIndex=parseInt(s);
						var sFieldID=arTableFieldID[iCellIndex];
						if(arAllFieldID.indexOf(sFieldID)>=0) {
							table.rows[iInsertAt].cells[cell].setAttribute("AspectSubmissionPending","new");
							var Done=false;
							for (var Child=0;(Done==false) && (Child<table.rows[iInsertAt].cells[cell].childNodes.length);Child++) {
								var e=table.rows[iInsertAt].cells[cell].childNodes[Child];
								if((e.nodeName.equalsIgnoreCase("select")) || (e.type=='checkbox') || (e.nodeName.equalsIgnoreCase("input")) || (e.nodeName.equalsIgnoreCase("text")) || (e.nodeName.equalsIgnoreCase("password"))) {
									setPendingSubmissionStyle(e,true,true);
									Done=true;
								}
							};
						};
					};
				};

				//resize dialog containing the table if there is one
				adjustDialogHeight(table);
				
				//show the edit dialog for the new record
				showTableEditDialogForRow(table,iInsertAt);

				//call function to initialize template with new values
				initializeNewRecordTemplate(ATableID);

				//appendToLog("insertTableRecord: added new record row="+iInsertAt+" Key="+sKeyValue,false,true);
				return(iInsertAt);
			}
			else {
				//alert("An error occurred initializing the new record.  Try again.");
				setTimeout("insertTableRecord(\""+ATableID+"\")");
				return(-1);
			};

			//call function to initialize template with new values
			//[it looks like these lines would never be reached]
			initializeNewRecordTemplate(ATableID);
			return(-1);
		};
	};
	
	alert("Unable to initialize new record.");
	return(-1);
};

/**************************************************************************************
Gets the pattern used to format a field in the table
**************************************************************************************/
function getFieldPattern(TableID,FieldID) {
	var arFieldID=getSubStringArray(table.getAttribute("aspectallfieldid"),",",false);
	var arPattern=getSubStringArray(table.getAttribute("aspectAllFieldPattern"),",",false);
	var n=getFieldIndex(FieldID,arFieldID);
	if(n<0) return("");
	return(arPattern[n]);
};

/**************************************************************************************
Applies a pattern to the value of a field.  
TableID	- Table containing information about the field.  
e		- Control to be formatted.  It can be a form element or a span tag.  The name of the control must
		  be a Field ID.  The field type and pattern are determined using metadata included in the table
sValue 	- An optional value to be formatted.  If a value is not specified, the current value of the control will
		  be used.

AarFieldID,AarFieldType,AarPattern are optional arguments with the only purpose of avoiding calling the 
getSubStringArray every time if many fields are to be formatted at one time by making successive calls to 
this function.
**************************************************************************************/
function formatField(TableID,e,sValue,AarFieldID,AarFieldType,AarPattern)
{
	var table=document.getElementById(TableID);
	if(!table) return;
	
	var arFieldID=(AarFieldID) ? AarFieldID : getSubStringArray(table.getAttribute("aspectallfieldid"),",",false);
	var arFieldType=(AarFieldType) ? AarFieldType : getSubStringArray(table.getAttribute("aspectallfieldtype"),",",false);
	var arPattern=(AarPattern) ? AarPattern : getSubStringArray(table.getAttribute("aspectAllFieldPattern"),",",false);

	if(arPattern==null) {
		//appendToLog("No patterns defined for table",false,true);
		return(sValue);
	};
	
	var sFieldID=e.getAttribute("name");
	var sResult="";
	
	//NOTE: An empty string passed in sValue will be considered as not defined and the current value of the element will be used
	//as the starting point.  This is a problem when called from setDialogValues() unless the field is set to the new value
	//before calling this function
	if(sValue) {
		sResult=sValue;
	}
	else {
		sResult=((e.nodeName.equalsIgnoreCase("text")) || (e.nodeName.equalsIgnoreCase("password"))) ? e.innerHTML : e.value;
		if((!sResult) || (sResult.equalsIgnoreCase("undefined"))) sResult="";
	};
	if(sFieldID) {
		var n=getFieldIndex(sFieldID,arFieldID);
		if(n>=0) {
			var iFieldType=arFieldType[n];
			var sPattern=arPattern[n];
			
			//if no pattern is defined, see if one is specified in the element
			if(e.getAttribute("pattern")) sPattern=e.getAttribute("pattern");
//appendToLog("formatField ID="+sFieldID+" pattern="+sPattern+" FieldType="+iFieldType,false,true);
			
			if(isNumberField(iFieldType)) {
				if(sPattern.length==0) {
					if((iFieldType==8) || (iFieldType==9) || (iFieldType==12)) {
						sPattern="999|999|999.00";
					}
					else {
						sPattern="999|999|999";
					};
				};
				if(sResult.length==0) sResult=0;
//appendToLog("formatNumber sResult="+sResult+" Pattern="+sPattern);
				sResult=formatNumber(sResult,sPattern);
//appendToLog("Formatted result="+sResult);
			}
			else if(isTimeField(iFieldType)) {
				if(sPattern.length==0) {
					if((iFieldType==13) || (iFieldType==21)) {
						sPattern="MM-dd-yyyy HH:mm:ss";
					}
					else if(iFieldType==10) {
						sPattern="MM-dd-yyyy";
					}
					else if(iFieldType==18) {
						sPattern="HH:mm:ss";
					};
				};

				//prepare the string for parsing.  Dashes are not allowed and the 
				//trailing milliseconds :000 must be removed
				//var s=replaceAllSubstrings(sResult,"-","/");
				//if(s.length>19) s=s.substring(0,19);
				var dt=parseTime(sResult);
//appendToLog("foematField dt="+dt+" Pattern="+sPattern,false,true);
//alert("dt="+dt);
//alert("formatDate="+formatDate(dt,sPattern));
				sResult=formatDate(dt,sPattern);
//appendToLog("formatField sResult="+sResult,false,true);
			};
		};
	};
	
	return(sResult);
};

/******************************************************************************************
Returns the select box in the dialog header containing the collection of key descriptions
******************************************************************************************/
function getTableDialogHeaderSelectKeyControl(eDialog) { 
	var arSelect=eDialog.getElementsByTagName("select");
	var Done=false;
	for (var i=0;(Done==false) && (i<arSelect.length);i++) {
		var s=arSelect[i].getAttribute("name");
		if((s) && (s.equalsIgnoreCase("selectKeyValue"))) return(arSelect[i]);
	};
};

function initializeTableDialogHeader(TableID,DialogID,KeyValue)
{
	//get the dialog
	var eDialog=document.getElementById(DialogID);
	if(!eDialog) return;

	//determine if the dialog header should be hidden
	table=document.getElementById(TableID);
	var s=table.getAttribute("aspectdialogheader");
	var bShowHeader=((!s) || (s.equalsIgnoreCase("true"))) ? true : false;

	//see if the header template exists
	var eHeader=document.getElementById("EditDialogHeaderTemplate"+TableID);
	if(!eHeader) {
		var e=document.getElementById("EditDialogHeader"+TableID);
		if(e) {
			var arSelect=eDialog.getElementsByTagName("select");
			if(arSelect) {
				var Done=false;
				for (var i=0;(Done==false) && (i<arSelect.length);i++) {
					var s=arSelect[i].getAttribute("name");
					if((s) && (s.equalsIgnoreCase("selectKeyValue"))) {
						arSelect[i].value=KeyValue;
						Done=true;
					};
				};
			};
			
			setVisible("EditDialogHeader"+TableID,bShowHeader);
		};
		return;
	};

	//remove the copy if one exists
	var ePreviousHeader=document.getElementById("EditDialogHeader"+TableID);
	if(ePreviousHeader) {
		ePreviousHeader.parentNode.removeChild(ePreviousHeader);
	};

	//copy the template to the dialog
	eHeader.id="EditDialogHeader"+TableID;
	eHeader.setAttribute("id","EditDialogHeader"+TableID);
	eHeader.style.display="block";
	eHeader.parentNode.removeChild(eHeader);
	eDialog.insertBefore(eHeader,eDialog.childNodes[0]);

	var arSelect=eDialog.getElementsByTagName("select");
	if(arSelect) {
		var Done=false;
		for (var i=0;(Done==false) && (i<arSelect.length);i++) {
			var s=arSelect[i].getAttribute("name");
			if((s) && (s.equalsIgnoreCase("selectKeyValue"))) {
				arSelect[i].value=KeyValue;
				Done=true;
			};
		};
	};

	setVisible("EditDialogHeader"+TableID,bShowHeader);
};

/***********************************************************************************************
Updates the select box in the dialog header so it reflects the records in the table.  
Called when records are inserted or deleted.  The KeyValue of the dialog is used to 
set the current selection so it must be set before calling this function/
***********************************************************************************************/
function updateTableDialogHeader(TableID)
{
	var table=document.getElementById(TableID);
	var eDialog=document.getElementById(table.getAttribute("EditDialogID"));
	var eHeader=document.getElementById("EditDialogHeader"+TableID);
	
	//make collection of all keyvalues in the table
	var arKeyValues=new Array();
	var arKeyDescription=new Array();
	for (var row=0;row<table.rows.length;row++) {
		var s=table.rows[row].getAttribute("keyvalue");
		if(s) {
			if((tableRowIsTemplate(table.rows[row])==false) && (tableRowIsDeleted(table.rows[row])==false)) {
				arKeyValues[arKeyValues.length]=s;
				arKeyDescription[arKeyDescription.length]=table.rows[row].getAttribute("keydescription");
			};
		};
	};

	//get the select box in the header.  Look for the first select box since there may be more than one
	//if an edit dialog contains another table inside of it
	var eSelect=null;
	var arSelect=eHeader.getElementsByTagName("select");
	var Done=false;
	for (var i=0;(Done=false) && (i<arSelect.length);i++) {
		var s=arSelect[i].getAttribute("name");
		if((s) && (s.equalsIgnoreCase("selectKeyValue"))) {
			eSelect=arSelect[i];
			Done=true;
		};
	};

	//remove any options that no longer exist in the table and make an array of existing options
	var arOptionValue=new Array();
	var arOptionText=new Array();
	var iOption=0;
	while(iOption<eSelect.options.length) {
		if(arKeyValues.indexOf(eSelect.options[iOption].value)<0) {
			eSelect.remove(iOption);
		}
		else {
			arOptionValue[arOptionValue.length]=eSelect.options[iOption].value;
			arOptionText[arOptionText.length]=eSelect.options[iOption].text;
			iOption++;
		};
	};

	//insert any elements that exist in the table but not in the select box
	for(var i=0;i<arKeyValues.length;i++) {
		if(arOptionValue.indexOf(arKeyValues[i])<0) 
		{
			//don't add the option if another option with the same key description exists.
			//The list is initially created by the driver include which does not allow duplicates
			//Adding them here would be confusing
			if(arOptionText.indexOf(arKeyDescription[i])<0) {
				var eNewOption=document.createElement('option');
				eNewOption.text=arKeyDescription[i];
				eNewOption.value=arKeyValues[i];
				if(eSelect.options.length==0) {
					try {
						eSelectadd(eNewOption, null); // standards compliant; doesn't work in IE
					}
					catch(e1) {
						eSelect.add(eNewOption); // IE only
					};
				}
				else {
					var eFirstOption=eSelect.options[0];  //could use eSelect.selectedIndex
					try {
						eSelect.add(eNewOption, eFirstOption); // standards compliant; doesn't work in IE
					}
					catch(ex) {
						eSelect.add(eNewOption, 0); // IE only
					};
				};
			};
		};
	};

	//set the selected option
	eSelect.value=eDialog.getAttribute("keyvalue");
};

function dialogRecordSelected(e)
{
	var eDialog=getDialogNode(e);
	if(eDialog==null) {
		alert("Cannot locate dialog");
		return;
	};

	//get the table
	var sTableID=eDialog.getAttribute("TableID");
	var table=document.getElementById(sTableID);
	
	//get the value selected
	var sKeyValue=e.value;

	//get the row containing the selected key value
	var iToDisplay=getTableRowContainingKey(table,sKeyValue);
	if(iToDisplay>=0) {
		var arFieldID=getSubStringArray(table.getAttribute("aspectAllFieldID"),",",true);
		var arValues=getSubStringArray(getAttr(table.rows[iToDisplay],"aspectAllValues"),",",true);
		for(var i=0;i<arValues.length;i++) arValues[i]=tokenizeTableValue(arValues[i],false);
		eDialog.setAttribute("keyvalue",table.rows[iToDisplay].getAttribute("keyvalue"));
		var arRefresh=setDialogValues(sTableID,eDialog,arFieldID,arValues);

		//call initialization function for dialog if one is defined
		var sDialogID=table.getAttribute("editdialogid");
		var s="initializeDialog"+sDialogID;
		if(eval('typeof '+s)=="function") eval(s+"()");
		
		//look for initialization function in the aspectinit attribute of the div
		//This is used so a single function can be called even when the dialog ID is random
		//The ID of the dialog div is passed as an argument.  Additional arguments can be
		//made available to the function by including them in the dialog div's attributes or
		//as hidden inputs inside the dialog.
		var s=eDialog.getAttribute("aspectinit");
		if(s) {
			if(eval('typeof '+s)=="function") eval(s+"('"+sDialogID+"')");
		};

		//initialize calendar and other controls
		initializeCustomControls();

		//refresh tables
		if(arRefresh.length>0) {
			for(var i=0;i<arRefresh.length;i++) {
				//check to see if the table still exists.  This is necessary because a dialog might include a table that
				//is created on the fly by an initialization function when the dialog is loaded and the table may no longer exist.
				if(document.getElementById(arRefresh[i])) refreshTable(arRefresh[i]);
			};
		};
	};
};

/***********************************************************************
Climbs the parent tree for the given element to locate the dialog containing the element.
***********************************************************************/
function getDialogNode(e) {
	if(e==null) {
		appendToLog("Error: e is null in getDialogNode");
		return(null);
	};
	
	var eDialog=null;
	var node=e;
	while((eDialog==null) && (node.parentNode)) {
		if(node.getAttribute) {
			if(node.getAttribute("TableID")) return(node);
		};
		node=node.parentNode;
	};
	return(null);
};

/***********************************************************************
Returns the index of the row matching the given key value
***********************************************************************/
function getTableRowContainingKey(table,KeyValue)
{
	for (var i=0;i<table.rows.length;i++) {
		var s=table.rows[i].getAttribute("keyvalue");
		if((s) && (s.equalsIgnoreCase(KeyValue))) return(i);
	};
	return(-1);
};

/***********************************************************************
Returns the first row in the table containing a record detail or subtotal.   Does not include
the template used for new records or section headers
***********************************************************************/
function getFirstTableRow(table,bIncludeSubtotal,StartIndex)
{
	var n=0;
	if(StartIndex) n=StartIndex;
	for (var i=n;i<table.rows.length;i++) {
		if((tableRowIsTemplate(table.rows[i])==false) && (tableRowIsDeleted(table.rows[i])==false)) {
			var s=table.rows[i].getAttribute("AspectSubtotalLevel");
			if(s) {
				if((parseInt(s)<0) || (bIncludeSubtotal)) return(i);
			};
		};
	};
	return(-1);
};

/***********************************************************************
Returns the last row in the table containing a record detail or subtotal.   Does not include
the template used for new records or section headers
***********************************************************************/
function getLastTableRow(table,bIncludeSubtotal)
{
	for (var i=table.rows.length-1;i>=0;i--) {
		if((tableRowIsTemplate(table.rows[i])==false) && (tableRowIsDeleted(table.rows[i])==false)) {
			var s=table.rows[i].getAttribute("AspectSubtotalLevel");
			if(s) {
				if((parseInt(s)<0) || (bIncludeSubtotal)) return(i);
			};
		};
	};
	return(-1);
};

/***********************************************************************
Returns the next row in the table containing a record detail or subtotal beginning with
StartIndex+1.   Does not include the template used for new records or section headers
***********************************************************************/
function getNextTableRow(table,StartIndex,bIncludeSubtotal)
{
	for (var i=StartIndex+1;i<table.rows.length;i++) {
		if((tableRowIsTemplate(table.rows[i])==false) && (tableRowIsDeleted(table.rows[i])==false)) {
			var s=table.rows[i].getAttribute("AspectSubtotalLevel");
			if(s) {
				if((parseInt(s)<0) || (bIncludeSubtotal)) return(i);
			};
		};
	};
	return(-1);
};

/***********************************************************************
Returns the previous row in the table containing a record detail or subtotal beginning with
StartIndex-1.   Does not include the template used for new records or section headers
***********************************************************************/
function getPrevTableRow(table,StartIndex,bIncludeSubtotal)
{
	for (var i=StartIndex-1;i>=0;i--) {
		if((tableRowIsTemplate(table.rows[i])==false) && (tableRowIsDeleted(table.rows[i])==false)) {
			var s=table.rows[i].getAttribute("AspectSubtotalLevel");
			if(s) {
				if((parseInt(s)<0) || (bIncludeSubtotal)) return(i);
			};
		};
	};
	return(-1);
};

function updateDialogRecord(e,Direction)
{
	//get the dialog the element belongs to
	var eDialog=getDialogNode(e);
	if(eDialog==null) {
		appendToLog("Error getting dialog in updateDialogRecord",false,true);
		return;
	};

	//get the table
	var sTableID=eDialog.getAttribute("TableID");
	var table=document.getElementById(sTableID);

	//get the select box
	var eSelect=null;
	var arSelect=eDialog.getElementsByTagName("select");
	var Done=false;
	for (var i=0;(Done==false) && (i<arSelect.length);i++) {
		var s=arSelect[i].getAttribute("name");
		if((s) && (s.equalsIgnoreCase("selectKeyValue"))) {
			eSelect=arSelect[i];
			Done=true;
		};
	};

	//determine the row to be displayed
	var sNewKeyValue="";
	if(Direction.equalsIgnoreCase("first")) {
		if(eSelect.options.length>0) sNewKeyValue=eSelect.options[0].value;
	}
	else if (Direction.equalsIgnoreCase("last")) {
		if(eSelect.options.length>0) sNewKeyValue=eSelect.options[eSelect.length-1].value;
	}
	else {
		for(var i=0;(sNewKeyValue.length==0) && (i<eSelect.options.length);i++) {
			if(eSelect.options[i].value.equalsIgnoreCase(eSelect.value)) {
				if (Direction.equalsIgnoreCase("next")) {
					if(i<eSelect.options.length-1) sNewKeyValue=eSelect.options[i+1].value;
				}
				else if (Direction.equalsIgnoreCase("prev")) {
					if(i>0) sNewKeyValue=eSelect.options[i-1].value;
				};
			};
		};
	};
	
	if(sNewKeyValue.length>=0) {
		var iNewRow=getTableRowContainingKey(table,sNewKeyValue);
		if(iNewRow>=0) 
		{
			//update the keyvalue in the dialog attributes
			eDialog.setAttribute("keyvalue",sNewKeyValue);

			//update the select box
			eSelect.value=sNewKeyValue;
			
			//set the values in the dialog
			var arFieldID=getSubStringArray(table.getAttribute("aspectAllFieldID"),",",true);
			var arValues=getSubStringArray(getAttr(table.rows[iNewRow],"aspectAllValues"),",",true);
			for(var i=0;i<arValues.length;i++) arValues[i]=tokenizeTableValue(arValues[i],false);
			var arRefresh=setDialogValues(sTableID,eDialog,arFieldID,arValues);

			//call initialization functino for dialog if one is defined
			var sDialogID=table.getAttribute("editdialogid");
			var s="initializeDialog"+sDialogID;
			if(eval('typeof '+s)=="function") eval(s+"()");
			
			//look for initialization function in the aspectinit attribute of the div
			//This is used so a single function can be called even when the dialog ID is random
			//The ID of the dialog div is passed as an argument.  Additional arguments can be
			//made available to the function by including them in the dialog div's attributes or
			//as hidden inputs inside the dialog.
			var s=eDialog.getAttribute("aspectinit");
			if(s) {
				if(eval('typeof '+s)=="function") eval(s+"('"+sDialogID+"')");
			};

			//initialize calendar and other controls
			initializeCustomControls();

			//refresh tables
			if(arRefresh.length>0) {
				for(var i=0;i<arRefresh.length;i++) {
					//check to see if the table still exists.  This is necessary because a dialog might include a table that
					//is created on the fly by an initialization function when the dialog is loaded and the table may no longer exist.
					if(document.getElementById(arRefresh[i])) refreshTable(arRefresh[i]);
				};
			};
		};
	};
};

function closeTableEditDialog(e)
{
	var eDialog=getDialogNode(e);
	if(eDialog) setVisible(eDialog,false);
};

/********************************************************************
Returns the index of the first row in the table containing headers
********************************************************************/
function getFirstTableHeader(table)
{
	//skip the first record which is table controls
	for (var i=1;i<table.rows.length;i++) {
		if(table.rows[i].cells.length>0) {
			if(table.rows[i].cells[0].nodeName.equalsIgnoreCase("th")) return(i);
		};
	};
	return(-1);
};

/********************************************************************
Displays a message in the dialog used to edit table records when the table contains
no records
********************************************************************/
function disableTableDialog(ATableID) 
{
	//get the ID of the dialog
	var table=document.getElementById(ATableID);
	var eDialog=document.getElementById(table.getAttribute("EditDialogID"));
	
	//abort if dialog does not exist.  This will happen if canEdit is false in the driver include.
	if(!eDialog) return;
	
	var eHeader=document.getElementById("EditDialogHeader"+ATableID);
	if(!eHeader) eHeader=document.getElementById("EditDialogHeaderTemplate"+ATableID);
	
	//create a div and overlay it to hide the dialog contents
	var div=document.createElement("div");
	var sDivID="EditDialogDisable"+ATableID;
	div.setAttribute("id",sDivID);
	div.id=sDivID;

	//size and position the div
	div.style.position="fixed";
	div.style.height=eDialog.offsetHeight;
	if(eHeader) div.style.height -=eHeader.offsetHeight;
	div.style.width=eDialog.offsetWidth;
	var xy=getPosition2012(eDialog,"fixed");
	div.style.top=(xy[1]+eHeader.offsetHeight)+"px";
	div.style.left=xy[0]+"px";
	div.style.zIndex="99";
	div.style.backgroundColor="white";
	div.innerHTML="Table is not initialized";

	eDialog.insertBefore(div,eDialog.childNodes[0]);
	setVisible(div,true);
};

/********************************************************************
Initializes new tables.  Called by the widget container whenever content is loaded.
Initializes the edit dialog header and sets the dialog to the first record in the table
********************************************************************/
function initializeTables2012()
{
	//appendToLog("initializeTables2012: started");
	if(!bContainerLoaded) return;

	addScripts();
	addStyles();
	makeScrollingTable();
	//show charts
	showCharts();
	
	//appendToLog("initializeTables2012 bContainerLoaded="+bContainerLoaded,false,true);
	//create an array of ID's for all tables to be updated.  Can't just iterate through an
	//array of tables and updating as they're found because table[n] changes to point
	//to a new table when the dialog header is moved.  E.g. table[18] may become table[17]
	//right in the middle of this function
	var arTable=document.getElementsByTagName("table");
	var arTableID=new Array();
	for (var i=0;i<arTable.length;i++) {
		//if((arTable[i].getAttribute("aspectAllFieldID")) && (arTable[i].getAttribute("id").toUpperCase().indexOf("INTERVALREFRESH")<0)) {
		if((arTable[i].getAttribute("aspecttype")) && (arTable[i].getAttribute("id").toUpperCase().indexOf("INTERVALREFRESH")<0)) {
			var s=arTable[i].getAttribute("TableInitialized");
			if((!s) || (s.equalsIgnoreCase("true")==false)) {
//appendToLog("Initializing table "+arTable[i].getAttribute("id"));
				arTableID[arTableID.length]=arTable[i].getAttribute("id");

				//update the span containing the time the table was generated
				//this only updates tables that haven't already been initialized
				if(arTable[i].id) setTableUpdateTime(arTable[i]);
			};
		}
		else {
			//update the span containing the time the table was generated
			//this is needed to update the time in tables that don't have an aspectAllFieldID
			//when is not defined when the table is not editable
			if(arTable[i].id) {
				if(!arTable[i].getAttribute("TimeInitialized")) {
					setTableUpdateTime(arTable[i]);
				};
			};
		};
	};

	if(arTableID.length==0) return;
	
	for(var i=0;i<arTableID.length;i++) 
	{
		var table=document.getElementById(arTableID[i]);
		var sDialogID=table.getAttribute("editdialogid");
		var iFirstRow=getFirstTableRow(table,false);
		var sKeyValue="";
		if(iFirstRow>=0) sKeyValue=table.rows[iFirstRow].getAttribute("keyvalue");
		initializeTableDialogHeader(arTableID[i],sDialogID,sKeyValue);

		//set the table ID and KeyValue in the dialog
		if((sDialogID) && (sDialogID.length>0)) {
			var eDialog=document.getElementById(sDialogID);
			if(eDialog) {
				eDialog.setAttribute("TableID",arTableID[i]);
				eDialog.setAttribute("KeyValue",sKeyValue);
			}
			else {
				//appendToLog("Invalid edit dialog ID in initializeTables2012().  TableID: "+arTableID[i]);
			};
		};

		if(iFirstRow>=0) 
		{
			//02-11-2017: Added the DialogOnly parameter to the driver include tag.  This is used to indicate that the table dialog
			//is displayed by default and that the table is hidden.  If DialogOnly is true, the dialog will be initialized when 
			//the table is refreshed.  Otherwise, the dialog will NOT be initialized here and will only be initialized when the 
			//dialog is opened.  This avoids refreshing tables containing in the dialog until the dialog is opened.  This is a waste 
			//of time and tables included in the dialog are often not valid until the dialog is opened for a record.
			var attrDialogOnly=table.getAttribute("DialogOnly");
			if(attrDialogOnly) {
				if(attrDialogOnly.equalsIgnoreCase("true")) {
					var arFieldID=getSubStringArray(table.getAttribute("aspectAllFieldID"),",",true);
					var arFieldType=getSubStringArray(table.getAttribute("aspectAllFieldType"),",",true);
					var arValues=getSubStringArray(getAttr(table.rows[iFirstRow],"aspectAllValues"),",",true);
					if(arValues!=null) {
						for(var j=0;j<arValues.length;j++) arValues[j]=tokenizeTableValue(arValues[j],false);
				
						//set value of all elements in the dialog
						if(eDialog) {
							var arRefresh=setDialogValues(arTableID[i],eDialog,arFieldID,arValues);

							//call initialization function for dialog if one is defined
							var s="initializeDialog"+sDialogID;
							if(eval('typeof '+s)=="function") eval(s+"()");

							//look for initialization function in the aspectinit attribute of the div
							//This is used so a single function can be called even when the dialog ID is random
							//The ID of the dialog div is passed as an argument.  Additional arguments can be
							//made available to the function by including them in the dialog div's attributes or
							//as hidden inputs inside the dialog.
							var s=eDialog.getAttribute("aspectinit");
							if(s) {
								if(eval('typeof '+s)=="function") eval(s+"('"+sDialogID+"')");
							};
						};
					};
				};
			};
		}
		else {
			disableTableDialog(arTableID[i]);
		};
	
		//set the attribute indicating the table has been initialized
		table.setAttribute("TableInitialized","true");
	};
	
	//add javascript for tables.  When a table is generated, associated javascript (if any) is included with
	//the table in a <script> element.  The ID of the script element is _JS[tableID].  This script element is
	//moved to the <head> element and the underscore is removed from the ID.  If the table is loaded again,
	//the sceipt element is just deleted if it already exists in the head element
	for(var i=0;i<arTableID.length;i++) 
	{
		var e=document.getElementById("_js"+arTableID[i]);
		if(e) {
			//a script element is included with the table.  Remove it and add it to the <head> element if it doesn't already exist
			e.parentNode.removeChild(e);

			//remove the current javascript element from the head when in development mode so changes to the code are reflected during development
			if("Deployed".equalsIgnoreCase("Development")) {
				var eCurrent=document.getElementById("js"+arTableID[i]);
				if(eCurrent) eCurrent.parentNode.removeChild(eCurrent);
			};

			if(!document.getElementById("js"+arTableID[i])) {
				//add it to the <head> element
				var eScript=document.createElement("script");
				eScript.id="js"+arTableID[i];

				//For IE, set the src of the script.  Another http request will be made to get the script
				if (getBrowserName().toUpperCase().indexOf("EXPLORER")>=0) {
					var s=e.getAttribute("_url");
					eScript.setAttribute("src",replaceAllSubstrings(s,"__Request"+"Server__",getServer()));
				}
				else {
					//otherwise, just include the script directly in the tag
					eScript.innerHTML=replaceAllSubstrings(e.innerHTML,"&amp;","&");
				};
				document.getElementsByTagName("head")[0].appendChild(eScript);
			};
		};
	};
};

/******************************************************************************
Called to delete selected records
******************************************************************************/
function deleteTableRecords(ATableID,ARow) {
	//un-check the select-all checkbox
	var eSelectAll=document.getElementById("SelectRecords"+ATableID);
	if(eSelectAll) eSelectAll.checked=false;
	
	var table=document.getElementById(ATableID);

	//abort if table is refreshing
	if(table.getAttribute("Loading")=="true") {
		appendToLog("Cannot delete record because table is currently loading");
		return;
	};

	//close the dialog if it's open
	var sDialogID=table.getAttribute("editdialogid");
	if(document.getElementById(sDialogID)) setVisible(sDialogID,false);
	
	var iSelectedRow=(ARow) ? ARow : -1;
	
	//get the onDelete attribute for the table.  It contains field ID's and values to be written when
	//a record is deleted in the form FieldID^Value|FieldID^Value
	var sOnDelete=table.getAttribute("aspectOnDelete");
	var arOnDelete=getSubStringArray(sOnDelete,"|",true);
	
	//get separate arrays for the field ID's, types and values in the OnDelete attribute
	var arOnDeleteFieldID=new Array();
	var arOnDeleteFieldType=new Array();
	var arOnDeleteFieldValue=new Array();
	for (var i=0;i<arOnDelete.length;i++) {
		var a=getSubStringArray(arOnDelete[i],"^",true);
		arOnDeleteFieldID[i]=a[0];
		arOnDeleteFieldType[i]=a[1];
		arOnDeleteFieldValue[i]=a[2];
	};

	var arKeyValue=new Array();
	var arFieldID=new Array();
	var arFieldType=new Array();
	var arFieldValue=new Array();

	//determine the cell that contains the select checkbox
	var c=getTableRecordSelectIndex(ATableID);

	var cSelected=0;
	for (var row=0;row<table.rows.length;row++) {
		if(table.rows[row].cells[c]) {
			var sKeyValue=table.rows[row].getAttribute("KeyValue");
			if((sKeyValue) && (tableRowIsTemplate(table.rows[row])==false))
			{
				var eCheckbox=table.rows[row].cells[c].firstChild;
				var bDelete=(iSelectedRow>=0) ? (row==iSelectedRow) : eCheckbox.checked;
				if(bDelete)
				{
					cSelected++;

					//set attributes to indicate data is being submitted
					setPendingSubmissionStyle(table.rows[row].cells[c].childNodes[0],true,true);
					//table.rows[row].cells[c].style.backgroundColor=PendingSubmissionBackgroundColor;
					table.rows[row].cells[c].setAttribute("AspectSubmissionPending","newdelete");
					table.rows[row].setAttribute("deleted","true");

					//create a data submission for each field in the onDelete attribute
					for (var i=0;i<arOnDeleteFieldID.length;i++) {
						arKeyValue[arKeyValue.length]=sKeyValue;
						arFieldID[arFieldID.length]=arOnDeleteFieldID[i];
						arFieldType[arFieldType.length]=arOnDeleteFieldType[i];
						arFieldValue[arFieldValue.length]=replaceAllSubstrings(arOnDeleteFieldValue[i],",","//co"+"mma//");
					};
				};
			};
		};
	};

	//abort if no records were selected
	if(cSelected==0) return;

	submitTableData(ATableID,arKeyValue.toString(),arFieldID.toString(),arFieldValue.toString(),false,true);
};

/******************************************************************************
OLD METHOD: Called to delete selected records
******************************************************************************/
function olddeleteTableRecords(ATableID,ARow)
{
	var table=document.getElementById(ATableID);

	var iSelectedRow=(ARow) ? ARow : -1;
	
	//get the onDelete attribute for the table.  It contains field ID's and values to be written when
	//a record is deleted in the form FieldID^Value|FieldID^Value
	var sOnDelete=table.getAttribute("aspectOnDelete");
	var arOnDelete=getSubStringArray(sOnDelete,"|",true);
	
	//get separate arrays for the field ID's, types and values in the OnDelete attribute
	var arOnDeleteFieldID=new Array();
	var arOnDeleteFieldType=new Array();
	var arOnDeleteFieldValue=new Array();
	for (var i=0;i<arOnDelete.length;i++) {
		var a=getSubStringArray(arOnDelete[i],"^",true);
		arOnDeleteFieldID[i]=a[0];
		arOnDeleteFieldType[i]=a[1];
		arOnDeleteFieldValue[i]=a[2];
	};

	var arKeyValue=new Array();
	var arFieldID=new Array();
	var arFieldType=new Array();
	var arFieldValue=new Array();

	//determine the cell that contains the select checkbox
	var c=getTableRecordSelectIndex(ATableID);

	var cSelected=0;
	for (var row=0;row<table.rows.length;row++) {
		if(table.rows[row].cells[c]) {
			var sKeyValue=table.rows[row].getAttribute("KeyValue");
			if((sKeyValue) && (tableRowIsTemplate(table.rows[row])==false))
			{
				var eCheckbox=table.rows[row].cells[c].firstChild;
				var bDelete=(iSelectedRow>=0) ? (row==iSelectedRow) : eCheckbox.checked;
				if(bDelete)
				{
					cSelected++;

					//set attributes to indicate data is being submitted
					setPendingSubmissionStyle(table.rows[row].cells[c].childNodes[0],true,true);
					//table.rows[row].cells[c].style.backgroundColor=PendingSubmissionBackgroundColor;
					table.rows[row].cells[c].setAttribute("AspectSubmissionPending","newdelete");
					table.rows[row].setAttribute("deleted","true");

					//create a data submission for each field in the onDelete attribute
					for (var i=0;i<arOnDeleteFieldID.length;i++) {
						arKeyValue[arKeyValue.length]=sKeyValue;
						arFieldID[arFieldID.length]=arOnDeleteFieldID[i];
						arFieldType[arFieldType.length]=arOnDeleteFieldType[i];
						arFieldValue[arFieldValue.length]=replaceAllSubstrings(arOnDeleteFieldValue[i],",","//co"+"mma//");
					};
				};
			};
		};
	};

	//abort if no records were selected
	if(cSelected==0) return;

	//display a status message
	var s="Deleting "+cSelected+" record";
	if(cSelected>1) s+="s";
	showTableMessage(ATableID,s,true);

	var sServer=getServer();
	var sHashID=table.getAttribute("aspectHashID");
	var sDriverID=table.getAttribute("aspectDriver");
	var sKeyExpression=table.getAttribute("aspectKeyExpression");
	
	//need to use params active when the table was created
	//var sParams=getTableDriverParams(ATableID);
	var sParams=table.getAttribute("aspectParamsActive");
	if(!sParams) sParams=getTableDriverParams(ATableID); //for compatibility before aspectParamsActive is posted

	var submitKeyValue=arKeyValue.toString();
	var submitFieldID=arFieldID.toString();
	var submitFieldType=arFieldType.toString();
	var submitFieldValue=arFieldValue.toString();

	var sUrl=getServer()+"/?Network=GreenLight&ID=putDriverData";
	sUrl +="&SourceHashID="+sHashID+"&DriverID="+sDriverID+"&KeyExpression="+sKeyExpression;
	sUrl +="&DriverParams="+sParams+"&KeyValue="+submitKeyValue+"&FieldID="+submitFieldID;
	sUrl +="&FieldType="+submitFieldType+"&Value="+submitFieldValue;

	//var sFunc="submitTableData(null,req.responseText)";
	var sFunc="";
	asynchInclude(null,sUrl,sFunc,sFunc);
};

/******************************************************************************
Returns the input control of the cell with the given KeyValue and Field ID
******************************************************************************/
function getTableCellControl(table,AKeyValue,AFieldID)
{
//appendToLog("getTableCellControl table="+table+" KeyValue="+AKeyValue+" FieldID="+AFieldID);
	var Cell=getTableCell(table,AKeyValue,AFieldID);
//appendToLog("getTableCellControl Cell="+Cell);
	if(Cell==null) return(null);

	for (var i=0;i<Cell.childNodes.length;i++) {
		var eChild=Cell.childNodes[i];
		if((eChild.type=="select-one") || (eChild.type=="select-multiple") || (eChild.type=="text") || (eChild.type=="number") || (eChild.type=="date") || (eChild.type=="password") || (eChild.type=="checkbox") || (eChild.type=="textarea")) return(eChild);
		if(eChild.nodeName.equalsIgnoreCase("textarea")) return(eChild);
		if(eChild.nodeName.equalsIgnoreCase("text")) return(eChild);
	};
//appendToLog("getTableCellControl returning null");
	return(null);
};

/******************************************************************************
Returns the TD of the cell with the given KeyValue and Field ID
******************************************************************************/
function getTableCell(table,AKeyValue,AFieldID)
{
//appendToLog("getTableCell table="+table+" KeyValue="+AKeyValue+" FieldID="+AFieldID);
	var row=getTableRow(table,AKeyValue);
	if(row==null) {
//appendToLog("getTableCell row=null");
		return(null);
	};

	var arFieldID=getSubStringArray(table.getAttribute("aspectFields"),",",true);
//appendToLog("getTableCell arFieldID="+arFieldID);
	for (var i=0;i<row.cells.length;i++) {
		var sCellIndex=row.cells[i].getAttribute("CellIndex");
		if(sCellIndex) {
			var iCellIndex=parseInt(sCellIndex);
			var sFieldID=arFieldID[iCellIndex];
			if(sFieldID) {
				if(sFieldID.equalsIgnoreCase(AFieldID)) {
					return(row.cells[i]);
				};
			};
		};
	};

//appendToLog("getTableCell returning null");
	return(null);
};

/******************************************************************************
Returns the TR containing with given KeyValue
******************************************************************************/
function getTableRow(table,AKeyValue)
{
	if(!table) return(null);
	
	for (var i=0;i<table.rows.length;i++) {
		if(!table.rows[i].getAttribute("istemplate")) {
			var sKeyValue=table.rows[i].getAttribute("KeyValue");
			if((sKeyValue) && (sKeyValue.equalsIgnoreCase(AKeyValue))) return(table.rows[i]);
		};
	};

	return(null);
};

/******************************************************************************
Returns the value of the given KeyValue and FieldID
******************************************************************************/
function getTableRowFieldValue(table,AKeyValue,AFieldID)
{
	//get the index of the field in the aspectallfieldid attribute
	var arAllFieldID=getSubStringArray(table.getAttribute("aspectallfieldid"),",",true);
	var iFieldIndex=arAllFieldID.indexOf(AFieldID);
	if(iFieldIndex<0) {
		appendToLog("Error in getTableRowFieldValue.  Cannot find field: "+AFieldID,false,true);
		return(null);
	};

	//locate the row containing the key value
	var row=getTableRow(table,AKeyValue);
	if(row==null) {
		appendToLog("Error in getTableRowFieldValue.  Cannot locate row with keyvalue="+AKeyValue,false,true);
		return(null);
	};

	var arValues=getSubStringArray(getAttr(row,"aspectAllValues"),",",true);
	if(iFieldIndex>=arValues.length) {
		appendToLog("Error in getTableRowFieldValue.  Index out of range.",false,true);
		return(null);
	};

	return(arValues[iFieldIndex]);
};

/******************************************************************************
Returns the input control for the field with the given FieldID in the edit dialog
******************************************************************************/
function getDialogControl(eDialog,AKeyValue,AFieldID) {
	//abort if a key value has not been defined because the dialog has not been initialized or 
	//if the dialog is displaying fields for another record
	var sKeyValue=eDialog.getAttribute("KeyValue");
	if(!sKeyValue) return(null);
	if(sKeyValue.equalsIgnoreCase(AKeyValue)==false) return(null);

	var arNodes=new Array();
	getAllInputNodes(eDialog,arNodes);
	for (var i=0;i<arNodes.length;i++) {
		if((arNodes[i].type=="select-one") || (arNodes[i].type=="select-multiple") || (arNodes[i].type=="text") || (arNodes[i].type=="password") || (arNodes[i].type=="checkbox") || (arNodes[i].type=="textarea")) {
			var s=arNodes[i].getAttribute("name");
			if((s) && (s.equalsIgnoreCase(AFieldID))) return(arNodes[i]);
		};
	};
	return(null);
};

/******************************************************************************
Updates the value of a field in the attributes for a row.  This is necessary so
a dialog will be initialized with the correct values if data is edited in a 
dialog and then the dialog is opened a 2nd time.  Operates on a single
Field ID and Value.  An array of values is not permitted.
******************************************************************************/
function setFieldValueInRow(ATableID,AKeyValue,AFieldID,AValue)
{
	var table=document.getElementById(ATableID);
	var arFieldID=getSubStringArray(table.getAttribute("aspectAllFieldID"),",",true);
//appendToLog("setFieldValueInRow: TableID="+ATableID+" KeyValue="+AKeyValue+" FieldID="+AFieldID+" Value="+AValue,false,true);
	var arChangedKeyValue=getSubStringArray(AKeyValue,",",false);
	var arChangedFieldID=getSubStringArray(AFieldID,",",false);
	
	if(AValue=="") {
		var arChangedValue=new Array(1);
		arChangedValue[0]="";
	}
	else {
		var arChangedValue=getSubStringArray(AValue,",",false);
	};
	
	//locate the row containing the keyexpression
	for (var i=0;i<arChangedKeyValue.length;i++)
	{
		var cUpdated=0;
		for (var row=0;row<table.rows.length;row++) {
			var sKeyValue=table.rows[row].getAttribute("keyvalue");
			if((sKeyValue) && (sKeyValue.equalsIgnoreCase(arChangedKeyValue[i]))) {
				var sSubtotalLevel=table.rows[row].getAttribute("AspectSubtotalLevel");
//appendToLog("setFieldValueInRow: sSubtotalLevel="+sSubtotalLevel+" parseInt="+parseInt(sSubtotalLevel));
				if((sSubtotalLevel) && (parseInt(sSubtotalLevel)<0)) {
					var arValues=getSubStringArray(getAttr(table.rows[row],"aspectAllValues"),",",true);
					var n=getFieldIndex(arChangedFieldID[i],arFieldID);
					arValues[n]=arChangedValue[i];
					arValues[n]=tokenizeTableValue(arValues[n],true);
					setAttr(table.rows[row],"aspectAllValues",arValues.toString());
					cUpdated++;
				}
				else {
					alert("Error: Missing subotalLevel attribute in setFieldValueInRow");
				}
			};
		};
		if(cUpdated==0) {
			//This can happen if RefreshOnDataSubmit is true for the table and the record no longer appears in the table after
			//an edit.  For example, clicking the Complete checkbox in the New Customer Checklist table may cause a record to 
			//be filtered out when the data is submitted.
			//alert("Error in setFieldValueInRow.  Could not update value for Key="+AKeyValue+" FieldID="+AFieldID+" Value="+AValue);
		};
	};
};

/********************************************************************************************************
Used to debug mergeTable2012 (need to un-hardwire table ID's)
********************************************************************************************************/
function outputTables(DestID,SrcID,s)
{
	appendToLog("============================================");
	appendToLog(s);
	appendToLog("Source table ID: "+SrcID);
	appendToLog("Dest table ID: "+DestID);
	appendToLog("============================================");
	var tableSrc=document.getElementById(SrcID);
	var tableDest=document.getElementById(DestID);
	for (var i=0;i<20;i++) {
		if(i<tableDest.rows.length) 	{
			var sSrcKey=getRowKey(tableSrc.rows[i]);
			var sDestKey=getRowKey(tableDest.rows[i]);
			var sMatch=(sSrcKey==sDestKey) ? "" : "Mismatch";
			appendToLog("row: "+i+" SrcKey="+sSrcKey+" DestKey="+sDestKey+" "+sMatch);
		};
	};
	appendToLog("============================================");
};

/********************************************************************************************************
Called by mergeTable2012 to get the key for a row which depends on whether it's a record or 
a section header
********************************************************************************************************/
function getRowKey(row)
{
	//look for table header
	if(row.getAttribute("istableheader")) {
		return(row.getAttribute("headerid"));
	};
	
	//look for section header
	if(row.getAttribute("issectionheader")) {
		return(row.getAttribute("headerkey"));
	};

	s=row.getAttribute("KeyValue");
	if(s) return(s);
	return("");
};

/********************************************************************************************************
Merges records from a source table into a destination table.  (see notifications in the control panel as an example).
A hidden table can be used as a buffer that is updated at some interval.  If a state element is used,
it does not take much time.  The destination table can then be updated from the buffer when new
records become available
********************************************************************************************************/
function mergeTable2012(DestID,SrcID)
{
	//appendToLog("mergeTable2012( dest="+DestID+" src="+SrcID);
	var tableSrc=document.getElementById(SrcID);
	var tableDest=document.getElementById(DestID);

	if(!tableSrc) {
		appendToLog("Invalid source table in mergeTable2012: "+SrcID);
		return;
	};

	if(!tableDest) {
		appendToLog("Invalid destination table in mergeTable2012: "+DestID);
		return;
	};

	//make a collection of all records in the source and dest
	//NOTE: Can't use getKeyValues() because section headers are not included
	var arSrcKey=new Array();
	for(var i=0;i<tableSrc.rows.length;i++) {
		arSrcKey[arSrcKey.length]=getRowKey(tableSrc.rows[i]);
	};
	
	var arDestKey=getKeyValues(DestID,false);
	for(var i=0;i<tableDest.rows.length;i++) {
		arDestKey[arDestKey.length]=getRowKey(tableDest.rows[i]);
	};

	//appendToLog("Merging tables.  DestRows="+tableDest.rows.length+" SrcRows="+tableSrc.rows.length);
	//delete any records from dest that are not in src
	//outputTables(DestID,SrcID,"Before delete");
	var n=1;
	while(n<tableDest.rows.length) 	{
		//don't merge the template used to insert new records
		if(!tableDest.rows[n].getAttribute("istemplate")) {
			var sDestKey=getRowKey(tableDest.rows[n]);
			if(sDestKey.length>0) {
				if(countPendingSubmissions(DestID,sSrcKey)==0) {
					if(arSrcKey.indexOf(sDestKey)<0) {
						var bDelete=true;
						if(false) {
							for(var cell=0;cell<tableDest.rows[n].cells.length;cell++) {
								var attr=tableDest.rows[n].cells[cell].getAttribute("AspectSubmissionPending");
								if((attr) && ((attr=="new") || (attr=="pending"))) {
									bDelete=false;
								};
							};
						};

						if(bDelete) {
							tableDest.deleteRow(n);
							appendToLog("mergeTable2012 deleted row: "+n+" DestKey="+sDestKey,false,true);
						}
						else {
							appendToLog("mergeTable2012 not deleting row: "+n+" key="+sDestKey+" because it is a new record");
							n++;
						};
					}
					else {
						n++;
					};
				}
				else {
					n++;
				};
			}
			else {
				n++;
			};
		}
		else {
			n++;
		};
	};
	//outputTables(DestID,SrcID,"After delete");

	var cInsert=0;
	for (var i=1;i<tableSrc.rows.length;i++) 
	{
		if(!tableSrc.rows[i].getAttribute("istemplate")) {
			var bInsertRow=true;
			var sSrcKey=getRowKey(tableSrc.rows[i]);
			
			//don't merge the row if it has outstanding submissions.  This avoids overwriting data that
			//has been edited but not saved yet
			if(countPendingSubmissions(DestID,sSrcKey)==0) 
			{
				//appendToLog("mergeTable2012: updating record "+sSrcKey);

				var sDestKey="";
				if(i<tableDest.rows.length) sDestKey=getRowKey(tableDest.rows[i]);
				//appendToLog("Adding row: "+i+" SrcKey="+sSrcKey+" DestKey="+sDestKey);	
				if((sSrcKey) && (sDestKey)) 
				{
					if(sSrcKey.equalsIgnoreCase(sDestKey)) {
						//appendToLog("Found matching record");
						//found a matching record

						//update the virtual index if defined
						if(tableSrc.rows[i].getAttribute("virtualindex")) {
							tableDest.rows[i].setAttribute("virtualindex",tableSrc.rows[i].getAttribute("virtualindex"));
						};

						var sSrcCRC=tableSrc.rows[i].getAttribute("crc");
						var sDestCRC=tableDest.rows[i].getAttribute("crc");
						if(sSrcCRC!=sDestCRC) {
							for(var j=0;j<tableSrc.rows[i].cells.length;j++) {
								if(tableDest.rows[i].cells[j]) {
									tableDest.rows[i].cells[j].innerHTML=tableSrc.rows[i].cells[j].innerHTML;
								};
							};
							tableDest.rows[i].setAttribute("crc",sSrcCRC);
							//appendToLog("Updated record: Key="+sSrcKey+" row="+i+" SrcCRC="+sSrcCRC+" DestCRC="+sDestCRC);
						}
						else {
							//appendToLog("record not modified: Key="+sSrcKey+" row="+i);
						};
					}
					else {
						//see if the record exists anywhere in the destination table
						var iDestRow=getTableRowContainingKey(tableDest,sSrcKey);
						//appendToLog("Looking for matching key.  iDestRow="+iDestRow);
						if(iDestRow>=0) {
							//the record was found elsewhere in the table
							
							//update the virtual index if defined
							if(tableSrc.rows[i].getAttribute("virtualindex")) {
								tableDest.rows[iDestRow].setAttribute("virtualindex",tableSrc.rows[i].getAttribute("virtualindex"));
							};
							
							var sSrcCRC=tableSrc.rows[i].getAttribute("crc");
							var sDestCRC=tableDest.rows[iDestRow].getAttribute("crc");
							if(sSrcCRC!=sDestCRC) {
								for(var j=0;j<tableSrc.rows[i].cells.length;j++) {
									if(tableDest.rows[iDestRow].cells[j]) {
										tableDest.rows[iDestRow].cells[j].innerHTML=tableSrc.rows[i].cells[j].innerHTML;
									};
								};
							};
						}
						else {
							//add a new record
							appendToLog("mergeTable2012 Insert row: "+i+" SrcKey="+sSrcKey+" DestKey="+sDestKey);
							var clone=tableSrc.rows[i].cloneNode(true);
							var tbody=null;
							for(var j=0;j<tableDest.childNodes.length;j++) {
								if(tableDest.childNodes[j].nodeName.toUpperCase()=="TBODY") tbody=tableDest.childNodes[j];
							};
							if(i<tableDest.rows.length-1) {
								tbody.insertBefore(clone,tableDest.rows[i]);
							}
							else {
								tbody.appendChild(clone);
							};

							//outputTables(DestID,SrcID,"After insert");
							cInsert++;
							
							arDestKey=getKeyValues(DestID,false);
						};
					};
				}
				else {
					//add a new record
					//appendToLog("Insert row: "+i+" SrcKey="+sSrcKey+" DestKey="+sDestKey);
					var clone=tableSrc.rows[i].cloneNode(true);
					var tbody=null;
					for(var j=0;j<tableDest.childNodes.length;j++) {
						if(tableDest.childNodes[j].nodeName.toUpperCase()=="TBODY") tbody=tableDest.childNodes[j];
					};
					tbody.appendChild(clone);

					//outputTables(DestID,SrcID,"After insert");
					cInsert++;
					arDestKey=getKeyValues(DestID,false);
				};
			}
			else {
				appendToLog("mergeTable2012: Not updating record "+sSrcKey+" because there are outstanding submissions");
			};
		};
	};
	//appendToLog("mergeTable2012 complete");
};

/**********************************************************************
Returns an array of keyvalues from the given table.  if bSelectedOnly is true, only returns
values for which the select checkbox is clicked.  Returns null if the table does not exist.
**********************************************************************/
function getKeyValues(tableid,bSelectedOnly)
{
	var eTable=document.getElementById(tableid);
	if(!eTable) {
		appendToLog("getKeyValues cannot locate table with ID="+tableid,false,true);
		return(null);
	};

	//determine the cell that contains the select checkbox
	var iSelectCell=-1;
	if(bSelectedOnly) {
		iSelectCell=getTableRecordSelectIndex(tableid);
	};

	var arKeyValue=new Array();

	for (var row=0;row<eTable.rows.length;row++) {
		var bInclude=true;
		//don't include section headers and table headers
		if(eTable.rows[row].getAttribute("keyvalue")) {
			if(bSelectedOnly) {
				if((iSelectCell>=0) && (eTable.rows[row].cells[iSelectCell])) {
					bInclude=eTable.rows[row].cells[iSelectCell].firstChild.checked;
				}
				else {
					bInclude=false;
				};
			};
		}
		else {
			bInclude=false;
		};
		
		if(bInclude) arKeyValue[arKeyValue.length]=eTable.rows[row].getAttribute("KeyValue");
	};

	/*****************************
	9/1/2014 - Don't know why this 2nd pass is here.  Could have been for debugging.
	*****************************/
	if(arKeyValue.length==0) {
		//appendToLog("getKeyValues: No records selected in table "+tableid+". Rows="+eTable.rows.length+" iSelectCell="+iSelectCell,false,true);
		for (var row=0;row<eTable.rows.length;row++) {
			var bInclude=true;
			if(eTable.rows[row].getAttribute("keyvalue")) {
				if(bSelectedOnly) {
					if((iSelectCell>=0) && (eTable.rows[row].cells[iSelectCell])) {
						bInclude=eTable.rows[row].cells[iSelectCell].firstChild.checked;
						//appendToLog("row["+row+"] child="+eTable.rows[row].cells[iSelectCell].firstChild+" checked="+eTable.rows[row].cells[iSelectCell].firstChild.checked+" included="+bInclude,false,true);
					}
					else {
						bInclude=false;
						//appendToLog("row["+row+"] not included.  iSelectCell="+iSelectCell+" cell="+eTable.rows[row].cells[iSelectCell]+"\r\n",false,true);
					};
				};
			}
			else {
				bInclude=false;
				//appendToLog("row["+row+"] keyvalue not defined",false,true);
			};
			
			if(bInclude) arKeyValue[arKeyValue.length]=eTable.rows[row].getAttribute("KeyValue");
		};
	};
	
	return(arKeyValue);
};

/*********************************************************************************
Shows/hides table rows for a given section.  Called when a section header is clicked.
*********************************************************************************/
function toggleTableRows(TableID,HeaderID)
{
	//get the table
	var table=document.getElementById(TableID);
	if(!table) {
		alert("cannot find table: "+TableID);
		return;
	};

	//
	for(var i=0;i<table.rows.length;i++) {
		var sHeaderID=table.rows[i].getAttribute("headerid");
		if((sHeaderID) && (sHeaderID==HeaderID)) {
			if(!table.rows[i].getAttribute("headerkey")) {
				toggleVisible(table.rows[i]);
			};
		};
	};
};

/********************************************************************
Sets the date/time in the table header
********************************************************************/
function setTableUpdateTime(Table)
{
	if(!Table) return;
	if(Table.id.length>0) {
		var e=document.getElementById("table_updated_"+Table.id);
		if(e) {
			e.innerHTML=formatDate(new Date(),"MM-dd-yyyy HH:mm:ss");
		};
	};
	Table.setAttribute("TimeInitialized","true");
};

/********************************************************************
Sets the style of a control to indicate that data submission is pending or complete
********************************************************************/
function setPendingSubmissionStyle(e,bIsTableCell,bPending)
{
	var sDebugName=(e.getAttribute) ? e.getAttribute("name") : "undefined";
	//appendToLog("setPendingSubmissionStyle e="+e+" IsTableCell="+bIsTableCell+" Pending="+bPending+" Name="+sDebugName,false,true);
	var eToSet=e;
	if(eToSet.type=="checkbox") eToSet=eToSet.parentNode;

	//if it's a hidden input associated with a datalist, change the element to the visible 
	//one used to get the input
	if((eToSet.type) && (eToSet.type.equalsIgnoreCase("hidden"))) {
		var sDataListID=eToSet.getAttribute("List");
		//appendToLog("eToSet.type="+eToSet.type+" sDataListID="+sDataListID);
		if(sDataListID) {
			eToSet=document.getElementById(sDataListID+"_input");
		}
		else {
			//alert("Error: setPendingSubmissionStyle: Datalist input with ID="+sDataListID+"_input not found");
		};
	};
		
	if(bPending) {
		if(eToSet.style) {
			var c=getComputedStyle(eToSet).backgroundColor;
			if(!eToSet.getAttribute("NonPendingBackgoundColor")) {
				eToSet.setAttribute("NonPendingBackgoundColor",c);
				//appendToLog("Saving background color: "+c,false,true);
			};
			eToSet.style.backgroundColor=PendingSubmissionBackgroundColor;
		}
		else {
			appendToLog("Cannot set style for type="+e.type+" nodeName="+e.nodeName,false,true);
		};
	}
	else {
		if(eToSet.style) {
			//eToSet.style.backgroundColor="white";
			var c=eToSet.getAttribute("NonPendingBackgoundColor");
//appendToLog("Setting background color to "+c,false,true);
			if(c) {
				eToSet.style.backgroundColor=c;
			}
			else {
				eToSet.style.backgroundColor="white";
			};
		}
		else {
			appendToLog("Cannot set style for type="+e.type+" nodeName="+e.nodeName,false,true);
		};
	};
};

/********************************************************************
Sets the background color of subtotal records.  Called by gotPendingSubmissions() 
when a table is about to be refreshed because data has been submitted and by 
refreshTableOnInterval() to reset the background after the table has been refreshed.
********************************************************************/
function highlightSubtotals(table,b) {
	for(var i=0;i<table.rows.length;i++) {
		var s=table.rows[i].getAttribute("aspectsubtotallevel");
		if(s) {
			if(parseInt(s)>=0) {
				setPendingSubmissionStyle(table.rows[i],false,b);
			};
		};
	};
};

/********************************************************************
Returns the index of the given FieldID in the given array of Field ID's.
Takes into account that the FieldID may not be the full ID
********************************************************************/
function getFieldIndex(FieldID,arFieldID)
{
	if(!arFieldID) {
		appendToLog("arFieldID is null in getFieldIndex");
		return(-1);
	};
	
	var n=arFieldID.indexOf(FieldID);
	
	/**************************************************************
	The following section is just to test for problems with FullID vs ID
	When debugged, only the above line is required
	**************************************************************/
	var sID=FieldID;
	var Match=-1;
	while(sID.indexOf(".")>=0) sID=sID.substring(sID.indexOf(".")+1);
	for(var i=0;((Match<0) && (i<arFieldID.length));i++) {
		var s=arFieldID[i];
		while(s.indexOf(".")>=0) s=s.substring(s.indexOf(".")+1);
		if(sID.equalsIgnoreCase(s)) Match=i;
	};

	if(n!=Match) {
		if(Match>=0) {
			appendToLog("getFieldIndex error n="+n+" Match="+Match+" For FieldID="+FieldID+" Match="+arFieldID[Match]+" Fields="+arFieldID);
		}
		else {
			appendToLog("getFieldIndex error n="+n+" Match="+Match+" For FieldID="+FieldID+" Fields="+arFieldID);
		};
	};
	return(Match);
};

/********************************************************************
Updates all cells in a table row to reflect the values in the aspectallvalues attribute.
Called after data has been edited and when new data is requested from the driver.
if AExcludeInputs is true, input fields will be excluded from the update.  This is
done to avoid overwriting changes to fields that may not have been submitted yet.  This
can be a problem if several fields are edited successively.
********************************************************************/
function updateCellsInRecord(table,AKeyValue,AExcludeInputs)
{
	var bExcludeInputs=((AExcludeInputs) && (AExcludeInputs==true));
	
	//appendToLog("updateCellsInRecord AKeyValue="+AKeyValue);
	
	//check for aspectallfieldid attribute.  This attribute will not be defined if editing is not enabled for the table.
	if(!table.getAttribute("aspectallfieldid")) {
		appendToLog("Error in updateCellsInRecord(): aspectallfieldid not defined.  Make sure that editing is enabled for the table",false,true);
		return;
	};
	
	var arAllFieldID=getSubStringArray(table.getAttribute("aspectallfieldid"),",",false);
	var arAllFieldType=getSubStringArray(table.getAttribute("aspectallfieldtype"),",",false);
	var arAllPattern=getSubStringArray(table.getAttribute("aspectAllFieldPattern"),",",false);

	var arTableFields=getSubStringArray(table.getAttribute("aspectfields"),",",true);
	var arFieldID=getSubStringArray(table.getAttribute("aspectallfieldid"),",",true);
	var row=getTableRowContainingKey(table,AKeyValue);
	var arValues=getSubStringArray(getAttr(table.rows[row],"aspectAllValues"),",",true);
	for(var i=0;i<arValues.length;i++) arValues[i]=tokenizeTableValue(arValues[i],false);

	//The aspecthtmlvalues attribute is set after a record has been edited using values returned from getRecordValues.
	//The aspectallvalues attribute contains data read using getField().  The aspecthtmlvalues attribute contains data
	//read using getFieldForHtml.  It should be used to set the value of table cells if it's available.
	var arHtmlValues=null;
	if(table.rows[row].getAttribute("aspecthtmlvalues")) {
		arHtmlValues=getSubStringArray(table.rows[row].getAttribute("aspecthtmlvalues"),",",true);
		for(var i=0;i<arHtmlValues.length;i++) arHtmlValues[i]=tokenizeTableValue(arHtmlValues[i],false);
	};
	
	for (var cell=0;cell<table.rows[row].cells.length;cell++) 
	{
		//or some reason, IE returns a value of 0 or 1 for the columns containing the select checkbox and edit icon.
		//get the name to deal with this.  The name should be null for every cell except those two.
		var s=table.rows[row].cells[cell].getAttribute("cellIndex");
		var sName=table.rows[row].cells[cell].getAttribute("name");
		if((!sName) && (s)) {
			var iCellIndex=parseInt(s);
			var sFieldID=arTableFields[iCellIndex];
			var n=getFieldIndex(sFieldID,arFieldID);
			if((n>=0) && (n<arValues.length))
			{
				//get the control contained in the cell and determine if it is active
				var bIsActiveElement=false;
				if(document.activeElement) {
					var arInput=table.rows[row].cells[cell].getElementsByTagName("input");
					if(!arInput) arInput=table.rows[row].cells[cell].getElementsByTagName("select");
					if(arInput) {
						bIsActiveElement=(document.activeElement==arInput[0]);
					};
				};

				if(!bIsActiveElement) {
					var sValue=(arHtmlValues==null) ? arValues[n] : arHtmlValues[n];
					table.rows[row].cells[cell].innerHTML=sValue;
//appendToLog("updateCellsInRecord updating cell="+iCellIndex+" FieldID="+sFieldID+" n="+n+" value="+arValues[n]+" htmlValue="+arHtmlValues[n],false,true);
				}
				else {
					//alert("skipping active element");
//appendToLog("updateCellsInRecord skipping active element cell="+iCellIndex+" FieldID="+sFieldID+" n="+n+" value="+arValues[n]+" htmlValue="+arHtmlValues[n],false,true);
				};

				if(sValue)
				{
/************************************************
					var Control=null;
					for (var i=0;(Control==null) && (i<table.rows[row].cells[cell].childNodes.length);i++) {
						var eChild=table.rows[row].cells[cell].childNodes[i];
						if((eChild.type=="select-one") || (eChild.type=="select-multiple") || (eChild.type=="text") || (eChild.type=="password") || (eChild.type=="checkbox") || (eChild.type=="textarea")) {
							Control=eChild;	
						}
						else	if(eChild.nodeName.equalsIgnoreCase("textarea")) {
							Control=eChild;	
						}
						else if(eChild.nodeName.equalsIgnoreCase("text")) {
							Control=eChild;	
						};
					};
					
					if(Control!=null) {
						if(Control.type=="checkbox") {
							if(!bExcludeInputs) Control.checked=(sValue.equalsIgnoreCase("true"));
						}
						else {
							if((Control.nodeName.equalsIgnoreCase("text")) || (Control.nodeName.equalsIgnoreCase("password"))) {
								if(sValue!=null) {
									Control.innerHTML=sValue; //need to set the value of the control first to properly handle empty strings (see note in formatField)
									var s=formatField(table.getAttribute("id"),Control,sValue,arAllFieldID,arAllFieldType,arAllPattern);
									Control.innerHTML=s;
								}
								else {
									appendToLog("updateCellsInRecord sValue=null for "+sFieldID,false,true);
								};
							}
							else {
								if(!bExcludeInputs) Control.value=sValue;
							};
						};
					};
**************************************************/					
				};
			}
			else {
				if(n<0) {
					//appendToLog("updateCellsInRecord skipped FieldID="+sFieldID+" n="+n+" Make sure it is included in the embedded fields.  arFieldID="+arFieldID,false,true);
				}
				else {
					//appendToLog("updateCellsInRecord skipped FieldID="+sFieldID+" n="+n+" values len="+arValues.length,false,true);
				};
			};
		}
		else {
			//appendToLog("updateCellsInRecord skipped cellIndex="+s+" sName="+sName,false,true);
		};
	};
};

function tableRowIsDeleted(TR)
{
	var s=TR.getAttribute("deleted");
	if(!s) return(false);
	if(s.equalsIgnoreCase("true")) return(true);
	return(false);
};

function tableRowIsTemplate(TR)
{
	var s=TR.getAttribute("ID");
	if(!s) return(false);
	if(s.toUpperCase().startsWith("InsertTemplate")) return(true);
	return(false);
};

/***********************************************************************
Called when a record is added from within the edit dialog.  e is the control clicked to make
the call.
***********************************************************************/
function addDialogRecord(e)
{
	//appendToLog("addDialogRecord",true);

	//get the div containing the dialog
	var eDialog=getDialogNode(e);
	if(!eDialog) {
		appendToLog("Unable to locate dialog containing element in addDialogRecord");
		return;
	};

	//get the table
	var sTableID=eDialog.getAttribute("TableID");
	var table=document.getElementById(sTableID);
	
	var iNewRow=insertTableRecord(sTableID);
	if(iNewRow>=0) {
		//hide the disable div 
		if(document.getElementById("EditDialogDisable"+sTableID)) setVisible("EditDialogDisable"+sTableID,false);

		//set the keyvalue of the dialog
		var sKeyValue=table.rows[iNewRow].getAttribute("keyvalue");
		eDialog.setAttribute("keyvalue",sKeyValue);

		//set the values in the dialog
		var arFieldID=getSubStringArray(table.getAttribute("aspectAllFieldID"),",",true);
		var arValues=getSubStringArray(getAttr(table.rows[iNewRow],"aspectAllValues"),",",true);
		for(var i=0;i<arValues.length;i++) arValues[i]=tokenizeTableValue(arValues[i],false);
		setDialogValues(sTableID,eDialog,arFieldID,arValues);
	}
	else {
		appendToLog("Unable to create new table record");
	};
};

/***********************************************************************
Called when a record is deleted from within the edit dialog.  e is the control clicked to make
the call.
***********************************************************************/
function deleteDialogRecord(e)
{
	//appendToLog("deleteDialogRecord",true);

	//get the div containing the dialog
	var eDialog=getDialogNode(e);
	if(!eDialog) {
		appendToLog("Unable to locate dialog containing element in addDialogRecord");
		return;
	};

	//get the table
	var sTableID=eDialog.getAttribute("TableID");
	var table=document.getElementById(sTableID);

	//get the keyvalue of the record being edited	
	var sKeyValue=eDialog.getAttribute("keyvalue");

	//locate the row containing the keyvalue of the record being edited
	var rCurrent=getTableRowContainingKey(table,sKeyValue)
	if(rCurrent<0) {
		appendToLog("Could not locate row containing key value "+sKeyValue);
		return;
	};

	//focus on the next record in the table
	updateDialogRecord(e,"next");

	//delete the record
	deleteTableRecords(sTableID,rCurrent);

	//remove the option from the dialog header's select box
	updateTableDialogHeader(sTableID);

	//disable dialog if no records are left
	//appendToLog("first record="+getFirstTableRow(table,false));
	if(getFirstTableRow(table,false)<0) disableTableDialog(sTableID);
};

/******************************************************************************
Returns the cell index (column) of the table cell containing the "Select" checkbox
It may be in 0 or 1 depending on whether editing is enabled
******************************************************************************/
function getTableRecordSelectIndex(ATableID)
{
	var table=document.getElementById(ATableID);
	var c=-1;
	for (var row=0;((c<0) && (row<table.rows.length));row++) {
		if((table.rows[row].cells[0]) && (table.rows[row].cells[0].firstChild.type=="checkbox")) {
			c=0;
		}
		else if((table.rows[row].cells[1]) && (table.rows[row].cells[1].firstChild.type=="checkbox")) {
			c=1;
		};
	};
	return(c);
};

/******************************************************************************
Called when the checkbox used to select all/none records is clicked
******************************************************************************/
function selectTableRecords(ATableID,e,HeaderID)
{
	var table=document.getElementById(ATableID);
	
	//abort if table not found
	if(!table) {
		alert("table not found: "+ATableID);
		return;
	};
	
	//the "select" checkbox might be in the 1st or 2nd column depending on whether an edit icon ia displayed
	var c=getTableRecordSelectIndex(ATableID);
	if(c>=0) {
		for (var row=0;row<table.rows.length;row++) {
			if(table.rows[row].cells[c]) {
				var sRowHeaderID=table.rows[row].getAttribute("headerid");
				var bSelect=((sRowHeaderID) && (sRowHeaderID.equalsIgnoreCase(HeaderID)));
				if(!bSelect) bSelect=((!sRowHeaderID) && (HeaderID.equalsIgnoreCase("NoHeaders")));
				if(bSelect) {
					var eCheck=table.rows[row].cells[c].firstChild;
					if((eCheck) && (eCheck.type=="checkbox")) eCheck.checked=e.checked;
				};
			};
		};
	};
};
/******************************************************************************
Called from initializeTables2012() to display any charts with ShowChart=true 
as an attribute.  Also called from the javascript initialization when a file 
is sent as an email attachment.
******************************************************************************/
var bInShowChart=false;
function showCharts() {
	if(bInShowChart) {
		console.log("showCharts exit because bInShowChart="+bInShowChart);
		return;
	};
	bInShowChart=true;

	var arDiv=document.getElementsByTagName("div");
	for(var i=0;i<arDiv.length;i++) {
		var sShowChart=arDiv[i].getAttribute("showchart");
		if(sShowChart) {
			if(sShowChart.equalsIgnoreCase("true")) {
				var sInitialized=arDiv[i].getAttribute("Initialized");
				if(!sInitialized) {
					//set to not visible.  This is done to avoid showGoogleChart just toggling 
					//the chart to not visible
					var sTableID=replaceAllSubstrings(arDiv[i].id,"googlechartoutputwrapper","");
					//displayChart1(sTableID);

					var table=document.getElementById(sTableID);
					var sChartType=table.getAttribute("aspectChartType");
					if((sChartType.equalsIgnoreCase("AspectLine")) || (sChartType.equalsIgnoreCase("AspectLineIndex")) || (sChartType.equalsIgnoreCase("AspectLine2")) || (sChartType.equalsIgnoreCase("AspectColumn")) || (sChartType.equalsIgnoreCase("AspectColumn2")) || (sChartType.equalsIgnoreCase("AspectScatter")) || (sChartType.equalsIgnoreCase("AspectScatter2"))) {
						//create an Aspect chart
						arDiv[i].setAttribute("Initialized","true");
						createChart(sTableID+"Chart");
						bInShowChart=false;
	
						//call showCharts again to display any remaining charts
						setTimeout("showCharts()",0);
					}
					else {
						//create a google chart
						hashPut("ChartTableID",sTableID);
						google.charts.setOnLoadCallback(showGoogleChartSub);
					};
					break;
				};
			};
		};
	};

	bInShowChart=false;
};

/******************************************************************************
display the chart for a table.  e is the icon used to open the graph and
is probably not needed
NOTE: THIS HAS BEEN REPLACED WITH DISPLAYCHART1() BELOW IN ORDER TO 
ADD GOOGLE CHARTS
******************************************************************************/
function displayChart(TableID,e)
{
	var sID="chart"+TableID;
	
	if(isVisible(sID)) {
		setVisible(sID,false);
		return;
	};
	
	var d=document.getElementById(sID);

	//replace the __requestserver__ token in the url for the chart image
	//This is not handled by TRpoxyHandler:handleNotification
/*	
	var arImg=d.getElementsByTagName("img");
	alert("Found "+arImg.length+" image tags in chart element");
	if(arImg.length>1) {
		var imgChart=arImg[1];
		var sSrc=imgChart.src;
		alert("src="+sSrc);
		if(sSrc.toUpperCase().indexOf("REQUESTSERVER")>=0) {
			if(sSrc.startsWith(getServer())) {
				sSrc=replaceAllSubstrings(sSrc,"__request"+"server__/","");
			}
			else {
				sSrc=replaceAllSubstrings(sSrc,"__request"+"server__",getServer());
			};
			imgChart.setAttribute("src",sSrc);
		};
		alert("new src="+imgChart.src);
	};
*/
	
	//make sure the chart is displayed relative to the body.  This is necessary
	//to position it properly.
	d.parentNode.removeChild(d);
	document.body.appendChild(d);
	
	var table=document.getElementById(TableID);
	d.style.position="relative";
	//var xy=getPosition2012(table,"absolute",d.parentNode);
	var xy=getPosition2012(table,"absolute",document.getElementsByTagName('BODY')[0]);
	d.style.left=(xy[0]+20)+"px"; //(table.offsetLeft+20)+"px";
	d.style.top=(xy[1]+40)+"px"; //(table.offsetTop+40)+"px";
	setVisible(d,true);
};

/******************************************************************************
display the chart for a table.  e is the icon used to open the graph and
is probably not needed
******************************************************************************/
function displayChart1(TableID,e) {
	//get the chart type
	var table=document.getElementById(TableID);
	var sChartType=table.getAttribute("aspectChartType");
console.log("displayChart1 sChartType="+sChartType);
	if((sChartType.equalsIgnoreCase("AspectLine")) || (sChartType.equalsIgnoreCase("AspectLineIndex")) || (sChartType.equalsIgnoreCase("AspectLine2")) || (sChartType.equalsIgnoreCase("AspectColumn")) || (sChartType.equalsIgnoreCase("AspectColumn2")) || (sChartType.equalsIgnoreCase("AspectScatter")) || (sChartType.equalsIgnoreCase("AspectScatter2"))) {
		var sID=TableID+"Chart";
		var e=document.getElementById(sID);
		if(e) {
			//just hide the chart if it's already visible
			if(isVisible(e)) {
				setVisible(e,false);
				e.style.display="none";
				return;	
			};
		};
		createChart(sID);
		return;
	};

	//show chart created by TChart
	if(document.getElementById("chart"+TableID)) 
	{
		//remove any content.  This is required if an Aspect chart has been displayed in the div
		//and then a google chart is displayed by changing the display
		document.getElementById("chart"+TableID).innerHTML="";

		showTChart(TableIID);
	};

	//show Google chart
	if(document.getElementById("googlechartdata"+TableID)) {
		showGoogleChart(TableID);
	};
}

/******************************************************************************
Called to display a google chart.  If the chart is already displayed, it is 
hidden.  Otherwise, the table ID is recorded in a temporary variable and 
setOnLoadCallback function is called to initiate the chart creation.
******************************************************************************/

function showGoogleChart(TableID) {

	var sChartDataID="googlechartdata"+TableID;
	var sChartOutputWrapperID="googlechartoutputwrapper"+TableID;
	var sChartOutputID="googlechartoutput"+TableID;

	if(isVisible(sChartOutputWrapperID)) {
		setVisible(sChartOutputWrapperID,false);
		var e=document.getElementById(sChartOutputWrapperID);
		e.style.display="none";

		var eChartDiv=document.getElementById(TableID+"Chart");
		if(eChartDiv) eChartDiv.style.display="none";

		return;
	};

	//setTimeout("showDialog('msg=Creating chart&icon=true')",0);
	
	hashPut("ChartTableID",TableID);

	//google.charts.setOnLoadCallback(showGoogleChartSub);
	setTimeout("google.charts.setOnLoadCallback(showGoogleChartSub)",100);
}; 


/******************************************************************************
This function does the work of creating the chart.  Data for the chart is 
supplied in a hidden div when the table is created.  The data is read from 
this div and passed to the google chart library to display the chart in 
an output div.  The output div is contained in a wrapper which is made 
visible just before calling for the chart to be created.
******************************************************************************/
function showGoogleChartSub() {

	//show progress bar.  For some reason, this is not displayed
	//showDialog('msg=Creating chart&icon=true');

	var TableID=hashGet("ChartTableID");
	var table=document.getElementById(TableID);
	var sChartDataID="googlechartdata"+TableID;
	var sChartOutputWrapperID="googlechartoutputwrapper"+TableID;
	var sChartOutputID="googlechartoutput"+TableID;

	var eChartOutput=document.getElementById(sChartOutputID);
	var iChartWidth=parseFloat(eChartOutput.getAttribute("width"));
	var iChartHeight=parseFloat(eChartOutput.getAttribute("height"));

	//get widths and heights that can be used as defaults if the chart is not visible 
	//and it's offsetWidth and offsetHeight return 0
	var eChartDiv=document.getElementById(TableID+"Chart");
	var sStyleWidth=(eChartDiv) ? eChartDiv.style.width : 0;
	var sStyleHeight=(eChartDiv) ? eChartDiv.style.height : 0;
	var iDocumentWidth=document.documentElement.offsetWidth;
//console.log("width1="+iChartWidth+" height1="+iChartHeight+" iDocumentWidth="+iDocumentWidth+" sStyleWidth="+sStyleWidth+" sStyleHeight="+sStyleHeight);

	var eChartDiv=document.getElementById(table.id+"Chart");
	if(eChartDiv) {
		//remove any content.  This is required if an Aspect chart has been displayed in the div
		//and then a google chart is displayed by changing the display
		eChartDiv.innerHTML="";

		setVisible(eChartDiv,true);
		if(iChartWidth==0) iChartWidth=eChartDiv.offsetWidth;
		if(iChartWidth==0) {
			iChartWidth=iDocumentWidth*0.95;
//console.log("set iChartWidth="+iChartWidth);
			if(sStyleWidth.indexOf("%")>0) {
//console.log("found width in style");
				var s=replaceAllSubstrings(sStyleWidth,"%","");
				var n=parseFloat(s);
//console.log("s="+s+" n="+n);
				if(n>0) {
					iChartWidth*=(n/100);
				};
			};
		};

		if(iChartHeight==0) iChartHeight=eChartDiv.offsetHeight;
		if(iChartHeight==0) {
			if(sStyleHeight.toUpperCase().indexOf("PX")>0) {
				var s=replaceAllSubstrings(sStyleHeight,"px","");
				iChartHeight=parseFloat(s);
//console.log("set iChartHeight="+iChartHeight+" s="+s);
				if(iChartHeight==0) {
//console.log("set iChartHeight to 500");
					iChartHeight=500;
				};
			};
		};
//console.log("width2="+iChartWidth+" height2="+iChartHeight);
	};

	var sChartType=table.getAttribute("aspectChartType");

	var eChartData=document.getElementById(sChartDataID);
	var a=getSubStringArray(eChartData.innerHTML,"|",true);

	var data=new google.visualization.DataTable();
	var a1=getSubStringArray(a[0],"^");
	for(var i=0;i<a1.length;i++) {
		if(i==0) {
			data.addColumn('string', a1[i]);
		}
		else {
			data.addColumn('number', a1[i]);
		};
	};

	//determine the interval at which data will be included in the chart.  The amount of data is 
	//limited for column charts.  Otherwise, the chart is truncated.
	var iDataInterval=1;
	if(sChartType.equalsIgnoreCase("Column")) {
		//set the number of bars to 1/3 the chart width.  This was chosen by experimenting.
		var iMaxColumn=iChartWidth/3;
		if(iMaxColumn<a.length) {
			iDataInterval=Math.floor(a.length/iMaxColumn+0)+1;
		};
	};
	
	//determine the interval at which data labels will be displayed
	//Don't implement this.  Let the chart do it.
	//var Interval=Math.floor(a.length/150)+1;
	var Interval=1;
	for(var i=1;i<a.length;i++) {
		if(i % iDataInterval==0) {
			var a1=getSubStringArray(a[i],"^");
			var a2=new Array();
			for(var j=0;j<a1.length;j++) {
				if(j==0) {
					if(i % Interval==0) {
						a2[j]=String(a1[j]);
					}
					else {
						//a2[j]="";
						a2[j]=String(a1[j]);
					};
				}
				else {
					a2[j]=parseFloat(a1[j]);
					if(isNaN(a2[j])) a2[j]=0;
				};
			}
			data.addRow(a2);
		};
	};

	var options={'title' : '',
		hAxis: {
			title: '',
			textStyle : { fontSize: '30px'}
		},
		vAxis: {
			title: '',
			textStyle : { fontSize: '30px'}
		},
		crosshair: {
			color: '#000',
			trigger: 'selection'
		},
		width:iChartWidth,
		height:iChartHeight,

		title: "",
		pointSize: 1,
		legend: 'bottom',
		_legend: {
			position:'bottom',
			textStyle : { fontSize: '30px'}
		},
	};

	//This is a quick fix for 2-axis charts.  It puts the first series on the first axis
	//and the second on the second axis.  There is no provision for more than 2 series.
	if(sChartType.equalsIgnoreCase("Line2")) {
		options.series={0: {targetAxisIndex: 0},1: {targetAxisIndex: 1}};
		options.vAxes={0: {title: 'Axis1'},1: {title: 'Axis2'}};
	};

	//add title if one is defined.
	var sChartTitle="";
	var eChartTitle=document.getElementById(TableID+"ChartTitle");
	if(eChartTitle) sChartTitle=eChartTitle.innerHTML;
	
	var s=table.getAttribute("ChartTitle");
	if((s) && (s.length>0)) sChartTitle=s;
	if(sChartTitle.length==0) {
		var eDisplayName=document.getElementById("SelectDisplay1"+TableID);
		if(eDisplayName) {
			sChartTitle=eDisplayName.options[eDisplayName.selectedIndex].text;
			var n=sChartTitle.indexOf(":");
			if(n>=0) sChartTitle=sChartTitle.substring(n+2);
		};
	};

	if(sChartTitle.length>0) options.title=sChartTitle;

	var eChartOutputWrapper=document.getElementById(sChartOutputWrapperID);

	eChartOutputWrapper.parentNode.removeChild(eChartOutputWrapper);

	//if a div is defined for the chart, add the chart to the div
	//if the table is not visible, add the chart to the parent node of the table so 
	//it appears where the table would
	if(eChartDiv) {
		eChartDiv.appendChild(eChartOutputWrapper);
	}
	else {
		//add a border around the chart
		eChartOutputWrapper.class="googlechartoutputborderedwrapper";

		//table.parentNode.insertBefore(eChartOutputWrapper,table);
		document.body.appendChild(eChartOutputWrapper);
	
		eChartOutputWrapper.style.position="absolute";
		var xy=getPosition2012(table,"absolute",document.getElementsByTagName('BODY')[0]);	

		eChartOutputWrapper.style.left=(Math.max(xy[0],0)+0)+"px"; //(table.offsetLeft+20)+"px";
		//eChartOutputWrapper.style.left=(xy[0]+20)+"px"; //(table.offsetLeft+20)+"px";
		eChartOutputWrapper.style.top=(xy[1]+40)+"px"; //(table.offsetTop+40)+"px";
	};

	eChartOutputWrapper.style.display="block";
	//setVisible(eChartOutputWrapper,true);

	showDialog();

	// Instantiate and draw chart, passing options.
	eChartOutput.innerHTML="";

	if(sChartType.equalsIgnoreCase("Bar")) {
		var chart=new google.visualization.BarChart(eChartOutput);
	}
	else if(sChartType.equalsIgnoreCase("Column")) {
		var chart=new google.visualization.ColumnChart(eChartOutput);
	}
	else if(sChartType.equalsIgnoreCase("Line")) {
		var chart=new google.visualization.LineChart(eChartOutput);
	}
	else if(sChartType.equalsIgnoreCase("Line2")) {
		var chart=new google.visualization.LineChart(eChartOutput);
	}
	else if(sChartType.equalsIgnoreCase("Pie")) {
		var chart=new google.visualization.PieChart(eChartOutput);
	}
	else if(sChartType.equalsIgnoreCase("Scatter")) {
		var chart=new google.visualization.ScatterChart(eChartOutput);
	}
	else if(sChartType.equalsIgnoreCase("Candlestick")) {
		var chart=new google.visualization.CandlestickChart(eChartOutput);
	}
	else {
		var chart=new google.visualization.LineChart(eChartOutput);
	};

	//var chart=new google.visualization.ComboChart(eChartOutput);

	// Wait for the chart to finish drawing before calling the getImageURI() method.
	/*
	google.visualization.events.addListener(chart, 'ready', function () {
		eChartOutput.innerHTML='<img src="' + chart.getImageURI() + '">';
	}); 
	*/
	
	chart.draw(data, options);

	//set the initialized flag in the chart wrapper
	var eChartWrapper=document.getElementById("googlechartoutputwrapper"+TableID);
	eChartWrapper.setAttribute("Initialized","true");
	
	//call showCharts again to display any remaining charts
	console.log("showGoogleChartSub complete for "+TableID);
	setTimeout("showCharts()",0);
};


/******************************************************************************
This function needs to be redone.  Do not try to copy contents from the 
iframe.  Use the getImageURI() function available in the google chart javascript.
******************************************************************************/
function printGoogleChart(ID,sWrapper) {
	var eToPrint=document.getElementById(ID);
	for(var i=0;i<eToPrint.childNodes.length;i++) {
		if(eToPrint.childNodes[i].nodeName=="IFRAME") {
		};
		var e=eToPrint.childNodes[i];
		for(var j=0;j<e.childNodes.length;j++) {
		};
	};
	return;

	//if the printer wrapper was retrieved, open the document in a new window
	if(sWrapper) {

		sWrapper +=eToPrint.innerHTML;
		sWrapper +="</body></html>";

		var docprint=window.open("","","toolbar=yes,location=no,directories=yes,menubar=yes,scrollbars=yes,width=650, height=600, left=100, top=25"); 
		docprint.document.open(); 
		docprint.document.write(sWrapper); 

		docprint.document.close(); 
		docprint.focus(); 
		return;
	}
	
	//get the printer wrapper
	var sUrl="__RequestServer__/?Network=GreenLight&ID=getCachedWidget&DocumentID=77NaWu0FhKDKXL7C70JpnKmy&Widget=Printer Wrapper";
	var sFunc="printGoogleChart(\""+ID+"\",s)";
	asynchInclude(null,sUrl,sFunc,sFunc);
};

function createGoogleTestChart() {
	google.charts.setOnLoadCallback(drawTestChart);
}; 

function drawTestChart() {
	// Define the chart to be drawn.

	var data=new google.visualization.DataTable();
	data.addColumn('string', 'Month');
	data.addColumn('number', 'Tokyo');
	data.addColumn('number', 'New York');
	data.addColumn('number', 'Berlin');
	data.addColumn('number', 'London');
	data.addRows([
		['Jan',  7.0, -0.2, -0.9, 3.9],
		['Feb',  6.9, 0.8, 0.6, 4.2],
		['Mar',  9.5,  5.7, 3.5, 5.7],
		['Apr',  14.5, 11.3, 8.4, 8.5],
		['May',  18.2, 17.0, 13.5, 11.9],
		['Jun',  21.5, 22.0, 17.0, 15.2],

		['Jul',  25.2, 24.8, 18.6, 17.0],
		['Aug',  26.5, 24.1, 17.9, 16.6],
		['Sep',  23.3, 20.1, 14.3, 14.2],
		['Oct',  18.3, 14.1, 9.0, 10.3],
		['Nov',  13.9,  8.6, 3.9, 6.6],
		['Dec',  9.6,  2.5,  1.0, 4.8]
	]);

	// Set chart options
	var options={'title' : 'Average Temperatures of Cities',
		hAxis: {
			title: 'Time',
			textStyle : { fontSize: '30px'}
		},
		vAxis: {
			title: 'Popularity',
			textStyle : { fontSize: '30px'}
		},
		colors: ['#a52714', '#097138'],
		crosshair: {
			color: '#000',
			trigger: 'selection'
		},
		width:800,
		height:400,
		title: "",
		legend: {
			position:'bottom',
			textStyle : { fontSize: '30px'}
		},
	};

	// Instantiate and draw the chart.
	var chart=new google.visualization.LineChart(document.getElementById('testgooglechartcontainer'));

	// Wait for the chart to finish drawing before calling the getImageURI() method.
	/*
	google.visualization.events.addListener(chart, 'ready', function () {
		testgooglechartcontainer.innerHTML='<img src="' + chart.getImageURI() + '">';
	});
	*/

	chart.draw(data, options);
}

/******************************************************************************
This function is used to display an image created by TChart when a table is 
created.  This is how charts were originally handled.
******************************************************************************/
function showTChart(TableID) 
{
	var sID="chart"+TableID;

	if(isVisible(sID)) {
		setVisible(sID,false);
		return;
	};
	
	var d=document.getElementById(sID);

	//make sure the chart is displayed relative to the body.  This is necessary
	//to position it properly.
	d.parentNode.removeChild(d);
	document.body.appendChild(d);
	
	var table=document.getElementById(TableID);
	d.style.position="absolute";
	//var xy=getPosition2012(table,"absolute",d.parentNode);
	var xy=getPosition2012(table,"absolute",document.getElementsByTagName('BODY')[0]);
	d.style.left=(xy[0]+0)+"px"; //(table.offsetLeft+20)+"px";
	d.style.top=(xy[1]+40)+"px"; //(table.offsetTop+40)+"px";
	setVisible(d,true);
};

function createChart(_id) {
	var eChartContainer=document.getElementById(_id);
	if(!eChartContainer) {
		console.log("Error: createChart: "+_id+" not found");
		return;
	};

	//make the element visible and add a single space.  If the element has no width, then it 
	//is not displayed so set a timeout and try again.
	eChartContainer.innerHTML=" ";
	setVisible(_id,true);

	//console.log("eChartContainer id="+_id+" width="+eChartContainer.offsetWidth);
	if(eChartContainer.offsetWidth==0) {
		setTimeout("createChart(\""+_id+"\")",1000);
		return;
	};
	
	//add title
	var eChartTitle=document.createElement("div");
	eChartTitle.id="ChartTitle"+_id;
	eChartTitle.setAttribute("class","chart_title");
	eChartTitle.innerHTML=getChartTitle(_id);
	eChartTitle.setAttribute("onmouseover","clearCrosshair('"+_id+"')");
	eChartContainer.appendChild(eChartTitle);

	//add left axis
	var eLeftAxis=document.createElement("div");
	eLeftAxis.id="ChartLeftAxis"+_id;
	eLeftAxis.setAttribute("class","chart_leftaxis");
	eLeftAxis.innerHTML="1000000000000";
	eLeftAxis.setAttribute("onmouseover","clearCrosshair('"+_id+"')");
	eChartContainer.appendChild(eLeftAxis);

	//add plot area container
	var ePlotAreaContainer=document.createElement("div");
	ePlotAreaContainer.id="ChartPlotAreaContainer"+_id;
	ePlotAreaContainer.setAttribute("class","chart_plotarea_container");
	eChartContainer.appendChild(ePlotAreaContainer);
	
	//add plot area
	var ePlotArea=document.createElement("div");
	ePlotArea.id="ChartPlotArea"+_id;
	ePlotArea.setAttribute("class","chart_plotarea");
	ePlotArea.setAttribute("onmousemove","showCrosshair(event,this)");
	ePlotArea.setAttribute("onmouseenter","showCrosshair(event,this)");
	
	//this causes flickering
	//ePlotArea.setAttribute("onmouseout","clearCrosshair(this)");

	ePlotAreaContainer.appendChild(ePlotArea);
	
	//add bottom axis
	var eBottomAxis=document.createElement("div");
	eBottomAxis.id="ChartBottomAxis"+_id;
	eBottomAxis.setAttribute("class","chart_bottomaxis");
	eBottomAxis.innerHTML="bottom<br>axis<br><br>";
	eBottomAxis.setAttribute("onmouseover","clearCrosshair('"+_id+"')");
	ePlotAreaContainer.appendChild(eBottomAxis);

	//add right axis
	var eRightAxis=document.createElement("div");
	eRightAxis.id="ChartRightAxis"+_id;
	eRightAxis.setAttribute("class","chart_rightaxis");
	eRightAxis.innerHTML="1000000000000";
	eRightAxis.setAttribute("onmouseover","clearCrosshair('"+_id+"')");
	eChartContainer.appendChild(eRightAxis);

	//add slider
	var eSliderDiv=document.createElement("div");
	eSliderDiv.setAttribute("class","chart_slider");
	eSliderDiv.id="ChartSlider"+_id;

	var eSliderControl=document.createElement("input");
	eSliderControl.id="Range"+_id;
	eSliderControl.setAttribute("class","slider_input");
	eSliderControl.setAttribute("type","range");
	//eSliderControl.setAttribute("min","0");
	//eSliderControl.setAttribute("max","1000");
	//eSliderControl.setAttribute("value","500");
	eSliderControl.setAttribute("onChange","scalePlotArea(\""+_id+"\")");
	eSliderDiv.appendChild(eSliderControl);
	eChartContainer.appendChild(eSliderDiv);

	//add legend
	var eLegend=document.createElement("div");
	eLegend.setAttribute("class","legend");
	eLegend.id="ChartLegend"+_id;
	eLegend.innerHTML="legend1<br>Legend2";
	eChartContainer.appendChild(eLegend);
	
	//get dimensions
	var iChartContainerWidth=eChartContainer.offsetWidth;
	var iChartContainerHeight=eChartContainer.offsetHeight;
	var iTitleHeight=eChartTitle.offsetHeight;
	var iLeftAxisWidth=eLeftAxis.offsetWidth;			
	var iRightAxisWidth=eRightAxis.offsetWidth;
	var iBottomAxisHeight=eBottomAxis.offsetHeight;
	var iSliderHeight=eSliderDiv.offsetHeight;
	var iLegendHeight=eLegend.offsetHeight;
	
	var iScrollbarHeight=eBottomAxis.offsetHeight;	//this needs to be corrected
	
	var iPlotAreaContainerWidth=iChartContainerWidth-iLeftAxisWidth-iRightAxisWidth;
	var iPlotAreaContainerHeight=iChartContainerHeight-iTitleHeight-iSliderHeight-iLegendHeight;
	var iPlotAreaHeight=iPlotAreaContainerHeight-iBottomAxisHeight-iScrollbarHeight;

	//set dimensions of plot area
	//ePlotAreaContainer.style.left=iLeftAxisWidth+"px";
	ePlotAreaContainer.style.marginLeft=iLeftAxisWidth+"px";
	ePlotAreaContainer.style.width=iPlotAreaContainerWidth+"px";
	ePlotAreaContainer.style.height=iPlotAreaContainerHeight+"px";
	ePlotArea.style.height=(iPlotAreaHeight-2)+"px";
	eSliderDiv.style.width=iPlotAreaContainerWidth+"px";
	eSliderDiv.style.marginLeft=iLeftAxisWidth+"px";

	eSliderControl.setAttribute("min",iPlotAreaContainerWidth);
	eSliderControl.setAttribute("max",5*iPlotAreaContainerWidth);
	eSliderControl.setAttribute("value",iPlotAreaContainerWidth);

	eLeftAxis.style.height=(iPlotAreaHeight+iBottomAxisHeight+iScrollbarHeight)+"px";
	eRightAxis.style.height=(iPlotAreaHeight+iBottomAxisHeight+iScrollbarHeight)+"px";

	setChartAxisScale(_id);
	drawLeftAxis(_id);
	drawRightAxis(_id);
	drawBottomAxis(_id);

	//note: this needs to come after setChartAxisScale so the location of the 
	//series (left/right) is known
	drawLegend(_id);

	initializePlotArea(_id);

	var sChartType=getChartType(_id);
	if((!sChartType.equalsIgnoreCase("AspectScatter")) && (!sChartType.equalsIgnoreCase("AspectScatter2"))) {
		drawDateMarkers(_id);
		drawRecessionTicks(_id);
	};
	drawZeroLine(_id,"left");
	drawZeroLine(_id,"right");
	setTimeout("drawPlot(\""+_id+"\",1);",0);
};

function getChartTitle(_id) {
	var sTableID=replaceAllSubstrings(_id,"Chart","");
	var table=document.getElementById(sTableID);

	var s=table.getAttribute("ChartTitle");
	if((s) && (s.length>0)) return(s);

	var eDisplayName=document.getElementById("SelectDisplay1"+sTableID);
	if(eDisplayName) {
		var s=eDisplayName.options[eDisplayName.selectedIndex].text;
		var n=s.indexOf(":");
		if(n>=0) s=s.substring(n+2);
		return(s);
	};

	return("");
};

function getChartType(_id) {
	var sTableID=replaceAllSubstrings(_id,"Chart","");
	var table=document.getElementById(sTableID);
	var sChartType=table.getAttribute("aspectChartType");
	return(sChartType);
};

function getChartData(_id) {
	var sTableID=replaceAllSubstrings(_id,"Chart","");
	var e=document.getElementById("googlechartdata"+sTableID);
	return(e.innerHTML);
};

function getAxisMinMax(_min,_max) {
	var tick=(_max-_min)/10;

	//console.log("_min="+_min);
	//console.log("_max="+_max);
	//console.log("tick="+tick);

	var Factor;
	if(tick<1) {
		Factor=0.1;
	}
	else if(tick<10) {
		Factor=1;
	}
	else if(tick<100) {
		Factor=10;
	}
	else {
		Factor=100;
	};

	tick=(Math.floor(tick/Factor)+1)*Factor;
	var min=Math.floor(_min/tick)*tick;
	var max=min+(tick*10);

	while(max<_max) max +=tick;

	//console.log("Factor="+Factor);
	//console.log("tick2="+tick);
	//console.log("min="+min);
	//console.log("max="+max);

	//try cutting the max by half
	if(max-tick*5>_max) {
		max-=tick*5;
	};

	//try cutting the max by one quarter
	if(max-tick*2.5>_max) {
		max-=tick*2.5;
	};

	//try increasing the min by half
	if(min+tick*5<_min) {
		min+=tick*5;
	};

	//try increasing the min by one quarter
	if(min+tick*2.5<_min) {
		min+=tick*2.5;
	};

	//console.log("min2="+min);
	//console.log("max2="+max);

	var a=new Array(min,max);
	return(a);
};

function setChartAxisScale(_id) {

	var sChartType=getChartType(_id);
	if((sChartType.equalsIgnoreCase("AspectLine2")) || (sChartType.equalsIgnoreCase("AspectColumn2")) || (sChartType.equalsIgnoreCase("AspectScatter2"))) {
	//if(getChartType(_id).equalsIgnoreCase("AspectLine2")) {
		setChart2AxisScale(_id);
		return;
	};

	var ChartData=getChartData(_id);
	var leftmin=0;
	var leftmax=0;
	var rightmin=0;
	var rightmax=0;
	var bottommin=0;
	var bottommax=0;
	
	var SeriesCount=getChartSeriesCount(ChartData);
	for(var i=1;i<SeriesCount;i++) {
		var a=getChartSeries(_id,ChartData,i);
		var min=getChartSeriesMin(a,_id);
		var max=getChartSeriesMax(a);

		if((!Number.isNaN(min)) && (!Number.isNaN(max))) {
			if(i==1) {
				if(sChartType.equalsIgnoreCase("AspectScatter")) {
					bottommin=min;
					bottommax=max;
				}
				else {
					leftmin=min;
					leftmax=max;
				};
			}
			else {
				if((sChartType.equalsIgnoreCase("AspectScatter")) && (i==2)) {
					//initialize min/max using first series that is not the X axis.  This is series 2.
					leftmin=min;
					leftmax=max;
				}
				else {
					leftmin=Math.min(leftmin,min);
					leftmax=Math.max(leftmax,max);
				};
			};
		};
	};
	
	if((leftmin==0) && (leftmax==0)) {
		leftmax=1;
	};

	if(leftmin==leftmax) {
		leftmin=leftmax*0.9;
		leftmax=leftmax*1.1;
	};

	//adjust min/max to make the scales more readable
	var a=getAxisMinMax(leftmin,leftmax);
	leftmin=a[0];
	leftmax=a[1];

	var e=document.getElementById(_id);
	e.setAttribute("LeftAxisMin",leftmin);
	e.setAttribute("LeftAxisMax",leftmax);
	e.setAttribute("RightAxisMin",rightmin);
	e.setAttribute("RightAxisMax",rightmin);
	e.setAttribute("BottomAxisMin",bottommin);
	e.setAttribute("BottomAxisMax",bottommax);

	for(var i=0;i<SeriesCount;i++) {
		e.setAttribute("SeriesAxis"+i,"left");
	};
};

function setChart2AxisScale(_id) {
	var sChartType=getChartType(_id);
	var armin=new Array();
	var armax=new Array();
	var sChartData=getChartData(_id);
	cSeries=getChartSeriesCount(sChartData);

	var bottommin=0;
	var bottommax=0;

	//get the min and max values for each series.  Remember that series 0 is the labels.
	for(var i=0;i<cSeries;i++) {
		if(i==0) {
			armin[armin.length]=-1
			armax[armax.length]=-1
		}
		else {
			armin[armin.length]=getChartSeriesMin(getChartSeries(_id,sChartData,i),_id);
			armax[armax.length]=getChartSeriesMax(getChartSeries(_id,sChartData,i));

			if(i==1) {
				bottommin=armin[armin.length-1];
				bottommax=armax[armax.length-1];
			};
		};
	};

/*
	for(var i=0;i<armin.length;i++) {
		console.log("A armin["+i+"]="+armin[i]+" armax["+i+"]="+armax[i]);
	};
*/

	//if dealing with a scatter chart, set min[0] and max[0] to min[1] and max[1].  This is a 
	//simple way of eliminating the min/max from the first series which is the X axis
	if(sChartType.equalsIgnoreCase("AspectScatter2")) {
		armin[1]=armin[2];
		armax[1]=armax[2];
	};

/*
	for(var i=0;i<armin.length;i++) {
		console.log("B armin["+i+"]="+armin[i]+" armax["+i+"]="+armax[i]);
	};
*/

	//console.log("cSeries="+cSeries);
	//console.log("armin="+armin.toString());
	//console.log("armax="+armax.toString());

	//test each possible combination
	var cTrial=0;
	var MinSpread=0;
	var bSpreadInitialized=false;

	//
	var arAxis=new Array();
	for(var i=0;i<cSeries;i++) {
		if(i==0) {
			arAxis[arAxis.length]="n/a";
		}
		else {
			arAxis[arAxis.length]="left";
		};
	};

	//an array with two elements representing the min and max value of the axis
	var LeftAxisRange=new Array();
	var RightAxisRange=new Array();

	//This loop tests every possible combination of left and right axis values.  
	//The i and j loops iterate through all possible values of left max and right max
	//Inside of that loop, k and l iterate through all possible min values
	//For each possible combination, every series is tested to see if it will fit inside 
	//one of the axes.  If not, the combination is considered invalid and ignored.
	
	//If the axes will accommodate all of the series, a spread is calculated to determine 
	//how well the series sit inside the axes.  This is just the sum of the axis maximum less 
	//the series maximum and the series minimum less the axis minimum.  The spread is summed 
	//for all series.  If the spread is less that the best spread so far, that ranges are recorded 
	//as well as the axis on which each series will be plotted.
	for(var i=0;i<cSeries;i++) {
		for(var j=1;j<cSeries;j++) {
			LeftMax=armax[i];
			RightMax=armax[j];
			for(var k=1;k<cSeries;k++) {
				for(var l=1;l<cSeries;l++) {
					LeftMin=armin[k];
					RightMin=armin[l];

					if((LeftMax>LeftMin) && (RightMax>RightMin)) {
						//see if all of the series can be accommodated 
						bIsValid=true;
						var arTestAxis=new Array();
						for(iSeries=1;iSeries<cSeries;iSeries++) {
							if((armin[iSeries]<LeftMin) || (armax[iSeries]>LeftMax)) {
								if((armin[iSeries]<RightMin) || (armax[iSeries]>RightMax)) {
									bIsValid=false;
									arTestAxis[iSeries]="invalid";
//console.log("("+LeftMin+","+LeftMax+"),("+RightMin+","+RightMax+") - Invalid");
									break;
								}
								else {
									arTestAxis[iSeries]="right";
								};
							}
							else {
								arTestAxis[iSeries]="left";

//console.log("Testing right axis.");
//console.log("armin="+armin[iSeries]+" RightMin="+RightMin);
//console.log("armax="+armax[iSeries]+" RightMax="+RightMax);
								//so far, the series will fit on the left.  See if it will fit on the right 
								//and if the range of the right axis is less than the range of the left axis.
								//If so, move it to the right
								if((armin[iSeries]>=RightMin) && (armax[iSeries]<=RightMax)) {
//console.log("RightMax-RightMin="+(RightMax-RightMin)+" LeftMax-LeftMin="+(LeftMax-LeftMin));
									if(RightMax-RightMin<LeftMax-LeftMin) {
										arTestAxis[iSeries]="right";
									};
								};
							};
						};

						if(bIsValid) {
							//evaluate the axes.  This spread is too simple and is replaced below.
							var Spread=(LeftMax-LeftMin)+(RightMax-RightMin);

							//calculate the spread by calculating the difference between the min/max value of 
							//each series and the min/max of the axis on which it is plotted
							Spread=0;
							for(iSeries=1;iSeries<cSeries;iSeries++) {
								if(arTestAxis[iSeries].equalsIgnoreCase("left")) {
									Spread+=(armin[iSeries]-LeftMin)+(LeftMax-armax[iSeries]);
								}
								else {
									Spread+=(armin[iSeries]-RightMin)+(RightMax-armax[iSeries]);
								};
							};
//console.log("("+LeftMin+","+LeftMax+"),("+RightMin+","+RightMax+") - Spread="+Spread+" MinSpread="+MinSpread);

							if((!bSpreadInitialized) || (Spread<MinSpread)) {
								MinSpread=Spread;
								bSpreadInitialized=true;
								LeftAxisRange[0]=LeftMin;
								LeftAxisRange[1]=LeftMax;
								RightAxisRange[0]=RightMin;
								RightAxisRange[1]=RightMax;
								for(var iSeries=1;iSeries<cSeries;iSeries++) {
									arAxis[iSeries]=arTestAxis[iSeries];
								};
							};
						};
					};
				};

				cTrial++;
			};
		};
	};

	//console.log("MinSpread="+MinSpread);
	//console.log("LeftAxisRange="+LeftAxisRange);
	//console.log("RightAxisRange="+RightAxisRange);
	//console.log("arAxis="+arAxis.toString());

	//adjust min/max to make the scales more readable
	var a=getAxisMinMax(LeftAxisRange[0],LeftAxisRange[1]);
	LeftAxisRange[0]=a[0];
	LeftAxisRange[1]=a[1];

	a=getAxisMinMax(RightAxisRange[0],RightAxisRange[1]);
	RightAxisRange[0]=a[0];
	RightAxisRange[1]=a[1];

	var e=document.getElementById(_id);
	//console.log("set attributes in "+_id+": "+e);
	e.setAttribute("LeftAxisMin",LeftAxisRange[0]);
	e.setAttribute("LeftAxisMax",LeftAxisRange[1]);
	e.setAttribute("RightAxisMin",RightAxisRange[0]);
	e.setAttribute("RightAxisMax",RightAxisRange[1]);
	e.setAttribute("BottomAxisMin",bottommin);
	e.setAttribute("BottomAxisMax",bottommax);

	console.log("bottommin="+bottommin+" bottommax="+bottommax);

	for(var i=1;i<arAxis.length;i++) {
		e.setAttribute("SeriesAxis"+i,arAxis[i]);
		//console.log("setAttribute SeriesAxis"+i+"="+arAxis[i]);
	};
};	

function getChartSeriesCount(_chartdata) {
	var a1=_chartdata.split("|");
	var a2=a1[0].split("^");
	return(a2.length);
};

function getChartLegend(_chartdata) {
	var a1=_chartdata.split("|");
	var a2=a1[0].split("^");
	return(a2);
};

function getChartSeries(_id,_chartdata,_index) {
	var a1=_chartdata.split("|");
	var arSeries=new Array();
	var dFirstValue=0;
	var sChartType=getChartType(_id);
	var bIndex=(sChartType=="AspectLineIndex");
	var dFirstIndexedValue=0;

	for(var i=1;i<a1.length;i++) {
		var a2=a1[i].split("^");
		if(_index==0) {
			arSeries[arSeries.length]=a2[_index];
		}
		else {
			if(bIndex) {
				if((i==1) || (dFirstValue==0)) dFirstValue=parseFloat(a2[_index]);
				if(dFirstValue==0) {
					arSeries[arSeries.length]=0;
				}
				else {
					arSeries[arSeries.length]=parseFloat(a2[_index])/Math.abs(dFirstValue)*100;
				};

				//This is to handle negative numbers.  If the first number is negative then the 
				//first index value will be -100, so add 200 to it.  It's also necessary to use
				//the absolute value of dFirstValue above when calculating the index value.
				if(dFirstValue<0) arSeries[arSeries.length-1]+=200;
			}
			else {
				arSeries[arSeries.length]=parseFloat(a2[_index]);
			};
		};
	};

	return(arSeries);
};

function getChartSeriesMax(_a) {
	var max=_a[0];
	for(var i=0;i<_a.length;i++) {
		if(!Number.isNaN(_a[i])) max=Math.max(max,_a[i]);
	};
	return(max);
};

/**************************************************************
4/2021 - Modified this to skip initial zeroes in a series.  For example, in a series forecast, 
the values are zero until the forecast begins.  Including these zeroes causes the min to be 
less than it should.

However, there is a problem when applying this to 2-axis graphs.  Currently, 0 will be 
returned as the min for a 2-axis graph.
**************************************************************/
function getChartSeriesMin(_a,_id) {
	var min=_a[0];

	//don't include 0's in the min calculation until a non-zero number has been encountered.
	//This allows the graph to avoid plotting the initial zero value for series that may not 
	//contain data until later in the series
	var bPastZeros=false;

	if(_id) {
		var sChartType=getChartType(_id);
		if((sChartType.equalsIgnoreCase("AspectLine2")) || (sChartType.equalsIgnoreCase("AspectColumn2")) || (sChartType.equalsIgnoreCase("AspectScatter2"))) {
			bPastZeros=true;
		};
	};

	for(var i=0;i<_a.length;i++) {
		if(!Number.isNaN(_a[i])) {
			if(_a[i]!=0) {
				if(!bPastZeros) min=_a[i];
				bPastZeros=true;
			};

			if(bPastZeros) {
				min=Math.min(min,_a[i]);
			};
		};
	};

	return(min);
};

function getSeriesColor(_seriesIndex) {
	var c="black";
	var arColor=["Blue","Tomato","BlueViolet","Brown","CadetBlue","Chocolate","Coral","CornflowerBlue","Crimson","DarkBlue","DarkCyan","DarkGoldenRod","DarkGreen","DarkMagenta","DarkOliveGreen","DarkOrange","DarkOrchid","DarkRed","DarkSlateBlue","DarkSlateGray","DarkSlateGrey","DarkTurquoise","DarkViolet","DeepPink","DeepSkyBlue","DimGray","DimGrey","DodgerBlue","FireBrick","ForestGreen","Fuchsia","Gold","GoldenRod","Gray","Grey","Green","GreenYellow","HotPink","IndianRed ","Indigo ","Ivory","Khaki","Lavender","LavenderBlush","LawnGreen","LemonChiffon","LightBlue","LightCoral","LightCyan","LightGoldenRodYellow","LightGray","LightGrey","LightGreen","LightPink","LightSalmon","LightSeaGreen","LightSkyBlue","LightSlateGray","LightSlateGrey","LightSteelBlue","LightYellow","Lime","LimeGreen","Linen","Magenta","Maroon","MediumAquaMarine","MediumBlue","MediumOrchid","MediumPurple","MediumSeaGreen","MediumSlateBlue","MediumSpringGreen","MediumTurquoise","MediumVioletRed","MidnightBlue","MintCream","MistyRose","Moccasin","NavajoWhite","Navy","OldLace","Olive","OliveDrab","Orange","OrangeRed","Orchid","PaleGoldenRod","PaleGreen","PaleTurquoise","PaleVioletRed","PapayaWhip","PeachPuff","Peru","Pink","Plum","PowderBlue","Purple","RebeccaPurple","Red","RosyBrown","RoyalBlue","SaddleBrown","Salmon","SandyBrown","SeaGreen","SeaShell","Sienna","Silver","SkyBlue","SlateBlue","SlateGray","SlateGrey","Snow","SpringGreen","SteelBlue","Tan","Teal","Thistle","Turquoise","Violet","Wheat","Yellow","YellowGreen","AliceBlue","Azure","Beige","Bisque","BlanchedAlmond","BurlyWood","Cornsilk","Cyan","DarkGray","DarkGrey","Aqua","Aquamarine","Black","DarkKhaki","DarkSalmon","DarkSeaGreen","Chartreuse","FloralWhite","Gainsboro","GhostWhite","HoneyDew"];
	if((_seriesIndex-1)<arColor.length) c=arColor[_seriesIndex-1];
	return(c);
};

function scalePlotArea(_id) {
	//console.log("scalePlotArea");
	initializePlotArea(_id);
	drawBottomAxis(_id);

	var sChartType=getChartType(_id);
	if((!sChartType.equalsIgnoreCase("AspectScatter")) && (!sChartType.equalsIgnoreCase("AspectScatter2"))) {
		drawRecessionTicks(_id);
		drawDateMarkers(_id);
	};
	drawZeroLine(_id,"left");
	drawZeroLine(_id,"right");
	setTimeout("drawPlot(\""+_id+"\",1)",0);
};

function initializePlotArea(_id) {
	var e=document.getElementById("ChartPlotArea"+_id);
	var width=document.getElementById("Range"+_id).value;
	e.style.width=(width-4)+"px";
	//document.getElementById("ChartBottomAxis"+_id).style.width=width+"px";
	e.innerHTML="";

	//add horizontal crosshair
	var eHorzCrosshair=document.createElement("div");
	eHorzCrosshair.setAttribute("class","chart_horz_crosshair");
	eHorzCrosshair.id=e.id+"HCross";
	eHorzCrosshair.style.width=e.offsetWidth+"px";
	e.appendChild(eHorzCrosshair);

	//add vertical crosshair
	var eVertCrosshair=document.createElement("div");
	eVertCrosshair.setAttribute("class","chart_vert_crosshair");
	eVertCrosshair.id=e.id+"VCross";
	eVertCrosshair.style.height=e.offsetHeight+"px";
	e.appendChild(eVertCrosshair);
};

function drawPlot(_id,iSeries) {
	var e=document.getElementById("ChartPlotArea"+_id);

	var sChartType=getChartType(replaceAllSubstrings(_id,"Chart",""));

	//draw scatter plot
	if((sChartType.equalsIgnoreCase("AspectScatter")) || (sChartType.equalsIgnoreCase("AspectScatter2"))) {
		drawXYPlot(_id,iSeries);
		return;
	};

	var eChartContainer=document.getElementById(_id);
	var LeftAxisMax=parseFloat(eChartContainer.getAttribute("LeftAxisMax"));
	var LeftAxisMin=parseFloat(eChartContainer.getAttribute("LeftAxisMin"));
	var RightAxisMax=parseFloat(eChartContainer.getAttribute("RightAxisMax"));
	var RightAxisMin=parseFloat(eChartContainer.getAttribute("RightAxisMin"));
	var SeriesAxis=eChartContainer.getAttribute("SeriesAxis"+iSeries);
	var sData=getChartData(_id);
	var SeriesCount=getChartSeriesCount(sData);
	var arLegend=getChartLegend(sData);

	var Series=getChartSeries(_id,sData,iSeries);
	var SeriesLabel=getChartSeries(_id,sData,0);

	//get background color
	var BackgroundColor=getSeriesColor(iSeries);

	var LastX=-1;
	var LastY=-1;
	var cNotPlotted=0;
	var graphwidth=e.offsetWidth;
	var PixelsPerPoint=graphwidth/Series.length;
	var sInnerHtml="";
	var sTooltip="";
	var cPoints=0;
	var cPointsAdded=0;
	var bFirstNonZero=false;

	for(var i=0;i<Series.length;i++) {
		var x=(i/Series.length)*graphwidth;

		//NOTE: The pixel height of the point is subtracted from e.offsetHeight.  Otherwise, 
		//points at the maximum value will be outside the plot area.  The bottom of the point 
		//will be positioned at the maximum which is the upper edge of the plot area.
		if(SeriesAxis.equalsIgnoreCase("left")) {
			var y=(Series[i]-LeftAxisMin)/(LeftAxisMax-LeftAxisMin) * (e.offsetHeight-3);
			var yZero=(0-LeftAxisMin)/(LeftAxisMax-LeftAxisMin) * (e.offsetHeight-3);
		}
		else {
			var y=(Series[i]-RightAxisMin)/(RightAxisMax-RightAxisMin) * (e.offsetHeight-3);
			var yZero=(0-RightAxisMin)/(RightAxisMax-RightAxisMin) * (e.offsetHeight-3);
		};

		//=================================================================
		//Note: Points are only plotted when the x or y offset value changes.  This avoids plotting 
		//multiple points in the exact same place.  When a point is not plotted, the tooltip for that 
		//point is appended to sTooltip.  This way, the tooltip for the final point displays 
		//values for all of the points that would occupy the same location.
		//=================================================================
		x=Math.round(x);
		y=Math.round(y);
		if((x!=LastX) || (y!=LastY) || (i==Series.length-1)) {
			sTooltip+=arLegend[iSeries]+": "+SeriesLabel[i]+": "+Series[i]+"<br>";
	
			var pointwidth=Math.round(Math.max(Math.min(PixelsPerPoint,7),4));
			var pointheight=Math.round(Math.max(Math.min(PixelsPerPoint,7),4));
			//x-=pointwidth/2;
			//y-=pointheight/2;
			//x=Math.round(x);
			//y=Math.round(y);

			var iBottom=y;
			var iHeight=pointheight;
			if((sChartType.equalsIgnoreCase("AspectColumn")) || (sChartType.equalsIgnoreCase("AspectColumn2"))) {
				if(Series[i]>=0) {
					if(LeftAxisMin>=0) {
						var iBottom=0;
						var iHeight=y;
					}
					else {
						var iBottom=yZero;
						var iHeight=y-yZero;
					};
				}
				else {
					var iBottom=y;
					var iHeight=yZero-y;
				};

				//var iBottom=0;
				//var iHeight=y;

				var pointwidth=graphwidth/Series.length/(SeriesCount-1)*0.95;
				var x=(i/Series.length)*graphwidth+((iSeries-1)*pointwidth);
				//console.log("SeriesCount="+SeriesCount+" iSeries="+iSeries+" pointwidth="+pointwidth+" x="+x);
			};

			if(Series[i]!=0) bFirstNonZero=true;
			//console.log("i="+i+" Series[i]="+Series[i]+" sTooltip="+sTooltip+" x="+x+" y="+y);
			//don't show points until the first non-zero value is encountered.  This avoids drawing a line 
			//across the bottom for a series that doesn't have any data at the beginning
			if(bFirstNonZero==true) {
				sInnerHtml+="<div class='point' style='background-color:"+BackgroundColor+";bottom:"+iBottom+"px;left:"+x+"px;height:"+iHeight+";width:"+pointwidth+"'";
			}
			else {
				sInnerHtml+="<div class='point' style='background-color:transparent;bottom:"+iBottom+"px;left:"+x+"px;height:"+iHeight+";width:"+pointwidth+"'";
			}

			sInnerHtml+="originalwidth=\""+pointwidth+"\"";
			sInnerHtml+=" _bottom="+y;
			sInnerHtml+=" _left="+x;
			sInnerHtml+=" onmouseover=\"showTooltip(event,'"+sTooltip+"',10,10)\"";
			sInnerHtml+=" onmouseout=\"showTooltip(event,'',0,0)\"";
			sInnerHtml+=" onclick=\"chartpointclicked(this)\"";
			sInnerHtml+=" id=\""+_id+"_"+iSeries+"_"+i+"\"";
			sInnerHtml+=" series=\""+iSeries+"\"";
			sInnerHtml+=" index=\""+i+"\"";
			sInnerHtml+=" Label=\""+SeriesLabel[i]+"\"";
			sInnerHtml+=" Value=\""+Series[i]+"\"";
			sInnerHtml+="></div>";
			cPointsAdded++;

			//sTooltip=SeriesLabel[i]+": "+Series[i]+"<br>";
			sTooltip="";

			cPoints=1;
			LastX=x;
			LastY=y;
		}
		else {
			sTooltip+=SeriesLabel[i]+": "+Series[i]+"<br>";
			cPoints++;
		};
	};	

	e.innerHTML+=sInnerHtml;
	//console.log("Added "+cPointsAdded+" from series "+iSeries);

	if(iSeries<SeriesCount-1) {
		setTimeout("drawPlot(\""+_id+"\","+(iSeries+1)+");",0);
	};
};

function drawXYPlot(_id,iSeries) {

	var sData=getChartData(_id);
	var SeriesCount=getChartSeriesCount(sData);
	//console.log("drawXYPlot id="+_id+" Series="+iSeries+" SeriesCount="+SeriesCount);

	//skip the first series.  This is used as the X axis
	if((iSeries==1) && (iSeries<SeriesCount-1)) {
		//console.log("Skipping first series (x values)");
		setTimeout("drawXYPlot(\""+_id+"\","+(iSeries+1)+");",0);
		return;
	};

	var e=document.getElementById("ChartPlotArea"+_id);

	var sChartType=getChartType(replaceAllSubstrings(_id,"Chart",""));

	var eChartContainer=document.getElementById(_id);
	var LeftAxisMax=parseFloat(eChartContainer.getAttribute("LeftAxisMax"));
	var LeftAxisMin=parseFloat(eChartContainer.getAttribute("LeftAxisMin"));
	var RightAxisMax=parseFloat(eChartContainer.getAttribute("RightAxisMax"));
	var RightAxisMin=parseFloat(eChartContainer.getAttribute("RightAxisMin"));
	var BottomAxisMax=parseFloat(eChartContainer.getAttribute("BottomAxisMax"));
	var BottomAxisMin=parseFloat(eChartContainer.getAttribute("BottomAxisMin"));
	var SeriesAxis=eChartContainer.getAttribute("SeriesAxis"+iSeries);
	var arLegend=getChartLegend(sData);

	var Series=getChartSeries(_id,sData,iSeries);
	var XSeries=getChartSeries(_id,sData,1);
	var SeriesLabel=getChartSeries(_id,sData,0);

	//get background color
	var BackgroundColor=getSeriesColor(iSeries);

	var LastX=-1;
	var LastY=-1;
	var cNotPlotted=0;
	var graphwidth=e.offsetWidth;
	var PixelsPerPoint=graphwidth/Series.length;
	var sInnerHtml="";
	var sTooltip="";
	var cPoints=0;
	var cPointsAdded=0;
	var bFirstNonZero=false;

	for(var i=0;i<Series.length;i++) {
		var xPcnt=(XSeries[i]-BottomAxisMin)/(BottomAxisMax-BottomAxisMin);
		var x=graphwidth*xPcnt;
//console.log("i="+i+" XSeries[i]="+XSeries[i]+" BottomAxisMin="+BottomAxisMin+" BottomAxisMax="+BottomAxisMax+" xPcnt="+xPcnt+" x="+x);

		//NOTE: The pixel height of the point is subtracted from e.offsetHeight.  Otherwise, 
		//points at the maximum value will be outside the plot area.  The bottom of the point 
		//will be positioned at the maximum which is the upper edge of the plot area.
		if(SeriesAxis.equalsIgnoreCase("left")) {
			var y=(Series[i]-LeftAxisMin)/(LeftAxisMax-LeftAxisMin) * (e.offsetHeight-3);
			var yZero=(0-LeftAxisMin)/(LeftAxisMax-LeftAxisMin) * (e.offsetHeight-3);
		}
		else {
			var y=(Series[i]-RightAxisMin)/(RightAxisMax-RightAxisMin) * (e.offsetHeight-3);
			var yZero=(0-RightAxisMin)/(RightAxisMax-RightAxisMin) * (e.offsetHeight-3);
		};

		//=================================================================
		//Note: Points are only plotted when the x or y offset value changes.  This avoids plotting 
		//multiple points in the exact same place.  When a point is not plotted, the tooltip for that 
		//point is appended to sTooltip.  This way, the tooltip for the final point displays 
		//values for all of the points that would occupy the same location.
		//=================================================================
		x=Math.round(x);
		y=Math.round(y);
		if((x!=LastX) || (y!=LastY) || (i==Series.length-1)) {
			sTooltip+=SeriesLabel[i]+": ("+arLegend[1]+"="+XSeries[i]+","+arLegend[iSeries]+"="+Series[i]+")<br>";
	
			var pointwidth=Math.round(Math.max(Math.min(PixelsPerPoint,7),5));
			var pointheight=Math.round(Math.max(Math.min(PixelsPerPoint,7),5));

			var iBottom=y;
			var iHeight=pointheight;

			if(Series[i]!=0) bFirstNonZero=true;
			sInnerHtml+="<div class='point' style='background-color:"+BackgroundColor+";bottom:"+iBottom+"px;left:"+x+"px;height:"+iHeight+";width:"+pointwidth+"'";

			sInnerHtml+="originalwidth=\""+pointwidth+"\"";
			sInnerHtml+=" _bottom="+y;
			sInnerHtml+=" _left="+x;
			sInnerHtml+=" onmouseover=\"showTooltip(event,'"+sTooltip+"',10,10)\"";
			sInnerHtml+=" onmouseout=\"showTooltip(event,'',0,0)\"";
			sInnerHtml+=" onclick=\"chartpointclicked(this)\"";
			sInnerHtml+=" id=\""+_id+"_"+iSeries+"_"+i+"\"";
			sInnerHtml+=" series=\""+iSeries+"\"";
			sInnerHtml+=" index=\""+i+"\"";
			sInnerHtml+=" Label=\""+SeriesLabel[i]+"\"";
			sInnerHtml+=" Value=\""+Series[i]+"\"";
			sInnerHtml+="></div>";
			cPointsAdded++;

			//sTooltip=SeriesLabel[i]+": "+Series[i]+"<br>";
			sTooltip="";

			cPoints=1;
			LastX=x;
			LastY=y;
		}
		else {
			sTooltip+=SeriesLabel[i]+": "+Series[i]+"<br>";
			cPoints++;
		};
	};	

	e.innerHTML+=sInnerHtml;
	//console.log("Added "+cPointsAdded+" from series "+iSeries);

	if(iSeries<SeriesCount-1) {
		setTimeout("drawXYPlot(\""+_id+"\","+(iSeries+1)+");",0);
	};
};

function olddrawPlot(_id,iSeries) {
	var e=document.getElementById("ChartPlotArea"+_id);

	var eChartContainer=document.getElementById(_id);
	var LeftAxisMax=parseFloat(eChartContainer.getAttribute("LeftAxisMax"));
	var LeftAxisMin=parseFloat(eChartContainer.getAttribute("LeftAxisMin"));

	var sData=getChartData(_id);
	var SeriesCount=getChartSeriesCount(sData);

	var Series=getChartSeries(_id,sData,iSeries);
	var SeriesLabel=getChartSeries(_id,sData,0);

	//get background color
	var BackgroundColor=getSeriesColor(iSeries);

	var LastX=-1;
	var LastY=-1;
	var cNotPlotted=0;
	var graphwidth=e.offsetWidth;
	s="";
	for(var i=0;i<Series.length;i++) {
		var x=(i/Series.length)*graphwidth;
		var y=(Series[i]-LeftAxisMin)/(LeftAxisMax-LeftAxisMin) * e.offsetHeight;
		x=Math.round(x);
		y=Math.round(y);
		if((x!=LastX) || (y!=LastY)) {
			var point=document.createElement("div");
			point.setAttribute("tt",SeriesLabel[i]+": "+Series[i]);
			point.setAttribute("onmouseover","showTooltip(event,this.getAttribute('tt'),10,10)");
			point.setAttribute("onmouseout","showTooltip(event,'',0,0)");
			point.setAttribute("class","point");
			point.style.backgroundColor=BackgroundColor;
			point.style.bottom=y+"px";
			point.style.left=x+"px";
			e.appendChild(point);  			

			LastX=x;
			LastY=y;
		}
		else {
			if(point) {
				var s=point.getAttribute("tt");
				s+="<br>"+SeriesLabel[i]+": "+Series[i];
				point.setAttribute("tt",s);
				cNotPlotted++;
			};
		};
	};	

	if(iSeries<SeriesCount-1) {
		setTimeout("drawPlot(\""+_id+"\","+(iSeries+1)+");",0);
	};
};

function drawLeftAxis(_id) {
	var MajorTickDivisions=10;
	var MinorTickMultiplier=2;
	var MinorTickDivisions=MajorTickDivisions * MinorTickMultiplier;
	
	var eLeftAxis=document.getElementById("ChartLeftAxis"+_id);
	var iLeftAxisWidth=eLeftAxis.offsetWidth;
	eLeftAxis.innerHTML="";
	
	var ePlotArea=document.getElementById("ChartPlotArea"+_id);
	var iBottomAxisHeight=document.getElementById("ChartBottomAxis"+_id).offsetHeight;
	var iScrollbarHeight=iBottomAxisHeight;	//this needs to be corrected
	var LeftAxisHeight=ePlotArea.offsetHeight;
	
	var e=document.getElementById(_id);
	var Max=parseFloat(e.getAttribute("LeftAxisMax"));
	var Min=parseFloat(e.getAttribute("LeftAxisMin"));
	var MajorTick=(Max-Min)/MajorTickDivisions;
	var MinorTick=(Max-Min)/MinorTickDivisions;
	var MajorTickHeight=LeftAxisHeight/MajorTickDivisions;
	var MinorTickHeight=LeftAxisHeight/MinorTickDivisions;
	
	//add container for major tick
	var eMajorTickContainer=document.createElement("div");
	eMajorTickContainer.setAttribute("class","vertical_axis_major_tick_container");
	eLeftAxis.appendChild(eMajorTickContainer);
	
	//add container for minor tick
	var MinorTickContainerWidth=10;
	var eMinorTickContainer=document.createElement("div");
	eMinorTickContainer.setAttribute("class","vertical_axis_minor_tick_container");
	eMinorTickContainer.style.width=MinorTickContainerWidth;
	eMinorTickContainer.style.marginLeft=(iLeftAxisWidth-MinorTickContainerWidth)+"px";
	eLeftAxis.appendChild(eMinorTickContainer);
	
	//add divs for major ticks
	var c=0;
	var n=Max;
	while(n>=Min) {
		var eMajorTick=document.createElement("div");
		eMajorTick.setAttribute("class","vertical_left_axis_major_tick");
		eMajorTick.style.height=MajorTickHeight+"px";
		var eTickValue=document.createElement("div");
		eTickValue.setAttribute("class","vertical_tick_value");
		eTickValue.innerHTML=formatNumber(n,"0.00");
		eTickValue.style.marginTop=(MajorTickHeight/3)+"px";
		eMajorTick.appendChild(eTickValue);
		eMajorTick.style.top=(-(MajorTickHeight*0.5)+(c*MajorTickHeight))+"px";
		eMajorTick.style.width=(iLeftAxisWidth-MinorTickContainerWidth)+"px";
		eMajorTickContainer.appendChild(eMajorTick);
		n-=MajorTick;
		c++;
	};
	
	//add divs for minor ticks
	var c=0;
	var n=Max;
	while(n>=Min) {
		var eMinorTick=document.createElement("div");
		eMinorTick.setAttribute("class","vertical_axis_minor_tick");
		eMinorTick.style.height=MinorTickHeight+"px";
		var eHorzLine=document.createElement("hr");
		eHorzLine.setAttribute("class","vertical_tick");
		eHorzLine.style.marginTop=(MinorTickHeight/2)+"px";
		eMinorTick.appendChild(eHorzLine);
		eMinorTick.style.top=(-(MajorTickHeight*0.5)+(c*MinorTickHeight)+((MinorTickMultiplier-1)*MinorTickHeight/2))+"px";
		eMinorTick.style.width=MinorTickContainerWidth+"px";
		eMinorTickContainer.appendChild(eMinorTick);
		n-=MinorTick;
		c++;
	};
};

function drawRightAxis(_id) {
	var MajorTickDivisions=10;
	var MinorTickMultiplier=5;
	var MinorTickDivisions=MajorTickDivisions * MinorTickMultiplier;
	
	var eRightAxis=document.getElementById("ChartRightAxis"+_id);
	var iRightAxisWidth=eRightAxis.offsetWidth;
	eRightAxis.style.width=(eRightAxis.offsetWidth-2)+"px"; //2 pixels are removed.  Otherwise the plot area border is covered up.
	eRightAxis.innerHTML="";
	
	var ePlotArea=document.getElementById("ChartPlotArea"+_id);
	var iBottomAxisHeight=document.getElementById("ChartBottomAxis"+_id).offsetHeight;
	var iScrollbarHeight=iBottomAxisHeight;	//this needs to be corrected
	var RightAxisHeight=ePlotArea.offsetHeight;
	
	var e=document.getElementById(_id);
	var Max=parseFloat(e.getAttribute("RightAxisMax"));
	var Min=parseFloat(e.getAttribute("RightAxisMin"));
	if(Min==Max) return;
	
	var MajorTick=(Max-Min)/MajorTickDivisions;
	var MinorTick=(Max-Min)/MinorTickDivisions;
	var MajorTickHeight=RightAxisHeight/MajorTickDivisions;
	var MinorTickHeight=RightAxisHeight/MinorTickDivisions;
	
	//add container for minor tick
	var MinorTickContainerWidth=10;
	var eMinorTickContainer=document.createElement("div");
	eMinorTickContainer.setAttribute("class","vertical_axis_minor_tick_container");
	eMinorTickContainer.style.width=MinorTickContainerWidth;
	eRightAxis.appendChild(eMinorTickContainer);
	
	//add container for major tick
	var MajorTickContainerWidth=iRightAxisWidth-MinorTickContainerWidth;
	var eMajorTickContainer=document.createElement("div");
	eMajorTickContainer.setAttribute("class","vertical_axis_major_tick_container");
	eMajorTickContainer.style.width=MajorTickContainerWidth+"px";
	eMajorTickContainer.style.marginLeft=MinorTickContainerWidth+"px";
	eRightAxis.appendChild(eMajorTickContainer);
	
	//add divs for major ticks
	var c=0;
	var n=Max;
	while(n>=Min) {
		var eMajorTick=document.createElement("div");
		eMajorTick.setAttribute("class","vertical_right_axis_major_tick");
		eMajorTick.style.height=MajorTickHeight+"px";
		var eTickValue=document.createElement("div");
		eTickValue.setAttribute("class","vertical_tick_value");
		eTickValue.innerHTML=formatNumber(n,"0.00");
		eTickValue.style.marginTop=(MajorTickHeight/4)+"px";
		eMajorTick.appendChild(eTickValue);
		eMajorTick.style.top=(-(MajorTickHeight*0.5)+(c*MajorTickHeight))+"px";
		eMajorTick.style.width=(iRightAxisWidth-MinorTickContainerWidth)+"px";
		eMajorTickContainer.appendChild(eMajorTick);
		n-=MajorTick;
		c++;
	};
	
	//add divs for minor ticks
	var c=0;
	var n=Max;
	while(n>=Min) {
		var eMinorTick=document.createElement("div");
		eMinorTick.setAttribute("class","vertical_axis_minor_tick");
		eMinorTick.style.height=MinorTickHeight+"px";
		var eHorzLine=document.createElement("hr");
		eHorzLine.setAttribute("class","vertical_tick");
		eHorzLine.style.marginTop=(MinorTickHeight/2)+"px";
		eMinorTick.appendChild(eHorzLine);
		eMinorTick.style.top=(-(MajorTickHeight*0.5)+(c*MinorTickHeight)+((MinorTickMultiplier-1)*MinorTickHeight/2))+"px";
		eMinorTick.style.width=MinorTickContainerWidth+"px";
		eMinorTickContainer.appendChild(eMinorTick);
		n-=MinorTick;
		c++;
	};

};

function drawBottomAxis(_id) {
	var sChartType=getChartType(replaceAllSubstrings(_id,"Chart",""));
	
	//if scatter plot...
	if((sChartType.equalsIgnoreCase("AspectScatter")) || (sChartType.equalsIgnoreCase("AspectScatter2"))) {
		drawXYBottomAxis(_id);
		return;
	};

	var eBottomAxis=document.getElementById("ChartBottomAxis"+_id);
	var iHeight=eBottomAxis.offsetHeight;
	eBottomAxis.style.height=iHeight+"px";
	eBottomAxis.innerHTML="";

	//var iWidth=eBottomAxis.offsetWidth;
	//var iWidth=eChartPlotArea.offsetWidth;
	var iWidth=document.getElementById("Range"+_id).value;

	eBottomAxis.style.width=(iWidth-4)+"px";
	
	var sData=getChartData(_id);
	var Series=getChartSeries(_id,sData,0);
	
	var LastX=-1;
	var LastWidth=0;
	var graphwidth=iWidth;

	for(var i=0;i<Series.length;i++) {
		var x=(i/Series.length)*graphwidth;
		x=Math.round(x);

		if((sChartType.equalsIgnoreCase("AspectColumn")) || (sChartType.equalsIgnoreCase("AspectColumn2"))) {
			var pointwidth=graphwidth/Series.length;
			x+=(pointwidth/2)
		}
		else {
			//shift right a bit, otherwise the leftmost label is cut off
			if(i==0) x+=5;
		};

		if((LastX==-1) || (x>LastX+LastWidth-20)) {

			var eTickContainer=document.createElement("div");
			eTickContainer.setAttribute("class","bottom_axis_tick_container");
			eTickContainer.style.width="auto";
			eTickContainer.style.left=x+"px";

			var eTick=document.createElement("div");
			eTick.setAttribute("class","bottom_axis_tick");
			eTick.innerHTML=Series[i];
			eTickContainer.appendChild(eTick);

			if(x+eTickContainer.offsetWidth<iWidth-1*LastWidth) {
				eBottomAxis.appendChild(eTickContainer);
				LastX=x;
				LastWidth=eTickContainer.offsetWidth;
			};
		};
	};
};

function drawXYBottomAxis(_id) {
	var e=document.getElementById(_id);
	var BottomAxisMin=parseFloat(e.getAttribute("BottomAxisMin"));
	var BottomAxisMax=parseFloat(e.getAttribute("BottomAxisMax"));

	var MajorTickDivisions=10;
	var MinorTickMultiplier=2;
	var MinorTickDivisions=MajorTickDivisions * MinorTickMultiplier;
	
	var ePlotArea=document.getElementById("ChartPlotArea"+_id);
	
	var eBottomAxis=document.getElementById("ChartBottomAxis"+_id);
	var iBottomAxisWidth=ePlotArea.offsetWidth;
	//var iBottomAxisWidth=eBottomAxis.offsetWidth;
	var iBottomAxisHeight=eBottomAxis.offsetHeight;
	eBottomAxis.innerHTML="";
	//console.log("iBottomAxisWidth="+iBottomAxisWidth);
	
	var e=document.getElementById(_id);
	var Max=parseFloat(e.getAttribute("BottomAxisMax"));
	var Min=parseFloat(e.getAttribute("BottomAxisMin"));
	var MajorTick=(Max-Min)/MajorTickDivisions;
	var MinorTick=(Max-Min)/MinorTickDivisions;
	
	//add container for major tick
	var MajorTickHeight=iBottomAxisHeight;
	var MajorTickWidth=iBottomAxisWidth/MajorTickDivisions;
	var eMajorTickContainer=document.createElement("div");
	eMajorTickContainer.setAttribute("class","vertical_axis_major_tick_container");
	eBottomAxis.appendChild(eMajorTickContainer);
	
	//add container for minor tick
	var MinorTickContainerHeight=10;
	var MinorTickHeight=10;
	var MinorTickWidth=iBottomAxisWidth/MinorTickDivisions;
	var eMinorTickContainer=document.createElement("div");
	eMinorTickContainer.setAttribute("class","bottomxy_axis_minor_tick_container");
	eMinorTickContainer.style.height=MinorTickContainerHeight;
	eMinorTickContainer.style.marginLeft=0+"px";
	eBottomAxis.appendChild(eMinorTickContainer);

	//get series	
	var sData=getChartData(_id);
	var Series=getChartSeries(_id,sData,1);

	//add divs for major ticks
	var c=0;
	var step=(BottomAxisMax-BottomAxisMin)/MajorTickDivisions;
	var n=BottomAxisMin;
	//console.log("BottomAxisMin="+BottomAxisMin);
	//console.log("BottomAxisMax="+BottomAxisMax);
	//console.log("step="+step);

	while(n<BottomAxisMax) {
		var eMajorTick=document.createElement("div");
		eMajorTick.setAttribute("class","bottomxy_axis_major_tick");
		eMajorTick.style.height=MajorTickHeight+"px";
		var eTickValue=document.createElement("div");
		eTickValue.setAttribute("class","bottomxy_tick_value");
		if(Math.abs(n)<100) {
			eTickValue.innerHTML=n.toFixed(2);
		}
		else {
			eTickValue.innerHTML=n.toFixed(0);
		};
		eTickValue.style.marginTop=(MajorTickHeight/3)+"px";
		eTickValue.style.width=iBottomAxisHeight+"px";
		eMajorTick.appendChild(eTickValue);
		eMajorTick.style.top=10+"px";
		eMajorTick.style.left=(c*MajorTickWidth)+"px";
		eMajorTick.style.width=MajorTickWidth+"px";
		eMajorTickContainer.appendChild(eMajorTick);
		n+=step;
		c++;
	};

	//add divs for minor ticks
	var c=0;
	var step=(BottomAxisMax-BottomAxisMin)/MinorTickDivisions;
	var n=BottomAxisMin;
	//console.log("step="+step);
	while(n<BottomAxisMax) {
		var eMinorTick=document.createElement("div");
		eMinorTick.setAttribute("class","bottomxy_axis_minor_tick");
		eMinorTick.style.height=MinorTickHeight+"px";
		eMinorTick.style.top=0+"px";
		eMinorTick.style.left=(c*MinorTickWidth)+"px";
		eMinorTick.style.width=1;
		eMinorTickContainer.appendChild(eMinorTick);
		n+=step;
		c++;
	};
};

function drawZeroLine(_id,_axis) {
	var e=document.getElementById("ChartPlotArea"+_id);

	var eChartContainer=document.getElementById(_id);
	var LeftAxisMax=parseFloat(eChartContainer.getAttribute("LeftAxisMax"));
	var LeftAxisMin=parseFloat(eChartContainer.getAttribute("LeftAxisMin"));
	var RightAxisMax=parseFloat(eChartContainer.getAttribute("RightAxisMax"));
	var RightAxisMin=parseFloat(eChartContainer.getAttribute("RightAxisMin"));
	var sData=getChartData(_id);

	if(_axis.equalsIgnoreCase("left")) {
		if((LeftAxisMin>=0) || (LeftAxisMax<=0)) return;
	}
	else {
		if((RightAxisMin>=0) || (RightAxisMax<=0)) return;
	};

	var SeriesLabel=getChartSeries(_id,sData,0);

	//get background color
	var BackgroundColor="black"

	var LastX=-1;
	var LastY=-1;
	var graphwidth=e.offsetWidth;
	var PixelsPerPoint=graphwidth/SeriesLabel.length;
	var sInnerHtml="";
	for(var i=0;i<SeriesLabel.length;i++) {
		var x=(i/SeriesLabel.length)*graphwidth;

		//NOTE: The pixel height of the point is subtracted from e.offsetHeight.  Otherwise, 
		//points at the maximum value will be outside the plot area.  The bottom of the point 
		//will be positioned at the maximum which is the upper edge of the plot area.
		if(_axis.equalsIgnoreCase("left")) {
			var y=(0-LeftAxisMin)/(LeftAxisMax-LeftAxisMin) * (e.offsetHeight-3);
		}
		else {
			var y=(0-RightAxisMin)/(RightAxisMax-RightAxisMin) * (e.offsetHeight-3);
		};

		x=Math.round(x);
		y=Math.round(y);
		if((x!=LastX) || (y!=LastY) || (i==SeriesLabel.length-1)) {
			//var pointwidth=Math.max(Math.min(PixelsPerPoint,5),3);
			//var pointheight=Math.max(Math.min(PixelsPerPoint,5),3);
			var pointwidth=2;
			var pointheight=2;
			x-=pointwidth/2;
			y-=pointheight/2;

			sInnerHtml+="<div class='point' style='background-color:"+BackgroundColor+";bottom:"+y+"px;left:"+x+"px;height:"+pointheight+";width:"+pointwidth+"'";
			sInnerHtml+="index=\""+i+"\"";
			sInnerHtml+="Value=\"0\"";
			sInnerHtml+="></div>";

			LastX=x;
			LastY=y;
		};
	};	

	e.innerHTML+=sInnerHtml;
};

function drawLegend(_id) {
	var eChartContainer=document.getElementById(_id);
	var sChartType=getChartType(_id);
	var ChartData=getChartData(_id);
	var arLegend=getChartLegend(ChartData);
	var bIsAspectLine2=(getChartType(_id).equalsIgnoreCase("AspectLine2"));
	var bIsAspectColumn2=(getChartType(_id).equalsIgnoreCase("AspectColumn2"));
	var bIsAspectScatter2=(getChartType(_id).equalsIgnoreCase("AspectScatter2"));
	
	var eLegend=document.getElementById("ChartLegend"+_id);
	eLegend.innerHTML="";

	//set the margins for the legend.  The width is the same width used to the minor ticks.
	//Not sure why this is.
	eLegend.style.marginLeft="10px";
	eLegend.style.marginRight="10px";

	var eUL=document.createElement("ul");
	eUL.setAttribute("class","chart_legend");

	for(var i=1;i<arLegend.length;i++) {
		var bSkip=false;
		if((sChartType.equalsIgnoreCase("AspectScatter")) || (sChartType.equalsIgnoreCase("AspectScatter2"))) {
			if(i==1) bSkip=true;
		};
		
		if(bSkip==false) {
			//create li element
			var eLI=document.createElement("li");
			eLI.setAttribute("class","chart_legend");
			eLI.setAttribute("ChartID",_id);
			eLI.setAttribute("onClick","highlightChartSeries('"+_id+"',"+i+",true)");
			//eLI.setAttribute("onMouseOut","highlightChartSeries('"+_id+"',"+i+",false)");

			//create div showing the color of the series
			var eLegendMarker=document.createElement("div");
			eLegendMarker.setAttribute("class","chart_legend_marker");
			eLegendMarker.style.backgroundColor=getSeriesColor(i);
			eLegendMarker.innerHTML="&nbsp;&nbsp;&nbsp;&nbsp;"
			eLI.appendChild(eLegendMarker);

			//create text containing the name of the series
			var eLegendText=document.createElement("span");
			eLegendText.id=_id+"legendtext_"+i;
			eLegendText.setAttribute("class","chart_legend_text");
			//eLegendText.style.color=getSeriesColor(i);
			eLegendText.innerHTML=arLegend[i];

			//add left/right to charts with 2 vertical axes
			//if(bIsAspectLine2) eLegendText.innerHTML+=" ("+eChartContainer.getAttribute("SeriesAxis"+i)+")";
			if((bIsAspectLine2) || (bIsAspectColumn2) || (bIsAspectScatter2)) {
				eLegendText.innerHTML+=" ("+eChartContainer.getAttribute("SeriesAxis"+i)+")";
			};

			eLI.appendChild(eLegendText);

			eUL.appendChild(eLI);
		};
	};

	eLegend.appendChild(eUL);
};

function showCrosshair(event,e) {
	var x=event.clientX;
	var y=event.clientY;
	var arFixedxy=getFixedCoord(e.parentNode);

	var eHorzCrosshair=document.getElementById(e.id+"HCross");
	if(!eHorzCrosshair) return;

	var eVertCrosshair=document.getElementById(e.id+"VCross");
	if(!eVertCrosshair) return;

	var maxy=arFixedxy[1]+eHorzCrosshair.parentNode.offsetHeight;
	var maxx=arFixedxy[0]+eVertCrosshair.parentNode.offsetWidth;
	
	//horizontal crosshair
	if((y>=arFixedxy[1]+3) && (y<=arFixedxy[1]+eHorzCrosshair.parentNode.offsetHeight)) {
		eHorzCrosshair.style.display="block";
		eHorzCrosshair.style.width=e.offsetWidth+"px";
		eHorzCrosshair.style.top=(y-3)+"px";
		eHorzCrosshair.style.left=arFixedxy[0]+"px";
	}
	else {
		eHorzCrosshair.style.display="none";
		eVertCrosshair.style.display="none";
		return;
	};

	//vertical crosshair
	if((x>=arFixedxy[0]+3) && (x<=arFixedxy[0]+eVertCrosshair.parentNode.offsetWidth)) {
		eVertCrosshair.style.display="block";
		eVertCrosshair.style.height=e.offsetHeight+"px";
		eVertCrosshair.style.top=arFixedxy[1]+"px";
		eVertCrosshair.style.left=(x-3)+"px";
	}
	else {
		eHorzCrosshair.style.display="none";
		eVertCrosshair.style.display="none";
	};
};

function clearCrosshair(_id) {
	if(document.getElementById("ChartPlotArea"+_id+"HCross")) {
		document.getElementById("ChartPlotArea"+_id+"HCross").style.display="none";
		document.getElementById("ChartPlotArea"+_id+"VCross").style.display="none";
	};
};

function drawRecessionTicks(_id) {
	var ChartData=getChartData(_id);
	var Series=getChartSeries(_id,ChartData,0);

	if(Series[0].indexOf("-")==2) {
		var arDateRange=["1854-12-01,1854-12-31","1857-06-30,1858-12-31","1860-10-31,1861-06-30","1865-04-30,1867-12-31","1869-06-30,1870-12-31","1873-10-31,1879-03-31","1882-03-31,1885-05-31","1887-03-31,1888-04-30","1890-07-31,1891-05-31","1893-01-31,1894-06-30","1895-12-31,1897-06-30","1899-06-30,1900-12-31","1902-09-30,1904-08-31","1907-05-31,1908-06-30","1910-01-31,1912-01-31","1913-01-31,1914-12-31","1918-08-31,1919-03-31","1920-01-31,1921-07-31","1923-05-31,1924-07-31","1926-10-31,1927-11-30","1929-08-31,1933-03-31","1937-05-31,1938-06-30","1945-02-28,1945-10-31","1948-11-30,1949-10-31","1953-07-31,1954-05-31","1957-08-31,1958-04-30","1960-04-30,1961-02-28","1969-12-31,1970-11-30","1973-11-30,1975-03-31","1980-01-31,1980-07-31","1981-07-31,1982-11-30","1990-07-31,1991-03-31","2001-03-31,2001-11-30","2007-12-31,2009-06-30","2020-02-01,2020-03-01"];
		var ePlotArea=document.getElementById("ChartPlotArea"+_id);
		var graphwidth=ePlotArea.offsetWidth;
		var PlotDt1=Date.parse(Series[0]);
		var PlotDt2=Date.parse(Series[Series.length-1]);
		var PlotDtRange=PlotDt2-PlotDt1;
		//console.log("PlotDt1="+PlotDt1+" PlotDt2="+PlotDt2+" PlotDtRange="+PlotDtRange);
		for(var i=0;i<arDateRange.length;i++) {
			var arRange=arDateRange[i].split(",");
			var dt1=Date.parse(arRange[0]);
			var dt2=Date.parse(arRange[1]);

			var x1=0;
			if((dt1>=PlotDt1) && (dt1<=PlotDt2)) {
				x1=(dt1-PlotDt1)/PlotDtRange*graphwidth;
			};

			if(dt2>PlotDt2) dt2=PlotDt2;
			var x2=0
			if((dt2>=PlotDt1) && (dt2<=PlotDt2)) {
				x2=(dt2-PlotDt1)/PlotDtRange*graphwidth;
			};

			if((x1>0) && (x2>0)) {
				var eRecessionShade=document.createElement("div");
				eRecessionShade.setAttribute("class","recession_shade");
				eRecessionShade.style.left=x1+"px";
				eRecessionShade.style.width=(x2-x1)+"px";
				eRecessionShade.style.height=ePlotArea.offsetHeight+"px";
				eRecessionShade.setAttribute("onmouseover","showTooltip(event,\""+arRange[0]+" - "+arRange[1]+"\",10,10)");
				eRecessionShade.setAttribute("onmouseout","showTooltip(event,'',0,0)");
				eRecessionShade.setAttribute("onmousemove","showCrosshair(event,this.parentNode)");
				eRecessionShade.setAttribute("onmouseenter","showCrosshair(event,this.parentNode)");
				ePlotArea.appendChild(eRecessionShade);
			};
		};
	};
};

function drawDateMarkers(_id)
{
	//console.log("drawDateMarkers");
	var ChartData=getChartData(_id);
	var Series=getChartSeries(_id,ChartData,0);
	if(Series[0].indexOf("-")==2) {
		var ePlotArea=document.getElementById("ChartPlotArea"+_id);
		var dt1=new Date();
		dt1.setTime(Date.parse(Series[0]));
		var dt2=new Date();
		dt2.setTime(Date.parse(Series[Series.length-1]));
		//console.log("dt1="+formatDate(dt1,"MM-dd-yyyy"));
		//console.log("dt2="+formatDate(dt2,"MM-dd-yyyy"));
		var t=dt2.getTime()-dt1.getTime();
		var Days=t/(1000*60*60*24);
		//console.log("Days="+Days+" Years="+Days/365);

		var today=new Date();
		today=new Date(today.getFullYear(), today.getMonth(), today.getDate(), 0, 0, 0);
		var IsForecast=false;

		var graphwidth=ePlotArea.offsetWidth;
		var e=document.getElementById("ChartPlotArea"+_id);
		var dt=dt1;
		var LastYear=dt.getFullYear();
		var LastMonth=dt.getMonth();

		//determine if month ticks should be displayed
		var bDisplayMonth=(graphwidth/(Days/30)>10);

		for(var i=0;i<Series.length;i++) {
			dt.setTime(Date.parse(Series[i]));
//console.log("i="+i+" dt="+dt+" Series[i]="+Series[i]);
			var Year=dt.getFullYear();
			var Month=dt.getMonth();
			var x=(i/Series.length)*graphwidth;
		
			if((IsForecast==false) && (dt.getTime()>=today.getTime())) {
				var eTodayTick=document.createElement("div");
				eTodayTick.setAttribute("class","chartTodayTick");
				eTodayTick.style.left=x;
				eTodayTick.style.height=ePlotArea.offsetHeight+"px";
				eTodayTick.setAttribute("onmousemove","showCrosshair(event,this.parentNode)");
				eTodayTick.setAttribute("onmouseenter","showCrosshair(event,this.parentNode)");
				eTodayTick.setAttribute("onmouseover","showTooltip(event,\"Today Tick: "+Series[i]+"\",10,10)");
				eTodayTick.setAttribute("onmouseout","showTooltip(event,'',0,0)");
				ePlotArea.appendChild(eTodayTick);
				IsForecast=true;
			}			
			else if(Year!=LastYear) {
				var eYearTick=document.createElement("div");
				eYearTick.setAttribute("class","chartYearTick");
				eYearTick.style.left=x;
				eYearTick.style.height=ePlotArea.offsetHeight+"px";
				eYearTick.setAttribute("onmousemove","showCrosshair(event,this.parentNode)");
				eYearTick.setAttribute("onmouseenter","showCrosshair(event,this.parentNode)");
				eYearTick.setAttribute("onmouseover","showTooltip(event,\"Year Tick: "+Series[i]+"\",10,10)");
				eYearTick.setAttribute("onmouseout","showTooltip(event,'',0,0)");
				ePlotArea.appendChild(eYearTick);
			}
			else if((bDisplayMonth) && (Month!=LastMonth)) {
				var eMonthTick=document.createElement("div");
				eMonthTick.setAttribute("class","chartMonthTick");
				eMonthTick.style.left=x;
				eMonthTick.style.height=ePlotArea.offsetHeight+"px";
				eMonthTick.setAttribute("onmousemove","showCrosshair(event,this.parentNode)");
				eMonthTick.setAttribute("onmouseenter","showCrosshair(event,this.parentNode)");
				eMonthTick.setAttribute("onmouseover","showTooltip(event,\"Month Tick: "+Series[i]+"\",10,10)");
				eMonthTick.setAttribute("onmouseout","showTooltip(event,'',0,0)");
				ePlotArea.appendChild(eMonthTick);
			};
			LastYear=Year;
			LastMonth=Month;
			//dt.setTime(Date.parse(Series[i]));
		};
	};
};

function updatePointInfo(_id,_series) {
	console.log("updatePointInfo");

	var sData=getChartData(_id);
	var arLegend=getChartLegend(sData);
	var SeriesCount=getChartSeriesCount(sData);
	var Series=getChartSeries(_id,sData,_series);

	//create an array of point info container ID's and the series index associated with each
	var arPointInfoID=new Array();
	var arPointIndex=new Array();
	var eChartPlotArea=document.getElementById("ChartPlotArea"+_id);
	for(var i=0;i<eChartPlotArea.childNodes.length;i++) {
		if(eChartPlotArea.childNodes[i].id.startsWith(_id+"point"+_series)) {
			var sPointID=eChartPlotArea.childNodes[i].getAttribute("pointid");
			var ePoint=document.getElementById(sPointID);
			var Index=parseFloat(ePoint.getAttribute("Index"));
			arPointInfoID[arPointInfoID.length]=eChartPlotArea.childNodes[i].id;
			arPointIndex[arPointIndex.length]=Index;
			//console.log("Found container: "+eChartPlotArea.childNodes[i].id+" for point "+sPointID+" Index="+Index);
		};
	};

	for(var i=0;i<arPointInfoID.length;i++) {
		//get the point info container with the index prior to this one
		var PreviousInfoID="";
		var PreviousPointIndex=0;

		for(var j=0;j<arPointInfoID.length;j++) {
			if(arPointIndex[j]<arPointIndex[i]) {
				if(arPointIndex[j]>PreviousPointIndex) {
					PreviousPointIndex=arPointIndex[j];
					PreviousInfoID=arPointInfoID[j];
				};
			};
		};

		console.log("PreviousInfoID="+PreviousInfoID+" len="+PreviousInfoID.length);

		var ePointInfo2=document.getElementById(arPointInfoID[i]);
		var ePoint2=document.getElementById(ePointInfo2.getAttribute("pointID"));
		var Label2=ePoint2.getAttribute("label");
		var Value2=parseFloat(ePoint2.getAttribute("value"));
		var s=arLegend[_series]+"<br>";
		s+=Label2+"<br>";
		s+=Value2+"<br>";

		//if a prior point was found, add the stats to the container being processed
		if(PreviousInfoID.length>0) {
			var ePointInfo1=document.getElementById(PreviousInfoID);
			var ePoint1=document.getElementById(ePointInfo1.getAttribute("pointID"));
			var Label1=ePoint1.getAttribute("label");
			var Value1=parseFloat(ePoint1.getAttribute("value"));

			s+="<hr>";
			s+=Label1+" - "+Label2+"<br>";
			s +="Difference: "+formatNumber(Value2-Value1,"0.00")+"<br>";
			if(Label1.charAt(2)=="-") {
				var dt1=new Date();
				var dt2=new Date();
				dt1.setTime(Date.parse(Label1));
				dt2.setTime(Date.parse(Label2));
				var t=dt2.getTime()-dt1.getTime();
				var Days=t/(1000*60*60*24);
				var Years=Days/365;
				s+="Days: "+Math.round(Days)+"<br>";
				s+="Year: "+formatNumber(Years,"0.00")+"<br>";

				//CAGR
				if(Value1!=0) {
					var Cagr=Math.pow(Value2/Value1,1/Years)-1;
					s+="CAGR: "+formatNumber(Cagr*100,"0.00")+"<br>";
					var Percent=(Value2/Value1)-1;
					s+="Percent: "+formatNumber(Percent*100,"0.00")+"<br>";
				};
			};

			//add mean and stdev for change in series value.  For example, this would be the mean 
			//price change and stdev of the price change for a stock series
			var PointIndex1=parseFloat(ePoint1.getAttribute("Index"));
			var PointIndex2=parseFloat(ePoint2.getAttribute("Index"));

			//calculate the mean
			var Sum=0;
			var Count=0;
			var MaxDiff=0;
			var MinDiff=0;
			for(var PointIndex=PointIndex1+1;PointIndex<=PointIndex2;PointIndex++) {
				var Num1=Series[PointIndex-1];
				var Num2=Series[PointIndex];
				var Diff=Num2-Num1;
				if(Count==0) {
					MaxDiff=Diff;
					MinDiff=Diff;
				}
				else {
					MaxDiff=Math.max(MaxDiff,Diff);
					MinDiff=Math.min(MinDiff,Diff);
				};
				Sum +=Diff;
				Count++;
			};

			//calculate the stdev
			if(Count>0) {
				var Mean=Sum/Count;
				var Sum=0;
				for(var PointIndex=PointIndex1+1;PointIndex<=PointIndex2;PointIndex++) {
					var Num1=Series[PointIndex-1];
					var Num2=Series[PointIndex];
					var Diff=(Num2-Num1)-Mean;
					Sum +=Math.pow(Diff,2);
				};

				var Stdev=Math.pow(Sum/Count,0.5);

				s+="<hr>";
				s+="Change in value stats:<br>";
				s+="Min: "+Math.round(MinDiff*10000)/10000+"<br>";
				s+="Max: "+Math.round(MaxDiff*10000)/10000+"<br>";
				s+="Mean: "+Math.round(Mean*10000)/10000+"<br>";
				s+="Stdev: "+Math.round(Stdev*10000)/10000+"<br>";
			};
		}

		//get the content element
		var eContent=document.getElementById(ePointInfo2.id+"content");
		eContent.innerHTML=s;
	};
};

function chartpointclicked(_point) {
	console.log("point clicked");
	
	//get the series that the point belongs to
	var iSeries=_point.getAttribute("series");

	//get the ID of the chart
	var sID=replaceAllSubstrings(_point.parentNode.id,"ChartPlotArea","");

	//look for point info containers that have already been created.  The ID of a point info container
	//is [_id]point[series]_[index].  The index is not in any particular order and will be recycled if 
	//a container is closed.
	var Index=0;
	var sPopupID=sID+"point"+iSeries+"_"+Index;
	while(document.getElementById(sPopupID)) {
		Index++;
		sPopupID=sID+"point"+iSeries+"_"+Index;
	};

	//create info container
	var ePointInfo=document.createElement("div");
	ePointInfo.setAttribute("class","point_info_container");
	ePointInfo.id=sID+"point"+iSeries+"_"+Index;
	ePointInfo.innerHTML="";

	ePointInfo.setAttribute("pointID",_point.id);
	_point.parentNode.appendChild(ePointInfo);

	//determine x/y coordinates
	var xy1=getPosition2012(_point,"absolute",_point.parentNode);
	var top=xy1[1]+10;
	var left=xy1[0]+10;

	//offset the left position to move the container toward the bottom left quadrant the closer 
	//the point is to the right-hand side of the plot area
	var d=_point.offsetLeft/_point.parentNode.offsetWidth;
	left -=d*ePointInfo.offsetWidth;

	//position the container above the point if the point is in the bottom half of the graph
	if(_point.offsetTop>_point.parentNode.offsetHeight/2) {
		top-=ePointInfo.offsetHeight;
	};

	ePointInfo.style.top=top+"px";
	ePointInfo.style.left=left+"px";

	//add close icon to info container
	var eClose=document.createElement("div");
	eClose.setAttribute("class","point_info_close_icon");
	eClose.innerHTML="<span class='clear'>&nbsp</span>";
	eClose.setAttribute("onclick","this.parentNode.parentNode.removeChild(this.parentNode);updatePointInfo(\""+sID+"\","+iSeries+")");
	ePointInfo.appendChild(eClose);

	//add div that will contain the content
	var eContent=document.createElement("div");
	eContent.setAttribute("class","point_info");
	eContent.id=ePointInfo.id+"content";
	ePointInfo.appendChild(eContent);

	updatePointInfo(sID,iSeries);
};

function highlightChartSeries(_id,_series) {
	var eChartPlotArea=document.getElementById("ChartPlotArea"+_id);
	if(!eChartPlotArea) {
		console.log("Cannot find: "+"ChartPlotArea"+_id+"Chart");
		return;
	};

	var arDiv=eChartPlotArea.getElementsByTagName("div");
	for(var i=0;i<arDiv.length;i++) {
		var series=arDiv[i].getAttribute("series");
		if(series) {
			if(series==_series) {
				var sBackgroundColor=arDiv[i].style.backgroundColor;
				if(sBackgroundColor=="black") {
					arDiv[i].style.backgroundColor=arDiv[i].getAttribute("origcolor");
				}
				else {
						arDiv[i].setAttribute("origcolor",sBackgroundColor);
						arDiv[i].style.backgroundColor="black";
				};
			};
		};
	};
};

/***********************************************************************
This takes too long
***********************************************************************/
function highlightChartSeriesOLD(_id,_series,_enable) {
	var eChartPlotArea=document.getElementById("ChartPlotArea"+_id);
	if(!eChartPlotArea) {
		console.log("Cannot find: "+"ChartPlotArea"+_id+"Chart");
		return;
	};

	var arDiv=eChartPlotArea.getElementsByTagName("div");
	var dOriginalWidth=null;
	for(var i=0;i<arDiv.length;i++) {
		var series=arDiv[i].getAttribute("series");
		if(series) {
			if(series==_series) {
				//get the original width of the point.  The point is expanded to a multiple of its 
				//original width and height when hightlighted.
				if(!dOriginalWidth) dOriginalWidth=parseFloat(arDiv[i].getAttribute("originalwidth"));

				if(_enable) {
					//enable highlighting
					if(arDiv[i].offsetWidth<=dOriginalWidth) {
						arDiv[i].style.width=(dOriginalWidth*2)+"px";
						arDiv[i].style.height=(dOriginalWidth*2)+"px";
						arDiv[i].style.bottom=(arDiv[i].getAttribute("_bottom")-dOriginalWidth)+"px";
						arDiv[i].style.left=(arDiv[i].getAttribute("_left")-dOriginalWidth)+"px";
						arDiv[i].style.border="solid 2px black";
					};
				}
				else {
					//disable highlighting
					if(arDiv[i].offsetWidth>dOriginalWidth) {
						arDiv[i].style.width=dOriginalWidth+"px";
						arDiv[i].style.height=dOriginalWidth+"px";
						arDiv[i].style.bottom=arDiv[i].getAttribute("_bottom")+"px";
						arDiv[i].style.left=arDiv[i].getAttribute("_left")+"px";
						arDiv[i].style.border="none";
					};
				};
			};
		};
	};
};




/********************************************************************
Adds scripts included in widgets to the document's head element.
Called by initializeTables2012() whenever content is loaded
********************************************************************/
function addScripts() {
	var arScript=document.body.getElementsByTagName("script");
	if(arScript) {
		for(var i=0;i<arScript.length;i++) 
		{
			if(!arScript[i].getAttribute("aspectinitialized"))
			{
				//add an ID to the script if it doesn't have one
				if(arScript[i].id.length==0) {
					arScript[i].id=getSalt(4);
					appendToLog("Added ID to script: "+arScript[i].id);
				};

				var ScriptID="$$JS"+arScript[i].id;
				
				//remove the current javascript element from the head when in development mode so changes to the code are reflected during development
				//if("Deployed".equalsIgnoreCase("Development")) {
					var eCurrent=document.getElementById(ScriptID);
					if(eCurrent) {
						eCurrent.parentNode.removeChild(eCurrent);
					};
				//};

				if(!document.getElementById(ScriptID)) {
					//add it to the <head> element
					var eScript=document.createElement("script");
					eScript.id=ScriptID;

					//For IE, set the src of the script.  Another http request will be made to get the script
					if (getBrowserName().toUpperCase().indexOf("EXPLORER")>=0) {
						var s=arScript[i].getAttribute("_url");
						eScript.setAttribute("src",replaceAllSubstrings(s,"__Request"+"Server__",getServer()));
					}
					else {
						//otherwise, just include the script directly in the tag
						eScript.innerHTML=replaceAllSubstrings(arScript[i].innerHTML,"&amp;","&");
					};
					document.getElementsByTagName("head")[0].appendChild(eScript);
				};

				arScript[i].setAttribute("aspectinitialized","true");
			}
			else {
				//appendToLog("Already initialized script: "+arScript[i].id);
			};
		};
	};
};

/********************************************************************
Adds styles included in widgets to the document's head element.
Called by initializeTables2012() whenever content is loaded
********************************************************************/
function addStyles() {
	var arStyle=document.body.getElementsByTagName("style");
	if(arStyle) {
		for(var i=0;i<arStyle.length;i++) {
			var StyleID="$$JS"+arStyle[i].id;
			
			//remove the current javascript element from the head when in development mode so changes to the code are reflected during development
			if("Deployed".equalsIgnoreCase("Development")) {
				var eCurrent=document.getElementById(StyleID);
				if(eCurrent) {
					eCurrent.parentNode.removeChild(eCurrent);
				};
			};

			if(!document.getElementById(StyleID)) {
				//add it to the <head> element
				var eStyle=document.createElement("style");
				eStyle.id=StyleID;

				//For IE, set the src of the style.  Another http request will be made to get the style
				if (getBrowserName().toUpperCase().indexOf("EXPLORER")>=0) {
					var s=arStyle.getAttribute("_url");
					eStyle.setAttribute("src",replaceAllSubstrings(s,"__Request"+"Server__",getServer()));
				}
				else {
					//otherwise, just include the style directly in the tag
					eStyle.innerHTML=replaceAllSubstrings(arStyle[i].innerHTML,"&amp;","&");
				};
				document.getElementsByTagName("head")[0].appendChild(eStyle);
			};
		};
	};
};






/******************************************************************************************************
Debugging
******************************************************************************************************/
var EnableConsole=false;
var EnableConsoleRemote="false";

function appendToLog(msg,boolClear,bAddToActivityLog) 
{
	if((EnableConsole) || (EnableConsoleRemote.equalsIgnoreCase("true"))) {
		var strMsg=replaceAllSubstrings(replaceAllSubstrings(msg,"<","&lt;"),">","&gt;");
		var strMsg=replaceAllSubstrings(msg,"&","@");
	
		//add the message to the Aspect activity log
		//var strUrl=getServer()+"/?Network=GreenLight&ID=appendToLog&msg=Browser: "+strMsg;
		//asynchInclude(null,strUrl); 
		
		strMsg=formatDate(new Date(),"HH:mm:ss")+" "+strMsg;
		var e=document.getElementById("debug_console");
		if (e) {
			(boolClear) ? e.innerHTML=strMsg+"<br>" : e.innerHTML+=strMsg+"<br>";
		};
	
		if(console) console.log(strMsg);
	};
};

/****************************************************************
Displays an alert message containing a stack trace.  Only works in 
Firefox.  Could be modified like printStackTrace() to work in all
browsers.
*****************************************************************/
function alertStackTrace() {
	var callstack=[];
	try {
		i.dont.exist+=0; //doesn't exist- that's the point
	} 
	catch(e) {
		alert(e.stack);
	};
};

/*********************************************************************************
Call to output a stack trace to the debug window.  This is probably more complicated
than necessary.  The match function causes all lines to be excluded.  The Firefox
method is very simple - e.stack is just a line-feed delimited array
*********************************************************************************/
function printStackTrace() {
	var callstack=[];
	var isCallstackPopulated=false;
	try {
		i.dont.exist+=0; //doesn't exist- that's the point
	} catch(e) {
		if (e.stack) { //Firefox
			var lines=e.stack.split('\n');
			for (var i=0, len=lines.length; i<len; i++) {
				//if (lines[i].match(/^\s*[A-Za-z0-9\-_\$]+\(/)) {
					callstack.push(lines[i]);
				//}
			}
			//Remove call to printStackTrace()
			callstack.shift();
			isCallstackPopulated=true;
		}
		else if (window.opera && e.message) { //Opera
			var lines=e.message.split('\n');
			for (var i=0, len=lines.length; i<len; i++) {
				if (lines[i].match(/^\s*[A-Za-z0-9\-_\$]+\(/)) {
					var entry=lines[i];
					//Append next line also since it has the file info
					if (lines[i+1]) {
						entry +=" at " + lines[i+1];
						i++;
					}
					callstack.push(entry);
				}
			}
			//Remove call to printStackTrace()
			callstack.shift();
			isCallstackPopulated=true;
		}
	}
	if (!isCallstackPopulated) { //IE and Safari
		var currentFunction=arguments.callee.caller;
		while (currentFunction) {
			var fn=currentFunction.toString();
			var fname=fn.substring(fn.indexOf("function") + 8, fn.indexOf('')) || 'anonymous';
			callstack.push(fname);
			currentFunction=currentFunction.caller;
		}
	}

	console.log("stack trace:",false,true);
	var s="";
	for(var i=0;i<callstack.length;i++) s +=callstack[i]+"^\r\n";
	console.log(s,false,true);
};




/*********************************************************************************
Sets the display attribute for an element.  The element (aitem) may be passed as
an ID or as an html element.  If an interval is specified, the element's interval
attribute is updated as follows
	- If the item is being hidden, interval is set to -1 regardless of the Interval value
	- If the item is being shown, interval is set to the Interval value 
		EXCEPT when Interval=0.  If Interval=0, then the interval is set to 0 if
		the item hasn't already been updated by an asynchinclude.
		
The interval argument allows an item to be displayed and for it to refresh at a given
interval.  It also allows for the content of an item to be updated only once, even
if it is displayed or hidden multiple times.  The idea is to allow many elements 
on a page, to only get the content for an element when it is displayed and to avoid
getting the content again if the item is hidden and displayed again.
*********************************************************************************/
function setVisible(aitem,boolVisible,Interval,ShowStatusIcon,Msg)
{
	var e=document.getElementById(aitem);
	if(!e) e=aitem;
	if(!e) return;
	if(!e.nodeName) {
		//appendToLog("Error in setVisible: "+aitem+" bVisible="+boolVisible);
		//printStackTrace();
		return;
	};
	
	if (e) {
		var strOn="block";
		var strOff="none";
		
		//if it's a table row, need to use inline or table-row
		if (e.nodeName.equalsIgnoreCase("tr")) {
			strOn="inline";
			if (getBrowserName().toUpperCase().indexOf("NETSCAPE")>=0) strOn="table-row";
		};
		
		//if it's a span, use inline
		if(e.nodeName.equalsIgnoreCase("span")) strOn="inline";
		
		//set the display on/off
		if (getBrowserName().toUpperCase().indexOf("EXPLORER")>=0) {
			//Internet Explorer
			if (boolVisible) {
				e.style.display=strOn;
				e.display=strOn;
			}
			else {
				e.style.display=strOff;
				e.display=strOff;
			};
		}
		else {
			//Everything else
			(boolVisible) ? e.style.display=strOn : e.style.display=strOff;
		};
		if(boolVisible) setDimensions(e);
		
		//if the element contains a table of tabs, also show or hide tabs belonging to the table
		var arTable=e.getElementsByTagName("table");
		if(arTable) {
			for (var i=0;i<arTable.length;i++) {
				var sClass=arTable[i].getAttribute("class");
				if((sClass) && (sClass.equalsIgnoreCase("tabdialog"))) {
					if(boolVisible) {
						//show the last tab selected
						s=arTable[i].getAttribute("SelectedTab");
						if(s) {
							var ar=getSubStringArray(s,"|");
							//if(ar==null) alert("ar=null in setVisible");
							for (var j=0;j<ar.length;j++) setVisible(ar[j],true);
						};
					}
					else {
						//hide all tabs associated with the table
						hideTabElements(arTable[i]);
					};
				};
			};
		};

		//if an interval is defined, set the interval attribute of the item
		if(Interval!=null) {
			if(boolVisible) {
				//only set the interval if it's greater than zero or if the element has not yet been updated
				//by an asynchinclude.  This allows a 0 interval to be specified to update the item only once,
				//even if it is shown and hidden multiple times.
				var bIsLoaded=false;
				if(e.getAttribute("AspectASynchInclude")) {
					if(e.getAttribute("AspectASynchInclude").trim().length>0) bIsLoaded=true;
				};
				if((parseInt(Interval)>0) || (!bIsLoaded)) {
					e.setAttribute("interval",Interval);
					if((ShowStatusIcon) || (Msg)) {
						e.innerHTML="";
						if(ShowStatusIcon) {
							var eProgress=document.createElement("progress");
							e.appendChild(eProgress);
							//var img=document.createElement("img");
							//img.src=imageStatusActive.src;
							//e.appendChild(img);
						};
						if(Msg) {
							e.innerHTML +="&nbsp;"+Msg;
						};
					};
					if(Interval==0) refreshWidgets();
				};
			}
			else {
				e.setAttribute("interval","-1");
			};
		};
	};
};

function isVisible(aitem) {
	var e=document.getElementById(aitem);
	if(!e) e=aitem;
	if(!e) return(false);
	if(!e.nodeName) return(false);

	//if no display style is defined, consider it visible
	if(!e.style) return(true);
	if(!e.style.display) return(true);
	if(e.style.display.length==0) return(true);

	if (e) {
		var strOn="block";
		var strOff="none";
		
		//if it's a table row, need to use inline or table-row
		if (e.nodeName.equalsIgnoreCase("tr")) {
			strOn="inline";
			if (getBrowserName().toUpperCase().indexOf("NETSCAPE")>=0) strOn="table-row";
		};

		//get the current display status
		if (getBrowserName().toUpperCase().indexOf("EXPLORER")>=0) {
			//Internet Explorer
			if ((e.style.display.length==0) || (e.style.display.equalsIgnoreCase(strOff))) {return(false);} else {return(true);};
		}
		else {
			//Everything else
			if ((e.style.display.length==0) || (e.style.display.equalsIgnoreCase(strOff))) {return(false);}	else {return(true);};
		};
	}
	else {
		alert("Error: isVisible cannot find element with ID="+aitem);
	};
};

/*********************************************************************************
Shows or hides an element.  The element may be specified using an ID or as an
html element.  The optional interval argument is passed to setVisible() so the
content of an item may be updated when it is made visible.
*********************************************************************************/
function toggleVisible(aitem,Interval,ShowStatusIcon,Msg) {
	var e=document.getElementById(aitem);
	if(!e) e=aitem;
	if(!e.nodeName) return;
	
	if (e) {
		var strOn="block";
		var strOff="none";
		
		//if it's a table row, need to use inline or table-row
		if (e.nodeName.equalsIgnoreCase("tr")) {
			strOn="inline";
			if (getBrowserName().toUpperCase().indexOf("NETSCAPE")>=0) {
				strOn="table-row";
			};
		};
		
		var bIsHidden=(e.style.display==strOff) || ((e.offsetWidth==0) && (e.offsetHeight==0));
		//appendToLog("bIsHidden="+bIsHidden+" e.style.display="+e.style.display+" strOff="+strOff+" e.offsetWidth="+e.offsetWidth+" e.offsetHeight="+e.offsetHeight);

		//get the current display status
		if (getBrowserName().toUpperCase().indexOf("EXPLORER")>=0) {
			//Internet Explorer
			//(Interval!=null) ? setVisible(aitem,(e.style.display==strOff),Interval,ShowStatusIcon,Msg) : setVisible(aitem,(e.style.display==strOff));
			(Interval!=null) ? setVisible(aitem,(e.style.display==strOff),Interval,ShowStatusIcon,Msg) : setVisible(aitem,bIsHidden);
		}
		else {
			//Everything else
			//(Interval!=null) ? setVisible(aitem,(e.style.display==strOff),Interval,ShowStatusIcon,Msg) : setVisible(aitem,(e.style.display==strOff));
			(Interval!=null) ? setVisible(aitem,(e.style.display==strOff),Interval,ShowStatusIcon,Msg) : setVisible(aitem,bIsHidden);
		};
	}
	else {
		//alert("Error: toggleVisible cannot find element with ID="+strID);
	};
};

/*********************************************************************************
*********************************************************************************/
function setInterval(aitem,Interval,ShowStatusIcon,Msg)
{
	var e=document.getElementById(aitem);
	if(!e) e=aitem;
	if(!e.nodeName) {
		appendToLog("Error in setInterval: "+aitem+" not found");
		return;
	};
	
	e.setAttribute("interval",Interval);
	if((ShowStatusIcon) || (Msg)) {
		e.innerHTML="";
		if(ShowStatusIcon) {
			var eProgress=document.createElement("progress");
			e.appendChild(eProgress);
		};
		if(Msg) {
			e.innerHTML +="&nbsp;"+Msg;
		};
	};
	
	if(Interval==0) refreshWidgets();
};
	





function getOptionValue(_e,_ID) {
	if(!_e) reutrn(null);
	for(var i=0;i<_e.options.length;i++) {
		if(_e.options[i].value.equalsIgnoreCase(_ID)) return(_e.options[i].text);
	};
	return(null);
};


function setDatalist(e,NewListID,bKeepSelection) {
	//abort if the new list does not exist
	if(!document.getElementById(NewListID)) {
		alert("Error in setList: List not found: "+NewListID);
		return;
	};

	//get the current and new lists
	var eCurrentList=document.getElementById(e.getAttribute("list"));
	if(!eCurrentList) eCurrentList=document.getElementById(e.getAttribute("_list"));
	var eNewList=document.getElementById(NewListID);

	//set the attribute of the visible element to use the new list
	//The _list attribute is used when enforcing a minimum character limit before opening the list
	//see invoice details for an example.
	e.setAttribute("list",NewListID);
	e.setAttribute("_list",NewListID);

	//see if the current input is valid for the new datalist
	bInputIsValid=isDatalistSelectionValid(e.value,eNewList);

	//if it is valid, then exit
	if(bInputIsValid) return;
	
	//otherwise, if bKeepSelection is true, then add the value to the new list
	if(bKeepSelection) {
		//get the value and the AspectID of the current selection
		var sKeepValue=e.value;
		var sKeepAspectID=getDatalistAspectID(sKeepValue,eCurrentList);

		//create a new innerHTML value for the datalist, adding the new value alphabetically
		var sInnerHTML="";
		var bAdded=false;
		for(var i=0;i<eNewList.options.length;i++) {
			var sValue=eNewList.options[i].value;
			var sAspectID=eNewList.options[i].getAttribute("AspectID");

			//add the new option at the appropriate location in the list
			if(!bAdded) {
				if(sValue.toUpperCase>sKeepValue.toUpperCase()) {
					sInnerHTML+="<option AspectID=\""+sKeepAspectID+"\" value=\""+sKeepValue+"\">";
					bAdded=true;
				};
			};

			//add the existing option
			sInnerHTML+="<option AspectID=\""+sAspectID+"\" value=\""+sValue+"\">";
		};
		eNewList.innerHTML=sInnerHTML;
	}
	else {
		//set the value to the first item in the new list and submit the data

		//determine if data should be submitted using submitDialogCell
		var s=e.getAttribute("submitdialogcell");
		bSubmit=((s) && (s.equalsIgnoreCase("true")));

		//get the hidden input used to submit the data
		var eInputSubmit=document.getElementById(e.id+"_submit");

		//if the new datalist is empty, just clear the values and return since there
		//is no default
		if(eNewList.options.length==0) {
			e.value="";
			eInputSubmit.value="";
		}
		else {
			e.value=eNewList.options[0].value;
			eInputSubmit.value=eNewList.options[0].getAttribute("AspectID");
		};
		if(bSubmit) submitDialogCell(eInputSubmit);
	};
};


function isDatalistSelectionValid(s,eList) {
	for(var i=0;i<eList.options.length;i++) {
		if(eList.options[i].value.equalsIgnoreCase(s)) return(true);
	};
	return(false);
};


function getDatalistAspectID(s,eList) {
	for(var i=0;i<eList.options.length;i++) {
		if(eList.options[i].value.equalsIgnoreCase(s)) {
			return(eList.options[i].getAttribute("AspectID"));
		};
	};
	return(null);
};


function dataListInputChanged(e) {
	//get the value of the input
	var sValue=e.value.trim();

	//determine if data should be submitted using submitDialogCell
	var s=e.getAttribute("submitdialogcell");
	bSubmit=((s) && (s.equalsIgnoreCase("true")));

	//get the hidden input used to submit the data
	var sInputSubmitID=e.id+"_submit";
	var eInputSubmit=document.getElementById(sInputSubmitID);
		
	//abort if the submit input does not exist
	if(!eInputSubmit) {
		alert("dataListInputChanged Cannot locate submit element: "+sInputSubmitID+" for input: "+e.id);
		return;
	};

	//get the datalist associated with the input
	if(e.getAttribute("list")) {
		var sDataListID=e.getAttribute("list");
	}
	else if(e.getAttribute("_list")) {
		var sDataListID=e.getAttribute("_list");
	};

	var eDataList=document.getElementById(sDataListID);
	if(!eDataList) {
		eDataList=document.getElementById(replaceAllSubstrings(e.id,"_input",""));
	};

	//abort if the datalist does not exist
	if(!eDataList) {
		alert("dataListInputChanged Cannot locate datalist with ID="+sDataListID+" for input: "+e.id);
		return;
	};

	//clear the value if the datalist contains no elements
	if(eDataList.options.length==0) {
		e.value="";
		console.log("Error: Datalist contains no values");
		return;
	};

	//get the default value and ID.  This is the first value in the datalist.  
	var sDefaultValue=eDataList.options[0].value;
	var sDefaultAspectID=eDataList.options[0].getAttribute("AspectID");

	//if the cell is empty, set the value to the first value in the datalist and 
	//submit the data
	if(sValue.length==0) {
		e.value=sDefaultValue;
		eInputSubmit.value=sDefaultAspectID;
		//console.log("dataListInputChanged set default value: "+sDefaultValue+"="+sDefaultAspectID+" bSubmit="+bSubmit);
		if(bSubmit) submitDialogCell(eInputSubmit);
		return;
	};

	//verify that the data is valid
	//appendToLog("verifying datalist Value="+sValue,false,true);
	for(var i=0;i<eDataList.options.length;i++) {
		if(eDataList.options[i].value.equalsIgnoreCase(sValue)) {
			var sAspectID=eDataList.options[i].getAttribute("AspectID");
			eInputSubmit.value=sAspectID;
			//console.log("dataListInputChanged validated value: "+sValue+"="+sAspectID+" bSubmit="+bSubmit);
			if(bSubmit) {
				//console.log("dataListInputChanged calling submitDialogCell name="+eInputSubmit.getAttribute("name"));
				submitDialogCell(eInputSubmit);
			};
			//appendToLog("Found match.  Set value of "+eInputSubmit.id+"="+sAspectID+" Submit="+bSubmit,false,true);
			return;
		};
	};

	//if the data was not valid, then clear the input and submit a blank value
	//appendToLog("Data not valid",false,true);
	//e.value=sDefaultValue;
	if(sDefaultValue.toUpperCase().startsWith("-- SELECT")) {
		//console.log("dataListInputChanged cleared invalid value: "+e.value);
		e.value="";
	}
	else {
		//console.log("dataListInputChanged set invalid value: "+sDefaultValue);
		e.value=sDefaultValue;
	};
	eInputSubmit.value=sDefaultAspectID;
	//console.log("dataListInputChanged: "+e.value+"="+eInputSubmit.value+" bSubmit="+bSubmit);
	//appendToLog("Set datalist input value=["+e.value+"] Set submit value=["+eInputSubmit.value+"]");
	if(bSubmit) submitDialogCell(eInputSubmit);
};

/******************************************************************
Refreshes the collections for all select boxes that have the "update" attribute
set to true.  This attribute is set by submitTableData() when data is submitted for a table.
******************************************************************/
function updateSelectBoxes()
{
	var arSelect=document.getElementsByTagName("select");
	for(var i=0;i<arSelect.length;i++) {
		var sUpdate=arSelect[i].getAttribute("update");
		if((sUpdate) && (sUpdate.equalsIgnoreCase("true"))) {
			if(arSelect[i].id.length==0) arSelect[i].id=getSalt(4);
			//appendToLog("updateSelectBoxes updating "+arSelect[i].id);
			updateOptions(arSelect[i].id);
		};
	};

	var arDataList=document.getElementsByTagName("DataList");
	for(var i=0;i<arDataList.length;i++) {
		var sUpdate=arDataList[i].getAttribute("update");
		if((sUpdate) && (sUpdate.equalsIgnoreCase("true"))) {
			if(arDataList[i].id.length==0) arDataList[i].id=getSalt(4);
			updateOptions(arDataList[i].id);
		};
	};
};

/****************************************************************************************************
Updates the options in a select box or DataList by making a call to the request server to get 
a current list of options.  Relies on select boxes generated by htmlSelect which include a 
source, filter, driver params and system driver name in the select tag.

If the optional Selected value is specified, the value of the updated select box will be set
to the given value.

If the optional AEnable paramter is specified, the updated select box will be enabled or 
disabled accordingly.  This allows a select box to be disabled while is it being updated and 
then enabled when the update is complete.

The optional CallBackFunction can be used to call a function when the update is complete.
This can be used when updateOptions is called explicitly in a script to continue with
further processing when the update is complete.

The IsComplete parrameter is used to indicate that the update is complete and to avoid
looping continuously if s is undefined due to an error getting the collection
****************************************************************************************************/
function updateOptions(ID,Selected,AEnable,CallbackFunction,IsComplete,s)
{	
	//alert("updateOptions ID="+ID+" Selected="+Selected+" AEnable="+AEnable+" IsComplete="+IsComplete);
	var e=document.getElementById(ID);
	if(!e) {
		appendToLog("Error: updateOptions() cannot locate select with ID="+ID);
		return;
	};
	
	var bIsDataList=(e.nodeName=="DATALIST");

	if(IsComplete) {
		setOptions(e,s);

		//enable the select box
		if(AEnable) e.disabled=!AEnable;

		if(bIsDataList) {
			//get the input associated with the datalist.  It uses the same ID, but without 
			//DataList at the beginning
			var sInputID=e.id.substring(8);
			var eInput=document.getElementById(sInputID);
			if(eInput) {
				for(var i=0;i<e.options.length;i++) {
					var sAspectID=e.options.getAttribute("AspectID");
					if(sAspectID.equalsIgnoreCase("Selected")) {
						eInput.value=e.options.value;
					};
				};
			};
		}
		else {
			//appendToLog("setting selected value to: "+Selected);
			for(var i=0;i<e.options.length;i++) {
				if(e.options[i].value.equalsIgnoreCase(Selected)) {
					e.selectedIndex=i;
					break;
				};
			};
		};

		//execute the callback if defined
		if((CallbackFunction) && (CallbackFunction.length>0)) {
			setTimeout(CallbackFunction,0);
		};

		return;
	}
	
	var sCollectionID=e.getAttribute("CollectionID");
	var sSource=e.getAttribute("source");
	var sFilter=e.getAttribute("filter");
	var sParams=e.getAttribute("params");
	var sSysDriverName=e.getAttribute("SysDriverName");
	
	var sUrl=getServer()+"/?Network=Greenlight&ID=getWidget&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&Widget=Notification Queries";
	sUrl +="&query=getHtmlSelectOptions";
	sUrl +="&CollectionID="+sCollectionID;
	sUrl +="&Source="+sSource;
	sUrl +="&Filter="+sFilter;
	sUrl +="&DriverParams="+sParams;
	sUrl +="&SystemDriverName="+sSysDriverName;
	//appendToLog("updateOptions URL: "+sUrl);

	//get current selection
	var SelectValue="";
	if(bIsDataList) {
		//get the input associated with the datalist.  It uses the same ID, but without 
		//DataList at the beginning
		var sInputID=e.id.substring(8);
		var eInput=document.getElementById(sInputID);
		if((eInput) && (eInput.value.length>0)) {
			for(var i=0;i<e.options.length;i++) {
				var sOptionValue=e.options[i].value;
				if(sOptionValue.equalsIgnoreCase(eInput.value)) {
					var SelectValue=e.options[i].getAttribute("AspectID");
					break;
				};
			};
		};
	}
	else {
		var SelectValue=e.value;
	};
	if(Selected) SelectValue=Selected;

	var bEnable=false;
	if(AEnable) bEnable=AEnable;

	var sCallbackFunc="";
	if(CallbackFunction) sCallbackFunc=CallbackFunction;

	var sFunc="updateOptions(\""+ID+"\",\""+SelectValue+"\","+bEnable+",\""+sCallbackFunc+"\",true,s)";
	//appendToLog("updateOptions: sFunc="+sFunc);
	//appendToLog("updateOptions: sUrl="+sUrl);
	asynchInclude(null,sUrl,sFunc,sFunc);
};

/* Sets the contents of a select box given a string of options in the form option1=value1|option2=value2 */
function setOptions(eSelect,strOptions) {
	//appendToLog("setOptions: "+strOptions);
	if(eSelect==null) {
		appendToLog("eSelect is null in setOptions.  Options="+strOptions,false,true);
		printStackTrace();
	};
	
	var bIsDataList=(eSelect.nodeName=="DATALIST");

	//save the current selection.  It will be restored if it is in the new set of options.
	var Selection="";
	var bKeepSelection=false;
	if(bIsDataList) {
		var eInput=document.getElementById(eSelect.id+"_input");
		if(eInput) {
			for(var i=0;i<eSelect.options.length;i++) {
				if(eSelect.options[i].value.equalsIgnoreCase(eInput.value)) {
					Selection=eSelect.options[i].getAttribute("AspectID");
				};
			};
		};
	}
	else {
		Selection=eSelect.value;
	};

	eSelect.options.length=0;
	if(bIsDataList) eSelect.innerHTML="";

	//use the split function instead of getSubStringArray to avoid problems that occur
	//if the data contains quotes.
	//arCollection=getSubStringArray(strOptions,"|",true);
	arCollection=strOptions.split("|");

	if(arCollection!=null) {
		if(bIsDataList) {
			var sOptions="";
			var sInputValue="";
			for(var i=0;i<arCollection.length;i++) {
				arPair=getSubStringArray(arCollection[i],"=",true);
				if((arPair) && (arPair.length>1)) {
					sOptions+="<option AspectID=\""+arPair[0]+"\" value=\""+arPair[1]+"\">";
					if(arPair[0].equalsIgnoreCase(Selection)) sInputValue=arPair[1];
				};
			};

			eSelect.innerHTML=sOptions;

			var eInput=document.getElementById(eSelect.id+"_input");
			if(eInput) eInput.value=sInputValue;
		}
		else {
			for(var i=0;i<arCollection.length;i++) {
				arPair=getSubStringArray(arCollection[i],"=",true);
				if((arPair) && (arPair.length>1)) {
					eSelect.options[eSelect.options.length]=new Option(arPair[1],arPair[0],false,false);
					if(arPair[0].equalsIgnoreCase(Selection)) bKeepSelection=true;
				};
			};
			
			if(bKeepSelection) eSelect.value=Selection;
		};
	}
	else {
		appendToLog("Error in setOptions.  Options is empty.",false,true);
		printStackTrace();
	};
};

function oldupdateOptions(ID,Selected,AEnable,CallbackFunction,IsComplete,s)
{	
	//appendToLog("updateOptions ID="+ID+" Selected="+Selected+" AEnable="+AEnable+" s="+s);
	var e=document.getElementById(ID);
	if(!e) {
		appendToLog("Error: updateOptions() cannot locate select with ID="+ID);
		return;
	};
	
	var sList=e.getAttribute("list");
	var bIsDataList=(sList) ? true : false;

	if(IsComplete) {
		setOptions(e,s);

		//enable the select box
		if(AEnable) e.disabled=!AEnable;

		if((!bIsDataList) && (Selected)) {
			//appendToLog("setting selected value to: "+Selected);
			for(var i=0;i<e.options.length;i++) {
				if(e.options[i].value.equalsIgnoreCase(Selected)) {
					e.selectedIndex=i;
					break;
				};
			};
		};

		//execute the callback if defined
		if((CallbackFunction) && (CallbackFunction.length>0)) {
			setTimeout(CallbackFunction,0);
		};

		return;
	}
	
	var sCollectionID=e.getAttribute("CollectionID");
	var sSource=e.getAttribute("source");
	var sFilter=e.getAttribute("filter");
	var sParams=e.getAttribute("params");
	var sSysDriverName=e.getAttribute("SysDriverName");
	
	var sUrl=getServer()+"/?Network=Greenlight&ID=getWidget&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&Widget=Notification Queries";
	sUrl +="&query=getHtmlSelectOptions";
	sUrl +="&CollectionID="+sCollectionID;
	sUrl +="&Source="+sSource;
	sUrl +="&Filter="+sFilter;
	sUrl +="&DriverParams="+sParams;
	sUrl +="&SystemDriverName="+sSysDriverName;
	//appendToLog("updateOptions URL: "+sUrl);

	var SelectValue=e.value;
	if(Selected) SelectValue=Selected;

	var bEnable=false;
	if(AEnable) bEnable=AEnable;

	var sCallbackFunc="";
	if(CallbackFunction) sCallbackFunc=CallbackFunction;

	var sFunc="updateOptions(\""+ID+"\",\""+SelectValue+"\","+bEnable+",\""+sCallbackFunc+"\",true,s)";
	//appendToLog("sFunc="+sFunc);
	asynchInclude(null,sUrl,sFunc,sFunc);
};

/* Sets the contents of a select box given a string of options in the form option1=value1|option2=value2 */
function oldsetOptions(eSelect,strOptions) {
	if(eSelect==null) {
		appendToLog("eSelect is null in setOptions.  Options="+strOptions,false,true);
		printStackTrace();
	};
	
	var sList=eSelect.getAttribute("list");
	var bIsDataList=(sList) ? true : false;

	//save the current selection.  It will be restored if it is in the new set of options.
	if(!bIsDataList) {
		var Selection=eSelect.value;
		var bKeepSelection=false;
	};
	
	var options=eSelect.options;
	options.length=0;
	arCollection=getSubStringArray(strOptions,"|",true);
	if(arCollection!=null) {
		for(var i=0;i<arCollection.length;i++) {
			arPair=getSubStringArray(arCollection[i],"=",true);
			if((arPair) && (arPair.length>1)) {
				if(bIsDataList) {
					var n=options.length;
					options[n]=new Option();
					options[n].setAttribute("Value",arPair[1]);
					options[n].setAttribute("AspectID",arPair[0]);
				}
				else {
					options[options.length]=new Option(arPair[1],arPair[0],false,false);
					if(arPair[0].equalsIgnoreCase(Selection)) bKeepSelection=true;
				};
			};
		};
		if((!bIsDataList) && (bKeepSelection)) eSelect.value=Selection;
	}
	else {
		appendToLog("Error in setOptions.  Options is empty.",false,true);
		printStackTrace();
	};
};




function logout()
{
	var CloseSessionID=getCookie("session");
	deleteCookie("session");
	window.open(getServer()+"/?Network=Greenlight&ID=getWidget&DocumentID=&Widget=&TargetPage=&CloseSession="+CloseSessionID,"_self");
};




var initializeParametersCount=0;
initializeParameters();

var arUICompany=new Array();
var arUIComputer=new Array();

//The last screen width is used to avoid executing the screenResizedListener() function
//when the screen size changes because the keyboard is displayed on a mobile device.  
//The result was for the hidepopups() function to hide the UI popups whenever the user 
//set the focus to a text field in a popup (e.g. search box in computer tab or a date 
//in a view parameter)
var LastScreenWidth=screen.width;

function screenResizedListener() {
	if(LastScreenWidth==screen.width) return;
	LastScreenWidth=screen.width;

	//Hide popups.  They do not resize properly until opened again.
	hidePopups();
	setOpenViewSelectionMethod();
	updateBrowserStats();
	hideAllTableMenus();
	formatViewContainers(true);
};

function updateBrowserStats() {
	//update screen size in the settings popup
	var e=document.getElementById("ScreenSize");
	if(e) e.innerHTML=screen.width+"x"+screen.height;
	e=document.getElementById("BrowserSize");
	if(e) e.innerHTML=window.innerWidth+"x"+window.innerHeight;
};

function initializeParameters(n)
{
	initializeParametersCount++;
	if(initializeParametersCount>10) {
		console.log("aborting initializeParameters initializeParametersCount="+initializeParametersCount);
		return;
	};

	//abort if top bar is not loaded.  There will not be a top bar in
	//containers other than the home page
	if(!document.getElementById("top_bar2015")) {
		setTimeout("initializeParameters()",500);
		return;
	};

	//make sure container surrounding views is loaded
	if(!document.getElementById("869512")) {
		setTimeout("initializeParameters()",500);
		return;
	};

	//Hide link used to close all open views
	//setVisible("UICloseAllViews",false);

	//hide the left bar and popup menu
	setVisible("UIMenuContainer",false);

	//update info in the settings popup
	updateBrowserStats();

	//enable mouseover events in menu bar
	var bisTouchDevice=('ontouchstart' in document.documentElement);
	appendToLog("bisTouchDevice="+bisTouchDevice);

	if(!bisTouchDevice) {
		/*	Mouseover and mouseout functions are disabled for now because there is 
				not a way to limit the size of the select box used for views.  The 
				select box can extend outside the bounds of the popup and cause the 
				popup to close.  
		*/
		if(false) {
			var s="showPopup('User',true)";
			document.getElementById("UISelectedUser").setAttribute("onmouseover",s);	
			document.getElementById("UISelectedUser").onmouseover=Function(s);		
	
			var s="showPopup('Computer',true)";
			document.getElementById("UISelectedComputer").setAttribute("onmouseover",s);	
			document.getElementById("UISelectedComputer").onmouseover=Function(s);		
	
			var s="showPopup('View',true)";
			document.getElementById("UISelectedView").setAttribute("onmouseover",s);	
			document.getElementById("UISelectedView").onmouseover=Function(s);		
	
			var s="showPopup('Settings',true)";
			document.getElementById("UISettings").setAttribute("onmouseover",s);	
			document.getElementById("UISettings").onmouseover=Function(s);		
		};
	};

	//cache the initial view informaiton
	var sCacheId="UIAvailableViews_"+getSelectedComputer()+"_"+getUserProfileID();
	var eCache=document.createElement("div");
	eCache.id=sCacheId;
	eCache.innerHTML=document.getElementById("UIAvailableViews").innerHTML;
	document.body.appendChild(eCache);

	//initialize the computer history selection with the current selection
	addToUIComputerHistory(getSelectedComputer(),getComputerName());

	//call the showPopup function for the view popup in order to move it from the
	//template to the menu bar.  This must be done before updating view parameters,
	//otherwise the update will fail if the template is moved while an asynchInclude
	//is still in progress to update the parameters
	showPopup("View",false);

	viewSelected();
};

/**************************************************************
Records a default value.  Called when a parameter value changes.
The default is recorded in Aspect and in the javascript hashtable.
Values recorded in the hashtable are used to update parameter
values when a view is selected and html for the parameter inputs
is gotten from the hashtable rather than by a request to Aspect.
Defaults are recorded in Aspect using the ID of the parameter
definition, the name of the parameter in the view definition and 
the ID of the parameter in the view definition.  This allows the
default to be retrieved in three ways:
	1.  A shared default based on the param definition (shared by all views)
	2.  A shared default based on the param name (shared by all views)
	3.  A default associated only with a specific param in a specific view
**************************************************************/
function putDefault(Key,Value,AltKey1,AltKey2) {
	if(typeof(Value)=="string") {
		if(Value.equalsIgnoreCase("undefined")) {
			//appendToLog("Ignoring default for "+Key+"="+Value+" Alt="+AltKey1+" Alt="+AltKey2);
			return;
		};
	};

	//record the value in the javascript hashtable.
	//this needs to be modified to account for the other two keys
	if(AltKey2) hashPut(AltKey2,Value);
  //appendToLog("putDefault "+Key+"="+Value+" Alt="+AltKey1+" Alt="+AltKey2);

	var sParams=getServer()+"/?Network=Greenlight&ID=putDefault";
	sParams +="&Key="+Key+"&Value="+Value;
	if(AltKey1) sParams +="&AltKey1="+AltKey1;
	if(AltKey2) sParams +="&AltKey2="+AltKey2;
	asynchInclude(null,sParams,"","");
};

/**************************************************************
These functions get the current selections
**************************************************************/
function getUserProfileID() {
	return(document.getElementById("UIselect_user_profile").value);
};

function getUserName() {
	var e=document.getElementById("UIselect_user_profile")
	return(e.options[e.selectedIndex].text);
};

function getComputerName() {
	var e=document.getElementById("UISelectUserComputer");
	return(e.options[e.selectedIndex].text);
};

function getViewName() {
	var e=document.getElementById("UISelectView");
	return(e.options[e.selectedIndex].text);
};

function getSelectedCompany() {
	return(document.getElementById("UISelectUserCompany").value);
};

function getSelectedComputer() {
	return(document.getElementById("UISelectUserComputer").value);
};

function getSelectedComputerHistory() {
	return(document.getElementById("UISelectUserComputerHistory").value);
};

function getSelectedPackage() {
	return(document.getElementById("UISelectPackage").value);
};

function getSelectedCategory() {
	return(document.getElementById("UISelectViewCategory").value);
};

function getSelectedView() {
	return(document.getElementById("UISelectView").value);
};

function getDeployedViewsOnlySelected() {
	var bDeployedOnly=true;
	if(document.getElementById("UIDeployedViewsOnly")) {
		bDeployedOnly=document.getElementById("UIDeployedViewsOnly").checked;
	};
	return(bDeployedOnly);
};

/**************************************************************
Gets an array of available computers.
**************************************************************/
function getAvailableComputers() {
	var e=document.getElementById("UICollection_Computer");
	return(e.innerHTML.trim().split("|"));
};

/**************************************************************
Gets an array of available packages.  The format of each
element in the array is:
	PackageID=PackageName
**************************************************************/
function getAvailablePackages() {
	var e=document.getElementById("UICollection_Package");

	if(!e) {
		var arSpan=document.getElementById("UIAvailableViews").getElementsByTagName("SPAN");
		for(var i=0;i<arSpan.length;i++) {
			if(arSpan[i].id) {
				if(arSpan[i].id.startsWith("UIAvailableViewsProcessedBy_")) arSpan[i].id="UIAvailableViewsProcessedBy";
				if(arSpan[i].id.startsWith("UICollection_Package_")) arSpan[i].id="UICollection_Package";
				if(arSpan[i].id.startsWith("UICollection_ViewCategory_")) arSpan[i].id="UICollection_ViewCategory";
				if(arSpan[i].id.startsWith("UICollection_View_")) arSpan[i].id="UICollection_View";
			};
		};
		e=document.getElementById("UICollection_Package");
	};

	if(!e) return("");
	if(e.innerHTML.trim().length==0) return("");

	var a1=e.innerHTML.trim().split("|");
	
	//if not showing only deployed views, then done
	if(!getDeployedViewsOnlySelected()) return(a1);

	//otherwise, only include packages that have a deployed view
	//make an array of all package ID's for deployed views
	var arDeployedPackage=new Array();
	var arView=getAvailableViews();
	for(var i=0;i<arView.length;i++) {
		//each element in the array is in the form:
		//ViewID=CategoryID^View Name^Params^HasParams^CacheParams^Deployed^PackageID
		var n=arView[i].indexOf("=");
		if(n>0) {
			var sViewID=arView[i].substring(0,n);
			var s=arView[i].substring(n+1);
			var a=s.split("^");
			if(a.length>5) {
				if(a[5].equalsIgnoreCase("true")) {
					if(arDeployedPackage.indexOf(a[6])<0) {
						arDeployedPackage[arDeployedPackage.length]=a[6];
					};
				};
			}
			else {
				if(arDeployedPackage.indexOf(a[6])<0) {
					arDeployedPackage[arDeployedPackage.length]=a[6];
				};
			};
		};
	};

	var a2=new Array();
	for(var i=0;i<a1.length;i++) {
		n=a1[i].indexOf("=");
		if(n>0) {
			var sID=a1[i].substring(0,n);
			if(arDeployedPackage.indexOf(sID)>=0) a2[a2.length]=a1[i];
		};
	};

	return(a2);
};

/**************************************************************
Gets an array of available view categories.  The format of each
element in the array is:
	Category ID=PackageID^Category Name
**************************************************************/
function getAvailableViewCategories() {
	var e=document.getElementById("UICollection_ViewCategory");

	if(!e) {
		var arSpan=document.getElementById("UIAvailableViews").getElementsByTagName("SPAN");
		for(var i=0;i<arSpan.length;i++) {
			if(arSpan[i].id) {
				if(arSpan[i].id.startsWith("UIAvailableViewsProcessedBy_")) arSpan[i].id="UIAvailableViewsProcessedBy";
				if(arSpan[i].id.startsWith("UICollection_Package_")) arSpan[i].id="UICollection_Package";
				if(arSpan[i].id.startsWith("UICollection_ViewCategory_")) arSpan[i].id="UICollection_ViewCategory";
				if(arSpan[i].id.startsWith("UICollection_View_")) arSpan[i].id="UICollection_View";
			};
		};
		e=document.getElementById("UICollection_ViewCategory");
	};
	if(!e) return("");

	var a1=e.innerHTML.trim().split("|");

	//if not showing only deployed views, then done
	if(!getDeployedViewsOnlySelected()) return(a1);

	//otherwise, only include categories that have a deployed view
	//make an array of all package ID's for deployed views
	var arDeployedCategory=new Array();
	var arView=getAvailableViews();
	for(var i=0;i<arView.length;i++) {
		//each element in the array is in the form:
		//ViewID=CategoryID^View Name^Params^HasParams^CacheParams^Deployed^PackageID
		var n=arView[i].indexOf("=");
		if(n>0) {
			var sViewID=arView[i].substring(0,n);
			var s=arView[i].substring(n+1);
			var a=s.split("^");
			if(a.length>5) {
				if(a[5].equalsIgnoreCase("true")) {
					if(arDeployedCategory.indexOf(a[0])<0) {
						arDeployedCategory[arDeployedCategory.length]=a[0];
					};
				};
			}
			else {
				if(arDeployedCategory.indexOf(a[0])<0) {
					arDeployedCategory[arDeployedCategory.length]=a[0];
				};
			};
		};
	};

	var a2=new Array();
	for(var i=0;i<a1.length;i++) {
		n=a1[i].indexOf("=");
		if(n>0) {
			var sID=a1[i].substring(0,n);
			if(arDeployedCategory.indexOf(sID)>=0) a2[a2.length]=a1[i];
		};
	};

	return(a2);
};

/**************************************************************
Gets an array of available views.  The format of each
element in the array is:

	ViewID=CategoryID^View Name^Params^HasUserParams^Cache^Deployed

Params includes the document ID, widget, container item and
any fixed params.  If a target is defined in the fixed params
with a value of _self or _blank, the view will be opened in a 
new window with its own widget container.

HasUserParams is true or false indicating whether the view
contains parameters that need to be supplied by the user.
This is used to avoid updating the params when it is not necessary.

Cache is true or false indicating whether params for the view
can be cached and used again when the view is next selected.  If
not, params will be requested from Aspect each time the view is
selected.

Deployed is true if the view has been deployed for all users.
**************************************************************/
function getAvailableViews() {
	var e=document.getElementById("UICollection_View");

	if(!e) {
		var arSpan=document.getElementById("UIAvailableViews").getElementsByTagName("SPAN");
		for(var i=0;i<arSpan.length;i++) {
			if(arSpan[i].id) {
				if(arSpan[i].id.startsWith("UIAvailableViewsProcessedBy_")) arSpan[i].id="UIAvailableViewsProcessedBy";
				if(arSpan[i].id.startsWith("UICollection_Package_")) arSpan[i].id="UICollection_Package";
				if(arSpan[i].id.startsWith("UICollection_ViewCategory_")) arSpan[i].id="UICollection_ViewCategory";
				if(arSpan[i].id.startsWith("UICollection_View_")) arSpan[i].id="UICollection_View";
			};
		};
		e=document.getElementById("UICollection_View");
	};
	if(!e) return("");

	var a1=e.innerHTML.trim().split("|");

	//de-tokenize pipes
	for(var i=0;i<a1.length;i++) {
		if(a1[i].indexOf("[pipe]")>=0) a1[i]=replaceAllSubstrings(a1[i],"[pipe]","|");
	};

	//if not showing only deployed views, then done
	if(!getDeployedViewsOnlySelected()) return(a1);

	//otherwise, only include deployed views 
	var arDeployedView=new Array();
	for(var i=0;i<a1.length;i++) {
		//each element in the array is in the form:
		//ViewID=CategoryID^View Name^Params^HasParams^CacheParams^Deployed^PackageID
		var n=a1[i].indexOf("=");
		if(n>0) {
			var sViewID=a1[i].substring(0,n);
			var s=a1[i].substring(n+1);
			var a=s.split("^");
			if(a.length>5) {
				if(a[5].equalsIgnoreCase("true")) {
					if(arDeployedView.indexOf(sViewID)<0) {
						arDeployedView[arDeployedView.length]=sViewID;
					};
				};
			}
			else {
				if(arDeployedView.indexOf(sViewID)<0) {
					arDeployedView[arDeployedView.length]=sViewID;
				};
			};
		};
	};

	var a2=new Array();
	for(var i=0;i<a1.length;i++) {
		n=a1[i].indexOf("=");
		if(n>0) {
			var sID=a1[i].substring(0,n);
			if(arDeployedView.indexOf(sID)>=0) a2[a2.length]=a1[i];
		};
	};

	return(a2);
};

/************************************************************************
Gets the key used to record the current view parameters in a hashtable
The html used to present view params is cached so a call doesn't have
to be made to Aspect to get them every time a view is selected.
************************************************************************/
function getViewParamsHashKey() {
	//it is important that the computer be included in the key because params
	//will be different for each computer.

	//The user is also included to allow for the possibility that the parameters 
	//for a view may be affected by the user selected
	var s=getUserProfileID()+"_"+getComputerName()+"_"+getSelectedView();
	return(s)
};

/**************************************************************
Called when the Deployed Views Only checkbox changes
**************************************************************/
function UIDeployedViewsOnlyChanged() {
	var b=document.getElementById("UIDeployedViewsOnly").checked;
	showViewParameters(false);
	updateAvailableViews(true);
};

/**************************************************************
Called when a user profile is selected
**************************************************************/
function userProfileSelected() {
	var sUserProfileID=getUserProfileID();
	var sParams="UserProfileID="+sUserProfileID;

	//record the selected user as the default
	var sDefaultKey="DefaultUIUser";
	putDefault(sDefaultKey,sUserProfileID);

	//update the displayed user name
	document.getElementById("UISelectedUserText").innerHTML=getUserName();

	//get list of available packages, view categories and views from the selected computer
	updateAvailableViews();

	var sSelectedComputer=getSelectedComputer();
	showViewParameters(false);
};

/**************************************************************
Called when company selection changes
**************************************************************/
function userCompanySelected(Salt) {
	var sSelectedCompanyID=getSelectedCompany();

	//hide any parameters and the icon used to open a view
	showViewParameters(false);

	//get the default computer for the current user / company
	var sCookieName=getUserProfileID()+"_"+getSelectedCompany();
	var sDefaultComputer=getCookie(sCookieName);
	if(!sDefaultComputer) sDefaultComputer="";
	//appendToLog("Got default computer "+sCookieName+"="+sDefaultComputer);

	//update the computer list to include computers for the selected company
	var eComputerList=document.getElementById("UISelectUserComputer");
	eComputerList.options.length=0;
	eComputerList.options[eComputerList.options.length]=new Option("-- Select --","0",false,false);
	var arComputer=getAvailableComputers();
	for(var i=0;i<arComputer.length;i++) {
		//each element in the array is in the form HashID=CompanyID^Computer Name
		var a1=arComputer[i].split("=");
		if(a1.length>1) {
			var a2=a1[1].split("^");
			var sHashID=a1[0];
			var sCompanyID=a2[0];
			var sComputerName=a2[1];
			if(sCompanyID==sSelectedCompanyID) {
				eComputerList.options[eComputerList.options.length]=new Option(sComputerName,sHashID,false,(sHashID==sDefaultComputer));
			};
		};
	};

	//update views available from the selected computer
	userComputerSelected(Salt);
};

/**************************************************************
Called when computer selection changes
**************************************************************/
function userComputerSelected(Salt) {
	//update the displayed computer name
	var s=getComputerName();
	var n=s.indexOf("[");
	if(n>0) s=s.substring(0,n-1);
	document.getElementById("UISelectedComputerText").innerHTML=s;

	var sSelectedComputer=getSelectedComputer();
	
	//add to history
	addToUIComputerHistory(sSelectedComputer,getComputerName());

	//record the selected computer as the default for the current user / company
	var sCookieName=getUserProfileID()+"_"+getSelectedCompany();
	//setCookie(sCookieName,sSelectedComputer);
	//appendToLog("set default computer "+sCookieName+"="+sSelectedComputer);

	//get list of available packages, view categories and views from the selected computer
	updateAvailableViews();

	showViewParameters(false);
};

function addToUIComputerHistory(ComputerID,ComputerName) {
	var eHistory=document.getElementById("UISelectUserComputerHistory");
	if(eHistory) {
		bExists=false;
		for(var i=0;((!bExists) && (i<eHistory.options.length));i++) {
			if(eHistory.options[i].value==ComputerID) bExists=true;
		};

		if(!bExists) eHistory.add(new Option(ComputerName,ComputerID,false,false),0);
		eHistory.value=ComputerID;
	};
};

/**************************************************************
Called when a selection is made from the computer history 
**************************************************************/
function UserComputerHistorySelected()
{
	//get the history selection
	var sSelectedComputer=getSelectedComputerHistory();

	//get list of computers
	//each element in the array is in the form HashID=CompanyID^Computer Name
	var arComputer=getAvailableComputers();

	//get the company ID of the selected computer
	var sSelectedCompanyID="";
	for(var i=0;i<arComputer.length;i++) {
		var a1=arComputer[i].split("=");
		if(a1.length>1) {
			if(a1[0]==sSelectedComputer) {
				var a2=a1[1].split("^");
				sSelectedCompanyID=a2[0];
				break;
			};
		};
	};

	//set the selected company
	document.getElementById("UISelectUserCompany").value=sSelectedCompanyID;

	//update the computer list to include computers for the selected company
	var eComputerList=document.getElementById("UISelectUserComputer");
	eComputerList.options.length=0;
	eComputerList.options[eComputerList.options.length]=new Option("-- Select --","0",false,false);
	for(var i=0;i<arComputer.length;i++) {
		//each element in the array is in the form HashID=CompanyID^Computer Name
		var a1=arComputer[i].split("=");
		if(a1.length>1) {
			var a2=a1[1].split("^");
			var sHashID=a1[0];
			var sCompanyID=a2[0];
			var sComputerName=a2[1];
			if(sCompanyID==sSelectedCompanyID) {
				eComputerList.options[eComputerList.options.length]=new Option(sComputerName,sHashID,false,(sHashID==sSelectedComputer));
			};
		};
	};

	//set the selected computer
	document.getElementById("UISelectUserComputer").value=sSelectedComputer;

	userComputerSelected("");
};

/**************************************************************
Called when package selection changes
**************************************************************/
function packageSelected() {
	//hide any view parameters currently displayed
	showViewParameters(false);

	//get the selected package
	var sSelectedPackageID=getSelectedPackage();
	
	//record the selected package as the default
	var sDefaultKey="DefaultUIPackage_"+getUserProfileID();
	putDefault(sDefaultKey,sSelectedPackageID);

	//get the default category for the current user / package
	var sCookieName=getUserProfileID()+"_"+getSelectedPackage();
	var sDefaultCategory=getCookie(sCookieName);
	if(!sDefaultCategory) sDefaultCategory="";
	
	appendToLog("packageSelected() sSelectedPackageID=["+sSelectedPackageID+"]");

	//update the view categories to include categories for the selected package
	var eViewCategory=document.getElementById("UISelectViewCategory");
	eViewCategory.options.length=0;
	var arViewCategory=getAvailableViewCategories();
	for(var i=0;i<arViewCategory.length;i++) {
		//each element in the array is in the form:
		//CategoryID=PackageID^CategoryName
		var a1=arViewCategory[i].split("=");
		if(a1.length>1) {
			var a2=a1[1].split("^");
			var sCategoryID=a1[0];
			var sPackageID=a2[0];
			var sCategoryName=a2[1];
			if(sPackageID==sSelectedPackageID) {
				eViewCategory.options[eViewCategory.options.length]=new Option(sCategoryName,sCategoryID,false,(sCategoryID==sDefaultCategory) || (eViewCategory.options.length==0));
			};
		};
	};

	//set the list of views to those in the selected category
	viewCategorySelected();
};

/**************************************************************
Called when view category selection changes
**************************************************************/
function viewCategorySelected() {
	var sSelectedCategoryID=getSelectedCategory();

	//record the selected category as the default for the current / package
	var sCookieName=getUserProfileID()+"_"+getSelectedPackage();
	//setCookie(sCookieName,sSelectedCategoryID);
	putDefault("UIDefaultCategory_"+getUserProfileID()+"_"+getSelectedPackage(),sSelectedCategoryID);

	//get the default view for the current user / package / category
	sCookieName=getUserProfileID()+"_"+getSelectedPackage()+"_"+sSelectedCategoryID;
	var sDefaultView=getCookie(sCookieName);

	if(!sDefaultView) sDefaultView="";

	//update views to include those for the selected category
	var eView=document.getElementById("UISelectView");
	eView.options.length=0;
	eView.options[eView.options.length]=new Option("-- Select --","0",false,false);
	var arView=getAvailableViews();
	var bDefaultViewSelecetd=false;
	for(var i=0;i<arView.length;i++) {
		//each element in the array is in the form:
		//ViewID=CategoryID^View Name^Params^HasParams^CacheParams^Deployed
		var n=arView[i].indexOf("=");
		if(n>0) {
			var sViewID=arView[i].substring(0,n);
			var s=arView[i].substring(n+1);
			var a=s.split("^");
			var sCategoryID=a[0];
			var sViewName=a[1];
			if(sCategoryID==sSelectedCategoryID) {
				var b=(sViewID==sDefaultView);
				if(b) bDefaultViewSelecetd=true;
				eView.options[eView.options.length]=new Option(sViewName,sViewID,false,b);
			};
		};
	};

	//hide the view params container
	showViewParameters(false);

	//if a default view was selected, then show the parameters
	if(bDefaultViewSelecetd) viewSelected();
}

/**************************************************************
Called when a view is selected.  Updates the view params container 
to show params for the selected view.
**************************************************************/
function viewSelected() {
	enableUISelections(false);

	//This was used to show the name of the view in the top menu bar
	//it's not helpful
	//document.getElementById("UISelectedView").innerHTML=getViewName();

	var sViewID=getSelectedView();
	var eViewParamsContainer=document.getElementById("view_params_container");

	//hide the open view container
	showViewParameters(false);

	//record the selected view as the default for the current / package / category
	var sCookieName=getUserProfileID()+"_"+getSelectedPackage()+"_"+getSelectedCategory();
	//setCookie(sCookieName,sViewID);
	putDefault("UIDefaultCategory_"+getUserProfileID()+"_"+getSelectedPackage()+"_"+getSelectedCategory(),sViewID);

	if(sViewID=="0") {
		//hide the view params container
		showViewParameters(false);
		enableUISelections(true);
	}
	else {
		//see if any parameters are defined for the view
		var bHasInputParams=false;
		var bAllowCache=false;
		var arView=getAvailableViews();
		for(var i=0;i<arView.length;i++) {
			if(arView[i].startsWith(sViewID)) {
				var n=arView[i].indexOf("=");
				if(n>0) {
					var s=arView[i].substring(n+1);
					var a=s.split("^");
					if(a.length>3) bHasInputParams=a[3];
					if(a.length>4) bAllowCache=a[4];
					break;
				};
			};
		};

		//clear the view params container 
		eViewParamsContainer.innerHTML="";

		if(bHasInputParams=="true") {
			//see if params have already been retrieved
			if(bAllowCache=="true") {
				var HashKey=getViewParamsHashKey();
				var s=hashGet(HashKey);
				if(s) {
					//appendToLog("got params from hashtable");
					eViewParamsContainer.innerHTML=s;

					//set default values
					var arTagName=["input","select","textarea"];
					for(ntag=0;ntag<arTagName.length;ntag++) {
						var a=eViewParamsContainer.getElementsByTagName(arTagName[ntag]);
						//appendToLog("Found "+a.length+" "+arTagName[ntag]+" elements");
						for(var i=0;i<a.length;i++) {
							if(a[i].id) {
								//the ID used for the default is in the container surrounding the parameter
								var e=document.getElementById("Container"+a[i].id);
								if(e) {
									var sParamId=a[i].id;
									if(sParamId) {
										var s=hashGet(sParamId);
										if(s) {
											s=s.toString();
											if(!s.equalsIgnoreCase("undefined")) {
												if(a[i].type=="checkbox") {
													a[i].checked=(s=="true");
													//appendToLog("set "+a[i].id+"="+(s=="true"));
												}
												else {
													if((ntag==0) && (a[i].type.equalsIgnoreCase("date"))) {
														s=s.substring(6)+"-"+s.substring(0,2)+"-"+s.substring(3,5);
													};
													a[i].value=s;
													//console.log("set "+a[i].id+"="+s+" value="+a[i].value+" type="+a[i].type);
												};
											};
										};
									};
								};
							};
						};
					};

					viewParamsContainerUpdated();
					return;
				}
			};
			
			//Make a request to Aspect to get the view parameters
			//appendToLog("making http request for params");

			//set a status icon
			var divIcon=document.createElement("div");
			divIcon.style.marginTop="10px";
			showStatusIcon(divIcon);
			eViewParamsContainer.appendChild(divIcon);
			//var img=document.createElement("img");
			//img.src=imageStatusActive.src;
			//eViewParamsContainer.appendChild(img);
			setVisible("view_params_container",true);
	
			//get the HashID of the computer that will process the request
			sHashID=getSelectedComputer();
			if(sHashID.length==0) {
				alert("Cannot update view parameters because missing computer ID");
				return;
			};
	
			//set the url for the view params container and refresh the container to show 
			//params for the selected view
			var sUrl=eViewParamsContainer.getAttribute("_url")+sViewID;
			sUrl +="&Source="+sHashID;
			//appendToLog("Getting parameters.  Url="+sUrl);

			var sFunc="viewParamsContainerUpdated()";
			asynchInclude(eViewParamsContainer,sUrl,sFunc,sFunc);
		}
		else {
			//no params to display, so move along
			viewParamsContainerUpdated();
		};
	};
};

/**************************************************************
Makes a request to the selected computer for information regarding
available packages, view categories and views.
**************************************************************/
function updateAvailableViews(bUpdated)
{
	var sSelectedComputer=getSelectedComputer();
	if(sSelectedComputer=="0") return;

	//determine the div that selections will be saved to.  A separate div is used for each
	//computer so they can be cached
	var sCacheId="UIAvailableViews_"+sSelectedComputer+"_"+getUserProfileID();

	if(bUpdated) {
		//copy data from the cached div to the active one
		document.getElementById("UIAvailableViews").innerHTML=document.getElementById(sCacheId).innerHTML;

		//update the ID's inside the UIAvailableViews div.  ID's include the hash ID when data
		//is cached.
		var arSpan=document.getElementById("UIAvailableViews").getElementsByTagName("SPAN");
		for(var i=0;i<arSpan.length;i++) {
			if(arSpan[i].id) {
				if(arSpan[i].id.startsWith("UIAvailableViewsProcessedBy_")) arSpan[i].id="UIAvailableViewsProcessedBy";
				if(arSpan[i].id.startsWith("UICollection_Package_")) arSpan[i].id="UICollection_Package";
				if(arSpan[i].id.startsWith("UICollection_ViewCategory_")) arSpan[i].id="UICollection_ViewCategory";
				if(arSpan[i].id.startsWith("UICollection_View_")) arSpan[i].id="UICollection_View";
			};
		};

		//update the package list to include available packages
		var ePackage=document.getElementById("UISelectPackage");
		ePackage.options.length=0;
		var arPackage=getAvailablePackages();
		for(var i=0;i<arPackage.length;i++) {
			//each element in the array is in the form PackageID=PackageName
			var a=arPackage[i].split("=");
			var sPackageID=a[0];
			var sPackageName=a[1];
			ePackage.options[ePackage.options.length]=new Option(sPackageName,sPackageID,false,(ePackage.options.length==0));
		};
		
		//set the view category
		packageSelected();

		enableUISelections(true);
		return;
	};

	//clear current data from the hidden span taga
	if(document.getElementById("UICollection_Package")) {
		document.getElementById("UICollection_Package").innerHTML="";
	};

	if(document.getElementById("UICollection_ViewCategory")) {
		document.getElementById("UICollection_ViewCategory").innerHTML="";
	};

	if(document.getElementById("UICollection_View")) {
		document.getElementById("UICollection_View").innerHTML="";
	};

	if(sSelectedComputer!="0") {
		//if the div exists don't make the call again
		var eCache=document.getElementById(sCacheId);
		if((eCache) && (eCache.innerHTML.length>0) && (eCache.innerHTML.toUpperCase().indexOf("NOT AVAILABLE")<0)) {
			updateAvailableViews(true);
			return;
		};
		
		//create the cache div and add it to the body
		if(!eCache) {
			var eCache=document.createElement("div");
			eCache.id=sCacheId;
			eCache.style.display="none";
			document.body.appendChild(eCache);
		};

		enableUISelections(false);
		sUrl=getServer()+"/?Network=Greenlight&ID=getWidget";
		sUrl +="&DocumentID=K4Ui6j3Y1rwlvukPkOqn25Em&&Widget=User Interface Setup";
		sUrl +="&ContainerItemID=935691&getContent=true";
		sUrl +="&UserProfileID="+getUserProfileID();
		sUrl +="&Source="+getSelectedComputer();
		sUrl +="&IsSupport=true";
		var sFunc="updateAvailableViews(true)";
		asynchInclude(eCache,sUrl,sFunc,sFunc);
	};
};




var UIUserPopupVisible=false;
var UIComputerPopupVisible=false;
var UIViewPopupVisible=false;
var UISettingsPopupVisible=false;

/*****************************************************************
Hides all popup content.  Called when a popup is open and a click
occurs outside the popup to close the popup
*****************************************************************/
function hidePopups() {
	//alertStackTrace();

	if(!document.getElementById("UISelectedUser")) return;

	setVisible("UIUserPopup",false);
	setVisible("UIComputerPopup",false);
	setVisible("UIViewPopup",false);
	setVisible("UISettingsPopup",false);
	
	document.getElementById("UISelectedUser").className="MenuBarLeft";
	document.getElementById("UISelectedComputer").className="MenuBarMiddle";
	document.getElementById("UISelectedView").className="MenuBarMiddle";
	document.getElementById("UISettings").className="MenuBarRight";

	UIUserPopupVisible=false;
	UIComputerPopupVisible=false;
	UIViewPopupVisible=false;
	UISettingsPopupVisible=false;
};

function toggleUserPopup() {
	showPopup("User",!UIUserPopupVisible);
};

var bComputerPopupInitialized=false;
function toggleComputerPopup() {
	showPopup("Computer",!UIComputerPopupVisible);
	//initializeTabbedDialogs();
	if(!bComputerPopupInitialized) {
		setVisible("UIComputerSelectDiv",true);
		bComputerPopupInitialized=true;
	};
};

function toggleViewPopup() {
	//if the view popup has not been initialized yet, make sure that the params container
	//is initialized before creating the popup.  Otherwise, the params container will
	//not be initialized
/*
	if(!document.getElementById("UIViewPopup")) {
		if(bUpdatingViewParamsContainer) {
			//wait for params to laod
			setTimeout("toggleViewPopup()",1000);
			showDialog("icon=true&msg=Loading...");
			return;
		};
		showDialog();
	};
*/
	showPopup("View",!UIViewPopupVisible);

	//move parameter container back from site map if necessary
	restoreUIViewParamsContainer();
/*
	if(isVisible("UIViewPopup")) {
		var eUIParmsOuterContainer=document.getElementById("view_params_outer_container");
		if(eUIParmsOuterContainer.innerHTML.length==0) {
			var eAltUIParamsContainer=document.getElementById("AltUIParamsContainer");
			eUIParmsOuterContainer.innerHTML=eAltUIParamsContainer.innerHTML;
			eAltUIParamsContainer.innerHTML="";
			setVisible(eAltUIParamsContainer,false);
		};
	};
*/
};

function toggleSettingsPopup() {
	//refresh the div in the settings popup containing the server selection
	if(!!UISettingsPopupVisible) setInterval("UIServerSelection",0,true);
	showPopup("Settings",!UISettingsPopupVisible);
};

function getPopupWidth() {
	var eSelectedUser=document.getElementById("UISelectedUser");
	var xy=getPosition2012(eSelectedUser,"absolute",document.getElementsByTagName('BODY')[0]);
	var X=xy[0];

	var eSettings=document.getElementById("UISettings");
	xy=getPosition2012(eSettings,"absolute",document.getElementsByTagName('BODY')[0]);
	return((xy[0]+eSettings.offsetWidth)-X);
};

function showPopup(Name,show) 
{
	//get the div containing the popup content
	var ePopup=document.getElementById("UI"+Name+"Popup");

	//get the template used to create the popup
	var eTemplate=document.getElementById("UI"+Name+"PopupTemplate");

	if(!ePopup) {	
		//the popup div hasn't been created yet so create it and add it to the body
		ePopup=document.createElement("div");
		ePopup.id="UI"+Name+"Popup";
		ePopup.className="UIPopup";
		//ePopup.style.borderTop="none";
		ePopup.innerHTML=eTemplate.innerHTML;
		eTemplate.innerHTML="";
		document.body.appendChild(ePopup);
	}
	else {
		//the popup div already exists.  The innerHTML of the template should be 
		//empty since it is cleared when the popup is created from the template.
		//If it's not still empty, copy the content again from the template.  This
		//causes changes made to the template during development to be reflected
		//in the popup div
		if(eTemplate.innerHTML.length>0) {
			ePopup.innerHTML=eTemplate.innerHTML;
			eTemplate.innerHTML="";
		};
	};

	if(show) {
		//close other popups
		hidePopups();

		setVisible(ePopup,true);

		//position the div beneath the selected user
		var eSelectedUser=document.getElementById("UISelectedUser");
		var xy=getPosition2012(eSelectedUser,"absolute",document.getElementsByTagName('BODY')[0]);
		var X=xy[0];
		var Y=xy[1]+eSelectedUser.offsetHeight;
		ePopup.style.top=Y+"px";
		ePopup.style.left=X+"px";

		var eSettings=document.getElementById("UISettings");
		var xy2=getPosition2012(eSettings,"absolute",document.getElementsByTagName('BODY')[0]);
		ePopup.style.width=((xy2[0]+eSettings.offsetWidth)-X)+"px";
	}
	else {
		//just hide the popoup content
		if(ePopup) setVisible(ePopup,false);
	};

	if(Name=="User") {
		document.getElementById("UISelectedUser").className=(show) ? "MenuBarLeftSelected" : "MenuBarLeft";
		UIUserPopupVisible=show;
	};

	if(Name=="Computer") {
		document.getElementById("UISelectedComputer").className=(show) ? "MenuBarMiddleSelected" : "MenuBarMiddle";
		UIComputerPopupVisible=show;
	};

	if(Name=="View") {
		document.getElementById("UISelectedView").className=(show) ? "MenuBarMiddleSelected" : "MenuBarMiddle";
		UIViewPopupVisible=show;
	};

	if(Name=="Settings") {
		document.getElementById("UISettings").className=(show) ? "MenuBarRightSelected" : "MenuBarRight";
		UISettingsPopupVisible=show;
	};

};





/**************************************************************
Called when the asynchInclude function has completed updating the
view params container
**************************************************************/
function viewParamsContainerUpdated() 
{
	//record the params so they can be restored later without having to make a call
	//to the computer
	var eViewParamsContainer=document.getElementById("view_params_container");
	hashPut(getViewParamsHashKey(),eViewParamsContainer.innerHTML);

	//check that values for all parameters are valid and if so, show the
	//icon used to open the view
	enableUISelections(true);
	showViewParameters(true);
	evaluateParameters();
	positionItems();

	initializeCustomControls();

	//update subsequent parameters.  When updating the params container, it is necessary to
	//update all parameters individually, starting with the second.  The Aspect script that
	//prepares the parameters by creating the divs and url's for each one is not able to
	//pass the value of previous parameters to each subsequent parameter.  These values are
	//required to make parameters visible or not and to allow a parameter to be modified 
	//based on the values of previous parameters (e.g. filtering a collection based on
	//a previous parameter.  The values of parameters can be affected by the javascript
	//functions getValue() and formatValue() that are called for each parameter, so it is
	//not possible for Aspect to determine these values.  
	//	
	//This needs to be made more efficient.
	//
	var eFirstParam=getFirstParamContainer();
	if(eFirstParam) {
		viewParamModified(eFirstParam.id.substring(9));
	};
};

/**************************************************************
Shows or hides view parameters and the icon used to open a view
**************************************************************/
function showViewParameters(b) {
	setVisible("view_params_container",b);

	if(b) {
		var e=document.getElementById("open_view_container");
		if(e) e.style.display="inline";
	}
	else {
		setVisible("open_view_container",b);
	};
};

/**************************************************************
Enables or disables controls used to select computer and view
**************************************************************/
function enableUISelections(b) {
	document.getElementById("UIselect_user_profile").disabled=!b;
	document.getElementById("UISelectUserCompany").disabled=!b;
	document.getElementById("UISelectUserComputer").disabled=!b;
	if(document.getElementById("UISelectPackage")) {
		document.getElementById("UISelectPackage").disabled=!b;
		document.getElementById("UISelectViewCategory").disabled=!b;
		document.getElementById("UISelectView").disabled=!b;
	};
};

/**************************************************************
Gets the container surrounding the first parameter in the list
**************************************************************/
function getFirstParamContainer() {
	var eViewParamsContainer=document.getElementById("view_params_container");
	if(!eViewParamsContainer) return(null);
	arParam=eViewParamsContainer.getElementsByTagName("div");
	if(arParam) {
		for (var i=0;i<arParam.length;i++) {
			if(arParam[i].getAttribute("isfirstparam")) return(arParam[i]);
		};
	};
	return(null);
};

/**************************************************************
Gets the container surrounding the last parameter in the list
**************************************************************/
function getLastParamContainer() {
	var eViewParamsContainer=document.getElementById("view_params_container");
	arParam=eViewParamsContainer.getElementsByTagName("div");
	if(arParam) {
		for (var i=0;i<arParam.length;i++) {
			if(arParam[i].getAttribute("islastparam")) return(arParam[i]);
		};
	};
	return(null);
};

/**************************************************************
Gets the container surrounding the parameter following the given container
**************************************************************/
function getNextParamContainer(aParam) {
	var e=document.getElementById(aParam);
	if(!e) e=aParam;
	if(!e) return(null);

	var NextParamID=e.getAttribute("NextParamID");
	if(NextParamID.length>0) return(document.getElementById(NextParamID));
	return(null);
};

/**************************************************************
Returns the value of the input element in the given container.  The ID
of the input element is the same as the container surrounding it but
without the word "container" at the beginning.  The argument passed to
this function is ContainerXXXX or the element itself.
**************************************************************/
function getParamValue(aParam) {
	var e=document.getElementById(aParam);
	if(!e) e=aParam;
	if(!e) return(null);

	//the ID of the input element is the same as the container, but without 
	//the "container" at the beginning
	var sInputID=e.id.substring(9);
	var eInput=document.getElementById(sInputID);
	if(!eInput) {
		alert("Cannot locate element with ID="+sInputID+" in param: "+aParam);
		return;
	};

	//if the input param is the hidden random value, then return a random value.
	//This parameter is named "Hidden Random Value" and it is defined in the greenlight package
	//The purpose of this is to allow a 2nd instance of a view to be opened with the same parameters.
	//To use this, add the hidden parameter to the view's table of parameters
	//6/2021: It looks like the ID has changed to QwuIisG6.  Note: This is not the ID in the table 
	//of user interface params.  It was determined using the console command below.
	//console.log("sInputID="+sInputID);
	if((sInputID=="eXDGHwnn") || (sInputID=="QwuIisG6")) {
		var s=getSalt(4);
		//console.log("s="+s);
		return(s);
	};

	//if (eInput.type=='checkbox') return(e.checked);
	//return(eInput.value);

	var sValue="";
	if(eInput.nodeName=="DATALIST") {
		var sText=document.getElementById(sInputID+"_input").value;
		for(var i=0;i<eInput.options.length;i++) {
			//if(i<10) console.log("options["+i+"].value="+eInput.options[i].text);
			if(eInput.options[i].value.equalsIgnoreCase(sText)) {
				sValue=eInput.options[i].getAttribute("AspectID");
			};
		};
	}
	else {
		sValue=(eInput.type=='checkbox') ? eInput.checked : eInput.value;
	};

	//format the parameter value if a function is defined for it
	var sFuncName="formatParam"+sInputID;
	if(eval('typeof '+sFuncName)=="function") {
		sValue=eval(sFuncName+"('"+sValue+"')");
	}
	
	//appendToLog("getParamValue "+sInputID+":  "+sValue);
	return(sValue);
};

/**************************************************************
Returns the text value of the input element in the given container.  
Same as getParamValue, except that the text value of a select box
is returned instead of the value.
**************************************************************/
function getParamText(aParam) {
	var e=document.getElementById(aParam);
	if(!e) e=aParam;
	if(!e) return(null);

	var s=getParamValue(aParam);

	//get the text value if it's a select box.  
	var sInputID=e.id.substring(9); //remove the "container" prefix
	var eInput=document.getElementById(sInputID);
	if(eInput) {
		if (eInput.tagName.equalsIgnoreCase("select")) s=eInput.options[eInput.selectedIndex].text;
	};

	return(s);
};

/**************************************************************
gets string containing name and value of all parameters
**************************************************************/
function getViewParams() {
	var s="ViewID="+document.getElementById("UISelectView").value;
	var eParam=getFirstParamContainer();
	while(eParam) {
		s +="&" + eParam.getAttribute("ParamName")+"="+getParamValue(eParam);
		eParam=getNextParamContainer(eParam);
	};
	return(s);
};

/**************************************************************
gets additional parameters to be passed when opening a view including
the user profile ID, whether the support package is loaded and whether
the Deployed Views Only checkbox is enabled.
**************************************************************/
function getUIParams() {
	//add user profile ID, and parameters indicating whether it's a support computer
	//and whether deployed views only is selected
	var s="&UserProfileID="+document.getElementById("UIselect_user_profile").value;
	s +="&IsSupport=true";
	s +="&DeployedViewsOnly=";
	if(document.getElementById("UIDeployedViewsOnly")) {
		s +=document.getElementById("UIDeployedViewsOnly").checked;
	}
	else {
		s +="false";
	};
	return(s);
};

/**************************************************************
Records default values for all parameters when a view is opened.  Defaults are
also recorded when the parameters are modified.  This function is only used
because date inputs do not fire an onChange event when the calendar is used
to select a date.  If this was corrected, this function could be removed.
**************************************************************/
function recordDefaultParamValues() {
	var eParam=getFirstParamContainer();
	while(eParam) {
		var sParamDefID=eParam.getAttribute("paramdefid");
		var sID=replaceAllSubstrings(eParam.id,"Container","");
		putDefault(sParamDefID,getParamValue(eParam.id),eParam.getAttribute("ParamName"),sID);
    eParam=getNextParamContainer(eParam);
	};
};

function getSourceComputerName(HashID)
{
	var e=document.getElementById("UISelectUserComputer");
	for(var i=0;i<e.options.length;i++) {
		if(e.options[i].value==HashID) return(e.options[i].text);
	};
	return("");
};

function getViewSource() {
	//if a source is specified in the parameters, use it first
	var eParam=getFirstParamContainer();
	while(eParam) {
		if(eParam.getAttribute("IsSource")) return(getParamValue(eParam));
		eParam=getNextParamContainer(eParam);
	};

	//Otherwise use the selected computer as the source
	return(document.getElementById("UISelectUserComputer").value);
};

function getFullViewName() {
	var sTitle=getViewName();

	var eParam=getFirstParamContainer();
	while(eParam) {
		var s=eParam.getAttribute("IncludeInTitle");
		if(s) {
			var sValue=getParamText(eParam);

			if(s=="1") {
				sTitle +=": "+sValue;
			}
			else if(s=="2") {
				sTitle=sValue;
				//note: not aborting here makes it possible to override the default title
				//and then append additional values to the title
			};
		};
		eParam=getNextParamContainer(eParam);
	};

	return(sTitle);
};

/**************************************************************
Called when a parameter value is modified.  An onChange function must
be defined in the input element of the parameter definition.
**************************************************************/
function viewParamModified(ID) {
	var e=document.getElementById("Container"+ID);

	//record the new default value
	var sDefaultID=e.getAttribute("paramdefid");
	putDefault(sDefaultID,getParamValue("Container"+ID),e.getAttribute("ParamName"),ID);

	//update the subsequent parameters
	var sNextID=e.getAttribute("NextParamID");
	//appendToLog("viewParamModified: "+ID+" Next ID: "+sNextID);
	if(sNextID) {
		if(sNextID.length>0) updateViewParameter(sNextID);
	};
	evaluateParameters();
};

/**************************************************************
Updates the contents of a parameter container by setting the interval url
to the url specified for the parameter definition.  The names and values
of all other parameters are appended to the url so the contents can be
updated to reflect the selections made for other parameters.
**************************************************************/
function updateViewParameter(ID) {
	//get the span tag surrounding the parameter.  The ID is "Containerxxxx"
	var e=document.getElementById(ID);

	//see if the parameter is to be updated.  
	var sUpdate=e.getAttribute("Update");

	if(sUpdate.equalsIgnoreCase("true")) {
		//set the url to the base url and add any parameters that have been set
		//remove any parentheses and quotes that may be in the user agent
		var sUrl=e.getAttribute("_url")+"&"+getViewParams();
	
		//add the current value of the parameter 
		sUrl +="&CurrentParamValue="+getParamValue(ID);
		
		//disable any controls in the container
		var a=e.getElementsByTagName("input");
		if(a) for(var i=0;i<a.length;i++) a[i].disabled=true;
		a=e.getElementsByTagName("select");
		if(a) for(var i=0;i<a.length;i++) a[i].disabled=true;
		a=e.getElementsByTagName("checkbox");
		if(a) for(var i=0;i<a.length;i++) a[i].disabled=true;
	
		//update the content of the parameter
		var sFunc="viewParameterUpdated('"+ID+"')";
		asynchInclude(e,sUrl,sFunc,sFunc);
	};

	var sNextID=e.getAttribute("NextParamID");
	if(sNextID.length>0) updateViewParameter(sNextID);
};

function viewParameterUpdated(ID) {
	initializeCustomControls();
};

/**************************************************************
Tests validity of all parameter values. 	
**************************************************************/
function evaluateParameters() {
	//Move any scripts added with parameters to the head element.  These scripts
	//contain functions used to evaluate the validity of parameter inputs
	addScripts();
	
	//get values for all parameters.  The value of all parameters is passed when the
	//value of each individual parameter is evaluated.  
	var sAllParams=getViewParams();
	
	//evaluate each parameter
	var bAllOk=true;
	var s="";
	var eParam=getFirstParamContainer();
	while(eParam) {
		var sInputID=eParam.id.substring(9);
		var sFuncName="evalParam"+sInputID;
		var b=true;
		if(eval('typeof '+sFuncName)=="function") {
			var v=getParamValue(eParam);
			var b=eval(sFuncName+"(\""+v+"\",\""+sAllParams+"\")");
			bAllOk=bAllOk && b;
		}
		else {
		};
		eParam=getNextParamContainer(eParam);
	};

	//appendToLog("evaluateParameters result: "+bAllOk);
	if(bAllOk) {
		document.getElementById("open_view_container").style.display="inline";
	}
	else {
		setVisible("open_view_container",bAllOk);
	};
};



function dummy() {
};

function setOpenViewSelectionMethod() 
{
	var eContainer=document.getElementById("ViewOutputContainer");
	var eTable=document.getElementById("OutputTabs");
	var eSelect=document.getElementById("OutputSelect");

	//if number of views is <=1, don't need to show either method
	if(countOpenViews()<1) {
		setVisible(eSelect,false);
		setVisible("OutputSelectContainer",false);

		//hide the tabs
		setVisible(eTable,false);

		//Show the view title.  This is the title bars that appear just above the view
		showViewTitles(true);

		//hide the Close All button
		setVisible("UICloseAllViews",false);

		//hide the element used to close the selected view when the select box is visible
		setVisible("UICloseSelectedView",false);

		return;
	};

	//table must be visible to determine it's width.  Does not seem to cause screen flicker
	setVisible(eTable,true);
	
	ContainerWidth=eContainer.offsetWidth;
	TableWidth=eTable.rows[0].offsetWidth;

	//appendToLog("ContainerWidth="+ContainerWidth+" TableWidth="+TableWidth);
	if(TableWidth>ContainerWidth*0.75) {
		//use select box.  Don't use setVisible because the display needs to be inline, not block
		eSelect.style.display="inline";
		eSelect.display="inline";

		//show the div surrounding the select box
		setVisible("OutputSelectContainer",true);

		//hide the tabs
		setVisible(eTable,false);

		//hide all view titles.  These are the title bars that appear just above the view
		showViewTitles(false);

		//show the Close All button
		setVisible("UICloseAllViews",(countOpenViews()>0));

		//show the element used to close the selected view
		setVisible("UICloseSelectedView",(countOpenViews()>0));
	}
	else {
		//use tabs

		//hide the select box and the container surrounding it
		setVisible(eSelect,false);
		setVisible("OutputSelectContainer",false);

		//show the tabs
		setVisible(eTable,true);

		//hide all view titles
		showViewTitles(false);

		//show the Close All button
		setVisible("UICloseAllViews",(countOpenViews()>0));

		//show the element used to close the selected view
		setVisible("UICloseSelectedView",false);
	};
};

/***********************************************************************
Shows or hides title bars above each view
***********************************************************************/
function showViewTitles(b) {
	var eSelect=document.getElementById("OutputSelect");
	if(!eSelect) return;
	if(eSelect.options.length==0) return;

	for(var i=0;i<eSelect.options.length;i++) {
		var s=eSelect.options[i].value.substring(13); //remove the ViewContainer prefix
		setVisible("ViewTitleContainer1"+s,b);
	};
};

/***********************************************************************
Refreshes the currently selected view
***********************************************************************/
function refreshSelectedView()
{
	var eSelect=document.getElementById("OutputSelect");
	var s=eSelect.value.substring(13); //remove the ViewContainer prefix
	if(s.length>0) {
		hidePopups();
		refreshView(s);
	};
};

/***********************************************************************
Refreshes the content of a view
***********************************************************************/
function refreshView(ID,b) {
	if(b) {
		showDialog();
		viewUpdated(ID,true);
		return;
	}
	
	var e=document.getElementById("Div"+ID);

	//abort if the view is already being refreshed
	if(e.childNodes[0]) {
		if(e.childNodes[0].getAttribute) {
			var s=e.childNodes[0].getAttribute("Refreshing");
			if(s) {
				appendToLog("Already refreshing");
				return;
			};
		};
	};

	//record the starting time in the output div
	e.setAttribute("StartTime",new Date().getTime());

	//show a message in the output div while the content is loading
	var divMessage=document.createElement("div");
	divMessage.setAttribute("class","output_loading");
	divMessage.setAttribute("Refreshing","true");
	var eProgress=document.createElement("Progress");
	eProgress.style.width="250px";
	divMessage.appendChild(eProgress);
	e.insertBefore(divMessage,e.childNodes[0]); 

	var Url=e.getAttribute("url");
	sFunc="refreshView(\""+ID+"\",true)";
	asynchInclude(e,Url,sFunc,sFunc);
};

/***********************************************************************
print the content a view
***********************************************************************/
function printView(ID,sWrapper) {
	var eView=document.getElementById("Div"+ID);
	if(!eView) {
		alert("Cannot locate view with ID=Div"+ID);
		return;
	};

	//if the printer wrapper was retrieved, open the document in a new window
	if(sWrapper) {
		sWrapper +=eView.innerHTML;
		sWrapper +="</body></html>"

		//show message
		showDialog("icon=true&msg=Preparing report...");

		//apply overlay to disable view
		applyOverlay(eView,"overlay"+ID);
		
		var docprint=window.open("","","toolbar=yes,location=no,directories=yes,menubar=yes,scrollbars=yes,width=650, height=600, left=100, top=25"); 
		docprint.document.open(); 
		docprint.document.write(sWrapper); 

		//copy style elements
		var arStyle=document.getElementsByTagName("style");
		for(var i=0;i<arStyle.length;i++) {
			docprint.document.getElementsByTagName("head")[0].appendChild(arStyle[i].cloneNode(true));
		};

		var arTagNames=new Array("div","form","thead");
		for (var i=0;i<arTagNames.length;i++) {
			var arTag=docprint.document.getElementsByTagName(arTagNames[i]);
			var j=0;
			while (j<arTag.length) {
				var attr1=arTag[j].getAttribute("noprint");
				var attr2=arTag[j].getAttribute("print");
				if (((attr1) && (attr1.toString().equalsIgnoreCase("true"))) || ((attr2) && (attr2.toString().equalsIgnoreCase("false")))) {
					arTag[j].style.display="none";
					arTag[j].display="none";
					arTag[j].innerHTML="&nbsp;";
					arTag[j].parentNode.removeChild(arTag[j]); 
				}
				else {
					j++;
				};
			};
		};
		
		//hide all select boxes
		var arSelect=docprint.document.getElementsByTagName("select");
		for(var i=0;i<arSelect.length;i++) {
			//could modify this to determine if the select box is inside a table 
			arSelect[i].style.display="none";
			arSelect[i].display="none";
		};

		//hide all input boxes (this hides inputs on cash reconciliation)
/*
		var ar=docprint.document.getElementsByTagName("input");
		for(var i=0;i<ar.length;i++) {
			//could modify this to determine if the select box is inside a table 
			ar[i].style.display="none";
			ar[i].display="none";
		};
*/

		//hide all collapsed section headers
/*
		var arDiv=docprint.document.getElementsByClassName("sectionheader");
		if(arDiv) {
			for(var i=0;i<arDiv.length;i++) {
				var o=arDiv[i].getAttribute("selected");
				if((!o) || (o=="false")) {
					arDiv[i].style.display="none";
				};
			};
		};
*/
		//hide cells in tables used to select and edit records
		var arCells=docprint.document.getElementsByName("selectrecord");
		for(var i=0;i<arCells.length;i++) arCells[i].style.display="none";

		var arCells=docprint.document.getElementsByName("editrecord");
		for(var i=0;i<arCells.length;i++) arCells[i].style.display="none";
		
		var arCells=docprint.document.getElementsByName("inspectrecord");
		for(var i=0;i<arCells.length;i++) arCells[i].style.display="none";
		
		//remove script tags
		var arTag=docprint.document.getElementsByTagName("script");
		var n=0
		do {
			if((arTag[n].id) && (arTag[n].id.equalsIgnoreCase("JSPrint"))) {
				n++;
			}
			else {
				arTag[n].parentNode.removeChild(arTag[n]); 
			};
		} while(n<arTag.length);

		//hide message
		showDialog();

		//remove overlay
		var eOverlay=document.getElementById("overlay"+ID);
		eOverlay.parentNode.removeChild(eOverlay);
		
		docprint.document.close(); 
		docprint.focus(); 
		return;
	}
	
	//get the printer wrapper
	var sUrl="__RequestServer__/?Network=GreenLight&ID=getCachedWidget&DocumentID=77NaWu0FhKDKXL7C70JpnKmy&Widget=Printer Wrapper";
	var sFunc="printView('"+ID+"',s)";
	asynchInclude(null,sUrl,sFunc,sFunc);
};

/***********************************************************************
email the content a view
***********************************************************************/
function emailView(ID,b) {
	showDialog("&msg=Not implemented<br><br>&fnOk=close");
};

/***********************************************************************
Updates the view selection mirror located in the view popup so it matches
the select element used to maintain a list of open views
***********************************************************************/
function updateViewSelectionMirror() {
	var eOutputSelect=document.getElementById("OutputSelect");
	var eOutputSelectMirror=document.getElementById("UIOutputSelectMirror");

	eOutputSelectMirror.options.length=0;
	for(var i=0;i<eOutputSelect.length;i++) {
		eOutputSelectMirror.options[eOutputSelectMirror.options.length]=new Option(eOutputSelect.options[i].text,eOutputSelect.options[i].value);
	};
	eOutputSelectMirror.value=eOutputSelect.value;
};

/***********************************************************************
Called when a view is selected from the select mirror in the views
popup.  Sets the selected view in the OutputSelect select element as
if the view was selected there andcalls showUITab
***********************************************************************/
function selectionMirrorChanged(e)
{
	var eOutputSelect=document.getElementById("OutputSelect");
	eOutputSelect.value=e.value;
	showUITab(eOutputSelect);
	return(true);
};

/***********************************************************************
Called when a view is selected from the select box.  Rather than calling
showTab from the select box, a click on the table tab is simulated so
the select box and table stay in synch
***********************************************************************/
function showUITab(e,ID) {
	if(e.nodeName.equalsIgnoreCase("span")) {
		//a tab was clicked.  Show the tab and update the select box
		showTab(e,ID);
	
		document.getElementById("OutputSelect").value=ID;	

		//update the view selection mirror
		updateViewSelectionMirror();

//		var select=document.getElementById("OutputSelect").select;
//		for(var i=0;i<select.options.length;i++) {
//			if(select.options[i].value==ID) select.value=ID;
//		};
		return;
	};

	//get the ID.  Have to remove "ViewContainer" from the start of the ID
	var sID=replaceAllSubstrings(e.value,"ViewContainer","");

	//update the view selection mirror
	updateViewSelectionMirror();

	//locate the corresponding td in the table
	var table=document.getElementById("OutputTabs");
	for (var i=0;i<table.rows[0].cells.length;i++) {
		var sCellID=table.rows[0].cells[i].getAttribute("ID");
		if(sCellID.equalsIgnoreCase("Cell"+sID)) {
			//var sName=table.rows[0].cells[i].childNodes[0].innerHTML;
			var sName="ViewContainer"+sID;
			showTab(table.rows[0].cells[i].childNodes[0],sName);
		};
	};
};

function countOpenViews() {
	var eSelect=document.getElementById("OutputSelect");
	if(!eSelect) return(0);
	return(eSelect.options.length);
};

/***********************************************************************
Gets the ID of the leftmost view
The ID passed to this function does not include the ViewContainer prefix
***********************************************************************/
function getLeftmostView() {
	var eSelect=document.getElementById("OutputSelect");
	if(eSelect.options.length==0) return("");
	var s=eSelect.options[0].value.substring(13); //remove the ViewContainer prefix
	return(s);
};

/***********************************************************************
Gets the view with the ID prior the given ID
The ID passed to this function does not include the ViewContainer prefix
***********************************************************************/
function getViewToLeftOf(ViewID)
{
	var sToLeftID="";
	var eSelect=document.getElementById("OutputSelect");
	for(var i=0;i<eSelect.options.length;i++) {
		var s=eSelect.options[i].value.substring(13); //remove the ViewContainer prefix
		if(s==ViewID) return(sToLeftID);
		sToLeftID=s;
	};
	
	//an error has occurred because the current view wasn't found
	return("");
};

/***********************************************************************
Closes all open views
***********************************************************************/
function closeAllViews()
{
	hidePopups();

	var eSelect=document.getElementById("OutputSelect");
	var arToDelete=new Array();
	for(var i=0;i<eSelect.options.length;i++) {
		arToDelete[arToDelete.length]=eSelect.options[i].value.substring(13); //remove the ViewContainer prefix
	};

	for(var i=0;i<arToDelete.length;i++) {
		deleteView(arToDelete[i]);
	};
};

/***********************************************************************
Closes all but the current view
***********************************************************************/
function closeOtherViews()
{
	hidePopups();

	var eSelect=document.getElementById("OutputSelect");
	var arToDelete=new Array();
	for(var i=0;i<eSelect.options.length;i++) {
		if(eSelect.options[i].value!=eSelect.value) {
			arToDelete[arToDelete.length]=eSelect.options[i].value.substring(13); //remove the ViewContainer prefix
		};
	};

	for(var i=0;i<arToDelete.length;i++) {
		deleteView(arToDelete[i]);
	};
};

/***********************************************************************
Deletes the currently selected view
***********************************************************************/
function closeSelectedView()
{
	var eSelect=document.getElementById("OutputSelect");
	var s=eSelect.value.substring(13); //remove the ViewContainer prefix
	if(s.length>0) {
		hidePopups();
		deleteView(s);
	};
};

/***********************************************************************
Deletes the output div with the given ID and removes the tab from the list of available tabs.
The ID passed to this function does not include the ViewContainer prefix
***********************************************************************/
function deleteView(sID)
{
	//get the view to the left of the one being deleted.  It will be selected.
	var sViewToLeftID=	getViewToLeftOf(sID);
	appendToLog("deleteView Left="+sViewToLeftID);

	var d=document.getElementById("ViewContainer"+sID);
	if(d) d.parentNode.removeChild(d);

	//delete the tab from the table
	var table=document.getElementById("OutputTabs");
	for (var i=0;i<table.rows[0].cells.length;i++) {
		var s=table.rows[0].cells[i].getAttribute("ID");
		if(s.equalsIgnoreCase("Cell"+sID)) table.rows[0].deleteCell(i);
	};

	//delete the option from the select box
	var select=document.getElementById("OutputSelect");
	for(var i=0;i<select.options.length;i++) {
		if(select.options[i].value=="ViewContainer"+sID) {
			select.remove(i);
		};
	};

	//update the view selection mirror
	updateViewSelectionMirror();

	if(countOpenViews()==0) {
		setVisible("UICloseAllViews",false);

		//hide the select box used to select a view
		setVisible("OutputSelect",false);
	}
	else {
		if(sViewToLeftID.length>0) {
			//set focus on the view to the left of the one being closed
			select.value="ViewContainer"+sViewToLeftID;
			showUITab(select);
		}
		else {
			//set focus on the first view
			var sFirstView=getLeftmostView();
			if(sFirstView.length>0) {
				select.value="ViewContainer"+sFirstView;
				showUITab(select);
			};
		};

		setOpenViewSelectionMethod();
	};
};

/***********************************************************************
Called when a view has been loaded
***********************************************************************/
function viewUpdated(sID,bIsRefresh) 
{
	var eView=document.getElementById("Div"+sID);
	//if(!eView) alert("Cannot locate: "+"Div"+sID);
	if(!eView) return;

	//get the start time and calculate the elapsed time required to process the widget
	var iStartTime=parseInt(eView.getAttribute("StartTime"));
	var iElapsed=new Date().getTime()-iStartTime;

	var eTitle=document.getElementById("ViewTitleContainer2"+sID);
	//eTitle.innerHTML="["+iElapsed+"ms]";
	var eElapsedTime=document.getElementById("ElapsedTime"+sID);
	eElapsedTime.innerHTML="["+iElapsed+"ms]";

	//add an icon used to refresh the contents of the div
	//and an icon used to close the div
	if(!bIsRefresh) {
		/*	The refresh and close icons are no longer included in the title
				They are still functional if this code is enabled
		*/
		if(false) {
			var divClose=document.createElement("div");
			divClose.className="view_close";
			divClose.innerHTML="&nbsp;";
			var sOnClick="deleteView('"+sID+"');";
			divClose.setAttribute("onclick",sOnClick);	//this works for firefox
			divClose.onclick=Function(sOnClick);		//this works for IE
			eTitle.appendChild(divClose);
	
			var divRefresh=document.createElement("div");
			divRefresh.className="view_refresh";
			divRefresh.innerHTML="&nbsp;";
			var sOnClick="refreshView('"+sID+"');";
			divRefresh.setAttribute("onclick",sOnClick);	//this works for firefox
			divRefresh.onclick=Function(sOnClick);		//this works for IE
			eTitle.appendChild(divRefresh);
		};
	};

	initializeTables2012();

	//initialize any tabs in the content
	initializeTabbedDialogs();

	//record elapsed time in google analytics
	var sViewName=document.getElementById("SourceName"+sID).innerHTML;
	gaevt("View","ViewUpdate",sViewName,iElapsed);

	return;
};

function getFixedViewParams(ViewID) {
	var arView=getAvailableViews();
	for(var i=0;i<arView.length;i++) {
		//Elements in the array are in the form: ViewID=CategoryID^View Name^Params
		var n=arView[i].indexOf("=");
		if(n>0) {
			var s1=arView[i].substring(0,n);
			var s2=arView[i].substring(n+1);
			if(s1==ViewID) {
				var a=s2.split("^");
				var s=replaceAllSubstrings(a[2],"&amp;","&");
				return(s);
			};
		};
	};
	return("");
};

/***********************************************************************
Opens a new view
***********************************************************************/
function openView(Salt) {
	var sViewName=getViewName();

	var sID=getSalt(6);
	
	//hide any open pop-ups
	hidePopups();

	//hide the alternate parameter container
	setVisible("AltUIParamsContainer",false);

	restoreUIViewParamsContainer();

	//show the close-all element.  Don't use setVisible because it needs to be inline
	//This element may not be used any more
	var eCloseAll=document.getElementById("UICloseAllViews");
	if(eCloseAll) {
		document.getElementById("UICloseAllViews").style.display="inline";
		document.getElementById("UICloseAllViews").display="inline";
	};

	//get the ID of the selected view
	var sViewID=getSelectedView();

	//record default parameter values.  Defaults are also recorded when the onChange event
	//fires for a parameter.  However, the onChange even is not fired when a calender is used 
	//to select a date.  This is a fix to address that.
	recordDefaultParamValues();

	//get fixed params for view.  Fixed params are only used if the view will be opened
	//in a new browser window, either as a view or as an external url.  Otherwise, they
	//are not appended to the additional params because the getWidgetbyProxy() funciton
	//will add them when the getWidget() request is processed.  If they were added here,
	//they would be added twice.
	var sFixedParams=getFixedViewParams(sViewID);

	//if no document or widget are defined, remove them from the string.  This is necessary
	//for external url's to open properly
	sFixedParams=replaceAllSubstrings(sFixedParams,"DocumentID=0&Widget=0&ContainerItemID=&","");

	if(sFixedParams.length>0) {
		//remove any cr/lf characters.  These are allowed in the dialog used to edit the view
		sFixedParams=replaceAllSubstrings(sFixedParams,"\n","")
		sFixedParams=replaceAllSubstrings(sFixedParams,"\r","")

		//remove leading & character
		if(sFixedParams.charAt(0)=="&") sFixedParams=sFixedParams.substring(1);
	};

	//get additional params
	var sViewParams=getViewParams();
	if(sViewParams.length>0) sViewParams+="&";

	//if the url includes a target (_blank, _self) then open the url as a new page and
	//not as a tab in the current page
	var sTarget=getElementValue(sFixedParams,"target","&");
	var sTargetUpper=sTarget.toUpperCase();
	if((sTargetUpper.indexOf("_BLANK")>=0) || (sTargetUpper.indexOf("_SELF")>=0)) {
		var sUrl="";
		if((sFixedParams.toUpperCase().startsWith("HTTP")) || (sFixedParams.toUpperCase().startsWith("HTTPS")) || (sFixedParams.toUpperCase().startsWith("FTP"))) {
			sUrl=sFixedParams;
		}
		else {
			sUrl=getServer()+"/?Network=Greenlight&ID=getWidget&"+sFixedParams;
		};

		//remove the target from the url
		sUrl=replaceAllSubstrings(sUrl,"target=_blank","");
		sUrl=replaceAllSubstrings(sUrl,"target=_self","");
		if(sUrl.endsWith("&")) sUrl=sUrl.substring(0,sUrl.length-1);

		//add any user-input params.  Don't add ViewID
		var a=getSubStringArray(sViewParams,"&",false);
		for(var i=0;i<a.length;i++) {
			if((a[i].length>0) && (!(a[i].toUpperCase().startsWith("VIEWID")))) {
				if(!sUrl.endsWith("?")) sUrl +="&";
				sUrl +=a[i];
			};
		};
		
		window.open(sUrl,sTarget);
		return;
	};

	sViewParams +=getUIParams();

	/*************************************************************************
	03-14-2016
	Note: Don't add fixed params to view params.  getWidgetByProxy() gets the fixed params
	from the Greenlight_UI_View driver.  This means that view must be defined on the
	computer that the request is being made to.

	It should also be possible to pass the fixed params.  However, there is a problem 
	with special characters (> in particular) that occurs when including the fixed params
	here.  Also, the view must exist on the source computer anyway because getWidgetByProxy 
	relies on this to determine the document ID, widget and container item.
	*************************************************************************/
	//add the fixed params to the user-input params
	//if(sFixedParams.length>0) sViewParams +="&"+sFixedParams;

	//set the url that will be opened in a new tab
	var sUrl=getServer()+"/?Network=Greenlight&ID=getWidget&" + sViewParams; 

	//pass user-input parameters to the dimensional driver 
	var sDimDriverParams=replaceAllSubstrings(sViewParams,"&","^");
	sUrl +="&DimDriverParams="+sDimDriverParams;

	//get the source computer
	var sSource=getViewSource();
	var sSourceName=getSourceComputerName(sSource);

	//NOTE: To keep compatibility with widgets in the control panel, a CustomerID field
	//is added to the URL.  The source parameter is set to the selected computer unless
	//a source is defined in the parameters to override it.  The CustomerID field will
	//always be the selected computer.  This allows a widget to be processed by a 
	//specific source (e.g. the local computer) while also passing the hash ID of the
	//selected computer.
	if((sUrl.toUpperCase().indexOf("SOURCE=")<0) && (("&"+sFixedParams.toUpperCase()).indexOf("&SOURCE=")<0)) {
		sUrl +="&Source="+getViewSource();
		sUrl +="&CustomerID="+getSelectedComputer();
	};

	//see if a tab has already been opened.  If so, focus it instead of opening a duplicate.
	//This is important because when a cached view is returned, the IDs used will be the same
	//as when the document was originally created, even when salt is used.  If a second instance
	//of the same cached document is opened, there will be two views sharing the same ID's.
	var arOpenViews=document.getElementsByClassName("ViewContent");
	for(var i=0;i<arOpenViews.length;i++) {
		var s=arOpenViews[i].getAttribute("url");
		if(s) {
			if(s.equalsIgnoreCase(sUrl)) {
				sSalt=arOpenViews[i].id.substring(3);
				hidePopups();
				var eTab=document.getElementById("span"+sSalt);
				showUITab(eTab,"ViewContainer"+sSalt);
				return;
			};
		};
	};

	//get the title for the view.  The computer name is added if it is not the local computer
	//var sViewTitle=sViewName;
	var sViewTitle=getFullViewName();

	if(getSelectedComputer()!="v8k3ey5q1") {
		var sComputerName=getComputerName();
		n=sComputerName.indexOf("[");
		if(n>1) sComputerName=sComputerName.substring(0,n-1);
		sViewTitle +=" - "+sComputerName;
	};

	//create a new output tab to contain the output
	var eViewContentContainer=document.createElement("div");
	eViewContentContainer.id="ViewContainer"+sID;
	eViewContentContainer.className="ViewContainer";
	document.getElementById("OutputDivs").appendChild(eViewContentContainer);

	//create a div to contain the header for the output
	var divTitle1=document.createElement("div");
	divTitle1.setAttribute("class","view_title1");
	divTitle1.id="ViewTitleContainer1"+sID;
	var divTitle2=document.createElement("div");
	divTitle2.setAttribute("class","view_title2");
	divTitle2.id="ViewTitleContainer2"+sID;
	divTitle1.appendChild(divTitle2);
	eViewContentContainer.appendChild(divTitle1);

	//add the name of the view to the title div
	eSourceName=document.createElement("div");
	eSourceName.id="SourceName"+sID;
	eSourceName.className="view_source_name";
	eSourceName.innerHTML=sViewTitle;
	divTitle2.appendChild(eSourceName);

	//add a span to the title div that will contain the elapsed time
	eElapsedTime=document.createElement("div");
	eElapsedTime.id="ElapsedTime"+sID;
	eElapsedTime.className="view_elapsed_time";
	divTitle2.appendChild(eElapsedTime);

	//add view controls to the view container
	var eViewControls=document.createElement("span");
	eViewControls.setAttribute("class","view_controls");

	var eSpan=document.createElement("span");
	eViewControls.appendChild(eSpan);

	//view control - print icon
	var eSpan=document.createElement("span");
	eSpan.setAttribute("class","view_control_print_icon");
	var sOnClick="printView('"+sID+"');";
	eSpan.setAttribute("onclick",sOnClick);
	eSpan.onclick=Function(sOnClick);  
	eViewControls.appendChild(eSpan);

	//view control - refresh icon
	eSpan=document.createElement("span");
	eSpan.setAttribute("class","view_control_refresh_icon");
	var sOnClick="refreshView('"+sID+"');";
	eSpan.setAttribute("onclick",sOnClick);
	eSpan.onclick=Function(sOnClick);  
	eViewControls.appendChild(eSpan);

	//view control - close icon
	var eSpan=document.createElement("span");
	eSpan.setAttribute("class","view_control_close_icon");
	var sOnClick="deleteView('"+sID+"');";
	eSpan.setAttribute("onclick",sOnClick);      
	eSpan.onclick=Function(sOnClick);  
	eViewControls.appendChild(eSpan);

	//view control - email icon
	if(false) {
		eSpan=document.createElement("span");
		eSpan.setAttribute("class","view_control_email_icon");
		var sOnClick="emailView('"+sID+"');";
		eSpan.setAttribute("onclick",sOnClick);
		eSpan.onclick=Function(sOnClick);  
		eViewControls.appendChild(eSpan);
	};

	eViewContentContainer.appendChild(eViewControls);

	//create the div that will contain the view content
	var div=document.createElement("div");
	div.setAttribute("ID","Div"+sID);
	div.id="Div"+sID;
	div.className="ViewContent";
	eViewContentContainer.appendChild(div);

	//show a message in the output div while the content is loading
	var divMessage=document.createElement("div");
	divMessage.setAttribute("class","output_loading");
	var eProgress=document.createElement("Progress");
	eProgress.style.width="250px";
	divMessage.appendChild(eProgress);
	//divMessage.innerHTML="Loading...";
	div.appendChild(divMessage);

	//add the new div to the table containing the list of tabs
	var text=document.createTextNode(sViewTitle);
	var span=document.createElement("span");
	span.id="span"+sID;
	span.className="tabdialogtabselected";
	var sOnClick="hidePopups();showUITab(this,'ViewContainer"+sID+"');";
	span.setAttribute("onclick",sOnClick);      //this works for firefox
	span.onclick=Function(sOnClick);            //this works for IE
	span.appendChild(text);

	//add an icon used to close the tab
	//the icon is contained in the background of the span
/*
	var eCloseIcon=document.createElement("div");
	eCloseIcon.setAttribute("Class","ViewTabCloseIcon");
	eCloseIcon.id="closetab"+sID;
	var sOnClick="deleteView('"+sID+"');";
	eCloseIcon.setAttribute("onclick",sOnClick);      //this works for firefox
	eCloseIcon.onclick=Function(sOnClick);            //this works for IE
	span.appendChild(eCloseIcon);
*/
	
/*
	var img=document.createElement("img");
	img.src=getServer()+"/?Network=Greenlight&ID=getImage&Filename={packageuril_greenlight}doc/images/greyX8x8.png";
	img.setAttribute("Class","view_tab");
	img.id="closetab"+sID;
	var sOnClick="deleteView('"+sID+"');";
	img.setAttribute("onclick",sOnClick);      //this works for firefox
	img.onclick=Function(sOnClick);            //this works for IE
	span.appendChild(img);
*/

	//programmatically add the tab to the table containing the dialog tabs
	var table=document.getElementById("OutputTabs");
	var cell=table.rows[0].insertCell(-1);
	cell.setAttribute("ID","Cell"+sID);
	cell.id="Cell"+sID;
	cell.setAttribute("Class","view_tab");
	cell.appendChild(span);
	//cell.appendChild(img);

	//add the div to the select box   The select box is set to visible, but a media query
	//manages the container surrounding the select box which means it may still not be
	//visible depending on the screen size.  
	var select=document.getElementById("OutputSelect");
	select.add(new Option(sViewTitle,"ViewContainer"+sID,false,true));
	setVisible(select,true);
	//select.options[select.options.length]=new Option(sViewTitle,"ViewContainer"+sID,false,true);

	//update the view selection mirror
	updateViewSelectionMirror();

	setOpenViewSelectionMethod();

	//record the starting time in the output div
	div.setAttribute("StartTime",new Date().getTime());

	//show the output div
	showTab(span,"ViewContainer"+sID);

	//if(sSource.length>0) sUrl +="&Source="+sSource+"&CustomerID="+sSource;
	//appendToLog("openView url="+sUrl);
	div.setAttribute("url",sUrl);
	//setInterval(div,0,true);
	
	var sFunc="viewUpdated(\""+sID+"\",false)";
	//alert("URL: "+sUrl);
	asynchInclude(div,sUrl,sFunc,sFunc);

	//google analytics event
	//note: this is called by the viewUpdated function when the view has been loaded
	//gaevt("View","Open",sViewName,0);
};

function hideInspectMenu(TDID,TableID) {
	//get the inspect menu
	var InspectMenuID="InspectMenu"+TableID;
	var eInspectMenuDiv=document.getElementById(InspectMenuID);

	//restore the table cell's bottom border
	if(eInspectMenuDiv.getAttribute("RestoreBorderWidth")) {
		var td=document.getElementById(TDID);
		td.style.borderBottomWidth=eInspectMenuDiv.getAttribute("RestoreBorderWidth");
	};

	setVisible(eInspectMenuDiv,false);
};

/*********************************************************
Called when the inspect menu icon is clicked.  TDID is the
ID of the TD containing the inspect icon that was clicked.
This value is set in the tdid attribute of the inspect
menu when it is displayed.  When an inspect menu item is
selected, the url can quickly be gotten from the td tag
where it is stored as an attribute.
*********************************************************/
function showInspectMenu(TDID,TableID)
{
	//get the inspect menu
	var InspectMenuID="InspectMenu"+TableID;
	var eInspectMenuDiv=document.getElementById(InspectMenuID);

	//if the inspect menu is already displayed for the selected record, just hide it
	if((isVisible(eInspectMenuDiv)) && (eInspectMenuDiv.getAttribute("TDID")==TDID)){
		hideInspectMenu(TDID,TableID);
		return;
	};

	//record the ID of the TD that was clicked to open the inspect menu.  This is used
	//to get the params when a menu item is selected
	eInspectMenuDiv.setAttribute("TDID",TDID);

	//set the menu item descriptions using the attributes in the TD that was clicked
	var td=document.getElementById(TDID);
	var ul=document.getElementById("InspectUL"+TableID);
	var arLI=ul.getElementsByTagName("LI");
	for(var i=0;i<arLI.length;i++) {
		var MenuItemID=arLI[i].id;
		var sDescription=td.getAttribute("inspectdescription"+MenuItemID);

		var Enabled=td.getAttribute("InspectEnabled"+MenuItemID);
		if(Enabled=="true") {
			arLI[i].setAttribute("class","inspect_menu_li");
		}
		else {
			arLI[i].setAttribute("class","inspect_menu_li_disabled");
		};

		if(sDescription) {		
			arLI[i].innerHTML=sDescription;
			arLI[i].style.display="block";
		}
		else {
			arLI[i].style.display="none";
		};
	};

	var eTable=document.getElementById("div"+TableID);

	//This was an attempt to clear the bottom border of the td and the top border
	//of the menu so they appear as a single item.  However, the border around the
	//tr gets in the way.  
	if(false) {
		//set the border of the inspect menu to match the border of the table cell
		var BorderBottomWidth=window.getComputedStyle(td,null).getPropertyValue("border-bottom-width");
		var BorderBottomColor=window.getComputedStyle(td,null).getPropertyValue("border-top-color");

		//save the border attributes of the table cell in the inspect menu
		eInspectMenuDiv.setAttribute("RestoreBorderWidth",BorderBottomWidth);
		eInspectMenuDiv.setAttribute("RestoreBorderColor",BorderBottomColor);

		//clear the bottom border of the table cell
		td.style.borderBottomWidth="0px";

		if(BorderBottomWidth!="0px") {
			eInspectMenuDiv.style.borderWidth=BorderBottomWidth;
			eInspectMenuDiv.style.borderColor=BorderBottomColor;
			eInspectMenuDiv.style.borderTopWidth="0px";
		};
	};

	//set the color and border width of the inspect menu to match the td
	var BorderBottomWidth=window.getComputedStyle(td,null).getPropertyValue("border-bottom-width");
	if(BorderBottomWidth!="0px") {
		var BorderBottomColor=window.getComputedStyle(td,null).getPropertyValue("border-top-color");
		eInspectMenuDiv.style.borderColor=BorderBottomColor;
		eInspectMenuDiv.style.borderWidth=BorderBottomWidth;
	};

	//make the top border of the inspect menu thicker
	eInspectMenuDiv.style.borderTopWidth="10px";

	var tddiv=td.getElementsByTagName("DIV")[0];
	var xy=getPosition2012(tddiv,"absolute",eTable);
	var Top=xy[1]+tddiv.offsetHeight;
	var Left=xy[0];
	eInspectMenuDiv.style.top=Top+"px";
	eInspectMenuDiv.style.left=Left+"px";
	setVisible(InspectMenuID,true);
};

function inspectMenuItemSelected(TableID,MenuItemID)
{
	var InspectMenuID="InspectMenu"+TableID;
	var eInspectMenuDiv=document.getElementById(InspectMenuID);
	var TDID=eInspectMenuDiv.getAttribute("TDID");
	var TD=document.getElementById(TDID);
	var sParams="";
	var sViewName="";

	hideInspectMenu(TDID,TableID);

	if(TD) {
		sParams=TD.getAttribute("inspectparams"+MenuItemID);
		sViewName=TD.getAttribute("inspecttitle"+MenuItemID);
	}
	else {
		alert("Cannot locate TD for selected menu item");
	};

	//execute a javascript function if the params begin with JS:
	if(sParams.toUpperCase().startsWith("JS:")) {
		setTimeout(sParams.substring(3),0);
		return;
	};

	if((sParams) && (sParams.length>0)) {
		//add the source to the params if a source is not explicitly defined in the
		//params for the inspect menu item
		if(("&"+sParams).toUpperCase().indexOf("&SOURCE=")<0) {
			var sHashID=eInspectMenuDiv.getAttribute("source");
			sParams +="&Source="+sHashID;
		};
	};

	appendToLog("Inspect Table: "+TableID);
	appendToLog("Inspect MenuItem: "+MenuItemID);
	appendToLog("Inspect TDID: "+TDID);
	appendToLog("Inspect Params: "+sParams);
	openInspectWindow(sViewName,sParams);
};

function initializeInspectMenuDialog(DialogID)
{
};

/***********************************************************************
Opens an inspect window in a new view
***********************************************************************/
function openInspectWindow(ViewName,Params) {

	appendToLog("openInspectWindow ViewName="+ViewName+" Params="+Params);

	var sViewName=ViewName;
	var sID=getSalt(6);
	
	//hide any open pop-ups
	hidePopups();

	//show the close-all element.  Don't use setVisible because it needs to be inline
	//This element may not be used any more
	var eCloseAll=document.getElementById("UICloseAllViews");
	if(eCloseAll) {
		document.getElementById("UICloseAllViews").style.display="inline";
		document.getElementById("UICloseAllViews").display="inline";
	};

	//record default parameter values.  Defaults are also recorded when the onChange event
	//fires for a parameter.  However, the onChange even is not fired when a calender is used 
	//to select a date.  This is a fix to address that.
	recordDefaultParamValues();

	//if the params includes a target (_blank, _self) then open the url as a new page and
	//not as a tab in the current page
	var sTarget=getElementValue(Params,"target","&");
	var sTargetUpper=sTarget.toUpperCase();
	if((sTargetUpper.indexOf("_BLANK")>=0) || (sTargetUpper.indexOf("_SELF")>=0)) 
	{
		var sUrl="";
		if((Params.toUpperCase().startsWith("HTTP")) || (Params.toUpperCase().startsWith("FTP")) || (Params.toUpperCase().startsWith("VIEWID")) || (Params.toUpperCase().startsWith(".."))) {
			sUrl=Params;

			//remove ViewID=xxx from the start of the URL
			if(sUrl.toUpperCase().startsWith("VIEWID")) {
				sUrl=sUrl.substring(sUrl.indexOf("&")+1);
			};

			//remove the source from the end of the params
			var n=sUrl.toUpperCase().indexOf("&SOURCE=");
			if(n>=0) {
				sUrl=sUrl.substring(0,n);
			};
		}
		else {
			sUrl=getServer()+"/?Network=Greenlight&ID=getWidget&"+Params;
		};

		//remove the target from the url
		sUrl=replaceAllSubstrings(sUrl,"target=_blank","");
		sUrl=replaceAllSubstrings(sUrl,"target=_self","");
		if(sUrl.endsWith("&")) sUrl=sUrl.substring(0,sUrl.length-1);

		appendToLog("Opening window: "+sUrl);
		window.open(sUrl,sTarget);
		return;
	};

	//add parameters from the UI
	if(Params.length>0) Params+="&";
	Params +=getUIParams();

	//set the url that will be opened in a new tab
	var sUrl=getServer()+"/?Network=Greenlight&ID=getWidget&" + Params; 

	//pass user-input parameters to the dimensional driver 
	var sDimDriverParams=replaceAllSubstrings(Params,"&","^");
	sUrl +="&DimDriverParams="+sDimDriverParams;

	//see if a tab has already been opened.  If so, focus it instead of opening a duplicate.
	//This is important because when a cached view is returned, the IDs used will be the same
	//as when the document was originally created, even when salt is used.  If a second instance
	//of the same cached document is opened, there will be two views sharing the same ID's.
	var arOpenViews=document.getElementsByClassName("ViewContent");
	for(var i=0;i<arOpenViews.length;i++) {
		var s=arOpenViews[i].getAttribute("url");
		if(s) {
			if(s.equalsIgnoreCase(sUrl)) {
				sSalt=arOpenViews[i].id.substring(3);
				hidePopups();
				var eTab=document.getElementById("span"+sSalt);
				showUITab(eTab,"ViewContainer"+sSalt);
				return;
			};
		};
	};

	//get the title for the view.  The computer name is added if it is not the local computer
	var sViewTitle=ViewName;

	//add the name of the computer to the view title if it's not the local computer
	//Don't add the computer name for inspect windows used to display faq, how to and videos
	var sSource=getElementValue(Params,"source","&"); 
	if((!sViewTitle.toUpperCase().startsWith("FAQ:")) && (!sViewTitle.toUpperCase().startsWith("HOW TO:")) && (!sViewTitle.toUpperCase().startsWith("PROCEDURE:"))) {
		if((sSource.length>0) && (!sSource.equalsIgnoreCase("v8k3ey5q1"))) {
			appendToLog("sSource="+sSource+" AspectHashID=v8k3ey5q1");
			var e=document.getElementById("UISelectUserComputer"); 
			var sComputerName="";
			for(var i=0;i<e.options.length;i++) {
				if(e.options[i].value.equalsIgnoreCase(sSource)) sComputerName=e.options[i].text;
			};
			if(sComputerName.length==0) sComputerName=sSource;
			sViewTitle +=" - "+sComputerName;
		};
	};

	//create a new output tab to contain the output
	var eViewContentContainer=document.createElement("div");
	eViewContentContainer.id="ViewContainer"+sID;
	eViewContentContainer.className="ViewContainer";
	document.getElementById("OutputDivs").appendChild(eViewContentContainer);

	//create a div to contain the header for the output
	var divTitle1=document.createElement("div");
	divTitle1.setAttribute("class","view_title1");
	divTitle1.id="ViewTitleContainer1"+sID;
	var divTitle2=document.createElement("div");
	divTitle2.setAttribute("class","view_title2");
	divTitle2.id="ViewTitleContainer2"+sID;
	divTitle1.appendChild(divTitle2);
	eViewContentContainer.appendChild(divTitle1);

	//add the name of the view to the title div
	eSourceName=document.createElement("div");
	eSourceName.id="SourceName"+sID;
	eSourceName.className="view_source_name";
	eSourceName.innerHTML=sViewTitle;
	divTitle2.appendChild(eSourceName);

	//add a span to the title div that will contain the elapsed time
	eElapsedTime=document.createElement("div");
	eElapsedTime.id="ElapsedTime"+sID;
	eElapsedTime.className="view_elapsed_time";
	divTitle2.appendChild(eElapsedTime);

	//add view controls to the view container
	var eViewControls=document.createElement("span");
	eViewControls.setAttribute("class","view_controls");
	//eViewControls.innerHTML="testing";

	//view control - print icon
	eSpan=document.createElement("span");
	eSpan.setAttribute("class","view_control_print_icon");
	var sOnClick="printView('"+sID+"');";
	eSpan.setAttribute("onclick",sOnClick);
	eSpan.onclick=Function(sOnClick);  
	eViewControls.appendChild(eSpan);

	//view control - refresh icon
	eSpan=document.createElement("span");
	eSpan.setAttribute("class","view_control_refresh_icon");
	var sOnClick="refreshView('"+sID+"');";
	eSpan.setAttribute("onclick",sOnClick);
	eSpan.onclick=Function(sOnClick);  
	eViewControls.appendChild(eSpan);

	//view control - close icon
	var eSpan=document.createElement("span");
	eSpan.setAttribute("class","view_control_close_icon");
	var sOnClick="deleteView('"+sID+"');";
	eSpan.setAttribute("onclick",sOnClick);      
	eSpan.onclick=Function(sOnClick);  
	eViewControls.appendChild(eSpan);

	//view control - email icon
	if(false) {
		eSpan=document.createElement("span");
		eSpan.setAttribute("class","view_control_email_icon");
		var sOnClick="emailView('"+sID+"');";
		eSpan.setAttribute("onclick",sOnClick);
		eSpan.onclick=Function(sOnClick);  
		eViewControls.appendChild(eSpan);
	};

	eViewContentContainer.appendChild(eViewControls);
	//create the div that will contain the view content
	var div=document.createElement("div");
	div.setAttribute("ID","Div"+sID);
	div.id="Div"+sID;
	div.className="ViewContent";
	eViewContentContainer.appendChild(div);

	//show a message in the output div while the content is loading
	divMessage=document.createElement("div");
	divMessage.setAttribute("class","output_loading");
	divMessage.innerHTML="Loading...";
	div.appendChild(divMessage);

	//add the new div to the table containing the list of tabs
	var text=document.createTextNode(sViewTitle);
	var span=document.createElement("span");
	span.id="span"+sID;
	span.className="tabdialogtabselected";
	var sOnClick="hidePopups();showUITab(this,'ViewContainer"+sID+"');";
	span.setAttribute("onclick",sOnClick);      //this works for firefox
	span.onclick=Function(sOnClick);            //this works for IE
	span.appendChild(text);

	//add an icon used to close the tab
	//the icon is contained in the background of the span
/*
	var eCloseIcon=document.createElement("div");
	eCloseIcon.setAttribute("Class","ViewTabCloseIcon");
	eCloseIcon.id="closetab"+sID;
	var sOnClick="deleteView('"+sID+"');";
	eCloseIcon.setAttribute("onclick",sOnClick);      //this works for firefox
	eCloseIcon.onclick=Function(sOnClick);            //this works for IE
	span.appendChild(eCloseIcon);
*/
	
	//programmatically add the tab to the table containing the dialog tabs
	var table=document.getElementById("OutputTabs");
	var cell=table.rows[0].insertCell(-1);
	cell.setAttribute("ID","Cell"+sID);
	cell.id="Cell"+sID;
	cell.setAttribute("Class","view_tab");
	cell.appendChild(span);
	//cell.appendChild(img);

	//add the div to the select box   The select box is set to visible, but a media query
	//manages the container surrounding the select box which means it may still not be
	//visible depending on the screen size.  
	var select=document.getElementById("OutputSelect");
	select.add(new Option(sViewTitle,"ViewContainer"+sID,false,true));
	setVisible(select,true);
	//select.options[select.options.length]=new Option(sViewTitle,"ViewContainer"+sID,false,true);

	setOpenViewSelectionMethod();

	//record the starting time in the output div
	div.setAttribute("StartTime",new Date().getTime());

	//show the output div
	showTab(span,"ViewContainer"+sID);

	div.setAttribute("url",sUrl);
	
	appendToLog("Opening inspect window: "+sUrl);
	var sFunc="viewUpdated(\""+sID+"\",false)";
	asynchInclude(div,sUrl,sFunc,sFunc);

	//google analytics event
	//note: this is called by the viewUpdated function when the view has been loaded
	//gaevt("View","inspect",sViewName,0);
};


function formatViewContainers(bScreenResized) {
	var arDiv=document.getElementsByTagName("div");
	for(var i=0;i<arDiv.length;i++) {
		if(arDiv[i].getAttribute("ViewContainer")) {
			if((bScreenResized) || (!arDiv[i].getAttribute("ViewContainerFormated"))) {
				formatViewContainer(arDiv[i]);
			};
		};
	};
};


function formatViewContainer(ID) {
	var eViewContainer=document.getElementById(ID);
	if(!eViewContainer) eViewContainer=ID;
	if(!eViewContainer) return;
	if(!isVisible(eViewContainer)) return;
	
	//get an array of all the different top positions in use
	var arTop=new Array();
	var arRowHeight=new Array();
	var arRowWidth=new Array();
	var MaxRowWidth=0;
	var arDiv=eViewContainer.getElementsByTagName("div");

	for(var i=0;i<arDiv.length;i++) {
		if(arDiv[i].getAttribute("ViewContainerItem")=="true") {
			//abort if the height of the div is 0, indicating that it is hidden.
			if(arDiv[i].offsetHeight==0) return;
			arDiv[i].style.width="auto";
			arDiv[i].style.height="auto";
			//arDiv[i].style.borderTop="1px solid black";
			//arDiv[i].style.borderLeftColor="black";
		};
	};

	for(var i=0;i<arDiv.length;i++) {
		if(arDiv[i].getAttribute("ViewContainerItem")=="true") {
			var Top=arDiv[i].offsetTop;
			var Height=arDiv[i].offsetHeight;
			var Width=arDiv[i].offsetWidth;
			var Index=arTop.indexOf(Top);
			if(Index<0) {
				Index=arTop.length;
				arTop[Index]=Top;
				arRowHeight[Index]=Height;
				arRowWidth[Index]=Width;
			}
			else {
				arRowHeight[Index]=Math.max(arRowHeight[Index],Height);
				arRowWidth[Index] +=Width;
			};
			MaxRowWidth=Math.max(MaxRowWidth,arRowWidth[Index]);
			arDiv[i].setAttribute("ViewContainerRow",Index);
		};
	};
	
	//set the height of each element on a row to the max height of any element on the row
	for(var i=0;i<arDiv.length;i++) {
		if(arDiv[i].getAttribute("ViewContainerItem")=="true") {
			var Row=arDiv[i].getAttribute("ViewContainerRow");
			//01-20-2017 - Disabled this.  See comments at start of function.
			//arDiv[i].style.height=arRowHeight[Row]+"px";
		};
	};

	//This section was used to apply a consistent width to all elements in a row.
	//It seems to apply the largest width of any row to every row instead of the 
	//taking the width from a single row.  In any case, it is probably not a good
	//idea to set the widths.  Set them in the content being embedded instead.
	//make all rows the same width
	if(false) {
		for(var Row=0;Row<arTop.length;Row++) {
			//get the current width of the row
			var CurrentWidth=0;
			var arDivsInRow=new Array();
			for(var i=0;i<arDiv.length;i++) {
				if(arDiv[i].getAttribute("ViewContainerItem")=="true") {
					if(arDiv[i].getAttribute("ViewContainerRow")==Row) {
						CurrentWidth +=arDiv[i].offsetWidth;
						arDivsInRow[arDivsInRow.length]=arDiv[i];

						//turn off top border for rows after row 0
						if(Row>0) arDiv[i].style.borderTop="none";
					};
				};
			};
			
			//Determine the number of pixels to add
			var PixelsToAdd=MaxRowWidth-CurrentWidth;
			if(PixelsToAdd>0) {
				var PixelsPerDiv=Math.floor(PixelsToAdd/arDivsInRow.length);
				var Remainder=PixelsToAdd - (PixelsPerDiv*arDivsInRow.length);
				for(var i=0;i<arDivsInRow.length;i++) {
					var W=PixelsPerDiv;
					if(i==arDivsInRow.length-1) W +=Remainder;
					arDivsInRow[i].style.width=(arDivsInRow[i].offsetWidth+W)+"px";
				};
			};
		};

		if(false) {
			//turn off left  border for columns after column 0
			for(var i=1;i<arDivsInRow.length;i++) {
				//boxes get out of alignment on the far right border if the left border is set to none.
				//Instead, set the color to transparent
				arDivsInRow[i].style.borderLeftColor="transparent";
			};
		};
	};

	eViewContainer.setAttribute("ViewContainerFormated","true");
};

/****************************************************************
The View tab is normally used to prompt for parameters and open a
view.  The functions below provide an alternate way to prompt for 
parameters and open a view, outside the View tab.  

Only one set of parameters exists at any time.  They are located in 
tags with the ID "view_params_container" and "open_view_container".
These elements normally belong to the "view_params_outer_container"
element in the View tab.

To open a view outside of the view tab, an element with the ID 
AltUIParamsContainer is created and the "view_params_container" and 
"open_view_container" elements are removed from the "view_params_outer_container"
element and added to the "AltUIParamsContainer" element.  This allows functions 
used to evaluate and update the parameters to function 
as they would if the parameters were in the View tab.  The view may 
also be opened as if it was being opened from the View tab.  Using one 
set of parameters also allows for consistency when the parameters are 
accessed from different locations and allows for recording default values.

When the view is opened, or when the View tab is selected, the 
"view_params_container" and "open_view_container" elements are restored 
to their original place in the View tab.  As a failsafe, an element with
the ID "view_params_outer_container_backup" is included in the View popup
and can be used to restore the parameter container if the AltUIParamsContainer
element is destroyed before the container is moved back to the view tab.
****************************************************************/

/****************************************************************
Restores the params container to its original place in the View
popup.  The params are removed from the AltUIParamsContainer and
appended to the view popup.  If the params container does not exist,
a new params container is initialized by copying html from the 
backup container.

This function is called whenever the view tab is clicked, whether 
it is being shown or hidden.
****************************************************************/
function restoreUIViewParamsContainer() {
	var eUIParmsOuterContainer=document.getElementById("view_params_outer_container");
	var eViewParamsContainer=document.getElementById("view_params_container");
	var eOpenviewContainer=document.getElementById("open_view_container");
	if((!eViewParamsContainer) || (!(eViewParamsContainer.parentNode==eUIParmsOuterContainer))) {
		if((eViewParamsContainer) && (eOpenviewContainer)) {
			eViewParamsContainer.parentNode.removeChild(eViewParamsContainer);
			eOpenviewContainer.parentNode.removeChild(eOpenviewContainer);
			eUIParmsOuterContainer.appendChild(eViewParamsContainer);
			document.getElementById("select_view_containerLI").appendChild(eOpenviewContainer);
			//eUIParmsOuterContainer.appendChild(eOpenviewContainer);

			//set the class of the div containing the open button icon back to the original class.
			//This restores the padding so the element is aligned horizontally with the view selection
			document.getElementById("OpenViewButton").setAttribute("class","OpenViewButton");
			setVisible("AltUIParamsContainer",false);
		}
		else {
			var eUIParmsOuterContainerBackup=document.getElementById("view_params_outer_container_backup");
			var s=eUIParmsOuterContainerBackup.innerHTML;
			s=replaceAllSubstrings(s,"_view_params_container","view_params_container");
			s=replaceAllSubstrings(s,"_open_view_container","open_view_container");
			s=replaceAllSubstrings(s,"_OpenViewButton","OpenViewButton");
			eUIParmsOuterContainerBackup.innerHTML=s;
			viewSelected();
		};
	};
};

/****************************************************************
Moves the view params container out of the view popup and into
a div with the ID AltUIParamsContainer.  The div is then appended 
to the element specified by e.  The view popup is updated with 
the package, category and view ID so it is in synch with the view
being opened.

This function is used to open a view and prompt for params outside 
the standard view popup.  For example, it might allow opening a 
view from a site map.  The difference between this and opening a 
view using openInspectWindow() is that this method allows for 
prompting for parameters associated with the view.  When using 
openInspectWindow(), the parameters must be known and be passed to 
the function.
****************************************************************/
function showViewParamsContainer(e,PackageID,CategoryID,ViewID)
{
	hidePopups();

	//If an item is selected in the site map and the params are already displayed
	//for that item, toggle the params to not visible
	var eAltUIParamsContainer=document.getElementById("AltUIParamsContainer");
	if(eAltUIParamsContainer) {
		if((eAltUIParamsContainer.parentNode==e) && (isVisible(eAltUIParamsContainer))) {
			setVisible(eAltUIParamsContainer,false);
			return;
		};
	};

	//see if any parameters are defined for the view
	var bHasInputParams=false;
	var arView=getAvailableViews();
	for(var i=0;i<arView.length;i++) {
		if(arView[i].startsWith(ViewID)) {
			var n=arView[i].indexOf("=");
			if(n>0) {
				var s=arView[i].substring(n+1);
				var a=s.split("^");
				if(a.length>3) bHasInputParams=a[3];
				break;
			};
		};
	};

	if(bHasInputParams=="true") {
		//create the AltUIParamsContainer element if it doesn't exist
		if(!eAltUIParamsContainer) {
			eAltUIParamsContainer=document.createElement("div");
			eAltUIParamsContainer.id="AltUIParamsContainer";
			eAltUIParamsContainer.className="AltUIParamsContainer";
		}
		else {
			eAltUIParamsContainer.parentNode.removeChild(eAltUIParamsContainer);
		};

		e.appendChild(eAltUIParamsContainer);
		setVisible(eAltUIParamsContainer,true);

		var eViewParamsContainer=document.getElementById("view_params_container");
		var eOpenviewContainer=document.getElementById("open_view_container");
		eViewParamsContainer.parentNode.removeChild(eViewParamsContainer);
		eOpenviewContainer.parentNode.removeChild(eOpenviewContainer);
		eAltUIParamsContainer.appendChild(eViewParamsContainer);
		eAltUIParamsContainer.appendChild(eOpenviewContainer);

		//set the class of the div containing the open button to the alternate class 
		//This adjusts the padding so the element is aligned horizontally with the params
		document.getElementById("OpenViewButton").setAttribute("class","OpenViewButtonAlt");
	};

	document.getElementById("UISelectPackage").value=PackageID;
	packageSelected();

	document.getElementById("UISelectViewCategory").value=CategoryID;
	viewCategorySelected();

	document.getElementById("UISelectView").value=ViewID;
	viewSelected();

	if(!(bHasInputParams=="true")) openView();
};

/***********************************************************************
An array of group names for elements to be animated.  Each element belongs 
to one of these groups.  Each group is animated independently.

Attributes are:
	Name - Name of the group
	MaxFrames - The maximum number of frames of any element in the group
	Frame - The current frame
	Delay - The number of milliseconds to pause before moving all elements to the next frame
	NextAction - The action to take when animate() is called for the group.
	Control - The range slider associated with the group
	SliderValue - This is set by the range slider when it changes.
	AnimationSpeed - The playback speed (1-10)
	Salt - A unique ID given to the group.  This is used to discontinue calls to animate() 
		for a group when it has been updated with new animation elements.
***********************************************************************/
var arAnimateGroup=new Array();

/***********************************************************************
An array of ID's for elements to be animated.  These elements contain 
a series of frames in the form of divs.

Attributes are:
	ID - ID of the element.  This is the wrapper containing the frames to be animated
	group - group name
	e - element 
	FrameCount - Number of frames in the animation
	Frames - Array of frames in the animation
	ActiveFrame - The currently visible frame
***********************************************************************/
var arAnimateID=new Array();

/***********************************************************************
Gets the table that an animation element belongs to
***********************************************************************/
function getAnimationTable(e) {
	var sTableID=null;
	var e1=e;
	do {
		e1=e1.parentNode;
		if(e1) {
			if(e1.nodeName.equalsIgnoreCase("TD")) {
				var eTableRow=e1.parentNode;
				var eTableBody=eTableRow.parentNode;
				var eTable=eTableBody.parentNode;
				return(eTable);
			};
		};
	} while((e1) && (e1.parentNode) && (sTableID==null));

	return(null);
};

/***********************************************************************
Gets the group name that an element belongs to.  The group can be specified 
in the animationgroup attribute.  If a name is not specified, the ID of the table
that the element belongs to will be used.
***********************************************************************/
function getAnimationGroupForElement(e) 
{
	//use the animationgroup attribute if one is specified.  This can be done when an animation 
	//is not included in a table
	var Group=e.getAttribute("animationgroup");
	if(Group) return(Group);

	//otherwise, return the ID of the table containing the animation
	var eTable=getAnimationTable(e);
	if(eTable) return(eTable.id);
	return(null);
};

/***********************************************************************
Returns an element from the arAnimateGroup array
***********************************************************************/
function getAnimationGroup(_groupname) {
	var nGroup=arAnimateGroup.map(function(e) { return e.Name; }).indexOf(_groupname);
	if(nGroup<0) return(null);
	return(arAnimateGroup[nGroup]);
};

/***********************************************************************
Gets an array of frames belonging to an element.  getElementsByTagName is 
used instead of childNodes because text elements are included in the 
childNodes for some reason in addition to the frames (divs)
***********************************************************************/
function getFrames(e) {
	var aNodes=e.getElementsByTagName("div");
	var a=new Array();
	for(var i=0;i<aNodes.length;i++) {
		var sClass=aNodes[i].getAttribute("class");
		if(sClass) {
			if((sClass.equalsIgnoreCase("meter_outer")) || (sClass.equalsIgnoreCase("meter_opaque"))) {
				a[a.length]=aNodes[i];
			};
		};			
	};
	return(a);
};

/***********************************************************************
Returns a count of the number of frames in an animation element
***********************************************************************/
function countFrames(e) {
	var a=getFrames(e);
	return(a.length);
};

/***********************************************************************
Adds the ID of an element to be animated to the array of animations
***********************************************************************/
function addAnimation(_id,_group) {
	var n=arAnimateID.map(function(e) { return e.id; }).indexOf(_id);
	if(n<0) {
		//console.log("addAnimation "+_id+" arAnimateID.len="+arAnimateID.length);
		n=arAnimateID.length;
		var e1=document.getElementById(_id);
		arAnimateID[n]={ID:_id,group:_group,e:e1,FrameCount:countFrames(e1),Frames:getFrames(e1),ActiveFrame:0};
		initializeAnimation(n);
	};
};

/***********************************************************************
Removes the ID of an element from the array of animations.  This is called 
by animate() when an animation no longer exists
***********************************************************************/
function removeAnimation(_index) {
	console.log("removeAnimation "+_index+" arAnimateID len="+arAnimateID.length);
	arAnimateID.splice(_index,1);
	console.log("removeAnimation complete len="+arAnimateID.length);
};

/***********************************************************************
Sets an animation back to its starting frame
***********************************************************************/
function initializeAnimation(_index) {
	arAnimateID[_index].ActiveFrame=0;
	var arFrames=getFrames(arAnimateID[_index].e);
	for(var i=0;i<arFrames.length;i++) {
		arFrames[i].style.display="none";
	};
};

/***********************************************************************
Sets the frame for an animation
***********************************************************************/
function advanceAnimation(_animation,PercentDone) {
	var NewActiveFrame=Math.floor(_animation.FrameCount*PercentDone);
	NewActiveFrame=Math.min(NewActiveFrame,_animation.FrameCount-1);
	//console.log("_animation.ActiveFrame="+_animation.ActiveFrame+" NewActiveFrame="+NewActiveFrame);
	if(NewActiveFrame!=_animation.ActiveFrame) {
		_animation.Frames[_animation.ActiveFrame].style.display="none";
		_animation.ActiveFrame=NewActiveFrame;
		_animation.Frames[_animation.ActiveFrame].style.display="block";
	};
};

/***********************************************************************
This is a continuous loop that makes the call to advance the animation 
for all animations in the array
***********************************************************************/
function animationFastRewind(_groupname) {
	var Group=getAnimationGroup(_groupname);
	Group.NextAction="fastrewind";
};

function animationSkipPrevious(_groupname) {
	var Group=getAnimationGroup(_groupname);
	Group.NextAction="skipprevious";
};

function animationPlayArrow(_groupname) {
	var Group=getAnimationGroup(_groupname);
	var e=document.getElementById(_groupname+"play_arrow");
	var s=e.getAttribute("class");
	if(s=="play_arrow") {
		e.setAttribute("class","pause");
		Group.NextAction="play";
	}
	else {
		e.setAttribute("class","play_arrow");
		Group.NextAction="pause";
	};
	console.log("Group.NextAction="+Group.NextAction);
};

function animationSkipNext(_groupname) {
	var Group=getAnimationGroup(_groupname);
	Group.NextAction="skipnext";
};

function animationFastForward(_groupname) {
	var Group=getAnimationGroup(_groupname);
	Group.NextAction="fastforward";
};

function setAnimationSpeed(_groupname,eSelect) {
	var Group=getAnimationGroup(_groupname);
	Group.AnimationSpeed=parseFloat(eSelect.value);
};

function animationRangeSet(_groupname,eRange) {
	var Group=getAnimationGroup(_groupname);
	Group.SliderValue=parseFloat(eRange.value);

	var e=document.getElementById(_groupname+"play_arrow");
	var s=e.getAttribute("class");
	if(s=="play_arrow") {
		Group.NextAction="RangeSelectedPause";
	}
	else {
		Group.NextAction="RangeSelectedPlay";
	};
};

function animate(_groupIndex,_groupsalt) {
	//don't animate hidden elements
	var Group=arAnimateGroup[_groupIndex];
	if(!Group) return;

	var iDelay=Group.AnimationSpeed*50;

	if(Group.NextAction=="play") {
		Group.Frame++;
		if(Group.Frame>Group.MaxFrames) {
			Group.Frame=0;
			iDelay=2000;
		};
	}
	else if(Group.NextAction=="pause") {
		setTimeout("animate("+_groupIndex+",\""+Group.Salt+"\")",1000);
		return;
	}
	else if(Group.NextAction=="fastrewind") {
		Group.Frame=0;
		Group.Control.value=Group.Frame;
		var e=document.getElementById(Group.Name+"play_arrow");
		e.setAttribute("class","play_arrow");
		Group.NextAction="pause";
	}
	else if(Group.NextAction=="fastforward") {
		Group.Frame=Group.MaxFrames;
		Group.Control.value=Group.Frame;
		var e=document.getElementById(Group.Name+"play_arrow");
		e.setAttribute("class","play_arrow");
		Group.NextAction="pause";
	}
	else if(Group.NextAction=="skipprevious") {
		Group.Frame--;
		Group.Control.value=Group.Frame;
		var e=document.getElementById(Group.Name+"play_arrow");
		e.setAttribute("class","play_arrow");
		if(Group.Frame<0) Group.Frame=0;
		Group.NextAction="pause";
	}
	else if(Group.NextAction=="skipnext") {
		Group.Frame++;
		var e=document.getElementById(Group.Name+"play_arrow");
		e.setAttribute("class","play_arrow");
		if(Group.Frame>Group.MaxFrames) Group.Frame=0;
		Group.NextAction="pause";
	}
	else if(Group.NextAction=="RangeSelectedPause") {
		Group.Frame=Group.SliderValue;
		Group.SliderValue=-1;
		Group.NextAction="pause";
	}
	else if(Group.NextAction=="RangeSelectedPlay") {
		Group.Frame=Group.SliderValue;
		Group.SliderValue=-1;
		Group.NextAction="play";
	};

	if((Group.Control.value==Group.Frame-1) || (Group.Frame==0)) {
		Group.Control.value=Group.Frame;
	};

	var PercentDone=Group.Frame/Group.MaxFrames;
	var n=0;
	while(n<arAnimateID.length) {
		if(arAnimateID[n].e) {
			advanceAnimation(arAnimateID[n],PercentDone);
			n++
		}
		else {
			removeAnimation(n);
		};
	};

	//don't renew the loop if no animation elements exist.  Animation elements will no 
	//longer exist when a table is refreshed
	if(Group.Salt==_groupsalt) setTimeout("animate("+_groupIndex+",\""+Group.Salt+"\")",iDelay);
};

function addAnimationControl(_table,_groupname) {
	var arTableTHead=_table.getElementsByTagName("thead");
	if(arTableTHead.length>=1) {
		//add another row to the table header
console.log("arTableTHead.length="+arTableTHead.length);
		if(arTableTHead.length==1) {
			//table controls are not displayed so add the control as the first row in the header.
			//This puts the control above the column headers
			var tr=arTableTHead[0].insertRow(0);
		}
		else {
			//table controls are included so add the control to the end of the table controls.
			var tr=arTableTHead[0].insertRow(-1);
		};

		//add a cell to contain the animation controls
		var THControl=document.createElement("th");
		THControl.setAttribute("colspan",100);
		tr.appendChild(THControl);

		//add range element to display playback position
		var eRange=document.createElement("input");
		eRange.setAttribute("id",_groupname+"animatecontrol");
		eRange.setAttribute("type","range");
		eRange.setAttribute("min",0);
		eRange.setAttribute("max",100); //this is updated in addAnimations to be the max number of frames
		eRange.setAttribute("value",0);
		eRange.style.width="100%";
		eRange.setAttribute("onInput","animationRangeSet('"+_groupname+"',this)");
		THControl.appendChild(eRange);

		if(arTableTHead.length==1) {
			tr=arTableTHead[0].insertRow(1);
		}
		else {
			tr=arTableTHead[0].insertRow(-1);
		};
		var THPlayback=document.createElement("th");
		THPlayback.setAttribute("colspan",100);
		THPlayback.style.textAlign="center";
		tr.appendChild(THPlayback);

		var Span=document.createElement("span");
		Span.setAttribute("class","fast_rewind");
		Span.style.marginRight="10px";
		Span.id=_groupname+"fast_rewind";
		Span.style.cursor="pointer";
		Span.setAttribute("onClick","animationFastRewind('"+_groupname+"')");
		THPlayback.appendChild(Span);

		Span=document.createElement("span");
		Span.setAttribute("class","skip_previous");
		Span.style.marginRight="10px";
		Span.id=_groupname+"skip_previous";
		Span.style.cursor="pointer";
		Span.setAttribute("onClick","animationSkipPrevious('"+_groupname+"')");
		THPlayback.appendChild(Span);

		Span=document.createElement("span");
		Span.setAttribute("class","pause");
		Span.style.marginRight="10px";
		Span.id=_groupname+"play_arrow";
		Span.style.cursor="pointer";
		Span.setAttribute("onClick","animationPlayArrow('"+_groupname+"')");
		THPlayback.appendChild(Span);

		Span=document.createElement("span");
		Span.setAttribute("class","skip_next");
		Span.style.marginRight="10px";
		Span.id=_groupname+"skip_next";
		Span.style.cursor="pointer";
		Span.setAttribute("onClick","animationSkipNext('"+_groupname+"')");
		THPlayback.appendChild(Span);

		Span=document.createElement("span");
		Span.setAttribute("class","fast_forward");
		Span.style.marginRight="10px";
		Span.id=_groupname+"fast_forward";
		Span.style.cursor="pointer";
		Span.setAttribute("onClick","animationFastForward('"+_groupname+"')");
		THPlayback.appendChild(Span);

		var Select=document.createElement("select");
		Select.setAttribute("onChange","setAnimationSpeed('"+_groupname+"',this)");
		Select.value=5;
		for(var i=1;i<=10;i++) {
			Select.options[i]=document.createElement("option");
			Select.options[i].text=i;
			Select.options[i].value=i;
			if(i==3) Select.options[i].selected=true;
		};
		THPlayback.appendChild(Select);

		return(eRange);
	};
};

/***********************************************************************
Removes animation elements that no longer exist.  Animations will no longer 
exist when a table is refreshed.  Also removes groups that no longer contain
any animations.
***********************************************************************/
function purgeAnimations() {
	//remove any animation elements that no longer exist
	var n=0;
	var c=0;
	while((c<100) && (n<arAnimateID.length)) {
		if(!document.getElementById(arAnimateID[n].ID)) {
			console.log("Removed animation: "+arAnimateID[n].ID+" n="+n+" arAnimateID.length="+arAnimateID.length);
			arAnimateID.splice(n,1);
		}
		else {
			n++;
		};
		c++;
	};

	//remove any groups for which there are no animations.  This happens when a table is refreshed.
	//The group will still be in the array but the animations will have been replaced
	var n=0;
	while(n<arAnimateGroup.length) {
		var n1=arAnimateID.map(function(e) { return e.group; }).indexOf(arAnimateGroup[n].Name);
		if(n1<0) {
			console.log("Removed group: "+arAnimateGroup[n].Name);
			arAnimateGroup.splice(n,1);
		}
		else {
			n++;
		};
	};
};

/***********************************************************************
This is called when content is loaded.  It adds elements to the array of 
elements to be animated
***********************************************************************/
function addAnimations() {

	//remove any animations that no longer exist
	purgeAnimations();

	//save the number of existing animation groups.  Animation will be started for 
	//any new groups added beyond this index
	var SaveGroupLen=arAnimateGroup.length;

	var a=document.getElementsByTagName("div");
	for(var i=0;i<a.length;i++) {
		var AnimateAttr=a[i].getAttribute("animate");
		if((AnimateAttr) && (a[i].id)) {
			if(AnimateAttr!="active") {
				//get the group that the animation belongs to
				var group=getAnimationGroupForElement(a[i]);

				var eTable=getAnimationTable(a[i]);
				var eAnimationControl=document.getElementById(group+"animatecontrol");
				if(!eAnimationControl) {
					eAnimationControl=addAnimationControl(eTable,group);
				};
	
				//add the group to the array of animation groups if it's not already included
				var nGroup=arAnimateGroup.map(function(e) { return e.Name; }).indexOf(group);
				if(nGroup<0) {
					nGroup=arAnimateGroup.length;
					arAnimateGroup[nGroup]={Name:group,MaxFrames:0,Frame:0,Delay:100,Control:eAnimationControl,NextAction:"play",SliderValue:-1,AnimationSpeed:5,Salt:getSalt(4)};
					console.log("added group: "+arAnimateGroup[nGroup].Name);
				};

				//add the element to the list of animations
				addAnimation(a[i].id,group);
				a[i].setAttribute("animate","active");

				//set the maximum number of frames for the group
				arAnimateGroup[nGroup].MaxFrames=Math.max(countFrames(a[i]),arAnimateGroup[nGroup].MaxFrames);
				//arAnimateGroup[nGroup].Frame=0;
				//arAnimateGroup[nGroup].Control=eAnimationControl;
				arAnimateGroup[nGroup].Control.setAttribute("max",arAnimateGroup[nGroup].MaxFrames);
			};
		};
	};

	StopAnimation=false;

	for(var i=SaveGroupLen;i<arAnimateGroup.length;i++) {
		animate(i,arAnimateGroup[i].Salt);
	};
};