function ForbiddenCahrs(evt)
{
	return CheckValidation(evt , "'[]" , false , ".התו שהוקלד אינו חוקי")
}
//-----------------------------------------------------------------------
//This function gets str and check if any the pressed key is un the str
function CheckValidation(evt , str , Allow, ErrorMsg)
{
	var strlen , i=0 , charCode , NotFound = 1 , tempChar
	
	strlen = str.length
	
	 //check type of user browser  Netscape Or IE	
	if (navigator.appName == "Netscape")
		//gets key that was pressed
		charCode = evt.which 
	else 
		charCode = evt.keyCode;
		
	while (i < strlen && NotFound)
	{ 
		if (charCode == str.charCodeAt(i))
		{
			tempChar = str.charAt(i)
			NotFound = 0 //Found
		}
		i = i + 1
	}
	if (Allow == 0)
	{
		if (NotFound == 1)
			return true;
		else
		{
			alert (ErrorMsg)	
			return false; 
		}
	}
	else
	{
		if (NotFound == 1)
		{
			alert (ErrorMsg)	
			return false;
		}
		else
			return true; 
	}
}
//-----------------------------------------------------------------------



function AllowNumbersOnly(evt , fieldname) 
{
 
	 var charCode;
	 //check type of user browser  Netscape Or IE	
	if (navigator.appName == "Netscape")
	 //gets key that was pressed
		charCode = evt.which 
	else 
		charCode = evt.keyCode;
	
	if (( charCode<48 || charCode > 57) && (charCode != 46) )
	{
		alert('Please insert only numbers into ' + fieldname + ' !');
		return false;
	}
	else
	   return true;

}
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------------------

function IsNumericStr(InStr)
{
	var retVal = true;
	
		if (InStr.charAt(0) != '0' &&
			InStr.charAt(0) != '1' &&
			InStr.charAt(0) != '2' &&
			InStr.charAt(0) != '3' &&
			InStr.charAt(0) != '4' &&
			InStr.charAt(0) != '5' &&
			InStr.charAt(0) != '6' &&
			InStr.charAt(0) != '7' &&
			InStr.charAt(0) != '8' &&
			InStr.charAt(0) != '9' ) 
			retVal = false;

	for (i=0; i < InStr.length; i++)
	{
		if (InStr.charAt(i) != '0' &&
			InStr.charAt(i) != '1' &&
			InStr.charAt(i) != '2' &&
			InStr.charAt(i) != '3' &&
			InStr.charAt(i) != '4' &&
			InStr.charAt(i) != '5' &&
			InStr.charAt(i) != '6' &&
			InStr.charAt(i) != '7' &&
			InStr.charAt(i) != '8' &&
			InStr.charAt(i) != '9')
		{	
			retVal = false;
			alert (InStr.charAt(i))		
		}
	}
	return retVal;
}

function isEmpty(s)
{
	return ((s == null) || (s.length == 0) || (IsBlankStr(s)));
}
//--------------------------------------------------------------------------------------------
function IsBlankStr(InStr)
{
	var retVal = true;
	for (i=0; i < InStr.length; i++)
	{
		if (InStr.charAt(i) != ' ')
		{
			retVal = false;
		}
	}
	return retVal;
}

//-----------------------------------------------------------------------------------
//general purpose functions
var digits = "0123456789";
var whitespace = " \t\n\r";
var decimalPointDelimiter = "."
var defaultEmptyOK = false;
var g_parsed_month,g_parsed_day,g_parsed_year;

function makeArray(n) {
   for (var i = 1; i <= n; i++) {
      this[i] = 0
   } 
   return this;
}

var daysInMonth = makeArray(12);
daysInMonth[1] = 31;
daysInMonth[2] = 29;   // must programmatically check this
daysInMonth[3] = 31;
daysInMonth[4] = 30;
daysInMonth[5] = 31;
daysInMonth[6] = 30;
daysInMonth[7] = 31;
daysInMonth[8] = 31;
daysInMonth[9] = 30;
daysInMonth[10] = 31;
daysInMonth[11] = 30;
daysInMonth[12] = 31;

