/***********************************************************************

     JavaScript Name        : Utils.js
     Author                 : Jaideep S. Parihar
************************************************************************/
var message="";
function clickIE() {if (document.all) {(message);return false;}}
function clickNS(e)
 {
if (document.layers||(document.getElementById&&!document.all)) 
{
	if (e.which==1||e.which==2||e.which==3) {(message);return false;}}}
	if (document.layers)
   {document.captureEvents(Event.MOUSEDOWN);document.onmousedown=clickNS;}
   else
   {document.onmouseup=clickNS;document.oncontextmenu=clickIE;}
document.oncontextmenu=new Function("return false")

/*
function openwin(url)
{
new_win=window.open(url,"BKS","resizable=no,alwaysLowered=yes,scrollbars=yes,width=500,height=500,status=no");
//new_win.moveTo(350,95);
new_win.focus();
}
*/


function checkAll(form,outsideElements,elementsPerRow,checkIndex)
{
	var numRows = (form.elements.length - (outsideElements + 1))/elementsPerRow;	
	var startIndex = checkIndex + 1;
	var ele = form.elements[checkIndex];

	for (var i=0;i<numRows;i++) 
	{	
   		form.elements[startIndex].checked=ele.checked; 
   		startIndex = startIndex + elementsPerRow;
   	}	
}


function validate(fieldValue)
{
	var strString;
	var intLength;
	var intLoopCount;
	var intStartIndex;
	var intEndIndex;
	

	// convert the input to string
	strString = fieldValue.toString();

	// Obtain the length of the string
	intLength = strString.length;
		
	//Obtain the index at which the string begins
	intStartIndex = -1;
	for(intLoopCount=0; intLoopCount < intLength; intLoopCount++)
	{
		if (strString.charAt(intLoopCount) == " ")
			intStartIndex = intLoopCount;
		else
			break;
	}
		
	// Extract the entire length of the string from the last trailing space
	strString = strString.substring(intStartIndex+1,intLength);
	
	intLength = strString.length;
	intEndIndex = intLength;

	// Locate the first leading space and obtain the index at which the string ends
	for(intLoopCount=intLength-1;intLoopCount>=0;intLoopCount--)
	{
		if (strString.charAt(intLoopCount) == " ")
			intEndIndex = intLoopCount;
		else
			break;
	}
	
	// Extract the actual string
	strString = strString.substring(0,intEndIndex);
	var valid = " _-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
	var ok="yes";
	var temp;
	for (var i=0; i<strString.length; i++)
	{
		temp = "" + strString.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	if (ok == "no") 
	{
		alert("Invalid entry!  Only characters and numbers are accepted!");
		strString = "";
   	}
	return strString;

}  // f'n validate()

function emailCheck (emailStr) {
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) {
	alert("Email address seems incorrect (check @ and .'s)")
	return false
}
var user=matchArray[1]
var domain=matchArray[2]
if (user.match(userPat)==null) {
    alert("The username doesn't seem to be valid.")
    return false
}

var IPArray=domain.match(ipDomainPat)
if (IPArray!=null) {
	  for (var i=1;i<=4;i++) {
	    if (IPArray[i]>255) {
	        alert("Destination IP address is invalid!")
		return false
	    }
    }
    return true
}
var domainArray=domain.match(domainPat)
if (domainArray==null) {
	alert("The domain name doesn't seem to be valid.")
    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) {
   alert("The address must end in a three-letter domain, or two letter country.")
   return false
}

if (len<2) {
   var errStr="This address is missing a hostname!"
   alert(errStr)
   return false
}
return true;
}

function validateEmail(element)
{
 if(emailCheck(element.value))
 	return true;
 else
 {
 	element.focus(); 	
 	return false;
 }	
 
}

function validateDate(objName) 
{
	var datefield = objName;
	if (chkDate(objName) == false) 
	{	
		datefield.focus();
		return false;
	}
	else 
	{
		return true;
	}
}

