// JScript 파일

/** 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 - 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;*/

var bAllCheckFlag = 0;
var sDomain = "";
var clickCount = 0;

browser_type = 0;
if (navigator.userAgent.indexOf("MSIE") != -1)
{
	browser_type = 1;
}

function ChgColor(status,line)
{
	var f = document.forms[0];
	var sObj = "line" + line;
	
	var sObj2 = "f." + line + ".checked";

	if ( browser_type == 1 )
	{
		if (status == 0)
		{
			var sNChecked = "#FFFFFF";
		}
		else
		{
			var sNChecked = "#e8e8e8";
		}

		if (eval(sObj2) == 0)
		{
			eval(sObj).style.backgroundColor = sNChecked;
		}
		else
		{
			eval(sObj).style.backgroundColor = '#e8e8e8';
		}
	}
}

function selectCheckAll(checkcnt, selObj)
{	
	var Form = document.forms[0];
	var j = 0;
    
	for( var i=0; i<Form.elements.length; i++)
	{
		var element = Form.elements[i];

		if (element.name != undefined && element.name.indexOf('ss_') == 0 )
		{
			var status = element.value;
		}

        if (element.name != undefined && element.name.indexOf('sa_') == 0)
		{
			j++;
			if (!element.disabled)
			{
				if ( bAllCheckFlag == 1 )
				{
					if ( j <= checkcnt ) status = 1;
					else status = 0;

					Form.checkall.checked = 0;
					element.checked	= 0;
					
                    ChgColor(0, element.name);
				}
				else
				{
					Form.checkall.checked = 1;
					element.checked	= 1;
					
					ChgColor(1, element.name);
				}
			}
		}
	}
	if ( bAllCheckFlag == 1 )
	{
		selObj.value = "모두선택";
		bAllCheckFlag = 0;
	}
	else
	{
		selObj.value = "선택취소";
		bAllCheckFlag = 1;
	}
}

/* 체크된 데이터 수 확인 */
function getChecked(obj)
{
	var Form = document.forms[0];

	var checked		= "";
	var allArr		= "";

	var count = 0;
	
	if(obj)
	{
	    count = obj.length;

	    if( count > 1 )
	    {
		    for( var i = 0; i < count; i++ )
		    {
			    if( eval("Form.sa_"+i+".checked") )
			    {
				    checked += obj[i].value;
				    checked += "#,#";
			    }
		    }
		    if(checked.substring(checked.length-3, checked.length) == "#,#")
		    {
			    checked = checked.substring(0, checked.length - 3);
		    }

		    if(checked == "") allArr = "";
		    else allArr = checked.split("#,#");
	    }
	    else
	    {
		    if( Form.sa_0.checked )
		    {
			    allArr = obj.value;
		    }
	    }
	}

	return allArr;
}

/* 체크된 데이터 수 확인 */
function getCheckedChk(obj)
{
	var Form = document.forms[0];

	var checked		= "";
	var allArr		= "";

	var count = 0;
	
	if(obj)
	{
	    count = obj.length;

	    if( count > 1 )
	    {
		    for( var i = 0; i < count; i++ )
		    {
			    if( eval("Form.sa_"+i) )
			    {
				    checked += obj[i].value;
				    checked += "#,#"+eval("Form.sa_"+i+".checked")+"|";
			    }
		    }
		    if(checked.substring(checked.length-3, checked.length) == "#,#")
		    {
			    checked = checked.substring(0, checked.length - 3);
		    }

		    if(checked == "") allArr = "";
		    else allArr = checked.split("#,#");
	    }
	    else
	    {
	    
			    allArr = obj.value+","+eval("Form.sa_0.checked")+"|";
	    }
	}
    
	return allArr;
}

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

    1. 일반적으로 obj tag와 관계없이 사용되는 기능.
    2. Function List
        - OpenWindow(theURL, winName, features)
        : 새창 열기
        - Alert(message)
        : 메세지를 알리는 메세지박스 표시
        - AlertConfirm(message)
        : 사용자의 의사결정을 포함하는 메세지박스 표시
        - AlertFocus(element, message)
        : 메세지를 알리는 메세지박스 표시 후 Element에 지정된 obj tag 로 focus
        - ShowErrMessage(message)
        : 서버 프로그램에서 생긴 ERROR 를 보여주는 MESSAGEBOX ALERT
        - fnDbClick()
        : 더블클릭 방지
============================================================================*/
/**
  * 새창열기
  *  window.open 에서 사용되는 방식으로 features 설정
  * @param theURL    새창의 Url
  * @param winName   새창의 name
  * @param features  새창의 세부 설정
  * @return
 */
//function OpenWindow(theURL,winName,features)
//{
//    window.open(theURL,winName,features);
//}

// 팝업 띄우기 옵션
function CloseWin(targetURL)
{
	opener.location.href = targetURL;
	this.close();
}

