function Trim(str)
{
	var trimstr = "", achar = "";
	if (str.charAt(0) != " ")
		{
		trimstr = str.charAt(0)
		}
	for (i=1; i < str.length; i++)
		{
		j = i - 1;
		if ((achar = str.charAt(i)) != " " && achar != "\n" && achar != "\t")
		    	trimstr += achar;
		else if (trimstr.charAt(trimstr.length-1) != " ")
			trimstr += " ";
		}
	if (trimstr.charAt(trimstr.length-1) == " ")
		trimstr = trimstr.substring(0, trimstr.length - 1);
	return trimstr;
}

function RequiredString(frm, fieldname, message)
{
	var fld = frm.elements[fieldname];
	var valu = Trim(fld.value);
	fld.value = valu;
	if (valu == "")
		{
		alert(message);
		fld.focus();
		return false;
		}
	return true;	
}

function RequiredList(frm, fieldname, message)
{
	var fld = frm.elements[fieldname];
	var valu = Trim(fld.value);
	if (valu == "")
		{
		alert(message);
		fld.focus();
		return false;
		}
	valu = fld.value.split("\n")
	for (var i = 0; i < valu.length; i++)
		valu[i] = Trim(valu[i]);
	fld.value = valu.join("\n")
	return true;	
}

function RequiredNumber(frm, fieldname, fielddesc, bInt, iMin, iMax)
{
	var fld = frm.elements[fieldname];
	var valu = fld.value;
	if (isNaN(valu))
		{
		alert("The value you entered for " + fielddesc + " is not a number");
		fld.focus();
		return false;
		}
	var numvalu = new Number(valu);
	if (bInt && numvalu != numvalu.toFixed(0))
		{
		alert(fielddesc + " must be an integer");
		fld.focus();
		return false;
		}
	if (!isNaN(iMin) && numValu < iMin)
		{
		alert(fielddesc + " may not be less than " + iMin);
		fld.focus();
		return false;
		}
	if (!isNaN(iMax) && numValu > iMax)
		{
		alert(fielddesc + " may not be more than " + iMax);
		fld.focus();
		return false;
		}
	return true;
}

function RequiredRadio(frm, fieldname, msg)
{
	return RequiredCheckbox(frm, fieldname, msg);
}

function RequiredCheckbox(frm, fieldname, msg)
{
	var fld = Arrayize(frm.elements[fieldname]);
	
	for (var i = 0; i < fld.length; i++)
		if (fld[i].checked)
			return true;
	alert(msg);
	fld[0].focus();
	return false;
}

function CheckboxValues(frm, fieldname)
{
	var fld = frm.elements[fieldname];
	var arrRes = new Array;
	if (!isArray(fld))
		arrRes[0] = fld.value;
	else
	{
		var k = 0;
		for (var i = 0; i < fld.length; i++)
			if (fld[i].checked)
				arrRes[k++] = fld[i].value;
		if (k == 0) arrRes[0] = "";
	}
	return arrRes;
}

function RadioValue(frm, fieldname)
{
	var fld = frm.elements[fieldname];
	if (!isArray(fld))
		return(fld.checked ? fld.value : "");
	else
		for (var i = 0; i < fld.length; i++)
			if (fld[i].checked)
				return(fld[i].value);
	return "";
}

function emailCheck (emailStr) {
	/* The following pattern is used to check if the entered e-mail address
	   fits the user@domain format.  It also is used to separate the username
	   from the domain. */
	var emailPat=/^(.+)@(.+)$/
	/* The following string represents the pattern for matching all special
	   characters.  We don't want to allow special characters in the address. 
	   These characters include ( ) < > @ , ; : \ " . [ ]    */
	var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]"
	/* The following string represents the range of characters allowed in a 
	   username or domainname.  It really states which chars aren't allowed. */
	var validChars="\[^\\s" + specialChars + "\]"
	/* The following pattern applies if the "user" is a quoted string (in
	   which case, there are no rules about which characters are allowed
	   and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
	   is a legal e-mail address. */
	var quotedUser="(\"[^\"]*\")"
	/* The following pattern applies for domains that are IP addresses,
	   rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
	   e-mail address. NOTE: The square brackets are required. */
	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/
	/* The following string represents an atom (basically a series of
	   non-special characters.) */
	var atom=validChars + '+'
	/* The following string represents one word in the typical username.
	   For example, in john.doe@somewhere.com, john and doe are words.
	   Basically, a word is either an atom or quoted string. */
	var word="(" + atom + "|" + quotedUser + ")"
	// The following pattern describes the structure of the user
	var userPat=new RegExp("^" + word + "(\\." + word + ")*$")
	/* The following pattern describes the structure of a normal symbolic
	   domain, as opposed to ipDomainPat, shown above. */
	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$")
	
	
	/* Finally, let's start trying to figure out if the supplied address is
	   valid. */
	
	/* Begin with the coarse pattern to simply break up user@domain into
	   different pieces that are easy to analyze. */
	var matchArray=emailStr.match(emailPat)
	if (matchArray==null) {
	  /* Too many/few @'s or something; basically, this address doesn't
	     even fit the general mould of a valid e-mail address. */
	//	alert("Email address seems incorrect (check @ and .'s)")
		return false
	}
	var user=matchArray[1]
	var domain=matchArray[2]
	
	// See if "user" is valid 
	if (user.match(userPat)==null) {
	    // user is not valid
	//    alert("The username doesn't seem to be valid.")
	    return false
	}
	
	/* if the e-mail address is at an IP address (as opposed to a symbolic
	   host name) make sure the IP address is valid. */
	var IPArray=domain.match(ipDomainPat)
	if (IPArray!=null) {
	    // this is an IP address
		  for (var i=1;i<=4;i++) {
		    if (IPArray[i]>255) {
	//	        alert("Destination IP address is invalid!")
			return false
		    }
	    }
	    return true
	}
	
	// Domain is symbolic name
	var domainArray=domain.match(domainPat)
	if (domainArray==null) {
	//	alert("The domain name doesn't seem to be valid.")
	    return false
	}
	
	/* domain name seems valid, but now make sure that it ends in a
	   three-letter word (like com, edu, gov) or a two-letter word,
	   representing country (uk, nl), and that there's a hostname preceding 
	   the domain or country. */
	
	/* Now we need to break up the domain to get a count of how many atoms
	   it consists of. */
	var atomPat=new RegExp(atom,"g")
	var domArr=domain.match(atomPat)
	var len=domArr.length
	if (domArr[domArr.length-1].length<2 || 
	    domArr[domArr.length-1].length>3) {
	   // the address must end in a two letter or three letter word.
	//   alert("The address must end in a three-letter domain, or two letter country.")
	   return false
	}
	
	// Make sure there's a host name preceding the domain.
	if (len<2) {
	//   var errStr="This address is missing a hostname!"
	//   alert(errStr)
	   return false
	}
	
	// If we've gotten this far, everything's valid!
	return true;
}


