/**
 * @fileoverview Array와 String 객체에 Prototype(원형)을 설정하여 객체를 확장하며
 * Form 내부 엘리먼트의 유효성 체크 및 한글의 UTF-8 인코딩을 제공한다.
 * @author OFFTOM
 * @version 3.0
 */

/**
 * Function Prototypes - common
 * @author OFFTON
 */
Array.prototype.getHashValue            = jf_array_getHashValue;
Array.prototype.makeArray               = jf_array_makeArray;

String.prototype.trim                   = jf_string_trim;
String.prototype.ltrim                  = jf_string_ltrim;
String.prototype.rtrim                  = jf_string_rtrim;
String.prototype.isEmpty                = jf_string_isEmpty;
String.prototype.isWhitespace           = jf_string_isWhitespace;
String.prototype.isLetter               = jf_string_isLetter;
String.prototype.isDigit                = jf_string_isDigit;
String.prototype.isLetterOrDigit        = jf_string_isLetterOrDigit;
String.prototype.isInteger              = jf_string_isInteger;
String.prototype.isSignedInteger        = jf_string_isSignedInteger;
String.prototype.isPositiveInteger      = jf_string_isPositiveInteger;
String.prototype.isNonNegativeInteger   = jf_string_isNonNegativeInteger;
String.prototype.isNegativeInteger      = jf_string_isNegativeInteger;
String.prototype.isIntegerInRange       = jf_string_isIntegerInRange;
String.prototype.isFloat                = jf_string_isFloat;
String.prototype.toFormat               = jf_string_toFormat;
String.prototype.deFormat               = jf_string_deFormat;
String.prototype.getLength              = jf_string_getLength;
String.prototype.encodeBASE64			= jf_string_encodeBASE64;
String.prototype.decodeBASE64			= jf_string_decodeBASE64;

/**
 * Function Prototypes - StringUtil
 * @author OFFTON
 */
String.prototype.isEmail                = jf_string_isEmail;
String.prototype.isPhoneNo              = jf_string_isPhoneNo;
String.prototype.isHandPhoneNo          = jf_string_isHandPhoneNo;
String.prototype.isSaupNo               = jf_string_isSaupNo;
String.prototype.isPSN                  = jf_string_isPSN;
String.prototype.unSplit                = jf_string_unSplit;
String.prototype.left                   = jf_string_left;
String.prototype.right                  = jf_string_right;
String.prototype.lPad                   = jf_string_lPad;
String.prototype.rPad                   = jf_string_rPad;
String.prototype.replaceAll             = jf_string_replaceAll;

/**
 * Function Prototypes - NumberUtil
 */
String.prototype.toComma                = jf_string_toComma;
String.prototype.deComma                = jf_string_deComma;

/**
 * Regular Expressions Definition
 * @author OFFTON
 */
var reg_exp_table = new Array(
  new Array('REGEXP_TRIM'               , /(^ +)|( +$)/g                )
 ,new Array('REGEXP_LTRIM'              , /(^ +)/g                      )
 ,new Array('REGEXP_RTRIM'              , /( +$)/g                      )
 ,new Array('REGEXP_IS_WHITESPACE'      , /^[\s]*$/                     )
 ,new Array('REGEXP_IS_LETTER'          , /^[a-zA-Z]+$/                 )
 ,new Array('REGEXP_IS_DIGIT'           , /^[0-9]+$/                    )
 ,new Array('REGEXP_IS_LETTER_OR_DIGIT' , /^[A-Za-z0-9]+$/              )
 ,new Array('REGEXP_IS_INTEGER'         , /^(\+|\-|\d*)\d+$/            )
 ,new Array('REGEXP_IS_SIGNED_INTEGER'  , /^(\+|\-)\d+$/                )
 ,new Array('REGEXP_IS_POSITIVE_INTEGER', /^(\+|\d*)\d+$/               )
 ,new Array('REGEXP_IS_NEGATIVE_INTEGER', /^(\-)\d+$/                   )
 ,new Array('REGEXP_IS_FLOAT'           , /^(\+|\-|\d*)\d+(\.|\d*)\d*$/ )
);

/**
 * 배열에서 key에 해당하는 value를 찾는 함수
 * @public
 * @param {String} key 찾으려는 데이터의 키값
 * @return 키값에 해당하는 값
 * @type String
 * @author OFFTON
 */
function jf_array_getHashValue(key) {
	var idx = 0;
	for (idx = 0; idx < this.length; idx++) {
		if (this[idx][0] == key) {
			return this[idx][1];
		}
	}
	return '';
}

/**
 * 배열을 지정된 size만큼 할당하고 0으로 초기화하는 함수
 * @public
 * @param {Number} size 배열 크기
 * @return 할당된 배열
 * type Object
 * @author OFFTON
 */
function jf_array_makeArray(size) {
	var i;
	for (i = 1; i <= size; i++) {
		this[i] = 0;
	}
	return this;
}

/**
 * 앞뒤 공백문자 제거함수
 * @public
 * @return 앞뒤 공백문자가 제거된 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_trim() {
	return (this.replace(reg_exp_table.getHashValue('REGEXP_TRIM'), ''));
}

/**
 * 좌측 공백문자 제거 함수
 * @public
 * @return 좌측 공백문자가 제거된 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_ltrim() {
	return (this.replace(reg_exp_table.getHashValue('REGEXP_LTRIM'), ''));
}

/**
 * 우측 공백문자 제거 함수
 * @public
 * @return 우측 공백문자가 제거된 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_rtrim() {
	return (this.replace(reg_exp_table.getHashValue('REGEXP_RTRIM'), ''));
}

/**
 * 빈문자열인지 체크하는 함수
 * @public
 * @return 빈문자열일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isEmpty() {
	return ((this == null) || (this.trim().length == 0));
}

/**
 * whitespace 문자열인지 체크하는 함수
 * @public
 * @return whitespace 문자열일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isWhitespace() {
	return (reg_exp_table.getHashValue('REGEXP_IS_WHITESPACE').test(this));
}

/**
 * 영문자인지 체크하는 함수
 * @public
 * @return 영문자일 경우(대소문자 구분없음) true, 아닐경우 flase
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isLetter() {
	return (reg_exp_table.getHashValue('REGEXP_IS_LETTER').test(this));
}

/**
 * 숫자인지 체크하는 함수
 * @public
 * @return 숫자일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isDigit() {
	return (reg_exp_table.getHashValue('REGEXP_IS_DIGIT').test(this));
}

/**
 * 숫자나 영문자 인지 체크하는 함수
 * @public
 * @return 숫자나 영문자일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isLetterOrDigit() {
	return (reg_exp_table.getHashValue('REGEXP_IS_LETTER_OR_DIGIT').test(this));
}

/**
 * 정수형인지 체크하는 함수
 * @public
 * @return 정수형일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isInteger() {
	return (reg_exp_table.getHashValue('REGEXP_IS_INTEGER').test(this));
}

/**
 * 부호가 있는 정수형인지 체크하는 함수
 * @public
 * @return 부호가 있는 정수형일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isSignedInteger() {
	return (reg_exp_table.getHashValue('REGEXP_IS_SIGNED_INTEGER').test(this));
}

/**
 * 양의 정수인지 체크(0은 제외)하는 함수
 * @public
 * @return 양의 정수일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isPositiveInteger() {
	return ((reg_exp_table.getHashValue('REGEXP_IS_POSITIVE_INTEGER').test(this)) && (parseInt(this, 10) > 0));
}

/**
 * 0 또는, 0보다 큰 수인지 체크하는 함수
 * @public
 * @return 0 또는, 0보다 큰 수 일경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isNonNegativeInteger() {
	return ((reg_exp_table.getHashValue('REGEXP_IS_POSITIVE_INTEGER').test(this)) || (parseInt(this, 10) == 0));
}

/**
 * 음의 정수인지 체크 하는 함수
 * @public
 * @return 음의 정수일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isNegativeInteger() {
	return (reg_exp_table.getHashValue('REGEXP_IS_NEGATIVE_INTEGER').test(this));
}

/**
 * 실수형인지 체크하는 함수
 * @public
 * @return 실수형일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isFloat() {
	return (reg_exp_table.getHashValue('REGEXP_IS_FLOAT').test(this));
}

/**
 * 입력한 범위 내의 값인지 체크(정수형)하는 함수
 * @public
 * @param {String} from 시작 범위. 값이 null일 경우는 from 조건 제외
 * @param {String} to 끝 범위. 값이 null일 경우는 to 조건 제외
 * @return 입력한 범위 내의 값일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isIntegerInRange(from, to) {
	if (!this.isInteger()) { return false; }        //정수형인지 체크
	if (!((from <= parseInt(this, 10)) && (to >= parseInt(this, 10)))) { return false; } //범위 내의 값인지 체크

	return true;
}

/**
 * 문자열을 format에 맞도록 변경하는 함수
 * @public
 * @param {String} format 변경할 형태
 * @return format에 맞도록 변경된 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_toFormat(format) {
	var ret = '';
	var i = 0, j = 0;

	if (this.isEmpty())   		{ return '';   }  //빈문자열일 경우 빈 문자 return
	if (format.isEmpty()) 		{ return this; }  //format이 지정되지 않았을 경우는 원래 문자열 return
	if (this.indexOf('_') > 0) 	{ return this; }

	for (i=0; i<format.length; i++) {
		if (format.charAt(i) == '_') {
			ret = ret + this.charAt(j++);
		} else {
			ret = ret + format.charAt(i);
		}
	}
	return (ret);
}

/**
 * format 형태로 변경된 문자열을 원래 상태로 복구하는 함수
 * @public
 * @param {String} format 변경 전 형태
 * @return 원래 문자열을 리턴
 * @type String
 * @author OFFTON
 */
function jf_string_deFormat(format) {
	var ret = '';
	var i = 0, j = 0;

	if (this.isEmpty())   		{ return '';   }  //빈문자열일 경우 빈 문자 return
	if (format.isEmpty()) 		{ return this; }  //format이 지정되지 않았을 경우는 원래 문자열 return
	if (format.indexOf('_') < 0){ return this; }

	for (i=0; i<format.length; i++) {
		if (format.charAt(i) == '_') {
			ret = ret + this.charAt(j++);
		} else {
			j++;
		}
	}
	return (ret);
}

/**
 * 문자열의 길이를 얻어오는 함수
 * @public
 * @return 문자열의 길이
 * @type Number
 * @author OFFTON
 */
function jf_string_getLength() {
	return (this.length);
}

/**
 * 메일형식 유효성 체크
 * @public
 * @return 올바른 메일형식일 경우 true, 아닐경우 false 리턴
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isEmail() {
	return (/^\w+((-|\.)\w+)*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z]{2,4}$/.test(this));
}

/**
 * 전화번호형식 유효성 체크
 * @public
 * @return 올바른 전화번호형식일 경우 true, 아닐경우 false 리턴
 * @type Boolean
 * @author OFFTON 
 */
