/***********************************************************
	시스템명  		: 필화2.0
	업무명 			: 시스템
	파일명 			: main.js
	프로그램명 	: 각종 기능 구현 자바스크립트
	개요 				: 필요한 각종 자바스크립트 기능을 제공한다.
	작성자 			: ABC
	작성일 			: 2004. 12. 21.
   	수정일 			: 2005.01.13 
   	수정일 			: 2005.01.27 (by 장준보 : is_valid_date, is_valid_time 다시 구현)
   	수정일 			: 2005.02.01 (by 정재호 : is_valid_hour, is_valid_min, is_valid_sec 다시 구현)
   	수정일 			: 2005.02.22 (by 신희종 : is_cellularno 수정)
   	수정일 			: 2005.03.10 (by 신희종 : key_only_number 수정)
   	수정일 			: 2005.04.06 (by 신희종 : checkPassword() 함수 추가)
   	수정일 			: 2007.03.27 (by 한상학 : 소스 및 주석 정리)	
 ***********************************************************/

/*
 * 기능 : 인자로 넘어온 두개의 문자열이 유효한 주민번호인지 체크한다.
 * 인자 : p_resno1 - 주민번호 앞6자리, p_resno2 - 주민번호 뒤7자리
 * 반환 : boolean - true, false
 * ex) is_resno("111111", "2121211")는 false를 반환한다.
*/
function is_resno( p_resno1, p_resno2 ){
	var a = new Array(13);
	var b = new Array(2,3,4,5,6,7,8,9,2,3,4,5);
	var sum = 0;
	var v_resno = p_resno1 +''+ p_resno2;

	if( is_empty(v_resno) ){
		alert("주민등록번호를 입력해 주십시오.");
		return false;
	}

	if( !is_number(v_resno) ){
		alert("주민등록번호는 숫자만 입력할 수 있습니다.");
		return false;
	}

	if( v_resno.length != 13 ){
		alert("주민등록번호 길이가 맞지 않습니다.");
		return false;
	}

	if ( fgn_no_chksum(v_resno) ){	//	외국인 주민등록번호인지 먼저 점검
		return true;
	} else {	//	내국인 주민등록번호인지 점검
		v_sex_digit = parseInt( v_resno.substring(6,7) );
		
		if( (v_sex_digit < 1) || ( 4 < v_sex_digit) ){
			alert("잘못된 주민등록 번호입니다.");
			return false;
		}
		
		switch( v_sex_digit ) {
			case 1 : v_birth_dt = "19" + v_resno.substring(0,6); break;
			case 2 : v_birth_dt = "19" + v_resno.substring(0,6); break;
			case 3 : v_birth_dt = "20" + v_resno.substring(0,6); break;
			case 4 : v_birth_dt = "20" + v_resno.substring(0,6); break;
		}
		
		if( !is_valid_date(v_birth_dt,'주민등록 번호의 ') ) {
			return false;
		}
		
		for(i=0; i<13; ++i) a[i] = v_resno.substr(i,1);
		for(i=0; i<12; ++i) sum = sum + (a[i] * b[i]);
		
		x = sum % 11;
		y = 11 - x;
		z = y % 10;
		
		if(z != a[12]) {
			alert("주민등록 번호가 잘못 입력되었습니다.");
			return false;
		}
	}

	return true;
}