// 부모창 새로고침
function ParentRefreshClose(targetURL)
{
	opener.window.location.href=targetURL;
	this.close();
}

// 부모창 새로고침2
function ParentRefreshWinClose()
{
	opener.document.location.reload()
	this.close();
}

// 윈도우 사이즈 바꾸기
function WindowResize(nWidth, nHeight)
{
	window.resizeTo(nWidth, nHeight);
}


/**
  * 메세지를 알리는 메세지박스 표시
  * @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.select();
   return ;
}

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

function fnDbClick()
{
	if(event.button >= 1) alert("잠시 기다려 주십시오. 지금 처리중입니다.");
}

function processKey()
{
	if( (event.ctrlKey == true && (event.keyCode == 78 || event.keyCode == 82)) ||
		(event.keyCode >= 112 && event.keyCode <= 123) )
	{
		event.keyCode = 0;
		event.cancelBubble = true;
		event.returnValue = false;
	}
	
    if (document.layers) 
    {
        document.captureEvents(Event.MOUSEDOWN);document.onmousedown=clickNS;
    }
    else
    {   
        document.onmouseup=clickNS;document.oncontextmenu=clickIE;
    }
	document.oncontextmenu=new Function("return false");
}

function clickIE() 
{
    if (document.all) {(message);return false;}
}

function clickNS(e) 
{
    if (document.layers||(document.getElementById&&!document.all)) 
    {
        if (e.which==2||e.which==3) 
        {(message);return false;}
    }
}


/*= 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)
        : 입력 필드의 문자 크기를 얻는다.. (한글까지 고려하여 계산됨)
        - calcByte( String ) 
        : messageStr의 byte 수를 계산. (maxByte + 1), (maxByte + 2 )까지만 계산
        - cutText( String, String) 
        : 최대 byte수를 초과하는 문자열을 잘라내고 나머지를 리턴
        - remove0d( String) 
        : 마지막에 "%0d" 제거
============================================================================*/

/**
  * 입력 받은 폼태그(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;
}

/**
  * messageStr의 byte 수를 계산. (maxByte + 1), (maxByte + 2 )까지만 계산
  * maxByte 보다 큰 경우 에는 cutStringIndex에 String Length값을 저장.
  * @param messageStr   문자열
  * @return tcount 문자열의 길이
 */
function calcByte( messageStr ) 
{
	var tcount = 0;

	for ( k = 0; k < messageStr.length; k++ ) {

		var onechar = messageStr.charAt( k );

      	if ( escape( onechar ).length > 4 ) {
        	tcount += 2;
       	} else if ( onechar!='\r') {
           	tcount++;
        }

  	}
	return tcount;
}


/**
  * 최대 byte수를 초과하는 문자열을 잘라내고 나머지를 리턴.
  * @param msgStrg 원본 String
  * @param maxByte 최대 byte 값.
  * @return String  잘라낸 문자열
 */
function cutText( msgStr, maxByte) 
{

	var cutStringIndex;
	var tcount = 0;

	var k = 0;
	for ( k ; k < msgStr.length; k++ ) 
	{

		var onechar = msgStr.charAt( k );
      	if ( escape( onechar ).length > 4 ) 
      	{
        	tcount += 2;
       	} else if ( onechar!='\r') 
       	{
           	tcount++;
        }

        if( tcount > maxByte ) 
        {

            break;
       	}

  	}

	return remove0d( msgStr.substring(0, k) );

}

/**
  * 마지막에 "%0d" 제거
  * @param String   문자열
  * @return String  잘라낸 문자열
 */
function remove0d( str ) 
{

	str = escape( str );

	if ( str.lastIndexOf("%0D") >= str.length - 3 ) 
	{
		str = str.substring( 0, str.lastIndexOf("%0D") );
	}
	return unescape( str );
}


/**
  * 대상 Object를 disable 시킨다.
  * @param  obj   대상 폼태그(Object)
  * @return
 */
function DisableObject(obj)
{
	switch( obj.type ) {
		case "checkbox" :
			 obj.disabled = true;
			 break;
		case "text" :
			 obj.readOnly=true;
	         obj.style.backgroundColor = "#E9F8F2";
	         obj.style.color = "#555555";
			 break;
		default:
	}
}

/**
  * 대상 Object를 enable 시킨다.
  * @param obj   대상 폼태그(Object)
  * @return
 */
