/************************************************************************************************
* 제    목 : common.js
* 설    명 : 표준함수(js)
* 작 성 자 : 신육설
* 작 성 일 : 2003.06.15
* 수정이력 :
************************************************************************************************/

/******************************************************************************************************************
//문자열관련
fTrim(pValue)                                                  : 문자열 앞뒤에있는 공백 제거
fGetByteSize(pValue)                                           : 파라미터 값의 Byte 크기를 리턴

//데이터형 체크
fCheckNumber(pValue)                                           : 파라미터 값이 숫자로만 이루어져있는지를 체크
fCheckInteger(pValue)                                          : 파라미터 값이 정수인지를 체크
fCheckFloat(pValue)                                            : 파라미터 값이 Float Type인지를 체크
fCheckEnglish(pValue)

//날짜관련
fCheckDay(pDay)                                                : 일값 체크 (수치여부, 범위(1~31일))
fCheckMonth(pMonth)                                            : 월값 체크 (수치여부, 범위(1~12월))
fCheckYear(pYear)                                              : 년도값 체크 (수치여부, 범위)
fCheckDate(pDate)                                              : 일자값 체크 (8문자 수치여부, 년월일값의 범위, 윤년)
fGetDay(pDate)                                                 : 파라미터로 받은 일자의 요일 리턴
fCompleteDay(pDay)                                             : 날짜(일)값을 체크한 후 2자리 수치값으로 리턴 ("01" 또는 "31" 형태)
fCompleteMonth(pMonth)                                         : 날짜(월)값을 체크한 후 2자리 수치값으로 리턴 ("01" 또는 "12" 형태)

//확장함수목록(메세지 포함)
fAlertMessage(pMessageCode, pAttachMessage)                    : 메세지 코드를 받아 첨부 메시지와 함께 Alert 처리
fCheckEmpty(pValue, pElementName)                              : 값이 없는지 체크
fCheckByteSize(pValue, pMaxLength, pElementName)               : 값의 길이 체크
efCheckDate(pValue, pElementName)                              : 값의 날짜형 체크
efCheckNumber(pValue, pElementName)                            : 값의 숫자형 체크
fAutoClick(pScript)                                            : "enter" 키가 눌러졌으면 파라미터로 받은 스크립트를 실행
fGetCookie(name)                                               : 쿠키값 얻어오기
fSetCookie(name, value, expiredays)                            : 쿠기값 저장하기


// Html Element Value Check Function
fCheckNumberTag(pElement,pLabel,pNull) : Input Box값의 숫자인지를 체크.  
fCheckStringTag(pElement,pLabel,pNull,pMaxLength) : Input Box값의 길이를 체크.
fCheckChooseTag(pElement,pLabel) : CHOOSE TYPE 체크.
fCheckDateTag(pElement,pLabel,pNull) : DATE TYPE 체크.
fCheckAngleTag(pElement,pLabel,pNull) : ANGLE(도-분-초) TYPE 체크.
fCheckDecimalTag(pElement,pLabel,pNull,pMaxLength,pPointLength) : DECIMAL TYPE 체크.
fCheckMoneyTag(pElement,pLabel,pNull) : MONEY TYPE 체크.
fCheckBooleanTag(pElement,pLabel) : BOOLEAN TYPE 체크.
fCheckRadioTag(pElement,pLabel) : radio, checkbox Tag값을 체크


// 함수리스트(태그액션)
   fCheckAll(pFormName,pListTr,pCheckboxName,pState) : 체크박스 전체선택, 선택해제
   fSetChecked(pElement,pValue) : 라디오버튼이나 체크박스에 해당하는 값을 넘기면 해당하는 값을 선택한다
   fEnableNumberTag(pElement) : 숫자만 입력가능한 태그로 만든다.

****************************************************************************************************************/