function chkDate(objName) 
{
	var strDate;
	var strDateArray;
	var strDay;
	var strMonth;
	var strYear;
	var intDay;
	var intMonth;
	var intYear;
		
	strDate = objName.value;
		
	if (strDate.indexOf("/") != -1) 
	{
		strDateArray = strDate.split("/");
		if (strDateArray.length != 3) 
		{
			alert("Date format is dd/mm/yyyy.");
			return false;
		}
		else 
		{
			if ((strDateArray[0].length != 2) || (strDateArray[1].length != 2) || (strDateArray[2].length != 4))
			{
				alert("Date format is dd/mm/yyyy.");
				return false;
			}
			strDay = strDateArray[0];
			strMonth = strDateArray[1];
			strYear = strDateArray[2];
		}
	


		if (validateIntegerValue(strDay) && validateIntegerValue(strMonth) && validateIntegerValue(strYear))
		{
			intMonth = parseInt(strMonth,10); 
			intDay = parseInt(strDay,10);
			intYear = parseInt(strYear,10);
			
			if (intYear>2010 || intYear<1990) 
			{			
				alert("Please check value for year.");
				return false;
			}
			
			if (intMonth>12 || intMonth<1) 
			{			
				alert("Please enter valid value for month.");
				return false;
			}
			
			if ((intMonth == 1 || intMonth == 3 || intMonth == 5 || intMonth == 7 || intMonth == 8 || intMonth == 10 || intMonth == 12) && (intDay > 31 || intDay < 1)) 
			{
				alert("Please enter valid value for day or month.");
				return false;
			}
			
			if ((intMonth == 4 || intMonth == 6 || intMonth == 9 || intMonth == 11) && (intDay > 30 || intDay < 1)) 
			{
				alert("Please enter valid value for day or month.");
				return false;
			}
			
			if (intMonth == 2) 
			{
				if (intDay < 1) 
				{
					alert("Please enter valid value for day.");
					return false;
				}
				if (LeapYear(intYear) == true) 
				{
					if (intDay > 29) 
					{
						alert("Please enter valid value for day or month.");
						return false;
					}
				}
			
				if (intDay > 28) 
				{
					alert("Please enter valid value for day or month.");
					return false;
				}
			}		
		}
		else
		{
			alert("Please enter numerals for day, month and year.");
			return false;	
		}
	}
	alert("Date format is dd/mm/yyyy.");
	return false;	
}


/********************************************************************
The following date formats are accepted:
mm-dd-yyyy, mm/dd/yyyy, mm.dd.yyyy, mm dd yyyy, 
mmm dd yyyy, mmddyyyy, m-d-yyyy, m/d/yyyy, m.d.yyyy, 
m d yyyy, mmm d yyyy, m-d-yy, m/d/yy, m.d.yy, m d yy, 
mmm d yy (yy is 20yy) 
***********************************************************************/
		