function jf_string_isPhoneNo() {
	return (/^\d{2,3}-\d{3,4}-\d{4}$/.test(this));
}

/**
 * 핸드폰번호형식 유효성 체크
 * @public
 * @return 올바른 핸드폰번호형식일 경우 true, 아닐경우 false 리턴
 * @type Boolean
 * @author OFFTON 
 */
function jf_string_isHandPhoneNo() {
	return (/^01([0|1|6|7|8|9]?)-?([0-9]{3,4})-?([0-9]{4})$/.test(this));
}

/**
 * 사업자번호형식 유효성 체크
 * @public
 * @return 올바른 사업자번호형식일 경우 true, 아닐경우 false 리턴
 * @type Boolean
 * @author OFFTON 
 */
function jf_string_isSaupNo() {
	//return (/([0-9]{3})([0-9]{2})([0-9]{5}$)/.test(this));
	
    // bizID는 숫자만 10자리로 해서 문자열로 넘긴다. 
    var checkID = new Array(1, 3, 7, 1, 3, 7, 1, 3, 5, 1);
    var tmpBizID, i, chkSum=0, c2, remander;
    var bizID = this.replace(/-/gi,''); 

    for (i=0; i<=7; i++) {
        chkSum += checkID[i] * bizID.charAt(i);
    }
    c2 = "0" + (checkID[8] * bizID.charAt(8)); 
    c2 = c2.substring(c2.length - 2, c2.length); 
    chkSum += Math.floor(c2.charAt(0)) + Math.floor(c2.charAt(1)); 
    remander = (10 - (chkSum % 10)) % 10 ; 

    if (Math.floor(bizID.charAt(9)) == remander) return true ; // OK!
    else    return false; 
}

/**
 * 올바른 주민등록번호인지 체크
 * @public
 * @return 올바른 주민등록번호일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function jf_string_isPSN() {
	var i   = 0, j = 0, sum = 0, checkVal = 0;
	var psn = this.replace('-', '');
	
	var isCheck = false;

	if (psn == '1111111111118') {         //올바르지 않은 주민등록번호
		return false;
	}
	if (!/^[0-9]+$/.test(psn)) {          //숫자가 아닐경우 return false
		return false;
	}

	for (i = 0, j = 2; j < 10; i++, j++) {
		sum += (psn.charAt(i) * j);
	}
	for (i = 8, j = 2; j < 6; i++, j++) {
		sum += (psn.charAt(i) * j);
	}

	checkVal = 11 - (sum % 11);
	checkVal = (checkVal >= 10) ? checkVal - 10 : checkVal;
	
	//외국인 등록번호 체크
	var isForeign = jf_string_isForeign(psn);
	
	if (psn.charAt(12) != checkVal && !isForeign) {
		return false;
	}
	return true;
}

/**
 * 외국인 등록번호 체크
 * @public
 * @return 올바른 외국인 등록번호일 경우 true, 아닐경우 false
 * @type   Boolean
 * @author OFFTON
 */
function jf_string_isForeign(regNo) {
    var sum = 0;
    var odd = 0;
    
    buf = new Array(13);
    for (i = 0; i < 13; i++) buf[i] = parseInt(regNo.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;
    }
}

/**
 * 구분자 제거
 * @public
 * @param {String} delimiter 구분자
 * @return 구분자를 제거한 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_unSplit(delimiter){
	var ret;
	var reg_exp_split;

	delimiter = (delimiter == null) ? '-' : delimiter;

	reg_exp_split = new RegExp('\\' + delimiter, 'gi');
	ret = this.replace(reg_exp_split, '');

	return ret;
}

/**
 * 왼쪽부터 문자열을 잘라 리턴해주는 함수
 * @public
 * @param {Number} len 자를 문자열의 길이
 * @return 왼쪽으로 부터 len만큼 자른 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_left(len) {
	if (len <= 0) {
		return '';
	} else if (len > this.length) {
		return this;
	} else {
		return this.substring(0, len);
	}
}

/**
 * 오른쪽부터 문자열을 잘라 리턴해주는 함수
 * @public
 * @param {Number} len 자를 문자열의 길이
 * @return 오른쪽으로 부터 len만큼 자른 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_right(len) {
	if (len <= 0) {
		return "";
	} else if (len > this.length) {
		return this;
	} else {
		var str_len = this.length;
		return this.substring(str_len, str_len - len);
	}
}

/**
 * 길이만큼 왼쪽에 빈 공간을 특정 문자로 채워주는 함수
 * @public
 * @param {Number} len 최종 문자열의 길이
 * @param {String} ch 빈 문자를 길이만큼 채워줄 문자
 * @return 특정 문자로 채워진 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_lPad(len, ch) {
	var ret      = this;
	var this_len = this.length;

	if (len < this_len) return ret;

	for (i = 0; i<len-this_len; i++) {
		ret = ch + ret;
	}
	return ret;
}

/**
 * 길이만큼 오른쪽에 빈 공간을 특정 문자로 채워주는 함수
 * @public
 * @param {Number} len 최종 문자열의 길이
 * @param {String} ch 빈 문자를 길이만큼 채워줄 문자
 * @return 특정 문자로 채워진 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_rPad(len, ch) {
	var ret      = this;
	var this_len = this.length;

	if (len < this_len) return ret;

	for (i = 0; i<len-this_len; i++) {
		ret = ret + ch;
	}
	return ret;
}

/**
 * 문자열에 포함된 특정 문자를 다른 문자로 변경한다.
 * @public
 * @param {String} symbol1 바꿀문자
 * @param {String} symbol2 바뀔문자
 * @return 치환된 문자열
 * @type String
 * @author OFFTON
 */
function jf_string_replaceAll( symbol1, symbol2 ) {
	var spt = this.split( symbol1 );
	var ret = '';

	for ( var i = 0; i < spt.length; i++ ) {
		if ( i > 0 ) ret += symbol2;
		ret += spt[i];
	}
	return ret == '' ? this : ret;
}

/**
 * 세자리마다 콤마 찍음
 * @public
 * @return 세자리마다 콤마 찍은 문자
 * @type String
 * @author OFFTON
 */
function jf_string_toComma() {
	var ret;
	var reg_exp_comma, arrNumber;

	reg_exp_comma = new RegExp('([0-9])([0-9][0-9][0-9][,.])');
	arrNumber = this.split('.');    //소수점 기분으로 분리

	arrNumber[0] += '.';

	do {
		arrNumber[0] = arrNumber[0].replace(reg_exp_comma, '$1,$2');
	} while (reg_exp_comma.test(arrNumber[0]));

	if (arrNumber.length > 1) {     //소수점 이하 값이 있을 경우
		ret = arrNumber.join('');     //구분자 없이 배열의 모든값을 합침
	} else {
		ret = arrNumber[0].split('.')[0];
	}
	return ret;
}

/**
 * 콤마 제거
 * @public
 * @return 콤마 제거한 문자
 * @type String
 * @author OFFTON
 */
function jf_string_deComma() {
	return (this.replace(/\,/gi, ''));
}

/**
 * 문자열을 BASE64로 인코딩한다.
 * @public
 * @return BASE64로 인코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function jf_string_encodeBASE64() {
	var input  = this;
	var output = "";
	var chr1, chr2, chr3;
	var enc1, enc2, enc3, enc4;
	var i = 0;
	var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

	input = encodeUTF8(input);
	do {
		chr1 = input.charCodeAt(i++);
		chr2 = input.charCodeAt(i++);
		chr3 = input.charCodeAt(i++);

		enc1 = chr1 >> 2;
		enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
		enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
		enc4 = chr3 & 63;

		if (isNaN(chr2)) {
			enc3 = enc4 = 64;
		} else if (isNaN(chr3)) {
			enc4 = 64;
		}

		output = output + keyStr.charAt(enc1) + keyStr.charAt(enc2) +
			keyStr.charAt(enc3) + keyStr.charAt(enc4);
	} while (i < input.length);

	return output;
}

/**
 * BASE64로 인코딩된 문자열을 한글로 디코딩한다.
 * @public
 * @return 디코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function jf_string_decodeBASE64() {
	var output = "";
	var chr1, chr2, chr3;
	var enc1, enc2, enc3, enc4;
	var i = 0;
	var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
	this.replace(/[^A-Za-z0-9\+\/\=]/g, "");
	do {
		enc1 = keyStr.indexOf(this.charAt(i++));
		enc2 = keyStr.indexOf(this.charAt(i++));
		enc3 = keyStr.indexOf(this.charAt(i++));
		enc4 = keyStr.indexOf(this.charAt(i++));

		chr1 = (enc1 << 2) | (enc2 >> 4);
		chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
		chr3 = ((enc3 & 3) << 6) | enc4;

		output = output + String.fromCharCode(chr1);

		if (enc3 != 64) {
			output = output + String.fromCharCode(chr2);
		}
		if (enc4 != 64) {
			output = output + String.fromCharCode(chr3);
		}
	} while (i < this.length);

	return decodeUTF8(output);
}












/**
 * 빈문자열인지 체크하는 함수(Prototypes으로 할 경우 null체크 문제로 추가함)
 * @public
 * @param {String} str 빈문자인지 체크할 문자열
 * @return 빈문자열일 경우 true, 아닐경우 false
 * @type Boolean
 * @author OFFTON
 */
function isEmpty(str) {
	return ((str == null) || (str.trim().length == 0));
}

/**
 * text 엘리먼트에 문자를 입력하고 엔터 키를 누를 경우 포커스를 이동시킨다.
 * @public
 * @param {String} formName 폼 이름
 * @param {Object} elem onKeyDown 이벤트가 발생된 엘리먼트
 * @author OFFTON
 */
function next_focus(formName, elem) {
	var step = 1;
	var arg = next_focus.arguments;
	if(arg.length > 2) {
		step = Number(arg[2]) + 1;
	}
	if(event.keyCode == 13) {
		nextFocus(formName, elem, step);
		event.keyCode = 0;
	}
}

/**
 * text 엘리먼트에 문자를 입력하고 엔터 키를 누를 경우 포커스를 이동시킨다.
 * @public
 * @param {String} formName 폼 이름
 * @param {Object} elem onKeyDown 이벤트가 발생된 엘리먼트
 * @param {Number} step 포커스 이동 거리
 * @author OFFTON
 */
function nextFocus(formName, elem, step) {
	var avail_form = eval(formName);

	for(var i = 0; i < (avail_form.elements.length) - 1; i++) {
		if( elem == avail_form.elements[i]) {
			var e = avail_form.elements[i+step];
			if(e && e.type != 'hidden' && e.disabled == false) {
				focusSelect(e);
	  		}
	  		break;
		}
  	}
}

/**
 * 입력된 엘리먼트로 포커스를 이동시킨다.
 * @public
 * @param {Object} elem 포커스가 이동 될 엘리먼트
 * @author OFFTON
 */
function focusSelect(elem) {
	elem.focus();
	if(elem.type == 'text' && elem.value.length > 0) {
		elem.select();
	}
}