/*
   내    용 : 문자열 앞뒤에있는 공백 제거
   파라미터 : pValue - 대상 문자열
   Return값 : 공백을 제거한 결과 문자열
*/
function fTrim(pValue)
{
   var vStartPoint = 0;                      // subString 하기 위한 시작 포인트
   var vEndPoint   = pValue.length;   // subString 하기 위한 끝 포인트

   //문자열앞에 공백문자가 들어 있는 Index 추출
   while( (vStartPoint < vEndPoint) && (pValue.charCodeAt(vStartPoint) == 32) )
   {
      vStartPoint++;
   }

   //문자열뒤에 공백문자가 들어 있는 Index 추출
   while( (vStartPoint < vEndPoint) && (pValue.charCodeAt(vEndPoint-1) == 32) )
   {
      vEndPoint--;
   }
   // 공백을 제거했으면 subString하여 결과문자열을 리턴하고 제거한 내용이 없으면 그대로 리턴
   return ( (vStartPoint > 0) || (vEndPoint < pValue.length) ) ? pValue.substring(vStartPoint, vEndPoint) : pValue;
}


/*
   내    용 : 파라미터 값의 Byte 크기를 리턴
   파라미터 : pValue - 파라미터 값
   Return값 : 파라미터 값의 Byte 크기
*/
function fGetByteSize(pValue)
{
   // Byte 수를 저장할 변수
   var vByteSize = 0;

   // Value 값의 길이만큼 loop
   for(var i=0; i<pValue.length; i++)
   {
      //한글이 들어오면 255보다 크다
      if(pValue.charCodeAt(i) > 255) vByteSize += 2;
      else vByteSize += 1;
   }

  return vByteSize;
}


/*
   내    용 : 파라미터 값이 숫자로만 이루어져있는지를 체크
   파라미터 : pNumber - 체크할 수치 또는 문자열
   Return값 : TRUE or FALSE
*/
function fCheckNumber(pNumber)
{
   // 값이 없으면 FALSE 리턴
   if(typeof(pNumber) == "undefined") return false;
   if(pNumber.length == 0) return false;

   // 문자열화시켜 변수에 저장
   var vNumber = pNumber.toString();

   // 문자열 길이만큼 loop
   for(var i=0; i<vNumber.length; i++)
   {
      var vTemp = vNumber.substring(i, i+1);
      
      // 숫자가 아니면 FALSE 리턴
      if(isNaN(vTemp)) return false;
      
      // 공백이면 FALSE 리턴
      if(" " == vTemp) return false;
   }

   // 이상 없으므로 TRUE 리턴
   return true;
}


/*
   내    용 : 파라미터 값이 정수인지를 체크
   파라미터 : pValue - 파라미터 값
   Return값 : TRUE or FALSE
*/
function fCheckInteger(pValue)
{
   // 값이 없으면 FALSE 리턴
   if(typeof(pValue) == "undefined") return false;
   if(pValue.length == 0) return false;

   // 문자열화시켜 변수에 저장
   var vValue = pValue.toString();

   // 첫번째 문자가 "-" 이면 제거
   if(vValue.substring(0, 1) == "-")
   {
      vValue = vValue.substring(1, vValue.length);
   }

   // 값이 0 이 아니면
   if(vValue != 0)
   {
      // 문자열 길이만큼 loop
      for(var i=0; i<vValue.length; i++)
      {
         // 숫자가 아니면 FALSE 리턴
         if(isNaN(vValue.substring(i, i+1))) return false;
      }
   }

   // 이상 없으므로 TRUE 리턴
   return true;
}


/*
   내    용 : 파라미터 값이 Float Type인지를 체크
   파라미터 : pValue - 파라미터 값
   Return값 : TRUE or FALSE
*/
function fCheckFloat(pValue)
{
   // 파라미터 값이 parseFloat()후에도 같으면 TRUE 리턴
   if(pValue == parseFloat(pValue)) return true;
   else return false;
}


/*
   내    용 : 파라미터 값이 영문자 인지를 체크
   파라미터 : pValue - 파라미터 값
   Return값 : TRUE or FALSE
*/
function fCheckEnglish(pValue) 
{
	var ch = '1234567890_abcdefghijklmnopqrstuvwxyz-ABCDEFGHIJKLMNOPQRSTUVWXYZ'
	var DATA = pValue.value
	
	for (i=0; i<DATA.length; i++) {
		if(ch.indexOf(DATA.substring(i , i+1)) == -1) return false;
	}

	return true;
}