/*
 * 기능 : 인자로 문자열이 유효한 외국인 주민번호인지 체크한다.
 * 인자 : reg_no - 외국인 주민번호
 * 반환 : boolean - true, false
 * ex) fgn_no_chksum("111111")는 false를 반환한다.
*/
function fgn_no_chksum(reg_no) {
	var sum = 0;
	var odd = 0;
	
	buf = new Array(13);
	for (i = 0; i < 13; i++) {
		buf[i] = parseInt(reg_no.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;
	}
	else {
		return true;
	}
}

/*
 * 기능 : 인자로 넘어온 세개의 문자열이 유효한 사업자번호인지 체크한다.
 * 인자 : p_bizno1 - 사업자번호, p_bizno2 - 사업자번호, p_bizno3 - 사업자번호
 * 반환 : boolean - true, false
 * ex) is_bizno("111","22222","33")는 false를 반환한다.
*/
function is_bizno( p_bizno1, p_bizno2, p_bizno3 ){

	var v_bizno = p_bizno1+''+p_bizno2+''+p_bizno3;
	var a = new Array;
    var b = new Array(1,3,7,1,3,7,1,3,5);
    var sum = 0;

    if ( is_empty(v_bizno) ) {
        alert("사업자등록번호를 입력해주십시오.");
        return false;
    }

    if ( !is_number(v_bizno) ) {
        alert("사업자등록번호는 숫자만 입력할 수 있습니다.");
        return false;
    }

    if ( v_bizno.length != 10 ) {
        alert("사업자등록번호의 길이가 맞지 않습니다.");
        return false;
    }

    for(i=0; i<10; i++) a[i] = v_bizno.substr(i,1);
    for(i=0; i<9;  i++) sum = sum + (a[i] * b[i]);

    sum = sum + ((a[8] * 5) / 10);
    y = (sum - (sum % 1)) % 10;

    if (y == 0)
        z = 0;
    else
        z = 10 - y;

    if (z != a[9]) {
        alert("사업자등록번호가 잘못 입력되었습니다.");
        return false;
    }
    return true;
}

/*
 * 기능 : 인자로 넘어온 문자열이 유효한 담당자사번인지 체크한다.
 * 인자 : p_userno - 담당자사번
 * 반환 : boolean - true, false
 * ex) is_userno("11111")는 true를 반환한다.
*/
function is_userno( p_userno ){

	 if ( is_empty(p_userno) ) {
        alert("담당자사번을 입력해주십시오.");
        return false;
    }

    if ( !is_number(p_userno) ) {
        alert("담당자사번은 숫자만 입력할 수 있습니다.");
        return false;
    }

    if ( p_userno.length != 5 ) {
        alert("담당자사번의 길이가 맞지 않습니다.");
        return false;
    }
    return true;
}

/*
 * 기능 : 인자로 넘어온 두개의 문자열이 유효한 법인번호인지 체크한다.
 * 인자 : p_corpno1 - 법인번호, p_corpno2 - 법인번호
 * 반환 : boolean - true, false
 * ex) is_corpno("11111")는 false를 반환한다.
*/
function is_corpno( p_corpno1, p_corpno2 ){

	var v_corpno = p_corpno1+''+p_corpno2;

	if(is_empty(v_corpno)){
		alert("법인번호를 입력해 주십시오");
		return false;

	}
	if (!is_number(v_corpno)){
		alert("법인번호는 숫자만 입력할 수 있습니다.");
		return false;
	}

	if (v_corpno.length != 13){
		alert("법인번호의 길이가 맞지 않습니다.");
		return false;
	}

	var arr_regno = v_corpno.split("");
	var arr_wt = new Array(1,2,1,2,1,2,1,2,1,2,1,2);
	var iSum_regno = 0;
	var iCheck_digit = 0;

	for (i = 0; i < 12; i++){
		iSum_regno +=  eval(arr_regno[i]) * eval(arr_wt[i]);
	}

	iCheck_digit = 10 - (iSum_regno % 10);
	iCheck_digit = iCheck_digit % 10;

	if (iCheck_digit != arr_regno[12]){
		alert("법인번호가 잘못 입력되었습니다.");
		return false;
	}
	return true;
}

/*
 * 기능 : 인자로 넘어온 날짜 형식의 문자열이 유효한 날짜인지 체크한다.
 * 인자 : p_date - 날짜 형식의 문자열
 * 반환 : boolean - true, false
 * ex) is_valid_date("20070323")는 true를 반환한다.
*/
function is_valid_date( p_date){

	var v_date = p_date;

    if ( is_empty(v_date) ) {
        return false;
    }

    v_date = del_hyphen_date(v_date);

    if ( v_date.length != 8 ){
        return false;
    }

    if ( !is_number(v_date)){
        return false;
    }

    var v_year    = parseInt(v_date.substring(0,4),10);
    var v_month   = parseInt(v_date.substring(4,6),10);
    var v_day     = parseInt(v_date.substring(6,8),10);

    if ( !is_valid_year(v_year) ){
        return false;
    }
    if ( !is_valid_month(v_month) ){
        return false;
    }
    if ( v_day < 1 || v_day > last_day(v_year, v_month) ){
        return false;
    }

    return true;
}

/*
 * 기능 : 인자로 넘어온 시간 형식(6자리)의 문자열이 유효한 시간인지 체크한다.
 * 인자 : p_time - 시간 형식의 문자열 
 * 반환 : boolean - true, false
 * ex) is_valid_time("1145524")는 true를 반환한다.
*/
function is_valid_time( p_time ) {

	var v_time  = p_time;

	if ( is_empty(v_time) ) {
        alert("시간을 입력해 주십시오");
        return false;
    }

    v_time = del_colon_time(v_time);

    if ( v_time.length != 6 ){
        alert('시간이 잘못 입력되었습니다.');
        return false;
    }

    if ( !is_number(v_time)){
        alert('시간은 숫자만 입력할 수 있습니다.');
        return false;
    }

	var v_hour  = parseInt(v_time.substring(0,2),10);
    var v_min   = parseInt(v_time.substring(2,4),10);
    var v_sec   = parseInt(v_time.substring(4,6),10);

    if( !is_valid_hour(v_hour) ){
    	alert("시간이 잘못 입력되었습니다.시간은 0~24까지 입니다.");
    	return false;
    }
    if( !is_valid_min(v_min) ){
    	alert("분이 잘못 입력되었습니다.분은 0~59까지 입니다.");
    	return false;
    }
    if( !is_valid_sec(v_sec) ){
    	alert("초가 잘못 입력되었습니다.초는 0~59까지 입니다.");
    	return false;
    }
    return true;
}

/*
 * 기능 : 인자로 넘어온 시간 형식의(4자리) 문자열이 유효한 시간인지 체크한다.
 * 인자 : p_time - 시간 형식의 문자열(4자리) 
 * 반환 : boolean - true, false
 * ex) is_valid_time_hm("11455")는 true를 반환한다.
*/
function is_valid_time_hm( p_time ) {

	var v_time  = p_time;

	if ( is_empty(v_time) ) {
        alert("시간을 입력해 주십시오");
        return false;
    }

    v_time = del_colon_time(v_time);

    if ( v_time.length != 4 ){
        alert('시간이 잘못 입력되었습니다.');
        return false;
    }

    if ( !is_number(v_time)){
        alert('시간은 숫자만 입력할 수 있습니다.');
        return false;
    }

	var v_hour  = parseInt(v_time.substring(0,2),10);
    var v_min   = parseInt(v_time.substring(2,4),10);

    if( !is_valid_hour(v_hour) ){
    	alert("시간이 잘못 입력되었습니다.시간은 0~24까지 입니다.");
    	return false;
    }
    if( !is_valid_min(v_min) ){
    	alert("분이 잘못 입력되었습니다.분은 0~59까지 입니다.");
    	return false;
    }
    return true;
}

/*
 * 기능 : 인자로 넘어온 날짜 형식의 두개 문자열이 유효한 기간인지 체크한다.
 * 인자 : p_date1 - 8자리 날짜 문자열(시작일자), p_date2 - 8자리 날짜 문자열(종료일자)
 * 반환 : boolean - true, false
 * ex) is_valid_period("20070323", "20070305")는 true를 반환한다.
*/
function is_valid_period( p_date1, p_date2 ) {

	var v_date1 = p_date1;
	var v_date2 = p_date2;

	if ( !is_valid_date(v_date1) ){
		return false;
	}
	if ( !is_valid_date(v_date2) ){
		return false;
	}

	if ( v_date1 > v_date2 ){
		alert("시작일("+v_date1+")은 종료일("+v_date2+")보다 이전이어야 합니다.");
		return false;
	}
	return true;
}

/*
 * 기능 : 인자로 넘어온 문자열이 유효한 숫자인지 체크한다.
 * 인자 : p_num - 숫자 형식의 문자열
 * 반환 : boolean - true, false
 * ex) is_number("20070323")는 true를 반환한다.
*/
function is_number( p_num ) {
	var v_chars = "0123456789";
    return containsCharsOnly( p_num, v_chars );
}

/*
 * 기능 : 인자로 넘어온 문자열 숫자와 ',' 로만 구성되어있는지 체크한다.
 * 인자 : p_amount - 숫자와 ','로 구성되어있는 문자열
 * 반환 : boolean - true, false
 * ex) is_amount("20,070,323")는 true를 반환한다.
*/
function is_amount( p_amount ) {
    var chars = "-,0123456789";
    return containsCharsOnly( p_amount,chars );
}

/*
 * 기능 : 인자로 넘어온 문자열 숫자와 '-' 로만 구성되어있는지 체크한다.
 * 인자 : p_id - 숫자와 '-'로 구성되어있는 문자열
 * 반환 : boolean - true, false
 * ex) is_id("2007-03-23")는 true를 반환한다.
*/
function is_id( p_id ) {
    var chars = "-0123456789";
    return containsCharsOnly( p_id,chars );
}

/*
 * 기능 : 인자로 넘어온 문자열 숫자와 '-'',''.' 로만 구성되어있는지 체크한다.
 * 인자 : p_num - 숫자와 '-'',''.'로 구성되어있는 문자열
 * 반환 : boolean - true, false
 * ex) is_number_rate("2007,032.3")는 true를 반환한다.
*/
function is_number_rate( p_num ) {
	var v_chars = "-,.0123456789";
    return containsCharsOnly( p_num, v_chars );
}

/*
 * 기능 : 인자로 넘어온 문자열 숫자와 '-''.' 로만 구성되어있는지 체크한다.
 * 인자 : p_rate - 숫자와 '-''.'로 구성되어있는 문자열
 * 반환 : boolean - true, false
 * ex) is_rate("-2007032.3")는 true를 반환한다.
*/
function is_rate( p_rate ) {
    var chars = "-.0123456789";
    return containsCharsOnly( p_rate,chars );
}

/*
 * 기능 : 인자로 넘어온 문자열이 유효한 우편번호인지 체크한다.
 * 인자 : p_zipcode - 우편번호 형식의 문자열
 * 반환 : boolean - true, false
 * ex) is_zipcode("20062020")는 false를 반환한다.
*/
function is_zipcode( p_zipcode ) {

	if ( is_empty(p_zipcode) ) {
        alert("우편번호를 입력해 주십시오.");
        return false;
    }

    if ( !is_number ( p_zipcode ) ) {
        alert("우편번호는 숫자만 입력할 수 있습니다.");
        return false;
    }

    if ( p_zipcode.length != 6 ) {
        alert("우편번호 길이가 맞지 않습니다.");
        return false;
    }
    return true;
}


/*
 * 기능 : 인자로 넘어온 세개의 문자열이 유효한 전화번호인지 체크한다.
 * 인자 : p_telno1 - 전화번호 형식의 문자열, p_telno2 - 전화번호 형식의 문자열, p_telno3 - 전화번호 형식의 문자열
 * 반환 : boolean - true, false
 * ex) is_telno("02""123","4567")는 true를 반환한다.
*/
function is_telno( p_telno1, p_telno2, p_telno3 ) {

    v_msg_temp = "전화번호를 [지역번호-국번-가입자번호]의 형태로 입력하여 주십시요.\n" +
                 "예) 02-123-4567";

	if ( is_empty(p_telno1) || is_empty(p_telno2) || is_empty(p_telno3) ) {
		alert(v_msg_temp);
		return false;
	}

	if ( !(is_number(p_telno1) && is_number(p_telno2) && is_number(p_telno3)) ) {
		alert("전화번호는 숫자만 입력할 수 있습니다.");
		return false;
	}

    v_len = p_telno1.length;
	if ( (p_telno1 != "0505") && ( (v_len < 2) || (v_len > 3) || (p_telno1.substring(0,1)!="0"))) {
        alert("지역번호가 잘못 입력되었습니다.");
        return false;
    }

    v_len = p_telno2.length;
    if ( (v_len < 3) || (v_len > 4) ) {
        alert("국번이 잘못 입력되었습니다.");
        return false;
    }

    v_len = p_telno3.length;
    if ( (v_len < 3) || (v_len > 4) ) {
        alert("가입자 번호가 잘못 입력되었습니다.");
        return false;
    }

    return true;

}

/*
 * 기능 : 인자로 넘어온 세개의 문자열이 유효한 팩스번호인지 체크한다.
 * 인자 : p_faxno1 - 팩스번호 형식의 문자열, p_faxno2 - 팩스번호 형식의 문자열, p_faxno3 - 팩스번호 형식의 문자열
 * 반환 : boolean - true, false
 * ex) is_faxno("02""123","4567")는 true를 반환한다.
*/
function is_faxno( p_faxno1, p_faxno2, p_faxno3 ) {

    v_msg_temp = "팩스번호를 [지역번호-국번-가입자번호]의 형태로 입력하여 주십시요.\n" +
                 "예) 02-123-4567";

	if ( is_empty(p_faxno1) || is_empty(p_faxno2) || is_empty(p_faxno3) ) {
		alert(v_msg_temp);
		return false;
	}

	if ( !(is_number(p_faxno1) && is_number(p_faxno2) && is_number(p_faxno3)) ) {
		alert("팩스번호는 숫자만 입력할 수 있습니다.");
		return false;
	}

    v_len = p_faxno1.length;
    if ( (p_faxno1 != "0303") && ((v_len < 2) || (v_len > 3) || p_faxno1.substr(0,1) != "0" )) {
        alert("지역번호가 잘못 입력되었습니다.");
        return false;
    }

    v_len = p_faxno2.length;
    if ( (v_len < 3) || (v_len > 4) ) {
        alert("국번이 잘못 입력되었습니다.");
        return false;
    }

    v_len = p_faxno3.length;
    if ( (v_len < 3) || (v_len > 4) ) {
        alert("가입자번호가 잘못 입력되었습니다.");
        return false;
    }

    return true;

}

/*
 * 기능 : 인자로 넘어온 세개의 문자열이 유효한 휴대전화번호인지 체크한다.
 * 인자 : p_cellularno1 - 휴대전화번호 문자열, p_cellularno2 - 휴대전화번호 문자열, p_cellularno3 - 휴대전화번호 문자열
 * 반환 : boolean - true, false
 * ex) is_cellularno("016""123","4567")는 true를 반환한다.
*/
function is_cellularno( p_cellularno1, p_cellularno2, p_cellularno3 ) {

    v_msg_temp = "휴대전화번호를 [식별번호-국번-가입자번호]의 형태로 입력하여 주십시요.\n" +
                 "예) 010-123-4567";

	if ( is_empty(p_cellularno1) || is_empty(p_cellularno2) || is_empty(p_cellularno3) ) {
		alert(v_msg_temp);
		return false;
	}

	if ( !(is_number(p_cellularno1) && is_number(p_cellularno2) && is_number(p_cellularno3)) ) {
		alert("휴대전화번호는 숫자만 입력할 수 있습니다.");
		return false;
	}

    v_len = p_cellularno1.length;
    if (  !( p_cellularno1=="010" || p_cellularno1=="011" || p_cellularno1=="016" || p_cellularno1=="017" || p_cellularno1=="018" || p_cellularno1=="019" )  ) {
        alert("식별번호가 잘못 입력되었습니다.");
        return false;
    }

    v_len = p_cellularno2.length;
    if ( (v_len < 3) || (v_len > 4) ) {
        alert("국번이 잘못 입력되었습니다.");
        return false;
    } else if ( p_cellularno1=="010" && v_len != 4 ) {
	    alert("010의 경우 국번이 4자리로 입력되어야 합니다.");
	    return false;
    }

    v_len = p_cellularno3.length;
    if ( (v_len < 3) || (v_len > 4) ) {
        alert("가입자번호가 잘못 입력되었습니다.");
        return false;
    }

    return true;
}

/*
 * 기능 : 인자로 넘어온 문자열이 영문 대문자로만 구성되어 있는지 체크한다.
 * 인자 : p_str - 영문 대문자로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_uppercase("ABCD")는 true를 반환한다.
*/
function is_uppercase( p_str ) {
    var v_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
    return containsCharsOnly( p_str, v_chars );
}

/*
 * 기능 : 인자로 넘어온 문자열이 영문 소문자로만 구성되어 있는지 체크한다.
 * 인자 : p_str - 영문 소문자로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_lowercase("abcd")는 true를 반환한다.
*/
function is_lowercase( p_str ){
	var v_chars = 'abcdefghijklmnopqrstuvwxyz';
    return containsCharsOnly( p_str, v_chars );
}

/*
 * 기능 : 인자로 넘어온 문자열이 영문 대소문자로만 구성되어 있는지 체크한다.
 * 인자 : p_str - 영문 대소문자로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_english("AAabcd")는 true를 반환한다.
*/
function is_english( p_str ) {
	var v_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
	return containsCharsOnly( p_str, v_chars );
}

/*
 * 기능 : 인자로 넘어온 문자열이 영문 대소문자와 숫자로만 구성되어 있는지 체크한다.
 * 인자 : p_str - 영문 소문자 문자열
 * 반환 : boolean - true, false
 * ex) is_english_num("AAabcd12")는 true를 반환한다.
*/
function is_english_num( p_str ) {
	var v_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
	return containsCharsOnly( p_str, v_chars );
}

/*
 * 기능 : 인자로 넘어온 문자열이 영문 소문자인지 체크한다.
 * 인자 : p_str - 영문 소문자 문자열
 * 반환 : boolean - true, false
 * ex) is_lowercase("abcd")는 true를 반환한다.
*/
function is_english_num_spcChar( p_str ) {
	var v_chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`~!@#$%^&*_-+=|';
	return containsCharsOnly( p_str, v_chars );
}

/*
 * 기능 : 인자로 넘어온 문자열이 공백이나 null인지 체크한다.
 * 인자 : p_str - 문자열
 * 반환 : boolean - true, false
 * ex) is_empty("")는 true를 반환한다.
*/
function is_empty( p_str ) {
	if( p_str == null || trim(p_str) == "" || typeof p_str == 'undefined' ) {
		return true;
	}
    return false;
}

/*
 * 기능 : 인자로 넘어온 두개의 문자열이 유효한 년, 월인지 체크한다.
 * 인자 : p_yyyy - 년도로 된 문자열, p_mm - 월로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_valid_yearMonth("2007", "03")는 true를 반환한다.
*/
function is_valid_yearMonth(p_yyyy, p_mm) {
    return is_valid_year(p_yyyy) && is_valid_month(p_mm);
}

/*
 * 기능 : 인자로 넘어온 두개의 문자열이 유효한 년인지 체크한다.
 * 인자 : p_yyyy - 년도로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_valid_year("2007")는 true를 반환한다.
*/
function is_valid_year(p_yyyy){
	var y = parseInt(p_yyyy,10);
	return (y >= 1800 && y <= 9999);
}

/*
 * 기능 : 인자로 넘어온 두개의 문자열이 유효한 월인지 체크한다.
 * 인자 : p_mm - 월로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_valid_month("03")는 true를 반환한다.
*/
function is_valid_month(p_mm) {
    var m = parseInt(p_mm,10);
    return (m >= 1 && m <= 12);
}


/*
 * 기능 : 인자로 넘어온 세개의 문자열이 유효한 일자인지 체크한다.
 * 인자 : p_yyyy - 년도로 된 문자열, p_mm - 월로 된 문자열, p_dd - 일로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_valid_day("2007","03""22")는 true를 반환한다.
*/
function is_valid_day(p_yyyy, p_mm, p_dd) {
    var m = parseInt(p_mm,10) - 1;
    var d = parseInt(p_dd,10);

    var end = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
    if ((p_yyyy % 4 == 0 && p_yyyy % 100 != 0) || p_yyyy % 400 == 0) {
        end[1] = 29;
    }

    return (d >= 1 && d <= end[m]);
}

/*
 * 기능 : 인자로 넘어온 문자열이 윤년인지 체크한다.
 * 인자 : p_yyyy - 년도로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_leay_year("2007")는 false를 반환한다.
*/
function is_leay_year( p_yyyy ) {
    if ((p_yyyy % 4 == 0 && p_yyyy % 100 != 0) || p_yyyy % 400 == 0) {
        return true;
    }
	return false;
}

/*
 * 기능 : 인자로 넘어온 문자열이 유효한 시(時)인지 체크한다.
 * 인자 : p_hh - 시(時)로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_valid_hour("24")는 true를 반환한다.
*/
function is_valid_hour(p_hh) {
    var h = parseInt(p_hh,10);
    return (h >= 0 && h <= 24);
}


/*
 * 기능 : 인자로 넘어온 문자열이 유효한 분(分)인지 체크한다.
 * 인자 : p_mi - 분(分)형식의 문자열
 * 반환 : boolean - true, false
 * ex) is_valid_min("59")는 true를 반환한다.
*/
function is_valid_min(p_mi) {
    var m = parseInt(p_mi,10);
    return (m >= 0 && m <= 59);
}


/*
 * 기능 : 인자로 넘어온 문자열이 유효한 초(秒)인지 체크한다.
 * 인자 : p_ss - 초(秒)로 된 문자열
 * 반환 : boolean - true, false
 * ex) is_valid_sec("59")는 true를 반환한다.
*/
function is_valid_sec(p_ss) {
    var s = parseInt(p_ss,10);
    return (s >= 0 && s <= 59);
}


/*
 * 기능 : 인자로 넘어온 문자열이 email주소 형식에 맞는지 체크한다.
 * 인자 : p_email - email주소 형식의 문자열
 * 반환 : boolean - true, false
 * ex) is_email("abc.naver.com")는 true를 반환한다.
*/
function is_email( p_email ) {
	//var re = /[^@]+@[A-Za-z0-9_-]+[.]+[A-Za-z]+/;
	var format = /^((\w|[\-\.])+)@((\w|[\-\.])+)\.([A-Za-z]+)$/;

	if (p_email.search(format) != -1) {
        return true; //올바른 포맷 형식
    }
   	alert("이메일 주소가 잘못 입력되었습니다.");
    return false;
}

/*
 * 기능 : 엔터키가 눌려졌는지 체크한다.
 * 반환 : boolean - true, false
 * ex) check_enter()은 엔터키가 눌려졌으면 true, 아니면 false를 반환한다. 
*/
function check_enter() {

	var ieKey = window.event.keyCode;
	if (ieKey==13) return true;
	return false;
}

/*
 * 기능 : 인자로 넘어온 문자열이 특정문자로만 되어있는지 체크한다.
 * 인자 : p_str - 문자열, chars - 특정문자
 * 반환 : boolean - true, false
 * ex) containsCharsOnly("aaaaa", "a")는 true를 반환한다.
*/
function containsCharsOnly( p_str, chars ) {
	if( is_empty(p_str) ) return false;

	for (var inx = 0; inx < p_str.length; inx++) {
		if (chars.indexOf(p_str.charAt(inx)) == -1){
			return false;
		}
	}
	return true;
}

/*
 * 기능 : 인자로 넘어온 문자열에 '.'이 있는지 체크한다.
 * 인자 : p_str - 문자열
 * 반환 : boolean - true, false
 * ex) is_number_dot("100000.00")는 true를 반환한다.
*/
function is_number_dot( p_str ){
	for (var inx = 0; inx < p_str.length; inx++) {
		if (".".indexOf(p_str.charAt(inx)) == 0){
			return true;
		}
	}
	return false;
}

/*
 * 기능 : 인자로 넘어온 문자열에서 특수문자가 있는지를 체크한다.
 * 인자 : tmpStr - 문자열
 * 반환 : boolean - true:특수 문자가 있는 경우, false:특수 문자가 없는 경우
 * ex) CheckSKey("aaaaa")는 true를 반환한다.
*/
function CheckSKey(tmpStr){
    var valTmp=tmpStr;
    var valTmp2 = DelSKey(tmpStr);
    if ( valTmp == valTmp2 )
    {
    	return true;
    }
	else 
	{
		return false;
	}
}

/*
 * 기능 : 인자로 넘어온 날짜 형식(8자리)의 문자열 유효한 날짜인자 체크한다.
 * 인자 : str - 날짜 형식의 문자열
 * 반환 : boolean - true, flase
 * ex) js_DateCheckYYYYMMDD("20070329")는 true를 반환한다.
*/
function js_DateCheckYYYYMMDD(str){
	var sDate = str;
	var aDaysInMonth=new Array(31,28,31,30,31,30,31,31,30,31,30,31);
	
	if (sDate.length != 8 ) {	
		return false; 
	}
	else{
		var iYear = sDate.substr(0,4);
		var iMonth=eval(sDate.substr(4,2));
		var iDay=eval(sDate.substr(6,2));
		var iDaysInMonth=(iMonth!=2)?aDaysInMonth[iMonth-1]:((eval(iYear)%4==0 && eval(iYear)%100!=0 || eval(iYear)%400==0)?29:28); 

		if(	iYear < 1900 || iYear > 9999) {	
			return false;
		}
		if( (iDay!=null && iMonth!=null && iYear!=null && eval(iYear) != 0 && iMonth<13 && iMonth>0 && iDay>0 && iDay<=iDaysInMonth) == false ) {	
			return false;
		}
	}
	
	return true;
}	

/*
 * 기능 : 인자로 넘어온 날짜 형식(6자리)의 문자열이 유효한 날짜인지 체크한다.
 * 인자 : str - 날짜 형식의 문자열
 * 반환 : boolean - true, flase
 * ex) js_DateCheckYYYYMM("200703")는 true를 반환한다.
*/
function  js_DateCheckYYYYMM(str) {
	
	if(isNull(str)) return false;	//공백이라면

	var valid = true;
	var msg="";

	var birth = str;
	var yyyy = birth.substring(0,4);
	var mm = birth.substring(4,6);
	
	if ((isNull(birth) || birth.length != 6)) {
		return false;
	}
	
	if (!(yyyy.substring(0,2)=="19" || yyyy.substring(0,2)=="20")) {
		valid= false;
	}

	if (mm > 12 || mm < 1) {
		valid =  false;
	}
	
	return valid;
}

/*
 * 기능 : 사용자의 OS가 WINDOW XP SP2 인지 체크한다.
 * 반환 : boolean - true(sp2), false(나머지)
 * ex) isXP2()는 true를 반환한다.
*/
function isXP2() {
	var osType = navigator.appVersion;
	if (navigator.appMinorVersion && navigator.appMinorVersion.toLowerCase().indexOf('sp2') != -1) {
		return true;
	} else {
		return false;
	}
}

/*
 * 기능 : 인자로 넘어온 날짜형식의 문자열에 dash를 자동으로 추가한다.
 * 인자 : p_obj - 날짜형식의 문자열
 * 반환 : dash가 생긴 문자열
 * ex) auto_dash_date("20070328")는 "2007-03-28"을 반환한다.
*/
function auto_dash_date( p_obj ) {

	if( (event.keyCode == 8 ) || (event.keyCode == 13 ) || (event.keyCode == 46 ) || (event.keyCode >= 37 && event.keyCode <= 40 ) )
	{
		return false;
	}

	var v_date = p_obj.value;
	v_date = del_hyphen_date(v_date);

	if (byte_length(v_date) <= 3)  p_obj.value = v_date ;
	if (byte_length(v_date) == 4)  p_obj.value = v_date ;
	if (byte_length(v_date) == 5)  p_obj.value = v_date.substring(0,4) + "-" + v_date.substring(4,5) ;
	if (byte_length(v_date) == 6)  p_obj.value = v_date.substring(0,4) + "-" + v_date.substring(4,6) ;
	if (byte_length(v_date) == 7)  p_obj.value = v_date.substring(0,4) + "-" + v_date.substring(4,6) + "-" + v_date.substring(6,7);
	if (byte_length(v_date) == 8)  p_obj.value = v_date.substring(0,4) + "-" + v_date.substring(4,6) + "-" + v_date.substring(6,8);

}

/*
 * 기능 : 인자로 넘어온 주민번호 형식의 문자열에 dash를 자동으로 추가한다.
 * 인자 : p_obj - 주민번호 형식의 문자열
 * 반환 : dash가 생긴 문자열
 * ex) auto_dash_pers("7311111111111")는 "731111-1111111"을 반환한다. 
*/
function auto_dash_pers( p_obj ) {

	if( (event.keyCode == 8 ) || (event.keyCode == 13 ) || (event.keyCode == 46 ) || (event.keyCode >= 37 && event.keyCode <= 40 ) )
	{
		return false;
	}

	var v_date = p_obj.value;
	v_date = del_hyphen_date(v_date);

	if (byte_length(v_date) <= 5)  p_obj.value = v_date ;
	if (byte_length(v_date) == 6)  p_obj.value = v_date ;
	if (byte_length(v_date) == 7)  p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,7);
	if (byte_length(v_date) == 8)  p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,8);
	if (byte_length(v_date) == 9)  p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,9);
	if (byte_length(v_date) == 10)  p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,10);
	if (byte_length(v_date) == 11)  p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,11);
	if (byte_length(v_date) == 12)  p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,12);
	if (byte_length(v_date) == 13)  p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,13);
}
 
/*
 * 기능 : 인자로 넘어온 사업자번호 형식의 문자열에 dash를 자동으로 추가한다.
 * 인자 : p_obj - 사업자번호 형식의 문자열
 * 반환 : dash가 생긴 문자열
 * ex) auto_dash_pers_taxid("1234567890")는 "123-45-67890"을 반환한다.
*/
function auto_dash_pers_taxid( p_obj ) {

	if( (event.keyCode == 8 ) || (event.keyCode == 13 ) || (event.keyCode == 46 ) || (event.keyCode >= 37 && event.keyCode <= 40 ) )
	{
		return false;
	}

	var v_date = p_obj.value;
	v_date = del_hyphen_date(v_date);

	if (byte_length(v_date) <= 8)  p_obj.value = v_date ;
	if (byte_length(v_date) == 9)  p_obj.value = v_date ;
	if (byte_length(v_date) == 10) p_obj.value = v_date.substring(0,3) + "-" + v_date.substring(3,5) + "-" + v_date.substring(5,10);
	if (byte_length(v_date) == 11) p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,11);
	if (byte_length(v_date) == 12) p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,12);
	if (byte_length(v_date) == 13) p_obj.value = v_date.substring(0,6) + "-" + v_date.substring(6,13);

}

/*
 * 기능 : 인자로 넘어온 우편번호 형식의 문자열에 dash를 자동으로 추가한다.
 * 인자 : p_obj - 우편번호 형식의 문자열
 * 반환 : dash가 생긴 문자열
 * ex) auto_dash_post("123456")는 "123-456"을 반환한다.
*/
function auto_dash_post( p_obj ) {

	if( (event.keyCode == 8 ) || (event.keyCode == 13 ) || (event.keyCode == 46 ) || (event.keyCode >= 37 && event.keyCode <= 40 ) )
	{
		return false;
	}

	var v_date = p_obj.value;
	v_date = del_hyphen_date(v_date);

	if (byte_length(v_date) <= 2)  p_obj.value = v_date ;
	if (byte_length(v_date) == 3)  p_obj.value = v_date ;
	if (byte_length(v_date) == 4)  p_obj.value = v_date.substring(0,3) + "-" + v_date.substring(3,4);
	if (byte_length(v_date) == 5)  p_obj.value = v_date.substring(0,3) + "-" + v_date.substring(3,5);
	if (byte_length(v_date) == 6)  p_obj.value = v_date.substring(0,3) + "-" + v_date.substring(3,6);
}

/*
 * 기능 : 인자로 넘어온 대출번호 형식의 문자열에 '-'를 자동으로 추가한다.
 * 인자 : p_loan - 대출번호 형식의 문자열
 * 반환 : p_loan - '-'를 추가한 문자열
 * ex) auto_dash_loan("123456789012")는 "12-3456-789012"를 반환한다.
*/
function auto_dash_loan( p_obj ) {

	if( (event.keyCode == 8 ) || (event.keyCode == 13 ) || (event.keyCode == 46 ) || (event.keyCode >= 37 && event.keyCode <= 40 ) )
	{
		return false;
	}

	var v_loan = p_obj.value;
	v_loan = del_hyphen_date(v_loan);

	if (byte_length(v_loan) <= 1)  p_obj.value = v_loan;
	if (byte_length(v_loan) == 2)  p_obj.value = v_loan;
	if (byte_length(v_loan) == 3)  p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,3);
	if (byte_length(v_loan) == 4)  p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,4);
	if (byte_length(v_loan) == 5)  p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,5);
	if (byte_length(v_loan) == 6)  p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,6);
	if (byte_length(v_loan) == 7)  p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,6) + "-" + v_loan.substring(6,7);
	if (byte_length(v_loan) == 8)  p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,6) + "-" + v_loan.substring(6,8);
	if (byte_length(v_loan) == 9)  p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,6) + "-" + v_loan.substring(6,9);
	if (byte_length(v_loan) == 10) p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,6) + "-" + v_loan.substring(6,10);
	if (byte_length(v_loan) == 11) p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,6) + "-" + v_loan.substring(6,11);
	if (byte_length(v_loan) == 12) p_obj.value = v_loan.substring(0,2) + "-" + v_loan.substring(2,6) + "-" + v_loan.substring(6,12);

}

/*
 * 기능 : 인자로 넘어온 숫자형식의 문자열에 자동으로 ','를 추가한다.
 * 인자 : p_obj - 숫자로된 문자열 객체, len - 총길이, scl - 소수점 자릿수(소수점 없을시 세팅안함)
 * 반환 : ','가 추가된 문자열
 * ex) auto_comma_num("10000.000", 15, 2)는 "10,000.00"를 반환한다.
*/
function auto_comma_num(p_obj, len, scl) {
	if(event.keyCode == 9 ) return;	
	if(len == null) len = 15;
	if(scl == null) scl = 0;	
	
	var num = '';
	var num = String(del_comma_num(p_obj.value));
	var pos = 0;
	
	// 사무계 요청 추가분
	while ( num.length > 1 && num.substring(0, 1) == "0" ) {
		if(num.indexOf(".", 0) == 1) break;	
		num = num.substring(1, num.length);
	}
	
	// 소수점 입력 여부 체크
	if( num.length > 1 && num.indexOf(".", 0) > -1) {
		pos = num.indexOf(".", 0);
	}	

	if (num.length < 1) {
		p_obj.value = "";
	} else {
		var tm = "";
		var ck = "";
		if (num.substring(0, 1) == "-") {
			tm = OnlyInt(num.substring(1, num.length));
			ck = "Y";
		} else {
			tm = OnlyInt(num);
			ck = "N";
		}
		
		var st = "";
		var cm = ",";
		
		// 키를 계속 눌렸을 때 15개 이상 입력되는 것을 막아줌
		if(tm.length > len)
		{
			alert("길이를 초과했습니다");
			tm = tm.substring(0, len);
		}
		
		var cm_cnt = 0;

		for (var i = tm.length, j = 0; i > 0; i--, j++) {
			if(pos > 0) {
				if (((j - (tm.length - pos)) % 3) == 2 && j > (tm.length - pos)) {
					if (tm.length == j + 1) {
						st = tm.substring(i - 1, i) + st;
					}
					else {
				 		st = cm + tm.substring(i - 1, i) + st;
						cm_cnt ++;
					}
				} else {
					st = tm.substring(i - 1, i) + st;
				}	
			}
			else {
				if ((j % 3) == 2) {
					if (tm.length == j + 1) {
						st = tm.substring(i - 1, i) + st;
					}
					else {
				 		st = cm + tm.substring(i - 1, i) + st;
						cm_cnt ++;
					}
				} else {
					st = tm.substring(i - 1, i) + st;
				}
			}
		}

		if (pos > 0) {
			st = st.substring(0, pos + cm_cnt) + "." + st.substr(pos + cm_cnt, scl);				
		}
		else {
			st = st.substring(0, len + cm_cnt - scl);
		}
		
		if (ck == "Y") st = "-" + st;
		
		p_obj.value = st;
	}
}

/*
 * 기능 : 인자로 넘어온 시간(시분초) 형식의 문자열에 ':'를 자동으로 추가한다.
 * 인자 : p_time - 시간 형식의 문자열
 * 반환 : p_time - ':'를 자동으로 추가한 문자열
 * ex) auto_colon_time("203521")는 "20:35:21"를 반환한다.
*/
function auto_colon_time( p_time ) {
	if( (event.keyCode == 8 ) || (event.keyCode == 13 ) || (event.keyCode == 46 ) || (event.keyCode >= 37 && event.keyCode <= 40 ) )
	{
		return false;
	}

	var str = p_time.value;
	str = del_colon_time(str);

	if (byte_length(str) <= 2)  p_time.value = str ;
	if (byte_length(str) == 3)  p_time.value = str.substring(0,2) + ":" + str.substring(2,3) ;
	if (byte_length(str) == 4)  p_time.value = str.substring(0,2) + ":" + str.substring(2,4) ;
	if (byte_length(str) == 5)  p_time.value = str.substring(0,2) + ":" + str.substring(2,4) + ":" + str.substring(4,5) ;
	if (byte_length(str) == 6)  p_time.value = str.substring(0,2) + ":" + str.substring(2,4) + ":" + str.substring(4,6) ;
}

/*
 * 기능 : 인자로 넘어온 시간(시분초) 형식의 문자열에 ':'를 자동으로 추가한다.
 * 인자 : p_time - 시간 형식의 문자열
 * 반환 : p_time - ':'를 자동으로 추가한 문자열
 * ex) auto_colon_time("203521")는 "20:35:21"를 반환한다.
*/
function del_colon_time( p_time ) {
	return p_time.replace(/:/gi,"");
}

/*
 * 기능 : 인자로 넘어온 법인번호 형식의 문자열에 '-'를 자동으로 추가한다.
 * 인자 : p_obj - 법인번호 형식의 문자열
 * 반환 : '-'가 자동으로 추가된 문자열
 * ex) auto_dash_corp("1234561234567")는 "123456-1234567"를 반환한다.
*/
function auto_dash_corp( p_obj ) {

	if( (event.keyCode == 8 ) || (event.keyCode == 13 ) || (event.keyCode == 46 ) || (event.keyCode >= 37 && event.keyCode <= 40 ) )
	{
		return false;
	}

	var str = p_obj.value;
	str = str.replace(/-/gi,"");

	if (byte_length(str) <= 5)  p_obj.value = str ;
	if (byte_length(str) == 6)  p_obj.value = str ;
	if (byte_length(str) == 7)  p_obj.value = str.substring(0,6) + "-" + str.substring(6,7) ;

}

/*
 * 기능 : 인자로 넘어온 문자열의 좌,우측 공백을 제거한다.
 * 인자 : p_str - 문자열
 * 반환 : p_str - 좌,우측 공백이 제거된 문자열
 * ex) trim("  aaa   ")는 "aaa"을 반환한다.
*/
function trim( p_str ) {
	return ltrim( rtrim( p_str ) );
}

/*
 * 기능 : 인자로 넘어온 문자열의 좌측 공백을 제거한다.
 * 인자 : p_str - 문자열
 * 반환 : p_str - 좌측 공백이 제거된 문자열
 * ex) ltrim("  aaa")는 "aaa"을 반환한다.
*/
function ltrim( p_str ) {

	if (p_str == "") {
		return	p_str;
	}

	var len = p_str.length;
	var st = 0;

	while ((st < len) && (p_str.charAt(st) <= ' ')) {
		st++;
	}

	return	(st > 0) ? p_str.substring(st, len) : p_str;

}

/*
 * 기능 : 인자로 넘어온 문자열의 우측 공백을 제거한다.
 * 인자 : p_str - 문자열
 * 반환 : 우측 공백이 제거된 문자열
 * ex) rtrim("aaa   ")는 "aaa"을 반환한다.
*/
function rtrim( p_str ) {

	if (p_str == "") {
		return	p_str;
	}

	var len = p_str.length;
	var st = 0;

	while ((st < len) && (p_str.charAt(len - 1) <= ' ')) {
		len--;
	}

	return	(len < p_str.length) ? p_str.substring(st, len) : p_str;

}

/*
 * 기능 : 인자로 넘어온 금액형식의 문자열에 ','를 제거한다.
 * 인자 : p_num - 금액형식의 문자열
 * 반환 : p_num - ','제거한 문자열
 * ex) del_comma_num("100,000")는 "100000"를 반환한다.
*/
function del_comma_num( p_num ) {
	return p_num.replace(/,/gi,"");
}

/*
 * 기능 : 인자로 넘어온 문자열에 ',.-:'를 제거한다.
 * 인자 : p_num - 문자열
 * 반환 : p_num - ',.-:' 제거한 문자열
 * ex) del_char("100,00-0")는 "100000"를 반환한다.
*/
function del_char( p_num ) {
	return(p_num.replace(/(\-)|(\/)|(\,)|(\.)|(\:)/gi,""));
}

/*
 * 기능 : 인자로 넘어온 날짜 형식의 문자열에 '-'를 제거한다.
 * 인자 : p_date - 날짜 형식의 문자열
 * 반환 : p_date - '-'를 제거한 문자열
 * ex) del_hyphen_date("2007-03-28")는 "20070328"를 반환한다.
*/
function del_hyphen_date( p_date  ) {
	return p_date.replace(/-/gi,"");
}

/*
 * 기능 : 인자로 넘어온 문자열사이의 공백을 제거한다.
 * 인자 : tmpStr - 문자열
 * 반환 : valTmp - 공백 제거한 문자열
 * ex) NotSpace("203  521")는 "203521"를 반환한다.
*/
function NotSpace(tmpStr)
{
    var valTmp="";
    for(i=0;i<tmpStr.length;i++)
    {
        if(tmpStr.charAt(i)!=" "){
            valTmp += tmpStr.charAt(i);
        }
    }
return valTmp;

}

/*
 * 기능 : 인자로 넘어온 문자열에서 숫자(0-9)외의 문자를 제거한다.
 * 인자 : tmpStr - 문자열
 * 반환 : valTmp - 숫자(0-9)외의 문자를 제거한 문자열
 * ex) OnlyInt("203--5:21")는 "203521"를 반환한다.
*/
function OnlyInt(tmpStr)
{
    var valTmp="";
    for(i=0;i<tmpStr.length;i++)
    {
        if(!isNaN(tmpStr.charAt(i)))
        {
            valTmp += tmpStr.charAt(i);
        }
    }
return valTmp;
}

/*
 * 기능 : 인자로 넘어온 문자열에서 특수문자를 제거한다.
 * 인자 : tmpStr - 문자열
 * 반환 : valTmp - 특수문자가 제거된 문자열
 * ex) DelSKey("abc%")는 "abc"를 반환한다.
*/
function DelSKey(tmpStr){
    var valTmp="";
    for(i=0;i<tmpStr.length;i++)
    {
        if((	tmpStr.charCodeAt(i)>=97 && tmpStr.charCodeAt(i)<= 125) 
        	|| (tmpStr.charCodeAt(i)>=65 && tmpStr.charCodeAt(i)<= 90) 
        	|| (tmpStr.charCodeAt(i)>=48 && tmpStr.charCodeAt(i)<= 57) 
        	|| tmpStr.charCodeAt(i)> 127)
        {
            valTmp += tmpStr.charAt(i);
        }
    }
return valTmp;
}

/*
 * 기능 : 인자로 넘어온 숫자로 된 문자열을 3자리 단위로 ','를 추가한다.
 * 인자 : p_num - 날짜형식의 문자열
 * 반환 : st - ','가 포함된 문자열.
 * ex) add_comma_num("10000000")는 "10,000,000"을 반환한다.
*/
function add_comma_num( p_num ) {
    var x = 0;
	var pos = 0;
	
	// 소수점 입력 여부 체크
	if(  p_num.length > 1 &&  p_num.indexOf(".", 0) > -1) {
		pos =  p_num.indexOf(".", 0);
	}	
	    
    if (p_num.length < 1) {
        return "";
    } else {
        var tm = "";
        var ck = "";
        if (p_num.substring(0, 1) == "-") {
            tm = p_num.substring(1, p_num.length);
            ck = "Y";
        } else {
            tm = p_num;
            ck = "N";
        }
        var st = "";
        var cm = ",";
        
		var cm_cnt = 0;    
        
        for (var i = tm.length, j = 0; i > 0; i--, j++) {
        	if(pos > 0) {
	            if (((j - (tm.length - pos)) % 3) == 2 && j > (tm.length - pos)) {
	                if (tm.length == j + 1) st = tm.substring(i - 1, i) + st;
	                else st = cm + tm.substring(i - 1, i) + st;
	            } else {
	                st = tm.substring(i - 1, i) + st;
	            }
            } 
            else {
	            if ((j % 3) == 2) {
	                if (tm.length == j + 1) st = tm.substring(i - 1, i) + st;
	                else st = cm + tm.substring(i - 1, i) + st;
	            } else {
	                st = tm.substring(i - 1, i) + st;
	            }            
            }
        }
        if (ck == "Y") st = "-" + st;
        return st;
    }
}

/*
 * 기능 : 인자로 넘어온 날짜형식의 문자열에 '-'를 추가한다.
 * 인자 : p_date - 날짜형식의 문자열
 * 반환 : p_date - '-'를 추가한 문자열
 * ex) add_hyphen_date("20070328")는 "2007-03-28"를 반환한다.
*/
function add_hyphen_date( p_date ){

	var re =/(\d{4})[-]?(\d{2})[-]?(\d{2})/gi;
	var r = re.exec(p_date);

	if( r != null ){
		if(is_valid_month(RegExp.$2)&&is_valid_day(RegExp.$1,RegExp.$2,RegExp.$3)){
			return RegExp.$1+'-'+RegExp.$2+'-'+RegExp.$3;
		}else{
			//alert("날짜의 입력이 잘못되었습니다. 확인해 주십시오.");
			return p_date;
		}
	}else{
		return p_date;
	}
}

/*
 * 기능 : 인자로 넘어온 날짜형식의 문자열에 '.'를 추가한다.
 * 인자 : p_date - 날짜형식의 문자열
 * 반환 : p_date - '.'를 추가한 문자열
 * ex) add_dot_date("20070328")는 "2007.03.28"를 반환한다.
*/
function add_dot_date( p_date ){

	var re =/(\d{4})[.]?(\d{2})[.]?(\d{2})/gi;
	var r = re.exec(p_date);

	if( r != null ){
		if(is_valid_month(RegExp.$2)&&is_valid_day(RegExp.$1,RegExp.$2,RegExp.$3)){
			return RegExp.$1+'.'+RegExp.$2+'.'+RegExp.$3;
		}else{
			//alert("날짜의 입력이 잘못되었습니다. 확인해 주십시오.");
			return p_date;
		}
	}else{
		return p_date;
	}
}

/*
 * 기능 : 인자로 넘어온 우편번호 형식의 문자열에 '-'를 추가한다.
 * 인자 : p_post - 우편번호 형식의 문자열
 * 반환 : p_post - '-'를 추가한 문자열
 * ex) add_hyphen_post("123456")는 "123-456"를 반환한다.
*/
function add_hyphen_post( p_post ){

	var re =/(\d{3})[-]?(\d{3})/gi;
	var r = re.exec(p_post);
	
	if( r != null ){
		if(is_zipcode(RegExp.$1+RegExp.$2)){
			return RegExp.$1+'-'+RegExp.$2;
		}else{
			//alert("우편번호의 입력이 잘못되었습니다. 확인해 주십시오.");
			return p_post;
		}
	}else{
		return p_post;
	}	

	return p_post;
}

/*
 * 기능 : 인자로 넘어온 주민번호형식의 문자열에 '-'를 추가한다.
 * 인자 : p_pers - 날짜형식의 문자열
 * 반환 : p_pers - '-'를 추가한 문자열
 * ex) add_hyphen_pers("8001012052124")는 800101-2052124"를 반환한다.
*/
function add_hyphen_pers( p_pers ){

	var re =/(\d{6})[-]?(\d{7})/gi;
	var r = re.exec(p_pers);

	if( r != null ){
		if(is_number(RegExp.$1)&&is_number(RegExp.$2)){
			return RegExp.$1+'-'+RegExp.$2;
		}else{
			return p_pers;
		}
	}else{
		return p_pers;
	}
}

/*
 * 기능 : 인자로 넘어온 대출번호 형식의 문자열에 '-'를 추가한다.
 * 인자 : p_loan - 대출번호 형식의 문자열
 * 반환 : p_loan - '-'를 추가한 문자열
 * ex) add_hyphen_loan("123456789012")는 "12-3456-789012"를 반환한다.
*/
function add_hyphen_loan( p_loan ){

	var re =/(\d{2})[-]?(\d{4})[-]?(\d{6})/gi;
	var r = re.exec(p_loan);

	if( r != null ){
		if(is_number(RegExp.$1)&&is_number(RegExp.$2)&&is_number(RegExp.$3)){
			return RegExp.$1+'-'+RegExp.$2+'-'+RegExp.$3;
		}else{
			//alert("대출번호의 입력이 잘못되었습니다. 확인해 주십시오.");
			return p_loan;
		}
	}else{
		return p_loan;
	}
}

/*
 * 기능 : 인자로 넘어온 시간(시분초) 형식의 문자열에 ':'를 추가한다.
 * 인자 : p_time - 시간 형식의 문자열
 * 반환 : p_time - ':'를 추가한 문자열
 * ex) add_colon_time("203521")는 "20:35:21"를 반환한다.
*/
function add_colon_time( p_time ){

	var re =/(\d{2})[:]?(\d{2})[:]?(\d{2})/gi;
	var r = re.exec(p_time);

	if( r != null ){
		if(is_valid_hour(RegExp.$1)&&is_valid_min(RegExp.$2)&&is_valid_sec(RegExp.$3)){
			return RegExp.$1+':'+RegExp.$2+':'+RegExp.$3;
		}else{
			alert("시간의 입력이 잘못되었습니다. 확인해 주십시오.");
			return p_time;
		}
	}else{
		return p_time;
	}

}

/*
 * 기능 : 인자로 넘어온 시간(시분) 형식의 문자열에 ':'를 추가한다.
 * 인자 : p_time - 시간 형식의 문자열
 * 반환 : p_time - ':'를 추가한 문자열
 * ex) add_colon_time("2035")는 "20:35"를 반환한다.
*/
function add_colon_time_hm( p_time ){

	var re =/(\d{2})[:]?(\d{2})/gi;
	var r = re.exec(p_time);

	if( r != null ){
		if(is_valid_hour(RegExp.$1)&&is_valid_min(RegExp.$2)){
			return RegExp.$1+':'+RegExp.$2;
		}else{
			alert("시간의 입력이 잘못되었습니다. 확인해 주십시오.");
			return p_time;
		}
	}else{
		return p_time;
	}
}

/*
 * 기능 : 인자로 넘어온 문자열의 길이를 실시간으로 체크하여 지정한 길이를 초과한 경우 입력 이전 문자열로 돌아간다.
 * 인자 : obj - 입력 폼 객체
 * 			 lim_byt - 제한 문자열 바이트 수
 * 			 str_prv - 입력 이전 문자열 
 * ex) checkByteLength(document.form[0].atc_tit, 10, document.form[0].tmp_atc_tit)는 입력 문자열의 바이트 길이가 10을 초과할 경우
 *       입력 가능 바이트 길이 초과 메시지를 보여준다.
*/

function checkByteLength(obj, lim_byt, obj_str_prv)
{
	var tag_nam = obj.tagName;
	var str = obj.value;
	
	switch(tag_nam)
	{
		case "INPUT" :
		
			if(byte_length(str) > lim_byt)
			{
				alert(	"입력 문자열의 길이가 제한 길이인 " +  lim_byt + " Byte를 " + (byte_length(str) - lim_byt) + " Byte 초과했습니다.\n" +
							"(한글 1자 = 2Byte, 영문 및 기호 1자 = 1Byte)\n입력 문자열의 길이를 줄여서 다시 입력해 주세요.");
				
				if(!is_empty(obj_str_prv)) obj.value = obj_str_prv.value;
				obj.focus();
				
				return false;
			}
			else
			{
				obj_str_prv.value = str;
			}
		
			break;
	
		case "TEXTAREA" :
		
			if(byte_length_ta(str) > lim_byt)
			{
				alert(	"입력 문자열의 길이가 제한 길이인 " +  lim_byt + " Byte를 " + (byte_length_ta(str) - lim_byt) + " Byte 초과했습니다.\n" +
							"(한글 1자 = 3Byte, 영문 및 기호 1자 = 1Byte)\n입력 문자열의 길이를 줄여서 다시 입력해 주세요.");
				
				if(!is_empty(obj_str_prv)) obj.value = obj_str_prv.value;
				obj.focus();
				
				return false;
			}		
			else
			{
				obj_str_prv.value = str;			
			}
		
			break;
		
		default : 
		
			break;
	}
}  

/*
 * 기능 : 문자열, 자리수, 앞뒤구분 받아 자리수를 맞춰서 앞(F)/뒤(B)에 "0" 채우기
 * 인자 : tmpStr - 문자열, tmpNum - 자릿수, tmpFlag - F(앞) / 뒤(B)
 * 반환 : valTmp - "0"채운 문자열, 검사할 문자열이 자리수 보다 크거나 같은 경우는 검사할 문자열을 그대로 반환함
 * ex) FillValue("1234567",10,'F')는 "0001234567"를 반환한다.
*/
function FillValue(tmpStr,tmpNum, tmpFlag)
{
    var valTmp="";
    var tValue = tmpStr.length;

	if ( tValue >= tmpNum ) {
		valTmp = tmpStr;
	}
	else {
	    for(i=tValue; i< tmpNum; i++)
	    {
	        if(tmpFlag == 'F')
	        {
	            valTmp += "0";
	            if(i == (tmpNum-1)){valTmp += ''+tmpStr; }
	        }
	        else
	        {
	            if(i == tValue){valTmp += tmpStr; }
	            valTmp += ''+"0";
	        }
	    }
	}

return valTmp;
}

/*
 * 기능 : 문자열, 자리수, 앞뒤구분 받아 자릿수를 맞춰서 앞(F)/뒤(B)에 특정 문자 채우기
 * 인자 : tmpStr - 문자열, tmpNum - 자릿수, fillChar - 특정문자, tmpFlag - F(앞) / 뒤(B)
 * 반환 : valTmp - 특정문자 채운 문자열, 검사할 문자열이 자리수 보다 크거나 같은 경우는 검사할 문자열을 그대로 반환함
 * ex) FillValueByChar("1234567",10, ' ', 'F')는 "   1234567"를 반환한다.
*/
function FillValueByChar(tmpStr,tmpNum, fillChar, tmpFlag)
{
    var valTmp="";
    var tValue = tmpStr.length;

	if ( tValue >= tmpNum ) {
		valTmp = tmpStr;
	}
	else {
	    for(i=tValue; i< tmpNum; i++)
	    {
	        if(tmpFlag == 'F')
	        {
	            valTmp += fillChar;
	            if(i == (tmpNum-1)){valTmp += ''+tmpStr; }
	        }
	        else
	        {
	            if(i == tValue){valTmp += tmpStr; }
	            valTmp += ''+ fillChar;
	        }
	    }
	}

return valTmp;
}

/*
 * 기능 : 인자로 넘어온 문자열의 byte length를 구한다.
 * 인자 : p_str - 문자열
 * 반환 : 계산된 byte length
 * ex) byte_length("aaa")는 3을 반환한다.
*/
//바이트로 length 구하기
function byte_length(p_str){
	return(p_str.length + (escape(p_str) + "%u").match(/%u/g).length - 1);
}

/*
 * 기능 : 인자로 넘어온 TEXTAREA 문자열의 byte length를 구한다.
 * 인자 : p_str - 문자열
 * 반환 : 계산된 byte length
 * ex) byte_length_ta("aaa")는 3을 반환한다.
*/
//TEXTAREA 입력 문자에 대해 바이트로 length 구하기
function byte_length_ta(p_str){
	return(p_str.length + (escape(p_str) + "%u").match(/%u/g).length * 2 - 1);
}

/*
 * 기능 : 현재년도를 구한다.
 * 반환 : v_year - 현재년도
 * ex) to_year()는 "2007"을 반환한다.
*/
function to_year() {

    var v_date = new Date();
    var v_year = v_date.getYear();

    if (v_year < 100)
        return ("19"+v_year).toString();
    else
        return v_year.toString();
}

/*
 * 기능 : 현재월을 구한다.
 * 반환 : v_month - 현재월
 * ex) to_month()는 "03"을 반환한다.
*/
function to_month() {

    var v_date = new Date();
    var v_month = v_date.getMonth() + 1;

    if (v_month < 10)
        return ("0"+v_month).toString();
    else
        return v_month.toString();

}

/*
 * 기능 : 현재일을 구한다.
 * 반환 : v_day - 현재일
 * ex) to_day()는 "28"을 반환한다.
*/
function to_day(){

    var v_date = new Date();
    var v_day = v_date.getDate();

    if (v_day < 10)
        return ("0"+v_day).toString();
    else
        return v_day.toString();

}

/*
 * 기능 : 현재일자를 구한다.
 * 반환 : rt_val - 현재일자
 * ex) to_date()는 "20070328"을 반환한다.
*/
function to_date(){
	return to_year()+"-"+to_month()+"-"+to_day();
}

/*
 * 기능 : 인자로 넘어온 날짜형식의 문자열을 yyyy년 MM월 dd일로 변경한다.
 * 인자 : p_date - 날짜형식의 문자열, p_type - 1:년 월 일 2:년월일
 * 반환 : rt_val - 현재일자
 * ex) to_ymd("20070328", 1)는 "2007년 03월 28일"을 반환한다.
*/
function to_ymd(p_date, p_type){
	var rt_val = "";

	if(is_valid_date(p_date))
	{
		p_date = del_hyphen_date(p_date);
	
	    var v_year    = parseInt(p_date.substring(0,4),10);
    	var v_month   = parseInt(p_date.substring(4,6),10);
    	var v_day     = parseInt(p_date.substring(6,8),10);	
    	
    	switch(p_type)
    	{
    		case 1 :
    			rt_val = v_year + "년 " + v_month + "월 " + v_day + "일";
    			break;
    			
    		case 2 :
    			rt_val = v_year + "년" + v_month + "월" + v_day + "일";  
    			break;    			
    			
    		default : 
 				rt_val = "";   			  			
    	}
    	
	}

	return rt_val;
}

/*
 * 기능 : 인자로 넘어온 년월형식 문자열의 해당월의 마지막 일자를 구한다.
 * 인자 : p_year - 년도, p_month - 월
 * 반환 : v_days - 해당년월의 마지막 일자
 * ex) last_day("2007", "03")는 "31"을 반환한다.
*/
function last_day( p_year, p_month) {

	var    v_dayOfMonth = new Array(31,28,31,30,31,30,31,31,30,31,30,31);

    if ( ((p_year %4 == 0) && (p_year % 100 != 0))||(p_year % 400 == 0) )
        v_dayOfMonth[1] = 29;
    var v_days = v_dayOfMonth[p_month-1];

    return v_days;

}

/*
 * 기능 : 인자로 넘어온 두 날짜형식의 문자열 사이의 일수를 계산한다.
 * 인자 : p_date1 - 날짜형식의 문자열(from), p_date2 - 날짜형식의 문자열(to)
 * 반환 : 두 일자 사이의 일수
 * ex) day_diff_count("20070322", "20070328")는 6을 반환한다.
*/
function day_diff_count(p_date1, p_date2){
	var date1 = toTimeObject(p_date1);
    var date2 = toTimeObject(p_date2);
    var day   = 1000 * 3600 * 24; //24시간

    return parseInt((date2 - date1) / day, 10);
}

/*
 * 기능 : 인자로 넘어온 두 날짜형식의 문자열 사이의 년, 월수를 계산한다.
 * 인자 : p_date1 - 날짜형식의 문자열(from), p_date2 - 날짜형식의 문자열(to)
 * 반환 : v_arr - 두 일자 사이의 년, 월수 배열
 * ex) day_diff_count("20070322", "20070428")는 {0, 1}을 반환한다.
*/
function month_diff_count(p_date1, p_date2){
	var date1 = toTimeObject(p_date1);
	var date2 = toTimeObject(p_date2);

	var years  = date2.getFullYear() - date1.getFullYear();
	var months = date2.getMonth() - date1.getMonth();

	var v_arr = new Array();
	v_arr[0] = parseInt((years*12+months)/12);
	v_arr[1] = (years*12+months)-(parseInt((years*12+months)/12)*12);
	//return (years * 12 months);
	return v_arr;
}

/*
 * 기능 : 인자로 넘어온 두 날짜형식의 문자열 사이의 년, 월수를 계산한다.
 * 인자 : time - 날짜형식의 문자열
 * 반환 : Date(year,month,day) - Date 객체
 * ex) toTimeObject("20070322")는 Date형 20070322을 반환한다.
*/
function toTimeObject(time) { //parseTime(time)
    var year  = time.substr(0,4);
    var month = time.substr(4,2)-1;
    var day   = time.substr(6,2);

    return new Date(year,month,day);
}

/*
 * 기능 : 인자로 (날짜, 년월일구분자, 더할값)을 받아 날짜에 인자로 받은 년, 월, 일수를 더하여 반환한다.
 * 인자 : p_date - 날짜형식의 문자열, dvn - 년(year)인지 월"month", 일"day"인지 구분하는 값, value - 더할 값
 * 반환 : 날짜형식 문자열
 * ex) addDate("20070517", "year", 2)는 "20090517"을 반환한다.
*/
function addDate(p_date, dvn, value)
{
	p_date = del_hyphen_date(p_date);
	var year	= p_date.substring(0,4);
	var month	= p_date.substring(4,6);
	var day		= p_date.substring(6,8);
   
	if(dvn == "year")
	{
		year = eval(year,10) + value;
		year = ""+year;
	}
	else if(dvn == "month")
	{
		month = eval(month,10) + value;
		if(month < 10)
		{
			month = "0"+month;
		}
		else
		{
			month = ""+month;
		}
	}
	else if(dvn == "day")
	{
		day = eval(day,10) + value;
		if(day < 10)
		{
			day = "0"+day;
		}
		else
		{
			day = ""+day;
		}
	}
	
	p_date= year+month+day;

	return p_date;
}  

/*
 * 기능 : 인자로 (날짜, 년월일구분자, 더할값)을 받아 날짜에 인자로 받은 년, 월, 일수를 빼서 반환한다.
 * 인자 : p_date - 날짜형식의 문자열, dvn - 년(year)인지 월"month", 일"day"인지 구분하는 값, value - 뺄 값
 * 반환 : 날짜형식 문자열
 * ex) subDate("20070517", "month", 2)는 "20070317"을 반환한다.
*/
function subDate(p_date, dvn, value)
{
	p_date = del_hyphen_date(p_date);
	var year	= p_date.substring(0,4);
	var month	= p_date.substring(4,6);
	var day		= p_date.substring(6,8);
   
	if(dvn == "year")
	{
		year = eval(year,10) - value;
		year = ""+year;
	}
	else if(dvn == "month")
	{
		month = eval(month,10) - value;
		if(month < 10)
		{
			month = "0"+month;
		}
		else
		{
			month = ""+month;
		}
	}
	else if(dvn == "day")
	{
		day = eval(day,10) - value;
		if(day < 10)
		{
			day = "0"+day;
		}
		else
		{
			day = ""+day;
		}
	}
	
	p_date= year+month+day;

	return p_date;
}  

/*
 * 기능 : 인자로 넘어온 문자열을 특정 문자로 나누어 Array 형태로 변환한다.
 * 인자 : tmpStr - 문자열, divMark - 특정문자
 * 반환 : tmpStr[] - 특정문자로 나누어진 배열
 * ex) divStr("aa.aaa",".")는 {"aa","aaa"}를 반환한다.
*/
function divStr(tmpStr,divMark){
    return tmpStr.split(divMark);
}

/*
 * 기능 : 인자로 넘어온 주민번호 형식의 문자열을  주민번호 뒤자리로 성별을 판별한다.
 * 인자 : juminVal - 주민번호 형식의 문자열
 * 반환 : mGender - "M", "F"
 * ex) CheckGender("7712152456711")는 "F"를 반환한다.
*/
function CheckGender(juminVal)
{
    if(juminVal.charAt(6)=="1" || juminVal.charAt(6)=="3")
    {
        mGender="M"; //남
    }
    else if(juminVal.charAt(6)=="2" || juminVal.charAt(6)=="4")
    {
        mGender="F"; //여
    }
return mGender;
}

/*
 * 기능 : 인자로 넘어온 숫자 형식의 문자열을 특정 포멧이 갖추어진 문자열로 변환한다.
 * 인자 : value - 숫자 형식의 문자열, format - 특정 포멧
 * 반환 : ret - 특정포멧으로 변환한 문자열
 * ex) GetFormat("1234567","###3.#####")는 "1,234,567.00000"를 반환한다.
*/
function GetFormat(value,format)
{
    value = ""+value;

    if(!format)
        return value;

    var sp = parseInt(format.charAt(3));

    if(!sp)
        return value;

    var pos = 0;
    var ret = "";
    var vSplit = value.split('.');
    var fSplit = format.split('.');
    var fp = fSplit[1];
    var fv = vSplit[1];
    var lv = vSplit[0];
    var len = lv.length;

    for(var i = len % sp; i < len; i += sp)
    {
        if(i == 0 || lv.charAt(i-1) == '-')
            ret += lv.substring(pos,i);
        else
            ret += lv.substring(pos,i)+',';
        pos = i;
    }

    ret += lv.substring(pos,len);

    if(!fv)
        fv = "";
    if(!fp)
        fp = "";

    var len1 = fp.length;
    var len2 = fv.length;

    if(len1)
        ret += '.' + fv.substring(0,len1) + fp.substring(len1,len2);
    //alert(ret);
    return ret;
}


/*
 * 기능 : 인자로 넘어온 숫자 형식의 문자열을 한글로 변환한다.
 * 인자 : string - 숫자 형식의 문자열
 * 반환 : result - 한글로 변환한 문자열
 * ex) ChangeIntHan("12345")는 "일만이천삼백사십오"를 반환한다.
*/
function ChangeIntHan(string)
{
      hn = new Array("영","일","이","삼","사","오","육","칠","팔","구");
      hj = new Array("","만","억","조","경","해");
      ul = new Array("영천","영백","영십","영");
      tm = new Array();
      result = "";

      if (string.charAt(0)=="-")
      {
          result = "마이너스 ";
          string = string.substr(1,string.length-1);
      }
      loop_size = Math.ceil(string.length/4);
               string2 = "";
      for (count=string.length; count >= 0; count--)
          string2 += string.substring(count,count-1);
          string = string2;
      for (A=0;A<loop_size;A++)
      {
        sum = hj[A] + " ";
        tm[A] = string.substr(A*4,4);

        tm2 = "";
            for (count=tm[A].length; count >= 0; count--)
            tm2 += tm[A].substring(count,count-1);
            tm[A] = tm2;
            part_jari = tm[A].length;
             for (D=0;D<10;D++)
             {
                for (B=0;B<10;B++) tm[A] = tm[A].replace(B,hn[B]);
             }

        if (part_jari == 4) tm[A] = tm[A].charAt(0)+"천"+tm[A].charAt(1)+"백"+tm[A].charAt(2)+"십"+tm[A].charAt(3);
        else if (part_jari == 3) tm[A] = tm[A].charAt(0)+"백"+tm[A].charAt(1)+"십"+tm[A].charAt(2);
        else if (part_jari == 2) tm[A] = tm[A].charAt(0)+"십"+tm[A].charAt(1);
        else tm[A] = tm[A].charAt(0);
        for (C=0;C<4;C++)
        {
          if (tm[A].match(ul[C]))
          {
            part_jari--; tm[A] = tm[A].replace(ul[C],"");
          }
        }
        if (part_jari != 0) tm[A] += sum;
      }
      for (loop_size;loop_size>-1;loop_size--) result += tm[loop_size];
      result = result.replace("undefined","");
     // alert(result);
      return result;
}

/*
 * 기능 : 인자로 넘어온 숫자 형식의 문자열을 한자로 변환한다.
 * 인자 : string - 숫자 형식의 문자열
 * 반환 : result - 한자로 변환한 문자열
 * ex) ChangeIntHanJa("12345")는 "壹萬貳千參百四拾五"를 반환한다.
*/
function ChangeIntHanJa(string)
{
      hn = new Array("영","壹","貳","參","四","五","六","七","八","九");
      hj = new Array("","萬","億","兆");
      ul = new Array("영千","영百","영拾","영");
      tm = new Array();
      result = "";

      if (string.charAt(0)=="-")
      {
          result = "마이너스 ";
          string = string.substr(1,string.length-1);
      }
      loop_size = Math.ceil(string.length/4);
               string2 = "";
      for (count=string.length; count >= 0; count--)
          string2 += string.substring(count,count-1);
          string = string2;
      for (A=0;A<loop_size;A++)
      {
        sum = hj[A] + " ";
        tm[A] = string.substr(A*4,4);

        tm2 = "";
            for (count=tm[A].length; count >= 0; count--)
            tm2 += tm[A].substring(count,count-1);
            tm[A] = tm2;
            part_jari = tm[A].length;
             for (D=0;D<10;D++)
             {
                for (B=0;B<10;B++) tm[A] = tm[A].replace(B,hn[B]);
             }

        if (part_jari == 4) tm[A] = tm[A].charAt(0)+"千"+tm[A].charAt(1)+"百"+tm[A].charAt(2)+"拾"+tm[A].charAt(3);
        else if (part_jari == 3) tm[A] = tm[A].charAt(0)+"百"+tm[A].charAt(1)+"拾"+tm[A].charAt(2);
        else if (part_jari == 2) tm[A] = tm[A].charAt(0)+"拾"+tm[A].charAt(1);
        else tm[A] = tm[A].charAt(0);
        for (C=0;C<4;C++)
        {
          if (tm[A].match(ul[C]))
          {
            part_jari--; tm[A] = tm[A].replace(ul[C],"");
          }
        }
        if (part_jari != 0) tm[A] += sum;
      }
      for (loop_size;loop_size>-1;loop_size--) result += tm[loop_size];
      result = result.replace("undefined","");
      return result;
}

function db2_length( p_str ){
	if( is_empty(p_str) ) return 0;
	return p_str.length*2+2;
}

/*
 * 기능 : 인자로 문자열에서 모든 특정 문자열을 찾아 전부 특정 문자로 변환한다.
 * 인자 : fullString - 전체문자열, text - 특정문자열, by - 특정문자
 * 반환 : newstr - 변환된 문자열
 * ex) replace("1100110022","00",",")은 "11,11,22"을 반환한다.
*/
function replace(fullString,text,by) {
	var strLength = fullString.length, txtLength = text.length;
	if ((strLength == 0) || (txtLength == 0)) return fullString;

	var i = fullString.indexOf(text);
	if ((!i) && (text != fullString.substring(0,txtLength))) return fullString;
	if (i == -1) return fullString;

	var newstr = fullString.substring(0,i) + by;

	if (i+txtLength < strLength)
	newstr += replace(fullString.substring(i+txtLength,strLength),text,by);

	return newstr;
}

/*
 * 기능 : SYSTEM의 현재일자를 '-'없이 반환한다.
 * 반환 : strDate - '-'없는 현재일자
 * ex) getSysDateNoneHyphen()은 "20070329"을 반환한다.
*/
function getSysDateNoneHyphen()
{
   var strDate = "";

   var date = new Date(); 

   strDate += date.getFullYear();                    

   strDate += date.getMonth() + 1;         

   strDate += date.getDate();                   

   return strDate;                                
}

/*
 * 기능 : SYSTEM의 현재시간을 '-'없이 반환한다.
 * 반환 : strTime - '-'없는 현재시간
 * ex) getSysTimeNoneHyphen()은 "171822"을 반환한다.
*/
function getSysTimeNoneHyphen()
{
   var strTime = "";

   var date = new Date(); 

   strTime += date.getHours();                    

   strTime += date.getMinutes();         

   strTime += date.getSeconds();                   

   return strTime;                                
}

/*
 * 기능 : 인자로 넘어온 date 객체를 날짜 형식의 문자열로 변환한다.
 * 인자 : date - date 객체
 * 반환 : strTime - 날짜 형식의 문자열
 * ex) getYmdDate(date)은 "20061231"을 반환한다.
*/
function getYmdDate(date)
{
   var strTime = "";

   strTime += FillValue(date.getYear()+"",4,'F');                    

   strTime += FillValue(date.getMonth()+1+"",2,'F');         

   strTime += FillValue(date.getDate()+"",2,'F');                   

   return strTime;                                
}

/*
 * 기능 : 인자로 넘어온 날짜 형식의 문자열과 같은 주의 원하는 요일의 날짜를 반환한다.
 * 인자 : date - 날짜 형식의 문자열, day - 요일 순서(0:일요일,1:월요일....)
 * 반환 : strTime - 같은주의 원하는 요일의 날짜
 * ex) getDayOfWeekDate('20070104',0)은 "20061231"(일요일)을 반환한다.
 *	   getDayOfWeekDate('20070104',1)은 "20060101"(월요일)을 반환한다.	
*/
function getDayOfWeekDate(date,day)
{
   var strTime ;
   date = del_hyphen_date(date);
   var year = date.substring(0,4);
   var month = date.substring(4,6);
   var dt = date.substring(6,8);
   
   var date2 = new Date(year,month-1,dt);

   var dayNum = day - date2.getDay();   
   strTime = getYmdDate(new Date(date2.getTime()+dayNum*1000*60*60*24));

   return strTime;                                
}

/*
 * 기능 : 인자로 넘어온 숫자 형식의 문자열을 대출이율 형식(##.###%)으로 변환한다. 
 * 인자 : num - 숫자 형식의 문자열
 * 반환 : rsltNum - 대출이율 형식으로 변환된 문자열
 * ex) getLoanRate('10000')은 "10.000%"을 반환한다.
*/
function getLoanRate(num)
{
	var num_f = num.substring(0,2);
	var num_t = num.substring(2,5);
	var rsltNum;
	
	if(num_t == 0)
	{
		rsltNum = parseInt(num_f) ;
	}
	else
	{
		rsltNum = parseInt(num_f + "." + num_t);
	}
	
	return rsltNum;
}

/*
 * 기능 : 키보드 입력시 숫자만 입력 가능하게 한다.
 * ex) key_only_number()
*/
function key_only_number(){
	if (!event.shiftKey 
	    && ( event.keyCode >=48 && event.keyCode <=57 )			// 자판 0~9
		|| (event.keyCode >=96 && event.keyCode <= 105 ) 			// keypad 0~9
		|| (event.keyCode == 109 )												// 자판 -
		|| (event.keyCode == 189 )												// keypad -
		|| (event.keyCode == 8 )													// back space
		|| (event.keyCode == 9 )													// tab
		|| (event.keyCode == 13 )													// enter
		|| (event.keyCode == 46 )													// delete
		|| (event.keyCode == 17 )													// ctrl
		|| (event.keyCode >= 37 && event.keyCode <= 40 ) )			// 방향키
	{
			return true;
	}
	else {
		event.returnValue = false;
	}
}

/*
 * 기능 : 키보드 입력시 숫자와 ','만 입력 가능하게 한다.
 * ex) key_amt_number()
*/
function key_amt_number(){
	if (!event.shiftKey 
	    && ( event.keyCode >=48 && event.keyCode <=57 )			// 자판 0~9
		|| (event.keyCode >=96 && event.keyCode <= 105 ) 			// keypad 0~9
		|| (event.keyCode == 109 )												// 자판 -
		|| (event.keyCode == 189 )												// keypad -
		|| (event.keyCode == 188 )												// 자판 ,
		|| (event.keyCode == 8 )													// back space
		|| (event.keyCode == 9 )													// tab
		|| (event.keyCode == 13 )													// enter
		|| (event.keyCode == 46 )													// delete
		|| (event.keyCode >= 37 && event.keyCode <= 40 ) )			// 방향키
	{
			return true;
	}
	else {
		event.returnValue = false;
	}

}

/*
 * 기능 : 키보드 입력시 숫자와 '.'만 입력 가능하게 한다.
 * ex) key_rate_number()
*/
function key_rate_number(){
	if (!event.shiftKey 
	    && ( event.keyCode >=48 && event.keyCode <=57 )			// 자판 0~9
		|| (event.keyCode >=96 && event.keyCode <= 105 ) 			// keypad 0~9
//		|| (event.keyCode == 109 )												// 자판 -
//		|| (event.keyCode == 189 )												// keypad -
		|| (event.keyCode == 110 )												// 자판 .
		|| (event.keyCode == 190 )												// keypad .
		|| (event.keyCode == 8 )													// back space
		|| (event.keyCode == 9 )													// tab
		|| (event.keyCode == 13 )													// enter
		|| (event.keyCode == 46 )													// delete
		|| (event.keyCode >= 37 && event.keyCode <= 40 ) )			// 방향키
	{
			return true;
	}
	else {
		event.returnValue = false;
	}
}

/*
 * 기능 : 입력으로 받은 HTML 체크박스 객체(<input type="checkbox" />)를 val 값에 따라 check 혹은 uncheck 한다.
 * 인자 : obj_chk - HTML 체크박스 객체
 * 			 val - "Y" 혹은 "N"
 * ex) 	 setCheckBox(obj_chk, "Y");는 obj_chk가 가리키는 체크박스 객체를 설정한다.
 */		
function setCheckBox(obj_chk, val)	
{
	if(!is_empty(obj_chk))
	{
		switch(val.toUpperCase())
		{
			case "Y" : 
				
				obj_chk.checked = true;
				break;			
				
			case "N" : 
				
				obj_chk.checked = false;
				break;			
				
			default : 
			
				break;
		}
	}
}

/*
 * 기능 : 입력으로 받은 HTML 체크박스 객체(<input type="checkbox" />)의 check 여부를 'Y'와 'N' 값으로 변환하여 가져온다.
 * 인자 : obj_chk - HTML 체크박스 객체
 * ex) 	 getCheckBox(obj_chk);는 obj_chk가 가리키는 체크박스 객체의 check 여부를 'Y'(check시)와 'N'(uncheck시) 값으로 변환하여 반환한다.
 */		
function getCheckBox(obj_chk)	
{
	var rtn_val;

	if(!is_empty(obj_chk))
	{
		if(obj_chk.checked)
		{
			rtn_val = "Y";
		}
		else
		{
			rtn_val = "N";		
		}
	}
	
	return rtn_val;
}