function checkdate(objName) {
var datefield = objName;
if (chkdate(objName) == false) {
datefield.select();
alert("That date is invalid.  Please try again.");
datefield.focus();
return false;
}
else {
return true;
   }
}
function chkdate(objName) {
var strDatestyle = "US"; //United States date style
//var strDatestyle = "EU";  //European date style
var strDate;
var strDateArray;
var strDay;
var strMonth;
var strYear;
var intday;
var intMonth;
var intYear;
var booFound = false;
var datefield = objName;
var strSeparatorArray = new Array("-"," ","/",".");
var intElementNr;
var err = 0;
var strMonthArray = new Array(12);
strMonthArray[0] = "Jan";
strMonthArray[1] = "Feb";
strMonthArray[2] = "Mar";
strMonthArray[3] = "Apr";
strMonthArray[4] = "May";
strMonthArray[5] = "Jun";
strMonthArray[6] = "Jul";
strMonthArray[7] = "Aug";
strMonthArray[8] = "Sep";
strMonthArray[9] = "Oct";
strMonthArray[10] = "Nov";
strMonthArray[11] = "Dec";
strDate = datefield.value;
if (strDate.length < 1) {
return true;
}
for (intElementNr = 0; intElementNr < strSeparatorArray.length; intElementNr++) {
if (strDate.indexOf(strSeparatorArray[intElementNr]) != -1) {
strDateArray = strDate.split(strSeparatorArray[intElementNr]);
if (strDateArray.length != 3) {
err = 1;
return false;
}
else {
strDay = strDateArray[0];
strMonth = strDateArray[1];
strYear = strDateArray[2];
}
booFound = true;
   }
}
if (booFound == false) {
if (strDate.length>5) {
strDay = strDate.substr(0, 2);
strMonth = strDate.substr(2, 2);
strYear = strDate.substr(4);
   }
}
if (strYear.length == 2) {
strYear = '20' + strYear;
}
// US style
if (strDatestyle == "US") {
strTemp = strDay;
strDay = strMonth;
strMonth = strTemp;
}
intday = parseInt(strDay, 10);
if (isNaN(intday)) {
err = 2;
return false;
}
intMonth = parseInt(strMonth, 10);
if (isNaN(intMonth)) {
for (i = 0;i<12;i++) {
if (strMonth.toUpperCase() == strMonthArray[i].toUpperCase()) {
intMonth = i+1;
strMonth = strMonthArray[i];
i = 12;
   }
}
if (isNaN(intMonth)) {
err = 3;
return false;
   }
}
intYear = parseInt(strYear, 10);
if (isNaN(intYear)) {
err = 4;
return false;
}
if (intMonth > 12 || intMonth < 1) {
err = 5;
return false;
}
if ((intMonth == 1 || intMonth == 3 || intMonth == 5 || intMonth == 7 || intMonth == 8 || intMonth == 10 || intMonth == 12) && (intday > 31 || intday < 1)) {
err = 6;
return false;
}
if ((intMonth == 4 || intMonth == 6 || intMonth == 9 || intMonth == 11) && (intday > 30 || intday < 1)) {
err = 7;
return false;
}
if (intMonth == 2) {
if (intday < 1) {
err = 8;
return false;
}
if (LeapYear(intYear) == true) {
if (intday > 29) {
err = 9;
return false;
}
}
else {
if (intday > 28) {
err = 10;
return false;
}
}
}
if (strDatestyle == "US") {
datefield.value = strMonthArray[intMonth-1] + " " + intday+" " + strYear;
}
else {
datefield.value = intday + " " + strMonthArray[intMonth-1] + " " + strYear;
}
return true;
}
function LeapYear(intYear) {
if (intYear % 100 == 0) {
if (intYear % 400 == 0) { return true; }
}
else {
if ((intYear % 4) == 0) { return true; }
}
return false;
}

function doDateCheck(from, to) {
if (Date.parse(from.value) <= Date.parse(to.value)) {
alert("The dates are valid.");
}
else {
if (from.value == "" || to.value == "") 
alert("Both dates must be entered.");
else 
alert("To date must occur after the from date.");
   }
}

function checkDateRange(from, to) 
{
	if (isEmpty(from))
	{
		alert("Both dates must be entered.");
		from.focus();
		return false;
	}
	
	if (isEmpty(to))
	{
		alert("Both dates must be entered.");
		to.focus();
		return false;
	}
	
	if (!(validateDate(from) && validateDate(to)))
	{
		return false;
	}
	
	var lvar1 = from.value;
	var lvar2 = to.value;
	
	var lDateFrom = new Date(parseInt(lvar1.substring(6,10)),(parseInt(lvar1.substring(3,5))-1),parseInt(lvar1.substring(0,2)));
	var lDateTo = new Date(parseInt(lvar2.substring(6,10)),(parseInt(lvar2.substring(3,5))-1),parseInt(lvar2.substring(0,2)));
	
	
	if (lDateFrom.getYear() < lDateTo.getYear()) 
	{		
		return true;	
	}
	
	if (lDateFrom.getYear() > lDateTo.getYear()) 
	{	
		alert("From date should be < To date.");
		from.focus();
		return false;	
	}
	
	var lMonthFrom = lDateFrom.getMonth();
	var lMonthTo = lDateTo.getMonth();
	
	if (lMonthFrom < lMonthTo) 
	{
		return true;	
	}

	if (lMonthFrom > lMonthTo) 
	{
		from.focus();
		alert("From date should be < To date.");
		return true;	
	}
	
	if (lDateTo.getDate() < lDateFrom.getDate()) 
	{
		from.focus();
		alert("From date should be < To date.");
		return false;	
	}
	
	return true;
}


