/*
Right(strString, intLength)

Left(strString, intLength)

RightTrim(strString)

LeftTrim(strString)

Trim(strString)

MyDate arg1=date format: d/m/y, m/d/y; y/m/d
arg2=date or arg2=day;arg3=month;arg4=year(format according to arg1)
method:IsDate, FormatDate(date format, Separator), AddDay(date format, total day), GetTime

Date.getShortMonth();Date.getFullMonth()

MyDayDiff arg1=date format, arg2=date 1, arg2=date 2

IsInteger(strInteger) argument must either string type or numeric type

IsNumeric(strNumeric) argument must either string type or numeric type

Round(noChar, mode, noOfDec) mode=1-normal rounding, 2-truncate, 3-all round up; 0<=noOfDec<=10

Rand(intMin, intMax)

IsNumber(strNumber) argument must either string type or numeric type

IsCurrency(strCurrency) argument must either string type or numeric type

CustomMatch(strCustomFormat, strCustom)

IsEmail(strEmail)

convert_currency(number,decimals)
*/
//--------------------------------Rand(intMin, intMax)--------------------------------------
function Rand(intMin, intMax)
{  
  if(!IsInteger(intMin) || !IsInteger(intMax))  return Number.NaN;
  return intMin + Math.floor(Math.random()*(intMax + 1 - intMin));
}
//--------------------------------Round(noChar, mode, noOfDec)-------------------

function Round(numChar, mode, noOfDec)
{
  if(!IsNumeric(numChar))  return Number.NaN;
  if(!IsInteger(noOfDec))  return Number.NaN;
  if(noOfDec>10 || noOfDec<0)  return Number.NaN;
  var flNoOfDec=Math.pow(10,noOfDec)

  switch(mode)
  {
    case 0:
       return Math.round(numChar*flNoOfDec)/flNoOfDec;
        break;
    case 1:
       return Math.floor(numChar*flNoOfDec)/flNoOfDec;
        break;
    case 2:
       return Math.ceil(numChar*flNoOfDec)/flNoOfDec;
       break;
  }
  return Number.NaN;
}
//--------------------------------IsEmail(strEmail)-------------------

function IsEmail(strEmail)
{
strEmail=Trim(strEmail);

if(strEmail==null || strEmail.length<6) return false;
var strEmailPat=/^(\w|-|\.)+@([A-Za-z0-9]){1,22}(\.([A-Za-z0-9]|-){1,22})*(\.([A-Za-z0-9]){1,3})$/;
if(!strEmailPat.test(strEmail)) return false;

var emailComponent=strEmail.split("@");
var arraySubDomain=emailComponent[1].split(".");
var i;

if(IsNumber(arraySubDomain[0]))
{
  if(arraySubDomain.length!=4) return false;
  if(parseInt(arraySubDomain[0])<0 || parseInt(arraySubDomain[0])>255) return false; 
  for(i=1; i<4; i++)
  {
    if(!IsNumber(arraySubDomain[i])) return false;    
    if(parseInt(arraySubDomain[i])<0 || parseInt(arraySubDomain[i])>255) return false;    
  }
  
  switch (arraySubDomain[0])
  {
    case "10":
      return false;
      break;
    case "172":
      if(parseInt(arraySubDomain[1])>=16 && parseInt(arraySubDomain[1])<=31)  return false;
      break;
    case "192":
      if(arraySubDomain[1]=="168")  return false;
      break;
    case "127":
      return false;
      break;
  }
}

return true;
}

//--------------------------------CustomMatch(strTest,strPattern)-------------------
function CustomMatch(strCustomFormat, strCustom)
{
if(strCustomFormat=="" || strCustomFormat==null || strCustom=="" || strCustom==null)
  return false;

strCustom=Trim(strCustom);
var allowedChar="|()- ?%&#abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
var strTempCustomFormat="";
var i;
var tempChar="";
for(i=0; i<strCustomFormat.length; i++)
{
  tempChar=strCustomFormat.substr(i,1);
  if(allowedChar.indexOf(tempChar)==-1)
    return false;

  switch(tempChar) 
  {
  case "#":  
    strTempCustomFormat+="\\d";
    break;
  case "?":
    strTempCustomFormat +="[a-zA-Z]";
    break;
  case "%":
    strTempCustomFormat +="[a-z]";
    break;
  case "&":
    strTempCustomFormat +="[A-Z]";
    break;
  case "(":
    strTempCustomFormat +="\\" + tempChar; 
    break;
  case ")":
    strTempCustomFormat +="\\" + tempChar;
    break;
  case " ":
    strTempCustomFormat +=" ";
    break;
  default:
    strTempCustomFormat +=tempChar;
  }

}

var arrayCustomePat=strTempCustomFormat.split("|");
strTempCustomFormat=""
for (i=0; i<arrayCustomePat.length; i++)
{
  strTempCustomFormat+= "(" + arrayCustomePat[i] + ")";
  if(i!=arrayCustomePat.length-1)  strTempCustomFormat+="|";
}

var strCustomPat=eval("/^(" + strTempCustomFormat + ")$/");
return strCustomPat.test(strCustom);
}

