/*
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'Project Name        - Mercury Clearinghouse
'Class/Form Name	 -  Validations.js
'Copyright           - 2009 by Health Plan Systems Inc.
'Purpose             - To create Global javascript validation functions
'Revision History:
'Ver   Date     Time   Developer
'-------------------------------
'$Log: /MDE/Development/Mercury Corporate Website/WHYMDE/Scripts/Validations.js $
'
'1     8/28/09 2:51p Jebasinghj
'
'1     1/19/09 6:17p Vijay
'
'~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/

var status ="Health Plan Systems"
var msgDateFormat = "Format : MM/DD/YYYY"
var msgNotValidDay="Not a valid day"
var msgNotValidMonth="Not a valid month"

var msgDateExceeds = "Date exceeds current date."
var msgPhoneFormat= "Format : 000-000-0000"
var msgFaxFormat= "Format : 000-000-0000"
var msgCellPhoneFormat= "Format: 000-000-0000"
var msgBeeperFormat= "Format: 000-000-0000"
var msgTaxFormat= "Format: 00-0000000"
var msgSsnFormat = "Format: 000-00-0000"
var msgZipFormat = "Format: 00000-0000"
var msgValidName = "Valid characters : [A-Z],[a-z],space,comma,full stop,hyphen,&"
var msgEmailFormat="Invalid Email address."
var sEmptyMessage = " is empty."
var msgNotValid="Not a valid"
var msgZero="Invalid number "

function vfnShowSearch(sCodeType, objQulaifier, objCode, objDesc, objFocus, sCheckFieldVal,objSerDate)
{
	var ctlCode=objCode.name
	var ctlDesc=objDesc.name
	var ctlFocus, sQulaifier
	var Code=objCode.value
	var Desc=objDesc.value
	var SerDate=objSerDate.value
	
	if(objQulaifier==null || objQulaifier=="")
		sQulaifier = "";
	else if(objQulaifier=="ND" || objQulaifier=="HC" || objQulaifier=="ID")
		sQulaifier = objQulaifier
	else
		sQulaifier = objQulaifier.options[objQulaifier.selectedIndex].value;		
		
	if(objFocus==null) 
		ctlFocus="";
	else
		ctlFocus=objFocus.name;
	
	if(sCheckFieldVal=="DONTSHOW" || sCheckFieldVal.value=="") 	{}		 //Don't Open
	else if(sCheckFieldVal==null || sCheckFieldVal!="")//Do Open
	{
		if(SerDate==null)
			var qrystr="CodeType=" + sCodeType + "&Qualifier=" + sQulaifier + "&Code=" + Code + "&ctlCode=" + ctlCode + "&Desc=" + escape(Desc) + "&ctlDesc=" + ctlDesc + "&ctlFocus=" + ctlFocus		
		else
			var qrystr="CodeType=" + sCodeType + "&Qualifier=" + sQulaifier + "&Code=" + Code + "&ctlCode=" + ctlCode + "&Desc=" + escape(Desc) + "&ctlDesc=" + ctlDesc + "&ctlFocus=" + ctlFocus + "&SerDate=" + SerDate

//	  Gowrishankar - 06/30/2004
//	  window.open("SearchCodesWin.asp?"+qrystr,"SearchCodesWin","resize=1,toolbar=no,scrollbars=yes,menubar=no,height=500,width=730,top=20,left=30")
		window.open("SearchCodesWin.asp?"+qrystr+"&AnesSetup=YES","SearchCodesWin","resize=1,toolbar=no,scrollbars=yes,menubar=no,height=500,width=730,top=20,left=30")
	}	
}


/*---------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnPopuluate
PURPOSE			-   To load City and State when zip is entered
ARGUMENTS		-	Code object, City object, State object, string
RETURN VALUE	-   Nil
---------------------------------------------------------------------------------------------------------------------*/
function vfnPopuluate(objCode,obj1,obj2,sMsg)
{

	if(objCode.value!="")
	{
		var parser=new ActiveXObject("microsoft.xmldom")
		parser.async="false"
			
		//location.href="XMLCodeCheck.asp?Code=" + escape(objCode.value) + "&msg=" + sMsg
		//return	

		parser.load("XMLCodeCheck.asp?Code=" + escape(objCode.value) + "&msg=" + sMsg)

		
		nodes = parser.documentElement.childNodes
				//answer_text.innerHTML=nodes.item(0).text
		//alert(nodes.item(0).text)
		//alert(nodes.item(1).text)

		if (nodes.item(0).text=="NA")
		{
			alert(sMsg+" Code not available in the list.")
			obj1.value=""
			obj2.value=""
			objCode.focus()
			objCode.select();
		}
		else
		{
			obj1.value=nodes.item(0).text
			obj2.value=nodes.item(1).text
		}
	}
}

function vfnPopuluateZip(objCode ,obj1,obj2,obj3,sMsg)
{
var nodes
	if(objCode.value!="")
	{
		sURL="XMLCodeCheck.asp?Code=" + escape(objCode.value) + "&msg=" + sMsg
		nodes=vfnXMLHttpRequest(sURL,"N")
		//nodes = nodes1.documentElement.childNodes
		   
	if (vfnGetNodeValue(nodes, 0)=="NA")
		{
			alert(sMsg + " Code not available in the list.")
			obj1.value = ""
			obj2.value = ""
			obj3.value = ""
			//objCode.focus()
			objCode.select();
			 
			return false;
		}
		else
		{
		 
		 
			obj1.value=vfnGetNodeValue(nodes, 0);//nodes.item(0).text
		
		
			obj2.value=vfnGetNodeValue(nodes, 1);
		
			obj3.value=vfnGetNodeValue(nodes, 2);
			return true;
		}
	}
	
}
function vfnPopuluateZip1(objCode ,obj1,obj2,obj3,sMsg)
{
	if(objCode.value!="")
	{
		var parser=new ActiveXObject("microsoft.xmldom")
		parser.async="false"
		parser.load("XMLCodeCheck.asp?Code=" + escape(objCode.value) + "&msg=" + sMsg)
		nodes = parser.documentElement.childNodes
		if (nodes.item(0).text=="NA")
		{
			alert(sMsg + " Code not available in the list.")
			obj1.value = ""
			obj2.value = ""
			obj3.value = ""
			objCode.focus()
			objCode.select();
			return false;
		}
		else
		{
		
			obj1.value=nodes.item(0).text
			obj2.value=nodes.item(1).text
			obj3.value=nodes.item(2).text
			return true;
		}
	}
}


/*----------------------------------------------------------------------------------------------------------------------
FUNCTION NAME	-	vfnTrim
PURPOSE			-	To trim spaces
ARGUMENTS		-	Field object
RETURN VALUE	-	Trimmed value
-------------------------------------------------------------------------------------------------------------------------*/