function checkGender(element)
{
	if (element.selectedIndex == 0)
	{
		alert("Please select a value for Title.");
		element.focus();
		return false;
	}
	return true;
	
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid amount else returns false]
Function  : Check if value is valid amount. The format is xx.yy ie.,
		any number of digits followed by dot ['.'] followed 
		by 2 digits. Element gets focus if value is incorrect		
-----------------------------------------------------------------*/
function validateAmount(element,message)
{
	var lNumber = element.value;
	var lIndex = lNumber.indexOf(".")
	
	if (lIndex == -1)
	{
		alert("Dot is missing. Format is *.xx for "+ message);
		element.focus();
		return false;
	}
	
	if (((lIndex + 3) == lNumber.length))
	{			
		if (isNaN(lNumber))
		{
			alert("Please enter only numerals for "+ message);
			element.focus();
			return false;
		}	
		return true;
	}
	alert("Please enter 2 digits after the dot for "+ message);
	element.focus();
	return false;	
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid amount else returns false]
Function  : Check if value is valid amount. The format is xx.yy ie.,
		any number of digits followed by dot ['.'] followed 
		by 2 digits. Element gets focus if value is incorrect		
-----------------------------------------------------------------*/
function validateAmountF(element,message)
{
	if (isEmpty(element))
	{
		alert("Please enter a value for "+ message);
		element.focus();
		return false;
	}
	
	if (validateAmount(element,message))
		return true;
	else
		return false;
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid amount else returns false]
Function  : Check if value is valid amount. The format is xx.yy ie.,
		any number of digits followed by dot ['.'] followed 
		by 2 digits. Element gets focus if value is incorrect		
-----------------------------------------------------------------*/
function validateAmountFZ(element,message)
{
	if (validateAmountF(element,message))
	{
		if (parseFloat(element.value) == 0)
		{	
			alert("Zero value is not allowed for " + message);
			element.focus();
			return false;
		}
		if (parseFloat(element.value) < 0)
		{	
			alert("Negative value is not allowed for " + message);
			element.focus();
			return false;
		}
		return true;
	}
	return false;
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid amount else returns false]
Function  : Check if value is valid amount. The format is xx.yy ie.,
		any number of digits followed by dot ['.'] followed 
		by 2 digits. Element gets focus if value is incorrect		
-----------------------------------------------------------------*/
function validateAmountZ(element,message)
{
	if (validateAmount(element,message))
	{
		if (parseFloat(element.value) == 0)
		{	
			alert("Zero value is not allowed for " + message);
			element.focus();
			return false;
		}
		if (parseFloat(element.value) < 0)
		{	
			alert("Negative value is not allowed for " + message);
			element.focus();
			return false;
		}
		return true;
	}
	return false;
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid exchange rate else 
			returns false]
Function  : Check if value is valid exchange rate. The format is xx.yy
		ie.,2 digits followed by dot ['.'] followed by 2 digits.
		Element gets focus if value is incorrect		
-----------------------------------------------------------------*/
function validateExchangeRate(element)
{
	if (isEmpty(element))
	{
		alert("Please enter valid Exchange Rate. Blank is not allowed");
		element.focus();
		return false;
	}
	
	var lNumber = element.value;
	var lIndex = lNumber.indexOf(".")
	
	if (lIndex == -1)
	{
		alert("Dot is missing. Format for Exchange Rate is xx.xx");
		element.focus();
		return false;
	}

	if (((lIndex + 3) == lNumber.length) && (lIndex == 2))
	{			
		if (isNaN(lNumber))
		{
			alert("Please enter only numerals for Exchange Rate.");
			element.focus();
			return false;
		}	

		if (lNumber < 0.0)
		{
			alert("Please enter positive value for Exchange Rate.");
			element.focus();
			return false;
		}

		if (lNumber == 0.0)
		{
			alert("Zero value is not allowed for Exchange Rate.");
			element.focus();
			return false;				
		}
		return true;
	}	
	else
	{
		alert("Format is 2 digits before dot and 2 digits after dot.");
		element.focus();
		return false;
	}
	return true;
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid integer else returns false]
Function  : Check if value is valid integer. Element gets focus if
		value is incorrect
-----------------------------------------------------------------*/

function validateInteger(element)
{
	if (isNaN(element.value))
		return false;	
	else
	{
		if (element.value.indexOf(".") == -1)		
			return true;
		else
			return false;		
	}	
}