//------------------------------------------------------------------------------------
function check_password(str)
{
if (str.length < 6) return false;

//inStr = str.value;
var ab;
var num;
ab = 0;
num = 0;
inStr = str
inLen = str.length;
for(var i=0; i<inLen; i++) {
     var ch = inStr.substring(i,i+1)
     if ((!(ch < "a") && (!("z" < ch))) || (!(ch < "A") && (!("Z" < ch)))) ab++;
     else if ((!(ch < "0")) && (!(ch > "9"))) num++;
}
if (((ab + num) < 6 ) || (num == 0) || (ab == 0)) return false;
return true;

}
//-------------------------------------------------------------------------------------
function GetElementIdxByName( ThisForm, ElementName)
{
	for (var idx=0; idx < ThisForm.elements.length; idx++)
	{
		if (ThisForm.elements[idx].name == ElementName)
			return idx;
	}
	return -1;
} 
//-------------------------------------------------------------------------------------------
function IsPhoneNumberStr(InStr)
{
	var retVal = true;
	
	for (i=0; i < InStr.length; i++)
	{
		if (InStr.charAt(i) != '-' &&
			InStr.charAt(i) != '.' &&
			InStr.charAt(i) != '(' &&
			InStr.charAt(i) != ')' &&
			InStr.charAt(i) != '/' &&
			InStr.charAt(i) != '*' &&
			InStr.charAt(i) != '#' &&
			InStr.charAt(i) != '0' &&
			InStr.charAt(i) != '1' &&
			InStr.charAt(i) != '2' &&
			InStr.charAt(i) != '3' &&
			InStr.charAt(i) != '4' &&
			InStr.charAt(i) != '5' &&
			InStr.charAt(i) != '6' &&
			InStr.charAt(i) != '7' &&
			InStr.charAt(i) != '8' &&
			InStr.charAt(i) != '9' &&
			InStr.charAt(i) != ' ')

		{
			retVal = false;
		}
	}
	return retVal;
}


function ParseDateStr(DateStr)
{
	//This function assumes the dates are strings in the format mm/dd/yy
	  //if year is 4 digits the format is mm/dd/yyyy 
	  //it also assumes no less then 1950 and no more then 2050 is allowed
	if (DateStr.length == 8)
		g_parsed_year	= DateStr.substring(6,8);
	else
	g_parsed_year	= DateStr.substring(8,10);
	
	g_parsed_month	= DateStr.substring(0,2);
	g_parsed_day	= DateStr.substring(3,5);

	//if (g_parsed_year < "50")
	//	g_parsed_year = "1" + g_parsed_year;
//	else
//		g_parsed_year = "0" + g_parsed_year;
}
//-------------------------------------------------------------------------------------------
function GetCorrectYear (Year)
{
	if ( Year > 1900 )
		return Year; // Year is regular 1999 2000 2001 ...
		
	if ( (Year > 90) && (Year < 100) )
		return Year + 1900; // We have 91,92,...,99 so we get 1991, 1992,..,1999
	
	return Year + 2000; // We have 01,02,..,90 so we get 2001, 2002,..., 2090
}
//-------------------------------------------------------------------------------------------
function CompareDates (DateStr1, DateStr2)
{
	// if the first date is bigger it returns 1
	// if they are the same it returns 0
	// if the first is smaller it returns -1
	
	var Date1 = DateStr1.split("/");
	var Date2 = DateStr2.split("/");	
	
	var Month1		= parseInt(Date1[0], 10);
	var Day1		= parseInt(Date1[1], 10);
	var Year1		= GetCorrectYear (parseInt(Date1[2], 10));
	
	var Month2		= parseInt(Date2[0], 10);
	var Day2		= parseInt(Date2[1], 10);
	var Year2		= GetCorrectYear (parseInt(Date2[2], 10));
			
	if ( (Year1 > Year2) ||
		 ((Year1 == Year2) && (Month1 > Month2)) ||
		 ((Year1 == Year2) && (Month1 == Month2) && (Day1 > Day2)) )
		return 1;
		
	if ( (Year1 < Year2) ||
		 ((Year1 == Year2) && (Month1 < Month2)) ||
		 ((Year1 == Year2) && (Month1 == Month2) && (Day1 < Day2)) )
		return -1;
		
	return 0;	
}
//-----------------------------------------------------------------------------------
function CompareParsedDates(Years1,Month1,Day1,Years2,Month2,Day2)
{
	// if the first date is bigger it returns 1
	  // if they are the same it returns 0
	  // if the first is smaller it returns -1
	var retVal = 0;
	if (Years1 > Years2)
		retVal = 1;
	else if (Years1 < Years2)
		retVal = -1;
	else if (Month1 > Month2)
		retVal = 1;
	else if (Month1 < Month2)
		retVal = -1;
	else if (Day1 > Day2)
		retVal = 1;
	else if (Day1 < Day2)
		retVal = -1;
	else
		retVal = 0;
	return retVal;
}
//-----------------------------------------------------------------------------------
function isDateStr(inStr)
{
	if (isEmpty(inStr)) 
		return defaultEmptyOK;

	var YearsEndIdx  = 0;  

	if (inStr.length != 8 && inStr.length != 10)
		return defaultEmptyOK;
	if (inStr.length == 8)
		var Years	= inStr.substring(6,8);
	else
	{
		var Years	= inStr.substring(8,10);
		inStr		= inStr.substring(0,6);
		inStr		= inStr + Years;
	}
	var Month	= inStr.substring(0,2);
	var Day		= inStr.substring(3,5);
	
	if (Years < "50")
		Years = "20" + Years;
	else
		Years = "19" + Years;

	return isDate(Years,Month,Day);
}
//-----------------------------------------------------------------------------------
function CompareDateWithToday(inDateStr)
{
	// return 0 if the same , >0 if future, <0 if past
	var now		= new Date();
	var nYears	= now.getYear();
	var nMonth	= now.getMonth()+1;
	var nDay	= now.getDate();

	var inYears	= 0;
	var inMonth	= 0;
	var inDay	= 0;

	ParseDateStr(inDateStr);
	inYears	= g_parsed_year;
	inMonth	= g_parsed_month;
	inDay	= g_parsed_day;

	var retVal = CompareParsedDates(inYears,inMonth,inDay,nYears,nMonth,nDay);
	return retVal;
}
//--------------------------------------------------------------------------------------------
function isDigit(c)
{   
	return ((c >= "0") && (c <= "9"));
}
//--------------------------------------------------------------------------------------------
function isInteger (s)

