//--- Notice ------------------------------------------------------------------
//
// CopyRight (c) 2000-2003, Cody Adams
// All rights reserved
//
// This JavaScript source code is the property of
// Cody Adams, cody@codalli.com  
//
// Unauthorized reproduction of part or all of the following content within
// this file is prohibited AND a violation of U.S. law.  
//
//-----------------------------------------------------------------------------
//
// Created by Cody Adams
// 24 October 2000
//
//--- Description -------------------------------------------------------------
// 
//
//
//
//--- Revisions ---------------------------------------------------------------
//
// 01 September 2002 - added function stripWS(...)
//
//
//-----------------------------------------------------------------------------

{
 var onExecute = new Array();      
 
 var errorMsg = new Array();
 var blank = "";
	 
	 
 //-- Localization ------------------------------------------------------------
 var cky1 = "This web site requires the use of cookies.\n",
     cky2 = "Certain features may not work properly and in some\n",
     cky3 = "cases you will not be allowed to continue.\n\n",
	 cky4 = "Please make sure that the use of cookies has been\n",
	 cky5 = "enabled through your browser\'s settings.";
}












//-----------------------------------------------------------------------------
// This function
function executeMe()
{
 for(var x=0;x<onExecute.length;x++)
 {
  eval(onExecute[x]);
 } 
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function tracks the list of errors that occur 
// during validation
function addError(which)
{
 errorMsg[errorMsg.length] = which; 
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function replaces the function statusMe(...) which has been depricated 
// because it seems to be causing javascript errors in Netscape 7.x.
function marquee(what)
{
 this.window.status = (typeof(what)== "undefined")?"" : what;
 // Returning true displays text in the status bar.
 // Returning false prevents text from being displayed.
 if (typeof(displayMarquee) != "undefined")
  return displayMarquee;
  
 else
  return false;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function displays the list of errors that occur 
// during validation
function displayErrors()
{
 // Do the grammar thing
 if(errorMsg.length == 1)
 { 
  var pError = "error has",
      pNeed  = "needs";
 }
  
 else
 { 
  var pError = "errors have",
      pNeed  = "need";
 }
 
 
 if(errorMsg.length >400)
 {
  var msg1 = "Some of the required fields are either missing or are incorrect.\n",
      msg2 = "Please review the form and make the proper corrections.";
      
  alert(msg1+msg2)
 }
 
 else
 {
  var msg1 = "The following "+pError+" occurred and "+pNeed+"\n",
      msg2 = "to be corrected before continuing:\n\n",
	  msg3 = blank;
	  
  for(var i=0; i<errorMsg.length; i++)
  {
   msg3 += '  - '+errorMsg[i];
  }
  
  alert(msg1+msg2+msg3);
 }
 
 errorMsg.length = 0;
 errorMsg = new Array();
}
//-----------------------------------------------------------------------------




//-----------------------------------------------------------------------------
// This function validates text fields to see that they 
// are not blank, or contain numeric values
function validateText(that,allowBlank)
{
 var blankAllowed = (typeof(allowBlank) == "undefined")?false :allowBlank;



 if(stripWS(that.value) == blank && !blankAllowed)
  return false;
 
 else
  return true;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function validates zipcodes to verify that they 
// are sized correctly and are valid numbers
function validateZipCode(zipcode)
{
 var thisZipCode = stripWS(zipcode.value);
 
 return (thisZipCode.length == 5 && !isNaN(thisZipCode,10));
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function checks to see that the length of a password 
// is at least six characters if not blank
function validatePassword(password,minlength)
{
 var thisLength = (typeof(minlength)!="undefined")?minlength :6;
 var thisValue  = stripWS(password.value);
 
 return (password.value != blank && password.value.length < thisLength)
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function checks phone numbers by verifying that the argument passed
// is a number and that the length of the number is the digits.
function validatePhone(number)
{
 var thisNumber = stripWS(number);

 return (!isNaN(thisNumber,10) && thisNumber.length == 10);
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function checks phone numbers by verifying that the 
// argument passed is a number and that the length of the 
// number is the digits.
function validateEmail(address)
{
 return (stripWS(address) != blank)
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function validates that the argument passed is not
// blank and is a number.
function validateNumber(number,allowBlank,minNumber,maxNumber)
{ 
 if(typeof(number) != "undefined")
 {
  // First, check to see that the number is not blank
  if(number.length > 0)
  {
   // Check to see if the value is a valid number
   if(isNaN(number))
    return "isNaN";
  
   else if (typeof(minNumber) != "undefined" && number < minNumber)
    return "less than";
  
   else if (typeof(maxNumber) != "undefined" && number > maxNumber)
    return "greater than";
    
   else
    return "ok";
  }
 
  else if(typeof(allowBlank) != "undefined" && !allowBlank)
    return "blank";
  
  else
    return "ok";
 }
 
 else
 {
  var msg1 = "runtime error ~fUtility.mgr:validateNumber(...)\n\n";
      
  alert(msg1);
 }
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function pads numbers to the hundredth decimal place
function DollarFormat(number)
{
 var myNumber = number;
 
 // Isolate the decimal value
 tArg1 = myNumber;
 tArg2 = parseInt(myNumber);
 tArg3 = tArg1 - tArg2;

 if(tArg3 == 0)
 { myNumber += ".00"; }
	
 else
 {
  tArg1 = (Math.round(tArg3 * 10)*100)/100;
  tArg2 = parseInt(tArg1);
  tArg3 = tArg1 - tArg2;
  
  if(tArg3 == 0)
  { myNumber += "0"; }
 }
 
 // return myNumber;
 return Math.round(number*100)/100;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function is used to resolve case sensitivity conflicts when ColdFusion
// dynamically writes field names. (They are written in uppercase).
function setField(thatForm,fieldName,fieldValue)
{
 with(thatForm)
 {
  for(var x=0;x<elements.length;x++)
  {
   if(elements[x].name.toLowerCase() == fieldName.toLowerCase())
   {
    elements[x].value = fieldValue;
    break;
   }
  }
 }
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function is used to resolve case sensitivity conflicts when ColdFusion
// dynamically writes field names. (They are written in uppercase).
function getField(thatForm,fieldName)
{
 var myValue = "undefined";
 
 with(thatForm)
 {
  for(var x=0;x<elements.length;x++)
  {
   if(elements[x].name.toLowerCase() == fieldName.toLowerCase())
   {
    myValue = elements[x].value;
    break;
   }
  }
 }
 
 return myValue;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function is used for debugging and alerts the
// current value of a specified field.
function alertField(thatForm,fieldName)
{
 var myValue = "undefined";

 with(thatForm)
 { 
  for(var x=0;x<elements.length;x++)
  {
   if(elements[x].name.toLowerCase() == fieldName.toLowerCase())
   {
    myValue = elements[x].value;
    break;
   }
  }
 }
 
 alert(myValue);
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function removes all white space from a given string
function stripWS(thatString)
{
 return thatString.replace(/ /g,'');
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function
function setForm()
{
 if(window != top)
 {
  if(typeof(parent.content.document.cForm) != "undefined")
   return parent.content.document.cForm;
  
  else
   return "undefined";
 }
 
 else
 {
  return this.document.cForm;
 }
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function 
function checkCookies()
{
 // Look for the preferences cookie first
 myCookie = document.cookie.toLowerCase();

 if(myCookie.indexOf("preferences") > -1)
 { return true; }
 
 
 
 else
 // The cookie did not exist so try to write
 // a default cookie.
 {
  var pTheme = "theme=default,",
      pLanguage = "locale=en_US";
	  
  document.cookie = "PREFERENCES="+escape(pTheme+pLanguage);
  
  if(myCookie.indexOf("PREFERENCES") > -1)
  { return true; }
 
  else
  {
   alert(cky1+cky2+cky3+cky4+cky5)
   
   return false;
  }
 }
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function fixes the month/day fieldsin the registration page.
function fixMonth()
{
 var months = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
 
 with(this.document.cForm)
 {
  var ddIndex = tDay.selectedIndex,
      yyIndex = tYear.selectedIndex,
	  mmIndex = tMonth.selectedIndex;
 
  // Check for february leapyear
  if(mmIndex == 2 && yyIndex >0)
   months[1] = (isLeapYear(tYear.options[yyIndex].text))?29 :28;

 
  tDay.length = months[mmIndex-1] +1;
  tDay.options[0].text = "--";
  
  for(i=1; i<tDay.length; i++)
  {
   tDay.options[i].value = i;
   tDay.options[i].text = i;
  }
  
  tDay.selectedIndex = (ddIndex > tDay.length) ?tDay.length-1 : ddIndex;
 }
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function
function isLeapYear(whichYear)
{
 var benchMark = 1884;
 
 var myDate = new Date();
     myYear = myDate.getFullYear();
	 
 var isLeapYear = false;
 
 for(var i=benchMark;i<=myYear;i+=4)
 {
  if(whichYear == i)
  {
   isLeapYear = true;
   break;
  }
 }

 return isLeapYear;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function switches the form action form http to https
function secureForm(thatForm,secureForm)
{
 var ok2secure = (typeof(secureForm) == "undefined") ?true : secureForm;
 var thisFormAction  = thatForm.action; 
 var alreadySecure   = thisFormAction.indexOf("https://") >= 0;
 
 if(alreadySecure && !ok2secure)
 {
  // unsecure the form
  thisFormAction = thisFormAction.replace(/https/,"http");
 }
 
 else if(!alreadySecure && ok2secure)
 {
  // secure the form
  thisFormAction = thisFormAction.replace(/http/,"https");
 }
 
 thatForm.action = thisFormAction;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function
function isSecured(thatForm)
{
 var myAction = thatForm.action;
 
 var securedIndex = myAction.indexOf("https");
 
 if(securedIndex >= 0)
  return true;
  
 else
  return false;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function
function rememberMe(thatForm,how)
{
 var thisMethod = (typeof(how) != "undefined")? how: "string";
 var thisValue;
 
 if(thisMethod == "string")
  var memoryString = "";
 else
  var memoryString = new Array();
 
 
 
 with(thatForm)
 {
  for(var i=0;i<elements.length;i++)
  {
   if(elements[i].type == "select-one")
    thisValue = elements[i].selectedIndex;
   	
   else if(elements[i].type == "text"     ||
           elements[i].type == "textarea" ||
		   elements[i].type == "file"     ||
		   elements[i].type == "password" ||
          (elements[i].type == "checkbox" && elements[i].checked) ||
          (elements[i].type == "radio" && elements[i].checked))
    thisValue = elements[i].value
	
   else thisValue = "hidden";
	
	
   if(thisMethod == "string")
	memoryString += thisValue
	
   else if(thisMethod == "structure")
	memoryString[elements[i].name] = thisValue;
	
   else 
	memoryString[memoryString.length] = thisValue;   
  } // end for(i)
 } // end with(form)
 

  return memoryString;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function
function hasChanged(array1,array2)
{
 var hasChanged = false;
 
 for(var x=0;x<array2.length;x++)
 {
  if(array1[x] != array2[x])
  {
   hasChanged = true;
   break;
  }
 }

 return hasChanged;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function
function compareObjects(obj1,obj2)
{
 var tempArray = new Array();
 
 for(var x=0;x<obj1.length;x++)
 {
  if(obj1[x].type == "select-one")
   thisValue = obj1[x].selectedIndex;
	  
  else if(obj1[x].type == "text"     ||
          obj1[x].type == "textarea" ||
		  obj1[x].type == "password" ||
         (obj1[x].type == "checkbox" && obj1[x].checked) ||
         (obj1[x].type == "radio"    && obj1[x].checked))
   thisValue = obj1[x].value;
	  
  else thisValue = "hidden";
	 
  
  
  if(thisValue != "hidden" && thisValue != obj2[x])
   tempArray[tempArray.length] = obj1[x].name;
 } // end for(x)
 
 return tempArray;
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function was found at http://www.webreference.com/js/tips/990928.html
function isEmail(str)
{
 // are regular expressions supported?
 var supported = 0;

 if (window.RegExp) 
 {
   var tempStr = "a";
   var tempReg = new RegExp(tempStr);
  
   if (tempReg.test(tempStr))
    supported = 1;
 }
 
 if (!supported) 
  return (str.indexOf(".") > 2) && (str.indexOf("@") > 0);
 
 var r1 = new RegExp("(@.*@)|(\\.\\.)|(@\\.)|(^\\.)");
 var r2 = new RegExp("^.+\\@(\\[?)[a-zA-Z0-9\\-\\.]+\\.([a-zA-Z]{2,3}|[0-9]{1,3})(\\]?)$");
  return (!r1.test(str) && r2.test(str));
}
//-----------------------------------------------------------------------------



//-----------------------------------------------------------------------------
// This function 
function signUp(domain)
{
 var sURL = domain;
 
 if(navigator.appName == "Netscape")
 {
  var jHt = 500,
      jWd = 900;
	  
  var jTop  = ",screenx=100",
      jLeft = ",screeny=100";
 }
 
 if(navigator.appName == "Microsoft Internet Explorer")
 {
  var jHt = 500,
      jWd = 800;
	  
  var jTop  = ",top=100",
      jLeft = ",left=100";
 }
	
 sWin = window.open(sURL,
	                'SignUp',
					'height='+jHt+',width='+jWd	+',menubar,scrollbars,resizable,status' +jTop +jLeft);
}
//-----------------------------------------------------------------------------






function changeTask(thatTask,thatForm)
{
 with(thatForm)
 {
  taskrequest.value = thatTask;
  submit(); 
 }
}

function manageObject(thatForm,thatObj,thatValue,thatTask)
{
 ok2continue = true;
 
 var msg1 = '',
     msg2 = 'Are you sure you want to ' +thatTask.toLowerCase()+ ' this record?';

 if(thatTask.toLowerCase() == 'purge')
  msg1 = 'A purged record cannot be recovered from the database!\n';
 
 if(thatTask.toLowerCase() == 'delete' 
 || thatTask.toLowerCase() == 'purge')
 {
  ok2continue = confirm(msg1 +msg2);
 }
 
 if(ok2continue)
 {
  thatForm[thatObj].value = thatValue;
  changeTask(thatTask,thatForm);
 }
}

function changeDepartment(thatDepartment,thatForm)
{
 with(thatForm)
 {
  taskrequest.value = '';
  manager.value     = thatDepartment;
  submit()
 }
}

function changeManager(thatManager,thatForm)
{
 with(thatForm)
 {
  taskrequest.value = '';
  assistantManager.value = thatManager;
  submit();
 }
}

function checkboxToRadio(that)
{
 with(this.document.eForm)
 {
  for(i=0;i<elements.length;i++)
  {
   if(that.checked 
   && elements[i].name == that.name 
   && elements[i].value != that.value 
   && that.type == elements[i].type)
   {
    elements[i].checked = false;
   }   
  }
 }
}


function wait(w,h)
{
 if(typeof(w) == 'undefined')
  w = 31;
 
 if(typeof(h) == 'undefined')
  h = 200; 
  
 screenwidth  = (screen.width/2) - w;
 screenheight = (screen.height/2) -h;
	
 wait = this.document.getElementById('wait');
 wait.style.visibility = 'visible';
 wait.style.position   = 'absolute';
 wait.style.top        = screenheight; 
 wait.style.left       = screenwidth;
}



function formatUSCurrency(num,nocomma,raw) 
{
 if(typeof(raw) == 'undefined')
  raw = true;

 if(typeof(nocomma) == 'undefined')
  nocomma = true;

 num = num.toString().replace(/\$|\,/g,'');
 
 if(isNaN(num))
  num = "0";
 
 sign  = (num == (num = Math.abs(num)));
 num   = Math.floor(num*100+0.50000000001);
 cents = num%100;
 num   = Math.floor(num/100).toString();
 
 if(cents<10)
  cents = "0" + cents;
  
 if(nocomma)  
 {
  return (num + '.' + cents);
 }
 else
 {
  for (var i = 0; i < Math.floor((num.length-(1+i))/3); i++)
  {
   num = num.substring(0,num.length-(4*i+3))+','+
   num.substring(num.length-(4*i+3));
  }
 }
  
 if(raw)
  return (num + '.' + cents);
 else
  return ((sign)?'':'-') + '$' + num + '.' + cents;
}