function loadEmbed(fileName,showId,whereId,width,height,showObj) {
	var idStr,wherePtr,showPtr,dot,fileType,args,showClass,autoplay;
  wherePtr = document.getElementById(whereId);
  showPtr = document.getElementById(showId);
	width = ( width === undefined ? '320' : width);
	height = ( height === undefined ? '255' : height);
	widthHeight = ' width="'+width+'" height="'+height+'"';
  if (wherePtr && showPtr && (fileName !== '')) {
		showObj = (showObj !== undefined ? showObj : null);
		showClass = (showObj && (showObj.showClass !== undefined) ? showObj.showClass : null);
		dot = fileName.lastIndexOf('.');
		fileType = ( dot < 0 ? '' : fileName.substr(dot+1).toLowerCase() );
		args = '';
		idStr = '';
		if (fileType == 'wmv') {
			embedObj = [
				'<object '+idStr+'classid="CLSID:22D6f312-B0F6-11D0-94AB-0080C74C7E95" type="application/x-oleobject" codebase="http://activex.microsoft.com/activex/controls/mplayer/en/nsmp2inf.cab#Version=6,4,7,1112"'+widthHeight+'>',
				'<param name="filename" value="'+fileName+'">',
				'<param name="Showcontrols" value="True">',
				'<param name="autoStart" value="True">',
				'<embed type="application/x-mplayer2" autoStart="True" howcontrols="True" src="'+fileName+(sessionName && sessionId ? '?'+sessionName+'='+sessionId : '')+'"'+widthHeight+'>',
				'</object>'
				];
			wherePtr.innerHTML = embedObj.join('');
			showPtr.className = showClass;
		}
		else if (fileType == 'pdf') {
			embedObj = [
				'<embed src="'+fileName+'"'+widthHeight+'>'
				];
			wherePtr.innerHTML = embedObj.join('');
			showPtr.className = showClass;
		}
		else if (fileType == 'mp3') {
			autoplay = (showObj && (showObj.autoplay !== undefined) ? showObj.autoplay : 'false');
			embedObj = [
				'<object'+widthHeight+'>',
				'<param name="src" value="'+fileName+'">',
				'<param name="autoplay" value="'+autoplay+'">',
				'<param name="controller" value="true">',
				'<param name="bgcolor" value="#ffffff">',
				'<embed src="'+fileName+'" autostart="'+autoplay+'" loop="false"'+widthHeight+' controller="true" bgcolor="#ffffff"></embed>',
				'</object>'
				];
			wherePtr.innerHTML = embedObj.join('');
			showPtr.className = showClass;
		}
  }
	return false;
}

// Add a cloned input node before a given node if fewer than n empty ones
function addInputNode(thisPtr,minEmptyCount,inputId,cloneId,insertId,insertClass) {
	var inputPtr,i,emptyCount,clonePtr,insertPtr,insertedPtr,newInputPtr;
	inputPtr = (thisPtr.form[inputId] !== undefined ? thisPtr.form[inputId] : null);
	if (inputPtr) {
		emptyCount = 0;
		for (i=0; i<inputPtr.length; ++i) {
			if (inputPtr[i].value === '') {
				++emptyCount;
			}
		}
		if (emptyCount < minEmptyCount) {
			clonePtr = document.getElementById(cloneId);
			insertPtr = document.getElementById(insertId);
			if (clonePtr && insertPtr) {
				insertedPtr = insertPtr.parentNode.insertBefore(clonePtr.cloneNode(true),insertPtr);
				if (insertedPtr) {
					insertedPtr.className = insertClass;
					insertedPtr.setAttribute('id','');
					newInputPtr = insertedPtr.getElementsByTagName('input');
					if (newInputPtr.length > 0) {
						newInputPtr[0].value = '';
						newInputPtr[0].setAttribute('name',inputId);
					}
				}
			}
		}
	}
}

function reveal(ptr) {
  var tt,count=0;
	if ((typeof ptr == 'object') || (typeof ptr == 'function')) {
		for (var t in ptr)
		{
			tt += t+',';
			if (count++%5 === 0) {
				tt += "\n";
			}
		}
  }
	else {
		tt = 'Not an object.  Type is '+typeof(ptr);
	}
  return(tt);
}

function submitModeForm(thisPtr,mode) {
	thisPtr.form.mode.value=mode;
	thisPtr.form.submit();
}