{   
	var i;
    if (isEmpty(s)) 
       if (isInteger.arguments.length == 1) 
		return defaultEmptyOK;
       else 
		return (isInteger.arguments[1] == true);
    //Search through string's characters one by one
      //until we find a non-numeric character.
      //When we do, return false; if we don't, return true.

    for (i = 0; i < s.length; i++)
    {   
        // Check that current character is number.
        var c = s.charAt(i);

        if (!isDigit(c)) return false;
    }

    // All characters are numbers.
    return true;
}
//--------------------------------------------------------------------------------------------
function isSignedInteger (s)

{   if (isEmpty(s)) 
       if (isSignedInteger.arguments.length == 1) 
		return defaultEmptyOK;
       else 
		return (isSignedInteger.arguments[1] == true);

    else {
        var startPos = 0;
        var secondArg = defaultEmptyOK;

        if (isSignedInteger.arguments.length > 1)
            secondArg = isSignedInteger.arguments[1];

        // skip leading + or -
        if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") )
           startPos = 1;    
        return (isInteger(s.substring(startPos, s.length), secondArg));
    }
}
//--------------------------------------------------------------------------------------
function isMoney (s)
{   
	var i;
	var seenDecimalPoint = false;
	var seenNonZeroDigit = false;
	var seenComma		 = false;
	var decimalPointIndex = 0;

    if (isEmpty(s)) 
      if (isMoney.arguments.length == 1) return defaultEmptyOK;
      else return (isMoney.arguments[1] == true);

    if (s == decimalPointDelimiter) return false;

    // Search through string's characters one by one
      //until we find a non-numeric character, non decimal point and non comma character.
      // When we do, return false; if we don't, continue checking.
    for (i = 0; i < s.length; i++)
    {   
      // Check that current character
        var c = s.charAt(i);

		if (c == "," && seenDecimalPoint)
			return false;
		else
		if (c == ",")
			seenComma = true;
		else
        if ((c == decimalPointDelimiter) && !seenDecimalPoint) 
		{
			seenDecimalPoint = true;
			decimalPointIndex = i;
		}
        else if (!isDigit(c)){
			return false;
		}
		else if (c != "0")
			seenNonZeroDigit = true;
	}

	if ((isMoney.arguments[1] == true) && // isn't obligatory
		(!seenNonZeroDigit)){			  // all digits are Zero
		return true;
	}

   // All characters are numbers or a decimal point or commas.
	if ((seenDecimalPoint && decimalPointIndex < s.length - 3) || !seenNonZeroDigit)
		return false; // more the 2 digits after dec point or all digits are Zero
	else if (!seenComma)
		return true; 
	else // Seen Comma
	{
		// Commas has to be every 3 digits from right to left 
		var len=0;
		if (seenDecimalPoint)
			len = decimalPointIndex;
		else
			len = s.length;

		for (var i = len - 3; i > 1 ; i-=4)
		{
			if (s.charAt(i-1) != ",")
				return false;
		}
		return true;
	}
}
//--------------------------------------------------------------------------------------
function isSignedMoney(s)