/**
 * 엘리먼트 값이 null 이거나 빈문자열이면 경고 메시지를 출력한다.
 * @public
 * @param {Object} elem NULL 체크할 엘리먼트
 * @param {String} notify 엘리먼트 설명
 * @return 선택되거나 입력된 값이 null이 아니라면 true, null이면 false
 * @type Boolean
 * @author OFFTON
 */
function notNullCheck(elem, notify) {
	if (elem.value.isEmpty()) {
		if (elem.type == 'select-one') {
			alert(notify + ' 선택하여 주십시오!');
		} else {
			alert(notify + ' 기입하여 주십시오!');
		}
		focusSelect(elem);
		if (event) {
			event.returnValue = false;
		}
		return false;
	}

	if (notNullCheck.arguments.length == 3) {
		var sz =  Number(notNullCheck.arguments[2]);
		if (elem.value.length != sz) {
	  		alert(notify + ' ' + sz + '자리로 기입하여 주십시오!');
			focusSelect(elem);
			if (event) {
				event.returnValue = false;
			}
	  		return false;
		}
  	}
	return true;
}

/**
 * 시작 엘리먼트의 값이 종료 엘리먼트의 값보다 작지 않다면
 * 입력된 경고 메시지를 출력한다.
 * @public
 * @param {Object} fromElm 체크할 시작 엘리먼트
 * @param {Object} toElm 체크할 종료 엘리먼트
 * @param {String} notifyFrom 시작 엘리먼트 설명
 * @param {String} notifyTo 종료 엘리먼트 설명
 * @return 올바른 경우 true, 올바르지 않은 false
 * @type Boolean
 * @author OFFTON
 */
function fromToCheck(fromElm, toElm, notifyFrom, notifyTo) {
	if (fromElm.value.isEmpty() && !toElm.value.isEmpty()) {
		alert(notifyFrom + ' 선택하여 주십시오!');
		return false;
	}
	if (!fromElm.value.isEmpty() && !toElm.value.isEmpty() && fromElm.value > toElm.value) {
		alert(notifyFrom + '을 ' + notifyTo + '보다 이전값으로 선택하여 주십시오!');
		return false;
	}
	return true;
}

/**
 * 시작 엘리먼트의 값이 종료 엘리먼트의 값보다 작지 않다면
 * 입력된 경고 메시지를 출력하고 포커스를 이동 시킨다.
 * @public
 * @param {Object} fromElm 체크할 시작 엘리먼트
 * @param {Object} toElm 체크할 종료 엘리먼트
 * @param {String} notifyFrom 시작 엘리먼트 설명
 * @param {String} notifyTo 종료 엘리먼트 설명
 * @return 올바른 경우 true, 올바르지 않은 false
 * @type Boolean
 * @author OFFTON
 */
function fromToCheckAndFocus(fromElm, toElm, notifyFrom, notifyTo) {
	if(fromElm.value.isEmpty() && !toElm.value.isEmpty()) {
		alert(notifyFrom + ' 기입하여 주십시오!');
		focusSelect(fromElm);
		return false;
	}
	if(!fromElm.value.isEmpty() && !toElm.value.isEmpty() && fromElm.value > toElm.value) {
		alert(notifyFrom + '을 ' + notifyTo + '보다 이전값으로 기입하여 주십시오!');
		focusSelect(toElm);
		return false;
	}
	return true;
}

/**
 * 시작 엘리먼트와 종료 엘리먼트의 값이 NULL인지 체크하고
 * 시작 엘리먼트의 값이 종료 엘리먼트의 값보다 작지 않다면
 * 입력된 경고 메시지를 출력한다.
 * @public
 * @param {Object} fromElm 체크할 시작 엘리먼트
 * @param {Object} toElm 체크할 종료 엘리먼트
 * @param {String} notifyFrom 시작 엘리먼트 설명
 * @param {String} notifyTo 종료 엘리먼트 설명
 * @return 올바른 경우 true, 올바르지 않은 false
 * @type Boolean
 * @author OFFTON
 */
function fromToRequisite(fromElm, toElm, notifyFrom, notifyTo) {
	if (fromElm.value.isEmpty()) {
		alert(notifyFrom + ' 기입하여 주십시오!');
		focusSelect(fromElm);
		return false;
	}
	if (toElm.value.isEmpty()) {
		alert(notifyTo + ' 기입하여 주십시오!');
		focusSelect(toElm);
		return false;
	}
	return fromToCheckAndFocus(fromElm,toElm,notifyFrom,notifyTo);
}

/**
 * textarea나 image, button을 제외하고 엔터키가 눌러졌을 경우
 * 다음 엘리먼트로 포커스를 이동하고 선택한다.
 * @public
 * @author OFFTON
 */
function onKeyDownHandler() {
	var objType = event.srcElement.type;
	if (!objType || objType == "textarea" || objType == "image" || objType == "button") {
		return;
	}
	if(event.keyCode == 13) {
		event.keyCode = 9;
	}
}

/**
 * document에서 onKeyDown 이벤트 발생 시 onKeyDownHandler()를 호출한다.
 * 다음 엘리먼트로 포커스를 이동하고 선택한다.
 * @public
 * @author OFFTON
 */
function documentKeyDownInit() {
	document.onkeydown = onKeyDownHandler;
}

/**
 * 선택 폼의 모든 엘리먼트의 값을 대상 폼의 동일한 이름의 엘리먼트에 복사한다.
 * @public
 * @param {String} sourceFromName 선택 폼 이름
 * @param {String} targetFormName 복사 대상 폼 이름
 * @author OFFTON
 */
function copyFormValue(sourceFromName, targetFormName) {
	var sourceFrom = eval(sourceFromName);
	var targetForm = eval(targetFormName);

	for (i = 0; i < sourceFrom.elements.length; i++) {
		try {
			targetForm.elements[sourceFrom.elements[i].name].value = sourceFrom.elements[i].value;
		} catch (e) {}
	}
}

/**
 * 해당 form의 모든 element의 name, value, type을 경고창에 보여준다.
 * @public
 * @param {String} formName 폼 이름
 * @param {String} targetFrame 폼의 대상 프레임 이름
 * @param {String} actionPage 폼을 실행할 페이지 이름
 * @author OFFTON
 */
function debugMessage(formName, targetFrame, actionPage) {
	var avail_form = eval(formName);
	var i, msg = '';
	msg = 'target : ';
	if (targetFrame != undefined) {
		msg += targetFrame;
	}
	msg += "\naction : ";

	if (actionPage != undefined) {
		msg += actionPage;
	}
	msg += "\n";

	for (i=0; i<avail_form.elements.length; i++) {
		msg += "[" + i + ": " + avail_form.elements[i].name
			+ " = "     + avail_form.elements[i].value
			+ " ("      + avail_form.elements[i].type + ")]  \n";
	}
	alert(msg);
}

/**
 * 해당 form의 target, action을 지정하여 submit 한다.
 * @public
 * @param {String} formName 폼 이름
 * @param {String} targetFrame 폼의 대상 프레임 이름
 * @param {String} actionPage 폼을 실행할 페이지 이름
 * @param {Boolean} isDebug 디버그 사용 유무. true인 경우 폼의 type, value 표시
 * @author OFFTON
 */
function submitForm(formName, targetFrame, actionPage, isDebug) {
	var avail_form = eval(formName);
	if (isDebug) {
		debugMessage(formName ,targetFrame, actionPage);
	}

	if (targetFrame != undefined) {
		avail_form.target = targetFrame;
	} else {
		avail_form.target = "";
	}

	if (actionPage != undefined) {
		if (actionPage != "") {
			avail_form.action = actionPage;
		}
	}
	avail_form.submit();
}

/**
 * 해당 엘리먼트의 유효성 체크
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {String} check_type 체크타입(D:Digit, LOD:LetterOrDigit...)
 * @param {String} notify 엘리먼트 설명
 * @param {Boolean} isInit 잘못된 값 제거여부. true인 경우 제거
 * @return 입력값이 조건에 맞게 유효하다면 true, 유효하지 않다면 false
 * @type Boolean
 * @author OFFTON
 */
function modeCheck(elem, check_type, notify, isInit) {
	var elem_title   = "";
	var notice       = "";
	var check_result = false;

	if (elem == null || elem.value.isEmpty()) {
		return false;
	}

	//체크타입 - 함수명의 대문자만 뽑아서 작성하는 것으로 한다.(필요시 추가)
	switch (check_type) {
		case "LOD" : //LetterOrDigit
			check_result = elem.value.isLetterOrDigit();
			notice       = "영문, 숫자의 조합으";
			break;
		case "L" :   //Letter
			check_result = elem.value.isLetter();
			notice       = "영문으";
			break;
		case "D" :   //Digit
			check_result = elem.value.isDigit();
			notice       = "숫자";
			break;
  	}

	//조회조건 입력이 올바르지 않을 경우 메세지를 띄운다.
	if (!check_result) {
		if (notice.isEmpty()) {
			alert("check_type이 올바르지 않습니다.");
		} else {
			alert(notify+" "+notice+"로 기입하여 주십시오");
		}

		//잘못된 값 제거 여부
		if (isInit) {
			elem.value = "";
			elem.focus();
		} else {
			elem.select();
		}
		return false;
	}
	return true;
}