/*
   내    용 : 일값 체크 (수치여부, 범위(1~31일))
   파라미터 : pDay - 체크할 날짜(일)
   Return값 : TRUE or FALSE
*/
function fCheckDay(pDay)
{
   // 값이 없으면 false 리턴
   if(pDay == "")
   {
      fAlertMessage(0, "일");
      return false;
   }

   // 길이가 2보다 크면 false 리턴
   if(pDay.length > 2)
   {
      fAlertMessage(3, "일");
      return false;
   }

   // 수치가 아니면
   if(isNaN(pDay))
   {
      fAlertMessage(4, "일");
      return false;
   }

   // 일값이 1 부터 31 사이의 수치가 아니면 false 리턴
   if(eval(pDay) < 1 || eval(pDay) > 31)
   {
      fAlertMessage(1, "일");
      return false;
   }

   // 이상 없으므로 TRUE 리턴
   return true;
}


/*
   내    용 : 월값 체크 (수치여부, 범위(1~12월))
   파라미터 : pMonth - 체크할 월
   Return값 : TRUE or FALSE
*/
function fCheckMonth(pMonth)
{
   // 값이 없으면 false 리턴
   if(pMonth == "")
   {
      fAlertMessage(0, "월");
      return false;
   }

   // 길이가 2보다 크면 false 리턴
   if(pMonth.length > 2)
   {
      fAlertMessage(3, "월");
      return false;
   }

   // 수치가 아니면
   if(isNaN(pMonth))
   {
      fAlertMessage(4, "월");
      return false;
   }

   // 월값이 1 부터 12 사이의 수치가 아니면 false 리턴
   if(eval(pMonth) < 1 || eval(pMonth) > 12)
   {
      fAlertMessage(1, "월");
      return false;
   }

   // 이상 없으므로 TRUE 리턴
   return true;
}


/*
   내    용 : 년도값 체크 (수치여부, 범위)
   파라미터 : pYear - 체크할 년도
   Return값 : TRUE or FALSE
*/
function fCheckYear(pYear)
{
   // 값이 없으면 false 리턴
   if(pYear == "")
   {
      fAlertMessage(0, "년도");
      return false;
   }

   // 길이가 4가 아니면 false 리턴
   if(pYear.length != 4)
   {
      fAlertMessage(3, "년도");
      return false;
   }

   // 수치가 아니면
   if(isNaN(pYear))
   {
      fAlertMessage(4, "년도");
      return false;
   }

   // 년도값이 0 부터 9999 사이의 수치가 아니면 false 리턴
   if(eval(pYear) < 0 || eval(pYear) > 9999)
   {
      fAlertMessage(1, "년도");
      return false;
   }
   return true;
}


/*
   내    용 : 일자값 체크 (8문자 수치여부, 년월일값의 범위, 윤년)
   파라미터 : pDate - 체크할 날짜
   Return값 : TRUE or FALSE
*/
function fCheckDate(pDate)
{
   // 일자값 저장 배열
   var vDateArray = new Array(3);

   // Null값이 없으면 false 리턴
   if(pDate == "")
   {
      return false;
   }

   // "/" 문자가 있으면
   if(pDate.match("/") == "/")
   {
      // "/" 문자를 구분자로 분리하여 배열에 저장
      vDateArray = pDate.split("/");

      // 배열 길이가 3 이 아니면 false 리턴
      if(vDateArray.length != 3)
      {
         return false;
      }
   }
   // "-" 문자가 있으면
   else if(pDate.match("-") == "-")
   {
      // "-" 문자를 구분자로 분리하여 배열에 저장
      vDateArray = pDate.split("-");

      // 배열 길이가 3 이 아니면 false 리턴
      if(vDateArray.length != 3)
      {
         return false;
      }
   }
   // "." 문자가 있으면
   else if(pDate.split(".").length > 1)
   {
      // "." 문자를 구분자로 분리하여 배열에 저장
      vDateArray = pDate.split(".");

      // 배열 길이가 3 이 아니면 false 리턴
      if(vDateArray.length != 3)
      {
         return false;
      }
   }
   // "/"문자가 없으면
   else
   {
      // 길이가 8 이 아니면 false 리턴
      if(pDate.length != 8) return false;
      
      // 수치가 아니면
      if(isNaN(pDate))return false;

      // 길이대로(년:4, 월:2, 일:2) 잘라서 배열에 저장
      vDateArray[0] = pDate.substr(0,4);
      vDateArray[1] = pDate.substr(4,2);
      vDateArray[2] = pDate.substr(6,2);
   }

   // 년도값이 0 부터 9999 사이의 수치가 아니면 false 리턴
   if(eval(vDateArray[0]) < 0 || eval(vDateArray[0]) > 9999)
      return false;

   // 월값이 1 부터 12 사이의 수치가 아니면 false 리턴
   if(eval(vDateArray[1]) < 1 || eval(vDateArray[1]) > 12)
      return false;

   // 일값이 1 부터 31 사이의 수치가 아니면 false 리턴
   if(eval(vDateArray[2]) < 1 || eval(vDateArray[2]) > 31)
      fAlertMessage(1, "일자(일)");

   // 월값이 길이가 1 이면 앞에 "0" 을 붙인다
   if(vDateArray[1].length == 1) vDateArray[1] = "0" + vDateArray[1];

   // 일값이 길이가 1 이면 앞에 "0" 을 붙인다
   if(vDateArray[2].length == 1) vDateArray[2] = "0" + vDateArray[1];

   // 30 일까지 있는 달의 일 체크
   if((eval(vDateArray[1]) == 4 || eval(vDateArray[1]) == 6 || eval(vDateArray[1]) == 9 || eval(vDateArray[1]) == 11) && eval(vDateArray[2]) == 31)
      return false;

   // 윤년일 경우
   if(((eval(vDateArray[0]) % 4 == 0 && eval(vDateArray[0]) % 100 != 0) || eval(vDateArray[0]) % 400 == 0))
   {
      // 2 월의 일 체크
      if(eval(vDateArray[1]) == 2 && eval(vDateArray[2]) > 29)
         return false;
   }
   // 윤년이 아닐 경우
   else
   {
      // 2월의 일 체크
      if(eval(vDateArray[1]) == 2 && eval(vDateArray[2]) > 28)
         return false;
   }

   return true;
}


