function validateRequired(form) {
                var isValid = true;
                var i = 0;
                var focusField = null;
                var fields = new Array();
                oRequired = new required();

                for (x in oRequired) {
                   	var field = form[oRequired[x][0]];
                   	
                   	if(typeof field == 'undefined'){
                   		continue;
                   	}

                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'file' ||
                        field.type == 'select-one' ||
                        field.type == 'radio' ||
                        field.type == 'password') {

                        var value = '';
						// get field's value
						if (field.type == "select-one") {
							var si = field.selectedIndex;
							if (si >= 0) {
								value = field.options[si].value;
							}
						} else {
							value = field.value;
						}

                        if (trim(value).length == 0) {

	                        if (i == 0) {
	                            focusField = field;
	                        }
	                        fields[i++] = oRequired[x][1];
	                        isValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return isValid;
            }

            // Trim whitespace from left and right sides of s.

            function trim(s) {
            	if(s == null || s == 'undefined') return "";
                return s.replace( /^\s*/, "" ).replace( /\s*$/, "" );
            }


 function validateRequiredIfNotNull(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oRequiredIf = new requiredIfNotNull();
                var isToShip = 'Y';


                for (x in oRequiredIf) {
                   	var field = form[oRequiredIf[x][0]];

					var checkOn = oRequiredIf[x][2]("isToShip");

					if( checkOn != 'undefined'){
					  for(var inc=0;inc< form.length;inc++){
					 	  if(form[inc].name == checkOn){
						      isToShip = form[inc].value;
						  }
					  }
					}else{
						isToShip = 'Y';
					}



                   	if(typeof field != 'undefined' && isToShip =='Y'){

					  if (field.type == 'text' ||
						  field.type == 'textarea' ||
						  field.type == 'file' ||
						  field.type == 'select-one' ||
						  field.type == 'radio' ||
						  field.type == 'password') {

						  var value = '';
						  // get field's value
						  if (field.type == "select-one") {
							  var si = field.selectedIndex;
							  if (si >= 0) {
								  value = field.options[si].value;
							  }
						  } else {
							  value = field.value;
						  }

						  if (trim(value).length == 0) {

							  if (i == 0) {
								  focusField = field;
							  }

							  fields[i++] = oRequiredIf[x][1];
							  isValid = false;
						  }
					  }
                    }
                }

                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return isValid;
            }
function validateFloatRange(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oRange = new floatRange();
                for (x in oRange) {
                    var field = form[oRange[x][0]];
                    if(typeof field == 'undefined') {
                        continue;
                    }
                    if ((field.type == 'text' ||
                         field.type == 'textarea') &&
                        (field.value.length > 0)) {

                        var fMin = parseFloat(oRange[x][2]("min"));
                        var fMax = parseFloat(oRange[x][2]("max"));
                        var fValue = parseFloat(field.value);
                        if (!(fValue >= fMin && fValue <= fMax)) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oRange[x][1];
                            isValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                    focusField.focus();
                    alert(fields.join('\n'));
                }
                return isValid;
            }
// TODO: double check that the type codes match the type data in the database.

		  function validateRetailUpcCheck (form)
		  {
		  	var UPC;
		  	var UPCtype;

            oRange = new retailUpcCheck();

            var gtinVal;
            var gtinformat ;
            var field;

            var isToShip;
            

            for( x in oRange){

            	field = form[oRange[x][0]];
                if(typeof field == 'undefined') {
                        continue;
                }

            	if(typeof field != 'undefined'){
            		gtinVal = field.value;
            	}
            	else {
            	    continue;
            	}

            	gtinformat = oRange[x][2]("retailGtinFormat");

				var checkOn = oRange[x][2]("isToShip");
			    if( checkOn != 'undefined'){
				    for(var inc=0;inc< form.length;inc++){
					    if(form[inc].name == checkOn){
						    isToShip = form[inc].value;

						}
					}
			    }else{
				    isToShip = 'Y';
				}
            }

		  	var found = false;

		  	UPC = gtinVal;
			

		  	for(var i=0;i< form.length;i++){
                //alert("key:"+ form[i].name +" Val:"+ form[i].value);
		  		if(form[i].name == gtinformat) {
		  			UPCtype = form[i].value;
		        }
		  	}

            if("N" == isToShip) {
            	
           	    return true;
            }
           if(UPCtype == "" || trim(UPCtype).length == 0) {
           		return true;
           }

			//if( !isAllDigits(UPC)){
				//alert(" UPC should be numeric...");
			//	return true;
			//}

		    if (UPCtype == 0)
		    {
		      if (UPC.length > 12 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version A must be 12 digits");
		        return false;
		      }else{
		      	UPC = padWithZeros(UPC,12);
		      	
			  	return mod10check12digits(UPC);
		      }
		    }
		    else  if (UPCtype == 1)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version E must be 8 digits");
		        return false;
		      }else{
				UPC = padWithZeros(UPC,8);		      
			  	return mod10check8digits(UPC);
		      }
		    }
		    else  if (UPCtype == 2)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type EAN-8 must be 8 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,8);
			  	return mod10check8digits(UPC);
		      }
		    }
		    else  if (UPCtype == 3)
		    {
		      if (UPC.length > 13 || isNaN (UPC) )
		      {
		        alert(" UPC of type EAN-13 must be 13 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,13);
			  	return mod10check13digits(UPC);
		      }
		    }
		    else  if (UPCtype == 4)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version 4 must be 8 digits");
		        return false;
		      }else{
			  	return true;
		      }
		    }
		    else if  (UPCtype == 7)
		    {
		      if (UPC.length > 14 || isNaN (UPC) ) {
		        alert(" UPC of type Case Marking Number I 2 of 5 must be 14 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,14);
		      	return mod10check14digits(UPC);
		      }
		    }
        
		    return true;
		  }