function RequiredEmail(frm, fieldname, fielddesc)
{
	var fld = frm.elements[fieldname];
	var valu = Trim(fld.value);
	fld.value = valu;
	if (valu == "")
		{
		alert("Please enter the " + fielddesc);
		fld.focus();
		return false;
		}
	if (!emailCheck(valu))
		{
		alert("The " + fielddesc + " must be of form name@organization.domain.");
		fld.focus();
		return false;
		}
	return true;	
}

function ExtractFilename(strPath)
{
	var pos = strPath.lastIndexOf("\\");
	return Trim(pos >= 0 ? strPath.substr(pos+1) : strPath);
}

function ExtractSuffix(strName)
{
	var pos = strName.lastIndexOf(".");
	return (pos >= 0 ? strName.substr(pos+1) : "").toUpperCase();
}

function IsDupFilename(strName)
{
	for (var i = 0; i < cI; i++)
		if (images[i].name.toLowerCase() == strName.toLowerCase())
			return true;
	for (i = 0; i < cDL; i++)
		if (downloads[i].name.toLowerCase() == strName.toLowerCase())
			return true;
	return false;
}

function RequiredUniqueFilename(x, field)
{
	if (x != "" && IsDupFilename(x))
	{
		alert("Duplicate filenames are not allowed (" + x + ")");
		field.focus();
		return false;
	}
	return true;
}

function Arrayize(x)
{
	if (isArray(x))
		return x;
	else
		return new Array(x);
}

function ValidatePhone(frm, fieldname, message, blankOK)
{
	var fld = frm.elements[fieldname];
	var phone = Trim(fld.value);
	var outstr = "";
	if (blankOK && phone == "")
		return true;
	var valid = true;
	var thischar;
	for (var i = 0; i < phone.length && valid; i++)
	{
		thischar = phone.charAt(i);
		if (outstr.length >= 12)
			outstr = outstr + thischar;
		else if ("0123456789".indexOf(thischar) >= 0)
		{
			if (outstr.length == 0 && thischar == "1")
			{ }
			else
			{
				if (outstr.length == 3 || outstr.length == 7)
					outstr = outstr + "-";
				outstr = outstr + thischar;
			}
		}
		else if (outstr.length != 0 && outstr.length != 3 && outstr.length != 7)
			valid = false;
	}
	var matchResult = outstr.match(/^\d\d\d\-\d\d\d\-\d\d\d\d/);
	if (!valid || !isArray(matchResult) )
	{
		alert(message);
		fld.focus();
		return false;
	}
	fld.value = outstr;
	return true;
}

function isArray(obj) {
	try
	{
		return (typeof obj == "object" && !isNaN(obj.length) && (typeof (obj.tagName)) == "undefined");
	} catch(e)
	{
		return false;
	}
	
}

function GoToField(frm, fieldname)
{
	var fld = frm.elements[fieldname];
	(isArray(fld) ? fld[0] : fld).focus();
}

function validationError(frm, fldname, message)
{
	alert(message);
	var dest = frm.elements[fldname];
	if (isArray(dest))
		dest[0].focus();
	else
		dest.focus();
	return false;
}

function refreshParentChoices()
	{
	// alert("refresh parent choices");
	var frm = document.forms[0];
	var fldPageType = frm.pageType;
	var strPageType = fldPageType.options[fldPageType.selectedIndex].value;
	var newList = strPageType == "1" ? publicPages : staffPages;
	var parentID = frm.parentID;
	var strParentID = parentID.options[parentID.selectedIndex].value;
	if (strParentID == "") strParentID = parentID.options[parentID.selectedIndex].text;

	for (var i = 1; i <= newList.length; i++)
		{
		var breakout = newList[i-1].split("\t");
		parentID.options[i] = new Option(breakout[0], breakout[1]);
		if (breakout[1] == strParentID)
			parentID.options[i].selected = true;
		}

	// if the old list was longer, delete the extras.
	while(parentID.options.length > i)
		parentID.options[parentID.options.length-1] = null;
	}