/*
   내    용 : 파라미터로 받은 일자의 요일 리턴
   파라미터 : pDate - 일자 (8자리 숫자로 이루어진 문자열)
   Return값 : 요일 (일,월,화,수,목,금,토 => 0,1,2,3,4,5,6)
*/
function fGetDay(pDate)
{
   var vDate = pDate.toString();
   
   if(vDate.length != 8)
   {
      fAlertMessage(3, "일자");
      return;
   }
   
   if(!fCheckNumber(vDate))
   {
      fAlertMessage(4, "일자");
      return;
   }
   
// var vDayArray = ["일", "월", "화", "수", "목", "금", "토"];
   var vTempDate = new Date();
   vTempDate.setYear(vDate.substring(0, 3));
   vTempDate.setMonth(eval(vDate.substring(4, 6))-1);
   vTempDate.setDate(vDate.substring(6, 8));
   var vDay  = vTempDate.getDay();
   return vDay;
}
/*
	내    용 : 날짜(일)값을 체크한 후 2자리 수치값으로 리턴 ("01" 또는 "31" 형태)
	파라미터 : pDay - 체크할 날짜(일)
	Return값 : 2자리 수치값 (오류가 없을 경우) or ""(오류가 있을 경우)
*/
function fCompleteDay(pDay)
{
	var vDay;
	vDay = pDay;

	// 일자 체크 결과가 false 이면 리턴
	if(fCheckDay(vDay) == false) return "";

	// 일값이 길이가 1 이면 앞에 "0" 을 붙인다
	if(vDay.length == 1) vDay = "0" + vDay;

	return vDay;
}

/*
	내    용 : 날짜(월)값을 체크한 후 2자리 수치값으로 리턴 ("01" 또는 "12" 형태)
	파라미터 : pMonth - 체크할 날짜(월)
	Return값 : 2자리 수치값 (오류가 없을 경우) or ""(오류가 있을 경우)
*/
function fCompleteMonth(pMonth)
{
	var vMonth;
	vMonth = pMonth;

	// 일자 체크 결과가 false 이면 리턴
	if(fCheckMonth(vMonth) == false) return "";

	// 월값이 길이가 1 이면 앞에 "0" 을 붙인다
	if(vMonth.length == 1) vMonth = "0" + vMonth;

	return vMonth;
}