/**
 * 문자열을 UTF-8로 인코딩한다.
 * java.net.URLEncoder.encode(String, "UTF-8"), ie6.0이상(js1.5)에서의 encodedURIComponent(String)과 같은 함수
 * @public
 * @param {String} str 인코딩할 문자열
 * @return UTF-8로 인코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function encodeURL(str){
	var s0, i, s, u;
	s0 = "";                // encoded str
	for (i = 0; i < str.length; i++){   // scan the source
		s = str.charAt(i);
		u = str.charCodeAt(i);          // get unicode of the char
		if (s == " "){s0 += "+";}       // SP should be converted to "+"
		else {
			if ( u == 0x2a || u == 0x2d || u == 0x2e || u == 0x5f || ((u >= 0x30) && (u <= 0x39)) || ((u >= 0x41) && (u <= 0x5a)) || ((u >= 0x61) && (u <= 0x7a))){       // check for escape
				s0 = s0 + s;            // don't escape
			}else {                  // escape
				if ((u >= 0x0) && (u <= 0x7f)){     // single byte format
					s = "0"+u.toString(16);
					s0 += "%"+ s.substr(s.length-2);
				}else if (u > 0x1fffff){     // quaternary byte format (extended)
					s0 += "%" + (oxf0 + ((u & 0x1c0000) >> 18)).toString(16);
					s0 += "%" + (0x80 + ((u & 0x3f000) >> 12)).toString(16);
					s0 += "%" + (0x80 + ((u & 0xfc0) >> 6)).toString(16);
					s0 += "%" + (0x80 + (u & 0x3f)).toString(16);
				}else if (u > 0x7ff){        // triple byte format
					s0 += "%" + (0xe0 + ((u & 0xf000) >> 12)).toString(16);
					s0 += "%" + (0x80 + ((u & 0xfc0) >> 6)).toString(16);
					s0 += "%" + (0x80 + (u & 0x3f)).toString(16);
				}else {                      // double byte format
					s0 += "%" + (0xc0 + ((u & 0x7c0) >> 6)).toString(16);
					s0 += "%" + (0x80 + (u & 0x3f)).toString(16);
				}
			}
		}
	}
	return s0;
}

/**
 * UTF-8로 인코딩된 문자열을 한글로 디코딩한다.
 * java.net.URLDecoder.decode(String, "UTF-8"), ie6.0이상(js1.5)에서의 decodeURIComponent(String)과 같은 함수
 * @public
 * @param {String} str 디코딩할 문자열
 * @return 디코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function decodeURL(str){
	var s0, i, j, s, ss, u, n, f;
	s0 = "";                // decoded str
	for (i = 0; i < str.length; i++){   // scan the source str
		s = str.charAt(i);
		if (s == "+"){s0 += " ";}       // "+" should be changed to SP
		else {
			if (s != "%"){s0 += s;}     // add an unescaped char
			else{               // escape sequence decoding
				u = 0;          // unicode of the character
				f = 1;          // escape flag, zero means end of this sequence
				while (true) {
					ss = "";        // local str to parse as int
						for (j = 0; j < 2; j++ ) {  // get two maximum hex characters for parse
							sss = str.charAt(++i);
							if (((sss >= "0") && (sss <= "9")) || ((sss >= "a") && (sss <= "f"))  || ((sss >= "A") && (sss <= "F"))) {
								ss += sss;      // if hex, add the hex character
							} else {--i; break;}    // not a hex char., exit the loop
						}
					n = parseInt(ss, 16);           // parse the hex str as byte
					if (n <= 0x7f){u = n; f = 1;}   // single byte format
					if ((n >= 0xc0) && (n <= 0xdf)){u = n & 0x1f; f = 2;}   // double byte format
					if ((n >= 0xe0) && (n <= 0xef)){u = n & 0x0f; f = 3;}   // triple byte format
					if ((n >= 0xf0) && (n <= 0xf7)){u = n & 0x07; f = 4;}   // quaternary byte format (extended)
					if ((n >= 0x80) && (n <= 0xbf)){u = (u << 6) + (n & 0x3f); --f;}         // not a first, shift and add 6 lower bits
					if (f <= 1){break;}         // end of the utf byte sequence
					if (str.charAt(i + 1) == "%"){ i++ ;}                   // test for the next shift byte
					else {break;}                   // abnormal, format error
				}
				s0 += String.fromCharCode(u);           // add the escaped character
			}
		}
	}
	return s0;
}

/**
 * 문자열을 UTF-8로 인코딩한다.
 * java.net.URLEncoder.encode(String, "UTF-8"), ie6.0이상(js1.5)에서의 encodedURIComponent(String)과 같은 함수
 * @public
 * @param {String} str 인코딩할 문자열
 * @return UTF-8로 인코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function encodeUTF8(str) {
	var str = new String(str);
	str.replace(/\r\n/g, '\n');
	var ret = '';

	for (var n=0; n <str.length; n++) {
		var c = str.charCodeAt(n);

		if(c < 128) {
			ret += String.fromCharCode(c);
		} else if((c > 127) && (c < 2048)) {
			ret += String.fromCharCode((c >> 6) | 192);
			ret += String.fromCharCode((c & 63) | 128);
		} else {
			ret += String.fromCharCode((c >> 12) | 224);
			ret += String.fromCharCode(((c >> 6) & 63) | 128);
			ret += String.fromCharCode((c & 63) | 128);
		}
	}
	return ret;
}

/**
 * UTF-8로 인코딩된 문자열을 한글로 디코딩한다.
 * java.net.URLDecoder.decode(String, "UTF-8"), ie6.0이상(js1.5)에서의 decodeURIComponent(String)과 같은 함수
 * @public
 * @param {String} str 디코딩할 문자열
 * @return 디코딩된 한글 값
 * @type String
 * @author OFFTON
 */
function decodeUTF8(str) {
	var str = new String(str);
	var ret = '';
	var i = 0;
	var c = c1 = c2 = 0;

	while(i < str.length) {
		c = str.charCodeAt(i);

		if(c < 128) {
			ret += String.fromCharCode(c);
			i++;
		} else if((c > 191) && (c < 224)) {
			c2 = str.charCodeAt(i+1);
			ret += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
			i += 2;
		} else {
			c2 = str.charCodeAt(i+1);
			c3 = str.charCodeAt(i+2);
			ret += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
			i += 3;
		}
	}
	return ret;
}

/**
 * 해당 엘리먼트가 Int 타입인지 체크한다.
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {String} notify 엘리먼트 설명
 * @return Int 타입인 경우 true, 그렇지 않은 경우 false
 * @type Boolean
 * @author OFFTON
 */
function integerCheck(elem, notify) {
	var inputValue = elem.value.deComma();
	if (!inputValue.isEmpty()) {
		if (!inputValue.isInteger()) {
			alert(notify + ' 정수로 기입하여 주십시오!');
			focusSelect(elem);
			return false;
		}
	}
	return true;
}


/**
 * 해당 엘리먼트의 null과 Int 타입 유무를 체크
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {String} notify 엘리먼트 설명
 * @return Int 타입인 경우 true, null이거나 Int 타입이 아닌 경우 false
 * @type Boolean
 * @author OFFTON
 */
function integerRequisite(elem, notify) {
	if (!notNullCheck(elem, notify)) {
		return false;
	}
	return integerCheck(elem, notify);
}

/**
 * 해당 엘리먼트가 Int 타입인지 체크하고 유효하지 않으면 포커스를 이동한다.
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {String} notify 엘리먼트 설명
 * @return Int 타입인 경우 true, 그렇지 않은 경우 false
 * @type Boolean
 * @author OFFTON
 */
function integerCheckAndFocus(elem, notify) {
	var inputValue = elem.value.deComma();
	if (!inputValue.isEmpty()) {
		if (!inputValue.isInteger()) {
			alert(notify + ' 정수로 기입하여 주십시오!');
			focusSelect(elem);
			return false;
		}
	}
	return true;
}

/**
 * 해당 엘리먼트가 양의 정수 인지 체크
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {String} notify 엘리먼트 설명
 * @return 양의 정수인 경우 true, 그렇지 않은 경우 false
 * @type Boolean
 * @author OFFTON
 */
function positiveIntegerCheck(elem, notify) {
	var inputValue = elem.value.deComma();
	if (!inputValue.isEmpty()) {
		if (!inputValue.isPositiveInteger()) {
			alert(notify + ' 양의 정수로 기입하여 주십시오!');
			focusSelect(elem);
			return false;
		}
	}
	return true;
}

/**
 * 해당 엘리먼트의 null과 양의 정수 유무 체크
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {String} notify 엘리먼트 설명
 * @return 양의 정수인 경우 true, 그렇지 않은 경우 false
 * @type Boolean
 * @author OFFTON
 */
function positiveIntegerRequisite(elem, notify) {
	if (!notNullCheck(elem,notify)) {
		return false;
	}
	return positiveIntegerCheck(elem,notify);
}

/**
 * 해당 엘리먼트가 0보다 크거나 같은 정수인지 체크
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {String} notify 엘리먼트 설명
 * @return 0보다 크거나 같은 정수인 경우 true, 그렇지 않은 경우 false
 * @type Boolean
 * @author OFFTON
 */
function nonNegativeIntegerCheck(elem, notify) {
	var inputValue = elem.value.deComma();
	if (!inputValue.isNonNegativeInteger()) {
		alert(notify + ' 0또는 0보다 큰 정수로 기입하여 주십시오!');
		focusSelect(elem);
		return false;
	}
	return true;
}

/**
 * 해당 엘리먼트가 null이 아니거나 0보다 크거나 같은 정수인지 체크
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {String} notify 엘리먼트 설명
 * @return 0보다 크거나 같은 정수인 경우 true, 그렇지 않은 경우 false
 * @type Boolean
 * @author OFFTON
 */
function nonNegativeIntegerRequisite(elem,notify) {
	if(!notNullCheck(elem,notify)) {
		return false;
	}
	return nonNegativeIntegerCheck(elem,notify);
}

/**
 * 입력된 float형 숫자값이 지정된 범위에 포함되는 값인지 체크
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {Float} lowerlimit 최소값 제한
 * @param {Float} upperlimit 최대값 제한
 * @param {String} notify 엘리먼트 설명
 * @return 지정된 범위에 포함되는 값일 경우  true, 입력값이 공백이거나 지정된 범위를 벗어나는 값이면 false
 * @type Boolean
 * @author OFFTON
 */
function floatCheck(elem, lowerlimit, upperlimit, notify) {
	var inputValue = elem.value.deComma();
	if (!inputValue.isEmpty()) {
		if (!inputValue.isFloat()) {
			alert(notify + ' 실수형으로 기입하여 주십시오!');
			return false;
		}

		var num = parseFloat(elem.value);
		if (num < lowerlimit || num >= upperlimit) {
			alert('(' + lowerlimit + ' <= ' + notify.substring(0,notify.length-1) + ' < ' + upperlimit + ')로 기입하여 주십시오!');
			return false;
		}
	}
	return true;
}

/**
 * 입력된 float형 숫자값이 지정된 범위에 포함되는 값인지 체크하고
 * 유효하지 않으면 포커스를 이동한다.
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {Float} lowerlimit 최소값 제한
 * @param {Float} upperlimit 최대값 제한
 * @param {String} notify 엘리먼트 설명
 * @return 지정된 범위에 포함되는 값일 경우  true, 입력값이 공백이거나 지정된 범위를 벗어나는 값이면 false
 * @type Boolean
 * @author OFFTON
 */
function floatCheckAndFocus(elem, lowerlimit, upperlimit, notify) {
	var inputValue = elem.value.deComma();
	if (!inputValue.isEmpty()) {
		if (!inputValue.isFloat()) {
			alert(notify + ' 실수형으로 기입하여 주십시오!');
			focusSelect(elem);
			return false;
		}

		var num = parseFloat(elem.value);
		if (num < lowerlimit || num >= upperlimit) {
			alert('(' + lowerlimit + ' <= ' + notify.substring(0,notify.length-1) + ' < ' + upperlimit + ')로 기입하여 주십시오!');
			focusSelect(elem);
			return false;
		}
	}
	return true;
}

/**
 * 입력된 float형 숫자값이 null이 아니거나 지정된 범위에 포함되는 값인지 체크
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {Float} lowerlimit 최소값 제한
 * @param {Float} upperlimit 최대값 제한
 * @param {String} notify 엘리먼트 설명
 * @return 지정된 범위에 포함되는 값일 경우  true, 입력값이 공백이거나 지정된 범위를 벗어나는 값이면 false
 * @type Boolean
 * @author OFFTON
 */
