//**Start Encode**

var isoRegExp = "([\\d]{4}-[\\d]{2}-[\\d]{2}T[\\d]{2}:[\\d]{2}:[\\d]{2})";
var AmericanDateTime = "^[\\s]*([\\d]{1,2})[-|\\/]([\\d]{1,2})[-|\\/]([\\d]{2,4})(?:\\s+([\\d:]*)|$)(\\s*AM|\\s*PM|$)";
var ISODateTime = "^(([\\d]{4})-([\\d]{1,2})-([\\d]{1,2})T(([\\d]{1,2}):([\\d]{1,2})(:([\\d]{1,2})){0,1}))";
var ISODateOnly = "^(([\\d]{4})-([\\d]{1,2})-([\\d]{1,2}))";
var xasciiFileExtensions = /\.(css|js|hta|htc|htm|html|inc|log|txt|xml|xsl)\s*$/i
var asciiFileExtensions = /\.(css|js|hta|htc|inc|log|txt|xml|xsl)\s*$/i

var pmMask = /\s*PM/i
var progressWindow = null;
var _menuHelp = null;							//Help associated with menu containing this page
var _pageBannerHeight = 0;				//No page banner

var _originalValuesSet = false;
var _originalHeight = "600px";
var _originalWidth = "800px";
var _originalTop = 0;
var _originalLeft = 0;
var _siteStylesheet = null;
var _siteStylesheetName;
var _lastSize = "largesize";

var _compareObject;

function debugIf(param)
{
  var agtObj;
  if (typeof(agt)=="object") agtObj = agt;
  if (!agtObj && typeof(_agt)=="object") agtObj = _agt;	
  if (!agtObj && typeof(mainWindow.agt)=="object") agtObj = mainWindow.agt;
  if (!agtObj && typeof(_mainWindow.agt)=="object") agtObj = _mainWindow.agt;
  	
  if (agtObj)
  {
	  switch(param)
	  {
	  	case "alt": 
	  		if (event.altKey == 1) debugger;	
				break;
	  	case "ctrl": 
	  		if (event.ctrlKey == 1) debugger;	
				break;
	  	default: 
	  		if (agtObj.agentid == param) debugger;	
				break;
	  }
  }  
}


window.size = function()
{
	var w = 0;
	var h = 0;

	//IE
	if(!window.innerWidth)
	{
		//strict mode
		if(!(document.documentElement.clientWidth == 0))
		{
			w = document.documentElement.clientWidth;
			h = document.documentElement.clientHeight;
		}
		//quirks mode
		else
		{
			w = document.body.clientWidth;
			h = document.body.clientHeight;
		}
	}
	//w3c
	else
	{
		w = window.innerWidth;
		h = window.innerHeight;
	}
	return {width:w,height:h};
}


/******************************************************
*    Resize some of the imput fields on the page and
*    set a class on the document.body based on the 
*    size of the window.
*    This is called from (at least) search and updates
******************************************************/
function setResizeFieldSize(baseDivId)
{
	var winsize = window.size();
	var curSize = "largesize";
	if (winsize.width < 1100) curSize = "medsize";
	if (winsize.width < 900) curSize = "smallsize";
	
	if (_lastSize	!= curSize)
	{
		$(document.body).removeClass('winsmallsize').removeClass('winmedsize').removeClass('winlargesize')
										.addClass('win'+curSize)
										.fireEvent('winsizechanged', {'lastSize': _lastSize, 'currentSize': curSize})
		
		//var baseDiv = $('searchCriteriaOnly');
		var baseDiv = $(baseDivId);
		baseDiv.getElements('input[' + curSize + ']').each( 
		               function(el){ el.setProperty('size', el.getProperty(curSize)) } );	


		_lastSize	= curSize;
	}
}


function escapeCriteria(dmql)
{
	var str = escape(dmql);
	str = str.replace(/\%28/g, "(");
	str = str.replace(/\%29/g, ")");
	str = str.replace(/\%3D/g, "=");
	return str.replace(/\+/g, "%2b");
}

function loadPage(xNode)
{
	loadMainPage(xNode);
	var mNode = xNode.getAttribute("menu");
	if (mNode)
	{
		mainvmbuilder.xmlobject = tasklist.xmlobject;
		mainvmbuilder.buildmenu(mNode);
	}
}

function pageLocationByNode(xNode)
{
	var owner = xNode.getAttribute("owner");
	if (!owner) owner = "MLS";
	var type = xNode.getAttribute("type");
	if (!type) type = "private";
	return pageLocation(owner, type, xNode.text);
}
function pageLocation(owner, type, filename)
{
	var uri;
	if (top.mainWindow.agt.remote)
	{
		uri = top.mainWindow.agt.valetDirectoryURL(owner,type, "read", filename);
	}
	else
	{
		uri = top.mainWindow.agt.getOwnerDirectory(owner, type)	+ "/" + filename;
	}
	return convertTokens(uri);
}

function loadMainPage(xNode)
{
	var uri = "";
	var filename = xNode.text;
	var owner = xNode.getAttribute("owner");
	if (owner)
	{
		var type = xNode.getAttribute("type");
		if (type)
		{
			uri = pageLocation(owner, type, filename);
		}
	}
	
	if (uri == "") uri = filename;
	else uri = convertTokens(uri);
	uri = convertTokens(uri);
	document.all("maindisplay").src = uri;
	
	_menuHelp = xNode.parentNode.selectSingleNode("HELP");			//Find menu-level help
}