/***************************************확장함수**************************************************
/*
	내    용 : 메세지 코드를 받아 첨부 메시지와 함께 Alert 처리
	파라미터 : pMessageCode   - 메시지 코드
	           pAttachMessage - 첨부 메시지
	Return값 : 없음
*/
function fAlertMessage(pMessageCode, pAttachMessage)
{
	var vAlertMessage;

	     if(0 == eval(pMessageCode)) vAlertMessage = pAttachMessage + "을(를) 반드시 입력해야 합니다.";
	else if(1 == eval(pMessageCode)) vAlertMessage = pAttachMessage + "값이 범위를 벗어납니다.";
	else if(2 == eval(pMessageCode)) vAlertMessage = pAttachMessage + "값의 갯수가 맞지 않습니다.";
	else if(3 == eval(pMessageCode)) vAlertMessage = pAttachMessage + "값의 길이가 맞지 않습니다.";
	else if(4 == eval(pMessageCode)) vAlertMessage = pAttachMessage + "값의 데이타형이 맞지 않습니다.";
	else if(5 == eval(pMessageCode)) vAlertMessage = pAttachMessage + "작업을 할 수 없습니다.";

   alert(vAlertMessage);
}


/*
   내    용 : 값이 없는지 체크
   파라미터 : pValue       - 체크할 문자열
              pElementName - 해당 객체명
   Return값 : TRUE or FALSE
*/
function fCheckEmpty(pValue, pElementName)
{
   if(fTrim(pValue) == "")
   {
      if("undefined" != typeof(pElementName)) fAlertMessage(0, pElementName);
      return false;
   }
   return true;   // 공백이 아니라면
}


/*
   내    용 : 값의 길이 체크
   파라미터 : pValue       - 체크할 문자열
              pMaxLength   - 최대 허용 길이
              pElementName - 해당 객체명
   Return값 : TRUE or FALSE
*/
function fCheckByteSize(pValue, pMaxLength, pElementName)
{
   if(fGetByteSize(pValue) > eval(pMaxLength))
   {
      if("undefined" != typeof(pElementName)) alert(pElementName+"은(는) "+pMaxLength+"Byte 이하로 입력해야 합니다");
      return false;
   }
   return true;
}


/*
   내    용 : 값이 날짜형인지 체크
   파라미터 : pValue       - 체크할 문자열
              pElementName - 해당 객체명
   Return값 : TRUE or FALSE
*/
function efCheckDate(pValue, pElementName)
{
   if(!fCheckDate(pValue))
   {
      if("undefined" != typeof(pElementName)) alert(pElementName+"을(를) 형식에 맞게 입력해주십시오.\n\n8자리 숫자로 입력 (예) '20030504' ");
      return false;
   }
   return true;
}


/*
   내    용 : 값이 숫자인지 체크
   파라미터 : pValue       - 체크할 문자열
              pElementName - 해당 객체명
   Return값 : TRUE or FALSE
*/
function efCheckNumber(pValue, pElementName)
{
   if(!fCheckEmpty(pValue)) return true;
   if(!fCheckNumber(pValue))
   {
      if("undefined" != typeof(pElementName)) alert(pElementName+"은(는) 숫자로만 입력할 수 있습니다.");
      return false;
   }
   return true;
}


/*
   내    용 : "enter" 키가 눌러졌으면 파라미터로 받은 스크립트를 실행
   파라미터 : pScript - 실행할 스크립트
   Return값 : 없음
*/
function fAutoClick(pScript)
{
   // 눌려진 키가 "enter" 이면 파라미터로 받은 스크립트(함수) 실행
   if(event.keyCode == 13) window.execScript(pScript, "javascript");
}


function selon(oItem) {
	oItem.style.background = "#EEEEFF";
	oItem.style.cursor = "hand";
}

function selout(oItem) {
	oItem.style.background = "#FFFFFF";
	oItem.style.cursor = "default";
}


function MM_swapImgRestore() { //v3.0
  var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}

function MM_preloadImages() { //v3.0
  var d=document; if(d.images){ if(!d.MM_p) d.MM_p=new Array();
    var i,j=d.MM_p.length,a=MM_preloadImages.arguments; for(i=0; i<a.length; i++)
    if (a[i].indexOf("#")!=0){ d.MM_p[j]=new Image; d.MM_p[j++].src=a[i];}}
}

function MM_findObj(n, d) { //v4.01
  var p,i,x;  if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
    d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
  if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
  for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
  if(!x && d.getElementById) x=d.getElementById(n); return x;
}

