// ----------------------------------------------------------------------
// Javascript form validation routines.
// Author: Stephen Poley
//
// Simple routines to quickly pick up obvious typos.
// All validation routines return true if executed by an older browser:
// in this case validation must be left to the server.
//
// Update Aug 2004: have tested that IE 5.0 and IE 5.5 both support DOM model
// sufficiently well, so innerHTML option removed (redundant).
// ----------------------------------------------------------------------

var nbsp = 160;    // non-breaking space char
var node_text = 3; // DOM text node-type
emptyString = /^\s*$/

// -----------------------------------------
//                  trim
// Trim leading/trailing whitespace off string
// -----------------------------------------

function trim(str)
{
  return str.replace(/^\s+|\s+$/g, '')
};

// -----------------------------------------
//                  msg
// Display warn/error message in HTML element
// commonCheck routine must have previously been called
// -----------------------------------------

function msg(fld,     // id of element to display message in
             msgtype, // class to give element ("warn" or "error")
             message) // string to display
{

  // setting an empty string can give problems if later set to a 
  // non-empty string, so ensure a space present. (For Mozilla and Opera one could 
  // simply use a space, but IE demands something more, like a non-breaking space.)
  var dispmessage;
  
  
  if (emptyString.test(message)){ 
    dispmessage = String.fromCharCode(nbsp);    
  }else{  
    dispmessage = message;
  }

  var elem = document.getElementById(fld);
  elem.firstChild.nodeValue = dispmessage;  

  elem.className = msgtype;
};

// -----------------------------------------
//            commonCheck
// Common code for all validation routines to:
// (a) check for older / less-equipped browsers
// (b) check if empty fields are required
// Returns true (validation passed), 
//         false (validation failed) or 
//         proceed (don't know yet)
// -----------------------------------------

var proceed = 2;  

function commonCheck    (vfld,   // element to be validated
                         ifld,   // id of element to receive info/error msg
                         reqd,   // true if required
						 st_reqd) //local string for "required"
{
  if (!document.getElementById) 
    return true;  // not available on this browser - leave validation to the server
  var elem = document.getElementById(ifld);
  if (!elem.firstChild)
    return true;  // not available on this browser 
  if (elem.firstChild.nodeType != node_text)
    return true;  // ifld is wrong type of node  

  if (emptyString.test(vfld.value)) {
    if (reqd) {
      msg (ifld, "error", st_reqd);  
      vfld.focus();
      return false;
    }
    else {
      msg (ifld, "warn", "");   // OK
      return true;  
    }
  }
  return proceed;
}

// -----------------------------------------
//            validatePresent
// Validate if something has been entered
// Returns true if so 
// -----------------------------------------

function validatePresent(vfld,   // element to be validated
                         ifld )  // id of element to receive info/error msg
{
  var stat = commonCheck (vfld, ifld, true);
  if (stat != proceed) return stat;

  msg (ifld, "warn", "");  // OK
  return true;
};

// -----------------------------------------
//               validateEmail
// Validate if e-mail address
// Returns true if so (and also if could not be executed because of old browser)
// -----------------------------------------