//Begin Function
		  function validateShippingUpcCheck(form)
		  {
		  	var UPC;
		  	var UPCtype;

            oRange = new shippingUpcCheck();

            var gtinVal;
            var gtinformat ;
            var field;

            var isToShip;

            for( x in oRange){

            	field = form[oRange[x][0]];
                    if(typeof field == 'undefined') {
                        continue;
                    }
            	

            	if(typeof field != 'undefined'){
            		gtinVal = field.value;
            	}
            	else {
            	    return true;
            	}

            	gtinformat = oRange[x][2]("shippingGtinFormat");

				var checkOn = oRange[x][2]("isToShip");
			    if( checkOn != 'undefined'){
				    for(var inc=0;inc< form.length;inc++){
					    if(form[inc].name == checkOn){
						    isToShip = form[inc].value;

						}
					}
			    }else{
				    isToShip = 'Y';
				}
            }

		  	var found = false;

		  	UPC = gtinVal;
		  	for(var i=0;i< form.length;i++){
		  		if(form[i].name == gtinformat) {
		  			UPCtype = form[i].value;
		        }
		  	}

            if("N" == isToShip) {
           	    return true;
            }
           if(UPCtype == "" || trim(UPCtype).length == 0) {
           		return true;
           }

			//if( !isAllDigits(UPC)){
				//alert(" UPC should be numeric...");
			//	return true;
			//}

		    if (UPCtype == 0)
		    {
		      if (UPC.length > 12 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version A must be 12 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,12);
			    return mod10check12digits(UPC);
		      }
		    }
		    else  if (UPCtype == 1)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version E must be 8 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,8);
			  	return mod10check8digits(UPC);
		      }
		    }
		    else  if (UPCtype == 2)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type EAN-8 must be 8 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,8);
			  	return mod10check8digits(UPC);
		      }
		    }
		    else  if (UPCtype == 3)
		    {
		      if (UPC.length > 13 || isNaN (UPC) )
		      {
		        alert(" UPC of type EAN-13 must be 13 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,13);
			  	return mod10check13digits(UPC);
		      }
		    }
		    else  if (UPCtype == 4)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version 4 must be 8 digits");
		        return false;
		      }else{
			  	return true;
		      }
		    }
		    else if  (UPCtype == 7)
		    {
		      if (UPC.length > 14 || isNaN (UPC) ) {
		        alert(" UPC of type Case Marking Number I 2 of 5 must be 14 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,14);
		      	return mod10check14digits(UPC);
		      }
		    }
        
		    return true;
		  }

//End



		  function validateUpcCheckConditional(form){
		  	var UPC;
		  	var UPCtype;



            oRange = new upcCheckConditional();


            var gtin ;
            var gtinVal;;
            var gtinformat ;
            var field;

            var isToShip;
            var isToShipVal;

            for( x in oRange){
            	field = form[oRange[x][0]];
                    if(typeof field == 'undefined') {
                        continue;
                    }
            	
            	if(typeof field != 'undefined'){
            		gtinVal = field.value;
            	}
            	gtin = oRange[x][2]("gtin");
            	gtinformat = oRange[x][2]("gtinformat");

            	isToShip =oRange[x][2]("isToShip");
            }



		  	var found = false;

		  	UPC = gtinVal;


		  	for(var i=0;i< form.length;i++){

		  		if(form[i].name == gtinformat)
		  			UPCtype = form[i].value;

            	if(typeof isToShip != 'undefined'){
		  			if(form[i].name == isToShip)
		  				isToShipVal = form[i].value;
            	}



		  	}


           if("N" == isToShipVal || UPC == '' || UPC.length == 0){
              	return true;
           }
           alert("5");
           if(UPCtype == "" || trim(UPCtype).length == 0){
           		return true;
           }


			//if( !isAllDigits(UPC)){
				//alert(" UPC should be numeric...");
			//	return true;
			//}
		    if (UPCtype == 0)
		    {
		      if (UPC.length > 12 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version A must be 12 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,12);
			  	return mod10check12digits(UPC);
		      }
		    }
		    else  if (UPCtype == 1)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version E must be 8 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,8);
			  	return mod10check8digits(UPC);
		      }
		    }
		    else  if (UPCtype == 2)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type EAN-8 must be 8 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,8);
			  	return mod10check8digits(UPC);
		      }
		    }
		    else  if (UPCtype == 3)
		    {
		      if (UPC.length > 13 || isNaN (UPC) )
		      {
		        alert(" UPC of type EAN-13 must be 13 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,13);
			  	return mod10check13digits(UPC);
		      }
		    }
		    else  if (UPCtype == 4)
		    {
		      if  (UPC.length > 8 || isNaN (UPC) )
		      {
		        alert(" UPC of type Version 4 must be 8 digits");
		        return false;
		      }else{
		      
			  	return true;
		      }
		    }
		    else if  (UPCtype == 7)
		    {
		      if (UPC.length > 14 || isNaN (UPC) ) {
		        alert(" UPC of type Case Marking Number I 2 of 5 must be 14 digits");
		        return false;
		      }else{
		      UPC = padWithZeros(UPC,14);
		      	return mod10check14digits(UPC);
		      }
		    }

		    return true;
		  }




		// takes a standard 14-digit barcode and makes sure it matches the check digit

		  function mod10check14digits( barcode)
		  {
		    if (barcode.length != 14) {
		     alert("I2of5 must be 14 digits");
		      return false;
		    }
		    oddSum = parseInt(barcode.charAt(0)) + parseInt(barcode.charAt(2)) + parseInt(barcode.charAt(4)) + parseInt(barcode.charAt(6)) + parseInt(barcode.charAt(8)) + parseInt(barcode.charAt(10))+ parseInt(barcode.charAt(12));
		    evenSum = parseInt(barcode.charAt(1)) + parseInt(barcode.charAt(3)) + parseInt(barcode.charAt(5)) + parseInt(barcode.charAt(7)) + parseInt(barcode.charAt(9)) + parseInt(barcode.charAt(11));

		    n = (oddSum * 3) + evenSum;
		    x = n % 10;
		    if ( x == 0 ) x = 10;

		    checkDigit = 10 - x;

		    if ( parseInt(barcode.charAt(13)) != checkDigit )
		    {
		      alert("* Mod 10 check - please check your marking number for correctness, ** Hint: Try " +checkDigit);
		      return false;
		    }
		    else
		    {
		      return true;
		    }
		  }



		  // takes a standard 13-digit barcode and makes sure it matches the check digit

		  function mod10check13digits( barcode )
		  {
		    // barcode = barcode.toString();

		    if( !( itemType == nonExplode || itemType == regular ))
		    {
		      return true;
		    }

		    oddSum = parseInt(barcode.charAt(0)) + parseInt(barcode.charAt(2)) + parseInt(barcode.charAt(4)) + parseInt(barcode.charAt(6)) + parseInt(barcode.charAt(8)) + parseInt(barcode.charAt(10));
		    evenSum = parseInt(barcode.charAt(1)) + parseInt(barcode.charAt(3)) + parseInt(barcode.charAt(5)) + parseInt(barcode.charAt(7)) + parseInt(barcode.charAt(9)) + parseInt(barcode.charAt(11));                          ;

		    n = (evenSum * 3) + oddSum;
		    x = n % 10;
		    if ( x == 0 ) x = 10;

		    checkDigit = 10 - x;

		    if ( parseInt(barcode.charAt(12)) != checkDigit )
		    {
		      alert("Mod 10 check - please check your marking number for correctness, ** Hint: Try " +checkDigit);
		      return false;
		    }
		    else
		    {
		      return true;
		    }
		  }

		  // takes a standard 12-digit barcode and makes sure it matches the check digit

		  function mod10check12digits( barcode )
		  {
		    // barcode = barcode.toString();
		    
		    

		    oddSum = parseInt(barcode.charAt(0)) + parseInt(barcode.charAt(2)) + parseInt(barcode.charAt(4)) + parseInt(barcode.charAt(6)) + parseInt(barcode.charAt(8)) + parseInt(barcode.charAt(10));
		    evenSum = parseInt(barcode.charAt(1)) + parseInt(barcode.charAt(3)) + parseInt(barcode.charAt(5)) + parseInt(barcode.charAt(7)) + parseInt(barcode.charAt(9));

		    n = (oddSum * 3) + evenSum;
		    x = n % 10;
		    if ( x == 0 ) x = 10;

		    checkDigit = 10 - x;

		    if ( parseInt(barcode.charAt(11)) != checkDigit )
		    {
		      alert("** Mod 10 check - please check your marking number for correctness, ** Hint: Try " +checkDigit);
		      return false;
		    }
		    else
		    
		    {
		    
		      return true;
		    }
		  }



		 // takes a standard 8-digit barcode and makes sure it matches the check digit

		  function mod10check8digits( barcode,itemType,upcType )
		  {
		    // barcode = barcode.toString();
		    oddSum = parseInt(barcode.charAt(0)) + parseInt(barcode.charAt(2)) + parseInt(barcode.charAt(4)) + parseInt(barcode.charAt(6));
		    evenSum = parseInt(barcode.charAt(1)) + parseInt(barcode.charAt(3)) + parseInt(barcode.charAt(5));

		    n = (oddSum * 3) + evenSum;
		    x = n % 10;
		    if ( x == 0 ) x = 10;

		    checkDigit = 10 - x;

		    if ( parseInt(barcode.charAt(7)) != checkDigit )
		    {
		      alert("Mod 10 check - please check your marking number for correctness, ** Hint: Try " +checkDigit);
		      return false;
		    }
		    else
		    {
		      return true;
		    }
		  }
