var vValidationDelim = "_YY_";
//vValidationDelim = "_YY_";
//vDisallowedCharacters = Array('"','\\');

var vValidateDebug=0;

//--------------------------------------------------------------------------------------------------
/**
* This function parses the hidden validation fields and tests the input values against them.
* @param  Form    pFormObj The Form object to be validated
* @return boolean          False if any validation errors occur; true otherwise
*/
function fValidate (pFormObj)
{
   if (vValidateDebug) { alert('fValidate('+pFormObj+')'); }

   var lvElements = pFormObj.elements;
   var i;
   for (i=0; i<lvElements.length; i++)
   {
      // We're only interested in validation fields (which contain vValidationDelim)
      if (lvElements[i].name.indexOf(vValidationDelim) == -1) { continue; }
      
      // Parse the data and locate the associated input field
      var lvData = lvElements[i].name.split(vValidationDelim);
      var lvName  = lvData[0];
      var lvInput = pFormObj.elements[lvName];
      if (!lvInput) 
      { 
         if (vValidateDebug) { alert('Found validation field '+lvElements[i].name+' but no input field '+lvName); }
         continue; 
      }
      var lvDataType = lvData[1];
      var lvMin      = lvData[2];
      var lvMax      = lvData[3];
      var lvRequired = lvData[4];
      var lvValue    = lvInput.value;

      // Check required
      if (lvRequired=='Y' && (!lvValue || lvValue=='')) { return fValidationError(lvInput, 'Please enter a value'); }
      
      //alert('Field = '+lvInput.name+', Data Type = '+lvDataType+', value = '+lvValue);
      //alert('i = '+i+', Field = '+lvInput.name);
      
      // Check data types
      switch (lvDataType)
      {
         case "INT": if (!fValidateInt(lvInput, lvMin, lvMax))     { return false; }
                     break;
         case "DEC": if (!fValidateDecimal(lvInput, lvMin, lvMax)) { return false; }
                     break;
         default:    //if (!fValidateCharacters(lvInput))            { return false; }
      }
   }

   return true;
}


//--------------------------------------------------------------------------------------------------
/**
* Throws up an error message, puts the focus on the input field and returns false
* @param  Input   pInput   The Input object with an erroneous value
* @param  string  pMessage The error message
* @return boolean          False
*/
function fValidationError (pInput, pMessage)
{
   alert(pMessage);
   pInput.focus();
   return false;
}


//--------------------------------------------------------------------------------------------------
/**
* Tests the value of an input field against the vDisallowedCharacters array and calls fValidationError if necessary
* @param  Input   pInput The Input object to be tested
* @return boolean        False if an error occurs, true otherwise
*/
function fValidateCharacters (pInput)
{
   if (vValidateDebug) { alert('fValidateCharacters('+pInput+')'); }
   if (pInput.value == '') { return true; }  // Blank values pass

   for (j=0; j<vDisallowedCharacters.length; j++)
   {
      lvChar = vDisallowedCharacters[j];
      if (pInput.value.indexOf(lvChar) > -1)
      { 
         return fValidationError(pInput, 'The ' + lvChar + ' character is not allowed'); 
      }
   }
   return true;
}


//--------------------------------------------------------------------------------------------------
/**
* Tests the value of an "INT" input field and calls fValidationError if necessary
* @param  Input   pInput The Input object to be tested
* @param  number  pMin   The minimum allowed value
* @param  number  pMax   The maximum allowed value
* @return boolean        False if an error occurs, true otherwise
*/
function fValidateInt (pInput, pMin, pMax)
{
   if (vValidateDebug) { alert('fValidateInt('+pInput+', '+pMin+', '+pMax+')'); }
   if (pInput.value == '') { return true; }  // Blank values pass

   if (parseInt(pInput.value,10) != pInput.value) 
   { 
      return fValidationError(pInput, 'Please enter an integer value'); 
   }
   pInput.value = eval(pInput.value);
   return fValidateRange(pInput, pMin, pMax, 'an integer');
}


//--------------------------------------------------------------------------------------------------
/**
* Tests the value of a "DEC" input field and calls fValidationError if necessary
* @param  Input   pInput The Input object to be tested
* @param  number  pMin   The minimum allowed value
* @param  number  pMax   The maximum allowed value
* @return boolean        False if an error occurs, true otherwise
*/
function fValidateDecimal (pInput, pMin, pMax)
{
   if (vValidateDebug) { alert('fValidateDecimal('+pInput+', '+pMin+', '+pMax+')'); }
   if (pInput.value == '') { return true; }  // Blank values pass

   if (parseFloat(pInput.value) != pInput.value) 
   { 
      return fValidationError(pInput, 'Please enter a numeric value'); 
   }
   pInput.value = eval(pInput.value);
   return fValidateRange(pInput, pMin, pMax, 'a number');
}


//--------------------------------------------------------------------------------------------------
/**
* Tests the value of a numeric input field against a value range and calls fValidationError if necessary
* @param  Input   pInput      The Input object to be tested
* @param  number  pMin        The minimum allowed value
* @param  number  pMax        The maximum allowed value
* @param  string  pTypeString A "pretty" data type ("an integer", "a number", etc.) for the error message
* @return boolean             False if an error occurs, true otherwise
*/
function fValidateRange (pInput, pMin, pMax, pTypeString)
{
   if (vValidateDebug) { alert('fValidateRange('+pInput+', '+pMin+', '+pMax+', '+pTypeString+')'); }
   if (pMin == pMax) { return true; }
   
   lvValue = parseFloat(pInput.value, 10);
   if (lvValue < pMin || lvValue > pMax) 
   {
      return fValidationError(pInput, 'Please enter ' + pTypeString +' between ' + pMin + ' and ' + pMax);
   }
   return true;
}