    /**
     * Filename     : Common.js
     * Function     : java script function to check input value
     * Comment      :
     * History      : 
     * Version      : 1.0
     */


    //****************************************************************************//
    //
    //  공통 JAVASCRIPT 함수들
    //
    //
    //  NafisKeyDown()                             - Tab Key가 입력되면 다음 필드로 이동을
    //  NafisKeyUp()                               - Enter Key가 입력되면 다음 필드로 이동한다
    //  NafisMouseUp()                             - 현재 Event가 발생하고 있는 필드를선택한다
    //  NafisFocus()                               - 커서가 필드에 위치할때 Event가 발생한다
    //  MoveNextOnly(field)                        - 커서만 다음 필드(field)로 이동시킨다

    //  checkLengthOnly(formName, field)           - 자릿수 입력이 올바른지 검사(항목이 하나)
    //                                               alert시 alt로 지정한 문자열을 보여줌.
    //  checkLength(formName, fields)              - 자릿수 입력이 올바른지 검사(항목이 여러개)
    //                                               alert시 alt로 지정한 문자열을 보여줌.
    //  checkLengths(formName, fields, idx)        - 자릿수 입력이 올바른지 검사(동일이름 항목이 여러개)
    //                                               alert시 alt로 지정한 문자열을 보여줌.
    //  checkEssentialInputOnly(formName, item)    - 필수입력 항목을 검사(항목이 하나)
    //                                               alert시 alt로 지정한 문자열을 보여줌.
    //  checkEssentialInput(formName, items)       - 필수입력 항목을 검사(항목이 여러개)
    //                                               alert시 alt로 지정한 문자열을 보여줌.
    //  checkEssentialInputs(formName, items, idx) - 필수입력 항목을 검사한다.(동일이름 항목이 여러개)
    //  checkDateOnly(formName, field)             - Date 타입의 입력이 올바른지 검사(항목이 하나)
    //  checkDate(formName, fields)                - Date 타입의 입력이 올바른지 검사(항목이 여러개)
    //  checkDates(formName, fields, idx)          - Date 타입의 입력이 올바른지 검사(동일이름 항목이 여러개)
    //  checkSplitDateOnly(formName, field)        - Date 타입의 입력이 올바른지 검사(항목이 하나)
    //                                               년월일이 3개의 필드로 분리되어 있을 경우
    //  checkSplitDate(formName, fields)           - Date 타입의 입력이 올바른지 검사(항목이 여러개)
    //                                               년월일이 3개의 필드로 분리되어 있을 경우
    //  checkSplitDates(formName, fields, idx)     - Date 타입의 입력이 올바른지 검사(동일이름 항목이 여러개)
    //                                               년월일이 3개의 필드로 분리되어 있을 경우
    //  checkDateTimeOnly(formName, field)         - DateTime 타입의 입력이 올바른지 검사(항목이 하나)
    //  checkDateTime(formName, fields)            - DateTime 타입의 입력이 올바른지 검사(항목이 여러개)
    //  checkDateTimes(formName, fields, idx)      - DateTime 타입의 입력이 올바른지 검사(동일이름 항목이 여러개)
    //  checkNumberOnly(formName, field)           - Number 타입의 입력이 올바른지 검사(항목이 하나)
    //  checkNumber(formName, fields)              - Number 타입의 입력이 올바른지 검사(항목이 여러개)
    //  checkNumbers(formName, fields, idx)        - Number 타입의 입력이 올바른지 검사(동일이름 항목이 여러개)
    //  checkDashNumOnly(formName, field)          - Dash("-")가 포함된 Number 타입의 입력이 올바른지 검사(항목이 하나)
    //  checkDashNum(formName, fields)             - Dash("-")가 포함된 Number 타입의 입력이 올바른지 검사(항목이 여러개)
    //  checkDashNums(formName, fields, idx)       - Dash("-")가 포함된 Number 타입의 입력이 올바른지 검사(동일이름 항목이 여러개)

    //  checkPeriodDate(startDate, endDate)        - Date 기간 입력이 올바른지 검사
    //  chkDoubleClick()                           - 더블클릭 check - 액션시 중복하여 Click하는 경우 처리(중복시 true)
    //  chkUsePwer(compare1, compare2)             - 사용자가 해당 메뉴에 대한  권한이 있는지를 Check

    //  msgClear()                                 - <body>의 onClick 이벤트가 발생하는 경우에 메시지 Clear
    //  msgDisplay(message)                        - message frame에 message string을 Display
    //  initDocument()                             - <body>의 onLoad 이벤트시에 액션 count 초기화

    //  isValidDashNum(value)                      - Dash("-")가 포함된 Number 타입이 올바른지 검사
    //  isValidDate(date, gubun)                   - date가 올바른지 검사, 13월 check시 gubun에 1 사용
    //  isValidDateTime(dateTime, gubun)           - datetime이 올바른지 검사, 13월 check시 gubun에 1 사용

    //  trimmed(value)                             - 문자열의 앞뒤 space를 제거
    //  getDaysInMonth(year,month)                 - 해당월이 몇일까지 있는지 계산
    //  leapYear (Year)                            - 해당년이 윤년인지 검사

    //  msgProcess(msgDiv, msgCode, msgName, msgTag, buttonOrder) - message 처리
    //  checkAlphaNum(formName, items)             - 숫자 및 영문 검사
    //  checkJuminRegtNo(preJuminRegtNo, postJuminRegtNo) - 주민등록번호가 유효한지 확인합니다.

    //  gotoHelpPop(strPgmName)                    - 도움말 팝업
    //  certCopyForm(orgForm, desForm, fields)     - 암호화 처리
    //  certCopyFormPop(orgForm, desForm, fields)  - 암호화 처리(팝업용)
    //  decryptPrint(str)                          - 복호화 처리 

    //****************************************************************************//

    var PrevLength;

    // Tab Key가 입력되면 다음 필드로 이동을 하고
    // 그렇지 않으면 필드에 입력된 값의 Length를 구한다.
    function NafisKeyDown()
    {
        if ( event.keyCode == 9 )
            PrevLength = -1;
        else
            PrevLength = event.srcElement.value.length;

        return false;
    }

    // Enter Key가 입력되면 다음 필드로 이동한다.
    // 이동할때 필드의 Max Length와 필드의 Validation을 체크한다.
    function NafisKeyUp()
    {
        var nMax = event.srcElement.maxLength;
        var bNext = false;

        if ( ( event.srcElement.value.length == nMax ) && ( PrevLength == nMax-1 || ( nMax==1 && PrevLength==1 ) ) )
        {
            bNext = true;
        }

        if ( event.keyCode == 13 )
        {
            bNext = true;
        }

        if ( bNext )
        {
            PrevLength = -1;
            event.srcElement.onafterupdate();
            return true;
        }

        return false;
    }

    // 현재 Event가 발생하고 있는 필드를선택한다.
    function NafisMouseUp()
    {
		try{
	        event.srcElement.select();
		}
        catch (exception)
		{
		}
    }

    // 커서가 필드에 위치할때 Event가 발생한다.
    function NafisFocus()
    {
        PrevLength = -1;
        event.srcElement.select();
    }

    // 커서만 다음 필드로 이동시킨다.
    function MoveNextOnly(formName, item)
    {
        var objForm = document.forms[formName];

        objForm[item].focus();
    }

    /**
    * Function      : 자릿수를 검사한다.
    *               :
    * @param        : formName    - Check 대상 Form Name
    *               : field       - Check 대상 Field Name
    * @return       : boolean
    */
    function checkLengthOnly(formName, field)
    {
        var objForm = document.forms[formName];
        var valueLength = objForm[field].value.length;
        var max = objForm[field].size;

        if( valueLength == 0 ) return true;


        if(valueLength < objForm[field].size)
        {
            alert(objForm[field].alt + ' 입력값이 부족합니다. (입력 : ' + objForm[field].size + '자리)' );
            objForm[field].focus();
            objForm[field].select();
            return false;
        }

        return true;
    }


    /**
    * Function      : 자릿수 입력이 올바른지 검사한다.
    *
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    * @return       : boolean
    */
    function checkLength(formName, fields)
    {
        var objForm = document.forms[formName];

        for(var i=0; i<fields.length ; i++)
        {
            if( objForm[fields[i]].value.length == 0 ) continue;

            if(objForm[fields[i]].value.length < objForm[fields[i]].size)
            {
                alert(objForm[fields[i]].alt + ' 입력값이 부족합니다. (입력 : ' + objForm[fields[i]].size + '자리)' );
                objForm[fields[i]].focus();
                objForm[fields[i]].select();
                return false;
            }
        }

        return true;
    }


    /**
    * Function      : 자릿수 입력이 올바른지 검사한다.
    *                 항목이 여러개 반복해서 나오는 경우 사용.
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    *               : idx         - 항목의 Array Index
    * @return       : boolean
    */
    function checkLengths(formName, fields, idx)
    {
        var objForm = document.forms[formName];

        for(var i=0; i<fields.length ; i++)
        {
            if( objForm[fields[i]][idx].value.length == 0 ) continue;

            if(objForm[fields[i]][idx].value.length < objForm[fields[i]][idx].size)
            {
                alert(objForm[fields[i]][idx].alt + ' 입력값이 부족합니다. (입력 : ' + objForm[fields[i]][idx].size + '자리)' );
                objForm[fields[i]][idx].focus();
                objForm[fields[i]][idx].select();
                return false;
            }
        }

        return true;
    }


    /**
    * Function      : 필수입력 항목을 검사한다.
    *               : 항목이 하나
    * @param        : formName    - Check 대상 Form Name
    *               : item        - Check 대상 Field Name
    * @return       : boolean
    */
    function checkEssentialInputOnly(formName, item)
    {
        var form = document.forms[formName];
        var value = null;
        var eleName = null;

        value = trimmed(form[item].value);

        if(value == "" )
        {
            eleName = form[item].alt;
            alert(eleName + '(필수입력) 값을 입력하세요.');
//            form[item].focus();
            form[item].select();

            if (form[item].type != 'select-one') {
                form[item].select();
            }

            return false;
        }

        return true;
    }


    /**
    * Function      : 필수입력 항목을 검사한다.
    *               : 항목이 여러개
    * @param        : formName    - Check 대상 Form Name
    *               : items       - Check 대상 Field Name Array
    * @return       : boolean
    */
    function checkEssentialInput(formName, items)
    {
        var form = document.forms[formName];
        var value = null;
        var eleName = null;

        for(var i=0; i<items.length; i++)
        {
            value = trimmed(form[items[i]].value);
            if(value == "" )
            {
                eleName = form[items[i]].alt;
                alert(eleName + '(필수입력) 값을 입력하세요.');
                form[items[i]].focus();
//                form[items[i]].select();

                if (form[items[i]].type != 'select-one') {
                    form[items[i]].select();
                }

                return false;
            }
        }

        return true;
    }


    /**
    * Function      : 필수입력 항목을 검사한다.
    *               : 동일이름 항목이 여러개
    * @param        : formName    - Check 대상 Form Name
    *               : items       - Check 대상 Field Name Array
    *               : idx         - 항목의 Array Index
    * @return       : boolean
    */
    function checkEssentialInputs(formName, items, idx)
    {
        var form = document.forms[formName];
        var value = null;
        var eleName = null;

        for(var i=0; i<items.length; i++)
        {
            value = trimmed(form[items[i]][idx].value);

            if(value == "" )
            {
                eleName = form[items[i]][idx].alt;
                alert(eleName + '(필수입력) 값을 입력하세요.');
//                form[items[i]][idx].focus();
                form[items[i]][idx].select();

                if (form[items[i]][idx].type != 'select-one') {
                    form[items[i]][idx].select();
                }

                return false;
            }
        }

        return true;
    }


    /**
    * Function      : Date 타입의 입력이 올바른지 검사한다.(항목이 하나)
    *               : 8자리, 예) 20020410
    * @param        : formName    - Check 대상 Form Name
    *               : field       - Check 대상 Field Name
    *               : gubun     - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkDateOnly(formName, field, gubun)
    {
        var objForm = document.forms[formName];

        if( gubun == 1 )
        {
            if(objForm[field].value.length >0 && !isValidDate(objForm[field].value, 1))
            {
                alert(objForm[field].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                objForm[field].focus();
                objForm[field].select();
                return false;
            }
        }
        else
        {
            if(objForm[field].value.length >0 && !isValidDate(objForm[field].value))
            {
                alert(objForm[field].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                objForm[field].focus();
                objForm[field].select();
                return false;
            }
        }

        return true;
    }


    /**
    * Function      : Date 타입의 입력이 올바른지 검사한다.(항목이 여러개)
    *               : 8자리, 예) 20020410
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    *               : gubun       - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkDate(formName, fields, gubun)
    {
        var objForm = document.forms[formName];

        if( gubun == 1 )
        {
            for(var i=0; i<fields.length ; i++)
            {
                if(objForm[fields[i]].value.length >0 && !isValidDate(objForm[fields[i]].value, 1))
                {
                    alert(objForm[fields[i]].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                    objForm[fields[i]].focus();
                    objForm[fields[i]].select();
                    return false;
                }
            }
        }
        else
        {
            for(var i=0; i<fields.length ; i++)
            {
                if(objForm[fields[i]].value.length >0 && !isValidDate(objForm[fields[i]].value))
                {
                    alert(objForm[fields[i]].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                    objForm[fields[i]].focus();
                    objForm[fields[i]].select();
                    return false;
                }
            }
        }

        return true;
    }

    /**
    * Function      : Date 타입의 입력이 올바른지 검사한다.(동일이름 항목이 여러개)
    *               : 8자리, 예) 20020410
    *               : 항목이 여러개 반복해서 나오는 경우 사용.
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    *               : idx         - 항목의 Array Index
    *               : gubun       - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkDates(formName, fields, idx, gubun)
    {
        var objForm = document.forms[formName];

        if( gubun == 1 )
        {
            for(var i=0; i<fields.length ; i++)
            {
                if(objForm[fields[i]][idx].value.length >0 && !isValidDate(objForm[fields[i]][idx].value, 1))
                {
                    alert(objForm[fields[i]][idx].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                    objForm[fields[i]][idx].focus();
                    objForm[fields[i]][idx].select();
                    return false;
                }
            }
        }
        else
        {
            for(var i=0; i<fields.length ; i++)
            {
                if(objForm[fields[i]][idx].value.length >0 && !isValidDate(objForm[fields[i]][idx].value))
                {
                    alert(objForm[fields[i]][idx].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                    objForm[fields[i]][idx].focus();
                    objForm[fields[i]][idx].select();
                    return false;
                }
            }
        }

        return true;
    }

    /**
    * Function      : Date 타입의 입력이 올바른지 검사한다.
    *               : 년월일이 3개의 필드로 분리되어 있을 경우, 예) 2002, 04, 10
    * @param        : formName    - Check 대상 Form Name
    *               : field       - Check 대상 Field Name, field2, field3가 반드시 있어야 함.
    *               : gubun       - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkSplitDateOnly(formName, field, gubun)
    {
        var objForm = document.forms[formName];

        var ymd = objForm[field].value + objForm[field+"2"].value + objForm[field+"3"].value;

        if( gubun == 1 )
        {
            if(ymd.length >0 && !isValidDate(ymd, 1))
            {
                alert(objForm[field].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                objForm[field].focus();
                objForm[field].select();
                return false;
            }
        }
        else
        {
            if(ymd.length >0 && !isValidDate(ymd))
            {
                alert(objForm[field].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                objForm[field].focus();
                objForm[field].select();
                return false;
            }
        }

        return true;
    }

    /**
    * Function      : Date 타입의 입력이 올바른지 검사한다.
    *               : 년월일이 3개의 필드로 분리되어 있을 경우, 예) 2002, 04, 10
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array, field2, field3가 반드시 있어야 함.
    *               : gubun       - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkSplitDate(formName, fields, gubun)
    {
        var objForm = document.forms[formName];

        for(var i=0; i<fields.length ; i++)
        {

            var ymd = objForm[fields[i]].value + objForm[fields[i]+"2"].value + objForm[fields[i]+"3"].value;

            if( gubun == 1 )
            {
                if(ymd.length >0 && !isValidDate(ymd, 1))
                {
                    alert(objForm[fields[i]].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                    objForm[fields[i]].focus();
                    objForm[fields[i]].select();
                    return false;
                }
            }
            else
            {
                if(ymd.length >0 && !isValidDate(ymd))
                {
                    alert(objForm[fields[i]].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                    objForm[fields[i]].focus();
                    objForm[fields[i]].select();
                    return false;
                }
            }
        }

        return true;
    }

    /**
    * Function      : Date 타입의 입력이 올바른지 검사한다.
    *               : 년월일이 3개의 필드로 분리되어 있을 경우, 예) 2002, 04, 10
    *               : 항목이 여러개 반복해서 나오는 경우 사용.
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array, field2, field3가 반드시 있어야 함.
    *               : idx         - 항목의 Array Index
    *               : gubun       - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkSplitDates(formName, fields, idx, gubun)
    {
        var objForm = document.forms[formName];

        if( gubun == 1)
        {
            for(var i=0; i<fields.length ; i++)
            {
                var ymd = objForm[fields[i][idx]].value + objForm[fields[i][idx]+"2"].value + objForm[fields[i][idx]+"3"].value;

                if(ymd.length >0 && !isValidDate(ymd, 1))
                {
                    alert(objForm[fields[i]][idx].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                    objForm[fields[i]][idx].focus();
                    objForm[fields[i]][idx].select();
                    return false;
                }
            }
        }
        else
        {
            for(var i=0; i<fields.length ; i++)
            {
                var ymd = objForm[fields[i][idx]].value + objForm[fields[i][idx]+"2"].value + objForm[fields[i][idx]+"3"].value;

                if(ymd.length >0 && !isValidDate(ymd))
                {
                    alert(objForm[fields[i]][idx].alt + ' 입력이 잘못되었습니다.(예 20001230)');
//                    objForm[fields[i]][idx].focus();
                    objForm[fields[i]][idx].select();
                    return false;
                }
            }
        }



        return true;
    }

    /**
    * Function      : DateTime 타입의 입력이 올바른지 검사한다.(항목이 하나)
    *               : 14자리, 예) 20020410120210
    * @param        : formName    - Check 대상 Form Name
    *               : field       - Check 대상 Field Name
    *               : gubun       - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkDateTimeOnly(formName, field, gubun)
    {
        var objForm = document.forms[formName];

        if( gubun == 1 )
        {
            if(objForm[field].value.length >0 && !isValidDateTime(objForm[field].value, 1))
            {
                alert(objForm[field].alt + ' 입력이 잘못되었습니다.(예 20001230235959)');
//                objForm[field].focus();
                objForm[field].select();
                return false;
            }
        }
        else
        {
            if(objForm[field].value.length >0 && !isValidDateTime(objForm[field].value))
            {
                alert(objForm[field].alt + ' 입력이 잘못되었습니다.(예 20001230235959)');
//                objForm[field].focus();
                objForm[field].select();
                return false;
            }
        }

        return true;
    }


    /**
    * Function      : DateTime 타입의 입력이 올바른지 검사한다.(항목이 여러개)
    *               : 14자리, 예) 20020410120210
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    *               : gubun       - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkDateTime(formName, fields, gubun)
    {
        var objForm = document.forms[formName];

        if( gubun == 1 )
        {
            for(var i=0; i<fields.length ; i++)
            {
                if(objForm[fields[i]].value.length >0 && !isValidDateTime(objForm[fields[i]].value, 1))
                {
                    alert(objForm[fields[i]].alt + ' 입력이 잘못되었습니다.(예 20001230235959)');
//                    objForm[fields[i]].focus();
                    objForm[fields[i]].select();
                    return false;
                }
            }
        }
        else
        {
            for(var i=0; i<fields.length ; i++)
            {
                if(objForm[fields[i]].value.length >0 && !isValidDateTime(objForm[fields[i]].value))
                {
                    alert(objForm[fields[i]].alt + ' 입력이 잘못되었습니다.(예 20001230235959)');
//                    objForm[fields[i]].focus();
                    objForm[fields[i]].select();
                    return false;
                }
            }
        }

        return true;
    }


    /**
    * Function      : DateTime 타입의 입력이 올바른지 검사한다.(동일이름 항목이 여러개)
    *               : 14자리, 예) 20020410120210
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    *               : idx         - 항목의 Array Index
    *               : gubun       - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function checkDateTimes(formName, fields, idx, gubun)
    {
        var objForm = document.forms[formName];

        if( gubun == 1 )
        {
            for(var i=0; i<fields.length ; i++)
            {
                if(objForm[fields[i][idx]].value.length >0 && !isValidDateTime(objForm[fields[i][idx]].value, 1))
                {
                    alert(objForm[fields[i][idx]].alt + ' 입력이 잘못되었습니다.(예 20001230235959)');
//                    objForm[fields[i][idx]].focus();
                    objForm[fields[i][idx]].select();
                    return false;
                }
            }
        }
        else
        {
            for(var i=0; i<fields.length ; i++)
            {
                if(objForm[fields[i][idx]].value.length >0 && !isValidDateTime(objForm[fields[i][idx]].value))
                {
                    alert(objForm[fields[i][idx]].alt + ' 입력이 잘못되었습니다.(예 20001230235959)');
//                    objForm[fields[i][idx]].focus();
                    objForm[fields[i][idx]].select();
                    return false;
                }
            }
        }

        return true;
    }


    /**
    * Function      : Number 타입의 입력이 올바른지 검사한다.(항목이 하나)
    * @param        : formName    - Check 대상 Form Name
    *               : field       - Check 대상 Field Name
    * @return       : boolean
    */
    function checkNumberOnly(formName, field)
    {
        var objForm = document.forms[formName];

        if(objForm[field].value.length>0 && isNaN(objForm[field].value))
        {
            alert(objForm[field].alt + '에 숫자를 입력해 주십시오.');
            objForm[field].focus();
            objForm[field].select();
            return false;
        }

        return true;
    }


    /**
    * Function      : Number 타입의 입력이 올바른지 검사한다.(항목이 여러개)
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    * @return       : boolean
    */
    function checkNumber(formName, fields)
    {
        var objForm = document.forms[formName];

        for(var i=0; i<fields.length ; i++)
        {
            if(objForm[fields[i]].value.length>0 && isNaN(objForm[fields[i]].value))
            {
                alert(objForm[fields[i]].alt + '에 숫자를 입력해 주십시오.');
                objForm[fields[i]].focus();
                objForm[fields[i]].select();
                return false;
            }
        }

        return true;
    }

    /**
    * Function      : Number 타입의 입력이 올바른지 검사한다.(동일이름 항목이 여러개)
    *               : 항목이 여러개 반복해서 나오는 경우 사용.
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    *               : idx         - 항목의 Array Index
    * @return       : boolean
    */
    function checkNumbers(formName, fields, idx)
    {
        var objForm = document.forms[formName];

        for(var i=0; i<fields.length ; i++)
        {
            if(objForm[fields[i]][idx].value.length>0 && isNaN(objForm[fields[i]][idx].value))
            {
                alert(objForm[fields[i]][idx].alt + '에 숫자를 입력해 주십시오.');
                objForm[fields[i]][idx].focus();
                objForm[fields[i]][idx].select();
                return false;
            }
        }

        return true;
    }


    /**
    * Function      : Dash("-")가 포함된 Number 타입의 입력이 올바른지 검사한다.
    *               : 항목이 하나
    * @param        : formName    - Check 대상 Form Name
    *               : field       - Check 대상 Field Name
    * @return       : boolean
    */
    function checkDashNumOnly(formName, field)
    {
        var objForm = document.forms[formName];

        if(objForm[field].value.length>0 && !isValidDashNum(objForm[field].value))
        {
            alert(objForm[field].alt + '에 숫자 와 \'-\' 만 입력해 주십시오.');
            objForm[field].focus();
            objForm[field].select();
            return false;
        }

        return true;
    }


    /**
    * Function      : Dash("-")가 포함된 Number 타입의 입력이 올바른지 검사한다.
    *               : 항목이 여러개
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    * @return       : boolean
    */
    function checkDashNum(formName, fields)
    {
        var objForm = document.forms[formName];

        for(var i=0; i<fields.length ; i++)
        {
            if(objForm[fields[i]].value.length>0 && !isValidDashNum(objForm[fields[i]].value))
            {
                alert(objForm[fields[i]].alt + '에 숫자 와 \'-\' 만 입력해 주십시오.');
                objForm[fields[i]].focus();
                objForm[fields[i]].select();
                return false;
            }
        }

        return true;
    }


    /**
    * Function      : Dash("-")가 포함된 Number 타입의 입력이 올바른지 검사한다.
    *               : 동일이름 항목이 여러개
    * @param        : formName    - Check 대상 Form Name
    *               : fields      - Check 대상 Field Name Array
    *               : idx         - 항목의 Array Index
    * @return       : boolean
    */
    function checkDashNums(formName, fields, idx)
    {
        var objForm = document.forms[formName];

        for(var i=0; i<fields.length ; i++)
        {
            if(objForm[fields[i]][idx].value.length>0 && !isValidDashNum(objForm[fields[i]][idx].value))
            {
                alert(objForm[fields[i]][idx].alt + '에 숫자 와 \'-\' 만 입력해 주십시오.');
                objForm[fields[i]][idx].focus();
                objForm[fields[i]][idx].select();
                return false;
            }
        }

        return true;
    }


    /**
    * Function      : Date 기간 입력이 올바른지 검사한다.
    * @param        : startDate   - Check 대상 시작일자
    *               : endDate     - Check 대상 종료일자
    * @return       : boolean
    */
    function checkPeriodDate(startDate, endDate)
    {
        if(startDate>endDate)
        {
            alert('기간 입력이 잘못되어 있습니다.');
            return false;
        }
        return true;
    }


    /**
    * Function      : 더블클릭 check - 액션시 중복하여 Click하는 경우 처리.
    * @param        : none
    * @return       : boolean
    */
    function chkDoubleClick()
    {
        if( top.hidden.HIDDEN_FORM.ACTION_CNT.value != 0 )
        {
            //alert("한번만 클릭하셔야 합니다.");
            top.hidden.HIDDEN_FORM.ACTION_CNT.value = 0;
            return true;
        }
        else
        {
            top.hidden.HIDDEN_FORM.ACTION_CNT.value++;
            return false;
        }
    }


    /**
    * Function      : 사용자가 해당 메뉴에 대한  권한이 있는지를 Check한다.
    * @param        : compare1 - 사용자 권한 (세션값)
    * @param        : compare2 - 사용자 권한 (Write 가능)
    * @return       : boolean
    */
    function chkUsePwer(compare1, compare2)
    {

        if(compare1 != compare2)
        {
            alert('수행 권한이 없습니다!\n관리자에게 문의하세요!');
            return false;
        }

        return true;
    }


    /**
    * Function      : <body>의 onClick 이벤트가 발생하는 경우에 메시지 Clear
    * @param        : none
    * @return       : none
    */
    function msgClear()
    {
        top.document.frames("msg").mesgstr.innerText = "";
    }


    /**
    * Function      : message frame에 message string을 Display
    * @param        : message
    * @return       : none
    */
    function msgDisplay(message)
    {
        top.document.frames("msg").mesgstr.innerText = message;
    }


    /**
    * Function      : 더블클릭 Count 초기화 - hidden frame의 변수 사용
    * @param        : none
    * @return       : none
    */
    function initDocument()
    {
        top.hidden.HIDDEN_FORM.ACTION_CNT.value = 0;
    }


    /**
    * Function      : Dash("-")가 포함된 Number 타입이 올바른지 검사한다.
    * @param        : value       - Check 대상 data
    * @return       : boolean
    */
    function isValidDashNum(value)
    {
        var tmp = "0123456789-";
        var cnt = value.length;

        for(var i=0; i < cnt; i++)
        {
            if(tmp.indexOf(value.charAt(i)) < 0 ) return false;
        }

        return true;
    }


    /**
    * Function      : date가 올바른지 검사한다.
    *                 13월15일이 존재하여 월 체크를 13까지 가능하도록 변경함 - 2002. 08. 14
    *                 13월 check를 위해 파라미터 추가 : gubun
    *                 13월 check시 gubun - 1
    * @param        : date      - Check 대상 date
    * @param        : gubun     - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function isValidDate(date, gubun)
    {
        var year, month, day;

        if(date.length<8) return false;
        if(!(isNum(date))) return false;

        year    = date.substring(0,4);
        month    = date.substring(4,6);
        day        = date.substring(6);

        if( gubun == 1 )
        {
            if(month==0 || month>13) return false;
        }
        else
        {
            if(month==0 || month>12) return false;
        }

        if(day==0 || day>getDaysInMonth(year, month)) return false;

        return true;
    }


    /**
    * Function      : datetime이 올바른지 검사한다.
    * @param        : dateTime  - Check 대상 datetime
    * @param        : gubun     - 13월 check시 1, 12월 check시 none or other
    * @return       : boolean
    */
    function isValidDateTime(dateTime, gubun)
    {
        var hour, minute, seconds;

        if(dateTime.length<14) return false;
        if(isNaN(dateTime)) return false;

        if(gubun == 1)
        {
            if(!isValidDate(dateTime.substring(0,8), 1)) return false;
        }
        else
        {
            if(!isValidDate(dateTime.substring(0,8))) return false;
        }

        hour    = dateTime.substring(8,10);
        minute    = dateTime.substring(10,12);
        seconds = dateTime.substring(12,14);

        if(hour>23) return false;
        if(minute>59) return false;
        if(seconds>59) return false;

        return true;
    }


    /**
    * Function      : 문자열의 앞뒤 space를 제거한다.
    * @param        : value
    * @return       : 앞뒤의 space가 제거된 문자열
    */
    function trimmed(value)
    {
        value = value.replace(/^\s+/, "");  // remove leading white spaces
        value = value.replace(/\s+$/g, ""); // remove trailing while spaces
        return value;
    }


    /**
    * Function      : 해당월이 몇일까지 있는지 계산한다.
    *               : 13월 15일 추가.
    * @param        : year      - 년도
    *               : month     - 월
    * @return       : days      - 일수
    */
    function getDaysInMonth(year,month)
    {
        var days;
        if (month==1 || month==3 || month==5 || month==7 || month==8 ||
            month==10 || month==12)  days=31;
        else if (month==4 || month==6 || month==9 || month==11) days=30;
        else if (month==2)
        {
            if (leapYear (year)==1)  days=29;
            else days=28;
        }
        else if (month==13) days=15;

        return (days);
    }


    /**
    * Function      : 해당년이 윤년인지 검사한다.
    * @param        : year      - 년도
    *               : month     - 월
    * @return       : 윤년이면 1, 아니면 0
    */
    function leapYear (Year)
    {
        if (((Year % 4)==0) && ((Year % 100)!=0) || ((Year % 400)==0))
            return (1);
        else
            return (0);
    }


    /**
    * Function      : message box 처리
    * @param        : msgDiv  - message 구분(E:처리시 Error, I:정상 처리 정보, W:Validation, Confirm, S:처리시 SQL Error)
    *                 msgCode - message.properties에 등록되어 있는 메시지 코드
    *                 msgName - message.properties에 등록되어 있는 메시지 명
    *                 msgTag  - Warning message 구분(1:경고, 2:Confirm, 3:Information(팝업의 경우 MsgBox처리)), default:1
    *                 buttonOrder - Confirm Message의 경우 Default Button(1:예, 2:아니오), default:1
    * @return       : boolean - Confirm의 아니오를 선택한 경우만 False, 그외는 True
    */
    function msgProcess(msgDiv, msgCode, msgName, msgTag, buttonOrder)
    {
        var resultProc;
        resultProc = true;

        switch(msgDiv)
        {
            case "I" :
                if ( msgTag == "3" )
                {
                    resultProc = msgProc(msgDiv, msgCode, msgName, msgTag, buttonOrder);
                }
                else
                {
                    top.document.frames("msg").mesgstr.innerText = msgName;
                }

                break;
            default :
                resultProc = msgProc(msgDiv, msgCode, msgName, msgTag, buttonOrder);
                break;
        }

        return resultProc;
    }

    /**
    * Function      : 영문 숫자만 검사 한다.
    * @param        : value
    * @return       : boolean
    */

    function checkAlphaNum(formName, items)
    {
        var form = document.forms[formName];
        var value = null;
        var eleName = null;

        for(var i=0; i<items.length; i++)
        {
          //  value = trimmed(form[items[i]].value);
            value = form[items[i]].value;
            value = value.toUpperCase();
            if (value.length == 0)
               return true;
            for (j = 0; j < value.length; j++)
                if (!((value.charAt(j) >= ('A') && (value.charAt(j)) <= ('Z')) ||
                    (value.charAt(j) >= ('0') && (value.charAt(j)) <= ('9'))))
                {
                   alert(form[items[i]].alt + ' (영문 및 숫자) 값을 입력하세요.' );
                   form[items[i]].focus();
                   form[items[i]].select();
                   return false;
                }
        }
        return true;

    }

    /**
     * Function     : 주민등록번호가 유효한지 확인합니다.
     *
     * @param       : preJuminRegtNo        확인할 주민등록번호 앞자리
     * @param       : postJuminRegtNo       확인할 주민등록번호 뒷자리
     * @return      : boolean               주민등록번호의 유효값(true, false)
     *
     */
    function checkJuminRegtNo(preJuminRegtNo, postJuminRegtNo)
    {
        var isValidJuminRegtNo = false ;

        var yy = preJuminRegtNo.substring(0,2) ;    // 생년
        var mm = preJuminRegtNo.substring(2,4) ;    // 생월
        var dd = preJuminRegtNo.substring(4,6) ;    // 생일
        var gender = postJuminRegtNo.substring(0,1) ;  // 성별

        // 기본 체크
        if(preJuminRegtNo.length != 6 || postJuminRegtNo.length != 7 || yy < 20
           || mm < 1 || mm > 12 || dd < 0 || dd > 31 || gender > 2 || gender < 1) {
            alert("잘못된 주민등록번호입니다") ;
            return isValidJuminRegtNo ;
        }

        // 주민등록번호 공식에 의한 체크
        var juminRegtNo = preJuminRegtNo + postJuminRegtNo ;

        var ck = 0 ;
        for(i = 0 ; i < 12 ; ++i) {
            var num = juminRegtNo.substring(i, i+1) ;
            ck += (i%8+2) * num ;
        }

        ck = (11-(ck%11))%10 ;

        if(parseInt(ck) != parseInt(juminRegtNo.substring(12,13))) {
            alert("잘못된 주민등록번호입니다") ;
            return isValidJuminRegtNo ;
        } else isValidJuminRegtNo = true ;

        return isValidJuminRegtNo ;
    }

    /**
     * Function     : OZ 구동 : target를 hidden2로
     *
     * @param       : URL                   URL
     *
     */
    function ozView(URL)
    {
        document.OZ_FORM.action = URL;
        document.OZ_FORM.target = "hidden2";
        document.OZ_FORM.submit();
    }

    function isNum(toCheck)
    {
        for( var i=0; i < toCheck.length; i++ )
        {
            if (!(toCheck.charAt(i) >= ('0') && (toCheck.charAt(i)) <= ('9')))
            {
                return false;
            }
        }
        return true;
    }

    /**
     * Function     : 도움말
     *
     * @param       : 프로그램명
     *
     */
    function gotoHelpPop(strPgmName)
    {
        var dlgUrl   = "/bt/System/BtHelpDetlFrm.jsp?PGM_NAME=" + strPgmName;
        var dlgStyle = "width=470, height=480, LEFT=470, TOP=100, scrollbars=no, resizable=yes";
        newWin = window.open(dlgUrl, "popup", dlgStyle);
        newWin.focus();
    }
    function setMsgProgress(msg) {
        progress.document.MAIN_FORM.PROGRESS.value = "END";
        progress.document.MAIN_FORM.MESSAGE.value = msg;
    }

    function openProgressWin() {
        //경로지정
        var dlgUrl   = "/common/BtProgress.html";
        var w = 400;
        var h = 130;
        //윈도우 스타일 지정
        var dlgStyle = "width=" + w + ", "
                     + "height=" + h +", "
                     + "left=" + (screen.availWidth - w)/2 + ", "
                     + "top="+ (screen.availHeight - h - 10)/2 +", "
                     + "status=no, "
                     + "scrollbars=no, "
                     + "resizable=no";

        //윈도우 생성 및 포커스 주기
        progress = open(dlgUrl, "_pg", dlgStyle);
        progress.focus();
    }

    /**
     * Function     : 암호화 처리 
     * @param       : orgForm  -MAIN_FORM
     *                desForm - CERT_FORM
     *                fields - 암호화 대상 필드
     *
     */
    function certCopyForm(orgForm, desForm, fields) {
      var len = orgForm.elements.length;
      var html = '';
     
      //CERT_FORM 의 필드 생성
      for ( var n=0; n<len; n++ ) {
          html += "<input type=hidden name=\""+ orgForm.elements[n].name +"\">";            
      }
      //CERT_FORM 의 필드 마지막에 암호화 대상 필드를 담을 필드 생성
      html += "<input type=hidden name=CERT_FIELDS>";
      desForm.innerHTML = html;  
      desForm.elements[len].value = fields;
       
      strSession  = document.knca.ReadDataFile("c:\\pki\\temp\\sess_id.txt");    
      if(!strSession)
      {
         alert('암호화 관련 파일(sess_id.txt)이 지워졌습니다.\n'+
               '다시 로그인 하세요.');
         top.location.href="/bt/BtLogout.jsp";          
         return;    
      }     
       
      //MAIN_FORM 에서 CERT_FORM  필드로  데이터 값 복사   
      for ( var n=0; n<len; n++ ) {
          desForm.elements[n].value = orgForm.elements[n].value;               
      }
      
      //CERT_FORM에 암호화 대상 필드로 암호화 시킴    
      for(var i=0; i<fields.length ; i++)
      {
         // 여러개 레코드로 구성된 필드인 경우
         if (orgForm[fields[i]].length)
         {
            z = orgForm[fields[i]].length;
            for(var n=0; n<z ; n++) {
              if ((orgForm[fields[i]][n].value != null) && (orgForm[fields[i]][n].value != ""))
                desForm[fields[i]][n].value = document.knca.SymmEncryptDataEx(orgForm[fields[i]][n].value, strSession, "SEED");
            }
         }  
         // 하나 레코드로 구성된 필드인 경우
         else { 
            if ((orgForm[fields[i]].value != null) && (orgForm[fields[i]].value != ""))
                desForm[fields[i]].value = document.knca.SymmEncryptDataEx(orgForm[fields[i]].value, strSession, "SEED");
         } 
      }
    }

    /**
     * Function     : 복호화 처리(조회용) 
     * @param       : str -복호화 대상 필드
     *
     */
    function decryptPrint(str) {
        document.write(decryptData(str));
    }
    function decryptData(str)
    {
        var sessId,SymmDecData;
        /* Symmetric Key를 이용하여 데이터를 복호화 한다. */    
        sessId = document.knca.ReadDataFile("c:\\pki\\temp\\sess_id.txt");
        if(!sessId)
        {
             alert('암호화 관련 파일(sess_id.txt)이 지워졌습니다.\n'+
                   '다시 로그인 하세요.');
             top.location.href="/bt/BtLogout.jsp";      
             return;    
        }
        SymmDecData = document.knca.SymmDecryptData(str,sessId,"SEED");
        return(SymmDecData);    
    }


	/*
	 * Filename     : Common.js
	 * Function     : 자바스크립트
	 * Comment      :
	 * History      : 2002/03/29, v1.0
	 * Version      : 1.0
	 */
	function js_check(form) {
		var frm = document.MAIN_FORM;
		var chk = form;
	
		if (frm.CHK_ALL.checked == true) {
			for (var i=0; i<chk.length;i++) {
				if (chk[i].type == "checkbox" && chk[i].checked == false) {
					chk[i].checked = true;
				}
			}
		}
		else {
			for (var i=0; i<chk.length;i++) {
				if (chk[i].type == "checkbox" && chk[i].checked == true) {
					chk[i].checked = false;
				}
			}
		}
	}

	/**
	 * Function     : 숫자에 콤마 찍기
	 * @param       : URL		            URL
	 */
	function comma_insert(data){
       var sum_data = "", j=0

       if ((data != "") && (data.indexOf(",") < 0) && (data.length > 3)) {
            for (var i = data.length-1; i >= 0 ; i-- ) {
                if ((data.substring(i,i+1) == ".") || (data.substring(i,i+1) == "-")) {
                   j=-1
                }
                else if (j == 3) {
                    sum_data = "," + sum_data
                    j = 0
                }
                sum_data = data.substring(i,i+1) + sum_data
                j++
            }
           return sum_data
        }
        else {
           return data
        }
 	}

	/**
	 * Function     : 숫자에 콤마 빼기
	 * @param       : URL		            URL
	 */
	function comma_delete(data) {
       var sum_data = ""
       for (var i = 0 ; i < data.length ; i++ ) {
          if ( data.substring(i,i+1) != "," )
             sum_data = sum_data + data.substring(i,i+1)
          else
            sum_data = sum_data
       }
       return isNaN(sum_data)?0:Number(sum_data);
	}

	/**
	 * Function     : 콤마 호출
	 * @param       : URL		            URL
	 */
	function Comma(obj){
         var frm = document.MAIN_FORM;
         obj.value = comma_insert(obj.value)
	}




    /**
    * Function      : 필수입력 항목을 검사한다.
    *               : 항목이 여러개
    * @param        : formName    - Check 대상 Form Name
    *               : items       - Check 대상 Field Name Array
    * @return       : boolean
    */
    function checkEssentialInputAS(formName, items)
    {
        var form = document.forms[formName];
        var value = null;
        var eleName = null;

        for(var i=0; i<items.length; i++)
        {
            value = trimmed(form[items[i]].value);

            if(value == "" )
            {
                eleName = form[items[i]].alt;
                alert(eleName + '(필수입력) 값을 입력하세요.');

				try{
					form[items[i]].focus();
					form[items[i]].select();
				}
				catch (exception)
				{
				}

                if (form[items[i]].type != 'select-one') {
                    form[items[i]].select();
                }

                return false;
            }
        }

        return true;
    }

	// 팝업창 위치 콘트롤
	// strAlign : center = 화면중간, left_top = 화면좌상단
	// strPage  : 팝업창 별명
	// strWidth : 팝업창 너비
	// strHeight: 팝업창 높이
	function goPopupLocation_x(strUrl, strPage, strWidth, strHeight, strAlign) {
		varForm   = document.mainForm;

		var strLeft   = (screen.Width/1-parseInt(strWidth))/2+1;
		var strTop    = (screen.Height/1-parseInt(strHeight))/2+1;

		if(strAlign == "left_top") {
			strLeft   = 0;
			strTop    = 0;
		}
		newWin = window.open(strUrl, strPage, "left=" +strLeft+",top="+strTop+",width="+strWidth+",height="+strHeight+",resizable=yes, toolbars=no, scrollbars=yes");
        newWin.focus();
	}