function validate_email (vfld,				// element to be validated
                        			ifld,				// id of element to receive info/error msg
                        			reqd,				// true if required
									st_reqd,			// local string for "required"
									st_email_def,	// local string for email valid chars
									st_check)		// local string for "unusual but valid please check"
{
  var stat = commonCheck (vfld, ifld, reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off
  var email = /^[^@]+@[^@.]+\.[^@]*\w\w$/
  if (!email.test(tfld)) {
    msg (ifld, "error", st_email_def);
    vfld.focus();
    return false;
  }

  var email2 = /^[A-Za-z][\w.-]+@\w[\w.-]+\.[\w.-]*[A-Za-z][A-Za-z]$/
  if (!email2.test(tfld)) 
    msg (ifld, "warn", st_check);
  else
    msg (ifld, "ok", "");// OK
  return true;
};


// -----------------------------------------
//            validate_phone
// Validate telephone number
// Returns true if so (and also if could not be executed because of old browser)
// Permits spaces, hyphens, brackets and leading +
// -----------------------------------------

function validate_phone (vfld,         // element to be validated
						ifld,         // id of element to receive info/error msg
						reqd,         // true if required
						st_reqd,      // local string for "required"
						st_telnr_def, // local string for phone valid chars
						st_check)     // local string for "unusual but valid please check"
{
  var stat = commonCheck (vfld, ifld, reqd, st_reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off
  var telnr = /^\+?[0-9 ()-]+[0-9]$/
  if (!telnr.test(tfld)) {
    msg (ifld, "error", st_telnr_def);
    vfld.focus();
    return false;
  }

  var numdigits = 0;
  for (var j=0; j<tfld.length; j++)
    if (tfld.charAt(j)>='0' && tfld.charAt(j)<='9') numdigits++;

  if (numdigits<6) {
    msg (ifld, "error", st_telnr_def);
    vfld.focus();
    return false;
  }

  if (numdigits>14)
    msg (ifld, "warn", st_check);
  else { 
    if (numdigits<10)
      msg (ifld, "warn", st_check);
    else
      msg (ifld, "ok", "");// OK
  }
  return true;
};

// -----------------------------------------
//             validateAge
// Validate person's age
// Returns true if OK 
// -----------------------------------------

function validateAge    (vfld,   // element to be validated
                         ifld,   // id of element to receive info/error msg
                         reqd)   // true if required
{
  var stat = commonCheck (vfld, ifld, reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);
  var ageRE = /^[0-9]{1,3}$/
  if (!ageRE.test(tfld)) {
    msg (ifld, "error", "ERROR: not a valid age");
    vfld.focus();
    return false;
  }

  if (tfld>=200) {
    msg (ifld, "error", "ERROR: not a valid age");
    vfld.focus();
    return false;
  }

  if (tfld>110) msg (ifld, "warn", "Older than 110: check correct");
  else {
    if (tfld<7) msg (ifld, "warn", "Bit young for this, aren't you?");
    else        msg (ifld, "ok", "");// OK
  }
  return true;
};



// -----------------------------------------
//             validate_int
// Validate an integer
// Returns true if OK 
// -----------------------------------------

function validate_int (vfld,         // element to be validated
								ifld,         // id of element to receive info/error msg
								reqd,         // true if required
								st_reqd,      // local string for "required"
								st_def) // local string for int valid 

{
  var stat = commonCheck (vfld, ifld, reqd, st_reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off
  var intRE = /^\-?[0-9]*$/
  if (!intRE.test(tfld)) {
    msg (ifld, "error", st_def);
    vfld.focus();
    return false;
  } else { 
      msg (ifld, "ok", "");// OK
  }
  return true;
};



// -----------------------------------------
//             validate_int
// Validate an integer
// Returns true if OK 
// -----------------------------------------

function validate_float(vfld,         // element to be validated
								ifld,         // id of element to receive info/error msg
								reqd,         // true if required
								st_reqd,      // local string for "required"
								st_def) // local string for int valid 

{

  var stat = commonCheck (vfld, ifld, reqd, st_reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off
  var intRE = /^\-?[0-9]*.[0-9]*$/
  if (!intRE.test(tfld)) {
    msg (ifld, "error", st_def);
    vfld.focus();
    return false;
  } else { 
      msg (ifld, "ok", "");// OK
  }
  return true;
};


// -----------------------------------------
//               validate_string
// Validate if string between 10 and 300 char long
// Returns true if so (and also if could not be executed because of old browser)
// -----------------------------------------

function validate_comment (vfld,   // element to be validated
							ifld,   // id of element to receive info/error msg
							reqd,      // true if required
							st_reqd,  // local string for "required"
							st_def)   // local string for detailed valid username
{
  return true;
  var stat = commonCheck (vfld, ifld, reqd,st_reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off

  var stringRE = /^.{10,300}$/
  if (!stringRE.test(tfld)) {
    msg (ifld, "error", st_def);
    vfld.focus();
    return false;
  }
  
  msg (ifld, "ok", "");// OK
  return true;
};



// -----------------------------------------
//               validate_username
// Validate if password with no space, only characters, digits and between 6 and 16 char long
// Returns true if so (and also if could not be executed because of old browser)
// -----------------------------------------

function validate_username (vfld,     // element to be validated
							ifld,     // id of element to receive info/error msg
							reqd,      // true if required
							st_reqd,  // local string for "required"
							st_def)   // local string for detailed valid username
{

  var stat = commonCheck (vfld, ifld, reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off

  var usernameRE = /^.{4,17}$/
  if (!usernameRE.test(tfld)) {
    msg (ifld, "error", st_def);
    vfld.focus();
    return false;
  }
  
    msg (ifld, "ok", "");// OK
  return true;
};



// -----------------------------------------
//               validate_password
// Validate if password with no space, only characters, digits and between 6 and 16 char long
// Returns true if so (and also if could not be executed because of old browser)
// -----------------------------------------

function validate_password (vfld,   // element to be validated
							ifld,   // id of element to receive info/error msg
							reqd,      // true if required
							st_reqd,  // local string for "required"
							st_def)   // local string for detailed valid username
{

  var stat = commonCheck (vfld, ifld, reqd,st_reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off

  var passwordRE = /^.{6,17}$/
  if (!passwordRE.test(tfld)) {
    msg (ifld, "error", st_def);
    vfld.focus();
    return false;
  }
  
  msg (ifld, "ok", "");// OK
  return true;
};



// -----------------------------------------
//               validate_namelike
// Validate if name like with  characters, digits and between 2 and 32 char long
// Returns true if so (and also if could not be executed because of old browser)
// -----------------------------------------

function validate_namelike (vfld,	// element to be validated
							ifld,   			// id of element to receive info/error msg
							reqd,     	 	// true if required
							st_reqd,  		// local string for "required"
							st_def)   		// local string for detailed valid name like
{

  var stat = commonCheck (vfld, ifld, reqd,st_reqd);
  if (stat != proceed) return stat;

  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off

  var namelikeRE = /^.{2,33}$/
  if (!namelikeRE.test(tfld)) {
    msg (ifld, "error", st_def);
    vfld.focus();
    return false;
  }
  
  msg (ifld, "ok", "");// OK
  return true;
};



// -----------------------------------------
//               validate_ serial_number
// Validate if e-mail address
// Returns true if so (and also if could not be executed because of old browser)
// -----------------------------------------
function validate_serial_number(vfld,	// element to be validated
							ifld,   			// id of element to receive info/error msg
							reqd,     	 	// true if required
							st_reqd,  		// local string for "required"
							st_def)   		// local string for detailed valid serial number like
{

  var stat = commonCheck (vfld, ifld, reqd,st_reqd);
  if (stat != proceed) return stat;


  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off

	if (tfld.length != 18){
		msg (ifld, "error", st_def);
		return false;
	}

  var sn_likeRE = /^.{3} .{3} .{3} .{3} .{2}$/
  if (!sn_likeRE.test(tfld)) {
    msg (ifld, "error", st_def);
    vfld.focus();
    return false;
  }
  
  msg (ifld, "ok", "");// OK
  return true;
};




// -----------------------------------------
//               validate_match
// Validate if two fields are equal 
// Returns true if so (and also if could not be executed because of old browser)
// -----------------------------------------

function validate_round (vfld,  // elements to be matched
						 			vfld_orig,   // elements to be matched
									ifld,   // id of element to receive info/error msg
							reqd,      // true if required
							st_reqd,  // local string for "required"
							st_def)   // local string for detailed valid round
{

  var stat = commonCheck (vfld, ifld, reqd,st_reqd);
  if (stat != proceed) return stat;

  var stat = commonCheck (vfld_orig, ifld, reqd,st_reqd);
  if (stat != proceed) return stat;
  
  var tfld = trim(vfld.value);  // value of field with whitespace trimmed off
  var tfld_orig = trim(vfld_orig.value);  // value of field with whitespace trimmed off
  
  if (tfld!=tfld_orig) {
    msg (ifld, "error", st_def);
    vfld.focus();
    return false;
  }
  
  msg (ifld, "ok", "");// OK
  return true;
};



function increment(element,type,minval,maxval,inc) {

	// parse the value first
	if (type=='#int'){
		value = parseInt(element.value);
	}else if  (type=='#float'){
		value = parseFloat(element.value);
	}

	if (value!=element.value) {
		value =minval;
		return false;
	}
	
	newValue  = value + inc;

		
	// test for booundaries
	if (newValue<minval) {
		newValue = minval;
	}else if(newValue>maxval) {
		newValue = maxval;	
	}
	
	element.value = newValue;
	
	return true;
}