//--------------------------------IsNumber(strNumber)-------------------
function IsNumber(strNumber)
{
strNumber=eval("'" + strNumber + "'");
if(strNumber==null || strNumber=="")
  return false;

strNumber=Trim(strNumber);

var strNumberPat=/^(\d+)$/;
return strNumberPat.test(strNumber);
}

//--------------------------------IsInteger(strInteger)-------------------
function IsInteger(strInteger)
{
strInteger=eval("'" + strInteger + "'");
if(strInteger==null || strInteger=="")
  return false;

strInteger=Trim(strInteger);

var strIntegerPat1=/^(-)?(\d+)(\.0+)?$/;
var strIntegerPat2=/^(-)?(\d{1,3},)?(\d{3},)*(\d{3})(\.0+)?$/;
return (strIntegerPat1.test(strInteger) || strIntegerPat2.test(strInteger));
}


//--------------------------------IsNumeric(strInteger)-------------------
function IsNumeric(strNumeric)
{
strNumeric=eval("'" + strNumeric + "'");
if(strNumeric==null || strNumeric=="")
  return false;

strNumeric=Trim(strNumeric);

var strNumericPat1=/^(-)?(\d+)(\.\d+)?$/;
var strNumericPat2=/^(-)?(\d{1,3},)?(\d{3},)*(\d{3})(\.\d+)?$/;
return (strNumericPat1.test(strNumeric) || strNumericPat2.test(strNumeric));

}

//--------------------------------IsCurrency(strCurrency)-------------------
function IsCurrency(strCurrency)
{
strCurrency=eval("'" + strCurrency + "'");
if(strCurrency==null || strCurrency=="")
  return false;

strCurrency=Trim(strCurrency);

var strCurrencyPat1=/^(-)?(\d+)(\.\d\d)?$/;
var strCurrencyPat2=/^(-)?(\d{1,3},)?(\d{3},)*(\d{3})(\.\d\d)?$/;
return (strCurrencyPat1.test(strCurrency) || strCurrencyPat2.test(strCurrency));
}


//--------------------------------MyDayDiff(strDateFormat,strDate1,strDate2)-------------------

function MyDayDiff(strDateFormat,strDate1,strDate2)
{
var obj_DayDiff_1=new MyDate(strDateFormat,strDate1);
var obj_DayDiff_2=new MyDate(strDateFormat,strDate2);

var intDate1=obj_DayDiff_1.GetTime();
var intDate2=obj_DayDiff_2.GetTime();

var intError;
if(intDate2==Number.NaN && intDate1==Number.NaN)
  return intError;
else
 return (intDate1-intDate2)/86400000;
}