function floatRequisite(elem, lowerlimit, upperlimit, notify) {
	if(!notNullCheck(elem, notify)) {
		return false;
	}
	return floatCheckAndFocus(elem, lowerlimit, upperlimit, notify);
}

/**
 * 입력값을 3자리 마다 콤마가 붙는 문자열로 변경
 * @public
 * @param {Object} elem 변경할 엘리먼트
 * @return 3자리 마다 콤마가 붙는 문자열
 * @type String
 * @author OFFTON
 */
function toComma(elem) {
	if (nonNegativeIntegerCheck(elem, '')) {
		elem.value = elem.value.toComma();
	}
}

/**
 * 문자열에서 콤마를 제거한다.
 * @public
 * @param {Object} elem 변경할 엘리먼트
 * @return 콤마가 제거된 문자열
 * @type String
 * @author OFFTON
 */
function deComma(elem) {
	elem.value = elem.value.deComma();
}

/**
 * 키 입력을 정수 또는 실수 숫자로 제한한다.
 * @public
 * @param {Object} elem 체크할 엘리먼트
 * @param {Number} len 소수점 이하 자리수
 * @param {Boolean} useNegative 부호 허용 여부. true:음수 사용, false:비 사용
 * @author OFFTON
 */
function numberFieldCheck(elem, len, useNegative) {
	if (event == null) {
		return;
	}

	var numberValue = elem.value;
	var keyChar		= String.fromCharCode(event.keyCode);

	if (len == null) {
		len = 0;
	}

	// - 부호 입력 구분
	if (useNegative == null) {
		useNegative = false;
	}

	// 숫자와 ENTER 키일 경우에는 입력을 받는다.
	if ( event.keyCode == 0x0D || (keyChar >= '0' && keyChar <= '9') ) {

		//자리수 체크
		if (len > 0) {
			var idx = numberValue.indexOf('.');

			if (idx == -1) {
				return;
			} else {
				var lastStr = numberValue.substring(idx+1, idx.length);
				if (lastStr.length < len) {
					return;
				}
			}
		} else {
			return;
		}
	}

	switch (len) {
		// 정수입력이면
		case 0:
			if(useNegative)	{// -허용
				if ( keyChar == '-' && !isContain(numberValue, keyChar) ) return;
			}
			break;
		// 실수입력이면
		default:
			if(!useNegative) {// - 비허용
				if ( keyChar == '.' && !isContain(numberValue, keyChar) ) return;
				break;
			}
			else {	// -허용
				if ( (keyChar == '.' || keyChar == "-") && !isContain(numberValue, keyChar) ) return;
				break;
			}
	}

	// IE로 이벤트를 보내지 않는다.
	event.keyCode = 0x00;
	event.returnValue = false;
}

/**
 * 문자열에 특정 문자가 포함되어 있는지 체크하여 결과를 반환한다.
 * @public
 * @param {String} 체크할 문자열
 * @param {Char} 문자
 * @return 문자열에 문자가 포함되어 있으면 true를 반환하고, 그렇지 않으면 false를 반환한다.
 * @type Boolean
 * @author OFFTON
 */
function isContain(str, ch) {
	var length = str.length;

	for (var index=0 ; index < length ; index++) {
		if (str.charAt(index) == ch) {
			return true;
		}
	}
	return false;
}

/**
 * 행의 디자인 클래스가 변경된 테이블의 엘리먼트
 * @public
 * @author OFFTON
 */
var __HIGHLIGHTED_TABLE_ELEM;

/**
 * 선택한 하위메뉴의 키 값을 보존하고 선택한 행의 디자인 클래스를 변경한다.
 * 반드시 document 객체가 selSubItemFm폼을 가지고 있어야 한다.
 *   &lt;form name="selSubItemFm" method="post"&gt;
 *	   &lt;input type="hidden" name="code"/&gt;
 *	   &lt;input type="hidden" name="idx"/&gt;
 *   &lt;/form>
 * @public
 * @param {Object} elem TR요소(Element)
 * @author OFFTON
 */
function highlightRow(elem) {
	__HIGHLIGHTED_TABLE_ELEM = elem.parentNode;
	if (!(document.selSubItemFm.idx.value == null || document.selSubItemFm.idx.value == '')) {
		var cnt = elem.parentNode.rows[document.selSubItemFm.idx.value].childNodes.length;
		for (var i = 0; i < cnt; i++) {
			var curClassName = elem.parentNode.rows[document.selSubItemFm.idx.value].childNodes[i].className;

			if (curClassName == 'bg1_selected') {
				elem.parentNode.rows[document.selSubItemFm.idx.value].childNodes[i].className = 'bg1';
			} else if (curClassName == 'bg1_c_selected') {
				elem.parentNode.rows[document.selSubItemFm.idx.value].childNodes[i].className = 'bg1_c';
			} else if (curClassName == 'td_sel_l') {
				elem.parentNode.rows[document.selSubItemFm.idx.value].childNodes[i].className = 'td_white_l';
			} else {
				elem.parentNode.rows[document.selSubItemFm.idx.value].childNodes[i].className = 'td_white_r';
			}
		}
	}

	var cnt = elem.childNodes.length;
	for (var i = 0; i < cnt; i++) {
		var curClassName = elem.childNodes[i].className;

		if (curClassName == 'bg1') {
			elem.childNodes[i].className = 'bg1_selected';
		} else if (curClassName == 'bg1_c') {
			elem.childNodes[i].className = 'bg1_c_selected';
		} else if (curClassName == 'td_white_l') {
			elem.childNodes[i].className = 'td_sel_l';
		} else {
			elem.childNodes[i].className = 'td_sel_r';
		}
	}
	document.selSubItemFm.idx.value = elem.rowIndex;
}

/**
 * 선택된 행의 디자인 클래스를 제거한다.
 * @public
 * @author OFFTON
 */
function removeHighlight() {
	if (!(document.selSubItemFm.idx.value == null || document.selSubItemFm.idx.value == '')) {
		var cnt = __HIGHLIGHTED_TABLE_ELEM.rows[document.selSubItemFm.idx.value].childNodes.length;

		for (var i = 0; i < cnt; i++) {
			var curClassName = __HIGHLIGHTED_TABLE_ELEM.rows[document.selSubItemFm.idx.value].childNodes[i].className;
			if (curClassName == 'bg1_selected') {
				__HIGHLIGHTED_TABLE_ELEM.rows[document.selSubItemFm.idx.value].childNodes[i].className = 'bg1';
			} else if (curClassName == 'bg1_c_selected') {
				__HIGHLIGHTED_TABLE_ELEM.rows[document.selSubItemFm.idx.value].childNodes[i].className = 'bg1_c';
			} else if (curClassName == 'td_sel_l') {
				__HIGHLIGHTED_TABLE_ELEM.rows[document.selSubItemFm.idx.value].childNodes[i].className = 'td_white_l';
			} else {
				__HIGHLIGHTED_TABLE_ELEM.rows[document.selSubItemFm.idx.value].childNodes[i].className = 'td_white_r';
			}
		}
	}
	document.selSubItemFm.idx.value = '';
}

/**
 * 브라우저 별로 지원하는 AJAX 처리 오브젝트를 리턴한다.
 * @private
 * @return ajax 오브젝트
 * @type Object
 * @author OFFTON
 */
function createHttpRequest() {
	if (window.ActiveXObject) {
		try {
			// IE6
			return new ActiveXObject("Msxml2.XMLHTTP");
		} catch(e){
			try{
				// IE4, IE5
				return new ActiveXObject("Microsoft.XMLHTTP");
			}catch(e2){
				return null;
			}
		}
	} else if (window.XMLHttpRequest){
		// Mozilla, FireFox, Opera, Safari, Konqueror3
		return new XMLHttpRequest();
	} else {
		return null;
	}
}

/**
 * XMLHttpRequest 객체를 이용하여 서버에서 DB 조회 후 특정 리턴 타입으로 저장된 결과를 콜백 함수의 파라메터에 세팅한다.
 * @public
 * @param {String} rtnType 처리 후 리턴  타입('str': 문자열, 'json': JSON String, 'xml' : XML)
 * @param {String} callbackMethodName 처리 후 리턴 값을 넘겨줄 콜백 함수
 * @param {String} formNameOrParams 파라메터가 저장된 폼 이름 또는 쿼리스트링타입의 파라메터 문자열(code=00001&codeName=offton)
 * @param {String} queryName 조회할 쿼리 이름. 쿼리 폴더 하위 부터 기술. 예) samples/ajax/ajax_l01.sql
 * @param {boolean} isDebug 쿼리 파라메터 디버그 사용 유무. true:디버그, false:디버그안함
 * @author OFFTON
 */
function searchData(rtnType, callbackMethodName, formNameOrParams, sqlFileName, isDebug) {
	var result	= null;
	var request	= createHttpRequest();
	request.onreadystatechange = function(){
		if(request.readyState == 4){
			if (rtnType == 'str' || rtnType == 'json') {
				result = request.responseText;
			} else if (rtnType == 'xml') {
				result = request.responseXML;
			}
		}
	}

	/* 파라메터 세팅 */
	var params     = "";
	var queryParam = "";
	try {
		eval('document.'+formNameOrParams);
		queryParam = formDataToParamType(formNameOrParams);
	} catch(e) {
		queryParam = formNameOrParams;
	}
	params = "__RTNTYPE=" + rtnType + "&__SQLFILENAME=" + sqlFileName + "&" + queryParam;

	if (isDebug != null && isDebug == true) {
		alert(params);
	}

	request.open('POST', '/XMLHttpServlet.do', false);
	request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset='utf-8'; ");
	request.setRequestHeader("Content-length", params.length);
	request.setRequestHeader("Connection", "close");
	request.send(params);

	switch (rtnType) {
		case 'str' :
			break;
		case 'json' :
			result = eval('(' + result + ')');
			break;
		case 'xml' :
			result = result.documentElement;
			break;
	}

	try {
		var cbFunc = eval(callbackMethodName);
		cbFunc(result);
	} catch(e) {
		alert(e);
		alert('콜백함수가 존재하지 않습니다.');
	}
}

/**
 * XMLHttpRequest 객체를 이용하여 서버에서 DB 조회 후 특정 리턴 타입으로 결과를 리턴한다.
 * @public
 * @param {String} rtnType 처리 후 리턴  타입('str': 문자열, 'json': JSON String, 'xml' : XML)
 * @param {String} formNameOrParams 파라메터가 저장된 폼 이름 또는 쿼리스트링타입의 파라메터 문자열(code=00001&codeName=offton)
 * @param {String} queryName 조회할 쿼리 이름. 쿼리 폴더 하위 부터 기술. 예) samples/ajax/ajax_l01.sql
 * @param {boolean} isDebug 쿼리 파라메터 디버그 사용 유무. true:디버그, false:디버그안함
 * @author OFFTON
 */
