<!--
    /** Date 구분자 **/
    var DATE_SEPERATOR = "/";
    /** 대표번호 구분자 **/
    var NO_SEPERATOR = "-";
    /** FOMR CONTROL - INIT */
    var INIT     = 0;
    /** FOMR CONTROL - SELECT */
    var SELECT   = 1;
    /** FOMR CONTROL - INSERT */
    var INSERT   = 2;
    /** FOMR CONTROL - UPDATE */
    var UPDATE   = 3;
    /** FOMR CONTROL - DELETE */
    var DELETE   = 4;
    /** FOMR CONTROL - PRINT */
    var PRINT    = 5;
    /** FOMR CONTROL - VIEW */
    var VIEW     = 6;
    /** FOMR CONTROL - SEARCH */
    var SEARCH   = 7;
    /** FOMR CONTROL - DEFAULT COMMAND 01 ~ 10 */
    var COMMAND01 = 11;
    var COMMAND02 = 12;
    var COMMAND03 = 13;
    var COMMAND04 = 14;
    var COMMAND05 = 15;
    var COMMAND06 = 16;
    var COMMAND07 = 17;
    var COMMAND08 = 18;
    var COMMAND09 = 19;
    var COMMAND10 = 20;

    /*= COMMON CONTROL ===========================================================

        1. 일반적으로 obj tag와 관계없이 사용되는 기능.
        2. Function List
            - openWindow(theURL, winName, features)
            : 새창 열기
            - alertConfirm(message)
            : 사용자의 의사결정을 포함하는 메세지박스 표시
            - alertFocus(element, message)
            : 메세지를 알리는 메세지박스 표시 후 Element에 지정된 obj tag 로 focus
            - showErrMessage(message)
            : 서버 프로그램에서 생긴 ERROR 를 보여주는 MESSAGEBOX ALERT
            - manyElementsSameFuction(strEventName , EventArgument1 , EventArgument2 ....
            : 여러개의 object들을 같은 함수로 동시에 처리하고 싶을때 쓴다.
            - decimalRound(str1,str2)
            : 소수점을 지닌 문자열을 반올림한다, 첫번째 매개변수를 받아 두번째 매개변수의 자리에서 반올림하는 함수

    ============================================================================*/


		function showErrMessage(message) {
		    if (message !="" ) {
				 alert(message);
			}
			return;
		}


    /**
      * 새창열기
      *  window.open 에서 사용되는 방식으로 features 설정
      * @param theURL    새창의 Url
      * @param winName   새창의 name
      * @param features  새창의 세부 설정
      * @return
     */
    function openWindow(theURL,winName,features) {
        window.open(theURL,winName,features);
    }

    /**
      * 메세지를 알리는 메세지박스 표시
      * @param message   메세지박스에 보여질 메세지
      * @return
     */
    function Alert(message)
    {
        var iLen = message.length;
    	if (iLen >= 1)
    	{
    		alert(message);
    	}
    }

    /**
      * 사용자의 의사결정을 포함하는 메세지박스 표시
      * @param message   메세지박스에 보여질 메세지
      * @return 1 : 확인,  0 : 취소
     */
    function alertConfirm(message) {
        if(confirm(message)==1) {
            return 1;
        } else {
            return 0;
        }
    }

    /**
      * 메세지를 알리는 메세지박스 표시 후 Element에 지정된 obj tag 로 focus
      * @param obj   focus 를 가질 Object
      * @param message   메세지박스에 보여질 메세지
      * @return
     */
    function alertFocus(obj, message )
    {
       if ( message != '') alert( message );
       obj.focus();
       if (obj.type == 'text' && obj.value.length >=1 ) obj.focus();
       return;
    }

    /**
     * 서버 프로그램에서 생긴 ERROR 를 보여주는 MESSAGEBOX ALERT
     * @param message   메세지박스에 보여질 메세지
     * @return
     */
    function showErrMessage(message)
    {
        var iLen = message.length;
        var showMessage;
        if (iLen >= 1)
        {
            showMessage=replaceStr(message,"<||>","\n");
            alert(showMessage);
        }
    }

    /**
     * 서버 프로그램에서 생긴 성공메세지를 보여주는 MESSAGEBOX ALERT
     * @param message   메세지박스에 보여질 메세지
     * @return
     */
    function showSuccessMessage(message)
    {
        var iLen = message.length;
        if (iLen >= 1)
        {
            alert(message);
        }
    }

    /*
     * 여러개의 input과 같은 object들을 같은 이벤트로 동시에 처리하고 싶을때 쓴다.
     * 가령 그 필드에 focus가 들어갈시 한글로 시작하게하는 onLoadHangul을 쓰고 싶을때면
     * 다음처럼 이벤트명과 오브젝트를 호출한다.
     *
     * manyElementsSameFuction( strEventName , EventArgument1 , EventArgument2 .... )
     *
     * 호출예 : manyElementsSameFuction("onLoadHangul",frm.CONT_NAME,frm.ISD_NAME);
     * @param strEventName 공통으로 적용되어야할 함수명 , EventArgument1 오브젝트 , ...
     * @return
     */
    function    manyElementsSameFuction() {
        var obj_receiver,sEvent;
        obj_receiver=manyElementsSameFuction.arguments;

        for(i=1; i< obj_receiver.length; i++) {
            sEvent = obj_receiver[0];
            if (obj_receiver[i] != "") {
                sEvent += "(" +  "obj_receiver[" + i + "]" + ");";
                eval(sEvent) ;
            }
        }
    }

    /*
     * 함수명 : debugSubmit()
     * 내  용 : debugSubmit() 는 element가 어떤 value를 전송하는지를 볼수있다
     * Event  : 해당사항없음
     * 인자값 : 없음
     * 작성자 : 한성환
     * Version: 1.0
     *
     * 호출예 : debug_submit();
     *
     */

    function debugSubmit(){

        	  var strTemp;
    	  var i,j;
    	  var mForm;
    	  var iForms = document.forms.length;

    	  for(j=0; j<iForms; j++) {
    		mForm = document.forms[j];
          	  		for(i=0; i< mForm.elements.length; i++) {
    				strTemp +=  mForm.elements[i].name;
    				strTemp +=  " = ";
    				strTemp +=  mForm.elements[i].value;
    	        		strTemp +=  "\n";
    	        	}
    	  }
    	  alert(strTemp);
    }
    /*
     * 함수명 : debugSubmit2()
     * 내  용 : form이 어떤 element들을 전송하는지를 볼수가 있다.
     * Event  : 해당사항없음
     * 인자값 : 없음
     * 작성자 : 한성환
     * Version: 1.0
     *
     * 호출예 : debugSubmit2();
     *
     */
    function debugSubmit2(){

        	  var strTemp;
    	  var i,j;
    	  var mForm;
    	  var iForms = document.forms.length;

    	  for(j=0; j<iForms; j++) {
    		mForm = document.forms[j];
          	  		for(i=0; i< mForm.elements.length; i++) {
    				alert(mForm.elements[i].type);
    				strTemp +=  mForm.elements[i].name;
    				strTemp +=  " = ";
    				strTemp +=  mForm.elements[i].value;
    	        		strTemp +=  "\n";
    	        	}
    	  }
    	  alert(strTemp);
    }

    /*
     * 함수명 : decimalRound()
     * 내  용 : 소수점을 지닌 문자열을 반올림한다, 첫번째 매개변수를 받아 두번째 매개변수의 자리에서 반올림하는 함수
     * Event  : 해당사항없음
     * 인자값 : '소수점을 지닌 문자열', '소수점몇자리까지 자르는지 여부'
     * 작성자 : 한성환
     * Version: 1.0
     *
     * 호출예 : var test = decimalRound('13.145592',3);
     *
     */
    function decimalRound(str1,str2){
          var s='0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';
          var idx=String(str1).indexOf('.');
          var b=String(str1).substr(0,idx+str2+1);
          if(parseInt(b.charAt(b.length-1))>=5){
               c=Number(b.substr(0,b.length-1))+Number(s.substr(0,str2)+1);
          } else {
               c=b.substr(0,b.length-1);
          }
          return c;
    }


    /*= FORM CONTROL =============================================================

        1. 폼 관련 기본 기능을 처리.
        2. Function List
            - chkLen(Object, Int)
            : 입력 받은 폼태그(Object)의 문자열의 길이가 특정 길이(Int)와 같은지 여부 체크
              true - 길이가 같음
              false - 길이가 다름
            - chkLenMoveFocus(Object, Int, Object)
            : 입력 받은 폼태그(Object)의 문자열의 길이가 특정 길이(Int) 이면
              다른 객체(Object)로 포커스를 이동
            - setFocus(Object)
            : 입력 받은 객체로 포커스 이동
            - chkLenByByte(Object, int)
            : 입력 필드의 문자 크기를 한정시킬때.. (한글까지 고려하여 계산됨)
              ex) onBlur="return fnLessEqualLen(this, len);"
            - getLenByByte(String)
            : 입력 필드의 문자 크기를 얻는다.. (한글까지 고려하여 계산됨)
            - disableObject(Object)
            : 대상 Object를 disable 시킨다.
            - enableObject(Object)
            : 대상 Object를 enable 시킨다.
            - disableManyObjects(Object,.......)
            : 입력되어진 변수의 수만큼 disableObject function 수행, 개수는 상관없음
            - enableManyObjects(Object,........)
            : 입력되어진 변수의 수만큼 enableObject function 수행, 개수는 상관없음
            - hideElement(Object)
            : 입력되어진 Object 들을 display = "none" 시킨다.
            - showElement(Object)
            : 입력되어진 Object 들을 display = "" 시킨다.
            - manyElementsHide(Object,.........)
            : 입력되어진 Object 들을 모두  display = "none" 시킨다, 개수는 상관없음
            - manyElementsShow(Object,.........)
            : 입력되어진 Object 들을 모두  display = "" 시킨다, 개수는 상관없음
            - clearObject(Object)
            : 대상 Object의 value값을 초기화 시킨다.
            - clearManyObjects(Object,.........)
            : 입력되어진 변수의 수만큼 clearObject function 수행, 개수는 상관없음
            - setupEnterKeyNextFocus(FORM)
            : Enter Key를 눌렀을때 다음 엘리먼트로 넘어가는 tab과 같은 역할을 하기위한 사전작업
            - enterKeyNextFocus()
            : Enter Key를 눌렀을때 다음 엘리먼트로 넘어가는 tab과 같은 역할을 하는 함수
            - enterKeyMaxLengthNextFocus()
            : Enter Key를 눌렀을때 다음 엘리먼트로 넘어가는 tab과 같은 역할을 하는 함수, maxlength로 다음 오브젝트로 자동 전송
            - onLoadHangu(Object)
            : linput tag가 최초로 focus를 받았을때 한글 입력모드가 되게함

    ============================================================================*/

    /**
      * 입력 받은 폼태그(Object)의 문자열의 길이가 특정 길이(Int)와 같은지 여부 체크
      * @param obj   대상 폼태그(Object)
      * @param len   비교할 길이
      * @return  true : 길이가 같음, false : 길이가 다름
     */
    function chkLen(obj, len) {
        if (obj.value.length == len) return true;
        return false;
    }

    /**
      * 입력 받은 폼태그(Object)의 문자열의 길이가 특정 길이(Int) 이면
      * 다른 객체(Object)로 포커스를 이동
      * @param obj   대상 폼태그(Object)
      * @param len   비교할 길이
      * @param dest  포커스를 이동할 폼태그(Object)
      * @return
     */
    function chkLenMoveFocus(obj, len, dest) {
        if (obj.value.length == len)
        setFocus(dest);
    }

    /**
      * 입력 받은 객체로 포커스 이동
      * @param obj   포커스를 이동할 폼태그(Object)
      * @return
     */
    function setFocus(obj) {
        obj.focus();
    }

    /**
      * 입력 필드의 문자 크기를 한정시킬때.. (한글까지 고려하여 계산됨)
      * @param obj   대상 폼태그(Object)
      * @param len   비교할 길이
      * @return
     */
    function chkLenByByte(obj, len)
    {
        var src    = obj.value;
        var srcLen = getLenByByte(src);
        if (srcLen <= len) return true;
        var delLen = srcLen - len;
        obj.focus();
        Alert("이 항목은 영문 " + len + "자 (한글은 " + Math.floor(len/2) + "자) 까지만 입력해야 합니다 \n"
            +  "입력 내용에서 영문 " + delLen + "자 (한글은 " + Math.ceil(delLen/2) + "자)를 제거하시기 바랍니다");
        return false;
    }

    /**
      * 입력 필드의 문자 크기를 얻는다.. (한글까지 고려하여 계산됨)
      * @param String   문자열
      * @return int 문자열의 길이
     */
    function getLenByByte(value)
    {
        var byteLength = 0;
        for (var inx = 0; inx < value.length; inx++) {
            var oneChar = escape(value.charAt(inx));
            if ( oneChar.length == 1 ) {
                byteLength ++;
            } else if (oneChar.indexOf("%u") != -1) {
                byteLength += 2;
            } else if (oneChar.indexOf("%") != -1) {
                byteLength += oneChar.length/3;
            }
        }
        return byteLength;
    }

    /**
      * 대상 Object를 disable 시킨다.
      * @param  obj   대상 폼태그(Object)
      * @return
     */
    function disableObject(obj)
    {
        switch( obj.type ) {
            case "button" :
		    case "select-one" :
		    case "textarea" :
		    case "radio" :
		    case "option" :
		    case "checkbox" :
                 obj.disabled = true;
                 break;
            case "password" :
            case "text" :
                 obj.readOnly=true;
                 obj.style.backgroundColor = "#efefef";
                 obj.style.color = "#555555";
                 break;
            default:
        }
    }

    /**
      * 대상 Object를 enable 시킨다.
      * @param obj   대상 폼태그(Object)
      * @return
     */
    function enableObject(obj)
    {
        switch( obj.type ) {
            case "button" :
		    case "select-one" :
		    case "textarea" :
		    case "radio" :
		    case "option" :
            case "checkbox" :
                 obj.disabled = false;
                 break;
            case "password" :
            case "text" :
                 obj.readOnly=false;
                 obj.style.backgroundColor = "#ffffff";
                 obj.style.color = "#000000";
                 break;
            default:
        }
    }

    /**
     * 입력되어진 변수의 수만큼 disableObject function 수행.
     * 입력되어진 Object 들을 모두 disable 시킨다.
     * 호출예 : disableManyObjects(haengwon_no, name, center_section_code);
     * @param obj   대상 폼태그(Object)
     * @param obj   대상 폼태그(Object)
     *  :
     */
    function disableManyObjects() {
        var obj_receiver;
        obj_receiver = disableManyObjects.arguments;
        for(i=0; i< obj_receiver.length; i++) {
            if (obj_receiver[i] != "") {
                disableObject(obj_receiver[i]);
            }
        }
    }

    /**
     * 입력되어진 변수의 수만큼 enableObject function 수행.
     * 입력되어진 Object 들을 모두 enable 시킨다.
     * 호출예 : enableManyObjects(haengwon_no, name, center_section_code);
     * @param obj   대상 폼태그(Object)
     * @param obj   대상 폼태그(Object)
     *  :
     */
    function enableManyObjects() {
        var obj_receiver;
        obj_receiver = enableManyObjects.arguments;
        for(i=0; i< obj_receiver.length; i++) {
            if (obj_receiver[i] != "") {
                enableObject(obj_receiver[i]);
            }
        }
    }

    /**
     * 입력되어진 Object 들을 display = "none" 시킨다.
     * 호출예 : hideElement(systemCode);
     * @param obj   대상 폼태그(Object)
     *  :
     */
    function	hideElement(obj) {
       obj.style.display = "none";
    }

    /**
     * 입력되어진 Object 들을 display = "" 시킨다.
     * 호출예 : showElement(systemCode);
     * @param obj   대상 폼태그(Object)
     *  :
     */
    function	showElement(obj) {
       obj.style.display = "";
    }

    /**
     * 입력되어진 변수의 수만큼 manyElementsHide function 수행.
     * 입력되어진 Object 들을 모두 display = "none" 시킨다.
     * 호출예 : manyElementsHide(haengwon_no, name, center_section_code);
     * @param obj   대상 폼태그(Object)
     * @param obj   대상 폼태그(Object)
     *  :
     */
    function	manyElementsHide() {
    	var obj_receiver;
     	obj_receiver=manyElementsHide.arguments;

    	for(i=0; i< obj_receiver.length; i++) {
    		if (obj_receiver[i] != "") {
    			hideElement(obj_receiver[i]);
    		}
    	}
    }

    /**
     * 입력되어진 변수의 수만큼 manyElementsShow function 수행.
     * 입력되어진 Object 들을 모두 display = "" 시킨다.
     * 호출예 : manyElementsHide(haengwon_no, name, center_section_code);
     * @param obj   대상 폼태그(Object)
     * @param obj   대상 폼태그(Object)
     *  :
     */
    function	manyElementsShow() {
    	var obj_receiver;
     	obj_receiver=manyElementsShow.arguments;

    	for(i=0; i< obj_receiver.length; i++) {
    		if (obj_receiver[i] != "") {
    			showElement(obj_receiver[i]);
    		}
    	}
    }

    /**
      * 대상 Object의 value값을 초기화 시킨다.
      * @param obj   대상 폼태그(Object)
      * @return
     */
    function clearObject(obj)
    {
        switch( obj.type ) {
            case "select-one" :
                 obj.selectedIndex='0';
            case "radio" :
		    case "checkbox" :
                 obj.checked=false;
                 break;
            case "text" :
            case "password" :
                 obj.readOnly=false;
                 obj.value="";
                 break;
            default:
        }
    }

    /**
     * 입력되어진 변수의 수만큼 clearObject function 수행.
     * 입력되어진 Object 들을 모두 clear 시킨다.
     * 호출예 : clearManyObjects(haengwon_no, name, center_section_code);
     * @param obj   대상 폼태그(Object)
     * @param obj   대상 폼태그(Object)
     *  :
     */
    function clearManyObjects() {
        var obj_receiver;
        obj_receiver = clearManyObjects.arguments;
        for(i=0; i< obj_receiver.length; i++) {
            if (obj_receiver[i] != "") {
                clearObject(obj_receiver[i]);
            }
        }
    }

    /**
     * Enter Key를 눌렀을때 다음 엘리먼트로 넘어가는 tab과 같은 역할을 하기위한 사전작업
     * 호출예 : setupEnterKeyNextFocus(document.form);
     * @param FORM 해당 form 오브젝트
     *  :
     */
    function    setupEnterKeyNextFocus(frm)
    {
        //alert("setNextFocus 시작");
        var i;
        for(i=0; i< frm.elements.length; i++) {
            if((frm.elements[i].type=="button")||(frm.elements[i].disabled)||(frm.elements[i].readOnly))
                        frm.elements[i].tabIndex=-1;
        }
    }

    /*
     * Enter Key를 눌렀을때 다음 엘리먼트로 넘어가는 tab과 같은 역할을 하는 함수
     * 이를 실행시키기 위해서는 페이지를 초기화할때 setEnterNextFocus(frm);를 호출해야한다.
     * 사용예>
     *  <SCRIPT LANGUAGE="javascript" FOR="document" EVENT="onkeydown">
     *  <!--
     *      enterKeyMaxLengthNextFocus();
     *  //-->
     *  </SCRIPT>
     *  ....
     *  <body .... onload="setEnterNextFocus(frm);" >
     * @param
     *  :
     */
    function    enterKeyNextFocus()
    {
        var keyCode = event.keyCode ? event.keyCode :
                    event.which ? event.which : event.charCode;
        // 엔터키(13)이면
        if (keyCode == 13) {
            window.event.keyCode = 9;
        }
    }

    /*
     * Enter Key를 눌렀을때 다음 엘리먼트로 넘어가는 tab과 같은 역할을 하는 함수
     *
     * 이를 실행시키기 위해서는 페이지를 초기화할때 setEnterNextFocus(frm);를 호출해야 하며
     * input tag 에 maxlength가 정의가 되어져 있어야 한다.
     * 사용예>
     *  <SCRIPT LANGUAGE="javascript" FOR="document" EVENT="onkeydown">
     *  <!--
     *      enterKeyMaxLengthNextFocus();
     *  //-->
     *  </SCRIPT>
     *  ....
     *  <body .... onload="setEnterNextFocus(frm);" >
     *  ....
     *  <input type="text" .... maxlength="4" .... >
     * @param
     *  :
     */
    function    enterKeyMaxLengthNextFocus(){
              var keyCode = event.keyCode ? event.keyCode : event.which ? event.which : event.charCode;
              var srcMaxLength=window.event.srcElement.getAttribute("maxlength");
              var srcValue=window.event.srcElement.getAttribute("value");

              if(srcValue!=null){

                  var srcValueLength=srcValue.length;

                  //Keycode가 37(왼쪽커서키)나 39(오른쪽커서키), 8(backspace)이나 46(delete) 이 아니면
                  //Tab Keycode로 바꾸어 다음 오브젝트로 포커스를 이동시켜야 한다.
                  if(srcMaxLength==srcValueLength){
                         if(!((keyCode==37)||(keyCode==39)||(keyCode==46)||(keyCode==8))){
                             window.event.keyCode = 9;
                             return;
                         }
                  }
                  // 엔터키(13)이면
                  if (keyCode == 13) {
                      window.event.keyCode = 9;
                  }


               }
    }

    /**
     * input tag가 최초로 focus를 받았을때 한글 입력모드가 되게함
     * 호출예 : onLoadHangul(Object);
     * @param Object
     *  :
     */
    function    onLoadHangul(element) {
                element.style.imeMode = "active";
    }


    /*= CHECKBOX/RADIO CONTROL ===========================================================

        1. CHECKBOX/RADIO 관련 기본 기능을 처리.
        2. Function List
            - togleCheckAll(Object, Object)
            : checkbox들을 반복하여 선택하거나 해지한다.
            - setAllCheckboxCancel(Object)
            : checkbox를 모두 해지한다.
            - setAllCheckboxCheck(Object)
            : checkbox를 모두 선택 표시한다.
            - isChecked(Object)
            : 리스트에서 하나이상의 체크박스가 선택되었는지 확인한다.
            - isCheckedOnlyOne(Object)
            : 리스트에서 하나의 체크박스만 선택되었는지 확인한다.
            - getRadioValue(oRadio)
            : 선택된 하나의 Radio Object Value를 반환
            - setRadioValue(oRadio,ObjectHidden);
            : 하나의 Radio Object 를 선택후 해제하고 싶은경우 사용,주의 히든필드가 함께 있어야함
    ============================================================================*/

    /**
      * 처음 obj가 선택되어진 경우 전체 checkObj를 선택하고
      * 해지되어진 경우 모두 해지한다.
      * @param obj   전체를 control하는 CHECKBOX 의 OBJECT
      * @param checkObj 해당 CHECKBOX
      * @return
     */
    function togleCheckAll(obj, checkObj) {
        if (!obj.checked) {
            setAllCheckboxCancel(checkObj);
        } else {
            setAllCheckboxCheck(checkObj);
        }
    }

    /**
      * CHECKBOX를 모두 해지한다.
      * @param obj   해당 CHECKBOX 의 OBJECT
      * @return
     */
    function setAllCheckboxCancel(obj){
        var count = obj.length;
        if(count > 1){
            for(var i=0;i<count;i++){
                obj[i].checked = false;
            }
         }else {
            obj.checked = false;
         }
         return;
    }

    /**
      * CHECKBOX를 모두 선택 표시한다.
      * @param obj   해당 CHECKBOX 의 OBJECT
      * @return
     */
    function setAllCheckboxCheck(obj){
        var count = obj.length;
        if(count > 1){
            for(var i=0;i<count;i++){
                obj[i].checked = true;
            }
         }else{
            obj.checked = true;
         }
         return;
    }

    /**
      * 리스트에서 하나이상의 체크박스가 선택되었는지 확인한다.
      * @param obj   해당 CHECKBOX 의 OBJECT
      * @return
     */
    function isChecked(obj){
        var count = obj.length;
        var iChecked = 0;
        if(count > 1){
            for(var i=0;i<count;i++){
                if (obj[i].checked) iChecked++;
            }
        } else {
            if (obj.checked) iChecked++;
        }
        if (iChecked == 0) {
            Alert("선택된 값이 없습니다");
            return false;
        }
        return true;
    }

    /**
      * 리스트에서 하나의 체크박스만 선택되었는지 확인
      * @param obj   해당 CHECKBOX 의 OBJECT
      * @return
     */
    function isCheckedOnlyOne(obj){
        var count = obj.length;
        if(count > 1){
            var iChecked = 0;
            for(var i=0;i<count;i++){
                if (obj[i].checked) iChecked++;
            }
            if (iChecked > 1) {
                Alert("하나만 선택하십시오");
                return false;
            }
         }
         return true;
    }

   /*
    * 선택된 하나의 Radio Object Value를 반환
    * @param     oRadio : object Radio
    * @return    String
    */
   function getRadioValue(oRadio)
   {
    if (oRadio == null) return "";

    if (oRadio.length != null)
    {
        for(i=0; i<oRadio.length; i++)
        {
            if (oRadio[i].checked) return oRadio[i].value;
        }
    } else  {
        if (oRadio.checked) return oRadio.value;
    }
    return "";
   }

    /*
     * 하나의 Radio Object 를 선택후 해제
     * <INPUT NAME="radioChk<%=i%>" TYPE="hidden" VALUE="DEFAULT">와 같은 상태저장 히든값이 필요함
     * @param     oRadio : object Radio
     * @param     radioChk : object Input Hidden
     * @return
     */
    function setRadioValue(oRadio, radioChk)
    {

       if (oRadio == null) return "";
       var chkGubun=radioChk.value;
       if(chkGubun!="DEFAULT"){
           if (oRadio.length != null) {
               for(i=0; i<oRadio.length; i++) {
                   if (chkGubun==oRadio[i].value)
                    oRadio[i].checked=false;
               }
           }
       }
       radioChk.value = getRadioValue(oRadio);
    }


    /*= TEXT INPUT VALUE CONTROL ===========================================================

        1. 문자열 관련 기본 기능을 처리.
        2. Function List
            - isNull(Object)
            : 입력값이 NULL인지 체크
            - isEmpty(Object)
            : 입력값이 공백인지 확인하여 리턴
            - removeSpaces(Value)
            : 입력값에 포함된 모든 스페이스 문자를 제거 후 리턴
            - replaceStr(str, find, replace)
            : 문자열에 포함된 모든 변환대상 패턴을 변경하여 리턴
            - containsChars(Object)
            : 입력값에 특정 문자(chars)가 있는지 체크. 특정 문자를 허용하지 않으려 할 때 사용
            - containsCharsOnly(Object)
            : 입력값이 특정 문자(chars)만으로 되어있는지 체크
            - isKorean(Object)
            : 입력값이 한글인지 체크
            - isAlphabet(Object)
            : 입력값이 알파벳인지 체크
            - isUpperCase(Object)
            : 입력값이 알파벳 대문자인지 체크
            - isLowerCase(Object)
            : 입력값이 알파벳 소문자인지 체크
            - isNumber(Object)
            : 입력된 문자열이 숫자 만을 포함하고 있는지 여부 리턴
            - isAlphaNum(Object)
            : 입력값이 알파벳,숫자로 되어있는지 체크
            - isNumDash(Object)
            : 입력값이 숫자,대시(-)로 되어있는지 체크
            - isNumComma(Object)
            : 입력값이 숫자,콤마(,)로 되어있는지 체크
            - isNumPeriod(Object)
            : 입력값이 숫자,날짜 구분자(.)로 되어있는지 체크
            - isMoney(Object)
            : 입력값이 숫자,소숫점(.),숫자구분자(,)로 되어있는지 체크
            - isEmailAddr(Object)
            : 입력값이 이메일을 구성할 수 있는 문자들로 구성되어 있는지 단순체크
            - isNumberMessage(Object)
            : 입력된 문자열이 숫자 만을 포함하고 있는지 여부 리턴,오류가 있을 경우 메세지를 표시하고 focus 이동

    ============================================================================*/

    /**
     * 입력값이 NULL인지 체크
     * @param obj   Object
     * @return true : Null 또는 공백
     */
    function isNull(obj) {
        if (obj.value == null || obj.value == "") {
            return true;
        }
        return false;
    }

    /**
     * 입력값에 스페이스 이외의 의미있는 값이 있는지 체크
     * @param obj   Object
     * @return true : 공백
     */
    function isEmpty(obj) {
        if (obj.value == null || obj.value.replace(/ /gi,"") == "") {
            return true;
        }
        return false;
    }

    /**
     * 입력값에 포함된 모든 스페이스 문자를 제거 후 리턴
     * @param str   Value
     * @return ret  스페이스가 제거된 문자열
     */
    function removeSpaces(str) {
        var ret = "";
        if (str.length == 0) return ret;

        for (var i=0; i<str.length; i++) {
            if (str.charAt(i) != " ") ret += str.charAt(i);
        }
        return ret;
    }

    /**
     * 문자열에 포함된 모든 변환대상 패턴을 변경하여 리턴
     * @param str   문자열
     * @return ret  변경된 문자열
     */
    function replaceStr(str, find, replace)
    {
        var pos = 0;
        pos = str.indexOf(find);

        while(pos != -1)
        {
            pre_str = str.substring(0, pos);
            post_str = str.substring(pos + find.length, str.length);
            str = pre_str + replace + post_str;
            pos = str.indexOf(find);
        }
        return str;
    }

    /**
     * 입력값에 특정 문자(chars)가 포함되지 않았는지 체크
     * 특정 문자를 허용하지 않으려 할 때 사용
     * ex) if (containsChars(form.name,"!,*&^%$#@~;")) {
     *         Alert("이름 필드에는 특수 문자를 사용할 수 없습니다.");
     *     }
     * @param obj   Object
     * @return true 특정 문자가 없을 경우
     */
    function containsChars(obj,chars) {
        for (var inx = 0; inx < obj.value.length; inx++) {
           if (chars.indexOf(obj.value.charAt(inx)) != -1)
               return true;
        }
        return false;
    }

    /**
     * 입력값이 특정 문자(chars)만으로 되어있는지 체크
     * 특정 문자만 허용하려 할 때 사용
     * ex) if (!containsCharsOnly(form.blood,"ABO")) {
     *         Alert("혈액형 필드에는 A,B,O 문자만 사용할 수 있습니다.");
     *     }
     * @param obj   Object
     * @return true 특정 문자가 있을 경우
     */
    function containsCharsOnly(obj,chars) {
        for (var inx = 0; inx < obj.value.length; inx++) {
           if (chars.indexOf(obj.value.charAt(inx)) == -1)
               return false;
        }
        return true;
    }

    /**
     * 입력값이 한글인지 체크
     * @param obj   Object
     * @return true 한글인 경우
     */
    function isKorean(obj)
    {
        if ((obj.value.length*2) == getLenByByte(obj.value)) return true;
        return false;
    }

    /**
     * 입력값이 알파벳인지 체크
     * @param obj   Object
     * @return true 알파벳일 경우
     */
    function isAlphabet(obj) {
        var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        return containsCharsOnly(obj,chars);
    }

    /**
     * 입력값이 알파벳 대문자인지 체크
     * @param obj   Object
     * @return true 알파벳 대문자인 경우
     */
    function isUpperCase(obj) {
        var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        return containsCharsOnly(obj,chars);
    }

    /**
     * 입력값이 알파벳 소문자인지 체크
     * @param obj   Object
     * @return true 알파벳 소문자인 경우
     */
    function isLowerCase(obj) {
        var chars = "abcdefghijklmnopqrstuvwxyz";
        return containsCharsOnly(obj,chars);
    }

    /**
      * 입력된 문자열이 숫자 만을 포함하고 있는지 여부 리턴
      * @param obj   Object
      * @return true - 숫자만을 포함하고 있는 경우
     */
    function isNumber(obj) {
        var chars = "0123456789";
        return containsCharsOnly(obj,chars);
    }

    /**
     * 입력값이 알파벳,숫자로 되어있는지 체크
     * @param obj   Object
     * @return true 알파벳,숫자로 되어있는 경우
     */
    function isAlphaNum(obj) {
        var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        return containsCharsOnly(obj,chars);
    }

    /**
     * 입력값이 숫자,대시(-)로 되어있는지 체크
     * @param obj   Object
     * @return true 숫자,대시(-)로 되어있는 경우
     */
    function isNumDash(obj) {
        var chars = "-0123456789";
        return containsCharsOnly(obj,chars);
    }

    /**
     * 입력값이 숫자,콤마(,)로 되어있는지 체크
     * @param obj   Object
     * @return true 숫자,콤마(,)로 되어있는 경우
     */
    function isNumComma(obj) {
        var chars = ",0123456789";
        return containsCharsOnly(obj,chars);
    }

    /**
     * 입력값이 숫자,날짜 구분자(/)로 되어있는지 체크
     * @param obj   Object
     * @return true 숫자,날짜 구분자(.)로 되어있는 경우
     */
    function isNumPeriod(obj) {
        var chars = "/0123456789";
        return containsCharsOnly(obj,chars);
    }

    /**

     * 입력값이 숫자,소숫점(.),숫자구분자(,)로 되어있는지 체크
     * @param obj   Object
     * @return true 숫자,날짜 구분자(.)로 되어있는 경우
     */
    function isMoney(obj) {
        var chars = ".,0123456789";
        return containsCharsOnly(obj,chars);
    }

    /**
     * 입력값이 이메일을 구성할 수 있는 문자들로 구성되어 있는지 체크
     * 단순한 이메일 입력포맷을 확인한다.
     * @param obj   Object
     * @return true 이메일 구성이 가능한 문자들로 구성되어 있을 경우
     */
    function isEmailAddr(obj) {
        var format = /^((\w|[\-\.])+)@((\w|[\-\.])+)\.([A-Za-z]+)$/;
        return isValidFormat(obj, format);
    }

    /**
      * 입력된 문자열이 숫자 만을 포함하고 있는지 여부 리턴
      * 오류가 있을 경우 메세지를 표시하고 focus 이동
      * @param obj   Object
      * @return true - 숫자만을 포함하고 있는 경우
     */
    function isNumberMessage(obj) {
        if (!isNumber(obj)) {
            alertFocus(obj, '숫자만 입력하십시오');
            return false;
        }
        return true;
    }

    /*= NUMBER CONTROL ===========================================================

        1. 숫자 관련 기본 기능을 처리.
        2. Function List
            - addComma(Object)
            : 입력값을 콤마가 포함된 문자열로 변환하여 리턴
              12345 를 입력하면 12,345 로 변환하여 리턴
            - removeComma(String)
            : 입력값에서 콤마를 없앤다.
            - removeDash(String)
            : 입력값에서 구분자(-)를 없앤다.
            - removePeriod(String)
            : 입력값에서 날짜 구분자(/ - , . ; :) 를 없앤다.
            - parseInt2(str)
            : 문자열을 정수로 변환하여 리턴
            - removeSeparator(Object)
            : 문자열에서 / - , . ; : 등을 제거하고 value 에 값넣어줌

    ============================================================================*/

    /**
      * 입력값을 콤마가 포함된 문자열로 변환하여 리턴
      * @param obj   숫자
      * @return ret  콤마를 추가한 숫자
     */
    function addComma(obj) {
        var ret;
        if (!isMoney(obj)) {
            alertFocus(obj, "숫자만 입력하십시오.");
            return;
        }
        var numstr = obj.value;
        numstr = removeComma(numstr);
        var rxSplit = new RegExp('([0-9])([0-9][0-9][0-9][,.])');
        var arrNumber = numstr.split('.');
        arrNumber[0] += '.';
        do {
            arrNumber[0] = arrNumber[0].replace(rxSplit, '$1,$2');
        }
        while (rxSplit.test(arrNumber[0]));
        if (arrNumber.length > 1) {
            ret = arrNumber.join('');
        } else {
            ret = arrNumber[0].split('.')[0];
        }
        obj.value = ret;
    }

    /**
     * 입력값에서 콤마를 없앤다.
     * @param str   문자열
     * @return 변경된 문자열
     */
    function removeComma(str) {
        return str.replace(/,/gi,"");
    }

    /**
     * 입력값에서 구분자(-)를 없앤다.
     * @param str   문자열
     * @return 변경된 문자열
     */
    function removeDash(str) {
        return str.replace(/-/gi,"");
    }

    /**
     * 입력값에서 날짜 구분자(.)를 없앤다.
     * @param str   문자열
     * @return 변경된 문자열
     */
    function removePeriod(str) {
        //return replaceStr(str, '.', '');
        return str.replace(/\/|\-|\.|\,|\;|\:/g,"");
    }

    /**
      * 문자열을 정수로 변환하여 리턴
      * @param str   문자열
      * @return 정수
     */
    function parseInt2(str) {
        return parseInt(str, 10);
    }

    /**
     * 입력값에서 구분자(-)를 없앤다.
     * @param str   문자열
     * @return 변경된 문자열
     */
    function removeSeparator(obj) {
        var objvalue = obj.value;
        objvalue = objvalue.replace(/\/|\-|\.|\,|\;|\:/g,"");

        obj.value= objvalue;
    }


    /*= DATETIME CONTROL ===========================================================

        1. 일자와 시간 관련 기본 기능을 처리.
        2. Function List
            - isDate(Object)
            : 입력값을 일자 Format 인지 확인
            - isValidYYYY(Object)
            : 입력된 문자열이 일자 Format YYYY이 맞는지를 확인
            - isValidYYYYMM(Object)
            : 입력된 문자열이 일자 Format YYYYMM이 맞는지를 확인
            - isValidYYMMDD(Object)
            : 입력된 문자열이 일자 Format YYMMDD이 맞는지를 확인
            - isMonth(month)
            : 입력된 문자열이 일자의 월로 변환가능한지 확인
            - isDay(year, month, day)
            : 입력된 문자열이 일자의 일로 변환가능한지 확인
            - getEndDay(year, month)
            : 해당 년, 월의 마지막 일자를 가져온다
            - addDateSeperator(Object)
            : 입력값에 일자 형식에 맞추어 DATE_SEPERATOR 를 추가한다.
            - getDaysBetween(fromObj, toObj)
            : 처음 Object와 두번째 Object 사이의 일자를 반환한다.이경우에 두번째 Object가 처음 Object 보다 나중 일자이다.
            - getDaysToToday(Object)
            : 오늘까지 남은 일수를 반환한다. 오늘 이후의 일자에 대해서는 음수값을 반환한다.
            - isAfterToday(Object)
            : 입력된 일자가 오늘 이후의 일자인지 확인한다.
            - isSequentialDate(fromObj, toObj, isToday)
            : 처음 Object의 일자가 두번째 Object의 일자보다 빠른지 확인

    ============================================================================*/

    /**
      * 입력된 문자열이 일자 Format 확인
      * @param str   문자열
      * @return true 일자 , false
     */
    function isDate ( obj )
    {
        str = removeSpaces(obj.value);
        str = removePeriod(obj.value);
        if (!isNumPeriod(obj)) {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYYMMDD의 형식으로 입력하십시오");
            return false;
        }
        if (str.length != 8) {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYYMMDD의 형식으로 입력하십시오");
            return false;
        }

        var year  = str.substring(0,4);
        var month = str.substring(4,6);
        var day   = str.substring(6,8);

        if ( parseInt2( year ) >= 1900  && isMonth( month ) && isDay( year,month ,day) )
            return true;
        else {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYYMMDD의 형식으로 입력하십시오");
            return false;
        }
    }

    /**
      * 입력된 문자열이 일자 Format YYYYMM이 맞는지를 확인
      * @param str   문자열
      * @return true 일자 , false
     */
    function isValidYYYYMM ( obj )
    {
        str = obj.value.replace(/\/|\-|\./g,"");
        if (!isNumPeriod(obj)) {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYYMM의 형식으로 입력하십시오");
            return false;
        }
        if (str.length != 6) {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYYMM의 형식으로 입력하십시오");
            return false;
        }

        var year  = str.substring(0,4);
        var month = str.substring(4,6);

        if ( parseInt2( year ) >= 1900  && isMonth( month ))
            return true;
        else {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYYMM의 형식으로 입력하십시오");
            return false;
        }
    }

    /**
      * 입력된 문자열이 일자 Format YYYY이 맞는지를 확인
      * @param str   문자열
      * @return true 일자 , false
     */
    function isValidYYYY ( obj )
    {
        str = obj.value.replace(/\/|\-|\./g,"");
        if (!isNumPeriod(obj)) {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYY의 형식으로 입력하십시오");
            return false;
        }
        if (str.length != 4) {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYY의 형식으로 입력하십시오");
            return false;
        }

        if ( (parseInt2( str ) >= 1900) &&( parseInt2( str ) < 2100))
            return true;
        else {
                obj.value = '';
            alertFocus(obj, "날짜는 YYYY의 형식으로 입력하십시오");
            return false;
        }
    }

    /**
      * 입력된 문자열이 6자리 일자 Format 확인
      * @param str   문자열
      * @return true 일자 , false
     */
    function isValidYYMMDD ( obj )
    {
        str = removeSpaces(obj.value);
        str = removePeriod(obj.value);
        if (!isNumPeriod(obj)) {
            alertFocus(obj, "날짜는 YYMMDD의 형식으로 입력하십시오");
            return false;
        }
        if (str.length != 6) {
            alertFocus(obj, "날짜는 YYMMDD의 형식으로 입력하십시오");
            return false;
        }

        var year  = str.substring(0,2);
        var month = str.substring(2,4);
        var day   = str.substring(4);

        if ( isMonth(month) && isDay2(day) )
            return true;
        else {
            alertFocus(obj, "날짜는 YYMMDD의 형식으로 입력하십시오");
            return false;
        }
    }

    /**
      * 입력된 문자열이 일자의 월로 변환가능한지 확인
      * @param month   문자열
      * @return true : 가능할 경우
     */
    function isMonth(month) {
        if (month.length > 2) return false;
        month = parseInt(month,10);
        if ((month <= 0) || (month > 12)) return false;
        return true;
    }

    /**
      * 입력된 문자열이 일자의 일로 변환가능한지 확인
      * @param year   년
      * @param month  월
      * @param day    일
      * @return true : 가능할 경우
     */
    function isDay(year, month, day) {
        if (day.length > 2) return false;
        year  = parseInt(year, 10);
        month = parseInt(month, 10);
        day   = parseInt(day, 10);
        if ((day <= 0) || (day > getEndDay(year, month))) return false;
        return true;
    }

    /**
      * 입력된 문자열이 일자의 일로 변환가능한지 확인 (월에 관계없음)
      * @param day 문자열
      * @return true : 가능할 경우
     */
    function isDay2(day) {
        if (day.length > 2) return false;
        day = parseInt(day, 10);
        if ((day <= 0) || (day > 31)) return false;
        return true;
    }

    /**
      * 해당 년, 월의 마지막 일자를 가져온다
      * @param year   년
      * @param month  월
      * @return 마지막 일자
     */
    function getEndDay(year,month){//
        if ((month==1)||(month==3)||(month==5)||(month==7)||(month==8)||(month==10)||(month==12))
            return 31;
        else {
            if(month==2) {
                if ((year%4==0) && ((year/4)%200!=0))   return 29;
                else    return 28;
            } else {
                return 30;
            }
        }
    }

    /**
     * 입력값이 유효한 일자인지 확인하고
     * 일자 형식에 맞추어 DATE_SEPERATOR 를 추가한다.
     * @param obj   Object
     * @return 구분자가 추가된 일자 형식의 문자열
     */
    function  addDateSeperator(obj)
    {
      if (isEmpty(obj)) return false;
      var numstr = obj.value.replace(/\/|\-|\./g,"");

      if (numstr.length < 6) {
          obj.value = '';
          alertFocus(obj, "날짜는 YYYYMM이나 YYYYMMDD의 형식으로 입력해주십시오");
          return false;
      }
      if (numstr.length == 6){
          if (!isValidYYYYMM(obj)) return false;
          var rxSplit = new RegExp('([0-9][0-9][0-9][0-9])([0-9][0-9])');
          numstr = numstr.replace(rxSplit, '$1'+DATE_SEPERATOR+'$2');
      } else {
          if (!isDate(obj)) return false;
          var rxSplit = new RegExp('([0-9][0-9][0-9][0-9])([0-9][0-9])([0-9][0-9])');
          numstr = numstr.replace(rxSplit, '$1'+DATE_SEPERATOR+'$2'+DATE_SEPERATOR+'$3');
      }
      obj.value = numstr;
      return true;
    }

    /**
     * 처음 Object와 두번째 Object 사이의 일자를 반환한다.
     * 이경우에 두번째 Object가 처음 Object 보다 나중 일자이다.
     * @param fromObj   Object
     * @param toObj     Object
     * @return int 두 Object 사이의 일자
     */
    function getDaysBetween(fromObj, toObj) {
        var numstr1 = removePeriod(fromObj.value);
        var user_day1 = new Date(numstr1.substr(0,4), parseInt2(numstr1.substr(4,2))-1, parseInt2(numstr1.substr(6)));
        var numstr2 = removePeriod(toObj.value);
        var user_day2 = new Date(numstr2.substr(0,4), parseInt2(numstr2.substr(4,2))-1, parseInt2(numstr2.substr(6)));
        user_day1 = user_day1.getTime();
        user_day2 = user_day2.getTime();
        var day_gab = Math.floor( (user_day2 - user_day1) / (60*60*24*1000) );
        return day_gab;
    }

    /**
     * 오늘까지 남은 일수를 반환한다. 오늘 이후의 일자에 대해서는 음수값을 반환한다.
     * @param obj   Object
     * @return int 남은 일수
     */
    function getDaysToToday(obj) {
        var numstr = removePeriod(obj.value);
        var user_day = new Date(numstr.substr(0,4), parseInt2(numstr.substr(4,2))-1, parseInt2(numstr.substr(6)));
        user_day = user_day.getTime();
        var today = new Date();
        today = today.getTime();
        var day_gab = Math.floor( (today - user_day) / (60*60*24*1000) );
        return day_gab;
    }

    /**
     * 입력된 일자가 오늘 이후의 일자인지 확인한다.
     * @param obj   Object
     * @return true : 오늘 이후의 일자일 경우, false
     */
    function isAfterToday(obj)
    {
        if (isEmpty(obj)) return false;
        if (!isDate(obj)) {
            return false;
        }
        var day_gab = getDaysToToday(obj);
        if( day_gab > 0) {
            alertFocus(obj, "오늘이후의 날짜를 입력하셔야 합니다");
            obj.value = "";
            return false;
        }
        return true;
    }

    /**
     * 처음 Object의 일자가 두번째 Object의 일자보다 빠른지 확인
     * @param obj   Object
     * @return true : 오늘 이후의 일자일 경우, false
     */
    function isSequentialDate(fromObj, toObj, isToday)
    {
        if (isEmpty(fromObj)) return false;
        if (isEmpty(toObj)) return false;
        if (!isDate(fromObj)) {
            return false;
        }
        if (!isDate(toObj)) {
            return false;
        }
        var day_gab = getDaysBetween(fromObj, toObj);
        if( day_gab < 0) {
            alertFocus(fromObj, "날짜를 바르게 입력하셔야 합니다");
            return false;
        }
        if ((!isToday)&&(day_gab == 0)) {
            alertFocus(fromObj, "날짜를 바르게 입력하셔야 합니다");
            return false;
        }
        return true;
    }


    /*= TEXT INPUT VALUE VALIDATION CHECK ==========================================

        1. TEXT 입력 값의 유효성을  확인한다.
        2. Function List
            - isValidJumin(obj)
            : 문자열이 올바른 주민등록번호인지 확인하여 리턴
            - isValidSaupja(obj)
            : 문자열이 올바른 사업자등록번호인지 확인하여 리턴
            - isValidBeopin(obj)
            : 문자열이 올바른 법인번호인지 확인하여 리턴
            - isValidAccountPassword(obj)
            : 신규계좌 생성시 입력된 비밀번호의 유효성을 확인한다.
            - isValidFormat(obj, format)
            : 입력값이 사용자가 정의한 포맷 형식인지 체크,자세한 format 형식은 자바스크립트의 'regular expression'을 참조
            - isValidEmail(obj)
            : 이메일 주소의 유효성을 확인한다.
            - isOnlyKorean(obj)
            : 한글인지를 확인한다.

    ============================================================================*/

    /**
      * 문자열이 올바른 주민등록번호인지 확인하여 리턴
     * @param obj   Object
      * @return true : 바른 주민등록번호일 경우
     */
    function isValidJumin(oResNo)
    {
        if(isEmpty(oResNo)) return false;
        var sResNo = removeDash(oResNo.value);

        if(sResNo.length != 13) {
            //return alertFocus( oResNo, "올바른 주민등록번호가 아닙니다.");
            return false;
        }

        var a = new Array(6)
        var b = new Array(7)
        var tot=0
        var c=0

        var sJumin0 = sResNo.substring(0,6);
        if (!isMonth(sJumin0.substring(2,4)))
            //return alertFocus( oResNo, "올바른 주민등록번호가 아닙니다.");
            return false;
        else if (!isDay2(sJumin0.substring(4,6)))
            //return alertFocus( oResNo, "올바른 주민등록번호가 아닙니다.");
            return false;

        var sJumin1 = sResNo.substring(6,13);

        for(var i=1;i<7;i++)
        {
            a[i]=sJumin0.substring(i-1,i);
            b[i]=sJumin1.substring(i-1,i);

            if(i<3)
                c=Number(b[i])*(i+7);
            else
                c=Number(b[i])*((i+9)%10);

            tot = tot + Number(a[i])*(i+1) + c;
        }

        b[7]=sJumin1.substring(6,7);

        if(Number(b[7]) != ((11-(tot%11))%10))
            //return alertFocus( oResNo, "올바른 주민등록번호가 아닙니다.");
            return false;
        else
            return true;

    }

    /**
      * 문자열이 올바른 사업자등록번호인지 확인하여 리턴
     * @param obj   Object
     * @return true : 바른 사업자등록번호일 경우
     */
    function isValidSaupja(oCorpNo)
    {
        if (isEmpty(oCorpNo)) return false;
        var sCorpNo = removeDash(oCorpNo.value);
        if(sCorpNo.length != 10) {
            return alertFocus( oCorpNo, "올바른 사업자등록번호가 아닙니다.");
        }

        var chkRule = "137137135";
        var step1, step2, step3, step4, step5, step6, step7;

        step1 = 0;

        for (var i=0; i<7; i++)
        {
            step1 = step1 + (sCorpNo.substring(i, i+1) * chkRule.substring(i, i+1));
        }

        step2 = step1 % 10;
        step3 = (sCorpNo.substring(7, 8) * chkRule.substring(7, 8)) % 10;
        step4 = sCorpNo.substring(8, 9) * chkRule.substring(8, 9);
        step5 = Math.round(step4 / 10 - 0.5);
        step6 = step4 - (step5 * 10);
        step7 = (10 - ((step2 + step3 + step5 + step6) % 10)) % 10;

        if (sCorpNo.substring(9, 10) != step7)
            return alertFocus( oCorpNo, "올바른 사업자등록번호가 아닙니다.");
        else
            return true;
    }

    /**
      * 문자열이 올바른 법인번호인지 확인하여 리턴
     * @param obj   Object
      * @return true : 바른 법인번호일 경우
     */
    function isValidBeopin(oBeopinNo){
        if (isEmpty(oBeopinNo)) return false;
        var pid = removeDash(oBeopinNo.value);
        if(pid.length != 10) {
            return alertFocus( oBeopinNo, "올바른 법인등록번호가 아닙니다.");
        }
        var pid = removeChar(oBeopinNo.value, "-");
        var number = "0123456789";
        var szChkDgt = "121212121212";
        var pidono = "";
        if (oBeopinNo.value.length < 1) {
            return;
        }
        for (var nCol=0; nCol < pid.length ; nCol++) {
            if (number.indexOf(pid.charAt(nCol)) >= 0) {
                    pidono += pid.charAt(nCol);
            }
        }
        var lastpid = pidono.substring(12,13);
        var i = 0;
        var j = 0;
        var nV1 = 0;
        var nV2 = 0;
        var nV3 = 0;
        for( i=0 ; i<12 ; i++) {
            nV1 = pidono.substring(i, i+1) * szChkDgt.charAt(i);
            if(nV1 > 9) {
                nV2 += nV1 % 10;
            } else {
                nV2 += nV1;
            }
        }
        nV3 = nV2 % 10;
        if( nV3 > 0 ) {
            nV3 = 10 - nV3;
        } else {
            nV3 = 0;
        }
        if (lastpid == nV3) {
            oBeopinNo.value= pid.substring(0, 7) + "-" + pid.substring(7, 13);
        } else {
            alertFocus( oBeopinNo, "올바른 법인등록번호가 아닙니다.");
            return;
        }
    }

    /**
     * 신규계좌 생성시 입력된 비밀번호의 유효성을 확인한다.
     * @param obj   Object
     * @return true : 사용가능한 비밀번호일 경우
     */
    function isValidAccountPassword(obj)
    {
        if (isEmpty(obj)) return;
        if (!IsNumer(obj)) {
            alertFocus(obj, "숫자만 입력하십시오.");
            return;
        }
        if (numstr.length != 4) {
            alertFocus(obj, "비밀번호는 4자리입니다.");
            return;
        }
    }

    /**
     * 입력값이 사용자가 정의한 포맷 형식인지 체크
     * 자세한 format 형식은 자바스크립트의 'regular expression'을 참조
     * @param obj      Object
     * @param format   String
     * @return true  올바른 포맷 형식일 경우
     */
    function isValidFormat(obj, format) {
        if (obj.value.search(format) != -1) {
            return true;
        }
        return false;
    }

    /**
     * 이메일 주소의 유효성을 확인한다.
     * @param obj   Object
     * @return true : 사용가능한 이메일 주소일 경우
     */
    function isValidEmail(obj)
    {
        if (isEmpty(obj)) return;
        if (!isEmailAddr(obj)) {
            alertFocus(obj, "잘못된 형식의 이메일 주소입니다");
            return;
        }
    }

    /**
     * 한글인지를 확인한다.
     * @param obj   Object
     * @return true : 사용가능한 이메일 주소일 경우
     */
    function isOnlyKorean(obj)
    {
        if (isEmpty(obj)) return;
        if (!isKorean(obj)) {
            alertFocus(obj, "한글만 입력하실 수 있습니다");
            return;
        }
    }

    /*= TEXT INPUT VALUE FORMAT ================================================

        1. TEXT 입력 값의 기준 포맷을 따라 변경한다
        2. Function List
            - addSeperatorToAccountNo(Object)
            : 11자리의 계좌번호를 입력받아 자동으로 '-'를 더하여 리턴(ex)
            - addSeperatorToJuminNo(Object)
            : 13자리의 주민등록번호를 입력받아 자동으로 '-'를 더하여 리턴(ex)123456-7890123
            - addSeperatorToSaupjaNo(Object)
            : 10자리의 사업자번호를 입력받아 자동으로 '-'를 더하여 리턴(ex)123-45-67890
            - addSeperatorToSilmyungNo(Object)
            : 10자리의 사업자번호, 13자리의 주민번호를 입력받아 자동으로 '-'를 더하여 리턴
            - addSeperatorToCardNo(Object)
            : 입력되는 카드번호의 4자리마다 '-'를 더하여 리턴 (ex)1234-5678-9012-3456

    ============================================================================*/

    /**
     * 11자리의 계좌번호를 입력받아 자동으로 '-'를 더하여 리턴
     * @param obj   Object
     * @return acct 계좌번호
     */
    function addSeperatorToAccountNo(obj)
    {
        if (isEmpty(obj)) return;
        if (!isNumDash(obj)) {
            alertFocus(obj, "숫자만 입력하십시오.");
            return;
        }
        var numstr = removeDash(obj.value);
        if (numstr.length != 11) {
            alertFocus(obj, "계좌번호는 11자리입니다");
            return;
        }
        var rxSplit = new RegExp('([0-9][0-9][0-9])([0-9][0-9])([0-9][0-9][0-9][0-9][0-9][0-9])');
        numstr = numstr.replace(rxSplit, '$1-$2-$3');
        obj.value = numstr;
    }

    /**
      * 13자리의 주민등록번호를 입력받아 자동으로 '-'를 더하여 리턴
     * @param obj   Object
      * @return acct 주민등록번호
     */
    function addSeperatorToJuminNo(obj)
    {
        if (isEmpty(obj)) return;
        if (!isNumDash(obj)) {
            obj.value = '';
            alertFocus(obj, "숫자만 입력하십시오.");
            return false;
        }

        if (!isValidJumin(obj)) {
            obj.value = '';
            alertFocus( obj, "올바른 주민등록번호가 아닙니다.");
            return false;
        }

        var numstr = removeDash(obj.value);
        var rxSplit = new RegExp('([0-9][0-9][0-9][0-9][0-9][0-9])([0-9][0-9][0-9][0-9][0-9][0-9][0-9])');
        numstr = numstr.replace(rxSplit, '$1-$2');
        obj.value = numstr;
    }

    /**
     * 10자리의 사업자번호를 입력받아 자동으로 '-'를 더하여 리턴
     * @param obj   Object
     * @return acct 사업자번호
     */
    function addSeperatorToSaupjaNo(obj)
    {
        if (isEmpty(obj)) return;
        if (!isNumDash(obj)) {
            alertFocus(obj, "숫자만 입력하십시오.");
            return false;
        }
        if (!isValidSaupja(obj)) {
            return false;
        }
        var numstr = removeDash(obj.value);
        var rxSplit = new RegExp('([0-9][0-9][0-9])([0-9][0-9])([0-9][0-9][0-9][0-9][0-9])');
        numstr = numstr.replace(rxSplit, '$1-$2-$3');
        obj.value = numstr;
    }

    /**
     * 10자리 혹은 13자리의 사업자번호,주민번호를 입력받아 자동으로 '-'를 더하여 리턴
     * @param obj   Object
     * @return acct 사업자번호, 주민번호
     */
    function addSeperatorToSilmyungNo(obj)
    {
        if (isEmpty(obj)) return;
        var numstr = removeDash(obj.value);
        if (numstr.length == 10) {
            addSeperatorToSaupjaNo(obj);
        } else if (numstr.length == 13){
            addSeperatorToJuminNo(obj);
        } else {
            alertFocus(obj, "잘못된 형식의 실명번호입니다");
        }
    }

    /**
     * 카드번호 입력시 4자리마다 NO_SEPERATOR(-) 추가한다
     * @param obj   Object
     * @return
     */
    function addSeperatorToCardNo(obj)
    {
        if (isEmpty(obj)) return;
        if (!isNumDash(obj)) {
            obj.value = obj.value.substr(0, obj.value.length-1);
            alertFocus(obj, "숫자만 입력하십시오.");
            return false;
        }
        var numstr = removeDash(obj.value);
        if (numstr.length != 16) {
            alertFocus(obj, "카드번호는 16자리입니다");
            return;
        }
        var numstr = obj.value;
        var num = numstr;
        var rxSplit = new RegExp('([0-9][0-9][0-9][0-9])([0-9])');
        do {
            numstr = numstr.replace(rxSplit, '$1-$2');
        }
        while (rxSplit.test(numstr));

        obj.value = numstr;
    }
	/**
     * 숫자만 입력 가능하게 한다. 
	 * 해당 입력 박스에 onKeyUp="this.value=key_number(this)" 코드를 넣어준다.
     * @param obj   Object
     * @return
     */
	function key_number(obj) {
	newString = "";
	count = 0;
	   if(obj.value.length==0) return "";

	   for (i = 0; i < obj.value.length; i++) {
		  ch = obj.value.substring(i, i+1);
		  if ((ch >= "0") && (ch <= "9")) {
			 newString += ch;
		 }
	   }
	   return newString;
	}

//-->