//--------------------------------MyDate()-------------------
function MyDate()
{

var myObj=new Object();

var strDay;
var strMonth;
var strYear;
var strSeparator;

var strMonthName=new Array("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");
var intTotalMonthDays=new Array(31,28,31,30,31,30,31,31,30,31,30,31);
var intMonthNameIndex;

var boolInputError=false;
var MyDateArgument=arguments;
var datDate;

//--------------------------------IniMyDate()-------------------
function IniMyDate()
{

var strDateFormat;
var strDate;

if(MyDateArgument.length==0)  
  return false;
else if(MyDateArgument.length==2)
{
  strDateFormat=Trim(MyDateArgument[0]);
  strDate=Trim(MyDateArgument[1]);
}
else if(MyDateArgument.length==4)
{
  strDateFormat=Trim(MyDateArgument[0]);
  strDate=MyDateArgument[1] + "/" + MyDateArgument[2] + "/" + MyDateArgument[3];
}
else
{
  alert("DEBUGER: Undefined function arguments!")
  return false;
}

var dateFormatPat=/^([a-zA-Z]{1,2})\/([a-zA-Z]{1,2})\/([a-zA-Z]{1,2})$/;
var arrayDateFormatMatch=strDateFormat.match(dateFormatPat);
var intDayIndex=0;
var intMonthIndex=0;
var intYearIndex=0;
var i;

if(arrayDateFormatMatch)
{
  for (i=1; i<arrayDateFormatMatch.length; i++)
  {
    if(arrayDateFormatMatch[i]=="d")
      intDayIndex=i;
    else if(arrayDateFormatMatch[i]=="y")
      intYearIndex=i;
    else if(arrayDateFormatMatch[i]=="m")
      intMonthIndex=i;
  }
}
else
{ 
  alert("DEBUGER: Undefined date format is provided!")
  return false;
}

if(!(intDayIndex && intMonthIndex && intYearIndex))
{
  alert("DEBUGER: Undefined date format is provided!")
  return false;
}


var datePat=/^(\w*)\/(\w*)\/(\w*)$/;
var arrayDateMatch=strDate.match(datePat);

if(!arrayDateMatch)
{
  datePat=/^(\w*)-(\w*)-(\w*)$/;
  arrayDateMatch=strDate.match(datePat);
  
  if(!arrayDateMatch)
    return false;
}
 


strDay=arrayDateMatch[intDayIndex];
strMonth=arrayDateMatch[intMonthIndex];
strYear=arrayDateMatch[intYearIndex];
strSeparator=arrayDateMatch[2]

var dayPat=/^(\d{1,2})$/;
if(!dayPat.test(strDay))  return false;

var yearPat=/^(\d{4})$/;
//if(!yearPat.test(strYear)|| parseInt(strYear)<1970 )  return false;
if(!yearPat.test(strYear))  return false;


var boolMatch=false;

var monthPat=/^(\d{1,2})$/;
if(monthPat.test(strMonth))
{
  if(parseInt(strMonth)>12)  return false;
  intMonthNameIndex=parseInt(strMonth)-1;
}
else
{
  strMonth=strMonth.toLowerCase()
  strMonth=Left(strMonth,1).toUpperCase() + Right(strMonth, strMonth.length-1);

  for(i=0; i<12; i++)
  {
    if(strMonth==strMonthName[i] || strMonth==Left(strMonthName[i],3)) 
    {
      intMonthNameIndex=i;
      boolMatch=true;
      break;  
    } 
  }

  if(!boolMatch) 
  {
    return false;
  }  

}



intTotalMonthDays[1]=((parseInt(strYear)%400==0)||((parseInt(strYear)%4==0)&&(parseInt(strYear)%100!=0))) ? 29:28;

if (parseInt(strDay)>parseInt(intTotalMonthDays[intMonthNameIndex])) return false;

datDate=new Date(strYear, intMonthNameIndex, strDay);
return true;
}

if(!IniMyDate()) boolInputError=true;

function Is4DigitYear()
{
if(boolInputError) return false;

var yearPat=/^(\d{4})$/;

if(yearPat.test(strYear))
  return true;
else
  return false;
}

//--------------------------------IsDate()-------------------
function IsDate()
{

if(boolInputError) return false;

return true;
}

//--------------------------------FormatDate()-------------------
function FormatDate()
{
if(boolInputError) return "Format Date: Error";

if(!(arguments.length==1 || arguments.length==2))
{
  alert("DEBUGER: Undefined function arguments!")
  return "Format Date: Error";
}

var dateFormatPat=/^([a-zA-Z]{1,2})\/([a-zA-Z]{1,2})\/([a-zA-Z]{1,2})$/;
var arrayDateFormatMatch=arguments[0].match(dateFormatPat);
var arrayStrSeq=new Array();
var strSeparator2;
var i;

if (arguments[1])
  strSeparator2=arguments[1];
else  
 strSeparator2=strSeparator;

var strMonthType;
var strDayType;
var boolDay=false;
var boolMonth=false;
var boolYear=false;

if(arrayDateFormatMatch)
{
  for (i=1; i<arrayDateFormatMatch.length; i++)
  {
    if(arrayDateFormatMatch[i]=="d" || arrayDateFormatMatch[i]=="dd")
    { 
      boolDay=true;
      strDayType=arrayDateFormatMatch[i];
      arrayStrSeq[arrayStrSeq.length]="strDay2";
    }
    else if(arrayDateFormatMatch[i]=="y")
    {
      boolYear=true;
      arrayStrSeq[arrayStrSeq.length]="strYear";
    }
    else if(arrayDateFormatMatch[i]=="m" || arrayDateFormatMatch[i]=="mm" ||arrayDateFormatMatch[i]=="M" || arrayDateFormatMatch[i]=="MM" )
    {
      boolMonth=true;
      arrayStrSeq[arrayStrSeq.length]="strMonth2";
      strMonthType=arrayDateFormatMatch[i];
    } 
  }
}
else
{ 
  alert("DEBUGER: Undefined date format is provided!")
  return "Format Date: Error";
}

if(!(boolDay && boolMonth && boolYear))
{ 
  alert("DEBUGER: Undefined date format is provided!")
  return "Format Date: Error";
}

var strMonth2;
if(strMonthType=="m")
  strMonth2="" + eval(intMonthNameIndex+1);
else if(strMonthType=="mm")
  strMonth2=Right("0" + eval(intMonthNameIndex+1),2);
else if(strMonthType=="M")
  strMonth2=Left(strMonthName[intMonthNameIndex],3);
else
  strMonth2=strMonthName[intMonthNameIndex];

var strDay2;
if(strDayType=="d")
  strDay2="" + strDay;
else if(strDayType=="dd")
  strDay2=Right("0" + strDay, 2);

return eval(arrayStrSeq[0] + "+strSeparator2+" + arrayStrSeq[1] + "+strSeparator2+" + arrayStrSeq[2]);

}

//--------------------------------AddDay()-------------------

function AddDay()
{

if(!(arguments.length==2 || arguments.length==3))
{
  alert("DEBUGER: Undefined function arguments!")
  return "AddDay: Error"
}

var strDateFormat=arguments[0];
var strAddDay=arguments[1];


var intdayPat=/^(\d+)$/;
if(!intdayPat.test(strAddDay) || boolInputError) return "AddDay: Error";

var datTemp=new Date();
datTemp.setTime(datDate.getTime() + parseInt(strAddDay)*86400000)

strDay="" + datTemp.getDate();
intMonthNameIndex=datTemp.getMonth();
strYear=datTemp.getFullYear();
if(strYear<1000) strYear += 1900;

strYear=""+strYear;
var strAddDay;
if(arguments[2])
  strAddDay=FormatDate(strDateFormat, arguments[2])
else
  strAddDay=FormatDate(strDateFormat)

strDay="" + datDate.getDate();
intMonthNameIndex=datDate.getMonth();
strYear=datDate.getFullYear();
if (strYear<1000)  strYear+=1900;
strYear="" + strYear;
if (strAddDay.indexOf("Error")==-1)
 return strAddDay;
else
 return "AddDay: Error";

}

//--------------------------------GetTime()-------------------
function GetTime()
{
if(boolInputError)
{
  alert("Get Time: Error");
  return Number.NaN;
}
else
  return datDate.getTime();
}


myObj.IsDate=IsDate;
myObj.Is4DigitYear=Is4DigitYear;
myObj.FormatDate=FormatDate;
myObj.AddDay=AddDay;
myObj.GetTime=GetTime;

return myObj;

}