function validateIntegerValue(value)
{
	if (isNaN(value))
		return false;	
	else
	{
		if (value.indexOf(".") == -1)		
			return true;
		else
			return false;		
	}	
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid integer else returns false]
Function  : Check if value is valid integer. Element gets focus if
		value is incorrect
-----------------------------------------------------------------*/

function validateIntegerF(element,message)
{
	if (isEmpty(element))
	{
		alert("Please enter " + message);
		element.focus();
		return false;
	}
	if (isNaN(element.value))
	{
	
		alert("Please enter valid integer values for " + message);
		element.focus();
		return false;
	}
	else
	{
		if (element.value.indexOf(".") == -1)		
			return true;
		else
		{
			alert("Please remove dot in value for "+ message);
			element.focus();
			return false;
		}
	}	
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid integer else returns false]
Function  : Check if value is valid integer. Element gets focus if
		value is incorrect
-----------------------------------------------------------------*/

function validateIntegerFZ(element,message)
{
	if (validateIntegerF(element,message))
	{
		if (parseInt(element.value) == 0)
		{	
			alert("Zero value is not allowed for " + message);
			element.focus();
			return false;
		}
		if (parseInt(element.value) < 0)
		{	
			alert("Negative value is not allowed for " + message);
			element.focus();
			return false;
		}
		return true;
	}
	return false;
}

/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if value is valid integer else returns false]
Function  : Check if value is valid integer. Element gets focus if
		value is incorrect
-----------------------------------------------------------------*/

function validateIntegerZ(element)
{
	if (validateInteger(element))
	{
		if (parseInt(element.value) == 0)
			return false;
		
		if (parseInt(element.value) < 0)
			return false;
		
		return true;
	}
	return false;
}



/*-----------------------------------------------------------------
Parameters: Editable GUI Element ie., textField or testArea
Returns	  : Boolean [True if element has blanks or null value else
			returns false]
Function  : Check if value is blank or string length is zero
-----------------------------------------------------------------*/
 
function isEmpty(element)
{		
	var strValue = element.value;	
	var count = element.value.length;
	
	if (count==0)
		return true;
	
	for (var i=0;i<count;i++)
		{	
			if (strValue.charAt(i) != " ")				
				return false;			
		}	
	return true;	
}