function getSearchData(rtnType, formNameOrParams, sqlFileName, isDebug) {
	var result	= null;
	var request	= createHttpRequest();
	request.onreadystatechange = function(){
		if(request.readyState == 4){
			if (rtnType == 'str' || rtnType == 'json') {
				result = request.responseText;
			} else if (rtnType == 'xml') {
				result = request.responseXML;
			}
		}
	}

	/* 파라메터 세팅 */
	var params     = "";
	var queryParam = "";
	try {
		eval('document.'+formNameOrParams);
		queryParam = formDataToParamType(formNameOrParams);
	} catch(e) {
		queryParam = formNameOrParams;
	}
	params = "__RTNTYPE=" + rtnType + "&__SQLFILENAME=" + sqlFileName + "&" + queryParam;

	if (isDebug != null && isDebug == true) {
		alert(params);
	}

	request.open('POST', '/XMLHttpServlet.do', false);
	request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset='utf-8'; ");
	request.setRequestHeader("Content-length", params.length);
	request.setRequestHeader("Connection", "close");
	request.send(params);

	switch (rtnType) {
		case 'str' :
			break;
		case 'json' :
			result = eval('(' + result + ')');
			break;
		case 'xml' :
			result = result.documentElement;
			break;
	}
	
	return result;
}

/**
 * IFRAME을 이용하여 서버에서 DB 조회 후 특정 리턴 타입으로 결과를 리턴한다.
 * @public
 * @param {String} rtnType 처리 후 리턴  타입('str': 문자열, 'json': JSON String, 'xml' : XML)
 * @param {String} callbackMethodName 처리 후 리턴 값을 넘겨줄 콜백 함수
 * @param {String} formNameOrParams 파라메터가 저장된 폼 이름 또는 쿼리스트링타입의 파라메터 문자열(code=00001&codeName=offton)
 * @param {String} queryName 조회할 쿼리 이름. 쿼리 폴더 하위 부터 기술. 예) samples/ajax/ajax_l01.sql
 * @param {boolean} isDebug 쿼리 파라메터 디버그 사용 유무. true:디버그, false:디버그안함
 * @author OFFTON
 */
function searchDataUseIFrame(rtnType, callbackMethodName, formNameOrParams, sqlFileName, isDebug) {
	/* search iframe set */
	var searchFrame 	= document.getElementById("__SEARCH_IFRAME");
	var searchFrameFile	= "/common/ajax/ajaxProcess.jsp";
	if (searchFrame == null) {

		try {
			searchFrame		 = document.createElement("<iframe id=\"__SEARCH_IFRAME\" name=\"__SEARCH_IFRAME\"></iframe>");
		} catch(e) {
			searchFrame		 = document.createElement('iframe');
			searchFrame.id	 = "__SEARCH_IFRAME";
			searchFrame.name = "__SEARCH_IFRAME";
		}
		searchFrame.src				= "";
		searchFrame.scrolling		= "no";
		searchFrame.frameborder		= "0";
		searchFrame.align			= "left";
		searchFrame.style.width		= '0';
		searchFrame.style.height	= '0';
		document.body.appendChild(searchFrame);
	}

	/* parameter set */
	var params     = "";
	var queryParam = "";
	try {
		eval('document.'+formNameOrParams);
		queryParam = formDataToParamType(formNameOrParams);
	} catch(e) {
		queryParam = formNameOrParams;
	}
	params = "__RTNTYPE=" + rtnType
						+ "&__SQLFILENAME=" + sqlFileName
						+ "&__CALLBACK=" + callbackMethodName
						+ "&" + queryParam;

	if (isDebug != null && isDebug == true) {
		alert(params);
	}

	/* call process page */
	searchFrame.src = searchFrameFile + "?" + params;
}

/**
 * 폼에 입력된 모든 엘리먼트와 값을 GET 방식으로 특정 페이지에 전달할 파라메터 문자열 형식으로 리턴한다.
 * @public
 * @param {String} formName 파라메터가 저장된 폼 이름
 * @return 파라메터 문자열
 * @type String
 * @author OFFTON
 */
function formDataToParamType(formName) {
	var sourceForm = eval("document." + formName);
	var elemArray  = sourceForm.elements;
	var paramStr   = "";
	var index	   = 0;

	for (var i=0; i<elemArray.length; i++) {
		if (index != 0) {
			paramStr += "&";
		}

		var paramType  = elemArray[i].type;
		var paramKey   = elemArray[i].name;
		var paramValue = elemArray[i].value;

		if (paramType != "button" && paramType != "submit" && paramType != "reset") {
			if (paramType == "radio" || paramType == "checkbox" ) {
				if (elemArray[i].checked) {
					paramStr += paramKey + "=";
					paramStr += paramValue;
					index ++;
				}
			} else {
				paramStr += paramKey + "=";
				paramStr += paramValue;
				index ++;
			}
		}
	}

	return paramStr;
}

/**
 * 폼에 입력된 모든 엘리먼트와 값을 JSON Object에 담아 리턴한다.
 * @public
 * @param {String} formName 파라메터가 저장된 폼 이름
 * @return 폼 입력 값
 * @type Json Object
 * @author OFFTON
 */
function formDataToJson(formName) {
	var sourceForm = eval("document." + formName);
	var elemArray  = sourceForm.elements;
	var jsonStr	   = "";
	var keysStr    = "";

	var keyArray = new Array();
	var keyTable = new Object();

	/* insert form elements */
	for (var i=0; i<elemArray.length; i++) {
		var paramType  = elemArray[i].type;
		var paramKey   = elemArray[i].name;
		var paramValue = elemArray[i].value;

		if (paramType != "button" && paramType != "submit" && paramType != "reset") {
			if (paramType == "radio" || paramType == "checkbox" ) {
				if (!elemArray[i].checked) {
					continue;
				}
			}

			/* data set */
			if (keyTable[paramKey] == undefined) {
				keyArray.push(paramKey);
				keyTable[paramKey] = new Array();
			}

			/* select multiple process */
			if (paramType == "select-multiple") {
				for (var k = 0; k < elemArray[i].options.length; k++) {
					if (elemArray[i].options[k].selected && elemArray[i].options[k].value != "") {
						keyTable[paramKey].push(elemArray[i].options[k].value);
					}
				}
				continue;
			}

			keyTable[paramKey].push(paramValue);
		}
	}

	/* create json string */
	for (var i = 0; i < keyArray.length; i++) {
		if (i != 0) {
			keysStr += ",";
			jsonStr += ",";
		}

		var keyName = keyArray[i];
		jsonStr += "\"" + keyName + "\":[";
		for (var j = 0; j < keyTable[keyName].length; j++ ) {
			if (j != 0) {
				jsonStr += ",";
			}
			jsonStr += "\"" + keyTable[keyName][j] + "\"";
		}
		jsonStr += "]";
		keysStr += "\"" + keyName+ "\"";
	}

	return eval('({' + "\"__KEYS\":[" + keysStr + "]," + jsonStr + '})');
}

/**
 * 문자열 형식의 데이터를 JSON Object로 변환한다.
 *
 * 입력 문자열> code|codeName, 00001|옵톤, 00002|offton
 * ===============================
 * code			codeName
 * -------------------------------
 * 00001		옵톤
 * 00002		offton
 *
 * @public
 * @param {String} str JSON Object를 만들 값이 조합된 문자열
 * @return 폼 입력 값
 * @type Json Object
 * @author OFFTON
 */
function stringToJson(str) {
	var dataArray = str.split(",");
	var jsonStr	  = "";
	var keysStr   = "";

	if (dataArray.length < 1) {
		return eval('({})');
	} else {
		/* get keys */
		var keyArray   = dataArray[0].split("|");
		var valueArray = new Array();


		if (keyArray.length < 1) {
			return eval('({})');
		}

		/* get values */
		for (var i=1; i<dataArray.length; i++) {
			var values = dataArray[i].split("|");
			for (var j=0; j<values.length; j++) {
				if (i == 1) {
					valueArray[j] = new Array();
				}
				valueArray[j][i-1] = values[j];
			}
		}

		/* create json string */
		for (var i=0; i<keyArray.length; i++) {
			if (i !=0 ) {
				jsonStr += ",";
				keysStr += ",";
			}
			jsonStr += "\"" + keyArray[i] + "\":[";
			for (var j=0; j<dataArray.length-1; j++) {
				if (j != 0) {
					jsonStr += ",";
				}
				jsonStr += "\"" + valueArray[i][j] + "\"";
			}
			jsonStr += "]";
			keysStr += "\"" + keyArray[i] + "\"";
		}
		return eval('({' + "\"__KEYS\":[" + keysStr + "]," + jsonStr + '})');
	}
}

/**
 * 플래시를 문서에 출력한다.
 * @public
 * @param {String} file 		SWF file saved url	(ex:	/STRATA/_chart/column2D.swf				)
 * @param {String} width 		flash width size	(ex:	800										)
 * @param {String} height 		flash height size	(ex:	600										)
 * @param {String} flashId 		flash unique id		(ex:	COLUMN2D								)
 * @param {String} bgColor 		background color	(ex:	FFFFFF									)
 * @param {String} params 		parameters			(ex:	parameter								)
 * @param {String} winMode 		window mode			(ex:	transparent								)
 * @type String
 * @author OFFTON
 */
function writeFlash(file, width, height, flashId, bgColor, params, winMode) {
	var oHtmlText = getWriteFlashHTML(file, width, height, flashId, bgColor, params, winMode);
	this.document.write(oHtmlText);
}

/**
 * 레이어에 플래시를 출력한다.
 * @public
 * @param {String} file 		SWF file saved url	(ex:	/STRATA/_chart/column2D.swf				)
 * @param {String} width 		flash width size	(ex:	800										)
 * @param {String} height 		flash height size	(ex:	600										)
 * @param {String} flashId 		flash unique id		(ex:	COLUMN2D								)
 * @param {String} bgColor 		background color	(ex:	FFFFFF									)
 * @param {String} params 		parameters			(ex:	parameter								)
 * @param {String} winMode 		window mode			(ex:	transparent								)
 * @param {String} divId 		레이어 아이디		(ex:	flashDiv								)
 * @type String
 * @author OFFTON
 */
function writeFlashToDiv(file, width, height, flashId, bgColor, params, winMode, divId) {
	var oHtmlText = getWriteFlashHTML(file, width, height, flashId, bgColor, params, winMode);
	document.getElementById(divId).innerHTML = oHtmlText;
}

/**
 * 플래시 코드를 리턴
 * @public
 * @param {String} file 		SWF file saved url	(ex:	/STRATA/_chart/column2D.swf				)
 * @param {String} width 		flash width size	(ex:	800										)
 * @param {String} height 		flash height size	(ex:	600										)
 * @param {String} flashId 		flash unique id		(ex:	COLUMN2D								)
 * @param {String} bgColor 		background color	(ex:	FFFFFF									)
 * @param {String} params 		parameters			(ex:	parameter								)
 * @param {String} winMode 		window mode			(ex:	transparent								)
 * @return chart object html code
 * @type String
 * @author OFFTON
 */