{   if (isEmpty(s)) 
       if (isSignedMoney.arguments.length == 1) return defaultEmptyOK;
       else return (isSignedMoney.arguments[1] == true);

    else {
        var startPos = 0;
        var secondArg = defaultEmptyOK;

        if (isSignedMoney.arguments.length > 1)
            secondArg = isSignedMoney.arguments[1];

        // skip leading + or -
        if ( (s.charAt(0) == "-") || (s.charAt(0) == "+") )
           startPos = 1;    
        return (isMoney(s.substring(startPos, s.length), secondArg));
    }
}
//--------------------------------------------------------------------------------------
function isDate (year, month, day)
{   
	// catch invalid years (not 2- or 4-digit) and invalid months and days.
    if (!(isYear(year, false) && isMonth(month, false) && isDay(day, false))) 
		return false;

    // Explicitly change type to integer to make code work in both
    // JavaScript 1.1 and JavaScript 1.2.
    var intYear = parseFloat(year);
    var intMonth = parseFloat(month);
    var intDay = parseFloat(day);

    // catch invalid days, except for February
    if (intDay > daysInMonth[intMonth])
		return false; 

    if ((intMonth == 2) && (intDay > daysInFebruary(intYear)))
		return false;


    return true;
}
//--------------------------------------------------------------------------------------
function isMonth (s)
{   
	if (isEmpty(s)) 
       if (isMonth.arguments.length == 1) return defaultEmptyOK;
       else return (isMonth.arguments[1] == true);
    return isIntegerInRange (s, 1, 12);
}
//--------------------------------------------------------------------------------------
function isDay (s)
{   if (isEmpty(s)) 
       if (isDay.arguments.length == 1) return defaultEmptyOK;
       else return (isDay.arguments[1] == true);   
    return isIntegerInRange (s, 1, 31);
}
//--------------------------------------------------------------------------------------
function isYear (s)
{   if (isEmpty(s)) 
       if (isYear.arguments.length == 1) return defaultEmptyOK;
       else return (isYear.arguments[1] == true);
    if (!isNonnegativeInteger(s)) return false;
    return ((s.length == 2) || (s.length == 4));
}
//--------------------------------------------------------------------------------------
function isNonnegativeInteger (s)
{   var secondArg = defaultEmptyOK;

    if (isNonnegativeInteger.arguments.length > 1)
        secondArg = isNonnegativeInteger.arguments[1];

    // The next line is a bit byzantine.  What it means is:
		//a) s must be a signed integer, AND
		// b) one of the following must be true:
			//i)  s is empty and we are supposed to return true for
			//	empty strings
			//ii) this is a number >= 0
	
    return (isSignedInteger(s, secondArg)
         && ( (isEmpty(s) && secondArg)  || (parseFloat (s) >= 0) ) );
}
//--------------------------------------------------------------------------------------

// isIntegerInRange (STRING s, INTEGER a, INTEGER b [, BOOLEAN emptyOK])
//
// isIntegerInRange returns true if string s is an integer 
// within the range of integer arguments a and b, inclusive.