function validateByte(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oByte = new ByteValidations();
                for (x in oByte) {
                	var field = form[oByte[x][0]];
                    if(typeof field == 'undefined') {
                        continue;
                    }
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'select-one' ||
						field.type == 'radio') {

						var value = '';
						// get field's value
						if (field.type == "select-one") {
							var si = field.selectedIndex;
							if (si >= 0) {
								value = field.options[si].value;
							}
						} else {
							value = field.value;
						}

                        if (value.length > 0) {
                            if (!isAllDigits(value)) {
                                bValid = false;
                                if (i == 0) {
                                    focusField = field;
                                }
                                fields[i++] = oByte[x][1];

                            } else {

	                            var iValue = parseInt(value);
	                            if (isNaN(iValue) || !(iValue >= -128 && iValue <= 127)) {
	                                if (i == 0) {
	                                    focusField = field;
	                                }
	                                fields[i++] = oByte[x][1];
	                                bValid = false;
	                            }
                            }
						}

                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return bValid;
            }
function validateMaxLength(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMaxLength = new maxlength();
                for (x in oMaxLength) {
                    var field = form[oMaxLength[x][0]];
                    if(typeof field == 'undefined') {
                        continue;
                    }
                    if (field.type == 'text' ||
                        field.type == 'textarea') {

                        var iMax = parseInt(oMaxLength[x][2]("maxlength"));
                        if (field.value.length > iMax) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oMaxLength[x][1];
                            isValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return isValid;
            }



function validateInteger(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oInteger = new IntegerValidations();

                for (x in oInteger) {
                	var field = form[oInteger[x][0]];
                    if(typeof field == 'undefined') {
                        continue;
                    }
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'select-one' ||
                        field.type == 'radio') {

                        var value = '';
						// get field's value
						if (field.type == "select-one") {
							var si = field.selectedIndex;
						    if (si >= 0) {
							    value = field.options[si].value;
						    }
						} else {
							value = field.value;
						}

                        if (value.length > 0) {

                            if (!isAllDigits(value)) {
                                bValid = false;
                                if (i == 0) {
	                                focusField = field;
	                            }
						        fields[i++] = oInteger[x][1];

                            } else {
	                            var iValue = parseInt(value);
	                            if (isNaN(iValue) || !(iValue >= -2147483648 && iValue <= 2147483647)) {
	                                if (i == 0) {
	                                    focusField = field;
	                                }
	                                fields[i++] = oInteger[x][1];
	                                bValid = false;
	                           }
                           }
                       }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return bValid;
            }

            function isAllDigits(argvalue) {
                argvalue = argvalue.toString();
                var validChars = "0123456789";
                var startFrom = 0;
                if (argvalue.substring(0, 2) == "0x") {
                   validChars = "0123456789abcdefABCDEF";
                   startFrom = 2;
                } else if (argvalue.charAt(0) == "0") {
                   validChars = "0123456789";
                   startFrom = 1;
                } else if (argvalue.charAt(0) == "-") {
                    startFrom = 1;
                }

                for (var n = startFrom; n < argvalue.length; n++) {
                    if (validChars.indexOf(argvalue.substring(n, n+1)) == -1) return false;
                }
                return true;
            }
function validateRange(form) {
                return validateIntRange(form);
            }
function validateCreditCard(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oCreditCard = new creditCard();
                for (x in oCreditCard) {
                    var field = form[oCreditCard[x][0]];
                    if(typeof field == 'undefined') {
                        continue;
                    }
                    if ((form[oCreditCard[x][0]].type == 'text' ||
                         form[oCreditCard[x][0]].type == 'textarea') &&
                        (form[oCreditCard[x][0]].value.length > 0)) {
                        if (!luhnCheck(form[oCreditCard[x][0]].value)) {
                            if (i == 0) {
                                focusField = form[oCreditCard[x][0]];
                            }
                            fields[i++] = oCreditCard[x][1];
                            bValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                    focusField.focus();
                    alert(fields.join('\n'));
                }
                return bValid;
            }

            /**
             * Reference: http://www.ling.nwu.edu/~sburke/pub/luhn_lib.pl
             */
            function luhnCheck(cardNumber) {
                if (isLuhnNum(cardNumber)) {
                    var no_digit = cardNumber.length;
                    var oddoeven = no_digit & 1;
                    var sum = 0;
                    for (var count = 0; count < no_digit; count++) {
                        var digit = parseInt(cardNumber.charAt(count));
                        if (!((count & 1) ^ oddoeven)) {
                            digit *= 2;
                            if (digit > 9) digit -= 9;
                        };
                        sum += digit;
                    };
                    if (sum == 0) return false;
                    if (sum % 10 == 0) return true;
                };
                return false;
            }

            function isLuhnNum(argvalue) {
                argvalue = argvalue.toString();
                if (argvalue.length == 0) {
                    return false;
                }
                for (var n = 0; n < argvalue.length; n++) {
                    if ((argvalue.substring(n, n+1) < "0") ||
                        (argvalue.substring(n,n+1) > "9")) {
                        return false;
                    }
                }
                return true;
            }
function validateDate(form) {
               var bValid = true;
               var focusField = null;
               var i = 0;
               var fields = new Array();
               oDate = new DateValidations();
               for (x in oDate) {
                   var field = form[oDate[x][0]];
                   if(typeof field == 'undefined') {
                        continue;
                   }
                   var value = form[oDate[x][0]].value;
                   var datePattern = oDate[x][2]("datePatternStrict");

	               if(typeof datePattern == 'undefined'){
                   		return true;
                   }

                   if ((form[oDate[x][0]].type == 'text' ||
                        form[oDate[x][0]].type == 'textarea') &&
                       (value.length > 0) &&
                       (datePattern.length > 0)) {
                     var MONTH = "MM";
                     var DAY = "dd";
                     var YEAR = "yyyy";
                     var orderMonth = datePattern.indexOf(MONTH);
                     var orderDay = datePattern.indexOf(DAY);
                     var orderYear = datePattern.indexOf(YEAR);
                     if ((orderDay < orderYear && orderDay > orderMonth)) {
                         var iDelim1 = orderMonth + MONTH.length;
                         var iDelim2 = orderDay + DAY.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
                         if (iDelim1 == orderDay && iDelim2 == orderYear) {
                            dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
                         } else if (iDelim1 == orderDay) {
                            dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
                         } else if (iDelim2 == orderYear) {
                            dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
                         } else {
                            dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                            if (!isValidDate(matched[2], matched[1], matched[3])) {
                               if (i == 0) {
                                   focusField = form[oDate[x][0]];
                               }
                               fields[i++] = oDate[x][1];
                               bValid =  false;
                            }
                         } else {
                            if (i == 0) {
                                focusField = form[oDate[x][0]];
                            }
                            fields[i++] = oDate[x][1];
                            bValid =  false;
                         }
                     } else if ((orderMonth < orderYear && orderMonth > orderDay)) {
                         var iDelim1 = orderDay + DAY.length;
                         var iDelim2 = orderMonth + MONTH.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
                         if (iDelim1 == orderMonth && iDelim2 == orderYear) {
                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})(\\d{4})$");
                         } else if (iDelim1 == orderMonth) {
                             dateRegexp = new RegExp("^(\\d{2})(\\d{2})[" + delim2 + "](\\d{4})$");
                         } else if (iDelim2 == orderYear) {
                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})(\\d{4})$");
                         } else {
                             dateRegexp = new RegExp("^(\\d{2})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{4})$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                             if (!isValidDate(matched[1], matched[2], matched[3])) {
                                 if (i == 0) {
                                     focusField = form[oDate[x][0]];
                                 }
                                 fields[i++] = oDate[x][1];
                                 bValid =  false;
                              }
                         } else {
                             if (i == 0) {
                                 focusField = form[oDate[x][0]];
                             }
                             fields[i++] = oDate[x][1];
                             bValid =  false;
                         }
                     } else if ((orderMonth > orderYear && orderMonth < orderDay)) {
                         var iDelim1 = orderYear + YEAR.length;
                         var iDelim2 = orderMonth + MONTH.length;
                         var delim1 = datePattern.substring(iDelim1, iDelim1 + 1);
                         var delim2 = datePattern.substring(iDelim2, iDelim2 + 1);
                         if (iDelim1 == orderMonth && iDelim2 == orderDay) {
                             dateRegexp = new RegExp("^(\\d{4})(\\d{2})(\\d{2})$");
                         } else if (iDelim1 == orderMonth) {
                             dateRegexp = new RegExp("^(\\d{4})(\\d{2})[" + delim2 + "](\\d{2})$");
                         } else if (iDelim2 == orderDay) {
                             dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})(\\d{2})$");
                         } else {
                             dateRegexp = new RegExp("^(\\d{4})[" + delim1 + "](\\d{2})[" + delim2 + "](\\d{2})$");
                         }
                         var matched = dateRegexp.exec(value);
                         if(matched != null) {
                             if (!isValidDate(matched[3], matched[2], matched[1])) {
                                 if (i == 0) {
                                     focusField = form[oDate[x][0]];
                                  }
                                  fields[i++] = oDate[x][1];
                                  bValid =  false;
                              }
                          } else {
                              if (i == 0) {
                                  focusField = form[oDate[x][0]];
                              }
                              fields[i++] = oDate[x][1];
                              bValid =  false;
                          }
                     } else {
                         if (i == 0) {
                             focusField = form[oDate[x][0]];
                         }
                         fields[i++] = oDate[x][1];
                         bValid =  false;
                     }
                  }
               }
               if (fields.length > 0) {
                  focusField.focus();
                  alert(fields.join('\n'));
               }
               return bValid;
            }

	    function isValidDate(day, month, year) {
	        if (month < 1 || month > 12) {
                    return false;
                }
                if (day < 1 || day > 31) {
                    return false;
                }
                if ((month == 4 || month == 6 || month == 9 || month == 11) &&
                    (day == 31)) {
                    return false;
                }
                if (month == 2) {
                    var leap = (year % 4 == 0 &&
                               (year % 100 != 0 || year % 400 == 0));
                    if (day>29 || (day == 29 && !leap)) {
                        return false;
                    }
                }
                return true;
            }