function MM_swapImage() { //v3.0
  var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
   if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}


// 쿠키를 읽어옵니다.
function fGetCookie(name) {
   var nameOfCookie = name + "=";
   var x = 0;
   while ( x <= document.cookie.length )
   {
      var y = (x+nameOfCookie.length);
      if ( document.cookie.substring( x, y ) == nameOfCookie ) {
         if ( (endOfCookie=document.cookie.indexOf( ";", y )) == -1 )
              endOfCookie = document.cookie.length;
         return unescape( document.cookie.substring( y, endOfCookie ) );
      }
      x = document.cookie.indexOf( " ", x ) + 1;
      if ( x == 0 )
         break;
   }
   return "";
}


// 쿠키를 만듭니다.
function fSetCookie( name, value, expiredays ) 
{ 
   var todayDate = new Date(); 
   todayDate.setDate( todayDate.getDate() + expiredays ); 
   document.cookie = name + "=" + escape( value ) + "; path=/; expires=" + todayDate.toGMTString() + ";" 
} 


/********************************** Html Element Value Check Function ******************/

/*
   내    용 : 숫자 Tag값을 체크.
   파라미터 : pElement - html tag
              pLabel - html tag 타이틀
              pNull - 널허용여부              
   Return값 : TRUE or FALSE
*/
function fCheckNumberTag(pElement,pLabel,pNull){
   if(pNull){
        if(pElement.value.length > 0){
            if(!fCheckNumber(pElement.value)){ 
                alert( "\"" + pLabel + "\"은(는) 숫자 또는 정수형식이 아닙니다.");
                fMoveFocus(pElement);
                return false;
            }
        }
    }else{
        if(pElement.value.length < 1){
            alert("\"" + pLabel + "\"을(를) 입력하세요!");
            fMoveFocus(pElement);
            return false;    
        }else{
            if(!fCheckNumber(pElement.value)){ 
                alert( "\"" + pLabel + "\"은(는) 숫자 또는 정수형식이 아닙니다.");
                fMoveFocus(pElement);
                return false;
            }
        }    
    }
    return true;
}
/*
   내    용 : 문자 Tag값을 체크.
   파라미터 : pElement - html input tag
              pLabel - html tag 타이틀
              pNull - 널허용여부              
              pMaxLength - 최대문자허용길이
   Return값 : TRUE or FALSE
*/
function fCheckStringTag(pElement,pLabel,pNull,pMaxLength){
    if(pNull){
        if( pElement.value.length > 0){
            if( typeof(pMaxLength)=="number" && !fCheckByteSize(pElement.value,pMaxLength) ) { 
                alert( "\"" + pLabel + "\"에 저장할 수 있는 글자수보다 많습니다.\n\"" + pLabel + "\"을(를) 입력하세요!");
                fMoveFocus(pElement);
                return false;
            }
        }
    }else{
        if( pElement.value.length < 1){
            alert("\"" + pLabel + "\"을(를) 입력하세요!");
            fMoveFocus(pElement);
            return false;
        }else{
            if( typeof(pMaxLength)=="number" && !fCheckByteSize(pElement.value,pMaxLength) ) {
                alert( "\"" + pLabel + "\"에 저장할 수 있는 글자수보다 많습니다.\n\"" + pLabel + "\"을(를) 입력하세요!");
                fMoveFocus(pElement);
                return false;
            }
        }
    }
    return true;
}


/*
   내    용 : Select Tag값을 체크.
   파라미터 : pElement - html select tag
              pLabel - html tag 타이틀
   Return값 : TRUE or FALSE
*/
function fCheckChooseTag(pElement,pLabel) {
    if( pElement.value.length < 1){
        alert("\"" + pLabel + "\"을(를) 선택하세요!");
        fMoveFocus(pElement);
        return false;
    }
    return true;
}