function isIntegerInRange (s, a, b)
{   if (isEmpty(s)) 
       if (isIntegerInRange.arguments.length == 1) return defaultEmptyOK;
       else return (isIntegerInRange.arguments[1] == true);

    
	// Catch non-integer strings to avoid creating a NaN below,
    // which isn't available on JavaScript 1.0 for Windows.
    if (!isInteger(s, false)) return false;

    
	// Now, explicitly change the type to integer via parseFloat
    // so that the comparison code below will work both on 
    // JavaScript 1.2 (which typechecks in equality comparisons)
    // and JavaScript 1.1 and before (which doesn't).
	
    var num = parseFloat (s);
    return ((num >= a) && (num <= b));
}
//--------------------------------------------------------------------------------------
function isPositiveInteger (s)
{   var secondArg = defaultEmptyOK;

    if (isPositiveInteger.arguments.length > 1)
        secondArg = isPositiveInteger.arguments[1];
    // The next line is a bit byzantine.  What it means is:
    // a) s must be a signed integer, AND
    // b) one of the following must be true:
    //    i)  s is empty and we are supposed to return true for
    //        empty strings
    //    ii) this is a positive, not negative, number
    return (isSignedInteger(s, secondArg)
         && ( (isEmpty(s) && secondArg)  || (parseFloat (s) > 0) ) );
}
//--------------------------------------------------------------------------------------
function daysInFebruary (year)
{
    return (  ((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0) ) ) ? 29 : 28 );
}
//------------------------------------------------------------------------------------------
function MakeDateString(checkStr)
{	
    var dateToCheck;
    dateToCheck=checkStr;

  if (checkStr.length == 8)
	dateToCheck = (checkStr.substring(6, 8));
  else if (checkStr.length == 10 && parseInt(checkStr.substring(6, 10)) >= 1950 && parseInt(checkStr.substring(6, 10)) <= 2049)
	dateToCheck = (checkStr.substring(8, 10));
  
  dateToCheck = dateToCheck + 
			checkStr.substring(3, 5) +
			checkStr.substring(0, 2);
	
  return (!isDateStr(dateToCheck))
}
//------------------------------------------------------------------------------------------
function FixDate(DateValue,txtBoxDate)
{	
	if (! isEmpty(DateValue)){
		var FirstIndexOfSlash = DateValue.indexOf("/");
		var Day = DateValue.substring(0,FirstIndexOfSlash);
		if (Day.length==1)
			Day = "0" + Day;
		if (!(isDay(Day)))
				return('000000');
		
		var NextIndexOfSlash = DateValue.indexOf("/",FirstIndexOfSlash+1);
		var Month = DateValue.substring(FirstIndexOfSlash+1, NextIndexOfSlash);
		if (Month.length==1)
			Month = "0" + Month;
		if (!(isMonth(Month)))
			return('000000');

		var Year = DateValue.substring(NextIndexOfSlash+1);
		if ((Year.length>=4) && ((Year.substring(0,2)==19) || (Year.substring(0,2)==20)) && Year>1950 && Year<2030 ){
			Year = Year.substring(2,4);
			return(Year + Month + Day);
			}
		if (Year.length==3){
			return('000000');
			}
		if ((Year.length==2) && ((Year.substring(0,2)>50) || (Year.substring(0,2)<30)) && (Year.substring(0,2)>=0)){
			Year = Year.substring(0,2);
			return(Year + Month + Day);
			}
		else{
			return('000000');
			}
	}
}
//------------------------------------------------------------------------------------------
function MakeFloatNumber(initValue,MaxLength)
{ 
	var tempNumber = parseFloat(initValue);
	if (initValue=='')
		return('0.00');
		
	if ((initValue.length > MaxLength - 3) || (isNaN(tempNumber)) || ((initValue.indexOf('.') < initValue.length - 3) && (initValue.indexOf('.')>0)))
		return(initValue);

	if ((initValue.indexOf('.') > 0) && (initValue.length <= (MaxLength - 3))){
		if (initValue.charAt(initValue.length - 3)=='.')
			return(initValue);
		if (initValue.charAt(initValue.length - 2)=='.')
			return(initValue + '0');
		if (initValue.charAt(initValue.length - 1)=='.')
			return(initValue + '00');
		}
	else
		return (initValue + '.00');
}
//------------------------------------------------------------------------------------------
function CheckMaxLength(MaxLength,stringValue)
{ 
	if (MaxLength - 3 >= stringValue.length)
		return true;
	else
		return false;
}
//------------------------------------------------------------------------------------------

function checkEmailValidate(emailAddress)
{
	
	var len = emailAddress.length;
	var pos  = emailAddress.indexOf('@');
	var strDotPos = emailAddress.indexOf('.', pos);
	
	
	if(pos == -1)	//not found @
		return false;
	
	if(strDotPos == -1)		//not found . after @
		return false;
		
	if(pos<1)		//there is'nt 1 char before @
		return false;
	
	
	pos +=1;
	if((len-pos)<1)// there is'nt 1 char after @
		return false;
	
	strDotPos +=1;
	if((strDotPos-pos)<2)// there is'nt 1 char between @ and .
		return false;
	
	if((len-strDotPos)<1)// there is'nt 1 char after .
		return false;
		
	return true; //every thing is o.k
}
//------------------------------------------------------------------------------------------