function validateIntRange(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oRange = new intRange();
                for (x in oRange) {
                    var field = form[oRange[x][0]];
                    if(typeof field == 'undefined') {
                        continue;
                    }
                    if ((field.type == 'text' ||
                         field.type == 'textarea') &&
                        (field.value.length > 0)) {

                        var iMin = parseInt(oRange[x][2]("min"));
                        var iMax = parseInt(oRange[x][2]("max"));
                        var iValue = parseInt(field.value);
                        if (!(iValue >= iMin && iValue <= iMax)) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oRange[x][1];
                            isValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                    focusField.focus();
                    alert(fields.join('\n'));
                }
                return isValid;
            }

    function validateShort(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oShort = new ShortValidations();
                for (x in oShort) {
                	var field = form[oShort[x][0]];
                    if(typeof field == 'undefined') {
                         continue;
                    }
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'select-one' ||
                        field.type == 'radio') {

                        var value = '';
						// get field's value
						if (field.type == "select-one") {
							var si = field.selectedIndex;
							if (si >= 0) {
								value = field.options[si].value;
							}
						} else {
							value = field.value;
						}

                        if (value.length > 0) {
                            if (!isAllDigits(value)) {
                                bValid = false;
                                if (i == 0) {
                                    focusField = field;
                                }
                                fields[i++] = oShort[x][1];

                            } else {

	                            var iValue = parseInt(value);
	                            if (isNaN(iValue) || !(iValue >= -32768 && iValue <= 32767)) {
	                                if (i == 0) {
	                                    focusField = field;
	                                }
	                                fields[i++] = oShort[x][1];
	                                bValid = false;
	                            }
	                       }
                       }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return bValid;
            }
function validateFloat(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oFloat = new FloatValidations();
                for (x in oFloat) {
                	var field = form[oFloat[x][0]];
                    if(typeof field == 'undefined') {
                         continue;
                    }
                    if (field.type == 'text' ||
                        field.type == 'textarea' ||
                        field.type == 'select-one' ||
                        field.type == 'radio') {

                    	var value = '';
						// get field's value
						if (field.type == "select-one") {
							var si = field.selectedIndex;
							if (si >= 0) {
							    value = field.options[si].value;
							}
						} else {
							value = field.value;
						}

                        if (value.length > 0) {
                            // remove '.' before checking digits
                            var tempArray = value.split('.');
                            var joinedString= tempArray.join('');

                            if (!isAllDigits(joinedString)) {
                                bValid = false;
                                if (i == 0) {
                                    focusField = field;
                                }
                                fields[i++] = oFloat[x][1];

                            } else {
	                            var iValue = parseFloat(value);
	                            if (isNaN(iValue)) {
	                                if (i == 0) {
	                                    focusField = field;
	                                }
	                                fields[i++] = oFloat[x][1];
	                                bValid = false;
	                            }
                            }
                        }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return bValid;
            }
function validateEmail(form) {
                var bValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oEmail = new email();
                for (x in oEmail) {
                    var field = form[oEmail[x][0]];
                    if(typeof field == 'undefined') {
                         continue;
                    }
                    if ((form[oEmail[x][0]].type == 'text' ||
                         form[oEmail[x][0]].type == 'textarea') &&
                        (form[oEmail[x][0]].value.length > 0)) {
                        if (!checkEmail(form[oEmail[x][0]].value)) {
                            if (i == 0) {
                                focusField = form[oEmail[x][0]];
                            }
                            fields[i++] = oEmail[x][1];
                            bValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                    focusField.focus();
                    alert(fields.join('\n'));
                }
                return bValid;
            }

            function checkEmail(emailStr) {
               if (emailStr.length == 0) {
                   return true;
               }
               var emailPat=/^(.+)@(.+)$/;
               var specialChars="\\(\\)<>@,;:\\\\\\\"\\.\\[\\]";
               var validChars="\[^\\s" + specialChars + "\]";
               var quotedUser="(\"[^\"]*\")";
               var ipDomainPat=/^(\d{1,3})[.](\d{1,3})[.](\d{1,3})[.](\d{1,3})$/;
               var atom=validChars + '+';
               var word="(" + atom + "|" + quotedUser + ")";
               var userPat=new RegExp("^" + word + "(\\." + word + ")*$");
               var domainPat=new RegExp("^" + atom + "(\\." + atom + ")*$");
               var matchArray=emailStr.match(emailPat);
               if (matchArray == null) {
                   return false;
               }
               var user=matchArray[1];
               var domain=matchArray[2];
               if (user.match(userPat) == null) {
                   return false;
               }
               var IPArray = domain.match(ipDomainPat);
               if (IPArray != null) {
                   for (var i = 1; i <= 4; i++) {
                      if (IPArray[i] > 255) {
                         return false;
                      }
                   }
                   return true;
               }
               var domainArray=domain.match(domainPat);
               if (domainArray == null) {
                   return false;
               }
               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)) {
                   return false;
               }
               if (len < 2) {
                   return false;
               }
               return true;
            }
function validateMask(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMasked = new mask();
                for (x in oMasked) {
                    var field = form[oMasked[x][0]];
                    if(typeof field == 'undefined') {
                         continue;
                    }
                    if ((field.type == 'text' ||
                         field.type == 'textarea') &&
                         (field.value.length > 0)) {

                        if (!matchPattern(field.value, oMasked[x][2]("mask"))) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oMasked[x][1];
                            isValid = false;
                        }
                    }
                }

                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return isValid;
            }

            function matchPattern(value, mask) {
               return mask.exec(value);
            }
function validateMinLength(form) {
                var isValid = true;
                var focusField = null;
                var i = 0;
                var fields = new Array();
                oMinLength = new minlength();
                for (x in oMinLength) {
                    var field = form[oMinLength[x][0]];
                    if(typeof field == 'undefined') {
                         continue;
                    }
                    if (field.type == 'text' ||
                        field.type == 'textarea') {

                        var iMin = parseInt(oMinLength[x][2]("minlength"));
                        if ((trim(field.value).length > 0) && (field.value.length < iMin)) {
                            if (i == 0) {
                                focusField = field;
                            }
                            fields[i++] = oMinLength[x][1];
                            isValid = false;
                        }
                    }
                }
                if (fields.length > 0) {
                   focusField.focus();
                   alert(fields.join('\n'));
                }
                return isValid;
            }
/*
	*****************************************************************************************************
	Author : Lea Smart
	Source : www.totallysmartit.com
	Date : 7/3/2001
	DHTML Calendar
	Version 1.2

	You are free to use this code if you retain this header.
	You do not need to link to my site (be nice though!)

	Amendments
	22 Jan 2002; Added ns resize bug code; rewrote date functions into Date 'class';
				 Added support for yyyy-mm-dd date format
				 Added support for calendar beginning on any day
	7th Feb 2002 Fixed day highlight when year wasn't current year bug
	9th Jun 2002 Fixed bug with weekend colour
				 Amended the code for the date functions extensions.  Shortened addDays code considerably
	*****************************************************************************************************
	*/
/*	var timeoutDelay = 2000; // milliseconds, change this if you like, set to 0 for the calendar to never auto disappear
	var g_startDay = 0// 0=sunday, 1=monday

	// preload images
	var imgUp = new Image(8,12);
	imgUp.src = 'static/up.gif';
	var imgDown = new Image(8,12);
	imgDown.src = 'static/down.gif';

	// used by timeout auto hide functions
	var timeoutId = false;

	// the now standard browser sniffer class
	function Browser(){
	  this.dom = document.getElementById?1:0;
	  this.ie4 = (document.all && !this.dom)?1:0;
	  this.ns4 = (document.layers && !this.dom)?1:0;
	  this.ns6 = (this.dom && !document.all)?1:0;
	  this.ie5 = (this.dom && document.all)?1:0;
	  this.ok = this.dom || this.ie4 || this.ns4;
	  this.platform = navigator.platform;
	}
	var browser = new Browser();

	// dom browsers require this written to the HEAD section

	if (browser.dom || browser.ie4){
	    document.writeln('<style>');
		document.writeln('#container {');
		document.writeln('position : absolute;');
		document.writeln('left : 100px;');
		document.writeln('top : 100px;');
		document.writeln('width : 124px;');;
		browser.platform=='Win32'?height=140:height=145;
		document.writeln('height : ' + height +'px;');
		document.writeln('clip:rect(0px 124px ' + height + 'px 0px);');
		//document.writeln('overflow : hidden;');
		document.writeln('visibility : hidden;');
		document.writeln('background-color : #ffffff');
		document.writeln('}');
		document.writeln('</style>');
		document.writeln(writeStyle());
		document.write('<div id="container"');
		if (timeoutDelay) document.write(' onmouseout="calendarTimeout();" onmouseover="if (timeoutId) clearTimeout(timeoutId);"');
		document.write('></div>');
	}

	var g_Calendar;  // global to hold the calendar reference, set by constructor

	function calendarTimeout(){
	  if (browser.ie4 || browser.ie5){
	    if (window.event.srcElement && window.event.srcElement.name!='month') timeoutId=setTimeout('g_Calendar.hide();',timeoutDelay);
	  }
	  if (browser.ns6 || browser.ns4){
	    timeoutId=setTimeout('g_Calendar.hide();',timeoutDelay);
	  }
	}

	// constructor for calendar class
	function Calendar(){
	  g_Calendar = this;
	  // some constants needed throughout the program
	  this.daysOfWeek = new Array("Su","Mo","Tu","We","Th","Fr","Sa");
	  this.months = new Array("January","February","March","April","May","June","July","August","September","October","November","December");
	  this.daysInMonth = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

	  if (browser.ns4){
	    var tmpLayer = new Layer(127);
		if (timeoutDelay){
		  tmpLayer.captureEvents(Event.MOUSEOVER | Event.MOUSEOUT);
		  tmpLayer.onmouseover = function(event) { if (timeoutId) clearTimeout(timeoutId); };
		  tmpLayer.onmouseout = function(event) { timeoutId=setTimeout('g_Calendar.hide()',timeoutDelay);};
		}
	    tmpLayer.x = 100;
	    tmpLayer.y = 100;
	    tmpLayer.bgColor = "#ffffff";
	  }
	  if (browser.dom || browser.ie4){
		var tmpLayer = browser.dom?document.getElementById('container'):document.all.container;
	  }
	  this.containerLayer = tmpLayer;
	  if (browser.ns4 && browser.platform=='Win32') {
	    this.containerLayer.clip.height=134;
	    this.containerLayer.clip.width=127;
	  }

	}

 	Calendar.prototype.getFirstDOM = function() {
		var thedate = new Date();
		thedate.setDate(1);
		thedate.setMonth(this.month);
		thedate.setFullYear(this.year);
		return thedate.getDay();
	}

	Calendar.prototype.getDaysInMonth = function (){
	   if (this.month!=1) {
	   return this.daysInMonth[this.month]
	   }
	   else {
	     // is it a leap year
		    if (Date.isLeapYear(this.year)) {
			  return 29;
			}
		    else {
			  return 28;
			}
	   }
	}

	Calendar.prototype.buildString = function(){
	  var tmpStr = '<form onSubmit="this.year.blur();return false;"><table width="100%" border="0" cellspacing="0" cellpadding="2" class="calBorderColor"><tr><td valign="top"><table width="100%" border="0" cellspacing="0" cellpadding="1" class="calBgColor">';
	  tmpStr += '<tr>';
	  tmpStr += '<td width="60%" class="cal" align="left">';
	  if (this.hasDropDown) {
	    tmpStr += '<select class="month" name="month" onchange="g_Calendar.selectChange();">';
		for (var i=0;i<this.months.length;i++){
	      tmpStr += '<option value="' + i + '"'
		  if (i == this.month) tmpStr += ' selected';
		  tmpStr += '>' + this.months[i] + '</option>';
	    }
	    tmpStr += '</select>';
	  } else {
	    tmpStr += '<table border="0" cellspacing="0" cellpadding="0"><tr><td><a href="javascript: g_Calendar.changeMonth(-1);">&lt;</a></td><td class="cal" width="100%" align="center">' + this.months[this.month] + '</td><td class="cal"><a href="javascript: g_Calendar.changeMonth(+1);">&gt;</a></td></tr></table>';
	  }
	  tmpStr += '</td>';
	  /* observation : for some reason if the below event is changed to 'onChange' rather than 'onBlur' it totally crashes IE (4 and 5)!

	  tmpStr += '<td width="40%" align="right" class="cal">';

	  if (this.hasDropDown) {
	    tmpStr += '<input class="year" type="text" size="';
	    // get round NS4 win32 lenght of year input problem
	    (browser.ns4 && browser.platform=='Win32')?tmpStr += 1:tmpStr += 4;
	  tmpStr += '" name="year" maxlength="4" onBlur="g_Calendar.inputChange();" value="' + this.year + '">';
	  } else {
	  tmpStr += '<table border="0" cellspacing="0" cellpadding="0"><tr><td class="cal"><a href="javascript: g_Calendar.changeYear(-1);">&lt;</a></td><td class="cal" width="100%" align="center">' + this.year + '</td><td class="cal"><a href="javascript: g_Calendar.changeYear(+1);">&gt;</a></td></tr></table>'	  }
	  tmpStr += '</td>';
	  tmpStr += '</tr>';
	  tmpStr += '</table>';
	  var iCount = 1;

	  var iFirstDOM = (7+this.getFirstDOM()-g_startDay)%7; // to prevent calling it in a loop

	  var iDaysInMonth = this.getDaysInMonth(); // to prevent calling it in a loop

	  tmpStr += '<table width="100%" border="0" cellspacing="0" cellpadding="1" class="calBgColor">';
	  tmpStr += '<tr>';
	    for (var i=0;i<7;i++){
		  tmpStr += '<td align="center" class="calDaysColor">' + this.daysOfWeek[(g_startDay+i)%7] + '</td>';
		}
	  tmpStr += '</tr>';
	  var tmpFrom = parseInt('' + this.dateFromYear + this.dateFromMonth + this.dateFromDay,10);
	  var tmpTo = parseInt('' + this.dateToYear + this.dateToMonth + this.dateToDay,10);
	  var tmpCompare;
	  for (var j=1;j<=6;j++){
	     tmpStr += '<tr>';
	     for (var i=1;i<=7;i++){
		   tmpStr += '<td width="16" align="center" '
		   if ( (7*(j-1) + i)>=iFirstDOM+1  && iCount <= iDaysInMonth){
		     if (iCount==this.day && this.year==this.oYear && this.month==this.oMonth) tmpStr += 'class="calHighlightColor"';
			 else {
			    if (i==7-g_startDay || i==((7-g_startDay)%7)+1) tmpStr += 'class="calWeekend"';
				else tmpStr += 'class="cal"';
			 }
		     tmpStr += '>';
			 tmpCompare = parseInt('' + this.year + padZero(this.month) + padZero(iCount),10);
			 if (tmpCompare >= tmpFrom && tmpCompare <= tmpTo) {
			   tmpStr += '<a class="cal" href="javascript: g_Calendar.clickDay(' + iCount + ');">' + iCount + '</a>';
			 } else {
			   tmpStr += '<span class="disabled">' + iCount + '</span>';
			 }
			 iCount++;
		   } else {
		     if  (i==7-g_startDay || i==((7-g_startDay)%7)+1) tmpStr += 'class="calWeekend"'; else tmpStr +='class="cal"';
			 tmpStr += '>&nbsp;';
		   }
		   tmpStr += '</td>'
		 }
		 tmpStr += '</tr>'
	  }
	  tmpStr += '</table></td></tr></table></form>'
	  return tmpStr;
	}

	Calendar.prototype.selectChange = function(){
	  this.month = browser.ns6?this.containerLayer.ownerDocument.forms[0].month.selectedIndex:this.containerLayer.document.forms[0].month.selectedIndex;
	  this.writeString(this.buildString());
	}

	Calendar.prototype.inputChange = function(){
	  var tmp = browser.ns6?this.containerLayer.ownerDocument.forms[0].year:this.containerLayer.document.forms[0].year;
	  if (tmp.value >=1900 || tmp.value <=2100){
	    this.year = tmp.value;
	    this.writeString(this.buildString());
	  } else {
	    tmp.value = this.year;
	  }
	}
	Calendar.prototype.changeYear = function(incr){
	   (incr==1)?this.year++:this.year--;
	   this.writeString(this.buildString());
	}
	Calendar.prototype.changeMonth = function(incr){
	    if (this.month==11 && incr==1){
	      this.month = 0;
	  	  this.year++;
	    } else {
	      if (this.month==0 && incr==-1){
	        this.month = 11;
		    this.year--;
	      } else {
		    (incr==1)?this.month++:this.month--;
		  }
		}
		this.writeString(this.buildString());
	}

	Calendar.prototype.clickDay = function(day){
	   var tmp = eval('document.' + this.target );
	   tmp.value = this.formatDateAsString(day,this.month,this.year);
	    if (browser.ns4) this.containerLayer.hidden=true;
	    if (browser.dom || browser.ie4){
	      this.containerLayer.style.visibility='hidden';
	    }
	}
	Calendar.prototype.formatDateAsString = function(day, month, year){
	  var delim = eval('/\\' + this.dateDelim + '/g');
	   switch (this.dateFormat.replace(delim,"")){
	     case 'ddmmmyyyy': return padZero(day) + this.dateDelim + this.months[month].substr(0,3) + this.dateDelim + year;
		 case 'ddmmyyyy': return padZero(day) + this.dateDelim + padZero(month+1) + this.dateDelim + year;
		 case 'mmddyyyy': return padZero((month+1)) + this.dateDelim + padZero(day) + this.dateDelim + year;
	     case 'yyyymmdd': return year + this.dateDelim + padZero(month+1) + this.dateDelim + padZero(day);
		 default: alert('unsupported date format');
	   }
	}
	Calendar.prototype.writeString = function(str){
	  if (browser.ns4){
	    this.containerLayer.document.open();
	    this.containerLayer.document.write(str);
	    this.containerLayer.document.close();
	  }
	  if (browser.dom || browser.ie4){
	    this.containerLayer.innerHTML = str;
	  }
	}

	Calendar.prototype.show = function(event, target, bHasDropDown, dateFormat, dateFrom, dateTo){
	// calendar can restrict choices between 2 dates, if however no restrictions
	// are made, let them choose any date between 1900 and 3000
	this.dateFrom = dateFrom || new Date(1900,0,1);
	this.dateFromDay = padZero(this.dateFrom.getDate());
	this.dateFromMonth = padZero(this.dateFrom.getMonth());
	this.dateFromYear = this.dateFrom.getFullYear();
	this.dateTo = dateTo || new Date(3000,0,1);
	this.dateToDay = padZero(this.dateTo.getDate());
	this.dateToMonth = padZero(this.dateTo.getMonth());
	this.dateToYear = this.dateTo.getFullYear();
	this.hasDropDown = bHasDropDown;
	this.dateFormat = dateFormat || 'dd-mmm-yyyy';
	switch (this.dateFormat){
	  case 'dd-mmm-yyyy':
	  case 'dd-mm-yyyy':
	  case 'yyyy-mm-dd':
	    this.dateDelim = '-';
		break;
	  case 'dd/mm/yyyy':
	  case 'mm/dd/yyyy':
	  case 'dd/mmm/yyyy':
	    this.dateDelim = '/';
		break;
	}

	  if (browser.ns4) {
	    if (!this.containerLayer.hidden) {
		  this.containerLayer.hidden=true;
		  return;
		}
	   }
	  if (browser.dom || browser.ie4){
	    if (this.containerLayer.style.visibility=='visible') {
		  this.containerLayer.style.visibility='hidden';
		  return;
		}
	  }

	  if (browser.ie5 || browser.ie4){
	    var event = window.event;
	  }
	  if (browser.ns4){
	    this.containerLayer.x = event.x+10;
	    this.containerLayer.y = event.y-5;
	  }
	  if (browser.ie5 || browser.ie4){
	    var obj = event.srcElement;
 	    x = 0;
  		while (obj.offsetParent != null) {
    		  x += obj.offsetLeft;
    		  obj = obj.offsetParent;
  		}
  		x += obj.offsetLeft;
	    y = 0;
		var obj = event.srcElement;
	    while (obj.offsetParent != null) {
    		  y += obj.offsetTop;
    		  obj = obj.offsetParent;
  		}
  		y += obj.offsetTop;

        this.containerLayer.style.left = x+35;
		if (event.y>0)this.containerLayer.style.top = y;
	  }
	  if (browser.ns6){
	    this.containerLayer.style.left = event.pageX+10;
		this.containerLayer.style.top = event.pageY-5;
	  }
	  this.target = target;
	  var tmp = eval('document.' + this.target);
	  if (tmp && tmp.value && tmp.value.split(this.dateDelim).length==3 && tmp.value.indexOf('d')==-1){
	    var atmp = tmp.value.split(this.dateDelim)
		switch (this.dateFormat){
		 case 'dd-mmm-yyyy':
		 case 'dd/mmm/yyyy':
		   for (var i=0;i<this.months.length;i++){
		     if (atmp[1].toLowerCase()==this.months[i].substr(0,3).toLowerCase()){
		       this.month = this.oMonth = i;
			   break;
		     }
		   }
		   this.day = parseInt(atmp[0],10);
		   this.year = this.oYear = parseInt(atmp[2],10);
		   break;
		 case 'dd/mm/yyyy':
		 case 'dd-mm-yyyy':
		   this.month = this.oMonth = parseInt(atmp[1]-1,10);
		   this.day = parseInt(atmp[0],10);
		   this.year = this.oYear = parseInt(atmp[2],10);
		   break;
		 case 'mm/dd/yyyy':
		 case 'mm-dd-yyyy':
		   this.month = this.oMonth = parseInt(atmp[0]-1,10);
		   this.day = parseInt(atmp[1],10);
		   this.year = this.oYear = parseInt(atmp[2],10);
		   break;
		 case 'yyyy-mm-dd':
		   this.month = this.oMonth = parseInt(atmp[1]-1,10);
		   this.day = parseInt(atmp[2],10);
		   this.year = this.oYear = parseInt(atmp[0],10);
		   break;
		}
	  } else { // no date set, default to today
	    var theDate = new Date();
	  	 this.year = this.oYear = theDate.getFullYear();
	     this.month = this.oMonth = theDate.getMonth();
	     this.day = this.oDay = theDate.getDate();
	  }
	  this.writeString(this.buildString());

	  // and then show it!
	   if (browser.ns4) {
	   this.containerLayer.hidden=false;
	   }
	  if (browser.dom || browser.ie4){
	      this.containerLayer.style.visibility='visible';
	  }
	}

	Calendar.prototype.hide = function(){
	  if (browser.ns4) this.containerLayer.hidden = true;
	  if (browser.dom || browser.ie4){
	    this.containerLayer.style.visibility='hidden';
	  }
	}

	function handleDocumentClick(e){
	  if (browser.ie4 || browser.ie5) e = window.event;

	  if (browser.ns6){
	    var bTest = (e.pageX > parseInt(g_Calendar.containerLayer.style.left,10) && e.pageX <  (parseInt(g_Calendar.containerLayer.style.left,10)+125) && e.pageY < (parseInt(g_Calendar.containerLayer.style.top,10)+125) && e.pageY > parseInt(g_Calendar.containerLayer.style.top,10));
	    if (e.target.name!='imgCalendar' && e.target.name!='month'  && e.target.name!='year' && e.target.name!='calendar' && !bTest){
		  g_Calendar.hide();
		}
	  }
	  if (browser.ie4 || browser.ie5){
		// extra test to see if user clicked inside the calendar but not on a valid date, we don't want it to disappear in this case
	   var bTest = (e.x > parseInt(g_Calendar.containerLayer.style.left,10) && e.x <  (parseInt(g_Calendar.containerLayer.style.left,10)+125) && e.y < (parseInt(g_Calendar.containerLayer.style.top,10)+125) && e.y > parseInt(g_Calendar.containerLayer.style.top,10));
	    if (e.srcElement.name!='imgCalendar' && e.srcElement.name!='month' && e.srcElement.name!='year' && !bTest & typeof(e.srcElement)!='object'){
		  g_Calendar.hide();
		}
	  }
	  if (browser.ns4) g_Calendar.hide();
	}

	// utility function
	function padZero(num) {
	  return ((num <= 9) ? ("0" + num) : num);
	}
	  // Finally licked extending  native date object;
	  Date.isLeapYear = function(year){ if (year%4==0 && ((year%100!=0) || (year%400==0))) return true; else return false; }
	  Date.daysInYear = function(year){ if (Date.isLeapYear(year)) return 366; else return 365;}
	  var DAY = 1000*60*60*24;
	  Date.prototype.addDays = function(num){
		return new Date((num*DAY)+this.valueOf());
	  }

	 // events capturing, careful you don't override this by setting something in the onload event of
	// the body tag
	/*
	window.onload=function()
	{
          new Calendar(new Date());
          if (browser.ns4){
            if (typeof document.NSfix == 'undefined'){
              document.NSfix = new Object();
              document.NSfix.initWidth=window.innerWidth;
              document.NSfix.initHeight=window.innerHeight;
            }
          }
        }
        if (browser.ns4) window.onresize = function(){
          if (document.NSfix.initWidth!=window.innerWidth || document.NSfix.initHeight!=window.innerHeight) window.location.reload(false);
    } // ns4 resize bug workaround

    window.document.onclick=handleDocumentClick;
    window.onerror = function(msg,url,line){
	  alert('******* an error has occurred ********' +
	  '\n\nARR21GPlease check that' +
	  '\n\n1)You have not added any code to the body onload event,'
	  +  '\nif you want to run something as well as the calendar initialisation'
	  + '\ncode, add it to the onload event in the calendar library.'
	  + '\n\n2)You have set the parameters correctly in the g_Calendar.show() method '
	  + '\n\nSee www.totallysmartit.com\\examples\\calendar\\simple.asp for examples'
	  + '\n\n------------------------------------------------------'
	  + '\nError details'
	  + '\nText:' + msg + '\nurl:' + url + '\nline:' + line);
	}

	function writeStyle() {
	return '<style> '
		+ '\n td.cal{font-family : Arial,Helvetica,Sans-serif; font-size : 11px; color : #000000;  background-color : #d3d3d3; } '
		+ '\n select.month{  font-family : Arial,Helvetica,Sans-serif;  font-size : 11px;  color : #000000;  width : 85px;	} '
		+ '\n input.year{  font-family : Arial,Helvetica,Sans-serif;  font-size : 11px;  color : #000000;  width : 30px; } '
		+ '\n td.calDaysColor { font-family : Arial,Helvetica,Sans-serif;  font-size : 11px;  color : #ffffff;  background-color : #000000;	} '
		+ '\n td.calWeekend { font-family : Arial,Helvetica,Sans-serif;  font-size : 11px;  color : #ffffff;  background-color : #c0c0c0;	} '
		+ '\n td.calBgColor { font-family : Arial,Helvetica,Sans-serif;  font-size : 11px;  color : #ffffff;  background-color : #d3d3d3;	} '
		+ '\n .calBorderColor {	  font-family : Arial,Helvetica,Sans-serif;	  font-size : 11px;	  color : #ffffff;	  background-color : #a9a9a9;	}'
		+ '\n td.calHighlightColor {  font-family : Arial,Helvetica,Sans-serif;	  font-size : 11px;	  color : #ffffff;	  background-color : #ffffcc;	} '
		+ '\n A.cal:Active {	  font-family : Arial,Helvetica,Sans-serif;	  font-size : 11px;	  color : #000000;	  text-decoration : none;	}  '
		+ '\n A.cal:Visited {	  font-family : Arial,Helvetica,Sans-serif;	  font-size : 11px;	  color : #000000;	  text-decoration : none;	}  '
		+ '\n A.cal:Hover {	  font-family : Arial,Helvetica,Sans-serif;	  font-size : 11px;	  color : #FF0000;	  text-decoration : none;	} '
		+ '\n .disabled {	  font-family : Arial,Helvetica,Sans-serif;	  font-size : 11px;	  color : #808080;	  text-decoration : none;	}  '
		+ '</style>';

	} */


	function validateCompareDate(form){
	
		return true;
	}
	
	function padWithZeros(str,len){
		for(var i=str.length;i<len;i++){
			str = "0"+str;
			
		}
		
		return str;
	}


  // Validate field is formatted to 12345678.12
  function testRegExp8dot2(tag) {
    if(tag == null || trim(tag).length == 0) return true;

    re = /^\d{0,6}((\.?)|(\.\d{0,2}))$/

    return re.test(tag);
  }
  function testRegExp12dot2(tag){
    if(tag == null || trim(tag).length == 0) return true;

    re = /^\d{0,10}((\.?)|(\.\d{0,2}))$/
    return re.test(tag);

  }
  function testRegExp11dot4(tag){
    if(tag == null || trim(tag).length == 0) return true;

    re = /^\d{0,7}((\.?)|(\.\d{0,4}))$/
    return re.test(tag);

  }

  function checkFor8and2Format(field,fieldName){
    if(typeof field == 'undefined') return;
    var val = field.value;
    if(val == null || trim(val).length == 0) return true;

    if(!testRegExp8dot2(val)){
        alert("Please make sure that "+fieldName +" is of the format 123456.12");
        return;
    }

  }

  function checkFor10and2Format(field){
    if(typeof field == 'undefined') return;
    var val = field.value;
    if(val == null || trim(val).length == 0) return true;

    if(!testRegExp12dot2(val)){
        alert("Please make sure that cube is of the format 12345678910.12");
        return;
    }

  }
    function checkFor7and4Format(field,fieldName){
    if(typeof field == 'undefined') return;
    var val = field.value;
    if(val == null || trim(val).length == 0) return true;

    if(!testRegExp11dot4(val)){
        alert("Please make sure that "+fieldName +" is of the format 1234567.1234");
        return false;
    }
    return true;
  }