/*
   내    용 : 날짜 Tag값을 체크.
   파라미터 : pElement - html tag
              pLabel - html tag 타이틀
              pNull - 널허용여부              
   Return값 : TRUE or FALSE
*/
function fCheckDateTag(pElement,pLabel,pNull){
   if(pNull){
        if(pElement.value.length > 0){
            if(!fCheckDate(pElement.value)){ 
                alert( "\"" + pLabel + "\"은(는) 19900101 ~ 21001230 까지 입력할 수 있습니다.");
                fMoveFocus(pElement);
                return false;
            } else {
               pElement.value = fCompleteDate(pElement.value);
               fAddDateSlash(pElement);
            }
        }
    }else{
        if(pElement.value.length < 1){
            alert("\"" + pLabel + "\"을(를) 입력하세요!");
            fMoveFocus(pElement);
            return false;    
        }else{
            if(!fCheckDate(pElement.value)){ 
                alert( "\"" + pLabel + "\"은(는) 19900101 ~ 21001230 까지 입력할 수 있습니다.");
                fMoveFocus(pElement);
                return false;
            } else {
               pElement.value = fCompleteDate(pElement.value);
               fAddDateSlash(pElement);
            }
        }    
    }
    
    return true;
}

/*
   내    용 : 도-분-초 Tag값을 체크.
   파라미터 : pElement - html tag
              pLabel - html tag 타이틀
              pNull - 널허용여부              
   Return값 : TRUE or FALSE
*/
function fCheckAngleTag(pElement,pLabel,pNull){
   if(pNull){
        if(pElement.value.length > 0){
            if(!fCheckAngle(pElement.value)){ 
                alert( "\"" + pLabel + "\"은(는) \"도-분-초\"형식이 아닙니다.");
                fMoveFocus(pElement);
                return false;
            }
        }
    }else{
        if(pElement.value.length < 1){
            alert("\"" + pLabel + "\"을(를) 입력하세요!");
            fMoveFocus(pElement);
            return false;    
        }else{
            if(!fCheckAngle(pElement.value)){ 
                alert( "\"" + pLabel + "\"은(는) \"도-분-초\"형식이 아닙니다.");
                fMoveFocus(pElement);
                return false;
            }
        }    
    }
    return true;
}



/*
   내    용 : 실수 Tag값을 체크.
   파라미터 : pElement - html tag
              pLabel - html tag 타이틀
              pNull - 널허용여부              
              pMaxLength - 전체 최대 길이
              pPointLength - 소수점이하 최대 길이
   Return값 : TRUE or FALSE
*/
function fCheckDecimalTag(pElement,pLabel,pNull,pMaxLength,pPointLength){
   if(!pNull){
      if(pElement.value.length < 1){
         alert("\"" + pLabel + "\"을(를) 입력하세요!");
         fMoveFocus(pElement);
         return false; 
      }   
   }

   if(pElement.value.length > 0){
      if(!fCheckFloat(pElement.value)){ 
          alert( "\"" + pLabel + "\"은(는) 실수형식이 아닙니다.");
          fMoveFocus(pElement);
          return false;
      }
   }

   if ( pMaxLength != "undefinded" && pPointLength != "undefinded" ) {
      point = pElement.value.lastIndexOf(".");
      if (point > -1) {
         vTmp1 = pElement.value.substring( 0, point );
         vTmp2 = pElement.value.substring( point+1, pElement.value.length );
         pMaxLength = eval(pMaxLength) + 1;
      } else {
         vTmp1 = pElement.value;
         vTmp2 = "";
      }
      
      if ( vTmp1.length > ( eval(pMaxLength)-eval(pPointLength) ) ) {
         alert( "\"" + pLabel + "\"은(는) 소수점이상 " + (pMaxLength-pPointLength) + "자리까지만 입력이 가능합니다" );
         fMoveFocus(pElement);
         return false;
      }
   
      if ( vTmp2.length > eval(pPointLength) ) {
         alert( "\"" + pLabel + "\"은(는) 소수점이하 " + pPointLength + "자리까지만 입력이 가능합니다" );
         fMoveFocus(pElement);
         return false;
      }
   }
    
   return true;
}

/*
   내    용 : 금액 Tag값을 체크.
   파라미터 : pElement - html tag
              pLabel - html tag 타이틀
              pNull - 널허용여부              
   Return값 : TRUE or FALSE
*/
function fCheckMoneyTag(pElement,pLabel,pNull){
   var pMoney = fReplaceWord(pElement.value, ",", "");
   if(pNull){
        if(pMoney.length > 0){
            if(!fCheckFloat(pMoney)){ 
                alert( "\"" + pLabel + "\"은(는) 실수형식이 아닙니다.");
                fMoveFocus(pElement);
                return false;
            }
        }
    }else{
        if(pMoney.length < 1){
            alert("\"" + pLabel + "\"을(를) 입력하세요!");
            fMoveFocus(pElement);
            return false;    
        }else{
            if(!fCheckFloat(pMoney)){ 
                alert( "\"" + pLabel + "\"은(는) 실수형식이 아닙니다.");
                fMoveFocus(pElement);
                return false;
            }
        }    
    }
    return true;
}