function vfnTrim(obj)
{
  	var Field
    Field = obj
    if (!Field) // Validate the Form element
      {
        alert("Function : Element is not Defined !");
        return(-1);
      }
			
	var y=Field.value.length;
    var retval=Field.value;
    var m=0;
		
    while(m < y) //Start removing white spaces from left side
	{  
      	if ((retval.substring(0,1)==" ")||(retval.substring(0,1)=="     "))
		{ 
          	retval=Field.value.substring(m+1,y); //remove left most white char
        } 
        else 
        { 
          	break;
        }
        m++;
    }
				
    y=retval.length;
    m=y;
	
      while (m >= 0) //Start removing white spaces from right side
		{  
        	if ((retval.substring(m-1,m)==" ")||(retval.substring(m-1,m)==" "))
          	{  
            	retval=retval.substring(0,m-1); //remove right most white char
            } 
          else 
            { 
              break;  //first non - white character encountered while 
                      //traversing from right to left. so break the loop
            }
          m--;
        }
        
      return retval;
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	- vfnReplace
PURPOSE			- To remove the character (eg - or /)
ARGUMENTS		- Field value, character to be removed
RETURN VALUE	- Field value with the character removed
-------------------------------------------------------------------------------------------------------------------------*/

function vfnReplace(sData,replaceChar)
{
	var newData=""
	for(var i=0; i<sData.length; i++)
	{
		if(sData.charAt(i)==replaceChar)
		{
		}
		else
		{
			newData = newData + sData.charAt(i)
		}
	}
	return newData
}


/*---------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnCheckForEmpty
PURPOSE			-   To check for empty.
ARGUMENTS		-	Field object, Message, Layer name, X position , Y position , ScrollBy/ScrollTo
RETURN VALUE	-   alert() (if empty) and return boolean (return false if empty)
---------------------------------------------------------------------------------------------------------------------*/
function vfnCheckForEmpty(obj,sMsg,sLayerName, scrollX, scrollY,scrollMode)
{
	if (scrollX==null) scrollX=-800 //for netscape
	if (scrollY==null) scrollY=-100
	if (scrollMode==null) scrollMode="By"	
	
	if (obj.type=="text" || obj.type=="password" || obj.type=="textarea" ||obj.type=="file")
	{
		obj.value=vfnTrim(obj)
		if (obj.value=="")
		{	
			if(sLayerName!=null  && sLayerName!="")
			//vfnLayerFocus(sLayerName)
			if (scrollMode=="To") window.scrollTo (scrollX, scrollY);
			{			
				obj.focus()
				obj.select();
			}
			if (scrollMode=="By") window.scrollBy(scrollX,scrollY)
			alert(sMsg + sEmptyMessage)
			return false;
		}
		else
			return true;
	}
	
	else if(obj.type=="select-one")	
	{
		//alert(obj.value)
		
	
		if (obj.options[obj.selectedIndex].value=="")
		{
			/*if(sLayerName!=null && sLayerName!="")
			{
				vfnLayerFocus(sLayerName)
			}*/
			if (scrollMode=="To") window.scrollTo (scrollX, scrollY);
			{
				obj.focus() 
				//obj.select();
			}
			if (scrollMode=="By") window.scrollBy(scrollX,scrollY)
			alert(sMsg + sEmptyMessage)
			return false;
		}
		else
			return true;
	}
}


/*---------------------------------------------------------------------------------------------------------------------
	UDF:
	FUNCTION NAME	-	vfnIsDecimal
	PURPOSE			-	To check if the entered value is Decimal.
	ARGUMENTS		-	Field object, bAlert=true
	RETURN VALUE	-	If Integer returns true.
---------------------------------------------------------------------------------------------------------------------*/

function vfnIsDecimal(obj,bAlert)
{
	if(bAlert==null) bAlert=1

	if(obj.value!="")
	{
	var s1=obj.value;
	var s2;
	var tem=0;
	var dot=0;
	
		for (var i=0;i<s1.length;i++)
		{
			s2=s1.charAt(i);
			if (s2=='.') 
				{
					dot=dot+1;
					if (dot>1)
						{
							obj.focus();
							obj.select();
							alert("Valid characters : [0-9,.]");
							return false;
						}
				}
			if( (s2>='0') && (s2<='9') || (s2=='.'))
			{
				tem=1;
				
			}
			else
			{
				tem=0
				break;
			}
		}

		if (tem==0)
		{
			obj.focus();				
			obj.select();	 //coment by MIchael
			
			if(bAlert==1)
				alert("Valid characters : [0-9,.]");
			
			return false;
		}
		else
		return true;
	}
}

/*---------------------------------------------------------------------------------------------------------------------
	UDF:
	FUNCTION NAME	-	vfnIsNumber	
	PURPOSE			-	To check if the entered value is Integer.
	ARGUMENTS		-	Field object, bAlert=true
	RETURN VALUE	-	If Integer returns true.
---------------------------------------------------------------------------------------------------------------------*/

function vfnIsNumber(obj,bAlert)
{
	if(bAlert==null) bAlert=1

	if(obj.value!="")
	{
	var s1=obj.value;
	var s2;
	var tem=0;
		for (var i=0;i<s1.length;i++)
		{
			s2=s1.charAt(i);
			if( (s2>='0') && (s2<='9')  )
			{
				tem=1;
			}
			else
			{
				tem=0
				break;
			}
		}

		if (tem==0)
		{
			obj.focus();				
			obj.select();	 //coment by MIchael
			
			if(bAlert==1)
				alert("Valid characters : [0-9]");
			
			return false;
		}
		else
		return true;
	}
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnIsValidAlphaChar
PURPOSE			-	To allow [a-z], [A-Z] and restricting other characters
ARGUMENTS		-	Form object
RETURN VALUE	-	If valid returns true else displays alert
-------------------------------------------------------------------------------------------------------------------------*/
function vfnIsValidAlphaChar(obj)          
{

	var Field
	obj.value=vfnTrim(obj)
	Field = obj
    var length = Field.value.length;
   
    for (var ct = 0; ct <= (Field.value.length - 1); ct++)
    {
		var Validchar = Field.value.substring(ct,ct+1);  // Check one Character at a time
		var character = 0;  // Set character as invalid alphanumeric value
		if(!(((Validchar >= "A") && (Validchar <= "Z")) || ((Validchar >= "a") && (Validchar <= "z"))))
		{
			alert("Valid characters : [A-Z],[a-z]");
			obj.focus();
			obj.select();
			return false;		
		}
	 }
	return true; //If valid character
}


 

/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnIsValidAlphaSplChar
PURPOSE			-	To allow [a-z], [A-Z], space, comma, hyphen, numbers and restricting other characters
ARGUMENTS		-	Field object
RETURN VALUE	-	If valid returns true else displays alert
-------------------------------------------------------------------------------------------------------------------------*/

function vfnIsValidAlphaSplChar(obj)          
{
	var Field
	obj.value=vfnTrim(obj)

	Field = obj
	
    var length = Field.value.length;
    
    for (var ct = 0; ct <= (Field.value.length - 1); ct++)
    {
		var Validchar = Field.value.substring(ct,ct+1);  // Check one Character at a time
		var character = 0;  // Set character as invalid alphanumeric value
		if (((Validchar >= "A") && (Validchar <= "Z")) || ((Validchar >= "a") && (Validchar <= "z")) || (Validchar == " ") || (Validchar == ",") || (Validchar == "-")||((Validchar >="0") && (Validchar <= "9")))
		{
       		character = 1; //valid character
	  	}
		else
		{
			character = 0; //Invalid character			
			obj.focus();
			obj.select();
			alert("Valid characters : [A-Z],[a-z],[0-9],space,comma,hyphen");
			return false;
		}
	}
	return true; //If valid character
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	- vfnIsValidAlphaNum
PURPOSE			- To allow [A-Z], [a-z], numbers and restrict all other characters
ARGUMENTS		- Field object
RETURN VALUE	- If valid returns true else displays alert
-------------------------------------------------------------------------------------------------------------------------*/

function vfnIsValidAlphaNum(obj)          
{

	var Field
	obj.value=vfnTrim(obj)
	Field = obj
    var length = Field.value.length;
   
    for (var ct = 0; ct <= (Field.value.length - 1); ct++)
    {
		var Validchar = Field.value.substring(ct,ct+1);  // Check one Character at a time
		var character = 0;  // Set character as invalid alphanumeric value
		if(!(((Validchar >= "A") && (Validchar <= "Z")) || ((Validchar >= "a") && (Validchar <= "z")) || ((Validchar >= "0") && (Validchar <= "9") ||(Validchar == " "))))
		//if(!(((Validchar >= "A") && (Validchar <= "Z")) || ((Validchar >= "a") && (Validchar <= "z")) || ((Validchar >= "0") && (Validchar <= "9"))))
		{
			alert("Valid characters : [A-Z],[a-z],[0-9]");
			obj.focus();
			obj.select(); 
			return false;
		}
	}
	return true; //If valid character
}

/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	- vfnIsValidName
PURPOSE			- To allow [A-Z],[a-z],space,comma,.,-,&,'
ARGUMENTS		- Field object
RETURN VALUE	- If valid returns true else displays alert
-------------------------------------------------------------------------------------------------------------------------*/
function vfnIsValidName(obj) 
{	
	obj.value=vfnTrim(obj)	
    var iLength = obj.value.length;
    	
    for (var ct = 0; ct <= (iLength - 1); ct++)
    {	
		var Validchar = obj.value.substring(ct,ct+1);  // Check one Character at a time
		var character = 0;  // Set character as invalid alphanumeric value
		if (((Validchar >= "A") && (Validchar <= "Z")) || ((Validchar >= "a") && (Validchar <= "z")) || (Validchar == ".") || (Validchar == " ") || (Validchar == ",") || (Validchar == "-") || (Validchar == "&") ||(Validchar == "&"))
		{
       		character = 1; //valid character
	  	}
		else
		{
			character = 0; //Invalid character
			alert(msgValidName);
			obj.focus();
			obj.select();
			return false;
		}
	    
	}
	
	
	obj.value=((obj.value).charAt(0)).toUpperCase()+obj.value.substring(1,(obj.value).length)
	return true; //If valid character
	
}


/*----------------------------------------------------------------------------------------------------------------------
FUNCTION NAME	- vfnQuotes
PURPOSE			- To allow all characters except single quotes and double quotes
ARGUMENTS		- field object
RETURN VALUE	- If valid returns true else displays alert 
-------------------------------------------------------------------------------------------------------------------------*/
function vfnQuotes(obj)
{
	var Field
	obj.value=vfnTrim(obj)
	Field = obj
	var length = Field.value.length;
     
    for (var ct = 0; ct <= (Field.value.length - 1); ct++)
    {
		var Validchar = Field.value.substring(ct,ct+1);  // Check one Character at a
							    // time
		var character = 0;  // Set character as invalid alphanumeric value
		if ((Validchar == "'") || (Validchar == '"'))
		{
			character = 0; //Invalid character			
			obj.focus();
			obj.select();
			alert("Type valid characters [InValid characters are single quotes and double quotes]");
			return false;
	  	}
		else
		{
			character = 1; //valid character
		}
	}
	return true; //If valid character
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnPhoneFaxFormat
PURPOSE			-	To format Phone and Fax values to the format 000-000-0000
ARGUMENTS		-	Form object, character to distinguish phone or fax
RETURN VALUE	-	If valid returns true else displays alert  
-------------------------------------------------------------------------------------------------------------------------*/
function vfnPhoneFaxFormat(obj,nType)
{

    obj.value=vfnTrim(obj);	
	phonefaxno=obj.value;			
	
	if(phonefaxno=="")return true;
	phonefaxno = vfnReplace(phonefaxno,"-")
	obj.value = phonefaxno
	
		if(vfnIsValidAlphaNum(obj)) //vfnIsNumber
		{	if(phonefaxno.length==10)
			{
				if(phonefaxno.substring(0,3)=="000" && phonefaxno.substring(3,6)=="000" && phonefaxno.substring(6,10)=="0000")	
					{
						if(nType=="F"){
							sMsgInvalid=" Fax number."
						}
						else if(nType=="P"){		
							sMsgInvalid=" Phone number."			
						}
						else if(nType=="C"){					
							sMsgInvalid=" Cell phone number."
						}
						else if(nType=="B"){
							sMsgInvalid=" Beeper."
						}
						obj.focus();
						obj.select();
						alert(msgNotValid + sMsgInvalid);
						return false
					}
				
				obj.value = phonefaxno.substring(0,3) + "-" + phonefaxno.substring(3,6) + "-" + phonefaxno.substring(6,10)	
				vfnToUpper(obj)
			}
			else
			{
				if(nType=="F"){					
					obj.focus();
					obj.select();
					alert(msgFaxFormat);
				}			
				else if(nType=="P"){					
					obj.focus();
					obj.select();
					alert(msgPhoneFormat);
				}
				else if(nType=="C"){					
					obj.focus();
					obj.select();
					alert(msgCellPhoneFormat);
				}
				else if(nType=="B"){
					obj.focus();
					obj.select();
					alert(msgBeeperFormat);
				}	
				return false;
			}
			
		}
		else
			return false;
		
		/*else{
			obj.select();obj.focus();
			alert("Enter valid characters [Valid character set [0-9]]");
			return false;}*/
		
		return true
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnTaxIDFormat
PURPOSE			-	To format tax value to format 00-0000000
ARGUMENTS		-	Field object
RETURN VALUE	-	If valid returns true else displays alert   
-------------------------------------------------------------------------------------------------------------------------*/

function vfnTaxIDFormat(obj)
{
    obj.value=vfnTrim(obj);
	taxID=obj.value;			
	
	if(taxID=="")return true;
	 			
		taxID = vfnReplace(taxID,"-")
		obj.value = taxID
		
		if(vfnIsNumber(obj))
		{		
			if( taxID.substring(0,2)=="00" && taxID.substring(2,9)=="0000000")
			{
				
				obj.focus();
				obj.select();
				alert(msgNotValid + " Tax ID.");
				return false;
			
			}
			if(taxID.length==9)
			{	
				obj.value = taxID.substring(0,2) + "-" + taxID.substring(2,9)	
			}
			else
			{
				obj.focus();
				obj.select();
				alert(msgTaxFormat);
				return false;
			}
		}
		else{
			/*obj.select();
			obj.focus();
			alert("Enter valid characters [Valid character set [0-9]]");*/
			return false;
			}
		
		return true
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnSSNFormat
PURPOSE			-	To format SSN value to format 000-00-0000
ARGUMENTS		-	Field object
RETURN VALUE	-	If valid returns true else displays alert   
-------------------------------------------------------------------------------------------------------------------------*/

function vfnSSNFormat(obj)
{
    obj.value=vfnTrim(obj);	
	ssn=obj.value;			
	
	if(ssn=="")return true;	
	 			
		ssn = vfnReplace(ssn,"-")
		
		obj.value = ssn	
		
		if(vfnIsNumber(obj))
		{		
			if(ssn.substring(0,3)=="000" && ssn.substring(3,5)=="00" && ssn.substring(5,9)=="0000")	
				{
				alert(msgNotValid + " SSN number." );
				obj.focus();
				obj.select();
				return false
				}
			if(ssn.length==9)
			{	
				obj.value = ssn.substring(0,3) + "-" + ssn.substring(3,5)	+ "-" + ssn.substring(5,9)	
			}
			else
			{	
				alert(msgSsnFormat);
				obj.focus();
				obj.select();
				return false;
			}
		}
		else{
			/*obj.select();
			obj.focus();
			alert("Valid characters : [0-9]");*/	
			return false;
			}		
		
		return true
}


/*------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnZipFormat
PURPOSE			-	To format zip value to format 00000-0000
ARGUMENTS		-	Field object
RETURN VALUE	-	If valid returns true else displays alert   
-------------------------------------------------------------------------------------------*/

function vfnZipFormat(obj)
{	
	obj.value=vfnTrim(obj);	
	zip=obj.value;
		
	if(zip=="") return true;
		
		zip = vfnReplace(zip,"-")		
		obj.value = zip;
		
		if(vfnIsNumber(obj))
		{		
			if(zip.length==9 || zip.length==5)
			{				
			if( zip.substring(0,5)=="00000" || zip.substring(5,9)=="0000")
				{
					alert(msgNotValid + " Zip code");				
					obj.focus();
					obj.select();
					return false;
					
				}
			if(zip.length==9) obj.value = zip.substring(0,5) + "-" + zip.substring(5,9);
	
			}
			else
			{
				alert(msgZipFormat);				
				obj.focus();
				obj.select();
				return false;
			}
		}
		else{
			/*alert("Enter valid characters [Valid character set [0-9]]");
			obj.select();
			obj.focus();*/
			return false;
			}
		
		return true;
		//obj.value=left(zip
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnSelectListItem
PURPOSE			-	To select the value (in the list box) given in the parameter 'selValue'. 
ARGUMENTS		-	Field object, Selected Value
RETURN VALUE	-	If the supplied value(selValue) is present in the list box, the particular item will be selected.
------------------------------------------------------------------------------------------------------------------------*/

function vfnSelectListItem(selObj,selValue)
{
	var iSIndex=0
	for(var i=0; i<selObj.length; i++)
	{
		if(selObj.options[i].value==selValue)
		{
			iSIndex=i
			break;
		}
	}
	selObj.selectedIndex=iSIndex;
}

/*----------------------------------------------------------------------------------------------------------------------
UDF: Date:		-	4:32 AM 07/22/2003(MIchael)
FUNCTION NAME	-	vfnSelectListBox
PURPOSE			-	On choosing a value from one select box, to load the corresponding value in the other select box
ARGUMENTS		-	selObj1,selObj2 (List box objects)
RETURN VALUE	-	If the selected value in the first list box is present in the second list box, the particular item will 
				-   be selected in the second list box
------------------------------------------------------------------------------------------------------------------------*/

function vfnSelectList(selObj1,selObj2)
{
	var iSIndex=0
	var selValue = selObj1.options[selObj1.selectedIndex].value;
	
	for(var i=0; i<selObj2.length; i++)
	{
		if(selObj2.options[i].value==selValue)
		{
			iSIndex=i
			break;
		}
	}
	selObj2.selectedIndex=iSIndex;
}


/*-----------------------------------------------------------------------------------------------------------------------

FUNCTION NAME	 - fnGetDays
PURPOSE			 - TO GET THE DAYS FOR THE CORRESPONDING MONTHS

-------------------------------------------------------------------------------------------------------------------------*/



function vfnGetDays(month,year){

	var ar=new Array(12)

	ar[0]=31
	ar[1]=(vfnLeapYear(year))?29:28
	ar[2]=31
	ar[3]=30
	ar[4]=31
	ar[5]=30
	ar[6]=31
	ar[7]=31
	ar[8]=30
	ar[9]=31
	ar[10]=30
	ar[11]=31
	return ar[month]
}

/*-------------------------------------------------------------------------------------------------------------------------

FUNCTION NAME	 - vfnLeapYear
PURPOSE			 - TO CHECK IF THE YEAR VALUE PASSED IS A LEAP YEAR OR NOT

----------------------------------------------------------------------------------------------------------------------------*/
function vfnLeapYear(year){
	if(year%4==0)
		return true;
	else
	return false;
}


//-----------------------------------------------DATE FORMAT END----------------------------------------------------------------------

function fnDateCompare(date1,GTToday1,date2,GTToday2,sMsg1,sMsg2, sTite,dd1Comdd2)
{
//1 or undefine - dd1<dd2
//10 - dd1<=dd2
//-1 - dd1>dd2
//-10 - dd1>=dd2



if(sTite=="")
{}
else
sTite=sTite+" : "

var ck=false

	ck=vfnDateCheck(date1,GTToday1) && vfnDateCheck(date2,GTToday2)
	
if(ck)
{
if(date1.value=="" && date2.value=="")
	return true;
else if(date1.value=="")
	{
	alert(sTite+sMsg1 + " is Empty");
	date1.focus();
	date1.select();
	return false;
	}
else if(date2.value=="")
	{
	alert(sTite+sMsg2 + " is Empty");
	date2.focus();
	date2.select()
	return false; 
	}
else if(dd1Comdd2=="10" && (new Date(date1.value) > new Date(date2.value)))
	{
	alert(sTite+sMsg2 +" should be greater than or equal to "+ sMsg1+".")
	date2.focus();
	date2.select()
	return false
	}
else if(dd1Comdd2!="10" &&(new Date(date1.value) >= new Date(date2.value)) )
	{	
	alert(sTite+sMsg2 +" should be greater than "+ sMsg1+".")
	date2.focus();
	date2.select();
	return false
	}
else
	return true;
		}
		else
			return false;
		
}


function vfnToUpper(obj)
{
	obj.value=obj.value.toUpperCase()
}

//To obtain, time for URL 
function vfnGetTime()
{
	return new Date().getTime();
}

function vfnCancel()
{
	if(confirm("Do you want to cancel the changes made?")==true)
	{
		window.location.reload();
	}
}
 
/*----------------------------------------------------------------------------------------------------------------------
UDF: Date:		-	11/26/2003
FUNCTION NAME	-	vfnSelectAllCheck
PURPOSE			-	On selecting a check box all other check box below it gets selected
ARGUMENTS		-	objChkAll,sChkName,iCount
------------------------------------------------------------------------------------------------------------------------*/

function vfnSelectAllCheck(objChkAll,sChkName,iCount)
{
	if(objChkAll.checked==true)
	{
		for(i=1;i<iCount.value;i++)
		{
			document.myform.elements[sChkName+i].checked=true
		}
	}
	else
	{
		for(i=1;i<iCount.value;i++)
		{
			document.myform.elements[sChkName+i].checked=false
		}
	}
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnEmailCheck
PURPOSE			-	To validate the field for a valid email address
ARGUMENTS		-	Field object
RETURN VALUE	-	If valid returns true else displays alert    
-------------------------------------------------------------------------------------------------------------------------*/

function vfnEmailCheck(obj)
{
	//emailStr=obj.value
	emailStr=vfnTrim(obj)

	if(emailStr=="")return true;	

	/* The following variable tells the rest of the function whether or not
	to verify that the address ends in a two-letter country or well-known
	TLD.  1 means check it, 0 means don't. */

	var checkTLD=1;

	/* The following is the list of known TLDs that an e-mail address must end with. */

	var knownDomsPat=/^(com|net|org|edu|int|mil|gov|arpa|biz|aero|name|coop|info|pro|museum)$/;

	/* The following pattern is used to check if the entered e-mail address
	fits the user@domain format.  It also is used to separate the username
	from the domain. */

	var emailPat=/^(.+)@(.+)$/;

	/* The following string represents the pattern for matching all special
	characters.  We don't want to allow special characters in the address. 
	These characters include ( ) < > @ , ; : \ " . [ ] */

	var specialChars="\\(\\)><@,;:\\\\\\\"\\.\\[\\]";

	/* The following string represents the range of characters allowed in a 
	username or domainname.  It really states which chars aren't allowed.*/

	var validChars="\[^\\s" + specialChars + "\]";

	/* The following pattern applies if the "user" is a quoted string (in
	which case, there are no rules about which characters are allowed
	and which aren't; anything goes).  E.g. "jiminy cricket"@disney.com
	is a legal e-mail address. */

	var quotedUser="(\"[^\"]*\")";

	/* The following pattern applies for domains that are IP addresses,
	rather than symbolic names.  E.g. joe@[123.124.233.4] is a legal
	e-mail address. NOTE: The square brackets are required. */

	var ipDomainPat=/^\[(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})\]$/;

	/* The following string represents an atom (basically a series of non-special characters.) */

	var atom=validChars + '+';

	/* The following string represents one word in the typical username.
	For example, in john.doe@somewhere.com, john and doe are words.
	Basically, a word is either an atom or quoted string. */

	var word="(" + atom + "|" + quotedUser + ")";

	// The following pattern describes the structure of the user

	var userPat=new RegExp("^" + word + "(\\." + word + ")*$");

	/* The following pattern describes the structure of a normal symbolic
	domain, as opposed to ipDomainPat, shown above. */

	var domainPat=new RegExp("^" + atom + "(\\." + atom +")*$");

	/* Finally, let's start trying to figure out if the supplied address is valid. */

	/* Begin with the coarse pattern to simply break up user@domain into different pieces that are easy to analyze. */

	var matchArray=emailStr.match(emailPat);

	if (matchArray==null) {

	/* Too many/few @'s or something; basically, this address doesn't even fit the general mould of a valid e-mail address. */

	alert(msgEmailFormat)
	obj.focus();
	obj.select();
	return false;
	}
	var user=matchArray[1];
	var domain=matchArray[2];

	// Start by checking that only basic ASCII characters are in the strings (0-127).

	// Checking Username part of an email
	for (i=0; i<user.length; i++) {
  	 if ((user.charCodeAt(i)>=64 && user.charCodeAt(i)<=90) || (user.charCodeAt(i)>=97 && user.charCodeAt(i)<=122) || (user.charCodeAt(i)==46) || (user.charCodeAt(i)==95) || (user.charCodeAt(i)>=48 && user.charCodeAt(i)<=57) || (user.charCodeAt(i)==45))
	 {}
	 else
	 {

		alert(msgEmailFormat)
		obj.focus();
		obj.select();
		return false;
     }
	}

	// Checking Domain part of an email
	
	for (i=0; i<domain.length; i++) {
  	 if ((domain.charCodeAt(i)>=64 && domain.charCodeAt(i)<=90) || (domain.charCodeAt(i)>=97 && domain.charCodeAt(i)<=122) || (domain.charCodeAt(i)==46) || (domain.charCodeAt(i)==95) || (domain.charCodeAt(i)>=48 && domain.charCodeAt(i)<=57) || (domain.charCodeAt(i)==45))
	 {}
	 else
	 {
		alert(msgEmailFormat)
		obj.focus();
		obj.select();
		return false;
     }
	}

	// See if "user" is valid 

	if (user.match(userPat)==null) {

	// user is not valid

	alert(msgEmailFormat)	
	obj.focus();
	obj.select();
	return false;
	}

	/* if the e-mail address is at an IP address (as opposed to a symbolic
	host name) make sure the IP address is valid. */

	var IPArray=domain.match(ipDomainPat);

	if (IPArray!=null)
	{

		// this is an IP address

		for (var i=1;i<=4;i++)
		{
			if (IPArray[i]>255) 
			{
				alert(msgEmailFormat)
				obj.focus();
				obj.select();
				return false;
			}
		}
		return true;
	}

	// Domain is symbolic name.  Check if it's valid.
	 
	var atomPat=new RegExp("^" + atom + "$");
	var domArr=domain.split(".");
	var len=domArr.length;
	for (i=0;i<len;i++) {
	if (domArr[i].search(atomPat)==-1) {
	alert(msgEmailFormat)
	obj.focus();
	obj.select();
	return false;
	   }
	}

	/* domain name seems valid, but now make sure that it ends in a known top-level domain (like com, edu, gov) or a two-letter word,
	representing country (uk, nl), and that there's a hostname preceding the domain or country. */

	if (checkTLD && domArr[domArr.length-1].length!=2 && 
	(domArr[domArr.length-1].toLowerCase()).search(knownDomsPat)==-1) {//toLowserCase() for Accept Captial Letter

	alert(msgEmailFormat)
	obj.focus();
	obj.select();
	return false;
	}

	// Make sure there's a host name preceding the domain.

	if (len<2) {
	alert(msgEmailFormat)
	obj.focus();
	obj.select();
	return false;
	}

	// If we've gotten this far, everything's valid!
	return true;
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnChkExt
PURPOSE			-	If the phone field is null then clear and lock the extensiobn field
ARGUMENTS		-	PhoneField,ExtField
RETURN VALUE	-	Nil
-------------------------------------------------------------------------------------------------------------------------*/
function vfnChkExt(objPhone,objExt)
{
	if(objPhone.value!="")
		{
			objExt.disabled=false;
		}
	else
		{
			objExt.value="";
			objExt.disabled=true;
		}
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnClearRadio
PURPOSE			-	To clear the checked values in radio buttons
ARGUMENTS		-	Radio button object and number of buttons(optional)
RETURN VALUE	-	Nil
AUTHOR			-	Michael J MAR-23-2004
-------------------------------------------------------------------------------------------------------------------------*/
function vfnClearRadio(objRadio,iRadioLength)
{
	if(iRadioLength==null && objRadio.length==null)
		iRadioLength=1;	
	else if(iRadioLength==null)
		iRadioLength = objRadio.length;
		
	if (iRadioLength=="" || iRadioLength==0)
	{
	}
	else if (iRadioLength==1)
	{ 
		objRadio.checked=false;
	}
	else if (iRadioLength>1)
	{
	 	for (i=0;i<objRadio.length;i++)
		{
			objRadio[i].checked=false;
		}
	}
	
}


/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnClearFormFields
PURPOSE			-	To clear all form fields txtbox, textarea, select()1 item), checkbox, password,
ARGUMENTS		-	(FormObject(myform-default), objects not to clear...n obkects -- to be done in future)
RETURN VALUE	-	Nil
-------------------------------------------------------------------------------------------------------------------------*/
function vfnClearFormFields()
{
	var FieldObject
	//var form
	for(var i=0; i<document.forms[0].elements.length; i++)
	{
		FieldObject = document.forms[0].elements[i]
		
		if (FieldObject.type=="text" || FieldObject.type=="password" || FieldObject.type=="textarea")
		{
			FieldObject.value="";
		}
		else if (FieldObject.type=="select-one")
		{
			FieldObject.selectedIndex=0;
		}

	}
	
}


/*----------------------------------------------------------------------------------------------------------------------
Auth : vijay Amirthraj
FUNCTION NAME	-	vfnDateFormat
PURPOSE			-	automatical split the mm/dd/yyyy format 
ARGUMENTS		-	(FormObject(myform-default
RETURN VALUE	-	Nil
-------------------------------------------------------------------------------------------------------------------------*/

function vfnDateFormat(obj,GTToday)
{

if(vfnTrim(obj)=="") 
return
str=vfnTrim(obj)
str1=""
str2=""
var iDateRange=29

//FEB-21-2004 'Michael
if(GTToday==1) 
{
	iDateRange = new Date().getYear()
	iDateRange = iDateRange.toString()
	iDateRange = parseInt(iDateRange.substring(2,4),10)
}
//Over FEB-21-2004 'Michael

for(i=0;i<str.length;i++)
	if(str.charAt(i)!="/")
	{
		if(parseInt(str.charAt(i),10)<=9)
			str1=str1+str.charAt(i)
	}
	else
	{//vijay 30 dec 2k3
	if (i==1)
	str1="0"+str1
	if(i==3 || i==4 && str1.length!=4)			 
	
	str1=str1.substring(0,2)+"0"+str1.substring(2,str1.length)
	//over 30 dec 2k3
	}
if(str1!="")
str=str1
if (str1.length<6)
return false
/*if (parseInt(str.substring(0,2),10)>12 && parseInt(str.substring(2,4),10)<=12)
			str1=str.substring(2,4)+"/"+str.substring(0,2)+"/"
else*/
	str1=str.substring(0,2)+"/"+str.substring(2,4)+"/"
if((str.substring(4,str.length)).length<=2)
	{
	
	if(parseInt(str.substring(4,str.length), 10)<=iDateRange)
		str2="20"+str.substring(4,str.length)
	else 
		str2="19"+str.substring(4,str.length)
	}
if (str2=="")
str2=str.substring(4,str.length)
str=str1+str2
obj.value=str
str=""
}

// New Email function FROM HPS SITE
// ******************* E-Mail *****************
function fnEmailFormat(objEMail)
{
	var EMailValue = objEMail.value;
	var a = "@";
	var b = ".";
	var a2 = 0;

    //----------------------------------------------------------------------------------------
    //   The '@' symbol should not be repeated more than once.
    //----------------------------------------------------------------------------------------
	var a1 = EMailValue.indexOf('@');
	var s2 = EMailValue.substring(a1+1, EMailValue.length);
	
	var a2 = s2.indexOf('@');

	if(a2!=-1)
	{
		window.alert(sEMailMessage + "'@' should not occur more than once.")
		objEMail.focus();
		return;
	}
    //----------------------------------------------------------------------------------------
    //   The '.' symbol should not be repeated more than once simultaneously.
    //----------------------------------------------------------------------------------------
	//var b1 = EMailValue.indexOf('.');
	//var s3 = EMailValue.substring(b1+1, EMailValue.length);

	//b2 = s3.indexOf('.');
  
	//if(b2!=-1)
	//{
	//	window.alert(sEMailMessage + "'.' should not occur more than once.")
	//	objEMail.focus();
	//	return;
	//}

	if(EMailValue!="")
	{
		var s2 = EMailValue.charAt(0);
		var dx = EMailValue.indexOf('@');
		var dx2 = EMailValue.indexOf('.');
		var t = EMailValue.substring(dx2+1,EMailValue.length)
        
	var s3="";   //FOR SPACE CHECKING
	var t1=0;
	var tem="";
	for(var i=0;i<EMailValue.length;i++)
	{
	s3=EMailValue.charAt(i);
	if(s3==" ")
	t1++;
	}
	
	if(!(((s2>='a')&&(s2<='z'))||((s2>='A')&&(s2<='Z'))))
	{
	alert("Invalid E-mail address.");
	objEMail.focus();
	return false
	}
	else if((dx<3)||(dx2<7))
	{
	alert("Invalid E-mail address.");
	objEMail.focus();
	return false
	}
	else if(t.length<2)
	{
	alert("Invalid E-mail address.");
	objEMail.focus();
	return false
	}
	else if(t1>0)
	{
	alert("Invalid E-mail address.");
	objEMail.focus();
	return false
	}
        
	else if(!((objEMail.value.indexOf("'")==-1) && (objEMail.value.indexOf('"')==-1 )))
	{
	alert("Cannot accept single or double quotes")
	objEMail.focus()
	return false
	}
   }
	else
	
	return true


 }

//Function Used for Text Area
function fnCheckMaxChars(taObject,sMaxChar)
{
	//to check for 255 characters as default
	
   if (sMaxChar==null)
    sMaxChar=225
    
   if (taObject.value.length>=sMaxChar)
    {         
      alert("Further entry is not allowed")
      taObject.focus()
      return false;
     }
}

//Function Used for Text Area
function fnRemoveExcessChars(taObject,sMaxChar) //Use Replace at ASP for single quote
{
	if (sMaxChar==null)
    sMaxChar=225
    
    taObj=vfnTrim(taObject)
    taObject.value=taObj.substring(0,sMaxChar)
}


//function used for Exten Area
function fnExtenCheck(obj)
{
obj.value=vfnTrim(obj)
if (obj.value=="")
return true
value=parseInt(obj.value,10)
if(value==0)
{
alert(msgZero)
obj.focus()
obj.select()
return false
}
}



//date compare
function vfnDateCompareNew(obj,obj1,Msg1,Msg2)
{
Date1=new Date(obj.value)
Date2=new Date(obj1.value)
if (Date1>Date2)
{
alert(Msg1+" should be greater than or equal to "+Msg2)
obj1.focus();
return false
}
}

function vfnCheckPageSize(obj)
{
var sPageSize = obj.value
	if(vfnIsNumber(obj)==true)
	{
		if(parseInt(sPageSize,10) >1000 || parseInt(sPageSize,10) < 1)
		{
			alert("Enter a number between 1 and 1000")
			obj.focus()
			obj.select()
		} 
	
	}

}



//****** To Check the USer Name ***

function fnIsValidUserName(r_varCtrl,sMsg)
{

	var Field
	r_varCtrl.value=r_varCtrl.value
	Field = r_varCtrl
	//Field.value = vfnTrim(Field);
    var length = Field.value.length;
   		
    for (var ct = 0; ct <= (Field.value.length - 1); ct++)
    {
		var Validchar = Field.value.substring(ct,ct+1);  // Check one Character at a
							    // time
		var character = 0;  // Set character as invalid alphanumeric value
		
		if (((Validchar >= "A") && (Validchar <= "Z")) || ((Validchar >= "a") && (Validchar <= "z")) || ((Validchar >= "0") && (Validchar <= "9")) || (Validchar == "-") || (Validchar == "_"))
		{
		
       		character = 1; //valid character
	  	}
		else
		{
		
			character = 0; //Invalid character
			if (sMsg.length>0 )
			alert("Valid characters : [A-Z],[a-z],[0-9],underscore,hyphen");
			r_varCtrl.focus();
			r_varCtrl.select();
			return false;
		}
	     
	}
	
	if(Field.value!="" && Field.value.length<6 && (sMsg.length>0 ))
	{
		alert(sMsg + " must have a minimum of 6 characters.")
		r_varCtrl.focus();
		r_varCtrl.select();
		return false
	}
		
	return true; //If valid character
}


function vfnFocusSelect(obj)
{
	
	if (obj.type=="text" || obj.type=="password" || obj.type=="textarea" ||obj.type=="file")
	{
		obj.focus()
		obj.select()
		
	}
	else 
	{
		obj.focus()		
	}
}


function fnDateFormat(sDate)
{
if(vfnTrim(sDate)=="") 
return
str=vfnTrim(sDate)
str1=""
str2=""
var iDateRange=29

for(i=0;i<str.length;i++)
	if(str.charAt(i)!="/")
	{
		if(parseInt(str.charAt(i),10)<=9)
			str1=str1+str.charAt(i)
	}
	else
	{
	if (i==1)
	str1="0"+str1
	if(i==3 || i==4 && str1.length!=4)			 
	
	str1=str1.substring(0,2)+"0"+str1.substring(2,str1.length)
	}
if(str1!="")
str=str1
if (str1.length<6)
return false

/*if (parseInt(str.substring(0,2),10)>12 && parseInt(str.substring(2,4),10)<=12)
	str1=str.substring(2,4)+"/"+str.substring(0,2)+"/"
else*/
	str1=str.substring(0,2)+"/"+str.substring(2,4)+"/"

if((str.substring(4,str.length)).length<=2)
	{
	if(parseInt(str.substring(4,str.length), 10)<=iDateRange)
		str2="20"+str.substring(4,str.length)
	else 
		str2="19"+str.substring(4,str.length)
	}
if (str2=="")
str2=str.substring(4,str.length)
str=str1+str2
sDate=str
str=""
return sDate
}



/*---------------------------------------------------------------------------------------------------------------------
UDF: 04/May/2004	-	S.Dinesh
FUNCTION NAME		-	openCenterWindow
PURPOSE				-   Open the new Window & place it on the center of the window
RETURN VALUE		-   Nil
---------------------------------------------------------------------------------------------------------------------*/

function openCenterWindow(filenameurl,widowname,widowwidth,windowheight)
{
	var wwidth=window.screen.availWidth
	var wheight=window.screen.availHeight
	wwidth=(wwidth-widowwidth)/2 //left
	wheight=(wheight-windowheight)/2 //height
	var url = filenameurl
	var newwindowname=widowname
	var features="toolbar=0,location=0,directories=0,status=0,menubar=0,scrollbars=0,resizable=0"+",width="+widowwidth+",height="+windowheight+",left="+wwidth+",top="+wheight
	var sealWin = window.open(url,newwindowname,features)
	sealWin.focus()
}


function vfnDisableFormFields()
{
	for(var i=0; i<document.forms[0].elements.length; i++)
	{
		document.forms[0].elements[i].disabled=true;

	}
	
	//Enable disired fields
	for(var i=0; i<arguments.length; i++)
	{
		arguments[i].disabled=false;
	}
}

function vfnComparePassword(obj1,obj2,sMsg)
{
	if (obj1.value!=obj2.value  )
		{
			alert(sMsg);
			obj2.focus();
			return false
		}
	return true;
}

/*--------TO FORMAT DATE-------------------------------------------------------------------------------------------------
	FUNCTIONS USED IN FORMATTING THE DATE ARE 
	
	1)vfnDateCheck
	3)getDays
	4)vfnLeapYear
*/

function vfnDateCheck(obj,GTToday1,sMsg1,sTitle)
{
// Purpose: To format the value to the format MM/DD/YYYY if the values is a valid date.

	var iMonth,iDay,iYear
	
	if(vfnDateFormat(obj,GTToday1)==false)
	{
				
				alert(msgDateFormat)
				obj.focus();
				obj.select();  //vijay 24-Dec-2003
				return false;
	 }
	 
	obj.value=vfnTrim(obj);
	if(obj.value=="") return true;
	var sOriginalValue = obj.value
	var sDate = vfnReplace(obj.value,"/")	
	obj.value = sDate;
	
	if(vfnIsNumber(obj,0) && sDate.length==8)
	{
		iMonth=sDate.substring(0,2);
		iDay=sDate.substring(2,4);
		iYear=sDate.substring(4,8);
	
		if((iMonth>=1 && iMonth<=12) && (iDay>=1 && iDay<=vfnGetDays(iMonth-1,iYear)) )
		{	
			obj.value = sDate.substring(0,2) + "/" + sDate.substring(2,4) + "/" + sDate.substring(4,8);
			if(GTToday1==1 && new Date(obj.value)>new Date())
			{
				alert(msgDateExceeds)
				obj.focus();
				obj.select();
				return false;
			}
			
			if (parseInt(iYear)<(new Date().getFullYear()-150)){
			alert("Not a valid year")
			obj.focus();
			obj.select();
			return false;
			}

			return true;
		}
		else // siddiq
		{	obj.value = sDate.substring(0,2) + "/" + sDate.substring(2,4) + "/" + sDate.substring(4,8);
		
			if(iMonth<1 )
				{
					alert(msgNotValidMonth)
					obj.value=sOriginalValue
					obj.focus();
					obj.select();  // siddiq
					return false;
				}
			else if(iMonth>12 )
				{
					alert(msgNotValidMonth)
					obj.value=sOriginalValue
					obj.focus();
					obj.select();  // siddiq
					return false;
				}
			else if(iDay>vfnGetDays(iMonth-1,iYear)) 
				{
					alert(msgNotValidDay)
					obj.value=sOriginalValue
					obj.focus();
					obj.select();  // siddiq
					return false;
				}
			else if(iDay<1) 
				{
					alert(msgNotValidDay)
					obj.value=sOriginalValue
					obj.focus();
					obj.select();  // siddiq
					return false;
				}
		}
	}
	else
	{
		alert(msgDateFormat)
		obj.value=sOriginalValue
		obj.focus();
		obj.select();
		return false;
	}
}




 
function fnShowCrystalReport(fname,qs1,qs2,q3,q4)
{ 	
	var fn
	fn=fname + "?qUser=" + qs1 + "&qRptType=" + qs2 + "&PID=" + q3 + "&PN=" + q4
	 
//	window.open(fn,'Report','')
	window.open(fn,'Report','directories=0,status=0,menubar=0,scrollbars=1,resizable=1')
}/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	vfnIsName
PURPOSE			-	To allow [a-z], [A-Z],[-(),.],space and restricting other characters
ARGUMENTS		-	Form object
RETURN VALUE	-	If valid returns true else displays alert
-------------------------------------------------------------------------------------------------------------------------*/
function vfnIsName(obj)          
{

	var Field
	obj.value=vfnTrim(obj)
	Field = obj
    var length = Field.value.length;
   
    for (var ct = 0; ct <= (Field.value.length - 1); ct++)
    {
		var Validchar = Field.value.substring(ct,ct+1);  // Check one Character at a time
		var character = 0;								 // Set character as invalid alphanumeric value
		if(!(  (Validchar == " ") || (Validchar == ",") || (Validchar == "-") ||(Validchar == ".")  || (Validchar == "(") || (Validchar == ")") || ((Validchar >= "A") && (Validchar <= "Z")) || ((Validchar >= "a") && (Validchar <= "z"))))
		{
			alert("Valid characters : [A-Z],[a-z],comma,dot,(,),-,space ");
			obj.focus();
			obj.select();
			return false;		
		}
	 }
	return true; //If valid character
}
function fnInitcaps(OBJ)
			{	str= new String(OBJ.value)
			    
				str=str.replace(str.substr(0,1),str.charAt(0).toUpperCase())
				OBJ.value=str
			}
function vfnPopuluateSubID(objCode,obj,sMsg)
{

	if(objCode.value!="")
	{
		var parser=new ActiveXObject("microsoft.xmldom")
		parser.async="false"
		var site="XMLCodeCheck.asp?Code=" + escape(objCode.value) + "&Mode=" + sMsg
		alert (site)
		parser.load(site)

		
		nodes = parser.documentElement.childNodes
		
		
		if (nodes.item(0).text=="NA")
		{
		
		var sItem = nodes.item(0).text
		var arListItem = sItem.split(String.fromCharCode(30))
		
			/*alert(sMsg+" ID is not available in the list.")
			obj.value=""
			objCode.focus()
			objCode.select();*/
		}
		else
		{
			obj1.value=nodes.item(0).text
			
		}
	}
}
//Function for Restricting Refresh
/*----------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	fnsetRefresh
PURPOSE			-	for Restricting Refresh	
ARGUMENTS		-	Boolean
Author			- 	siddiq
-------------------------------------------------------------------------------------------------------------------------*/
function fnsetRefresh(sValue)
	{	 
		 document.cookie = "PRefreshCheck=" + escape(sValue); 
	}
	
/*---------------------------------------------------------------------------------------------------------------------
UDF:
FUNCTION NAME	-	fnEnc
PURPOSE			-   To Encrypt the Querystring from Client-side scripting
ARGUMENTS		-	Value to Encrypt
RETURN VALUE	-   If valid returns Encrypted Value, else returns an empty value.
---------------------------------------------------------------------------------------------------------------------*/
function fnEnc(Val)
{

	var nodes
	var sURL
	if(Val != "")
	{
	
	sURL="XMLCode4Encryption.asp?msg=" + escape(Val)
	nodes=vfnXMLHttpRequest(sURL,"N")
	if (vfnGetNodeValue(nodes, 0)=="NA")
			return "";
	else
		return vfnGetNodeValue(nodes, 0)
	}
}
/*function fnEnc(Val)
{
	if(Val != "")
	{
	
		var parser = new ActiveXObject("microsoft.xmldom")
		parser.async = "false"
	
		//location.href="XMLCode4Encryption.asp?msg=" + escape(Val)
		//return	

		parser.load("XMLCode4Encryption.asp?msg=" + escape(Val))
		
		nodes = parser.documentElement.childNodes
		
		if (nodes.item(0).text=="NA")
			return "";
		else
			return (nodes.item(0).text);
	}
}
*/
function vfnXMLHttpRequest(sURL,sType)
{
	var parser
	var nodes=null
	if (window.XMLHttpRequest) //Netcape
	{
		xmlhttp=new XMLHttpRequest()
		xmlhttp.open("GET",sURL,false)
		xmlhttp.send(null)
	}
	else if(window.ActiveXObject) //IE only
	{
		xmlhttp=new ActiveXObject("Microsoft.XMLHTTP")
		if (xmlhttp)
		{
			xmlhttp.open("GET",sURL,false)
			xmlhttp.send()
		}
	}
	
	if (xmlhttp.readyState==4)
	{
		
			var xmlstring=xmlhttp.responseText
			 
			if (xmlhttp.status!=200)
			{
				alert(sMsgXMLErr)
				xmlstring="<answer>NA</answer>"
			}
			
			if (window.XMLHttpRequest)
			{
				var domparser = new DOMParser();
				parser = domparser.parseFromString(xmlstring, "text/xml");
				nodes=parser.documentElement.childNodes
			}
			else
			{
				var parser=new ActiveXObject("microsoft.xmldom")
				parser.async="false"				
				parser.loadXML(xmlstring)			
				nodes = parser.documentElement.childNodes
				
			}			

		if(sType=="P")
			return parser
		else
			return nodes
		
	}
}

function vfnGetNodeValue(nodes, iPos)
{
	if(nodes.item(iPos).firstChild)
		return nodes.item(iPos).firstChild.nodeValue;
	else
		return "";
}

// To get the max length of TextArea
function checkchars(obj,maxlength,msg)
{
//change max length to determine below
//var maxlength=950
var nValue = vfnTrimValue(obj.value);

if (nValue.length>maxlength)
    {
        alert(msg + " : The Length of Entered text is " + nValue.length + ". It must be " + maxlength + " characters or less!")
        obj.select();
        return false
    }
else
    {
        return true;
    }
}

// To trim the string
function vfnTrimValue(sValue)
{
 	var Field
    Field = sValue
	var y=sValue.length;
    var retval=sValue;
    var m=0;
	
    while(m < y) //Start removing white spaces from left side
	{  
      	if ((retval.substring(0,1)==" ")||(retval.substring(0,1)=="     ") ||(retval.substring(0,1)=="\n"))
		{ 
          	retval=Field.substring(m+1,y); //remove left most white char
        } 
        else 
        { 
          	break;
        }
        m++;
    }
				
    y=retval.length;
    m=y;
    
    	
	
      while (m >= 0) //Start removing white spaces from right side
		{  
        	if ((retval.substring(m-1,m)==" ")||(retval.substring(m-1,m)==" ") ||(retval.substring(m-1,m)=="\n") )
          	{  
            	retval=retval.substring(0,m-1); //remove right most white char
            } 
          else 
            { 
              break;  //first non - white character encountered while 
                      //traversing from right to left. so break the loop
            }
          m--;
        }
        
      return retval;
}


function vfnInterchangeDateCheck(obj,GTToday1,sMsg1,sTitle)
{
// Purpose: To format the value to the format MM/DD/YYYY if the values is a valid date.

	var iMonth,iDay,iYear
			
	obj.value = vfnTrim(obj);
	if(obj.value=="") return true;
	var sOriginalValue = obj.value
	var sDate =obj.value
	obj.value = sDate;

	if(vfnIsNumber(obj,0) && sDate.length==6 && (sDate.substring(2,4) != "00" || sDate.substring(4,6) != "00" || sDate.substring(0,2) != "00"))
	{	
		iMonth= sDate.substring(2,4);
		iDay = sDate.substring(4,6);
		iYear = sDate.substring(0,2);
		iYear = "20" + iYear
		
		if((iMonth >= 1 && iMonth <= 12) && (iDay>=1 && iDay <= vfnGetDays(iMonth-1,iYear)) )
		{	
			obj.value = sDate.substring(0,2) + sDate.substring(2,4) + sDate.substring(4,6);
			if(GTToday1==1 && new Date(obj.value)>new Date())
			{	
				alert(msgDateExceeds)
				obj.focus();
				obj.select();
				return false;
			}

			if (sDate.substring(0,2) == "00")
			{
				alert("Not a valid year")
				obj.focus();
				obj.select();
				return false;
			}			
			else if (iYear > (new Date().getFullYear()))
			{
			alert("Not a valid year")
			obj.focus();
			obj.select();
			return false;
			}

			return true;
		}
		else // prabahar
		{
			a = new Date();
			cDate = a.getDate();
			cMonth = a.getMonth();
			cYear = a.getFullYear();
			
			iYear = "20" + sDate.substring(0,2)
			if(cYear < iYear)
			{
				alert("Not a valid year")
				obj.value = sOriginalValue
				obj.focus();
				obj.select();  // prabahar
				return false;			
			
			}
			else if(cMonth < sDate.substring(2,4)) 
			{
				alert(msgNotValidMonth)
				obj.value = sOriginalValue
				obj.focus();
				obj.select();  // prabahar
				return false;			
			
			}						
			else if(cDate < sDate.substring(4,6)) 
			{
				alert(msgNotValidDay)
				obj.value = sOriginalValue
				obj.focus();
				obj.select();  // prabahar
				return false;
			}
		}
	}
	else if (sDate.substring(2,4) == "00" || sDate.substring(4,6) == "00" || sDate.substring(0,2) == "00")
	{
		alert(msgInterDateFormat)
		obj.value=sOriginalValue
		obj.focus();
		obj.select();
		return false;
	}
}