function buildFileName(initialString)
{
	re = /['%#!~`]/g;
	var newStr = initialString.replace(re, "");
	return newStr;
}

function debugAlert(msg)
{
	alert(msg);
}

function hhmmss(dt)
{
	var hours = dt.getHours();
	var minutes = dt.getMinutes();
	var seconds = dt.getSeconds();
	var retValue = "";
	if (hours < 10) retValue += "0";
	retValue += hours.toString() + ":";
	if (minutes < 10) retValue += "0";
	retValue += minutes.toString() + ":";
	if (seconds < 10) retValue += "0";
	retValue += seconds.toString();
	return retValue;
}

function dateToText(passedDate, passedformat)
{
	var str;
	var hours;
	var minutes;
	var seconds;
	var format;

	var dt = passedDate;
	if (passedformat == "UTC")
	{
		dt.setMinutes(dt.getMinutes()+dt.getTimezoneOffset());
	}
	try
	{
		hours = dt.getHours();
		minutes = dt.getMinutes();
		seconds = dt.getSeconds();
	}
	catch(e)
	{
		return "";
	}
	if (!passedformat) format = top.mainWindow.agt.dateformat;
	else format = passedformat;
	
	format = format.toUpperCase();
	if (format == "ACCESS") format = top.mainWindow.agt.dateformat + "SECONDS";

	var meridian = "AM";
	if (hours >= 12) meridian = "PM";
	switch (format)
	{
		case "AMERICAN":
		case "AMERICANSECONDS":
			str = (dt.getMonth() + 1) + "/" + dt.getDate() + "/" + dt.getFullYear();
			if ((hours > 0) | (minutes > 0))
			{
				if (hours > 12) hours = hours -12;
				if (hours < 10) str += " 0" + hours.toString();
				else str += " " + hours.toString();
				if (minutes < 10) str += ":0" + minutes.toString();
				else str += ":" + minutes.toString();
				if (format == "AMERICANSECONDS")
				{
					if (seconds < 10) str += ":0" + seconds.toString();
					else str += ":" + seconds.toString();
				}
				str += " " + meridian;
			}
			break;

		case "EUROPEAN":
		case "EUROPEANSECONDS":
			str = dt.getDate() + "/" + (dt.getMonth() + 1) + "/" + dt.getFullYear();
			if ((hours > 0) | (minutes > 0))
			{
				if (hours > 12) hours = hours -12;
				if (hours < 10) str += " 0" + hours.toString();
				else str += " " + hours.toString();
				if (minutes < 10) str += ":0" + minutes.toString();
				else str += ":" + minutes.toString();
				if (format == "EUROPEANSECONDS")
				{
					if (seconds < 10) str += ":0" + seconds.toString();
					else str += ":" + seconds.toString();
				}
				str += " " + meridian;
			}
			break;

		case "UTC":
		case "ISO":
			str = dt.getFullYear() + "-";
			if (dt.getMonth() < 9) str += "0";
			str += (dt.getMonth() + 1) + "-" 
			if (dt.getDate() < 10) str += "0";
			str += dt.getDate();
			if (hours < 10) str += "T0" + hours.toString();
			else str += "T" + hours.toString();
			if (minutes < 10) str += ":0" + minutes.toString();
			else str += ":" + minutes.toString();
			if (seconds < 10) str += ":0" + seconds.toString();
			else str += ":" + seconds.toString();
			break;
			
			/********************************
			*			Handle YY/MM/DD HH:MM:SS
			*						YYYY/MMM
			********************************/
		default:
			str = passedformat;
			
			var mon = dt.getMonth();
			var months = "JanFebMarAprMayJunJulAugSepOctNovDec";
			var xstr = "0" + (mon +1).toString();
			xstr = xstr.substring(xstr.length-2, xstr.length);
			str = str.replace(/MMM/i, months.substring(mon*3, (mon+1)*3));
			str = str.replace(/NN/i, xstr);
			
			var year = dt.getFullYear().toString();
			str = str.replace(/YYYY/i, year);
			str = str.replace(/YY/i, year.substring(2,4));
			
			xstr = "0" + dt.getDate().toString();
			xstr = xstr.substring(xstr.length-2, xstr.length);
			str = str.replace(/DD/i, xstr);
			
			var hrs = dt.getHours();
			if (str.match(/PP/i))
			{
				if (hrs < 12) str.replace(/PP/i, "AM");
				else
				{
					str.replace(/PP/i, "PM");
					hrs = hrs - 12;
				}
			}
			xstr = "0" + hrs.toString();
			xstr = xstr.substring(xstr.length-2, xstr.length);
			str = str.replace(/HH/, xstr);

			if (hrs > 12) xstr = "0" + (hrs-12).toString();
			else xstr = "0" + hrs.toString();
			xstr = xstr.substring(xstr.length-2, xstr.length);
			str = str.replace(/hh/, xstr);
						
			xstr = "0" + dt.getMinutes().toString();
			xstr = xstr.substring(xstr.length-2, xstr.length);
			str = str.replace(/MM/, xstr);
						
			xstr = "0" + dt.getSeconds().toString();
			xstr = xstr.substring(xstr.length-2, xstr.length);
			str = str.replace(/SS/, xstr);
						
	}
	//alert("originalDate=" +passedDate + "\r\npassedformat=" + passedformat + "\r\nnew date=" + str + "\r\nagent date format=" + top.mainWindow.agt.dateformat);
	return str;
}

function textDateToISO(dateText)
{
	var dt = textToDate(dateText);
	return dateToText(dt, "ISO");
}

/****************************************
*		Convert an ISO string to a date			*
*		object, but leave it in UTC time.		*
****************************************/
function ISOTextToUTC(datetext)
{
	//2005-03-06T11:23:00
	//0123456789 12345678

	return new Date(parseInt(datetext.substring(0,4),10),
									parseInt(datetext.substring(5,7),10) -1,
									parseInt(datetext.substring(8,10),10),
									parseInt(datetext.substring(11,13),10),
									parseInt(datetext.substring(14,16),10),
									parseInt(datetext.substring(17,19),10));
}
function textToDate(datetext, format)
{
	var regwithtime;
	var regdateonly;
	var re;	
	var matchArray;
	var month,day,year,hours,minutes, seconds;


	/******************************************
	*			Decide if this is a relative date		*
	******************************************/
	re = new RegExp("\\s*(now|today|yesterday|tomorrow|utc){1}\\s*([-+]{0,1})\\s*(\\d*)\\s*((year|month|week|day|hour|minute|second){1}(s){0,1})*$","i");
	matchArray = datetext.match(re);
	if (matchArray)
	{
		dt = new Date();		//Get the current date/time
		switch(matchArray[1].toUpperCase())
		{
			case "TODAY":
				dt.setHours(0,0,0,0);
				break;
				
			case "YESTERDAY":
				dt.setDate(dt.getDate()-1);
				dt.setHours(0,0,0,0);
				break;
			case "TOMORROW":
				dt.setDate(dt.getDate()+1);
				dt.setHours(0,0,0,0);
				break;
			case "UTC":
				var tz = dt.getTimezoneOffset();
				dt.setMinutes(dt.getMinutes()+tz);
				break;
		}
		var units = parseInt(matchArray[3], 10);		//Today + 3, Yesterday - 5
		if (!isNaN(units))
		{
			if (matchArray[2] == "-") units = units * -1;			//User entered a minus sign
			switch (matchArray[5].toUpperCase())
			{
				case "DAY":			dt.setDate(dt.getDate()+units);						break;
				case "WEEK":		dt.setDate(dt.getDate()+(units*7));				break;
				case "MONTH":		dt.setMonth(dt.getMonth()+units);					break;
				case "YEAR": 		dt.setFullYear(dt.getFullYear()+units);		break;
				case "HOUR":		dt.setHours(dt.getHours()+units);					break;
				case "MINUTE":	dt.setMinutes(dt.getMinutes()+units);			break;
				case "SECOND":	dt.setSeconds(dt.getSeconds()+units);			break;
				default:				dt.setDate(dt.getDate()+units);						break;		//treat as days
			}
		}
		dt.setHours(dt.getHours(), dt.getMinutes(), dt.getSeconds(), 1);			//Flag 		
		return dt;
	}
	

	/******************************************
	*			Not a relative date. Try absolute		*
	******************************************/
	if (!format) 
	{
		var re = new RegExp(isoRegExp);
		if (re.test(datetext)) format = "ISO";
		else format = top.mainWindow.agt.dateformat;	
	}
	var adjustTimeZone = false;
	hours = minutes = seconds = 0;
	switch (format)
	{
		case "EUROPEAN":
			re = new RegExp(AmericanDateTime);
			matchArray = datetext.match(re);
			if (matchArray)
			{
				if (matchArray[4].length > 0)
				{
					var hsegs = matchArray[4].split(":");
					hours = parseInt(hsegs[0], 10);
					if (hsegs.length > 1) minutes = parseInt(hsegs[1], 10);
					if (hsegs.length > 2) seconds = parseInt(hsegs[2], 10);
					if (matchArray.length > 5)
					{
						re = /\s*PM/i;
						if (re.test(matchArray[5]))
						{
							if (hours < 12) hours += 12;
						}
					}
				}
				day = parseInt(matchArray[1], 10);
				month = parseInt(matchArray[2], 10);
				year = parseInt(matchArray[3], 10);
			}
			else return null;
			break;

		case "UTC":
		case "ISO":
			re = new RegExp(ISODateTime);
			matchArray = datetext.match(re);
			if (matchArray)
			{
				hours = parseInt(matchArray[6], 10);
				minutes = parseInt(matchArray[7], 10);
				if ((matchArray.length > 8) && (matchArray[9].length > 0))
					seconds = parseInt(matchArray[9], 10);
				if (format == "UTC") adjustTimeZone = true;
			}
			else
			{
				re = new RegExp(ISODateOnly);
				matchArray = datetext.match(re);
				if (!matchArray) 
				{
					alert(datetext + " is not an ISO date");
					// +"\ntextToDate called from " + textToDate.caller);
					return null;
				}
				hours = 0;
				minutes = 0;
			}
			year = parseInt(matchArray[2], 10);
			month = parseInt(matchArray[3], 10);
			day = parseInt(matchArray[4], 10);
			break;

		case "AMERICAN":
		default:
			re = new RegExp(AmericanDateTime);
			matchArray = datetext.match(re);
			if (matchArray)
			{
				if (matchArray[4].length > 0)
				{
					var hsegs = matchArray[4].split(":");
					hours = parseInt(hsegs[0], 10);
					if (hsegs.length > 1) minutes = parseInt(hsegs[1], 10);
					if (hsegs.length > 2) seconds = parseInt(hsegs[2], 10);
					if (matchArray.length > 5)
					{
						if (pmMask.test(matchArray[5]))
						{
							if (hours < 12) hours += 12;
						}
					}
				}
				month = parseInt(matchArray[1], 10);
				day = parseInt(matchArray[2], 10);
				year = parseInt(matchArray[3], 10);
			}
			else return null;
			break;

	}

	if ((year > 50) & (year < 100)) year += 1900;
	else if (year < 100) year += 2000;

	if (month > 12) return null;
	if (month < 1) return null;
	dt = new Date(year,month-1, day);

	if (adjustTimeZone)
	{
		tz = dt.getTimezoneOffset();
		hours = hours - tz/60;
	}
	dt.setHours(hours, minutes, seconds, 0);		//We never do milliseconds
	return dt;
}

/****************************
*		Express a date object		*
*		as a relative date.			*
****************************/
function dateToRelative(dateobj)
{
	var diff;
	var i,j;
	var dt = new Date();				//Current date and time
	dt.setHours(0,0,0,0);				//Make it midnight
	var rd = new Date(dateobj.getFullYear(), dateobj.getMonth(), dateobj.getDate(), 0, 0, 0, 0);
	
	/************************************
	*		If this is the same day of the 	*
	*		month, express the increment		*
	*		as MONTH or YEAR								*
	************************************/
	if (rd.getDate() == dt.getDate())		//Same day of the month?
	{
		diff = ((rd.getFullYear()*12) + rd.getMonth()) - ((dt.getFullYear()*12) + dt.getMonth()) ;
		if (diff == 0) return "TODAY";
		i = Math.floor(diff/12);
		if (i*12 == diff)
		{
			if (i == 1) return "TODAY + " + i.toString() + " YEAR";
			if (i > 1)  return "TODAY + " + i.toString() + " YEARS";
			if (i == -1) return "TODAY " + i.toString() + " YEAR";
			return "TODAY " + i.toString() + " YEARS";
		}
		if (diff == 1) return "TODAY + " + diff.toString() + " MONTH";
		if (diff > 1)  return "TODAY + " + diff.toString() + " MONTHS";
		if (diff == -1) return "TODAY " + diff.toString() + " MONTH";
		return "TODAY " + diff.toString() + " MONTHS";
	}

	/************************************
	*		Decide if the difference is			*
	*		a multiple of seven.						*
	************************************/
	var dif = rd.getTime() - dt.getTime();
	var days = Math.floor((dif/(24*60*60*1000)) + .01);		//Number of days
	i = Math.floor(days/7);
	if (i*7 == days)
	{
		if (i == 1) return "TODAY + " + i.toString() + " WEEK";
		if (i > 1)  return "TODAY + " + i.toString() + " WEEKS";
		if (i == -1) return "TODAY " + i.toString() + " WEEK";
		return "TODAY " + i.toString() + " WEEKS";
	}

	if (days == 1) return "TODAY + 1 DAY";
	if (days > 1)  return "TODAY + " + days.toString() + " DAYS";
	if (days == -1) return "YESTERDAY";
	return "TODAY " + days.toString() + " DAYS";
	
}

/**********************************************
*			Agent files can be stored locally, or		*
*			they can be stored on the host.					*
*			local = p24/weeks/
*			remote = http://domain/p24/vo.srf?type=apr&id=weeks&id=weeks:pweb/
**********************************************/
function userFileDirectory(agentObject)
{
	var URL;
	if (!agentObject.remote) 
	{
		URL = agentObject.userdirectory;
	}
	else 
	{
		URL = agentObject.baseurl + 
		"vo.srf?type=apr&id=" + agentObject.agentid + ":" + agentObject.appname + "/";
	}
	return URL;
}

function baseDirectoryURL(agentObject)
{
	var URL;
	if (!agentObject.remote) 
	{
		URL =  agentObject.site + "/";
	}
	else 
	{
		URL =  agentObject.site + "/";
	}
	return URL;
}

function convertTokens(passedValue, optionalParmeterList)
{
	var parms;
	var token;
	try
	{
		var val = passedValue;
		var re = /^.*({.*})/
		while (re.test(val))
		{
			parms = val.match(re);
			token = convertToken(parms[1], optionalParmeterList);
			if (token == parms[1]) break;
			val = val.replace(parms[1], token);
		}
		
	  return val;
	}
	catch(e)
	{
		alert("Error in convertTokens:" +
			"\nValue to convert: " + passedValue +
			"\nValue so far: " + val +
			"\nLast token: " + token +
			"\nparms[0]: " + parms[0] +
			"\n" + e);
		debugger;
	}
}


function convertToken(token, optionalParameterList)
{
	var result=token;
  valsets=token.match(/{\s*(\w+).?([^\.]+)?.?(\w+)?.?(\w+)?(.\w+)?\s*}/);
	if (!valsets) return token;
	var tokenType=valsets[1];
	switch(tokenType.toLowerCase())
	{
		case "parameter":
			var txt = optionalParameterList;
			if (!txt) txt = top.ourWindow.parameters;
			if (txt != null)
			{
				if (txt.length > 0)
				{
					re = new RegExp("[\\=\\?\\&\\;]" + valsets[2] + "=([^\\&\\;]+)", "i");
					if (re.test(txt))
					{
						var matches = txt.match(re);
						result = matches[1];
					}
				}
			}
			break;
			
		/************************************
		*		Caller wants a field value.			*
		*		If they want the original or		*
		*		default values, get those				*
		*		from the update rules.  The			*
		*		form may still be loading, and	*
		*		these values may not be set.		*
		************************************/
		case "field":
		  var fldName=valsets[2].toUpperCase();
		  if (fldName == "CURRENT") 
		  {
		  	if (_currentField) fldName = _currentField.toUpperCase();
		  }
		  var valueType=valsets[3].toLowerCase();
		  if ((valueType != "original") & (valueType != "default"))
		  {
			  var elem=document.getElementById(fldName);		//Look for a <vds:xxx id='fieldname'/>
			  if (elem) 
			  {
			  	result=elem.currentvalue;
			  }
			}
			
			if ((result == null) | (result==token))
			{
				
				if (_updateSet)
				{
					elem = _updateSet.businessrules.selectSingleNode("//RULE[@field='" + fldName + "']");
					if (elem)
					{
						var xNode;
					  switch(valueType.toLowerCase())
					  {
					  	case "original":
					  		xNode = elem.selectSingleNode("ORIGINAL");
					  	  break;
					  	case "default":
					  		xNode = elem.selectSingleNode("DEFAULT");
					  	  break
					  	case "value":
					  	default:
					  		xNode = elem.selectSingleNode("CURRENT");
					  	  break;
					  }
						if (xNode) result = xNode.text;
					}
					else
						{
							alert("Didn't find field name " + fldName + " to replace the token\n" + token);
						}
				}
			}
			
			break;
		case "date":
			var dt=textToDate(valsets[2]);		//Convert to date
			result = dateToText(dt);
			break;

		case "config":
		case "configuration":
			var dNode = top.mainWindow.agt.confignode.selectSingleNode(valsets[2].toUpperCase());
			if (dNode) result = dNode.text;
			else result = "Configuration is missing "+valsets[2];
			break;
		case "agent":
			switch(valsets[2].toUpperCase())
			{
				case "ID":
					result = top.mainWindow.agt.agentid;
					break;
				case "PERMISSIONS":
					result = top.mainWindow.agt.permissions;
					break;
				case "LEVEL":
					result = top.mainWindow.agt.level;
					break;
				case "PASSWORD":
					result = top.mainWindow.agt.password;
					break;				
				case "SESSIONID":
					result = top.mainWindow.agt.sessionid;
					break;	
				default:
					var xNode = top.mainWindow.agt.loginobject.xmlobject.selectSingleNode("//LOGIN/" + valsets[2]);
					if (!xNode) xNode = top.mainWindow.agt.loginobject.xmlobject.selectSingleNode("//" + valsets[2]);
					if (!xNode) 
					{
						result = "PWEBLogin.srf is missing " + valsets[2];
						//alert("DEBUG: did not find //LOGIN/" + valsets[2] + " in\n" + top.mainWindow.agt.preferences.xml);
					}
					else result = xNode.text;
					break;
			}
		  break;
	}

	return result;
}

function valetPrompt(msg, defaultValue, ok, cancel, dialog)
{
	var sts;
	var pObj = new Object();
	pObj.message = msg;
	if (ok) pObj.ok = ok;
	else pObj.ok = "OK";
	pObj.cancel = cancel;
	if (defaultValue) pObj.value = defaultValue;
	else pObj.value = "";
	
	if (dialog) sts = top.showModalDialog("prompt.htm", pObj, dialog);
	else sts = top.showModalDialog("prompt.htm", pObj, "dialogHeight:100px;dialogWidth:400px;status:no;unadorned:yes;resizable:yes");
	var retValue = pObj.value;
	delete pObj;
	if (!sts) return "";
	return retValue;
}
function valetConfirm(msg, ok, cancel, dialog)
{
	var sts;
	var pObj = new Object();
	pObj.message = msg;
	if (ok) pObj.ok = ok;
	else pObj.ok = "OK";
	pObj.cancel = cancel;
	
	if (dialog) sts = top.showModalDialog("confirmation.htm", pObj, dialog);
	else sts = top.showModalDialog("confirmation.htm", pObj, "dialogHeight:100px;dialogWidth:300px;status:no;unadorned:yes;resizable:yes");
	delete pObj;
	return sts;
}

function valetProgressCreate(msg, cancel, dialogWindowSettings)
{
	if (progressWindow) valetProgressComplete();
	progressWindow = new Object();
	progressWindow.cancel = cancel;				//Text string
	progressWindow.closeStatus = "none";
	if (dialogWindowSettings) progressWindow.dialogWindowSettings = dialogWindowSettings;
	else progressWindow.dialogWindowSettings = "height=300,width=400,resizeable=yes,toolbar=no,menubar=no,location=no";
		
	progressWindow.window = top.open("", "progressWindow", progressWindow.dialogWindowSettings);
	valetProgressUpdate(msg);
	return progressWindow;
}

function valetProgressUpdate(msg)
{
	if (progressWindow != null) 
	{
		var wmsg = "<html>";
		wmsg += "<head>";
		wmsg += "<title>Progress</title><STYLE>@import:url(../styles/commonStyles.css);</STYLE>";
		wmsg += "</head>";

		wmsg += "<body>";
		wmsg += "<div>" + msg + "</div>";
		wmsg += "<hr /><br/>";
		if (progressWindow.cancel)
		{
			wmsg += "<table width='100%' cellpadding='5' cellspacing='1' id='buttonsTable'>";
			wmsg += "<tr>";
			wmsg += "<td align='center' id='cancelButtonCell'><button id='CancelButton' onclick='window.close()'>Cancel</button></td>";
			wmsg += "</tr>";
			wmsg += "</table>";
		}		
		wmsg += "</body>";
		wmsg += "</html>";
		
		progressWindow.window.document.open();
		progressWindow.window.document.write(wmsg);
		progressWindow.window.document.close();
	}
	return progressWindow;
}

function valetProgressComplete()
{
	if (progressWindow == null) return;
	if (progressWindow.window)
	{
		try
		{
			progressWindow.window.close();
		}
		catch(err) {};
	}
	delete(progressWindow);
	progressWindow = null;
	return;
}

/***************************************************************
*			Read a message format string from the messages file.
*			Build output from the format and the passed parameters.
****************************************************************/
function messageText(messageId, defaultMessageText, paramArray)
{
	return windowMessageText(top.mainWindow, messageId, defaultMessageText, paramArray);
}

/********************************************
*		Use this routine if messagelist is not
*		in top.mainWindow - for example, if you
*		are calling this from a dialog window.
*********************************************/
function windowMessageText(wnd, messageId, defaultMessageText, paramArray)
{
	var paramName;
	var paramValue;
	var msg = defaultMessageText;
	var mNode = wnd.messagelist.xmlobject.selectSingleNode("//MESSAGE[@id=\"" + messageId + "\"]");
	if (mNode) msg = mNode.text;
	
	msg = convertTokens(msg);
	if (paramArray)
	{
		for (var pp=0; pp<paramArray.length; pp++)
		{
			var match = paramArray[pp].match(/[\=\:]/);
			if (match)
			{
				paramName = RegExp.leftContext;
				paramValue = RegExp.rightContext;
			}
			else
			{
				paramName = paramArray[pp];
				paramValue = "";
			}
			var re = RegExp("{" + paramName + "}", "i");
			msg = msg.replace(re, paramValue);
		}
	}
	return msg;

}

function valetAlert(msg, ok, dialog)
{
	var sts;
	var pObj = new Object();
	pObj.message = msg.replace(/\\r\\n/g, "<br/>");
	if (ok) pObj.ok = ok;
	else pObj.ok = "OK";
	pObj.cancel = null;
	
	if (dialog) sts = top.showModalDialog("confirmation.htm", pObj, dialog);
	else sts = top.showModalDialog("confirmation.htm", pObj, "dialogHeight:100px;dialogWidth:300px;status:no;unadorned:yes;");
	delete pObj;
	return sts;
}

function resizeWindow(wnd, size)
{
	if (size.toUpperCase() == "MAXIMIZE")
	{
		if (_originalValuesSet)
		{
			top.dialogHeight = _originalHeight;
			top.dialogWidth = _originalWidth;
			top.dialogTop = _originalTop;
			top.dialogLeft = _originalLeft;
			_originalValuesSet = false;
		}
		else
		{
			_originalHeight = top.dialogHeight;
			_originalWidth = top.dialogWidth;
			_originalTop = top.dialogTop;
			_originalLeft = top.dialogLeft;
			_originalValuesSet = true;
	
			wnd.dialogHeight = screen.availHeight-5;
			wnd.dialogWidth = (screen.availWidth-5).toString() + "px";;
			wnd.dialogTop = 0;
			wnd.dialogLeft = 0;
		}
	}
	else
	{
		wnd.dialogHeight = _originalHeight;
		wnd.dialogWidth = _originalWidth;
		wnd.dialogTop = _originalTop;
		wnd.dialogLeft = _originalLeft;
	}
	
}

/********************************************
*		User clicked on the HELP menu item.
*		If the page itself contained a <HELP>
*		tag, the library name and topic are
*		passed to us.
********************************************/
function showPageHelp(libraryName, topic)
{
	var hNode;
	var helpLibrary = "valethelp/valethelp.xml";					//Library of last resort
	var helpTopic = "valethelp/gettingstarted.htm";				//Topic of last resort

	if (libraryName != null) helpLibrary = libraryName;
	if (topic != null) helpTopic = topic;
	
	if (_menuHelp)
	{
		hNode = _menuHelp.selectSingleNode("LIBRARY");
		if (hNode) helpLibrary = hNode.text;
		hNode = _menuHelp.selectSingleNode("TOPIC");
		if (hNode) helpTopic = hNode.text;
		else helpTopic = null;
	}

//	alert("helpLibrary=" + helpLibrary + "\nhelpTopic=" + helpTopic +		"\nlibraryName=" + libraryName +		"\ntopic=" + topic)

	var pObj = new Object();
	pObj.library = helpLibrary;
	pObj.topic = helpTopic;
	pObj.httpobj = top.mainWindow.loginHelpObject;
	top.showModalDialog("helpPage.htm", pObj, "dialogHeight:500px;dialogWidth:600px;status:no;resizable:yes;");
	
	
}

/**************************************
*		Be sure all the folders required	*
*		to store a file actually exist.		*
*																			*
*		fspec is the full file name, not	*
*		just the directory.								*
*																			*
**************************************/
function checkForFolder(fspec)
{
	var lspec = unescape(fspec).replace(/\\/g, "/");
	var segs = lspec.split("/");
	var dirName = segs[0];
	idx = 0;
	if (dirName.indexOf(":") > 0)
	{
		dirName += "\\" + segs[1];
		idx = 1;
	}
	try
	{
		while (idx < segs.length-1)
		{
			if (!top.mainWindow.fso.FolderExists(dirName))
			{
				top.mainWindow.logConsole("Creating folder " + dirName);
				top.mainWindow.fso.CreateFolder(dirName);
			}
			idx++;
			dirName += "\\" + segs[idx];
		}
	}
	catch(e)
	{
		top.mainWindow.logConsole("Unable to create the folder " + dirName + "\n" + e);
		top.mainWindow.valetAlert("Unable to create the folder " + dirName + "\n" + e);
		return false;
	}
	return true;
}

/****************************************
*		Retrieve a file from the host and		*
*		write it to the corresponding 			*
*		directory here on the PC						*
****************************************/
function getOneFile(relativeFileName, savelevel, filetype, MimeType)
{
	var uri = top.mainWindow.agt.valetDirectoryURL(savelevel, filetype,"read");
	uri += "&object=" + relativeFileName;
	var fName = top.mainWindow.agt.getOwnerDirectory(savelevel, filetype);
	fName += "/" + relativeFileName;
	fName = unescape(fName).replace(/\//g, "\\");
	return retrieveSingleFile(uri, fName, true, savelevel, filetype, relativeFileName, MimeType);
}

function retrieveSingleFile(inputURI, outputFileSpec, updateSynchFile, savelevel, filetype, relativeFileName, MimeType)
{

	var getFile = top.mainWindow.getFileObject.vdsobj;
	getFile.createObject(inputURI);
	
	var fileRead = true;
	var errmsg = "";
	var newFileCreated = false;
	var outFile = null;						//Output object for text file
	try
	{
		getFile.load("GET", inputURI, false);
		if (!getFile.status)
		{
			fileRead = false;
			errmsg = "HTTP read status=" + getFile.statuscode + " " + getFile.statustext;
		}
	}
	catch(e)
	{
		fileRead = false;
		errmsg = "Unable to retrieve " + inputURI + "\r\n" + e;
	}
	
	/**************************************
	*		If we managed to download the 		*
	*		file, write the file here.				*
	**************************************/
	if (fileRead)
	{
		var textFile = true;				//Assume it is a text file
		//try
		{
			var fName = unescape(outputFileSpec).replace(/\//g, "\\");
			checkForFolder(fName);

			if (MimeType)
			{
				if (MimeType.match(/(image|access)/i)) textFile = false;
			}
			else
			{
				textFile = asciiFileExtensions.test(fName);			//Decide if this is an ascii file
				//if (fName.match(/\.(jpg|jpeg|bmp|gif|mdb|xls|ico|pdf)$/i)) textFile = false;
			}			
			if (textFile)
			{
				fName = fName.replace(/\\/g, "/");
				outFile = top.mainWindow.fso.CreateTextFile(fName, true);
				newFileCreated = true;
				
				/******************************************
				*			Norton Anti-Virus pop-up blocker		*
				*			adds several JavaScript functions.	*
				*			This code removes them.							*
				******************************************/
				var txt = getFile.httpobj.responseText;
				var count = 0;
				if (fName.match(/\.(js|htm|html)$/))
				{
					var off = txt.indexOf("<scr" + "ipt");
					while (off >= 0)
					{
						var eoff = txt.indexOf("</scr" + "ipt>", off);
						if (eoff < 0) break;
						subtxt = txt.substring(off, eoff+9);
						
						if (subtxt.match(  /function\s+(SymOnUnload|SymError)\(\)/  ) )
						{
							txt = txt.replace(subtxt, "");
							off = txt.indexOf("<scr" + "ipt", off);
						}
						else off = txt.indexOf("<scr" + "ipt", eoff);
						if (count++ > 10) break;
					}
				}
				//top.mainWindow.copyToClipboard(txt);
				outFile.Write(txt);
				outFile.Close();
				
				if (fName.match(/objects.xml$/))
				{
					alert("Reloading objects");
					top.mainWindow.agt.reloadObjects();
				}
			}
			else
			{
				var aStream = new ActiveXObject('ADODB.Stream');
				aStream.Type = 1;			//adTypeBinary
				aStream.Open();
				aStream.Write(getFile.httpobj.responseBody);
				track = "Line 983";
				aStream.SaveToFile(fName, 2);					//2=adSaveCreateOverWrite
				track = "Line 985";
				newFileCreated = true;
				aStream.Close();
				track = "Line 988";
				delete(aStream);
			}
		}
		//catch(err)
		//{
//			errmsg = "Error writing the new file 2: " + fName;
	//		if (MimeType) errmsg += "\n\tMimetype=" + MimeType;
		//	errmsg += "\r\n\ttextFile flag=" + textFile + "\n\t"  +
			//	"\r\n" + err + "\r\n" + track;
			//fileRead = false;
		//}
		/************************************
		*		If we tried to create a file,
		*		but failed to finish it, delete 
		*		the partially saved file.
		************************************/
		if ((newFileCreated == true) & (fileRead == false))
		{
			fName = fName.replace(/\\/g, "/");
			valetAlert("Deleting " + fName + " because we tried to download it without success");
			try
			{
				if (outFile != null) outFile.Close();
				top.mainWindow.fso.DeleteFile(fName);
			}
			catch(e)
			{
				alert("Unable to delete " + fName + 
				"\nThis file has been corrupted");
			}
		}
				
		/***********************************
		*		If the calling routine asked,
		*		update the SynchTimes.xml file.
		************************************/
		if (fileRead) fileRead = updateSynchFile;
		if (fileRead) updateSynchTimes(savelevel, filetype, relativeFileName);
	}
	return errmsg;
}

/******************************************
*		When we have successfully downloaded
*		a file, update the entry in SynchTimes.xml
*		so that we do not update it again.
**************************************************/
function updateSynchTimes(savelevel, filetype, relativeFileName)
{
	//var prefNode = top.mainWindow.getSynchronizationNode(savelevel, filetype);
	var prefNode = top.mainWindow.getSynchronizationConsortiumNodeByName(savelevel, filetype);
	if (prefNode) 
	{
		var uri = "//FILE[FILENAME $ieq$ '" + relativeFileName + "']";
		uri = uri.replace(/\\/g, "\\\\");
		var hNode = top.mainWindow.hostDirectory.xmlobject.selectSingleNode(uri);
		if (hNode)
		{
			var taskObj = new Object();
			taskObj.fileoperation = "Manual";
			taskObj.fileName = relativeFileName;
			taskObj.status = "Download";
			taskObj.reason = "User asked for the file to be downloaded";
			taskObj.index = -1;
			taskObj.savelevel = savelevel;			//consortium name
			taskObj.filetype = filetype;
			top.mainWindow.addSynchNode(taskObj);
		}
	}
}
/****************************************
*		Retrieve a file from the host and		*
*		write it to the corresponding 			*
*		directory here on the PC						*
****************************************/
function compareOneFile(relativeFileName, savelevel, filetype, MimeType)
{
	var uri = top.mainWindow.agt.valetDirectoryURL(savelevel, filetype,"read");
	uri += "&object=" + relativeFileName;

	var fName = top.mainWindow.agt.basedirectory + "temp/" + relativeFileName;
	fName = unescape(fName).replace(/\//g, "\\");
	var localFile = top.mainWindow.agt.getOwnerDirectory(savelevel, filetype) + "\\" + relativeFileName;
	localFile = unescape(localFile).replace(/\//g, "\\");
	var errmsg = retrieveSingleFile(uri, fName, false, savelevel, filetype, relativeFileName, MimeType);
	if (errmsg.length == 0)
	{
		_compareObject = new Object();
		_compareObject.localFile = localFile;
		_compareObject.fName = fName;
		_compareObject.cmd = "FC";
		_compareObject.savelevel = savelevel;
		_compareObject.relativeFileName = relativeFileName;
		_compareObject.filetype = filetype;
		
		var afe = /\.(css|js|hta|htc|htm|html|inc|log|txt|xml|xsl)\s*$/i;

		if (afe.test(localFile))			//Decide if this is an ascii file
		{
			_compareObject.cmd += " /N";
		}
		else _compareObject.cmd += " /B";
		_compareObject.cmd += " \"" + localFile + "\" \"" + fName + "\"";
		_compareObject.count = 0;
		_compareObject.difText = "";
		_compareObject.errText = "";
		try
		{
			_compareObject.wsh = new ActiveXObject("WScript.Shell");
			_compareObject.oExec = _compareObject.wsh.Exec(_compareObject.cmd);
			top.setTimeout(finishCompareOneFile, 100);
		}
		catch(err)
		{
			errmsg = "Error running File Compare\r\n" + cmd + "\r\n" + err;
			delete _compareObject;
		}
	}
	return errmsg;
}

function finishCompareOneFile()
{
	if (_compareObject == null) return;
	if (_compareObject.count++ < 100)
	{
		while (!_compareObject.oExec.StdOut.AtEndOfStream)
		{
			_compareObject.difText += _compareObject.oExec.stdOut.ReadLine() + "\r\n";
		}
		while (!_compareObject.oExec.StdErr.AtEndOfStream)
		{
			_compareObject.errText += _compareObject.oExec.stdErr.ReadLine() + "\r\n";
		}
	}
	
	if (_compareObject.oExec.Status == 0)
	{
			top.setTimeout(finishCompareOneFile, 100);
			return;
	}

	//alert("Error=" + _compareObject.errText + "\r\nOutput=" + _compareObject.difText);
	try
	{
		var txt = _compareObject.cmd + 
			"\r\ncount=" + _compareObject.count + 
			"\r\nError=" + _compareObject.errText +
			"\r\ndifText.length=" + _compareObject.difText.length +
			"\r\n" + _compareObject.difText;
		top.mainWindow.copyToClipboard(txt);
		if (_compareObject.difText.indexOf("no differences encountered") >= 0)
		{
			alert("Files match");
			var uri = "//FILE[FILENAME='" + _compareObject.relativeFileName.replace(/\\/g, "\\\\") + "']";
			updateSynchTimes(_compareObject.savelevel, _compareObject.filetype, _compareObject.relativeFileName);
			var dNode = pObj.hd.xmlobject.selectSingleNode(uri);
			if (dNode)
			{
				dNode.setAttribute("replace", "FilesMatch");
				dNode.setAttribute("replaceReason", "File comparison");
				rebuildDisplay();
			}
			else 
			{
				top.mainWindow.copyToClipboard(pObj.hd.xmlobject.xml);
				alert("Did not find " + uri + "\r\n" + pObj.hd.xmlobject.xml);
			}
		}
		else
		{
			alert("The files do not match.  Check the clipboard for differences");
		}
		_compareObject.difText = "";
	}
	catch(err)
	{
		alert("Error trying to read comparison response\r\n" + err);
	}
	delete _compareObject.wsh;
	delete _compareObject;
	_compareObject = null;	
}

/********************************************
*		Post a file to the host
*			relativeFileName = images\photo.jpg
*			savelevel = Agent, Office, Broker, Company, MLS
*			filetype = private, public
*********************************************/
function postOneFile(relativeFileName, savelevel, filetype)
{
	/**************************************
	*			Find the local file and get			*
	*			the date for that file.					*
	**************************************/
	var filespec = unescape(top.mainWindow.agt.getOwnerDirectory(savelevel, filetype) + "/" + relativeFileName);
	return postFileToHost(filespec, relativeFileName, savelevel, filetype);
}

/********************************************
*		Post a file to the host
*			filespec = full file path of local file
*			relativeFileName = images\photo.jpg
*			savelevel = Agent, Office, Broker, Company, MLS
*			filetype = private, public
*********************************************/
function postFileToHost(filespec, relativeFileName, savelevel, filetype)
{

	var status;
	var statusText;
	var adoStream;
	var errmsg = "";
	var uri = "";
	var fil;
	var fileType;
	try
	{


		/**************************************
		*			Find the local file and get			*
		*			the date for that file.					*
		**************************************/
		if (!top.mainWindow.fso.FileExists(filespec))
		{
			return filespec + " could not be found to upload";
		}
    fil = top.mainWindow.fso.GetFile(filespec);
    fileType = fil.Type;
    cdt = new Date(fil.DateLastModified);
		var tz = cdt.getTimezoneOffset();
		cdt.setHours(cdt.getHours()+tz/60);					//Express date in UTC
    
		/************************************
		*		Open a connection to the host		*
		************************************/
		uri = top.mainWindow.agt.valetDirectoryURL(savelevel,filetype, "post", relativeFileName);
    uri += "&mimetype=text/xml&filedate=" + dateToText(cdt, "ISO");
		errmsg += "\nuri=" + uri;
		var vdsobj = top.mainWindow.postFileObject.vdsobj;		//HTTP object inside tranobj
		vdsobj.createObject(uri);
		vdsobj.setRequestHeader("Content-Type", "application/upload");
    
		/**********************************
		*				Read the local file				*
		*			We read text files using		*
		*			the file object.  We read		*
		*			other files using ADO.			*
		*
		*			If we read text files with ADO and 
		*			stream type adTypeText, they do not 
		*			upload at all.  If we read text
		*			files with ADO and stream type
		*			adTypeBinary, they upload in unicode.
		**********************************/
    errmsg = "";
    try
    {
    	filespec = filespec.replace(/\//g, "\\");
    	errmsg = "filespec=" + filespec;
	    if (asciiFileExtensions.test(filespec))
	    {
	    	errmsg += "\nTrying to read " + filespec;
	    	fil = top.mainWindow.fso.OpenTextFile(filespec);
	    	errmsg += "\nFile opened";
	    	var fileText = fil.ReadAll();
		    errmsg += "\nFile read";
	    	fil.Close();
	    	delete (fil);
		    vdsobj.setRequestHeader("Content-Length", fileText.length);
		    vdsobj.postText(uri, fileText, false);
				errmsg += "\nvdsobj.send completed";
	    }
	    else
	    {
		    adoStream = new ActiveXObject("ADODB.Stream");
		    errmsg += "\nActiveX created correctly";
		    adoStream.Mode = 3; // adModeReadWrite
		    adoStream.Type = 1; // adTypeBinary
		    adoStream.Open();
		    errmsg += "\nStream opened";
		    adoStream.LoadFromFile(filespec);
		    errmsg += "\nLocal file read by ADO stream";
        vdsobj.setRequestHeader("Content-Length", adoStream.Size);
		    errmsg += "\nContent-Length set to "+adoStream.Size;
		    vdsobj.postStream(uri, adoStream, false);
				errmsg += "\nvdsobj.postStream completed.";
		    delete (adoStream);
		  }
		}
		catch(e)
		{
			return "Error loading " + filespec+ " (" + fileType  + ")" + 
				"\n" + errmsg + "\n" + e;
		}		

		/**************************************************************************
		*				Parse the host response																						*
		*		We use postFileObject.xmlobject instead of vdsobj.httpobj.responseXML	*
		*		because vdsobj.httpobj.responseXML may be a DOMDocument.4.0, which		*
		*		only supports XPATH search syntax.																		*
		**************************************************************************/
		errmsg = "Local file loaded";
		errmsg += "\nvdsobj.status=" + vdsobj.status;
		if (!vdsobj.status)
		{
			errmsg += "\nError uploading " + filespec + " (" + fileType + ")\n";
			errmsg += vdsobj.statustext;
			return errmsg;
		}
		var rXML = top.mainWindow.postFileObject.xmlobject;				
		if (rXML)
		{
			errmsg += "\nrXML was defined";
			var sNode = rXML.selectSingleNode("//span[@id='uploadStatus']");
			if (sNode)
			{
				errmsg += "\ruploadStatus was found: " + sNode.text;
				if (sNode.text != "SUCCESS")
				{
					errmsg += "\nError uploading " + filespec+ " (" + fileType  + ")\n" + sNode.text;
					sNode = rXML.selectSingleNode("//span[@id='uploadStatusMessage']");
					if (sNode) 
					{
						errmsg = "Error uploading " + filespec+ " (" + fileType  + ")";
						errmsg += "\nHost error=" + sNode.text;
					}
					//errmsg += "\nResponse from host:\n" + rXML.xml;
				}
				else
				{
					/****************************************************
					*		If we are posting as part of the resynch				*
					*		process, we need to update the hostDirectory		*
					*		structure as well.  														*
					*																										*
					*		If we are posting individual files (e.g. the		*
					*		setup utility is uploading) the hostDirectory		*
					*		structure will be empty.												*
					*****************************************************/
					errmsg = "";
					//var prefNode = top.mainWindow.getSynchronizationNode(savelevel, filetype);
					var prefNode = top.mainWindow.getSynchronizationConsortiumNodeByName(savelevel, filetype);
					if (prefNode) 
					{
						var uri = "//FILE[FILENAME $ieq$ '" + relativeFileName + "']";
						uri = uri.replace(/\\/g, "\\\\");
						var hNode = top.mainWindow.hostDirectory.xmlobject.selectSingleNode(uri);
						if (hNode)
						{
							var trNodes = top.mainWindow.postFileObject.xmlobject.selectNodes("//table[@id='uploadTable']/tr");
							var tdNodes = trNodes[1].selectNodes("td");
							//top.mainWindow.copyToClipboard("hNode=\n" + hNode.xml +
							//	"\ntrNode = " + trNodes[1].xml +
							//	"\ntdNodes.length=" + tdNodes.length);
							//alert("DEBUG: check clipboard");
							if (tdNodes.length > 4)
							{
								hNode.setAttribute("shmdt", tdNodes[1].text);
								hNode.setAttribute("shcdt", tdNodes[4].text);
								hNode.setAttribute("hmdt", tdNodes[1].text);
								hNode.setAttribute("hcdt", tdNodes[4].text);
								var sNode = hNode.selectSingleNode("MODDATE");
								if (sNode) sNode.text = tdNodes[1].text;
								sNode = hNode.selectSingleNode("CREATEDATE");
								if (sNode) sNode.text = tdNodes[4].text;
							}

							var taskObj = new Object();
							taskObj.fileoperation = "Manual";
							taskObj.fileName = relativeFileName;
							taskObj.status = "Upload";
							taskObj.reason = "User asked for the file to be downloaded";
							taskObj.index = -1;
							taskObj.savelevel = savelevel;			//consortium name
							taskObj.filetype = filetype;
							top.mainWindow.addSynchNode(taskObj);

						}
					}
				}
			}
			else
			{
				errmsg += "\nError uploading " + filespec+  "\n" + 
					"No uploadStatus node in response\n" +
					"\n<br/>Response text is in clipboard";
				top.mainWindow.copyToClipboard(vdsobj.httpobj.responseText);
			}
		}
		else
		{
			errmsg = "Error uploading " + filespec+ "\n" + "Unable to find responseXML object in response";
		}

    return errmsg;
	}
	catch(e)
	{
		return "Generic error posting the file " + filespec + 
			"\n" + uri + 
			"\n" + errmsg + "\n" + e;
	}
}

/********************************************
*		Decide if this site has a page banner		*
********************************************/
function displayPageBanner()
{
	var fileLocation;
	var elem = document.getElementById("pageBannerFrame");
	if (!elem) return;
	fileLocation = top.mainWindow.agt.basedirectory + top.mainWindow.agt.site + "/pageBanner.htm";
	elem.src = fileLocation;
}

/********************************************
*		The page banner has loaded.  Adjust			*
*		all of the settings to make room.				*
********************************************/
function pageBannerLoaded(wnd, hgt)
{
	wnd._pageBannerHeight = hgt;
//	adjustForPageBanner(wnd);
	elem = wnd.document.getElementById("pageBannerFrame");
	if (elem) elem.style.display = "block";
	
	if (!_originalValuesSet)
	{
		_originalHeight = top.dialogHeight;
		_originalWidth = top.dialogWidth;
		_originalTop = top.dialogTop;
		_originalLeft = top.dialogLeft;
		_originalValuesSet = true;
	}
	return;
}

function formatNumber(intValue, formatString)
{
	var str = intValue.toString();
	var outStr = str.substring(str.length-3, str.length);
	while (str.length > 3)
	{
		str = str.substring(0, str.length-3);
		outStr = str.substring(str.length-3, str.length) + "," + outStr;
	}
	outStr = outStr.replace(/\s/g, "");
	return outStr;
}

/***************************************
*			Find a file in the hierarchical
*			list of files.
***************************************/
function findFileInHierarchy(fileName)
{
	var retFileName;
	var hLevels = new Array("Agent", "Office", "Broker", "Company", "MLS");
	if (top.mainWindow.agt.remote)
	{
		for (var hh=0; hh<hLevels.length; hh++)
		{
			retFileName = top.mainWindow.agt.valetDirectoryURL(hLevels[hh], "private","read",fileName);
			if (top.mainWindow.fso.FileExists(retFileName)) return retFileName;
		}
	}
	else
	{
		for (var hh=0; hh<hLevels.length; hh++)
		{
			retFileName = top.mainWindow.agt.getOwnerDirectory(hLevels[hh], "private")	+ "/" + fileName;
			if (top.mainWindow.fso.FileExists(retFileName)) return retFileName;
		}
	}
	return null;
}

/****************************************
*			Some boards want to call items stored
*			at different levels (e.g. searches, 
*			reports, logos, etc.) by different
*			names other than MLS, Agent, Office.
********************************************/
function getLevelName(level)
{
	var uri = "//SYNCHRONIZE/" + level.toUpperCase() + "FILES";
	var lNode = top.mainWindow.agt.preferences.selectSingleNode(uri);
	if (lNode)
	{
		if (lNode.getAttribute("systemname")) return lNode.getAttribute("systemname");		
	}
	return level;
}

/************************************************
*			Find a resource on the data dictionary		*
************************************************/
function findDictionaryNode(resource, className)
{
	if (!top.mainWindow.datadictionary.status) top.mainWindow.reloadDictionary();
	var dNode = top.mainWindow.datadictionary.xmlobject;
	var uri = "//DATADICTIONARY/RESOURCE[@name = '" + resource.toLowerCase() + "'";
	if (className.length > 0) uri += " and @class = '" + className.toLowerCase() + "'";
	uri += "]";
	
	var rNode = dNode.selectSingleNode(uri);
	if (rNode == null)
	{
		if (className.length > 0)
		{
			uri = "//DATADICTIONARY/RESOURCE[@name = '" + resource.toLowerCase() + "'";
			uri += " and @class = '*']";
			rNode = dNode.selectSingleNode(uri);
		}
	}
	
	if (rNode == null)
	{
			uri = "//DATADICTIONARY/RESOURCE[@name = '" + resource.toLowerCase() + "']";
			rNode = dNode.selectSingleNode(uri);
	}
	return rNode;
}



/****************************************************
*			Reset custom styles from user's preferences		*
****************************************************/
function customStyles()
{
	var newStyleSheet;
	var sNode = top.mainWindow.agt.loginobject.xmlobject.selectSingleNode("//PREFERENCES/STYLE");
	if ((sNode) && (sNode.text.length > 0)) resetCustomStyles(sNode.text);
	else resetCustomStyles("");
}

/****************************************************
*			Reset custom styles from a text string				*
****************************************************/
function resetCustomStyles(newText)
{
	var newStyleSheet;
	for (var ss=0; ss<document.styleSheets.length; ss++)
	{
		if (document.styleSheets[ss].title == "userStyles") break;
	}
	
	if (ss >= document.styleSheets.length) 
	{
		if (newText.length == 0) return;			//No new attributes - do not need a new sheet
		newStyleSheet = document.createStyleSheet(null, document.styleSheets.length);
		newStyleSheet.title = "userStyles";
	}
	else newStyleSheet = document.styleSheets[ss];

	while (newStyleSheet.rules.length)  newStyleSheet.removeRule(0);			//Be sure the stylesheet is empty

	var match = newText.match(/\s*([^\s\{]*)\s*\{([^\}]*)\}/);
	while (match)
	{
		ruleName = match[1];
		ruleValue = match[2];
		newStyleSheet.addRule(ruleName, ruleValue);
		newText = newText.replace(match[0], "");
		match = newText.match(/\s*([^\s\{]*)\s*\{([^\}]*)\}/);
	}
}

/*********************************************
*			Find the user-defined styles
*****************************************/
function findUserStyles()
{
	var newStyleSheet;
	for (var ss=0; ss<document.styleSheets.length; ss++) if (document.styleSheets[ss].title == "userStyles") break;
	
	if (ss >= document.styleSheets.length) 
	{
		newStyleSheet = document.createStyleSheet(null, document.styleSheets.length);
		newStyleSheet.title = "userStyles";
	}
	else newStyleSheet = document.styleSheets[ss];
	return newStyleSheet;
}
/****************************************************
*			Find a named rule in one of the stylesheets.	*
*			Work backwards through the list so that we		*
*			find the most significant rule first.					*
****************************************************/
function findStyleRule(ruleName)
{
	for (ss = document.styleSheets.length-1; ss>= 0; ss--)
	{
		var sheet = document.styleSheets[ss];
		for (var rr=0; rr<sheet.rules.length; rr++)
		{
			if (sheet.rules[rr].selectorText.toUpperCase() == ruleName.toUpperCase())
			{
				return sheet.rules[rr];
			}
		}
		var imports = sheet.imports;
		for (var ii=0; ii<sheet.imports.length; ii++)
		{
			isheet = sheet.imports[ii];
			for (var rr=0; rr<isheet.rules.length; rr++)
			{
				if (isheet.rules[rr].selectorText.toUpperCase() == ruleName.toUpperCase())
				{
					return isheet.rules[rr];
				}
			}
		}
	}
	return null;
}

/*****************************************
*		Get a list of consortiums where
*		this user has permissions.
*****************************************/
function consortiumWriteList(agt)
{
	var permissions = "," + agt.permissions.toUpperCase() + ",";
	var writeList = "";
	var cNodes = agt.loginobject.xmlobject.selectNodes("//CONSORTIUMS");
	for (var cc=0; cc<cNodes.length; cc++)
	{
		for (ii=0; ii<cNodes[cc].childNodes.length; ii++)
		{
			if (permissions.indexOf("," + cNodes[cc].childNodes[ii].nodeName + ",") > 0) writeList += cNodes[cc].childNodes[ii].nodeName + ",";
		}
	}
	return writeList.replace(/\,$/, "");
}

function consortiumDescription(agt, consortiumName)
{
	var cNode = agt.loginobject.xmlobject.selectSingleNode("//CONSORTIUMS/" + consortiumName.toUpperCase()+ "/DESCRIPTION");
	if (cNode) return cNode.text;
	else return consortiumName;
}

/********************************************************
*			Used to display one panel in a multi-tab panel.		*
********************************************************/
function displayOption(ulList, topDiv,displayDiv, idx)
{
  addFlash_TabbedMenuClick();
	
	var ul = document.getElementById(ulList);
	if (ul)
	{
		for (var uu=0; uu<ul.childNodes.length; uu++) 
		{
			if (ul.childNodes[uu].id != "quicklinksedit") ul.childNodes[uu].id = "li" + uu;
		}
		if (idx >= 0) ul.childNodes[idx-1].id = "current";
	}
	else top.valetAlert("Unable to find a document element called " + ulList);

	var divElem = document.getElementById(topDiv);
	if (divElem)
	{
		for (var dd=0; dd<divElem.childNodes.length; dd++)
		{
			if ((divElem.childNodes[dd].id.toUpperCase() == displayDiv.toUpperCase()) |
					(divElem.childNodes[dd].getAttribute("alwaysExpanded") == "yes")) divElem.childNodes[dd].style.display = "block";
			else divElem.childNodes[dd].style.display = "none";
		}
	}
	else return top.valetAlert("Unable to find the document element " + topDiv);
}

/********************************************************
*			Used to shrink/expand a panel in a panel display	*
********************************************************/
function togglePanel(topDiv, ulList, displayDiv, skipHeight, srcObj)
{
	var src
	if (srcObj)	src = srcObj.src;
	else src = window.event.srcElement.src.toUpperCase();
	
	topNode = document.getElementById(topDiv);
	ulNode = document.getElementById(ulList);
	var divNode = document.getElementById(displayDiv);
	if (src.match(/MINUS.GIF/i))
	{
		ulNode.style.display = "none";
		divNode.style.display = "none";
		src = src.replace(/MINUS/i, "PLUS");
		if(!skipHeight) topNode.style.height = "30px";
		if (window.event.srcElement.getAttribute("panelid"))
		{
			window.event.srcElement.setAttribute("collapsed", "true");
		}
	}
	else
	{
		ulNode.style.display = "block";
		divNode.style.display = "block";
		src = src.replace(/PLUS/i, "MINUS");
		if(!skipHeight) topNode.style.height = topNode.getAttribute("originalheight");
		if (window.event.srcElement.getAttribute("panelid"))
		{
			window.event.srcElement.removeAttribute("collapsed");
		}
	}
	
	if (srcObj)	srcObj.src = src;
	else window.event.srcElement.src = src;
}

/************************************
*			User asked for help						*
************************************/
function showHelp(library, topic)
{
	var pObj = new Object();
	pObj.window = top;
	pObj.mainWindow = top.mainWindow;
	pObj.agt = top.mainWindow._agt;
	pObj.library = library;
	pObj.topic = topic;
	pObj.httpobj = top.mainWindow.loginHelpObject;
	top.showModalDialog("helpPage.htm", pObj, "dialogHeight:500px;dialogWidth:600px;status:no;resizable:yes;");
	
}

var mouseX = -1;
var mouseY = -1;
function dialogDrag(obj, e)
{
	if (mouseX == -1) debugger;
  mouseX = e.pageX || (e.clientX+(document.documentElement.scrollLeft || document.body.scrollLeft));
  mouseY = e.pageY || (e.clientY+(document.documentElement.scrollTop  || document.body.scrollTop));

}




function addFlash_TabbedMenu()
{
	$S('.rpbtabbedmenu a').action({
		onmouseover: function() {
			if (this.parentNode.id == "current") return;  

			if (this.Fx_Color) this.Fx_Color.options.duration=0;  //clear the current transition

			if (this.id=="") this.id = this.uniqueID;
			var myColorFx = new Fx.Color(this.id, 'color', {duration: 200});
			myColorFx.custom('776655', 'FFFFFF') 
			this.Fx_Color = myColorFx;
		},
		onmouseout: function() {
			var myColorFx;
			if (this.id=="") this.id = this.uniqueID;
			
			if (this.Fx_Color) this.Fx_Color.options.duration=0;  //clear the current transition

			//var cl = this.style['color'];
			//if (cl != "") cl=cl.rgbToHex()
			var cl = this.currentStyle.color;
			if (this.parentNode.id == "current")
			{ 
				if (cl=="#333333")
				{
					return;
				}  
				else
				{
					myColorFx = new Fx.Color(this.id, 'color', {duration: 200});
					myColorFx.custom('FFFFFF', '333333') 
				}
			}
			else
			{
				myColorFx = new Fx.Color(this.id, 'color', {duration: 600});
				myColorFx.custom('FFFFFF', '776655') 
			}
			this.Fx_Color = myColorFx;
		}
	});
}

function addFlash_TabbedMenuClick()
{
	  if (this.event==null) return;
	  if (window.Fx==null) return;
	  
		var el = this.event.srcElement;
		if (el==null) return;


		try
		{		
			if (el.id=="") el.id = el.uniqueID;
		
	    var ul = null;
	    var tmpel  = el;
	    while (ul==null && tmpel!=null)
	    {
	      if (tmpel.tagName == 'UL') ul=tmpel;
	      tmpel = tmpel.parentNode;      
			}
			
			if (ul == null) return;		//D. Weeks - This happens on the CMA page when we switch tabs via another control
			
			for (var i=0; i < ul.childNodes.length; i++)
			{
				if(ul.childNodes[i].childNodes[0].tagName!='A') alert('addFlash_TabbedMenuClick assumed a certain structure that does now seem to exist');
			  if (ul.childNodes[i].childNodes[0].id != el.id)
			  {
			  	ul.childNodes[i].childNodes[0].style.color='#776655';
			  }	
			}

			var myColorFx = new Fx.Color(el.id, 'color', {duration: 300});
			myColorFx.custom('FFFFFF', '000000') 	
		}
		catch(err) {}			//When CMA calls displayOption from a button click, this error occurs
}




/*************************************************************************
  importNodes is a recursive function created because the importNode
  method wasn't introduced until msxml 6.0 which some users will not
  have yet.
**************************************************************************/
function importNodes(sourceNode, destNode, unescapeAttrib, unescapeText)
{
  if (sourceNode == null) return;
  
  
  // copy all of the attributes
  if (sourceNode.attributes)
  {
	  for (var n=0; n<sourceNode.attributes.length; n++)
	  {
	  	var val = sourceNode.attributes[n].value;
	  	if (unescapeAttrib) val = unescape(val); 
	    destNode.setAttribute(sourceNode.attributes[n].name, val); 
	  }
  }
  
  // copy all of the child nodes
  if (sourceNode.childNodes)
  {
		for (var i=0; i<sourceNode.childNodes.length; i++)
		{
		  var curNode = sourceNode.childNodes[i];
		  var newDestNode = destNode.appendChild(destNode.ownerDocument.createNode(curNode.nodeType, curNode.nodeName, ""));
		  importNodes(curNode, newDestNode, unescapeAttrib, unescapeText);
		}
	}		

	if (sourceNode.nodeValue) destNode.nodeValue = sourceNode.nodeValue;
}



/*******************************************************************************************************/

var crsTools = {

		"crsRedirectPage": "../htm/crsRedirect.aspx",
		
		"getAgentValue":  function (agtObj, param) {
			
			var vNode = top.podTools.loginDataXML.selectSingleNode("//" + param);
		  if (vNode) return vNode.text;
		  else alert("crsTools could not find the agent field " + param);
		  return "";
		},
		
		"getAgentParams" : function() {

			var agt = mainWindow._agt

			var fullName = crsTools.getAgentValue(agt, "AgentFullName");
			var firstName = fullName.substr(0, fullName.indexOf(" "));
			var lastName = fullName.substr(fullName.indexOf(" ") + 1);
			
			var parms;
      parms =  "agentfname=" + firstName + 
               "&agentlname=" + lastName + 
               "&agentemail=" + crsTools.getAgentValue(agt, "AgentEmail") + 
               "&officename=" + crsTools.getAgentValue(agt, "OfficeName") + 
               "&ofcaddress=" + crsTools.getAgentValue(agt, "OfficeAddress1") + 
               "&ofccity=" + crsTools.getAgentValue(agt, "OfficeCity") + 
               "&ofcstate=" + crsTools.getAgentValue(agt, "OfficeState") + 
               "&ofczip=" + crsTools.getAgentValue(agt, "OfficeZip") + 
               "&ofcphone=" + crsTools.getAgentValue(agt, "OfficePhone");

			return parms;		
		},

    "loginPageUrl"  : function() {

			var agt = mainWindow._agt
    	return crsTools.crsRedirectPage + "?agentid=" + agt.agentid + "&" + crsTools.getAgentParams();
    },

    "reportPageUrl"  : function(county, state, pid, addno, addname) {
    	
			var agt = mainWindow._agt

    	var parms; 
    	parms =  "&cmd=rpt" + 
               "&county=" + county + 
               "&state=" + state +
               "&pid=" + pid + 
               "&addno=" + addno + 
               "&addname=" + addname;
               
    	return crsTools.crsRedirectPage + "?agentid=" + agt.agentid + parms + "&" + crsTools.getAgentParams();
    	
//  	<input type="hidden" name="cmd" value="rpt">
//		<input type="hidden" name="county" value="#TRIM(URL.CNTY)#">
//		<input type="hidden" name="state" value="GA">
//		<input type="hidden" name="pid" value="#TRIM(URL.TID)#">
//		<input type="hidden" name="addno" value="#TRIM(URL.STN)#">
//		<input type="hidden" name="addname" value="#TRIM(URL.STRT)#">
//		<!--- <input type="hidden" name="addname" value="#LEFT(TRIM(URL.STRT),5)#"> --->    	
  	},
  
		"openInVision": function(podId, divId, frameId) {

			// Maximize the pod			
			podTools.maximizePod(podId); 
			
			// Hide the old maximize data
			var divObj = $(divId);
			if (!divObj) alert('supraTools could not find divId: ' + divId); 
			else divObj.setStyle('display','none'); 
			
			// display and load the iframe
			var frameObj = $(frameId);
			if (!divObj) alert('tranDeskTools could not find divId: ' + divId); 
			else frameObj.setStyle('display','').setProperty('src', crsTools.loginPageUrl());
		}

};


var gamlsProTools = {

		"redirectPage": "../../gamlsProRedirect.srf",
		
    "loginPageUrl"  : function(target) {
    	return gamlsProTools.redirectPage + "?target="+target;
    },
		
		"buildFrameAndOpen": function(obj) {
debugger;			
			var id = "gproframe_"+(new Date).getTime();
			var el = new Element('iframe', { 'width':'100', 'height':'100', 'frameborder':'0',
			                     'src': gamlsProTools.loginPageUrl('_blank'),
			                     'id': id }).inject(obj);
			                     
			setTimeout("$('"+id+"').remove();", 60*1000);
			                    
		}
	
};


var tranDeskTools = {

		"podURL": function() {
			var sURL = 'https://www.transactiondesk.com/inet5_bin/hsrun.hse/INSTANETFORMS/INSTANETFORMS/INSTANETFORMS.htx;start=AuthUserGAMLS?';
			sURL += 'gamlsLoginID=' + mainWindow.agt.agentid;
			sURL += '&gamlsPWD=' + mainWindow.agt.password;
			return sURL;
		},
					
		"openInVision": function(podId, divId, frameId) {

			// Maximize the pod			
			podTools.maximizePod(podId); 
			
			// Hide the old maximize data
			var divObj = $(divId);
			if (!divObj) alert('supraTools could not find divId: ' + divId); 
			else divObj.setStyle('display','none'); 
			
			// display and load the iframe
			var frameObj = $(frameId);
			if (!divObj) alert('tranDeskTools could not find divId: ' + divId); 
			else frameObj.setStyle('display','').setProperty('src', tranDeskTools.podURL());
		}
	
};



/*******************************************************************************************************/


var supraTools = {

		"loginId" :					null,	
		"supraPagePath" :		null,
		
		"podURL": function() {
			return 'http://www.gesecurity.com/portal/site/GESecurity/menuitem.89ac3174dcfc02daa78bdd9856030730/?vgnextoid=30954c85b2aba010VgnVCM100000592d7003RCRD';
		},
				
		"login" : function (){			
		},
		
		"openInVision": function(podId, divId, frameId) {

			// Maximize the pod			
			podTools.maximizePod(podId); 
			
			// Hide the old maximize data
			var divObj = $(divId);
			if (!divObj) alert('supraTools could not find divId: ' + divId); 
			else divObj.setStyle('display','none'); 
			
			// display and load the iframe
			var frameObj = $(frameId);
			if (!divObj) alert('supraTools could not find divId: ' + divId); 
			else frameObj.setStyle('display','').setProperty('src', supraTools.podURL());
		},
		
    "assignKeyboxUrl"  : function(sid, ListingID, LagID, Addr, City, State, Zip) {
			
			if (loginId==null) supraTools.login();
			
			return "www.google.com";			
		}
};


/*******************************************************************************************************/