function checkFormNotEmpty(thisPtr,elementNames) {
	var i,error,value,words,elementInfo,name,minLength,suffix;
	error = '';
	if (typeof (elementNames) == 'object') {
		for (elementName in elementNames) {
			elementInfo = elementNames[elementName];
			name = elementInfo;
			minLength = 0;
			suffix = '';
			if (typeof (elementNames) == 'object') {
				name = elementInfo.name;
				minLength = (elementInfo.minLength !== undefined ? elementInfo.minLength : 0);
				suffix = ' that is at least '+minLength+' words';
			}
			value = thisPtr[elementName].value;
			words = value.split(' ');
			if ((value == '') || (minLength && (words.length<minLength))) {
				error += 'Please enter '+ name + suffix + ".\n";
			}
		}
	}
	if (error) {
		alert(error);
	}
	return (error == '');
}

function checkApplicationElement(element,required,fieldType,fieldSize,optional) {
	var i,re,value,valueError,selected,match,hour,minute,subdomain,thisElement,elementName;
	value = '';
	elementName = (elementName === undefined ? '' : elementName);
	if ((fieldType=='') && optional) {
		fieldType = 'literal';
	}
	switch(fieldType) {
		case 'text':
		case 'enctext':
		case 'name':
		case 'phone':
		case 'textarea':
		case 'url':
		case 'price':
		case 'date':
		case 'time':
		case 'hidden':
			value = trim(element.value);
			if (fieldSize && (value.length > fieldSize)) {
				value = value.substr(0,fieldSize);
			}
			break;
		case 'optional':
		case 'literal':
		case 'extrayn':
		case 'radio':
			if (element.length !== undefined) {
				for (i=0; i<element.length; ++i) {
					thisElement = element[i];
					elementName = thisElement.name;
					if (thisElement.checked) {
						value = thisElement.value;
					}
				}
			}
			break
		case 'select':
		case 'selectInt':
		case 'tableselect':
			selected = element.selectedIndex;
			if ((selected >= 0) && (selected < element.options.length)) {
				value = element.options[selected].value;
			}
			break;
	}
	valueError = required && (value === '');
	//if (valueError) { alert('fieldType='+fieldType); }
	if ((value !== '') && !valueError) {
		switch(fieldType) {
			case 'phone':
				value = value.replace(/\s+/g,'');
				match = value.match(/^[(]*(\d{3})[)-]*(\d{3})[-]*\s*(\d{4})/);
				if (match) {
					element.value = '('+match[1]+') '+match[2]+'-'+match[3];
				}
				else {
					valueError = true;
				}
				break;
			case 'url':
				match = value.match(/(http[s]*)*(:\/\/)*([a-zA-Z]{1}[a-zA-Z0-9_-]*\.)*([a-zA-Z]{1}[a-zA-Z0-9_-]*)\.(com|org|net|biz|gov)(\/*.*)/i);
				if (match) {
					subdomain = (match[3] === undefined ? '' : match[3]);
					value = (match[1] === '' ? 'http' : match[1].toLowerCase() )+'://'+subdomain+match[4]+'.'+match[5]+match[6];
					element.value = value;
				}
				else {
					valueError = true;
				}
				break;
			case 'price':
				match = value.match(/^[$]*(\d*)[.]*(\d*)/);
				if (match) {
					dollars = (match[1] ? match[1] : 0);
					cents = ( match[2] !== undefined ? '00'+match[2] : '00' );
					cents = cents.substr(cents.length-2);
					value = dollars+'.'+cents;
					element.value = '$'+value;
				}
				else {
					valueError = true;
				}
				break;
			case 'date':
				value = Date.parse(value);
				valueError = isNaN(value);
				break;
			case 'time':
				match = value.match(/^(\d{1,2})(:*)(\d{2})\s*([aApP][mM])/);
				if (match) {
					hour = match[1];
					hour = ( (hour.substr(0,1) == 0) && (hour.length>1) ? hour.substr(1) : hour );
					hour = parseInt(hour);
					minute = parseInt(match[3]);
					ampm = match[4].toUpperCase();
					valueError = ((hour <= 0) || (hour > 12) || (minute < 0) || (minute > 60) || !ampm);
					element.value = hour+':'+match[3]+ampm;
				}
				else {
					valueError = true;
				}
				value = ( valueError ? '' : (hour*100) + minute + ( (ampm == 'PM') && (hour != 12) ? 1200 : 0 ) );
				break;
		}
	}
	return [value,valueError];
}

function applicationElementClass(element,required,error,nonAlertClass) {
	var i,formPtr,elements,strElement,thisElement,parentElement,elementType,elementName,alertClass,alertClasses,debug;
	alertClasses = { dateInput:'dateApplicationAlert', applicationExtra:'applicationExtraAlert' }
	debug = false;
	if ((required || error) && element) {
		nonAlertClass = ( nonAlertClass === undefined ? '' : nonAlertClass );
		alertClass = ( alertClasses[nonAlertClass] !== undefined ? alertClasses[nonAlertClass] :'applicationAlert' );
		elements = [];
		if (typeof element == 'string') {
			strElement = element;
			if (element.indexOf('.') >= 0) {
				element = element.split('.');
				formPtr = document.getElementById(element[0]);
				element = (formPtr ? formPtr[element[1]] : null );
			}
			else {
				element = document.getElementById(element);
			}
			elements = (element.length === undefined ? [element] : element);
		}
		else if ((typeof(element) == 'object') && (element.length !== undefined)) {
			elements = element;
		}
		else if (element) {
			elements = [element];
		}
		for (i=0; i<elements.length; ++i) {
			thisElement = elements[i];
			elementType = (thisElement.type === undefined ? 'undefined' : thisElement.type);
			elementName = (thisElement.name === undefined ? 'undefined' : thisElement.name);
			if ((elementType == 'checkbox') || (elementType == 'radio')) {
				thisElement = thisElement.parentNode;
			}
			if (debug && error && (i==0)) { alert('thisElement='+thisElement+', elementName='+elementName+', elementType='+elementType+', alertClass='+alertClass); }
			if (thisElement) {
				thisElement.className = ( error ? alertClass : nonAlertClass );
			}
		}
		if ((element.nodeName !== undefined) && (element.nodeName.toLowerCase() == 'select')) {
			element.className = ( error ? alertClass : nonAlertClass );
		}
	}
	else {
		error = false;
	}
	return error;
}

function trim(str) {
	if (str === undefined) {
		str = '';
	}
	else {
		str = str.replace(/^\s+/,'');
		str = str.replace(/\s+$/,'');
	}
  return str;
}

function setClear(thisPtr,partType,partName,set) {
	var i,elements,checkable;
	if (thisPtr.form !== undefined) {
		elements = thisPtr.form.elements;
		checkable = ((partType == 'checkbox') || (partType == 'radio'));
		for (i=0; i<elements.length; i++) {
//			alert('partType='+elements[i].type+', partName='+elements[i].name);
			if (checkable && (elements[i].type == partType) && (elements[i].name == partName)) {
				elements[i].checked = set;
			}
		}
	}
	return false;
}

function $(id) {
	return(document.getElementById(id));
}

function showDiv(docPtr,id,showClass) {
	var idPtr;
	showClass = ((showClass === undefined) || !showClass ? null : showClass);
	idPtr = docPtr.getElementById(id);
	if (idPtr) {
		idPtr.className = showClass;
	}
	return false;
}

function hideDiv(docPtr,id) {
	var idPtr;
	idPtr = docPtr.getElementById(id);
	if (idPtr) {
		idPtr.className = 'noDisplay';
	}
	return false;
}

function showHide(setId,showIds,showClass,allIds)
{
	var i,allId,id,idPtr,found;
	// Set the show class to blank if not passed
	if (showClass === undefined) {
		showClass = '';
	}
	// Set show ids to be an empty array if not passed
	if (showIds === undefined) {
		showIds = [];
	}
	// Make sure showIds is an array
	else if (typeof showIds != 'object') {
		showIds = [showIds];
	}
	// Add the show id to the all ids list if all ids is not given
	if (allIds === undefined) {
		allIds = showIds;
	}
	else if (typeof allIds != 'object') {
		allIds = [allIds];
	}
	// Create the set object if it does not exist
	if (showHide[setId] === undefined) {
		showHide[setId] = {}
	}
	// Save all the Id names in the set object
	for (i=0; i<allIds.length; i++) {
		allId = allIds[i];
		if (showHide[setId][allId] == undefined) {
			showHide[setId][allId] = '';
		}
	}
	ids = showHide[setId];
	for (id in ids) {
		idPtr = document.getElementById(id);
		if (idPtr) {
			found = false;
			for (i=0; (i<showIds.length) && !found; i++) {
				found = (id == showIds[i]);
			}
			idPtr.className = (found ? showClass : 'noDisplay' );
		}
	}
	return false;
}

function cloneToPath(docPtr,fromId,toPath)
{
	var fromPtr,toPathPtr;
	fromPtr = docPtr.getElementById(fromId);
	pathParams = elementSpecToPtr(docPtr,toPath);
	toPathPtr = pathParams[0];
	if (fromPtr && toPathPtr) {
		insertNode = fromPtr.cloneNode(true);
		insertNode.removeAttribute('id');
		insertNode.className = '';
		insertRowNode(toPathPtr,insertNode);
	}
	return insertNode;
}

function insertRowNode(insertSitePtr,insertNode)
{
  insertSitePtr.parentNode.insertBefore(insertNode,insertSitePtr);
}

// Return an object with the passed spec
//  objctSpec = nodeId,path=value{|nodeId,path=value...}
//		path = tag:count{,tag:count...}
function setInnerHtml(docPtr,setSpec)
{
	var elementSpecs,elementSpec,specValue,idPath,value,specParams,valuePtr,param,pArray,pIndex,pValue,i;
	elementSpecs = setSpec.split('|');
	for (i=0; i<elementSpecs.length; i++) {
		elementSpec = elementSpecs[i];
		if (elementSpec.indexOf('=') >= 0) {
			specValue = elementSpec.split('=');
			idPath = specValue[0];
			value = specValue[1].replace('<','&lt;');
			specParams = elementSpecToPtr(docPtr,idPath);
			valuePtr = specParams[0];
			param = specParams[1];
			if (valuePtr) {
				if (param !== '') {
					pArray = param.indexOf('[');
					if (pArray >= 0) {
						pIndex = parseInt(param.substr(pArray+1));
						param = param.substr(0,pArray);
						pValue = valuePtr[param].split('|');
						pValue[pIndex] = value;
						valuePtr[param] = pValue.join('|');
					}
					else {
						valuePtr[param] = value;
					}
				}
				else {
					valuePtr.innerHTML = value;
				}
			}
		}
	}
}

function elementSpecToPtr(docPtr,elementPath,debug) {
	var specValue,idPath,id,valuePtr,param,tagCount,tag,count,j,k,debugStr;
	debugStr = elementPath+"\n";
	valuePtr = null;
	param = '';
	value = '';
	idPath = elementPath.split(',')
	id = idPath.shift();
	debugStr += 'id='+id+"\n";
	valuePtr = docPtr.getElementById(id);
	if (valuePtr) {
		for (j=0; j<idPath.length; j++) {
			tagCount = idPath[j].split(':');
			tag = tagCount[0].toLowerCase();
			count = tagCount[1];
			param = (tagCount[2]===undefined ? '' : tagCount[2]);
			debugStr += tag+':'+count+', ';
			if (count !== '') {
				valuePtr = valuePtr.firstChild;
				// Find the nth node of type tag
				k = -1;
				while (valuePtr && (k<count)) {
					if (valuePtr.nodeName.toLowerCase() == tag) {
						k++;
						debugStr += 'k='+k+', ';
					}
					if (k < count) {
						debugStr += 'nodeName='+valuePtr.nodeName.toLowerCase()+', ';
						valuePtr = (valuePtr.nextSibling ? valuePtr.nextSibling : valuePtr.firstChild);
					}
				}
				debugStr += "\n";
			}
		}
	}
	if ((debug !== undefined) && (debug !== '')) {
		alert(debugStr);
	}
	return Array(valuePtr,param)
}

function styleValue(ptr,attribute,value) {
	var stylePtr,styleValue;
	styleValue = '';
	if (typeof(ptr) == 'string') {
		ptr = document.getElementById(ptr);
	}
	if (ptr) {
		stylePtr = null;
		if (ptr.runtimeStyle != null) {
			stylePtr = ptr.runtimeStyle;
		}
		else if (ptr.style != null) {
			stylePtr = ptr.style;
		}
		if (stylePtr != null) {
			if ((attribute == 'top') && !(stylePtr.pixelTop == null)) {
				attribute = 'pixelTop';
				value = parseFloat(value);
			}
			if ((value !== undefined) && (stylePtr[attribute] != null)) {
				stylePtr[attribute] = value;
			}
		}
	}
}


function donationSetUnique(thisPtr,valueSetIds,radioId,values,setIds) {
	var i,valueSetId,valueSetPtr,setPtr,inputPtr,inputNumber,radioPtr;
	inputNumber = parseInt(thisPtr.value);
	if (inputNumber > 0) {
		for (i=0; i<values.length; i++) {
			setPtr = thisPtr.form[setIds[i]];
			if (setPtr !== undefined) {
				setPtr.value = values[i];
			}
		}
		radioPtr = thisPtr.form[radioId];
		if (radioPtr !== undefined) {
			for (i=0; i<radioPtr.length; i++) {
				radioPtr[i].checked = false;
			}
		}
	}
	else {
		inputNumber = '';
	}
	for (i=0; i<valueSetIds.length; ++i) {
		valueSetId = valueSetIds[i];
		valueSetPtr = (typeof(valueSetId) == 'string' ? thisPtr.form[valueSetId] : valueSetId);
		valueSetPtr.value = inputNumber;
	}
}

function unSQuote(replaced,str) {
	str = str.replace(replaced,"'");
	return(str);
}

function checkedValue(ptr) {
  var value,ptrA3,ptrRadio,ptrInput,i;
  value = 0;
  if (ptr) {
    ptrA3 = ptr['a3'];
    ptrRadio = ptr['Xx'];
    ptrInput = ptr['Yy'];
    if (ptrRadio && ptrInput && ptrA3) {
      value = parseInt(ptrInput.value);
      if (isNaN(value)) { value = 0; }
      if ((value == 0) && ptrRadio.length !== undefined) {
        for (i=0; i<ptrRadio.length; i++) {
          if (ptrRadio[i].checked) {
            value += parseFloat(ptrRadio[i].value);
          }
        }
      }
      if (value > 0) {
        ptrA3.value = value;
      }
      if (!(value > 0)) {
        alert('Please Select a Donation Amount');
      }
    }
  }
  return value;
}

function checkedNumeric(ptr) {
  var value;
  value = (ptr ? parseInt(ptr.value) : 0);
  if (!(value > 0)) {
    alert('Please Enter a Donation Amount');
  }
  return value;
}

function SetFocus(TargetFormName) {
  var target = 0;
  if (TargetFormName != "")
    for (i=0; i<document.forms.length; i++) {
      if (document.forms[i].name == TargetFormName) {
        target=i;
        break;
      }
    }

  var TargetForm = document.forms[target];
    
  for (i=0; i<TargetForm.length; i++) {
    if ( (TargetForm.elements[i].type != "image") && 
         (TargetForm.elements[i].type != "hidden") && 
         (TargetForm.elements[i].type != "reset") && 
         (TargetForm.elements[i].type != "submit") ) {

      TargetForm.elements[i].focus();

      if ( (TargetForm.elements[i].type == "text") || 
           (TargetForm.elements[i].type == "password") )
        TargetForm.elements[i].select();
      
      break;
    }
  }
}

function RemoveFormatString(TargetElement, FormatString) {
  if (TargetElement.value == FormatString)
    TargetElement.value = "";
    TargetElement.select();
}

function CheckDateRange(from, to) {
  if (Date.parse(from.value) <= Date.parse(to.value))
    return true;
  else
    return false;
}

function timeStampSeconds() {
	var timeStamp;
	timeStamp = new Date();
	timeStamp = Math.floor(timeStamp.getTime()/1000);
	return timeStamp;
}

function IsValidDate(DateToCheck, FormatString) {
  var strDateToCheck;
  var strDateToCheckArray;
  var strFormatArray;
  var strFormatString;
  var strDay;
  var strMonth;
  var strYear;
  var intday;
  var intMonth;
  var intYear;
  var intDateSeparatorIdx = -1;
  var intFormatSeparatorIdx = -1;
  var strSeparatorArray = new Array("-"," ","/",".");
  var strMonthArray = new Array("jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec");
  var intDaysArray = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

  strDateToCheck = DateToCheck.toLowerCase();
  strFormatString = FormatString.toLowerCase();
  
  if (strDateToCheck.length != strFormatString.length) {
    return false;
  }

  for (i = 0; i < strSeparatorArray.length; i++) {
    if (strFormatString.indexOf(strSeparatorArray[i]) != -1) {
      intFormatSeparatorIdx = i;
      break;
    }
  }

  for (i = 0; i < strSeparatorArray.length; i++) {
    if (strDateToCheck.indexOf(strSeparatorArray[i]) != -1) {
      intDateSeparatorIdx = i;
      break;
    }
  }
  
  if (intDateSeparatorIdx != intFormatSeparatorIdx)
    return false;

  if (intDateSeparatorIdx != -1) {
    strFormatArray = strFormatString.split(strSeparatorArray[intFormatSeparatorIdx]);
    if (strFormatArray.length != 3) {
      return false;
    }

    strDateToCheckArray = strDateToCheck.split(strSeparatorArray[intDateSeparatorIdx]);
    if (strDateToCheckArray.length != 3) {
      return false;
    }

    for (i = 0; i < strFormatArray.length; i++) {
      if (strFormatArray[i] == 'mm' || strFormatArray[i] == 'mmm')
        strMonth = strDateToCheckArray[i];
      if (strFormatArray[i] == 'dd')
        strDay = strDateToCheckArray[i];
      if (strFormatArray[i] == 'yyyy')
        strYear = strDateToCheckArray[i];
    }
  }
  else {
    if (FormatString.length>7) {
      if (strFormatString.indexOf('mmm') == -1)
        strMonth = strDateToCheck.substring( strFormatString.indexOf('mm'), 2 );
      else
        strMonth = strDateToCheck.substring( strFormatString.indexOf('mmm'), 3 );
      strDay = strDateToCheck.substring( strFormatString.indexOf('dd'), 2 );
      strYear = strDateToCheck.substring( strFormatString.indexOf('yyyy'), 2 );
    }
    else {
      return false;
    }
  }

  if (strYear.length != 4) {
    return false;
  }
  intday = parseInt(strDay, 10);
  if (isNaN(intday)) {
    return false;
  }
  if (intday < 1) {
    return false;
  }

  intMonth = parseInt(strMonth, 10);
  if (isNaN(intMonth)) {
    for (i = 0;i < strMonthArray.length; i++) {
      if (strMonth == strMonthArray[i]) {
        intMonth = i+1;
        break;
      }
    }
    if (isNaN(intMonth)) {
      return false;
    }
  }
  if (intMonth>12 || intMonth<1) {
    return false;
  }

  intYear = parseInt(strYear, 10);
  if (isNaN(intYear)) {
    return false;
  }
  if (IsLeapYear(intYear) == true) {
    intDaysArray[1] = 29;
  }

  if (intday > intDaysArray[intMonth - 1]) {
    return false;
  }
  
  return true;
}

function IsLeapYear(intYear) {
  if (intYear % 100 == 0) {
    if (intYear % 400 == 0)
      return true;
  }
  else {
    if ((intYear % 4) == 0)
      return true;
  }

  return false;
}

function countChecked(thisPtr,checkId,checkCount,message) {
	var checkPtr,i,thisCount,countOk;
	thisCount = 0;
	checkPtr = thisPtr.form[checkId];
	if ((checkPtr !== undefined) && (checkPtr.length !== undefined)) {
		for (i=0; i<checkPtr.length; ++i) {
			if (checkPtr[i].checked) {
				++thisCount;
			}
		}
	}
	countOk = (thisCount >= checkCount);
	if (!countOk) {
		alert(message);
	}
	return countOk;
}

// guestObj is an object whose properties give the location where guest data is to be loaded
function guestSearch(guestObj) {
	var guestSearch,args = '';
	for (field in guestObj) {
		args += (args === '' ? '' : '&')+field+'='+guestObj[field];
	}
	//document.venue_form.criteria.value
	if (args !== '') {
		guestSearch = window.open('guestSearch.php?'+args, 'guestSearch', 'scrollbars=yes,resizable=yes,width=500,height=350,menubar=no,location=no,left=200,top=150');
		guestSearch.focus();
	}
}
//##############################################################################################
//----------------------------------------------------------------------------------------------
// Subroutine Purpose: 
//   Register the textareaInput handler to a list of text areas
//----------------------------------------------------------------------------------------------
// Parameters Used:
//  1 - textareas: an object with one property for each textarea to be monitored
//      defined by { 'fromName.inputName':maxSize, ... }
//----------------------------------------------------------------------------------------------
// Outputs
//   None
//----------------------------------------------------------------------------------------------
function registerTextareaInput(textareas)
{
	var i,size,textarea,textareaArgs;
	if (textareas) {
		for (textarea in textareas) {
			textareaInput[textarea] = textareas[textarea];
			registerEventListener(textarea,'keyup',textareaInput,false);
		}
	}
}
//##############################################################################################
function textareaInput(evt)
//----------------------------------------------------------------------------------------------
// Subroutine Purpose: 
//   Handle input from the keyboard in a textarea.  Limit input to the preset size
//      Shift Key charCode = 16
//----------------------------------------------------------------------------------------------
// Parameters Used:
//  1 - evt: event pointer
//----------------------------------------------------------------------------------------------
// Outputs
//   None
//----------------------------------------------------------------------------------------------
{
	var thisCharCode,thisCharString,thisCharTime,sizeId;

	if (!evt) {
		evt = window.event;
	}
	thisPtr = ( evt.srcElement !== undefined ? evt.srcElement : this );
	stopBubbling(evt);
	// Convert the character code to a string
	thisCharCode = evt.keyCode;
	thisCharString = charCodeToString(thisCharCode,evt.shiftKey,evt.ctrlKey,evt.altKey);
	sizeId = thisPtr.form.getAttribute('id')+'.'+thisPtr.name;
	size = ( textareaInput[sizeId] !== undefined ? textareaInput[sizeId] : 0 );
	if (thisPtr.value.length > size) {
		thisPtr.value = thisPtr.value.substr(0,size);
	}
	//if (thisCharString == 'a') { alert(textareaInput[sizeId]); }
}
//##############################################################################################
function registerEventListener(addId,addEventType,addFunction,addCapture)
//----------------------------------------------------------------------------------------------
// Subroutine Purpose: 
//   Make visible a hidden element or make hidden the last element made visible
//----------------------------------------------------------------------------------------------
// Parameters Used:
//  1 - String: id of element to add the listener to
//  2 - Event type to listen for
//  3 - function which handles the event
//  4 - if true this handler sees the event during the capture phase
//      Capture mode happens first then the element triggering the event then bubbling mode
//----------------------------------------------------------------------------------------------
// Outputs
//   None
//----------------------------------------------------------------------------------------------
{
	var addPointer,addIds;
	if (addId.indexOf('.') >= 0) {
		addIds = addId.split('.');
		addPointer = document.getElementById(addIds[0]);
		addPointer = ( addPointer && (addPointer[addIds[1]] !== undefined) ? addPointer[addIds[1]] : null );
	}
	else {
		addPointer = document.getElementById(addId);
	}
	if (addPointer) {
		if (addPointer.addEventListener) {
			addPointer.addEventListener(addEventType,addFunction,addCapture); 
		}
		else if (addPointer.attachEvent) {
			addPointer.attachEvent('on'+addEventType,addFunction);
		}
	}
}
//##############################################################################################
function stopBubbling(evt)
//----------------------------------------------------------------------------------------------
// Subroutine Purpose: 
//   Stop an event from bubbling up to higher levels
//----------------------------------------------------------------------------------------------
// Parameters Used:
//   1 - event object
//----------------------------------------------------------------------------------------------
// Outputs
//   None
//----------------------------------------------------------------------------------------------
{
	if (evt) {
		if (evt.stopPropagation) {
			evt.stopPropagation();
		}
		else {
			if (evt.preventBubble) {
				evt.preventBubble();
			}
			else {
				if (evt.cancelBubble != undefined) {
					evt.cancelBubble = true;
				}
				else {
					alert(reveal(evt));
				}
			}
		}
	}
}
//##############################################################################################

function charCodeToString(thisCharCode,shiftKeyDown,ctrlKeyDown,altKeyDown)
//----------------------------------------------------------------------------------------------
// Subroutine Purpose: 
//   Convert a character code into a string.
//----------------------------------------------------------------------------------------------
// Parameters Used:
//  1 - Character code
//  2 - True if the shift key is down
//----------------------------------------------------------------------------------------------
// Outputs
//   None
//----------------------------------------------------------------------------------------------
{
	//	Keyboard:charCodes:ISO 8859
	//			backspace:8:BS, enter:13:CR, capslock:20:DC4, shift:16:DLE, delete:46:., ;:59:;, 
	//	Convert the charCode value to a string.
	//	Use it to find the index of the unshifted character in either string
	//	Use that index to find the corresponding shifted or unshifted character
	var		shiftedString = "!@#$%^&*()ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
	var unshiftedString = "1234567890abcdefghijklmnopqrstuvwxyz ";
	//	If the string is not found above, search for the character code in CHARCODE
	//	Use the index-1 divided by three as an index into the shifted and unshifted charcode strings
	var charCodeToShift = ",186,187,188,189,190,191,192,219,220,221,222,32,";
	var shiftedCharCode = ":+<_>?~{|}\" ";
	var unshiftedCharCode = ";=,-./`[\\]' ";
	var thisString,stringIndex;
	
	var shiftCtrlAlt = (shiftKeyDown ? 'S' : '')+(ctrlKeyDown ? 'C' : '')+(altKeyDown ? 'A' : '');
	if (ctrlKeyDown || altKeyDown) {
		thisString = '('+shiftCtrlAlt+thisCharCode+')';
	}
	else {
		if ((thisCharCode>=48 && thisCharCode<=57) || (thisCharCode>=65 && thisCharCode<=90)) {
			thisString = String.fromCharCode(thisCharCode);
			if (shiftKeyDown && (stringIndex=unshiftedString.indexOf(thisString))>=0)
				thisString = shiftedString.charAt(stringIndex);
			if (!shiftKeyDown && (stringIndex=shiftedString.indexOf(thisString))>=0)
				thisString = unshiftedString.charAt(stringIndex);
		}
		else {
			if ((stringIndex = charCodeToShift.indexOf(','+thisCharCode+',')/4)>=0) {
				thisString = (shiftKeyDown ? shiftedCharCode.charAt(stringIndex): unshiftedCharCode.charAt(stringIndex));
			}
			else {
				thisString = '('+shiftCtrlAlt+thisCharCode+')';
			}
		}
	}
	return(thisString);
}
//##############################################################################################
function copyFormElements(fromString,toId)
//----------------------------------------------------------------------------------------------
// Subroutine Purpose: 
//   Copy form element values from one or more forms to a single form.  Forms must already exist.
//----------------------------------------------------------------------------------------------
// Parameters Used:
//  1 - Comma separated string of form ids to copy
//  2 - Id of form to copy to
//----------------------------------------------------------------------------------------------
// Outputs
//   None
//----------------------------------------------------------------------------------------------
{
	var i,j,elementName,allValues='',i=0;
	var fromId,fromIds;
	var fromObject,toObject = document.getElementById(toId);
	fromIds = (typeof fromString == 'object' ? fromString : fromString.split(','));
	toObject = (typeof toId == 'object' ? toId : document.getElementById(toId));
	for (i=0; i<fromIds.length; i++)
	{
		fromId = fromIds[i];
		fromObject = ((typeof fromId) == 'object' ? fromId : document.getElementById(fromId));
		if (fromObject && toObject) {
			for (j=0; j<fromObject.elements.length; j++) {
				elementName = fromObject.elements[j].name;
				if (toObject.elements[elementName] !== undefined) {
					toObject.elements[elementName].value=fromObject.elements[j].value;
					allValues += fromObject.elements[j].value;
				}
			}
		}
	}
	return(allValues);
}
//##############################################################################################
var XMLHttpReq=null,XMLHttpState = 0,XMLHttpStatus = 0,XMLHttpText = '';
function loadContent(url,args,method,sinkTextId,sinkXml) {
	var get,status = false;
	XMLHttpRequestTypes = new Array("Msxml2.XMLHTTP.7.0","Msxml2.XMLHTTP.6.0","Msxml2.XMLHTTP.5.0","Msxml2.XMLHTTP.4.0","MSXML2.XMLHTTP.3.0","MSXML2.XMLHTTP","Microsoft.XMLHTTP");
	if (url) {
		XMLHttpState = 0;
		if (XMLHttpReq) XMLHttpReq.abort();
		XMLHttpReq = null;
		// branch for native XMLHttpRequest object
		if(window.XMLHttpRequest && !(window.ActiveXObject)) {
			try {
				XMLHttpReq = new XMLHttpRequest();
			} catch(e) {
				XMLHttpReq = null;
			}
			// branch for IE/Windows ActiveX version
		}
		if(!XMLHttpReq && window.ActiveXObject) {
			for (var i=0; (i<XMLHttpRequestTypes.length) && !XMLHttpReq; i++) {
				try {
					XMLHttpReq = new window.ActiveXObject(XMLHttpRequestTypes[i]);
				} catch(e) {
					XMLHttpReq = null;
				}
			}
		}
		if (XMLHttpReq) {
			try {
				XMLHttpReq.onreadystatechange = function() { XMLHttpStatusChange(sinkTextId,sinkXml); }
				if (get = (method.toLowerCase() == 'get')) {
					url += '?'+args;
				}
				XMLHttpReq.open(method,url,true);
				if (get) {
					args = '';
				}
				else {
					XMLHttpReq.setRequestHeader("Content-Type","application/x-www-form-urlencoded");
				}
				XMLHttpReq.send(args);
				status = true;
			} catch(e) {
				alert('newXMLHttpRequest XMLHttpReq creation error');
				status = false;
			}
		}
	}
	else {
		status = XMLHttpState+'';
	}
	return(status)
}

function XMLHttpStatusChange(sinkTextId,sinkXml) {
  var sinkPtr,alertDiv=document.getElementById('alert');
  if (alertDiv) alertDiv.innerHTML += XMLHttpReq.readyState+' -- ';
  if ((XMLHttpState=XMLHttpReq.readyState) == 4) {
    if ((XMLHttpStatus=XMLHttpReq.status) == 200) {
      if ((sinkTextId != undefined) && sinkTextId && (XMLHttpReq.responseText != undefined) && (sinkPtr=document.getElementById(sinkTextId))) {
        sinkPtr.innerHTML = XMLHttpReq.responseText;
      }
      if ((sinkXml != undefined) && sinkXml) {
				xmlResponse = ( (XMLHttpReq.responseXML != undefined) && XMLHttpReq.responseXML ? XMLHttpReq.responseXML : {} );
				if (typeof(sinkXml) == 'string') {
					eval(sinkXml+' = xmlResponse');
				}
				else if (typeof(sinkXml) == 'function') {
					sinkXml(xmlResponse);
				}
				else {
					alert('typeof(sinkXml)='+typeof(sinkXml));
				}
			}
    }
    else {
      XMLHttpText = XMLHttpReq.statusText;
    }
    if (alertDiv) alertDiv.innerHTML += XMLHttpReq.status+' -- ';
  }
}