function TelephoneFunc(FormName)
{
	var Phone; 
	var Index;
	var LenP;
	
	
	Phone = FormName.CustomerPhone.value;
	LenP = Phone.length
	
	if ( LenP!= 12)
		{
			alert("Phone number should be in format of xxx-xxx-xxxx");
			return;
		}
	
	for (Index=0;Index<LenP;Index++) 	
		{
			switch (Index) {
				case 0:
				case 1:
				case 2:
				case 4:
				case 5:
				case 6:
				case 8:
				case 9:
				case 10:
				case 11:
					if(!isDigit(Phone.charAt(Index)))
					{
						alert("Phone number should be in format of xxx-xxx-xxxx");
						return(false);
					}
					break;
				case 3:
				case 7:
					if (Phone.charAt(Index) != '-')
					{
						alert("Phone number should be in format of xxx-xxx-xxxx");
						return(false);
					}
					break;
				default:
						alert("An error occur!");
						return(false);
						break;
				}
			return(true);
		}

}
//-------------------------------------------------------------------------------------------


function keyHole(evt) 
{
 
  var charCode;
 //check type of user browser  Netscape Or IE	
if (navigator.appName == "Netscape")
 //gets key that was pressed
charCode = evt.which 
else 
charCode = evt.keyCode;
             //  '  (              )          [             ]                :                ;            |                =           +            ?            <               >         \                 /              ,    
if ( charCode==39 ||     charCode == 40 ||charCode==41 ||charCode==91 || charCode==93 ||charCode==58 ||charCode==59 ||charCode==124 ||charCode==61 ||charCode==43||charCode==63||charCode==60||charCode==62 ||charCode==92||charCode==47||charCode==44) 
{
  alert('Illegal character!!!');


  return false;
}
else
   return true;

}

//------------------------------------------------------------------------------------------


function DisableTextBox(evt)
{


    var charCode;
 //check type of user browser  Netscape Or IE
   if (navigator.appName == "Netscape")
 //gets key that was pressed
    charCode = evt.which; 
   else 
   charCode = evt.keyCode;
             
//if (charCode >=0 || charCode<=255) 
   //return false;
 //else
   return false;

}

//--------------------------------------------------------------------------------------------
// added by oren
//--------------------------------------------------------------------------------------------
function TelephoneFuncEx(strPhoneNum)
{
	var Phone; 
	var Index;
	var LenP;	
	
	Phone = strPhoneNum;
	LenP = strPhoneNum.length;
	
	if ( LenP != 12)
	{
		alert("Phone number should be in format of xxx-xxx-xxxx (Invalid length)");
		return(false);
	}
	
	for (Index=0;Index<LenP;Index++) 		
	{
		switch (Index) 
		{
			case 0:
			case 1:
			case 2:
			case 4:
			case 5:
			case 6:
			case 8:
			case 9:
			case 10:
			case 11:
				if( !isDigit(Phone.charAt(Index)) )
				{
					alert("Phone number should be in format of xxx-xxx-xxxx (Invalid digit)");
					return(false);
				}
				break;
			case 3:
			case 7:
				if (Phone.charAt(Index) != '-')
				{
					alert("Phone number should be in format of xxx-xxx-xxxx (Invalid Separator)");
					return(false);
				}
				break;
			default:
					alert("An error occur!");
					return(false);
					break;
			}
		return(true);
	}

}

//-------------------------------------------------------------------
function CheckIllegalChar(evt) 
{
 
  var charCode;
 //check type of user browser  Netscape Or IE	
 if (navigator.appName == "Netscape")
   //gets key that was pressed
   charCode = evt.which 
 else 
    charCode = evt.keyCode;
             // '    
if (charCode ==39)   
{
  alert('Illegal character!!!');


  return false;
}
else
   return true;

}
//-----------------------------------------------------------------------
function AllowNumbersOnly(evt , fieldname) 
{
 
	 var charCode;
	 //check type of user browser  Netscape Or IE	
	if (navigator.appName == "Netscape")
	 //gets key that was pressed
		charCode = evt.which 
	else 
		charCode = evt.keyCode;
	
	if (( charCode<48 || charCode > 57) && (charCode != 46) )
	{
		alert('Please insert only numbers into ' + fieldname + ' !');
		return false;
	}
	else
	   return true;

}
//--------------------------------------------------------------------------

 function isAllDigits(s)
 {
    var test = "" + s;
    for (var k = 0; k < test.length; k++)
        {
        var c = test.substring(k, k+1);
        if (isDigit(c) == false)
            {
            return false;
            }
        }
    return true;
 }
 
 