function validateAlphaNumeric(fieldValue)
{
	// Get the value of the text field into this variable
	var strFieldValue = fieldValue.toString();
	// Start validation
	if (!(isNaN(fieldValue)))
	{
		if (parseInt(fieldValue) == 0)
			return false;
	}
	var valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
	var ok="yes";
	var temp;
	for (var i=0; i<strFieldValue.length; i++)
	{
		temp = "" + strFieldValue.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	if (ok == "no") 
	{
		return false;
   	}
   	if (ok == "yes") 
	{
		return true;
   	}
}  


function validateAlphaNumericF(element,message)
{
	if (isEmpty(element))
	{
		alert("Please enter value for "+ message);
		element.focus();
		return false;		
	}
	// Get the value of the text field into this variable
	var strFieldValue = element.value.toString();
	// Start validation
	var valid = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
	
	
	for (var i=0; i<strFieldValue.length; i++)
	{
		if (strFieldValue.substring(i, i+1) == " ") 
		{
			alert("Please remove space in value for "+ message);
			element.focus();
			return false;
		}
		
		if (valid.indexOf(strFieldValue.substring(i, i+1)) == "-1") 
		{
			alert("Special characters are not allowed for "+ message);
			element.focus();
			return false;
		}
	}
	
	if (!(isNaN(element.value)))
	{
		if (parseInt(element.value) == 0)
		{
			alert("Zero value is not allowed for "+ message);
			element.focus();
			return false;
		}		
	}
	return true;
}  

function validateName(fieldValue)
{
	// Get the value of the text field into this variable
	var strFieldValue = fieldValue.toString();
	// Start validation
	var valid = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
	var ok="yes";
	var temp;
	// Check all the characters of the string
	for (var i=0; i<strFieldValue.length; i++)
	{
		temp = "" + strFieldValue.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	if (ok == "no") 
	{
		return false;
   	}
   	if (ok == "yes") 
	{
		return true;
   	}
}

function validateNameF(element,message)
{
	if (isEmpty(element))
	{
		alert("Please enter " + message);
		element.focus();
		return false;
	}	
	// Get the value of the text field into this variable
	var strFieldValue = element.value.toString();
	
	// Start validation
	var valid = " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.";
	
	// Check all the characters of the string
	for (var i=0; i<strFieldValue.length; i++)
	{
		if (valid.indexOf(strFieldValue.substring(i, i+1)) == "-1") 
		{
			alert("Special characters or numbers are not allowed for " + message);
			element.focus();
			return false;
		}	
	}
	return true;
}

function validatePhoneFaxNumber(fieldValue)
{
	// Get the value of the text field into this variable
	var strFieldValue = fieldValue.toString();
	// Start validation
	var valid = " 1234567890-()";
	var ok="yes";
	var temp;
	// Check all the characters of the string
	for (var i=0; i<strFieldValue.length; i++)
	{
		temp = "" + strFieldValue.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	if (ok == "no") 
		{
			return false;
	   	}
	   	if (ok == "yes") 
		{
			return true;
   	}
}

function validatePhoneFaxNumberF(element,message)
{
	// Get the value of the text field into this variable
	var strFieldValue = element.value;
	// Start validation
	var valid = " 1234567890-()";
	var ok="yes";
	var temp;
	// Check all the characters of the string
	for (var i=0; i<strFieldValue.length; i++)
	{
		temp = "" + strFieldValue.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	if (ok == "no") 
	{
		element.focus();
		alert("Please enter proper values for " + message);
		return false;
	}	
	else
	{
		return true;
   	}
}

function validatePhoneNumber(element)
{
	// Get the value of the text field into this variable
	var strValue = element.value;
	// Start validation
	var valid = "-1234567890";
	var ok="yes";
	var temp;
	// Check all the characters of the string
		
	for (var i=0; i<strValue.length; i++)
	{
		temp = "" + strValue.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	
	// should not be first char	
	if (strValue.substring(0,1) == "-")
	{
		alert("- should not be first pls.");
		return false;
	}
		
	var var1 =  element.value.length;
	
	// should not be first char	
	if (strValue.substring(var1-1,var1) == "-")
	{
		alert("- should not be last pls.");
		return false;
	}
	
	// should not be 2 consecutive -
	if (strValue.indexOf("--") != -1)
	{
		alert("No consecutive - pls.");
		return false;
	}
	
	// should not be more than 2 occurances		
	if (strValue.split("-").length > 3) 
	{
		alert("Not more than 2 - pls.");
		return false;
	}
	
	var strArray = strValue.split("-");	
	if (strArray.length <2 )
	{
		if (strValue.length > 11)
		{
			alert("No more than 11 digits pls");
			return false;
		}
	}
	else
	{
		for (var i=0; i<strArray.length; i++)
		{
			if (strArray[i].length > 7)
			{				
				alert("No more than 7 digits pls");
				return false;
			}
		}
	}
	if (ok == "no")
	{
		element.focus();
		alert("Please enter proper values for Phone Number.");
		return false;
	}	
	else
	{
		return true;
   	}
}

function validateFaxNumber(element)
{
	// Get the value of the text field into this variable
	var strValue = element.value;
	// Start validation
	var valid = "1234567890";
	var ok="yes";
	var temp;
	// Check all the characters of the string
	for (var i=0; i<strValue.length; i++)
	{
		temp = "" + strValue.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	
	// should not be first char	
	if (strValue.substring(0,1) == "-")
	{
		alert("- should not be first pls.");
		return false;
	}
		
	var var1 =  element.value.length;
	
	// should not be first char	
	if (strValue.substring(var1-1,var1) == "-")
	{
		alert("- should not be last pls.");
		return false;
	}
	
	// should not be 2 consecutive -
	if (strValue.indexOf("--") != -1)
	{
		alert("No consecutive - pls.");
		return false;
	}
	
	// should not be more than 2 occurances		
	if (strValue.split("-").length > 3) 
	{
		alert("Not more than 2 - pls.");
		return false;
	}
	
	var strArray = strValue.split("-");	
	if (strArray.length <2 )
	{
		if (strValue.length > 11)
		{
			alert("No more than 11 digits pls");
			return false;
		}
	}
	else
	{
		for (var i=0; i<strArray.length; i++)
		{
			if (strArray[i].length > 7)
			{				
				alert("No more than 7 digits pls");
				return false;
			}
		}
	}
	
	if (ok == "no") 
	{
		element.focus();
		alert("Please enter proper values for Fax Number.");
		return false;
	}	
	else
	{
		return true;
   	}
}


function validatePathNames(fieldValue)
{
	// Get the value of the text field into this variable
	var strFieldValue = fieldValue.toString();
	// Start validation
	if(strFieldValue.indexOf("//") != "0")
	{			
		alert("Please start with a double forward slash ! ");
		return false;
	}
	
	if(strFieldValue.split("//").length > "2")
	{			
		alert("Do not give two double forward slashes ! ");
		return false;
	}
	if(strFieldValue.split(".").length > "2")
	{			
		alert("Do not give two file extensions ! ");
		return false;
	}
	if(strFieldValue.indexOf("./") >= "0" || strFieldValue.indexOf("/.") >= "0")
	{			
		alert("Do not give a dot before/after a forward slash ! ");
		return false;
	}
	if(strFieldValue.indexOf("..") >= "0")
	{			
		alert("Two consecutive dots not allowed ! ");
		return false;
	}
	if(strFieldValue.indexOf("///") >= "0")
	{			
		alert("Three forward slashes not allowed ! ");
		return false;
	}
	if(strFieldValue.indexOf(".") == "-1")
	{			
		alert("Please give the file extension (file type) ! ");
		return false;
	}
	if(strFieldValue.indexOf(".") == (strFieldValue.length-1))
	{			
		alert("You forgot to enter the file extension (file type) ! ");
		return false;
	}
	var valid = "./abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
	var ok="yes";
	var temp;
	for (var i=0; i<strFieldValue.length; i++)
	{
		temp = "" + strFieldValue.substring(i, i+1);
		if (valid.indexOf(temp) == "-1") ok = "no";
	}
	if (ok == "no") 
	{
		alert("Please enter authentic names - no special characters ! ");
		return false;
	}
	if (ok == "yes") 
	{
		return true;
   	}
}


function validateLength(fieldValue,length)
{
	// Get the value of the text field into this variable
	var strFieldValue = fieldValue.toString();
	
	if(strFieldValue.length<length)
		return false;
	else 
		return true;
}

function validateSelection(form,numOtherElements7,numRowElements3,startElementIndex3)
{
	var numRows = (form.elements.length - numOtherElements7)/numRowElements3;	
	var count = 0;
	
	for (var i=0;i<numRows;i++)
	{	
		if (form.elements[startElementIndex3].checked)
		{	
			count++;
		}		
		startElementIndex3 = startElementIndex3 + numRowElements3;
	}	
	if (count == 0)
	{
		alert("Atleast one row should be selected !");
		return false;
	}
	else
		return true;
}
	
function validateSingleSelection(form,numOtherElements7,numRowElements3,startElementIndex3)
{
	var numRows = (form.elements.length - numOtherElements7)/numRowElements3;	
	var count = 0;
	
	for (var i=0;i<numRows;i++)
	{	
		if (form.elements[startElementIndex3].checked)
		{	
			count++;
		}		
		startElementIndex3 = startElementIndex3 + numRowElements3;
	}	
	if (count == 0 || count > 1)
	{
		alert("One row should be selected !");
		return false;
	}
	else
		return true;
}
	
function checkAge(objName) {
var agefield = objName;
if (isNaN(objName.value)) {
agefield.select();
alert("That age is invalid.  Please try again.");
agefield.focus();
return true;
}
else {
return false;
   }
}   



function validateAddress(element)
{
	if (isEmpty(element))
	{
		alert("Please enter Address");
		element.focus();
		return false;
	}
	
	return true;
}



function doAgeCheck(from, to) {
if (from.value == "" || to.value == "") {
 alert("Both ages must be entered.");
}
else {
if (from.value <= to.value) 
alert("Valid Age");
else 
alert("To age must occur after the from age.");
   }
}

function blank_validate(fldobj,fldname)
{
if (fldobj.length)
 return "";
else
  return "   " + fldname + "\n";
}