function getWriteFlashHTML(file, width, height, flashId, bgColor, params, winMode) {
	var oHtmlText;
	var menu = false;
	oHtmlText =
			"<object classid='clsid:d27cdb6e-ae6d-11cf-96b8-444553540000'\n" +
			"        codebase='http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=8,0,0,0'\n" +
			"        width='" + width + "' height='" + height + "' id='" + flashId + "' align='middle'>\n" +
			"    <param name='allowScriptAccess' value='always' />\n" +
			"    <param name='movie' value='" + file + "' />\n" +
			"    <param name='FlashVars' value='" + params + "' />\n" +
			"    <param name='wmode' value='" + winMode + "' />\n" +
			"    <param name='menu' value='"+menu+"' />\n" +
			"    <param name='quality' value='high' />\n" +
			"    <param name='bgcolor' value='" + bgColor + "' />\n" +
			"    <param name='name' value='" + flashId + "' />\n" +
			"    <embed src='" + file + "' FlashVars='" + params + "' wmode='" + winMode + "' menu='"+menu+"'\n" +
			"            quality='high' bgcolor='" + bgColor + "' width='" + width + "' height='" + height + "'\n" +
			"            name='" + flashId + "' align='middle' allowScriptAccess='always' type='application/x-shockwave-flash'\n" +
			"            pluginspage='http://www.macromedia.com/go/getflashplayer' />\n" +
			"</object>\n";

	return oHtmlText;
}

/**
 * checkbox의 전체 선택 및 선택해제를 처리하는 메소드이다.
 * @public
 * @param {String} chkAllId 테이블 헤더 부분에 존재하는 선택/해제 checkbox의 ID
 * @param {String} checkboxName 테이블의 몸체에 존재하는 checkbox의 ID
 * @author OFFTON
 */
function checkAllProcess(chkAllId, checkboxName){
	var chkElems   = document.getElementsByName(checkboxName);
	var chkAllElem = document.getElementById(chkAllId);

	chkAllElem.onclick = function(){
		for(var i=0; i<chkElems.length; i++) {
			chkElems[i].checked = chkAllElem.checked ? true : false;
			//selectRow(chkElems[i]);
		}
	}
}

/**
 * 체크박스 선택 유무에 따라 선택된 행의 디자인 클래스를 변경한다.
 * @public
 * @param {Object} chkElem 선택한 행의 체크박스 엘리먼트
 * @author OFFTON
 */
function selectRow(chkElem) {
	var trElem		= chkElem.parentNode.parentNode;
	var isSelected	= chkElem.checked;
	var tdElems		= trElem.getElementsByTagName('td');

	for (var i = 0; i < tdElems.length; i++) {
		var curClassName = tdElems[i].className;

		if (isSelected) {
			if (curClassName == 'bg1') {
				tdElems[i].className = 'bg1_selected';
			} else if (curClassName == 'bg1_c') {
				tdElems[i].className = 'bg1_c_selected';
			} else if (curClassName == 'td_white_l') {
				tdElems[i].className = 'td_sel_l';
			}

		} else {
			if (curClassName == 'bg1_selected') {
				tdElems[i].className = 'bg1';
			} else if (curClassName == 'bg1_c_selected') {
				tdElems[i].className = 'bg1_c';
			} else if (curClassName == 'td_sel_l') {
				tdElems[i].className = 'td_white_l';
			}
		}
	}
}

/**
 * 트랜젝션 동작 상태 progress바를 출력한다.
 * @public
 * @param {String} isDone true : 작업 완료 상태, false : 작업 중 상태 
 * @author OFFTON
 */
function progress(isDone) {
	var progressDiv  = null;
	var loadingMsg	 = "";
	
	try {
		progressDiv = document.getElementById("__PROGRESS_DIV");
	} catch (e) {
	}
	
	if (progressDiv == null) {
		progressDiv = document.body.appendChild(document.createElement("DIV"));
		loadingMsg  = getWriteFlashHTML('/common/msg/msg_loading.swf','180', '100','waitMsg','#ffffff','','transparent');
		var widSize	= document.body.clientWidth;
		var heiSzie	= document.body.clientHeight;
		
		//loadingMsg= '<img src="/_img/progress/progress_large.gif" border="0">';
		
		progressDiv.innerHTML = '<table width="100%" height="100%" align="center" border="0">'
								+ '<tr><td align="center">'+ loadingMsg +'</td></tr>'
								+ '</table>';
		progressDiv.id = '__PROGRESS_DIV';
		progressDiv.style.position = 'absolute';
		progressDiv.style.left     = '0px';
		progressDiv.style.top      = '0px';
		progressDiv.style.width    = widSize;
		progressDiv.style.height   = heiSzie;
	}
	
	if (isDone) {
		progressDiv.style.display = 'none';
		document.body.style.overflow = 'auto';
	} else {
		progressDiv.style.display = 'inline';
		document.body.style.overflow = 'hidden';
	}
}

/**
 * 해당 폼내의 체크박스가 하나라도 선택되었는지 체크한다.
 * @public
 * @param {Object} formElem 체크박스가 포함된 Form(Element) 
 * @param {Object} chkBxElem 체크박스(Element)
 * @return {boolean} 선택유무. true:최소 한개가 선택됨, false:선택되지 않음
 * @author OFFTON
 */
function isSelectedItem(formElem, chkBxNm) {
	var fm = formElem;
	var chkCnt	 = 0;
	var chkElems = fm.getAttribute(chkBxNm);
	if (chkElems == null) {
		return false;
	} else if (chkElems.length == undefined) {
		if (chkElems.checked) {
			chkCnt++;
		}
	} else {
		for (var i=0; i < chkElems.length; i++) {
			if (chkElems[i].checked) {
				chkCnt++;
			}
		}
	}

	if (chkCnt == 0) {
		return false;
	} else {
		return true;
	}
}

/**
 * Mouse Over시 해당 Element의 디자인 클래스 변경
 * @public
 * @param {Object} elem CSS를 변경할 엘리먼트
 * @author OFFTON
 */
function msOverCss(elem) {
	if (elem.tagName == 'TR') {
		/* TR Element */
		for (var i = 0; i < elem.childNodes.length ;i++) {
			var tdElem = elem.childNodes[i];
			if (tdElem.tagName == 'TD') {
				tdElem.className = tdElem.className  + ' ' +'bg_over';
			}
		}
	}
}

/**
 * Mouse Out시 해당 Element의 디자인 클래스 변경
 * @public
 * @param {Object} elem CSS를 변경할 엘리먼트
 * @author OFFTON
 */
function msOutCss(elem) {
	if (elem.tagName == 'TR') {
		/* TR Element */
		for (var i = 0; i < elem.childNodes.length ;i++) {
			var tdElem = elem.childNodes[i];
			if (tdElem.tagName == 'TD') {
				tdElem.className = tdElem.className.replace(new RegExp('(^|\\s)' + 'bg_over' + '(?:\\s|$)'), '$1');
			}
		}
	}
}

/*
 * TABLE에서 선택된 ROW를 표시하고 다른 아이템 선택시 이전 선택된 아이템의 CSS를 변경하기 위해 선택된 엘리먼트 저장
 */
var __TR_SELECTED_ELEMENT = null;

/**
 * Mouse Click시 해당 Element의 디자인 클래스 변경
 * @public
 * @param {Object} elem CSS를 변경할 엘리먼트
 * @author OFFTON
 */
function msClickCss(elem) {
	if (elem == null || elem == undefined) {
		return false;
	}
	
	if (elem.tagName == 'TR') {
		var idTd = null;
		/* TR Element */
		
		/* 이전 선택된 ROW 스타일 변경 */
		try {
			if (__TR_SELECTED_ELEMENT != null) {
				for(var i = 0; i < __TR_SELECTED_ELEMENT.childNodes.length; i++) {
					idTd = __TR_SELECTED_ELEMENT.childNodes[i];
					if (idTd.tagName == 'TD') {
						idTd.className = idTd.className.replace(new RegExp('(^|\\s)' + 'bg_click' + '(?:\\s|$)'), '$1');
	                }
	            }
			}
		} catch (e) {
		}
		
		/* 현재 선택된 ROW 스타일 변경 */
		__TR_SELECTED_ELEMENT = elem;
		for(var j = 0; j< elem.childNodes.length; j++) {
			idTd = elem.childNodes[j];
			if (idTd.tagName == 'TD') {
				idTd.className = idTd.className  + ' ' +'bg_click';
			}
		}
	}
	return true;
}

/**
 * 웹브라우저의 정보를 Json Object 형태로 제공한다.
 * 
 * 사용법:
 *			var brInfo = getWebBrowseVersion();
 *			if (brInfo.name == 'explorer') {
 *				if (brInfo.version == '6.0') {
 *				
 *				} else if (brInfo.version == '6.0') {
 *
 *				}
 *			} else if (brInfo.name == 'Firefox') {
 *			}
 *
 * 
 * @public
 * @return {JosonObject} 웹브라우저 정보
 * @author OFFTON
 */
function getWebBrowseVersion() {
	var br_name		= '';
	var br_version	= '';
	var br_data 	= navigator.userAgent;
	var br_index	= null;
	var br_ver_nm	= null;

	if (navigator.appName == 'Microsoft Internet Explorer') {
		br_index 	= br_data.indexOf('MSIE');
		br_ver_nm	= br_data.substr(br_index, 8);
		
		br_name 		= 'explorer';
		br_version		= br_ver_nm.substr(5, 3);

	} else if (navigator.appName == 'Netscape') {
		if ((br_index = br_data.indexOf('Firefox')) > -1) {
			br_ver_nm  = br_data.substr(br_index, 13);
			br_name    = br_ver_nm.substr(0, 7);
			br_version = br_ver_nm.substr(8, 5);
		}
	}

	var brInfo = {
		"name" : br_name
	,	"version" : br_version
	}

	return brInfo;
}

/**
 * 다음 엘리먼트로 포커스 이동
 * @public
 * @param {Object} base CSS를 변경할 엘리먼트
 * @param {Object} attempt CSS를 변경할 엘리먼트
 * @author OFFTON
 */
function setFocusNext(base, attempt) {
	var tmp = 10;
	var maxAttempt = 0;
	var obj = base;

	if (attempt == null || Number(attempt) == 'NaN') maxAttempt = tmp;
	else if (Number(attempt) < 1 || Number(attempt) > tmp) maxAttempt = tmp;
	else maxAttempt = Number(attempt);

	for (var i=0; i<maxAttempt; i++) {
		try {
			if (obj.nextSibling == null) return;

			obj = obj.nextSibling;

			if (obj.nodeName == 'INPUT' || obj.nodeName == 'TEXTAREA') {
				obj.focus();
				return;
			}            
		} catch(e) {
			alert(e.message);
			continue;
		}
	}
}