/*
   내    용 : Boolean Tag값을 체크.
   파라미터 : pElement - html select tag
              pLabel - html tag 타이틀
   Return값 : TRUE or FALSE
*/
function fCheckBooleanTag(pElement,pLabel) {
    if( pElement.value.length < 1){
        alert("\"" + pLabel + "\"을(를) 선택하세요!");
        fMoveFocus(pElement);
        return false;
    }
    return true;
}

/*
   내    용 : radio, checkbox Tag값을 체크.
   파라미터 : pElement - html select tag
              pLabel - html tag 타이틀
   Return값 : TRUE or FALSE
*/
function fCheckRadioTag(pElement,pLabel) {
    var bChk = false;
    
    if(typeof(pElement)=="undefined") return false;
    
    if(pElement.checked) bChk = true;
    
    for(i=0; i<pElement.length; i++)
        if(pElement[i].checked) bChk = true;

    if(!bChk && typeof(pLabel)!="undefined")
        alert("\"" + pLabel + "\"을(를) 선택하세요!");

    return bChk;

}


/***************************************태그액션**************************************************
/*
	내    용 : 체크박스 전체선택, 선택해제
	파라미터 : pFormName - html form 객체
	          pListTr - html list tr 객체
	          pCheckboxName - html checkbox 객체
	            
	Return값 : 없음;
*/ 
function fCheckAll(pElement,pTargetElement,pListTr) {
	if(typeof(pTargetElement) != "object") return;

    if(typeof(pTargetElement.length) == "number") {
    	for (i=0; i<pTargetElement.length; i++) {
    		pTargetElement[i].checked = pElement.checked;
    		if( typeof(pListTr) != "undefined" ) {
    		   if(pElement.checked) cc(eval(pListTr)[i],'#efe3de');
    		   else  cc(eval(pListTr)[i],'#efebef');
    		}
    	} 
    
    } else {
        pTargetElement.checked = pElement.checked;
		if( typeof(pListTr) != "undefined" ) {
		   if(pElement.checked) cc(eval(pListTr),'#efe3de');
		   else  cc(eval(pListTr),'#efebef');
		}
    }
    	
}

/*
내    용 : 라디오버튼이나 체크박스에 해당하는 값을 넘기면 해당하는 값을 선택한다
파라미터 : pElement - 선택할 Element
           pValue - 선택할 값
*/
function fSetChecked(pElement, pValue)
{
    if (pElement.length > 0) {
        for(var i=0; i<pElement.length; i++) {
            if ( pElement[i].value == pValue ) pElement[i].checked = true;
        }
    } else {
        if ( pElement.value == pValue ) pElement.checked = true;
    }
}

/*
내    용 : 숫자만 입력가능한 태그로 만든다.
파라미터 : pElement  - 적용할 Element
*/
function fEnableNumberTag(pElement)
{
    var enabletxt = "1234567890-."; //사용가능한 문자
    
    var targettxt = pElement.value;
    var targetlen = targettxt.length;
    var returntxt = "";
    var point = -1;
    
    for(i=0; i<targetlen; i++) {
        if(enabletxt.indexOf(targettxt.charAt(i))>=0) {
            if(targettxt.charAt(i)=='-' && i>0) {
            } else if( targettxt.charAt(i)=='.' && point<0 ) {
                returntxt += targettxt.charAt(i);
                point = i;
            } else if( targettxt.charAt(i)=='.' && point>0 ) {
            } else {
                returntxt += targettxt.charAt(i);
            }
        }
    }
    
    pElement.value = returntxt;
}

function NewWin(addr)
{
	NewWindow=window.open(addr, 'newwindow', 'width=817,height=600,toolbar=no ,directories=no,status=no,scrollbars=yes,resize=no,menubar=no');
}
function NewWin2(addr)
{
	NewWindow=window.open(addr, 'newwindow', 'width=975,height=762');
}