//--------------------------------getShortMonth()-------------------
Date.prototype.getShortMonth=getShortMonth;
Date.prototype.getFullMonth=getFullMonth;
function getShortMonth(){
var intMonth=this.getMonth();
var arrayShortMonth=new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec");
return arrayShortMonth[intMonth];
}
//--------------------------------getFullMonth()-------------------
function getFullMonth(){
var intMonth=this.getMonth();
var arrayFullMonth=new Array("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");
return arrayFullMonth[intMonth];
}

//--------------------------------Trim(strString)-------------------
function Trim(strString)
{
if(strString==null)
  return (null);

return RightTrim(LeftTrim(strString));
}

//--------------------------------LeftTrim(strString)-------------------
function LeftTrim(strString)
{

if(strString==null)
  return (null);

var i;
var intLength=strString.length;

for (i=0; i<strString.length; i++)
{
  if(strString.charAt(i)!=" " && strString.charAt(i)!="\t" && strString.charAt(i)!="\r" && strString.charAt(i)!="\f" && strString.charAt(i)!="\n")
    break;
}

return Right(strString, intLength-i);
}

//--------------------------------RightTrim(strString)-------------------
function RightTrim(strString)
{
var i;
if (strString==null)
  return (null);

for(i=strString.length-1; i>=0; i--)
{
  if(strString.charAt(i)!=" " && strString.charAt(i)!="\t" && strString.charAt(i)!="\r" && strString.charAt(i)!="\f" && strString.charAt(i)!="\n")
    break;
}

return Left(strString, i+1);
}