/**
 * 콤보박스가 입력된 값을 선택하도록 처리한다.
 * @public
 * @param {Object} comboElem 콤보박스 엘리먼트
 * @param {String} selectValue 선택되로록 할 값
 * @author OFFTON
 */
function comboSelectValue(comboElem, selectValue) {
	for (var i = 0; i < comboElem.length; i++) {
		if (comboElem[i].value == selectValue) {
			comboElem[i].selected = true;
			return true;
		}
	}
}

/**
 * 문자열 byte 체크
 * @param elem  - 대상 문자열이 포함된 element
 * @param limit - 허용될 수 있는최대 byte
 */
function checkByte(elem, limit) {
	var codeByte  = 0;
	var overCount = 0;
	
	for(var i=0; i<elem.value.length; i++) {
		if(escape(elem.value.charAt(i)).length > 4)	codeByte += 2;
		else	codeByte++;
		
		if(codeByte > limit)	overCount++;
	}
	
	var browseInfo = getWebBrowseVersion();
	
	if(codeByte > limit) {
		alert('입력하신 내용의 길이가 너무 길어 마지막 입력하신'+overCount+'자 만큼 제거됩니다.');
		elem.focus();

		elem.value = elem.value.substring(0, elem.value.length - overCount);
		
		return false;
	}
}

/**
 * validate number
 * @param e - evnet
 * @param isDecimal
 * @param delim
 */
function fn_numbersOnly(e, isDecimal, delim) {
	var key;
	var keychar;

	if(window.event) {
		key = window.event.keyCode;
	}else {
		key = e.which;
	}

	keychar = String.fromCharCode(key);

	if(key == null || key == 0 || key == 8 || key == 9 || key == 13 || key == 27) {
		return true;
	}else if('0123456789'.indexOf(keychar) > -1) {		
		return true;
	}else if(isDecimal && keychar == delim) {		
		return true;
	}else {
		return false;
	}
}

/**
 * 이미지 원본보기 CONTROLLER
 * @param imgSrc
 * @return
 */
function fn_openImage(imgSrc) {
	var oriImage = new Image();
	oriImage.src = (imgSrc);

	//이미지의 사이즈정보를 위해 일정시간 간격 이후에 이미지 원본보기 함수호출 - 이미지 로딩시간에의해 정보를 얻지 못하는 경우 발생
	setTimeout(function() {
		fn_openImagePop(oriImage);
	}, 100);
}
/**
 * 이미지 원본보기
 * @param imgSrc
 * @return
 */
function fn_openImagePop(oriImage) {
	if(oriImage.complete) {
		var scrollbars = 'no';
		var imgWidth   = oriImage.width;
		var imgHeight  = oriImage.height;
				
		if(imgWidth > document.documentElement.scrollWidth - 10) {
			imgWidth   = document.documentElement.scrollWidth - 10;
			scrollbars = 'yes';
		}
		
		if(imgHeight > document.documentElement.scrollHeight - 30) {
			imgHeight  = document.documentElement.scrollHeight - 30;
			scrollbars = 'yes';
		}
		
		winOption = 'scrollbars='+scrollbars + ',resizable=yes,width='+imgWidth+'px,height='+imgHeight+'px,left=0px,top=0px';
		var popimg = window.open('/_inc/imgViewer.jsp?img_src='+oriImage.src, 'originalImagePop', winOption);
	}
}

/**
 * 우편번호 찾기
 * @return
 */
function fn_openZipcodePop() {
	window.open('/_inc/findZipcodePop.jsp', 'zipcodePop', 'width=500px, height=560px, resizable=no, status=no, scrollbars=yes, menubar=no');
}

/**
 * 제품분류코드 찾기 팝업창열기
 * @return
 */
function fn_openUnspscPop(val) {
	var win = window.open('/_inc/findUnspscPop.jsp?keyword='+val, 'unspscPop', 'width=500px, height=520px, resizable=no, status=no, scrollbars=yes, menubar=no');
}

/**
 * 추천부서 검색
 * @return
 */
function fn_openSBCPop(elemId) {
	var searchElem  = document.getElementById(elemId);
	var searchValue = ''; 
	
	if(searchElem) {
		searchValue = searchElem.value;
	}
	window.open('/_inc/findSBCPop.jsp?sbc_name='+searchValue, 'sbc_jisa', 'width=500px, height=560px, resizable=no, status=no, scrollbars=yes, menubar=no');
}

/**
 * 체크박스 전체선택/해제
 * @param isCheck     - main check element 의 check 상태
 * @param subElemName - 목록에 포함된 check element(sub) name
 * @return
 */
function fn_checkedProcess(isCheck, subElemName) {
	var subElem = document.getElementsByName(subElemName);

	for(var i=0; i<subElem.length; i++) {
		subElem[i].checked = isCheck;
	}
}

/**
 * header 통합검색 layer control
 * @return
 */
function fn_displaySearchLayer() {
	var searchLayer = document.getElementById('s_layer');
	var searchLabel = document.getElementById('s_lable');
	
	if(searchLayer.style.display == 'none') {
		searchLayer.style.display = 'block';
		searchLabel.className = searchLabel.className + ' on';
	}else {
		searchLayer.style.display = 'none';
		searchLabel.className = searchLabel.className.replace('on', '');
	}
}

/**
 * header 통합검색 layer control
 * @param categoryName
 * @return
 */
function fn_closeSearchLayer(categoryName) {
	searchLayer = document.getElementById('s_layer').style.display = 'none';
	document.getElementById('s_lable').innerHTML = categoryName;
}

/**
 * 전체메뉴 layer display control
 * @return
 */
function fn_displayMenuControl() {
	var menuContainer = document.getElementById('menuAllArea');
	
	menuContainer.style.display = menuContainer.style.display == 'none' ? 'block' : 'none';
}

/**
 * display rolling control
 * @param objId
 * @param sec1
 * @param sec2
 * @param speed
 * @param height
 * @return
 */
function scrolling(objId,sec1,sec2,speed,height){
    this.objId=objId;
    this.sec1=sec1;
    this.sec2=sec2;
    this.speed=speed;
    this.height=height;
    this.h=0;
    this.div=document.getElementById(this.objId);
    this.htmltxt=this.div.innerHTML;
    this.div.innerHTML=this.htmltxt+this.htmltxt;
    this.div.isover=false;
    this.div.onmouseover=function(){this.isover=true;};
    this.div.onmouseout=function(){this.isover=false;};
    var self=this;
    this.div.scrollTop=0;
    window.setTimeout(function(){self.play();},this.sec1);
}
scrolling.prototype={
    play:function(){
        var self=this;
        if(!this.div.isover){
            this.div.scrollTop+=this.speed;
            if(this.div.scrollTop>this.div.scrollHeight/2){
                this.div.scrollTop=0;
            }else{
                this.h+=this.speed;
                if(this.h>=this.height){
                    if(this.h>this.height|| this.div.scrollTop%this.height !=0){
                        this.div.scrollTop-=this.h%this.height;
                    }
                    this.h=0;
                    window.setTimeout(function(){self.play();},this.sec1);
                    return;
                }
            }
        }
        window.setTimeout(function(){self.play();},this.sec2);
    }
};

/**
 * 문자열의 position 에 해당하는 위치에 구분자 추가
 * 포지션은 delimiter 를 구분자로 추가 될 index 를 만든다(ex : 2010-10-10 -> delimeter : '-', position : '4-6') 
 * @param val
 * @param delimiter
 * @param position
 * @return
 */
function fn_appendDelimiter(val, delimiter, position) {
	var retStr     = '';
	var isComplete = true;
	
	var positionArr = position.split(delimiter);
	var oldIdx      = 0;
	
	for(var i=0; i<positionArr.length; i++) {
		if(!Number(positionArr[i])) {
			isComplete = false;
			break;
		}
		retStr += val.substring(oldIdx, positionArr[i]) + delimiter;
		oldIdx  = positionArr[i];
	}
	retStr += val.substring(oldIdx);
	
	if(isComplete) {
		return retStr;
	}else {
		alert('문자열 가공 실패');
		return val;
	}
}

/**
 * form의 action 및 target 재 지정 - form의 onsubmit eventhandler
 * @return
 */
function fn_searchList(form, action, target) {
	if(form.pg)	form.pg.value = ''; //페이지 파라메터 초기화
	
	form.action = action;
	form.target = target;
	
	return true;
}

/**
 * 이미지 리사이즈
 * @param maxWidth
 * @return
 */
function fn_imageResize(maxWidth) {
	var images = document.getElementsByTagName('img');
	
	for(var i=0; i<images.length; i++) {
		if(images[i].width > maxWidth) {
			images[i].width = maxWidth;
		}
	}
}

/**
 * 주소(URL)복사
 * @param url - 쿼리스트링이 포함된 URL
 * @return
 */
function fn_urlCopy(url) {
    var browseInfo  = getWebBrowseVersion();

    if(browseInfo.name.toLowerCase().indexOf('explor') > -1) { // IE
        window.clipboardData.setData('Text', url); 
        alert("게시글의 주소가 복사되었습니다.\n원하시는 곳에 Ctrl+v로 붙여넣기 해주세요."); 
    }else { // 기타 브라우저
    	var temp = prompt("Ctrl+C를 눌러 복사하시고,\n\n원하시는 곳에 Ctrl+V로 붙여넣기 해주세요. ", url);
    }
}

/**
 * 파라메터 obj를 기준으로 layer의 좌측 여백크기 리턴
 * @param obj
 * @return
 */
function fn_getObjectLeft(obj) {
	if (obj.offsetParent && obj.offsetParent.id == 'wrap') {
		return obj.offsetLeft;
	} else {
		return obj.offsetLeft + (obj.offsetParent ? fn_getObjectLeft(obj.offsetParent) : 0);
	}
}

/**
 * 파라메터 obj를 기준으로 layer의 위쪽 여백크기 리턴
 * @param obj
 * @return
 */
function fn_getObjectTop(obj) {
	if (obj.offsetParent && obj.offsetParent.id == 'wrap') {
		return obj.offsetTop;
	} else {		
		return obj.offsetTop + (obj.offsetParent ? fn_getObjectTop(obj.offsetParent) : 0);
	}
}

/**
 * 페이지 내의 단일 파일과 멀티파일업로드를 동시에 등록할 경우 단일 파일의 각 첨부파일의 최대 크기를 지정한다. 단위는 MB이다.
 * 멀티파일 업로드의 경우 fileControl.jsp 내에서 처리
 * @author Offton
 * @param maxSize
 * @param fileSavePath
 * @return void
 */
function setCurrentUploadEnv(maxSize, fileSavePath) {
	var request = createHttpRequest();
	var params	= 'maxSize=' + maxSize + '&fileSavePath=' + fileSavePath;

	request.open('POST', '/_inc/rp/fileUploadEnvSet.jsp', false);
	request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset='utf-8'; ");
	request.setRequestHeader("Content-length", params.length);
	request.setRequestHeader("Connection", "close");
	request.send(params);
}