function EnableObject(obj)
{
	switch( obj.type ) {
		case "checkbox" :
			 obj.disabled = false;
			 break;
		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]);
		}
	}
}

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

    1. CHECKBOX 관련 기본 기능을 처리.
    2. Function List
        - TogleCheckAll(Object, Object)
        : checkbox들을 반복하여 선택하거나 해지한다.
        - SetAllCheckboxCancel(Object)
        : checkbox를 모두 해지한다.
        - SetAllCheckboxCheck(Object)
        : checkbox를 모두 선택 표시한다.
        - IsChecked(Object)
        : 리스트에서 하나이상의 체크박스가 선택되었는지 확인한다.
        - IsCheckedOnlyOne(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){
	if (obj != null) {
		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){
	if (obj != null) {
		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;
}

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

/**
  * CHECKBOX를 모두 해지한다.
  * @param obj   해당 CHECKBOX 의 OBJECT
  * @return
 */
function SetAllCheckboxCancelByElement(objNm){

	var Form = document.forms[0];
	var j = 0;
    
	for( var i=0; i<Form.elements.length; i++)
	{
		var element = Form.elements[i];

		if ( element.name.indexOf(objNm) >= 0 )
		{
			element.checked = false;
		}
	}
    return;
}

/**
  * CHECKBOX를 모두 선택 표시한다.
  * @param obj   해당 CHECKBOX 의 OBJECT

  * @return
 */
function SetAllCheckboxCheckByElement(objNm){
	var Form = document.forms[0];
	var j = 0;
    
	for( var i=0; i<Form.elements.length; i++)
	{
		var element = Form.elements[i];

		if ( element.name.indexOf(objNm) >= 0 )
		{
			element.checked = true;
		}
	}
    return;
}

/**
  * 리스트에서 하나이상의 체크박스가 선택되었는지 확인한다.
  * @param obj   해당 CHECKBOX 의 OBJECT
  * @return
 */
function IsCheckedByElement(objNm)
{
    var Form = document.forms[0];
    var iChecked = 0;

	for( var i=0; i<Form.elements.length; i++)
	{
		var element = Form.elements[i];

		if ( element.name.indexOf(objNm) >= 0 && element.checked)
		{
			iChecked++;
		}
	}

    if (iChecked == 0) 
    {
        return false;
    }
    return true;
}

/*= 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)만으로 되어있는지 체크
        - IsAlphabet(Object)
        : 입력값이 알파벳인지 체크
        - IsUpperCase(Object)
        : 입력값이 알파벳 대문자인지 체크
        - IsLowerCase(Object)
        : 입력값이 알파벳 소문자인지 체크
        - IsNumber(Object)
        : 입력된 문자열이 숫자 만을 포함하고 있는지 여부 리턴
        - IsAlphaNum(Object)
        : 입력값이 알파벳,숫자로 되어있는지 체크
        - IsNumDash(Object)
        : 입력값이 숫자,대시(-)로 되어있는지 체크
        - IsNumComma(Object)
        : 입력값이 숫자,콤마(,)로 되어있는지 체크
        - IsNumPeriod(Object)
        : 입력값이 숫자,날짜 구분자(.)로 되어있는지 체크

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

String.prototype.trim = function()
{
	//return this.replace(/^s*(b.*b|)s*$/, "$1"); // 문장의 앞과 뒤의 공백 제거
	a = this
	//alert(a)
	var search = 0
	while ( a.charAt(search) == " ")
	{
		search = search + 1
	}

	a = a.substring(search, (a.length))
	search = a.length - 1
	while (a.charAt(search) ==" ")
	{
		search = search - 1
	}
	return a.substring(0, search + 1)
} 

/**
 * 입력값이 NULL인지 체크
 * @param obj   Object
 * @return true : Null 또는 공백
 */
function IsNull(obj) {
    if (obj.value == null || obj.value.trim() == "") {
        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;
}
/*
function RemoveSpaces(obj, msg)
{
    var str = obj.value;
    var ret = "";
    
    if (str.length != 0)
	{
    	for (var i=0; i<str.length; i++) 
    	{
    	    if (str.charAt(i) != " ")
    	    {	
    	    	ret += str.charAt(i);
    	    }
    	    else
    	    {
    	    	alert("띄어쓰기 없이 입력해 주세요.");
    	    }
    	}
    	
    	obj.value = 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) 
{
	var newvalue = obj.value.trim();
	
    for (var inx = 0; inx < newvalue.length; inx++) 
    {
       if (chars.indexOf(newvalue.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);
}

//modified by mkkim 2004.10.29
function IsNumber_mkkim(num) {
    var chars = "0123456789";
    var new_number = num;

    for (var inx = 0; inx < num.length; inx++) {
       if (chars.indexOf(num.charAt(inx)) == -1)
           return false;
    }
    return true;
}
/**
 * 입력값이 알파벳,숫자로 되어있는지 체크
 * @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;
}

/**
  * 입력된 문자열이 숫자 만을 포함하고 있는지를 체크하고 ,
  * 문자열의 길이가 특정 길이(Int)와 같은지 여부 체크
  * 오류가 있을 경우 메세지를 표시하고 focus 이동
  * @param obj   Object
  * @return true - 숫자만을 포함하고 있는 경우
  * @create by mkkim 060905
 */
function IsNumberChkLenMessage(obj, len) {
    if (!IsNumber(obj)) {
        //AlertFocus(obj, '숫자만 입력하십시오');
        return false;
    }

    if (!ChkLen(obj, len)) {
        //AlertFocus(obj, len+'자리 만큼만 입력해야 합니다.\n예를 참고하시오');
        return false;
  	}

    return true;
}

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

    1. 숫자 관련 기본 기능을 처리.
    2. Function List
        - AddComma(Object)
        : 입력값을 콤마가 포함된 문자열로 변환하여 리턴
          12345 를 입력하면 12,345 로 변환하여 리턴
        - RemoveComma(String)
        : 입력값에서 콤마를 없앤다.
        - RemoveDash(String)
        : 입력값에서 구분자(-)를 없앤다.
        - RemovePeriod(String)
        : 입력값에서 날짜 구분자(.) 를 없앤다.
        - ParseInt(str)
        : 문자열을 정수로 변환하여 리턴

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

/**
  * 입력값을 콤마가 포함된 문자열로 변환하여 리턴
  * @param obj   숫자
  * @return ret  콤마를 추가한 숫자
 */
function AddComma(obj) {
    var ret;
    if (!IsMoney(obj)) {
        obj.value = obj.value.substring(0, obj.value.length-1);
        
	    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, '.', '');
}

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

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

    1. 일자와 시간 관련 기본 기능을 처리.
    2. Function List
        - IsDate(Object)
        : 입력값을 일자 Format 인지 확인
        - IsMonth(month)
        : 입력된 문자열이 일자의 월로 변환가능한지 확인
        - IsDay(year, month, day)
        : 입력된 문자열이 일자의 일로 변환가능한지 확인
        - GetEndDay(year, month)
        : 해당 년, 월의 마지막 일자를 가져온다
        - AddDateSeperator(Object)
        : 입력값에 일자 형식에 맞추어 DATE_SEPERATOR 를 추가한다.
        - IsTime(Object)
        : 입력값을 시간 Format 인지 확인
        - IsTimeStr(Str)
        : 입력값을 시간 Format 인지 확인

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

/**
  * 입력된 문자열이 일자 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 ( ParseInt( year ) >= 1900  && IsMonth( month ) && IsDay( year,month ,day) )
		return true;
	else {
	        obj.value = '';
        //AlertFocus(obj, "날짜는 YYYYMMDD의 형식으로 입력하십시오");
		return false;
	}
}

/**
  * 입력된 문자열이 6자리 일자 Format 확인
  * @param str   문자열
  * @return true 일자 , false
 */
function IsDateSixLength ( 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);
    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;
  if (!IsDate(obj)) {
      return false;
  }
  var numstr = RemovePeriod(obj.value);
  if (numstr.length != 8) {
      obj.value = '';
      //AlertFocus(obj, "날짜는 YYYYMMDD의 형식으로 입력해주십시오");
      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), ParseInt(numstr1.substr(4,2))-1, ParseInt(numstr1.substr(6)));
    var numstr2 = RemovePeriod(toObj.value);
    var user_day2 = new Date(numstr2.substr(0,4), ParseInt(numstr2.substr(4,2))-1, ParseInt(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), ParseInt(numstr.substr(4,2))-1, ParseInt(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;
}
/**
  * 입력된 문자열 시간 Format 확인
  * @param str   문자열
  * @return true 일자 , false
 */
function IsTime ( obj )
{
	str = RemoveSpaces(obj.value);
	str = RemovePeriod(str);
	if (!IsNumPeriod(obj)) {
	    obj.value = '';
        //AlertFocus(obj, "시간은 HH24MI의 형식으로 입력하십시오");
        return false;
	}
	if (str.length != 4) {
	    obj.value = '';
        //AlertFocus(obj, "시간은 HH24MI의 형식으로 입력하십시오");
	    return false;
	}

	var hour  = str.substring(0,2);
	var minute = str.substring(2,4);

	if ( ParseInt( hour ) <= 23 && ParseInt( minute ) <= 59 )
		return true;
	else {
	    obj.value = '';
        //AlertFocus(obj, "시간은 23시 59분 이내로 입력해야 합니다.");
		return false;
	}
}

/**
  * 입력된 문자열 시간 Format 확인
  * @param str   문자열
  * @return true 일자 , false
 */
function IsTimeStr ( value )
{
	str = RemoveSpaces(value);
	str = RemovePeriod(str);

	if (str.length != 4) {
        Alert("시간은 HH24MI의 형식으로 입력하십시오");
	    return false;
	}

	var hour  = str.substring(0,2);
	var minute = str.substring(2,4);

	if ( ParseInt( hour ) <= 23 && ParseInt( minute ) <= 59 )
		return true;
	else {
        Alert("시간은 23시 59분 이내로 입력해야 합니다.");
		return false;
	}
}

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

    1. TEXT 입력 값의 유효성을  확인한다.
    2. Function List
        - IsValidJumin
        : 문자열이 올바른 주민등록번호인지 확인하여 리턴
        - IsValidSaupja
        : 문자열이 올바른 사업자등록번호인지 확인하여 리턴
        - IsValidBeopin
        : 문자열이 올바른 법인번호인지 확인하여 리턴
        - IsValidAccountPassword
        : 신규계좌 생성시 입력된 비밀번호의 유효성을 확인한다.

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

/**
  * 재외국인 번호 체크
 * @param obj   Object
  * @return true : 바른 주민등록번호일 경우
 */
function IsValidFgnNo(oResNo) {

	if(IsEmpty(oResNo)){
		return false;
	}
	var fgnno = oResNo.value;
	if(fgnno.length != 13) {
		return false;
    }
    
    var sum=0;
    var odd=0;
    buf = new Array(13);
    for(i=0; i<13; i++) { buf[i]=parseInt(fgnno.charAt(i)); }
    odd = buf[7]*10 + buf[8];
    if(odd%2 != 0) { return false; }
    if( (buf[11]!=6) && (buf[11]!=7) && (buf[11]!=8) && (buf[11]!=9) ) {
            return false;
    }
    multipliers = [2,3,4,5,6,7,8,9,2,3,4,5];
    for(i=0, sum=0; i<12; i++) { sum += (buf[i] *= multipliers[i]); }
    sum = 11 - (sum%11);
    if(sum >= 10) { sum -= 10; }
    sum += 2;
    if(sum >= 10) { sum -= 10; }
    if(sum != buf[12]) { return false }
    return true;
}

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

    if(juminno=="" || juminno==null || juminno.length!=13) {
            //alert("주민등록번호를 입력하세요.");
            return false;
    }
    var jumin1 = juminno.substr(0,6);
    var jumin2 = juminno.substr(6,7);
    var yy         = jumin1.substr(0,2);        // 년도
    var mm = jumin1.substr(2,2);        // 월
    var dd = jumin1.substr(4,2);        // 일
    var genda = jumin2.substr(0,1);        // 성별
    var msg, ss, cc;

    // 숫자가 아닌 것을 입력한 경우
    if (!isNumeric(jumin1)) {
            //alert("주민등록번호 앞자리를 숫자로 입력하세요.");
            return false;
    }
    // 길이가 6이 아닌 경우
    if (jumin1.length != 6) {
            //alert("주민등록번호 앞자리를 다시 입력하세요.");
            return false;
    }
    // 첫번째 자료에서 연월일(YYMMDD) 형식 중 기본 구성 검사
    if (yy < "00" || yy > "99" ||
            mm < "01" || mm > "12" ||
            dd < "01" || dd > "31") {
            //alert("주민등록번호 앞자리를 다시 입력하세요.");
            return false;
    }
    // 숫자가 아닌 것을 입력한 경우
    if (!isNumeric(jumin2)) {
            //alert("주민등록번호 뒷자리를 숫자로 입력하세요.");
            return false;
    }
    // 길이가 7이 아닌 경우
    if (jumin2.length != 7) {
            //alert("주민등록번호 뒷자리를 다시 입력하세요.");
            return false;
    }
    // 성별부분이 1 ~ 4 가 아닌 경우
    if (genda < "1" || genda > "4") {
            //alert("주민등록번호 뒷자리를 다시 입력하세요.");
            return false;
    }
    // 연도 계산 - 1 또는 2: 1900년대, 3 또는 4: 2000년대
    cc = (genda == "1" || genda == "2") ? "19" : "20";
    // 첫번째 자료에서 연월일(YYMMDD) 형식 중 날짜 형식 검사
    if (isYYYYMMDD(parseInt(cc+yy), parseInt(mm), parseInt(dd)) == false) {
            //alert("주민등록번호 앞자리를 다시 입력하세요.");
            return false;
    }
    // Check Digit 검사
    if (!isSSN(jumin1, jumin2)) {
            //alert("올바른 주민등록번호가 아닙니다.");
            return false;
    }
    return true;
}

/**
  * 문자열이 올바른 사업자등록번호인지 확인하여 리턴
 * @param obj   Object
 * @return true : 바른 사업자등록번호일 경우
 */
function IsValidSaupja(oCorpNo)
{
    if (IsEmpty(oCorpNo)) return false;
    var vencod = RemoveDash(oCorpNo.value);
	if(vencod.length != 10) {
	    return false;
    }

    var sum = 0;
    var getlist =new Array(10);
    var chkvalue =new Array("1","3","7","1","3","7","1","3","5");
    for(var i=0; i<10; i++) { getlist[i] = vencod.substring(i, i+1); }
    for(var i=0; i<9; i++) { sum += getlist[i]*chkvalue[i]; }
    sum = sum + parseInt((getlist[8]*5)/10);
    sidliy = sum % 10;
    sidchk = 0;
    if(sidliy != 0) { sidchk = 10 - sidliy; }
    else { sidchk = 0; }
    if(sidchk != getlist[9]) { return false; }
    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;
    }
}

/* 주민번호, 사업자번호 체크시 사용하는 함수 */
function isYYYYMMDD(y, m, d) {
    switch (m) {
    case 2:        // 2월의 경우
            if (d > 29) return false;
            if (d == 29) {
                    // 2월 29의 경우 당해가 윤년인지를 확인
                    if ((y % 4 != 0) || (y % 100 == 0) && (y % 400 != 0))
                            return false;
            }
            break;
    case 4:        // 작은 달의 경우
    case 6:
    case 9:
    case 11:
            if (d == 31) return false;
    }
    // 큰 달의 경우
    return true;
}
function isNumeric(s) {
    for (i=0; i<s.length; i++) {
        c = s.substr(i, 1);
        if (c < "0" || c > "9") return false;
    }
    return true;
}
function isLeapYear(y) {
    if (y < 100)
    y = y + 1900;
    if ( (y % 4 == 0) && (y % 100 != 0) || (y % 400 == 0) ) {
            return true;
    } else {
            return false;
    }
}
function getNumberOfDate(yy, mm) {
    month = new Array(29,31,28,31,30,31,30,31,31,30,31,30,31);
    if (mm == 2 && isLeapYear(yy)) mm = 0;
    return month[mm];
}
function isSSN(s1, s2) {
    n = 2;
    sum = 0;
    for (i=0; i<s1.length; i++)

            sum += parseInt(s1.substr(i, 1)) * n++;
    for (i=0; i<s2.length-1; i++) {
            sum += parseInt(s2.substr(i, 1)) * n++;
            if (n == 10) n = 2;
    }
    c = 11 - sum % 11;
    if (c == 11) c = 1;
    if (c == 10) c = 0;
    if (c != parseInt(s2.substr(6, 1))) return false;
    else return true;
}


/*= 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
        - 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)) {
        //AlertFocus(obj, "숫자만 입력하십시오.");
        return false;
    }
    if (!IsValidJumin(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, "잘못된 형식의 실명번호입니다");
    }
}

/**
 * 10자리 혹은 13자리의 사업자번호,주민번호를 입력받아 자동으로 '-'를 더하여 리턴
 * @param obj1   Object
 * @param obj2   Object
 * @return acct 사업자번호, 주민번호
 */
function checkSilmyungNo(obj1, obj2)
{
	var obj = obj1.value+obj2.value;
    if (IsEmpty(obj)) return;
    if (obj.length == 10) {
        AddSeperatorToSaupjaNo(obj);
    } else if (obj.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;
}

/**
 * 숫자만 입력되었는지 체크한다.
 * @param obj Object
 * @return
 */
function checkNum(obj) {
	if (IsEmpty(obj)) return;
	if(IsNumber(obj) == false) {
		AlertFocus(obj, "숫자만 입력하십시오.");
        return false;
	}
}

/**
* 텍스트 박스의 문자열 길이를 체크한다.
*
* @param    obj, maxlen
* @return    void
*/
function CheckLen(obj, maxlen, msgNo, msgText)
{
    var str_src    = obj.value;
    var str_len = GetLenByByte(str_src);
    var message;

    if(str_len > maxlen)
    {
        //message = GetMsg(msgNo, msgText, Math.floor(maxlen/2), maxlen);
        message = GetMsg(msgNo, msgText, maxlen, maxlen);

        alert(message);
        //alert(maxlen + "바이트까지만 입력 가능합니다.");
        obj.value = stringCut(str_src, maxlen);
        return false;
    }
    else return true;
}


/**
* 문자열 자르기
*
* @param    string    str        사용자가 입력한 문자열
* @param    int        MAX_LEN    입력문자의 최대값
* @return    string    str
*/
function stringCut(str, MAX_LEN)
{
    var str;
    var len = 0;

    var temp;
    var count = 0;

    len = str.length;

    for (k=0 ; k<len ; k++)
    {
        temp = str.charAt(k);

        if (escape(temp).length > 4) {
            count += 2;
        }
        else
            if(escape(temp) != "%0D")
                count++;

        if(count > MAX_LEN)
        {
            break;
        }
    }

    return str.substring(0, k);

}

/**
 * radio 버튼 중 선택한 값을 Return한다.
 * @param field : radio button 객체
 * @return 선택한 값
 */
function getCheckedValue(radio) {
    var len = radio.length;
    var chkValue = "";

    if(len > 1)
    {
        for(i=0; i<len; i++) {
            if(radio[i].checked == true) {
                chkValue = radio[i].value;
                break;
            }
        }
    }
    else
    {
        if(radio.checked)
            chkValue = radio.value;
    }
    return chkValue;
}

/**
 * radio 버튼 중 선택한 값을 Return한다.
 * @param Form : form 객체
 * @param name : 컨트롤명 
 * @return 선택한 값
 */
function getElementCheckedValue(Form, name) {
    var element;
    var eName;
    
    name = fnReverse(name);
    
    for( var i=0; i<Form.elements.length; i++)
    {
        element = Form.elements[i];
        eName = fnReverse(element.name);
        
        if (eName.indexOf(name) == 0)
        {
            if(element.checked)
            {
                return element.value;
            }
        }
    }
    
    return "";
}

/**
 * element return
 * @param Form : form 객체
 * @param name : 컨트롤명 
 * @return element
 */
function getElement(Form, name)
{
    var element;
    var eName = "";

    name = fnReverse(name);

    for( var i=0; i<Form.elements.length; i++)
    {
        element = Form.elements[i];
        if(element != undefined)
        {
            eName = fnReverse(element.name);
            
            if (eName.indexOf(name) == 0 )
            {
                return element;
                break;
            }
        }
    }
    
    return null;
}

/**
 * element return
 * @param id : 컨트롤 ID
 * @return element
 */
function getDocElementId(id)
{
    var element;
    var eId ;
    
    id = fnReverse(id);
    
    for(i=0; i<document.all.length; i++)
    {
        element = document.all[i];
        eId = fnReverse(document.all[i].id);
        
        if (eId.indexOf(id) == 0 )
        {
            return element;
            break;
        }
    }

    return null;
}
    
// 문자열 뒤집기
function fnReverse( str )
{
    var revStr = "";
    var i, len;

    len = str.length - 1;
    
    for(i=len; i>=0; i--)
    {
        revStr += str.charAt(i);
    }
    
    return revStr;
}

// 이미지 포맷 체크
function checkImgFormat(msg, imgPath)
{
	if (imgPath.toLowerCase().indexOf(".png") != -1 || imgPath.toLowerCase().indexOf(".jpg") != -1 || imgPath.toLowerCase().indexOf(".gif") != -1)
	{
		return true;
	}
	else
	{

		if (imgPath.trim() != "" )
		{
			alert(msg + "은(는) PNG, JPG, GIF파일만  허용됩니다.");
			return false;
		}
	}
}

// 이미지 포맷 체크
function checkImgFormatJPG(msg, imgPath)
{
	if (imgPath.toLowerCase().indexOf(".jpg") != -1)
	{
		return true;
	}
	else
	{

		if (imgPath.trim() != "" )
		{
			alert(msg + "은(는) jpg, JPG파일만 허용됩니다.");
			return false;
		}
	}
}

//function fnCheckDateLimit(form, nowdate, sname, ename, maxmonth) 
//{	
//    if(maxmonth == "") maxmonth = "0";
//    
//	var Form = form;
//	var str1 = "";
//	var str2 = "";
//	var maxday = maxmonth * 30;

//	if(sname == "") sname = "txtSchFromDt";
//	if(ename == "") ename = "txtSchToDt";
//	
//	if( fnCheckDate(Form, nowdate, sname, ename))
//	{
//		if(maxmonth != "0" && parseInt(GetDaysBetween(eval("Form."+sname), eval("Form."+ename))) >  maxday)
//		{	
//			Alert(GetMsg('207', maxmonth, null, null));
//			SetFocus(eval("Form."+ename));
//			return false;
//		}
//		return true;	
//	}
//	return false;
//}

//function fnCheckDate(form, nowdate, sname, ename) 
//{
//	var Form = form;
//	
//	if(sname == "") sname = "txtSchFromDt";
//	if(ename == "") ename = "txtSchToDt";

//	if(IsNumber(eval("Form."+sname)) == false || eval("Form."+sname).value.length != 8)
//	{
//		Alert(GetMsg('200', "검색시작일", null, null));
//		SetFocus(eval("Form."+sname));
//		return false;
//	}
//	
//	if(IsNumber(eval("Form."+ename)) == false || eval("Form."+ename).value.length != 8) 
//	{
//		Alert(GetMsg('200', "검색시작일", null, null));
//		SetFocus(eval("Form."+ename));
//		return false;
//	}
//	
//	if(parseInt(eval("Form."+sname).value) >  parseInt(eval("Form."+ename).value))
//	{
//		Alert(GetMsg('204', null, null, null));
//		SetFocus(eval("Form."+ename));
//		return false;
//	}
//	
//	return true;
//}

function fnCheckDateLimit(form, sname, ename, condition, title, maxmonth) 
{
    if (maxmonth == "") maxmonth = "0";

    var Form = form;
    var str1 = "";
    var str2 = "";
    var maxday = eval(maxmonth) * 30;

    maxday = maxday + (eval(maxmonth) / 2) + (eval(maxmonth) % 2);   // 31일 계산

    if (sname == "") sname = "txtSchStartDt";
    if (ename == "") ename = "txtSchEndDt";

    if (title == "") title = "검색일"
    else title = title + "일"

    var stitle = title + "시작일";
    var etitle = title + "종료일";

    if (fnCheckDate(form, sname, ename, stitle, etitle)) 
    {
        if (maxmonth != "0" && parseInt(GetDaysBetween(eval("Form." + sname), eval("Form." + ename))) > maxday) {
            if (condition != "") {
                Alert(GetMsg('212', condition, title, maxmonth));
                SetFocus(eval("Form." + ename));
                return false;
            }
            else {
                Alert(GetMsg('213', title, maxmonth, ""));
                SetFocus(eval("Form." + ename));
                return false;
            }
        }
        return true;
    }
    return false;
}

function fnCheckDate(form, sname, ename, stitle, etitle) {
    var Form = form;

    if (sname == "") sname = "txtSchStartDt";
    if (ename == "") ename = "txtSchEndDt";

    if (stitle == "") stitle = "검색시작일";
    if (etitle == "") etitle = "검색종료일";

    if (IsNumber(eval("Form." + sname)) == false || eval("Form." + sname).value.length != 8) {
        Alert(GetMsg('200', stitle, null, null));
        SetFocus(eval("Form." + sname));
        return false;
    }

    if (IsNumber(eval("Form." + ename)) == false || eval("Form." + ename).value.length != 8) {
        Alert(GetMsg('200', etitle, null, null));
        SetFocus(eval("Form." + ename));
        return false;
    }

    if (parseInt(eval("Form." + sname).value) > parseInt(eval("Form." + ename).value)) {
        Alert(GetMsg('208', stitle, etitle, null));
        SetFocus(eval("Form." + ename));
        return false;
    }

    return true;
}

function fnCheckMonthLimit(form, sname, ename, etitle, maxmonth) 
{	
    if(maxmonth == "") maxmonth = "0";
    
	var Form = form;

	if(sname == "") sname = "txtSchStartDate";
	if(ename == "") ename = "txtSchEndDate";
	if(etitle == null || etitle == "") etitle = "종료";
	
	if( fnCheckMonth(Form, sname, ename, etitle))
	{
//		if(maxmonth != "0" && parseInt(GetDaysBetween(eval("Form."+sname), eval("Form."+ename))) >  maxday)
//		{	
//			Alert(GetMsg('207', maxmonth, null, null));
//			SetFocus(eval("Form."+ename));
//			return false;
//		}
		return true;	
	}
	
	return false;
}

function fnCheckMonth(form, sname, ename, etitle) 
{
	var Form = form;
	
	if(sname == "") sname = "txtSchStartDate";
	if(ename == "") ename = "txtSchEndDate";
	if(etitle == null || etitle == "") etitle = "종료";
	
	etitle = etitle + "년월";

	if(IsNumber(eval("Form."+sname)) == false || eval("Form."+sname).value.length != 6)
	{
		Alert(GetMsg('201', "시작년월", null, null));
		SetFocus(eval("Form."+sname));
		return false;
	}
	
	if(IsNumber(eval("Form."+ename)) == false || eval("Form."+ename).value.length != 6) 
	{
		Alert(GetMsg('201', etitle, null, null));
		SetFocus(eval("Form."+ename));
		return false;
	}
	
	if(parseInt(eval("Form."+sname).value) >  parseInt(eval("Form."+ename).value))
	{
		Alert(GetMsg('210', etitle, null, null));
		SetFocus(eval("Form."+ename));
		return false;
	}
	
	return true;
}

function fnConvertEmoticon(str)
{
    str = ReplaceStr(str,"cR_","<br/>");
    str = ReplaceStr(str,"sQ_","'");
    str = ReplaceStr(str,"dQ_","\"");
    
    return str;
}
       
function fnOnlyNumberKey(keyCode)
{
    if (event.ctrlKey == true || keyCode == 8 || keyCode == 9 || keyCode == 13 || keyCode == 17 || keyCode == 37 || keyCode == 39 || keyCode == 46 || (keyCode > 95 && keyCode < 106))
    {
        return true;
    }
    else if(keyCode < 48 || keyCode > 57)
    {
        alert("숫자만 입력할 수 있습니다.");
        return false;
    }
    else
    {
        return true;
    }
}

function fnOnlyNumberDashKey(keyCode) {
    if (event.ctrlKey == true || keyCode == 189 || keyCode == 8 || keyCode == 9 || keyCode == 13 || keyCode == 37 || keyCode == 39 || keyCode == 46 || (keyCode > 95 && keyCode < 106)) {
        return true;
    }
    else if (keyCode < 48 || keyCode > 57) {
        alert("숫자만 입력할 수 있습니다.");
        return false;
    }
    else {
        return true;
    }
}

function chkClick() 
{
    if (clickCount > 1) 
    {
        return false;
    }
    else {
        clickCount++;
        return true;
    }
}

// object 절대좌표 구하기
function getAbsolutePos(obj) {
    var position = new Object;
    position.x = 0;
    position.y = 0;

    if (obj) {
        position.x = obj.offsetLeft;
        position.y = obj.offsetTop;

        if (obj.offsetParent) {
            var parentpos = getAbsolutePos(obj.offsetParent);
            position.x += parentpos.x;
            position.y += parentpos.y;
        }
    }
    return position;
}