//--------------------------------Left(strString, intLength-i)-------------------
function Left(strString, intLength)
{
if(strString==null)
  return (null);

if(intLength>strString.length)
  intLength=strString.length;

return strString.substr(0, intLength);
}

//--------------------------------Right(strString, intLength-i)-------------------
function Right(strString, intLength)
{
if(strString==null)
  return (null);

if(intLength>strString.length)
  intLength=strString.length;

return strString.substr(strString.length-intLength);
}


//--------------------------------convert_currency(number,decimals)-------------------
function convert_currency(number,decimals)
	{

		number = round_decimals(number,decimals)

		var foundPosition = number.indexOf(".");
		var xArray = number.split(".");

		if (!(isNaN(number)))
		{
			if (foundPosition == -1)
				return format_number(number);
			else{
				xArray[0] = format_number(parseInt(xArray[0]))
				if(number>=0)
					return xArray.join('.');
				else if(parseInt(xArray[0])==0)
					return '-' + xArray.join('.');
				else
					return xArray.join('.');			}
		}
		else
			return "NaN.00";
	}

function format_number(num)
{
	if (num >= 1000 || num <= -1000)
	{
		var number_string = Math.abs(num).toString();
		var insert_position;

		switch (number_string.length % 3)
		{
			case 1:
				insert_position = 1;
				break;

			case 2:
				insert_position = 2;
				break;

			case 0:
				insert_position = 3;
				break;
		}

		while (insert_position < number_string.length)
		{
			number_string = number_string.left(insert_position) + "," + number_string.substring(insert_position);
			insert_position += 4;
		}

		if (num < 0)
			return "-" + number_string;
		else
			return number_string;
	}
	else
	{
		return num.toString();
	}
}

function extract_left(total_chars)
{
	return this.substring(0, total_chars);
}

String.prototype.left = extract_left;

function round_decimals(original_number, decimals)
{
	if(original_number==null || original_number=="")
		original_number=0;
	
	if(isNaN(original_number))
		return NaN;


	if(decimals==null || decimals=="" ||isNaN(decimals))
		return original_number;
	
	if(Number.toFixed){		
		return parseFloat(original_number).toFixed(decimals);
		
	}
	else{
		var original_number2;			
		var intMinus=0;
		var intNegatif=1;
		
		if(parseFloat(original_number)<0 ){		
			original_number2 =parseFloat(original_number) *-1;			
			intNegatif=-1;
		}
		else
			original_number2=parseFloat(original_number);
		
		
		while(original_number2>0 && original_number2 < 2){
			original_number2=original_number2+1;
			intMinus++;
		}
			
		
		var result1 = (original_number2) * Math.pow(10, decimals);		
		var result2 = Math.round(result1);
		var result3 = result2 / Math.pow(10, decimals)-intMinus;
		
		result3 = result3 * Math.pow(10, decimals);		
		result3 = Math.round(result3);		
		result3 = result3/ Math.pow(10, decimals)*intNegatif;
		
		return pad_with_zeros(result3, decimals);
		
	
	}
	
	
	
	
}

function pad_with_zeros(rounded_value, decimal_places)
{
	var value_string = rounded_value.toString();
	var decimal_location = value_string.indexOf(".");

	if (decimal_location == -1)
	{
		decimal_part_length = 0;
		value_string += decimal_places > 0 ? "." : "";
	}
	else
	{
		decimal_part_length = value_string.length - decimal_location - 1;
	}

	var pad_total = decimal_places - decimal_part_length;

	if (pad_total > 0)
	{
		for (var counter = 1; counter <= pad_total; counter++)
			value_string += "0";
	}

	return value_string;
}


function setvalue_E(id,sw){
  if (sw == 'on'){
    if (id.value.indexOf('Search Keyword') > -1) {
      id.value='';
    }
  } else {
    if (id.value == '') {
      id.value = '> Search Keyword';
    }
  }
}


function commonSearchKey(){
  if(document.commonSearch.qt.value.length == 0){
    alert("Please enter keyword.");
    return false;
  } else {
    return true;
  }
}