// -------------------------------------------------------------------------
	//  Name: LoadPage
	//  Abstract: Load the specified page
	// -------------------------------------------------------------------------
	function LoadPage( strPage )
	{
		try
		{
			// Everything should be in Contents
			strPage = "/Contents/" + strPage;
			
			// Do it
			window.open( strPage, "_top" );
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::LoadPage( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: SetObjectClass
	//  Abstract: Set the style class for an object.
	// -------------------------------------------------------------------------
	function SetObjectClass( strClass )
	{
		try
		{
			window.event.srcElement.className = strClass;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::SetObjectClass( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: LaunchEmailLink
	//  Abstract: Launch a link to an email address.  Use javascript so we
	//			avoid spiders that fish email addresses for spam.
	// -------------------------------------------------------------------------
	function LaunchEmailLink( strTo, strSite )
	{
		try
		{
			var strLink = "";
			
			// Build link programmatically to prevent spam.
			strLink = "mailto:" + strTo + "@" + strSite;
			
			// Do it
			window.open( strLink, "_top" );
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::LaunchEmailLink( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: LoadListFromDatabase
	//  Abstract: Load the specified list with the values returned by the specified call.
	//			Use the predefined SQL statement or if that is blank build a generic
	//			SQL statement from the table, PK, name column, etc...
	// -------------------------------------------------------------------------
	function LoadListFromDatabase( objTargetList, intSelectDefaultID, blnEmptyOption, strCustomSQL, strTable, strPrimaryKey, strNameColumn, strSortColumn, blnOnlyActiveEntries )
	{
		try
		{
			var strResult = "";
			var astrValues = "";
			var intIndex = 0;
			var intID = 0;
			var strName = "";
			var optOption = 0;
			var intSelectedIndex = 0;
			
			// Empty the target list
			objTargetList.options.length = 0;
			
			// Make a remote scripting call
			var objRemoteScriptingResults = RSExecute( strWEB_PATH + "/Contents/Utilities/UtilitiesRemoteScripting1.asp", "GetListFromDatabase",strCustomSQL,strTable, strPrimaryKey, strNameColumn,strSortColumn,blnOnlyActiveEntries );
			
			// Check the call results
			if( WasCallSuccessful( "Client-Utilities-1.asp", "LoadListFromDatabase", objRemoteScriptingResults ) ) 
			{
				// Get the list
				var strResult = "" + objRemoteScriptingResults.return_value;	// Force copy by value using ""
				
				// Split the values, returned in the delimited string, into an array.
				astrValues = strResult.split( strDELIMITER );
				
				// Add an empty option ?
				if( blnEmptyOption ) objTargetList.options.add( Option( "", 0 ) );
				
				// Loop through all the returned name/value pairs
				for( intIndex = 0; intIndex < astrValues.length - 1; intIndex += 2 )
				{
					// Get the ID and name
					intID = astrValues[intIndex];
					strName = astrValues[intIndex + 1];
					
					// Make a new option
					optOption = new Option( strName, intID );
					
					// Add the option to the list
					objTargetList.options.add( optOption );
					
					// Select the default ID
					if( intSelectDefaultID == intID ) intSelectedIndex = intIndex;
				}
				
				// If list not empty select the first option or default ID
				if( objTargetList.options.length > 0 && objTargetList.selectedIndex < 0 ) objTargetList.selectedIndex = intSelectedIndex;
			}
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::LoadListFromDatabase( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: AddOptionToListInOrder
	//  Abstract: Use the bisection method to find the location of the new
	//			option in the list.
	//
	//			If we are adding a group of items from a sorted source list then
	//			all consecutive options will be added after the previous option.
	//			So, the calling function can use this information and tell us
	//			where to start searching in the list with the optional parameter
	//			intStartIndex
	// -------------------------------------------------------------------------
	function AddOptionToListInOrder( lstSelectList, objNewOption, intStartIndex )
	{
		try
		{
			var strNewOption = "" + objNewOption.text;			// Cast to string
			var strCurrentOption = "";
			var intStopIndex = lstSelectList.length - 1;		// 0 based
			var intMiddleIndex = 0;
			var intNewIndex = 0;
			
			// Empty list?
			if( lstSelectList.length == 0 )
			{
				// Yes, so just add the new option
				lstSelectList.options.add( objNewOption );
				
				// And highlight
				lstSelectList.options[ 0 ].selected = true;
			}
			else
			{
				// No start index given?  Just start at the beginning
				if( "" + intStartIndex == "" || "" + intStartIndex == "undefined" ) intStartIndex = 0;
				
				// Bisect the list
				while( intStartIndex < intStopIndex )
				{
					// Find the middle
					intMiddleIndex = parseInt( ( intStopIndex + intStartIndex ) / 2 );
					
					// Get the middle option text
					strCurrentOption = "" + lstSelectList.options[ intMiddleIndex ].text;		// Cast to string
					
					// Less than middle?
					if( strNewOption.localeCompare( strCurrentOption ) < 0 ) 
					{
						// Yes, move the Stop index up
						intStopIndex = intMiddleIndex;
					}
					else
					{
						// No, move the Start index down
						intStartIndex = intMiddleIndex + 1;
					}
				}
				
				// 1 last compare.  Goes before or after Start index option
				strCurrentOption = "" + lstSelectList.options[ intStartIndex ].text;		// Cast to string
				
				// Insert after?
				if( strNewOption.localeCompare( strCurrentOption ) >= 0 ) 
				{
					// Yes
					intStartIndex++;
				}
				
				// Insert at the specified location
				lstSelectList.options.add( objNewOption, intStartIndex );
				
				// And highlight
				lstSelectList.options[ intStartIndex ].selected = true;
				
				// Set new index
				intNewIndex = intStartIndex;
			}
			return intNewIndex;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::AddOptionToListInOrder( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: SelectOptionInList
	//  Abstract: Given a select list and an ID search the list for the option with
	//			the matching ID and select it.
	// -------------------------------------------------------------------------
	function SelectOptionInList( lstSelectList, intID )
	{
		try
		{
			var intIndex = 0;
			
			// Loop through all the options
			for( intIndex = 0; intIndex < lstSelectList.options.length; intIndex++ )
			{
				// Is this the ID we are looking for?
				if( lstSelectList.options[intIndex].value == intID ) 
				{
					// Select it
					lstSelectList.selectedIndex = intIndex;
					
					// Yes, so stop searching
					break;
				}
			}
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::SelectOptionInList( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: MoveListItems
	//  Abstract: Move all selected list items from the source to the destination list
	// -------------------------------------------------------------------------
	function MoveListItems( lstSourceList, lstDestinationList )
	{
		try
		{
			var intIndex = 0;
			var intCurrentIndex = -1;
			var intID = 0;
			var strName = "";
			var objOption = 0;
			var intNewIndex = 0;		// Where was the last item inserted 
			
			// Clear any selections in destination list
			for( intIndex = 0; intIndex < lstDestinationList.length; intIndex++ )
			{
				lstDestinationList.options[ intIndex ].selected = false;
			}
			
			// Loop through all the options in the source list to find the selected ones.
			for( intIndex = 0; intIndex < lstSourceList.options.length; intIndex++ ) 
			{
				// Is the option selected?
				if( lstSourceList.options[intIndex].selected == true )
				{
					// Yes
					
					// Save current index so we can highlight next when we are done
					intCurrentIndex = intIndex;
					
					// Get the ID and Name
					intID = lstSourceList.options[intIndex].value;
					strName = lstSourceList.options[intIndex].text;
					
					// Create a new blank option
					objOption = new Option( strName, intID );
					
					// Yes, then add item in order
					intNewIndex = AddOptionToListInOrder( lstDestinationList, objOption, intNewIndex );
					
					// Remove option from the source list
					lstSourceList.options.remove( intIndex );
					
					// Removing the option moves all the options up one so don't increment the index
					intIndex--;
				}
			}
			
			// Highlight next item in the source list
			HighlightNextInList( lstSourceList, intCurrentIndex );
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::MoveListItems( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: HighlightNextInList
	//  Abstract: Highlight the next item in the list.  Usually called after current
	//			item deleted/removed.
	// -------------------------------------------------------------------------
	function HighlightNextInList( lstList, intCurrentIndex )
	{
		try
		{
			// Are there any items in the list( might have deleted the last one )?
			if( lstList.length > 0 )
			{
				// Yes
				
				// Did we delete the last item?
				if( intCurrentIndex >= lstList.length )
				{
					// Yes, move the index to the new last item
					intCurrentIndex = lstList.length - 1;
				}
				
				// Select next closest item
				lstList.selectedIndex = intCurrentIndex;
			}
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::HighlightNextInList( ).\nError:" + expError.message );
		}
	} // HighlightNextInList
	
	
	//-------------------------------------------------------------------------
	//	Name: ClearList
	//	Abstract: Empty out a list
	//-------------------------------------------------------------------------
	function ClearList( objTargetList ) 
	{
		try
		{
			// Empty the target list
			objTargetList.options.length = 0;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::ClearList( ).\nError:" + expError.message );
		}
	}
	
	
	//------------------------------------------------------------------------- 
	//	Name: AddAllOptionToList 
	//	Abstract: Add an 'All' option to the beginning of a list 
	//------------------------------------------------------------------------- 
	function AddAllOptionToList( objTargetList ) 
	{ 
		try 
		{ 
			var objNewOption = new Option( "All", 0 ); 
			
			// Add to the front of the list
			objTargetList.options.add( objNewOption, 0 ); 
			
			// Select it
			objTargetList.selectedIndex = 0;
		} 
		catch( expError ) 
		{ 
			alert( "Client-Utilities-1.js::AddAllOptionToList( ).\nError:" + expError.message );
		}
	}
	
	
	//------------------------------------------------------------------------- 
	//	Name: TrimAllFormTextBoxes 
	//	Abstract: Trim all the textboxes on the form
	//------------------------------------------------------------------------- 
	function TrimAllFormTextBoxes( frmTarget ) 
	{ 
		try 
		{ 
			var intIndex = 0;
			var objCurrentElement = 0;
			
			// Loop through each element in the form
			for( intIndex = 0; intIndex < frmTarget.elements.length; intIndex++ )
			{
				// Next element
				objCurrentElement = frmTarget.elements.item( intIndex );
				
				// Textbox?
				if( objCurrentElement.type == "text" )
				{
					// Yes, trim it
					objCurrentElement.value = Trim( objCurrentElement.value );
				}
			}
		} 
		catch( expError ) 
		{ 
			alert( "Client-Utilities-1.js::TrimAllFormTextBoxes( ).\nError:" + expError.message );
		}
	}
	
	
	// ----------------------------------------
	//  Name: GetDate
	//  Abstract: Get the current date in yyyy/mm/dd format
	// ----------------------------------------
	function GetDate( )
	{
		try
		{
			var strMonth = "";
			var strDay = "";
			var strYear = "";
			var dNow = new Date( );
			var strDate = "";
			
			strMonth = "" + ( dNow.getMonth( ) + 1 );	//Cast to string.  Zero based?!?!?!
			strDay = "" + dNow.getDate( );				//Cast to string
			strYear = "" + dNow.getYear( );				//Cast to string
			
			// Pad with leading 0s
			if( strMonth.length < 2 ) strMonth = "0" + strMonth;
			if( strDay.length < 2 ) strDay = "0" + strDay;
			
			// Put it all together
			strDate = strYear + "/" + strMonth + "/" + strDay;
			
			return strDate;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::GetDate( ).\nError:" + expError.message );
		}
	}
	
	
	// ----------------------------------------
	//  Name: GetTime
	//  Abstract: Get the current time in HH:MM:SS format
	// ----------------------------------------
	function GetTime( )
	{
		try
		{
			var strHours = "";
			var strMinutes = "";
			var strSeconds = "";
			var dNow = new Date( );
			var strTime;
			
			// HH
			strHours = "" + ( dNow.getHours( ) );	//Cast to string.
			if( strHours.length < 2 )
			{
				strHours = "0" + strHours;
			}
			
			// MM
			strMinutes = "" + dNow.getMinutes( );	//Cast to string
			if( strMinutes.length < 2 )
			{
				strMinutes = "0" + strMinutes;
			}
			
			// SS
			strSeconds = "" + dNow.getSeconds( );	//Cast to string
			if( strSeconds.length < 2 )
			{
				strSeconds = "0" + strSeconds;
			}
			
			// HH:MM:SS
			strTime = strHours + ":" + strMinutes + ":" + strSeconds;
			
			return strTime;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::GetTime( ).\nError:" + expError.message );
		}
	}
	
	
	//-------------------------------------------------------------------------
	//  Name: ValidDate
	//  Abstract: Validates a date in format of YYYY/MM/DD which always
	//				sorts correctly.
	//-------------------------------------------------------------------------
	function ValidDate( strDate )
	{
		try
		{
			var blnResult = false;
			
			// yyyy/mm/dd.  \d = [0-9]
			strDatePattern = "^(19|20)\\d\\d[- /.](0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])$";
			
			// Match the pattern
			if( strDate.match( strDatePattern ) != null )
			{
				// Found a match
				blnResult = true;
			}
			
			return blnResult;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::ValidDate( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: GetCookie
	//  Abstract: Return the value of the specified cookie.  If not found then
	//			return the supplied default.
	// -------------------------------------------------------------------------
	function GetCookie( strCookieName, strDefault )
	{
		try
		{
			strCookieName = "; " + strCookieName;				// Add delimiters to to make it easier to search
			var strCookieValue = strDefault;
			var strCookies = "; " + document.cookie + ";";		// Add delimiters to to make it easier to search
			var intStart = -1;
			var intEnd = -1;
			
			// Does the cookie exist?
			if( strCookies.indexOf( strCookieName ) >= 0 )
			{
				// Find the start and end
				intStart = strCookies.indexOf( strCookieName ) + strCookieName.length + 1;
				intEnd = strCookies.indexOf( ";", intStart - 1 );
				
				// If there is a cookie value then get it otherwise use the default
				if( intStart <= intEnd ) 
				{
					strCookieValue = strCookies.substring( intStart, intEnd );
				}
			}
			
			// Debug
			//alert( "Cookies: " + document.cookie + "\n" );
			//alert( "Get: " + strCookieName + "=" + strCookieValue + "\n" );
			
			return strCookieValue;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::GetCookie( ).\nError:" + expError.message );
		}
	}
	
	
	//-------------------------------------------------------------------------
	//  Name: SetCookie
	//  Abstract: Save a name/value pair as a cookie
	//-------------------------------------------------------------------------
	function SetCookie( strName, strValue, blnDelete )
	{
		try
		{
			var strPath = "path=" + strWEB_PATH + ";";
			var dtmExpires = new Date( strCLIENT_COOKIE_EXPIRE );
			
			// Delete to cookie?
			if( blnDelete == "true" )
			{
				dtmExpires = new Date( strCLIENT_COOKIE_DELETE );
			}
			
			// Must be in this format or document.cookie won't save it!!!
			var strExpires = "expires=" +  dtmExpires.toGMTString( ) + ";";
			
			// Put it all together
			var strCookie = "" + strName + "=" + strValue + ";" + strPath + strExpires;
			
			// Save
			document.cookie = strCookie;
			
			// Debug
			//alert( "Set: " + strCookie );
			//alert( "Cookies: " + document.cookie + "\n" );
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::SetCookie( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: Replace
	//  Abstract: Replace all occurances of strFind with strReplace in strSource
	// -------------------------------------------------------------------------
	function Replace( strSource, strFind, strReplace )
	{
		try
		{
			var rexFind = 0;
			var strResult = "";
			
			// Regular expression for finding
			rexFind = new RegExp( strFind, "g"  );
			
			// Replace
			strResult = strSource.replace( rexFind, strReplace );
			
			return strResult;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::Replace( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: CleanString
	//  Abstract: Remove non-alphanumeric characters and trim leading and trailing
	//			white space.  Use the default pattern if none is specified.
	// -------------------------------------------------------------------------
	function CleanString( strString, strPattern )
	{
		try
		{
			var strBuffer = "" + strString;	// Force copy by value using ""
			
			// Any non-word character( excluding a comma, single quote and space ) 
			if( strPattern == null || strPattern == "" ) strPattern = /[^A-Za-z0-9_,' ]/gi;
			
			// Pattern with nothing
			strBuffer = strBuffer.replace( strPattern, "");
			
			// Trim
			strBuffer = Trim( strBuffer );
			
			return strBuffer;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::CleanString( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: Trim
	//  Abstract: Trim leading and trailing white space.
	// -------------------------------------------------------------------------
	function Trim( strString )
	{
		try
		{
			var strBuffer = "" + strString;	// Force copy by value using ""
			
			// Replace leading with space with nothing( global/ignore case )
			strBuffer = strBuffer.replace( /^\s*/gi, "");
			
			// Replace trailing with space with nothing( global/ignore case )
			strBuffer = strBuffer.replace( /\s*$/gi, "");
			
			return strBuffer;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::Trim( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: IsStrongPassword
	//  Abstract: Must be 6 characters long and contain at least 1 uppercase 
	//			letter, 1 lowercase letter and 1 non-letter.
	// -------------------------------------------------------------------------
	function IsStrongPassword( strPassword )
	{
		try
		{
			var blnIsStrongPassword = false;
			var blnContainsUpperCaseLetter = false;
			var blnContainsLowerCaseLetter = false;
			var blnContainsNonLetter = false;
			var strPattern = null;
			
			if( strPassword.length >= 6 )
			{
				// Look for an uppercase letter
				strPattern = /[A-Z]/g
				if( strPassword.match( strPattern ) != null ) blnContainsUpperCaseLetter = true;
				
				// Look for a lowercase letter
				strPattern = /[a-z]/g
				if( strPassword.match( strPattern ) != null ) blnContainsLowerCaseLetter = true;
				
				// Look for a non-letter
				strPattern = /[^A-Za-z]/g
				if( strPassword.match( strPattern ) != null ) blnContainsNonLetter = true;
				
				// Is this a strong password
				if( (blnContainsUpperCaseLetter == true) && (blnContainsLowerCaseLetter == true) && (blnContainsNonLetter == true) ) blnIsStrongPassword = true
			}
			return blnIsStrongPassword;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::IsStrongPassword( ).\nError:" + expError.message );
			
			return false;
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: SetBusyCursor
	//  Abstract: Lock the form and change the cursor to an hourglass if busy
	//			otherwise set to normal
	// -------------------------------------------------------------------------
	function SetBusyCursor( frmTargetForm, blnBusy )
	{
		try
		{
			var blnInternetExplorer = navigator.appName.toLowerCase() == "microsoft internet explorer";
			
			var intIndex = 0;
			
			// Busy?
			if( blnBusy == true )
			{
				// Yes, disable
				frmTargetForm.style.cursor = "wait";
				
				// IE?
				if( blnInternetExplorer )
				{
					frmTargetForm.setCapture( );
				}
			}
			else
			{
				// No, enable
				frmTargetForm.style.cursor = "auto";
				
				// IE?
				if( blnInternetExplorer )
				{
					frmTargetForm.releaseCapture( );
				}
			}
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::SetBusyCursor( ).\nError:" + expError.message );
		}
	}
	
	
	// -------------------------------------------------------------------------
	//  Name: OpenModalDialog
	//  Abstract: Open the specified page in a modal window
	// -------------------------------------------------------------------------
	function OpenModalDialog( strPage, intHeight, intWidth, objDialogArguments )
	{
		var objResult = 0;
		
		try
		{
			var strDialogOptions = "border=thin;center=yes;dialogHeight=" + intHeight + "px;dialogWidth=" + intWidth + "px;help=no;maximize=no;minimize=no;status=no;";
			
			objResult = window.showModalDialog( strPage, objDialogArguments, strDialogOptions );
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::OpenModalDialog( ).\nError:" + expError.message );
		}
		finally
		{
			// Return result
			return objResult;
		}
	}
	
	
	//-------------------------------------------------------------------------
	//	Name: DumpValues
	//	Abstract: Dump every name/value pair for an element.  Debug only.
	//-------------------------------------------------------------------------
	function DumpValues( eSource )
	{
		try
		{
			var strMessage = "";
			var intCount = 0;
			
			for( objItem in eSource )
			{
				strMessage += objItem + strDELIMITER + eSource[objItem] + ", ";
				if( intCount++ % 3 == 1 )
				{
					strMessage += "\n";
				}
			}
			alert( strMessage );
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::DumpValues( ).\nError:" + expError.message );
		}
	}
	
	
	//-------------------------------------------------------------------------
	//	Name: BuildExceptionMessage
	//	Abstract: Build and return a string that holds the exception message.
	//-------------------------------------------------------------------------
	function BuildExceptionMessage( expError, strPageName, strFunctionName )
	{
		var strErrorMessage = "";
		
		try
		{
			// Start with Page and function names
			strErrorMessage = strPageName + "::" + strFunctionName + "().\n";
			
			// Is there an error number? ( Only Internet Explorer has an error number );
			if( expError.number )
			{
				strErrorMessage = strErrorMessage + "Error Number: " + expError.number + "\n";
			}
			
			// Append error name and message
			strErrorMessage = strErrorMessage + expError.name + ": " + expError.message;
		}
		catch( expError )
		{
			alert( "Client-Utilities-1.js::DumpValues( ).\n" + expError.name + ": " + expError.message );
		}
		return strErrorMessage;
	}
	
	
	// ------------------------------------------------------------------------------------------
	// Name: ShowJavascriptSections
	// Abstract: Search the document for elements that use the className clsANY_JavascriptOnly.
	//	     When found we remove this class, and thus show the element.
	// ------------------------------------------------------------------------------------------
	function ShowJavascriptSections()
	{
		try
		{	
			var aobjElements, objElement;
			var intIndex = 0;
			
			// Get all of the document elements
			aobjElements = document.getElementsByTagName("*");
			
			// Loop through all the document elements
			for( intIndex = 0; intIndex < aobjElements.length; intIndex++ )
			{
				// Get this element
				objElement = aobjElements[intIndex];
				
				// Does it use clsANY_JavascriptOnly?
				if( objElement.className.search(/ *clsANY_JavascriptOnly/gi ) != -1 )
				{
					// Yes, remove it
					objElement.className = objElement.className.replace(/clsANY_JavascriptOnly/gi, '');
				}
				
				// No, but does it use clsANY_JavascriptOff?
				else if( objElement.className.search(/ *clsANY_JavascriptOff/gi ) != -1 )
				{
					// Yes, we only want to see this if there is not JS.  Hide the element
					objElement.style.display="none";
				}
				
				// No, but does it use the no script class?
				else if( objElement.className.search(/ *clsNoScript/gi ) != -1 )
				{
					// Yes, don't display it
					objElement.style.display="none";
				}
				
				// No, but does it use the no script class for any element?
				else if( objElement.className.search(/ *clsANY_NoScript/gi ) != -1 )
				{
					// Yes, don't display it
					objElement.style.display="none";
				}
			}
		}
		catch( expError )
		{ 
			alert( BuildExceptionMessage( expError, "ShowJavascriptSections", "ShowJavascriptSections" ) ); 
		}
	} // ShowJavascriptSections
	
	
	// ------------------------------------------------------------------------------------------
	// Name: LimitTextLength
	// Abstract: Make sure the text in the given textarea object does not go over the given maximum 
	//	     character count.  Optionally use the objCountField to track the remaining number 
	//	     of available characters.
	// ------------------------------------------------------------------------------------------
	function LimitTextLength(objTextArea, objCountField, lngMaximum) 
	{	
		try
		{
			// Is it too big?
			if(objTextArea.value.length > lngMaximum) 
			{
				// Yes, trim it
				objTextArea.value = objTextArea.value.substring(0, lngMaximum);
				
				// Do I have a count field object?
				if( objCountField )
				{
					// Yes, set zero value and focus
					objCountField.value = '0  -  Limit Met';
					objCountField.select();
					objCountField.focus();
				}
			}
			else
			{
				// No, do I have a count field object?
				if( objCountField )
				{
					// Yes, update 'characters left' counter
					objCountField.value = lngMaximum - objTextArea.value.length;
					
					// Set Limit met message if needed
					if( objCountField.value <= 0 )
					{
						objCountField.value = '0  -  Limit Met';
					}
				}
			}
		}
		catch( expError ) // Format and display errors
		{
			alert( BuildExceptionMessage( expError, 'Client-Utilities-1.js', 'LimitTextLength' ) ); 
		}
	} // LimitTextLength