//------------------------------------------------------------------------- 
  function validZip(zip)
  {
    
    if (zip.length == 5)
    {
        var result = isAllDigits(zip);
        if (result == false)
        {
            alert("Invalid character in zip code");
        }
        return result;
    }
    else if (zip.length == 10)
      {
		 var result = isAllDigits(zip.substring(0,5));
		 if (result == true)
            {
            if (zip.substring(5,6) != "-")
                {
                 result = false;
                }
            else
                {
                result = isAllDigits(zip.substring(6,10));
                }
            }
        if (result == false)
            {
            alert("Invalid character in zip code");
            }
        return result;
        }
    else
        {
        alert("Invalid zip code; please re-enter it");
        return false;
        }
 }


function SplitDate(strDate)

{
   var arrDate;
  if (!IsBlankStr(strDate))
  {
     arrDate=strDate.split("/") 
   
    if (arrDate.length>0)
    {
      g_parsed_month=arrDate[0];
      g_parsed_day=arrDate[1];
      g_parsed_year=arrDate[2];
   
    }
   else
    {
      g_parsed_month="";
      g_parsed_day="";
      g_parsed_year="";  
   
    }
  }
  else
  {
      g_parsed_month="";
      g_parsed_day="";
      g_parsed_year="";  
   
  
  }
   
 
 return;
}


//function for opening the upload-window
function myWin(formName,imageObjName,imgPathName)
{
	var myWin,url,picName,myForm;
	myForm=eval(formName)
	
//an option to give a specific name to the img file
//for now it is temp - and will be changed later on
	//picName=document.myForm.picName.value;
	//if(picName=="")
	picName="temp"
	
	url="upload/uploadFile.asp?imgPathName=" + imgPathName + "&imageObjName=" + imageObjName + "&picName=" + picName + "&FormName=" + formName;
	myWin = window.open(url,"upload","toolbar=0,directories=0,status=0,scrollbars=0,resizable=0,menubar=0,width=500,height=200")
}



function ChechDateValidation(strDate)
{
  var arrDate;
   
  if (!IsBlankStr(strDate))
  {
     arrDate=strDate.split("/") 
   
    if (arrDate.length>0)
    {
      g_parsed_day=arrDate[0];
      g_parsed_month=arrDate[1];
      g_parsed_year=arrDate[2];
   
	  return isDate (g_parsed_year, g_parsed_month, g_parsed_day);   
    }
    else
    {
      g_parsed_month="";
      g_parsed_day="";
      g_parsed_year="";  
    }
  }
  else
  {
      g_parsed_month="";
      g_parsed_day="";
      g_parsed_year="";   
  }
	
	return false;
}

function ChechIfDateLaterThanNow(strDate)
{
  var arrDate;
   
  if (!IsBlankStr(strDate))
  {
     arrDate=strDate.split("/") 
   
    if (arrDate.length>0)
    {
      g_parsed_day=arrDate[0];
      g_parsed_month=arrDate[1];
      g_parsed_year=arrDate[2];
		
	  var thisDate  = new Date()
	  var oDate = new Date(g_parsed_year,(parseInt(g_parsed_month)-1),(parseInt(g_parsed_day)))

	  return (Date.parse(thisDate) > Date.parse(oDate))
    }
    else
    {
      g_parsed_month="";
      g_parsed_day="";
      g_parsed_year="";  
    }
  }
  else
  {
      g_parsed_month="";
      g_parsed_day="";
      g_parsed_year="";   
  }
	
	return false;
}

function isTime (sTime)
{

 var arrTime;
   
  if (!IsBlankStr(sTime))
  {
     arrTime = sTime.split(":") 
   
    if (arrTime.length == 2)
    {
		if (arrTime[0] >=0 && arrTime[0] <= 24 && arrTime[1]>=0 && arrTime[1]<=59)
			return true;
		else
			return false;      
	}
  }	

}