YNU_JEUS/app_home/himed/xpapps/com/commonxp/xp/comm_utl.xjs

<?xml version="1.0" encoding="utf-8"?>
<Script type="xscript4.0"><![CDATA[/***************************************************************************************  
 * System Name		:	HIT
 * Job Name 		:	
 * File Name 		:	comm_utl.xjs
 * Creator 	    	:	임준호
 * Make Date 		:	2014-02-18
 *                                                                                        
 * Description  	:	                                                                   
 *--------------------------------------------------------------------------------------- 
 * Modify Date     	Modifier  	Modify Description                                     
 *--------------------------------------------------------------------------------------- 
 * 2014-02-18        HIT       
 *                                                                                        
 *--------------------------------------------------------------------------------------- 
 ****************************************************************************************/
 
//prototype_date
Date.prototype.getAddDate = utlf_getAddDate;
Date.prototype.getDateFormat = utlf_getDateFormat;
String.prototype.toDate	= utlf_toDate;
Date.prototype.getDayOfWeek	= utlf_getDayOfWeek;
Date.prototype.getMonthDay = utlf_getMonthDay;
Date.prototype.isLeapYear = utlf_isLeapYear;

//prototype_numeric
String.prototype.setAmountToKorean = utlf_setAmountToKorean;
String.prototype.isNumber = utlf_isNumber;
String.prototype.isFloat = utlf_isFloat;
String.prototype.getRound = utlf_getRound;
String.prototype.getTruncate = utlf_getTruncate;

//prototype_string
String.prototype.setReplaceWord	= utlf_setReplaceWord;
String.prototype.getByteLength = utlf_getByteLength;
String.prototype.isByteSize = utlf_isByteSize;
String.prototype.getTrim = utlf_getTrim;
String.prototype.getTrimLeft = utlf_getTrimLeft;
String.prototype.getTrimRight = utlf_getTrimRight;
String.prototype.getLeftPad = utlf_getLeftPad;
String.prototype.getRightPad = utlf_getRightPad;
String.prototype.getCarrigeReturnRemove = utlf_getCarrigeReturnRemove;
String.prototype.getByteString = utlf_getByteString;
String.prototype.getCarrigeReturnReplace = utlf_getCarrigeReturnReplace;
String.prototype.subString2 = utlf_subString2;

String.prototype.getRound_medirec = utlf_getRound_medirec;

/********************************************************************************************************************/
/************************* 문자열/숫자 관련 함수 *****************************************************************/
/********************************************************************************************************************/
//	utlf_args2Object	: "key1=value1 key2=value2" 형태의 문자열을 object literal형식으로 변환한다.
//  utlf_trim	: 입력받은 문자열의 공백을 제거한다.
//	utlf_lTrim	: 문자열의 좌측 공백을 제거
//	utlf_rTrim	: 문자열의 우측 공백을 제거
//	utlf_isNull	: NULL 여부 체크
//	utlf_right	: 문자열의 오른쪽 부분을 지정한 길이만큼 가져오는 함수.
//	utlf_rPad	: 입력된 sValue에 nLength 만큼 오른쪽에 Char를 채운다
//	utlf_lPad	: 입력된 sValue에 nLength 만큼 왼쪽에 Char를 채운다
//	utlf_getLengB	: 입력된 sValue에 byte를 리턴한다
//	utlf_getStringByte	: 입력된 sValue를 주어진 byte만큼 자른다.
//	utlf_transNullToEmpty	: NULL 일 경우 빈 값을 리턴한다.
//  utlf_transEmptyToNull : Empty  일 경우 Null을 리턴한다.(2014.12.02)
//	utlf_transNull	: NULL 일 경우 예약된값을 리턴한다.
//	utlf_transNullToChar	: NULL 일 경우 새로운 값을 리턴한다.
//	utlf_transNullToSpace	: NULL 일 경우 공백을 리턴한다.
//	utlf_mid	: 입력된 문자열에서 가운데 부분을 주어진 길이만큼 Return 한다
//	utlf_isDigit	: 숫자 정합성 체크
//	utlf_round	: 인자로 넘어온 숫자를 반올림 처리한다
//	utlf_setComma	: 숫자 세자리 단위로 ","를 집어넣는다.
//	utlf_pos	: 문자열의 위치를 대소문자 구별하여 찾는다
//	utlf_isNum	: 문자열이 숫자형식에 맞는지 여부 체크
//  utlf_getFormat	: 문자열을 특정 포맷으로 변환
//  utlf_isHangul :  데이터 한글인지 영문인지 구분해주는 함수
//	utlf_isAlphabet : 영문인지 확인
//	utlf_isSearchString	: 전체 문장에서 특정 문장이 있는지를 검사하는 함수
//	(prototype-String.setReplaceWord)utlf_setReplaceWord	: 문자열중의 특정 문자 또는 단어를 찾아 원하는 문자 또는 단어로 치환
//	(prototype-String.getByteLength)utlf_getByteLength	: 파라미터 값의 Byte 크기를 리턴
//	(prototype-String.isByteSize)utlf_isByteSize	: 문자열의 Byte 크기가 제한값을 벗어나는지 체크 (벗어나면 false 리턴)
//	utlf_getStringAsByte : 문자열을 원하는 바이트 크기로 만든다.
//	(prototype-String.getTrim)utlf_getTrim	: 문자열 앞뒤에있는 공백 제거
//	(prototype-String.getTrimLeft)utlf_getTrimLeft	: 문자열 앞에 있는 공백 제거
//	(prototype-String.getTrimRight)utlf_getTrimRight	: 문자열 뒤에 있는 공백 제거
//	(prototype-String.getLeftPad)utlf_getLeftPad	: 숫자 값에 원하는 길이만큼 '0'을 붙여 표현
//	(prototype-String.getRightPad)utlf_getRightPad	: 숫자 값에 원하는 길이만큼 뒤쪽에 ' '을 붙여 표현
//	utlf_getStringLength	: 문자열의 길이를 구한다.
//	(prototype-String.getCarrigeReturnRemove)utlf_getCarrigeReturnRemove	: CarrigeReturn을 없앤 문자열을 리턴한다.
//	utlf_getSearchStringRight	: 전체 문장에서 특정 문장을 뒤에서 부터 찾는 함수
//	(prototype-String.getByteString)utlf_getByteString	: 원하는 바이트만큼 문자열을 잘라옴. 만약 현재 문자열보다 자르고자 하는 바이트가 크면 현재 문자열 반환.
//	(prototype-String.getCarrigeReturnReplace)utlf_getCarrigeReturnReplace	: CarrigeReturn을 원하는 문자열로 반환한 다음  리턴한다.
//	(prototype-String.setAmountToKorean)utlf_setAmountToKorean	: 금액을 한글로 변환 (단위포함)
//	(prototype-String.isNumber)utlf_isNumber	: 저장된 값이 Number 형인지 점검
//	(prototype-String.isFloat)utlf_isFloat	: 저장된 값이 Float 형인지 점검
//	(prototype-String.getRound)utlf_getRound	: 저장된 값을 지정한 자리에서 올림/반올림/버림 처리
//	(prototype-String.getTruncate)utlf_getTruncate	: 소수점 버리고 정수형 String으로 생성 (음수인경우에도 마찬가지 음수표시는 유효)
//	utlf_getRandomNo	: 랜덤숫자 만들기
//  (삭제)utlf_isEmpty : 입력값이 null 또는 wihte space로만 이루어져 있으면 빈문자를 리턴하는 함수
//	utlf_setColumnTrimStr	: 문자열의 앞, 뒤 공백을 제거하여 지정된 dataset의 컬럼에 입력한다.
//	utlf_getObjFont : Font Object 생성 반환
//	utlf_getTextSize : 텍스트 길이 반환 px
//  utlf_setFormat : 입력 값에 format을 적용하여 리턴 (2015.01.19)
//  utlf_setAsterisk : 입력 값에 표시할 문자열의 길이 만큼만 보여주고 나머지는 *처리 해서 보여준다. (2015.11.23)

/********************************************************************************************************************/
/************************* 날짜 관련 함수 *************************************************************************/
/********************************************************************************************************************/
//	utlf_splitDateS	: yyyyMMdd형태의 날짜를 주어진 문자로 년,월,일을 구분하여 출력한다.
//	utlf_makeDateYmd	: 입력된 문자를 date로 변환.
//	utlf_makeDateS	: [yyyy][MM][dd] -> yyyyMMdd 형태의 문자열 날짜 출력
//	utlf_isLeap	: 윤년여부 확인
//	utlf_addDate	: 입력된 날자에 nOffset 으로 지정된 만큼의 일을 증감한다.
//	utlf_addMonth	: 입력된 날자에 nOffset 으로 지정된 만큼의 월을 증감한다.
//	utlf_lastDateNum	: 해당월의 마지막 날짜를 가져온다.
//	utlf_solar2Lunar	: 양력을 음력으로 변환해주는 함수 (처리가능 기간  1841 - 2043년)
//	utlf_lunar2Solar	: 음력을 양력으로 변환해주는 함수 (처리가능 기간  1841 - 2043년)
//	utlf_getHolidays	: 양력 nYear에 해당하는 년도의 법정 공휴일(양력) List 모두 구하기
//	(삭제)utlf_isValidDay	: 날짜 정합성 체크 - utlf_isValidDateTime로 대체
//	(삭제)utlf_isValidMonth	: 년월 정합성 체크 - utlf_isValidDateTime로 대체
//	utlf_getEpTime	: 사용시간 계산
//	utlf_getDay	: 입력된 날자로부터 요일을 구함
//	utlf_getDayKor	: 입력된 날자로부터 한글로 요일을 구함
//	utlf_diffDate	: 두 일자간의 차이 일수 계산
//	utlf_diffMonth	: 두 월간의 차이 월수 계산
//	utlf_getTimeInterval	: 두 시간의 차를 초단위로 반환
//	utlf_getLastMonth	: 한달전 날짜 구하는 함수
//	utlf_getFirstDate	: 현재월 1일 만들기
//	utlf_getLastDate	: 현재월 마지막일 만들기
//	utlf_getOneMonthAfter	: 한달후 날짜 구하는 함수
//	utlf_str2Date	: 문자를 Date형으로 변환
//	utlf_date2Str	: Date형을 문자로 변환
//	utlf_isValidDateTime	: 유효한 날짜, 시간 인지 점검
//	utlf_getDateTime	: 옵션에 따라 Date형을 DateTime형 String으로 변환
//	utlf_getRemoveFormatter	: YYYY/MM/DD or YYYY-MM-DD -> YYYYMMDD 로 변환
//	utlf_getDateInterval	: 두 일자사이의 차를 다양한 형태의 날짜 단위로 반환
//	utlf_getDayCountForMonth	: 해당년의 해당 월이 몇일인지를 반환
//	utlf_getNewDate	: 현재날짜 시간 서버시간으로 변경
//	utlf_getCurrentDate	: 현재 날짜 반환
//	utlf_getCurrentTime	: 현재 시간 반환
//	utlf_getCurrentDateTime	: 현재 날짜 시간 반환
//	utlf_getCurrentWeek	: 현재 요일 반환
//	urlf_getStrDate	: 스트링형태의 날짜데이터 반환
//	(prototype-String.toDate)		utlf_toDate	: 문자열 날짜를 Date로 반환
//	(prototype-Date.getAddDate)	utlf_getAddDate	: 특정일자의 상대일자(+/-)를 계산
//	(prototype-Date.getDateFormat)	utlf_getDateFormat	: Date type을 문자 포맷으로 바꾼다.
//	(prototype-Date.getDayOfWeek)	utlf_getDayOfWeek	: Kind에 해당하는 요일을 반환
//	(prototype-Date.getMonthDay)	utlf_getMonthDay	: 해당일의 마지막 일을 계산
//	(prototype-Date.isLeapYear)	utlf_isLeapYear	: 윤년인지 아닌지 점검
//	utlf_getYear	: 현재 년도 반환
//	utlf_getMonth	: 현재 월 반환
//	utlf_getDate	: 현재 일 반환

/********************************************************************************************************************/
/************************* 주민등록/사업자번호/법인번호/이메일주소 체크관련 함수 *****************************/
/********************************************************************************************************************/
//	utlf_getSex	: 주민번호로 성별을 Return 한다
//	utlf_isCompRegNo	: 사업자 등록번호 확인
//	utlf_isCorpRegNo	: 법인 등록번호 확인
//	utlf_isRsrNo	: 주민 등록번호 확인
//	utlf_isEmail	: Email 적합여부 확인
//	utlf_getBefo	: 주민번호 뒷 첫번째 자리로 년대를 return 한다.
//	utlf_getAge	: 법적연령-만나이를 구한다
//	utlf_getFullAge	: 현재일자를 기준으로 나이계산
//	utlf_isForegnResidentNo	: 외국인 주민등록번호에 대한 검증을 수행
//  (삭제)utlf_getGender	: 주민번호로 성별을 return 한다.



/********************************************************************************************************************/
/************************* 기타 ************************************************************************************/
/********************************************************************************************************************/
//	utlf_getRandomSubmitUUID	: uuid 생성
//	utlf_isTelephoneZoneNo	: 올바른 DDD번호인지 점검 (필요할까?)
//	utlf_transBase64ToImg	: base64로 인코딩된 이미지를 imageViewer에 출력
//	utlf_transBase64ToBin	: base64로 인코딩된 이미지를 binary로 변환 (신규 2014-05-13)
//	utlf_saveToImageBinary	: imageViewer의 이미지를 binary로 변환 (신규 2014-05-13)
//	utlf_transFileToImg	: 첨부파일(이미지)을 imageViewer에 출력 (신규 2014-05-08)
//	utlf_screenToImage	: 화면을 캡쳐한다. (2014-04-04)
//  utlf_installBarcodeFont : 바코드 폰트를 등록한다. (2015-07-23)
//  utlf_validMaskEditTime : MastEdit를 시간으로 사용할 경우, 부정확한 입력을 제한한다.(ontextchange함수에 사용) (2017-02-13)
//  utlf_validMaskEditDateTime : MastEdit를 일자 시간으로 사용할 경우, 부정확한 입력을 제한한다.(ontextchange함수에 사용) (2017-05-14)


/********************************************************************************************************************/
/************************* 문자열/숫자 관련 함수 *****************************************************************/
/********************************************************************************************************************/

/**********************************************************************************
 * 함수명		: utlf_args2Object
 * 설  명		: "key1=value1 key2=value2" 형태의 문자열을 object literal형식으로 변환한다.
 * argument		: sParam (원본 문자열)
 * return Type	: object
 * 작성자		: 임준호
**********************************************************************************/
function utlf_args2Object(sParam){
	var arrParam = sParam.split(" ");
	var objResult = new Array(arrParam.length);
	for(var i in arrParam){
		var key = arrParam[i].split("=")[0];
		var value = stripQuote(arrParam[i].split("=")[1]);
		objResult[i]={col: key, val: value};
	}
	return objResult;
}


 /**********************************************************************************
 * 함수명		: utlf_trim
 * 설  명		: 입력받은 문자열의 공백을 제거한다.
 * argument		: sValue 문자열 값
				 
 * return Type	: return 문자열
 * 작성자		: tobesoft
**********************************************************************************/
function utlf_trim(sValue)
{
	if (sValue == null) return "";
	if (new String(sValue).valueOf() == "undefined") return "";
	if (new String(sValue) == null) return "";
		
	var retVal = (new String(sValue)).replace(/^\s+|\s+$/g, '');

	return retVal;
}

/**********************************************************************************
 * 함수명		: utlf_lTrim
 * 설  명		: 문자열의 좌측 공백을 제거
 * argument		: sOrg (원본 문자열)
				 sTrim (치환대상 문자열)
 * return Type	: String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_lTrim(sOrg, sTrim)
{
	var chk, pos;

	if( utlf_isNull(sOrg) )		return "";
	if( utlf_isNull(sTrim) )	sTrim = " ";
	
	for( pos = 0 ; pos < sOrg.length ; pos+=sTrim.length )
	{
		if( sOrg.substr( pos, sTrim.length ) != sTrim )
			break;
	}
	
	return sOrg.substr(pos);
}

/**********************************************************************************
 * 함수명     : utlf_rTrim
 * 설명       : 문자열의 우측 공백을 제거
 * argument    : sOrg (원본 문자열)
				 sTrim (치환대상 문자열)
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_rTrim(sOrg, sTrim)
{
	var pos, nStart;

	if( utlf_isNull(sOrg) )		return "";
	if( utlf_isNull(sTrim) )		sTrim = " ";
		
	for( pos = sOrg.length-sTrim.length ; pos >= 0 ; pos -= sTrim.length )
	{
		if( sOrg.substr( pos, sTrim.length ) != sTrim )
			break;
	}

	return sOrg.substr(0, pos+sTrim.length);
}

/**********************************************************************************
 * 함수명     : utlf_isNull
 * 설명       : NULL 여부 체크
 * argument    : sValue (문자열)
 * return Type : boolean
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_isNull(sValue)
{
    if( ("x"+sValue == "xNaN") && ( new String(sValue.length).valueOf() == "undefined")) return true;
    
    if (sValue == null) return true;
    
    var v_ChkStr = new String(sValue);

    if (v_ChkStr == null) return true;

    if (v_ChkStr.toString().length == 0 ) return true;

    return false;
}

/*********************************************************************
 * 함 수 명	: utlf_setQuote
 * 설명			: Argument 전송된 각 Data 값에 Quote(') 를 붙여준다.
 * argument		: 문자열 
 * return Type	: String
 * 작성자		: 임준호
 ********************************************************************
function utlf_setQuote(sStr) 
{
    if (utlf_isNull(sStr))
    {
		argString = "";
    }

    var strVal = new String(sStr);
    var strRet = new String("'");

    for (var i = 0; i < strVal.length; i++) 
    {
        if (strVal.substr(i, 1) == "'") 
        {
            strRet += '"';
        } else if (strVal.substr(i, 1) == '"') {
            strRet += '"';
        } else {
            strRet += strVal.substr(i, 1);
        }
    }
    
    strRet += "'";
    return strRet;
}*/


/**********************************************************************************
 * 함수명     : utlf_right
 * 설명       : 문자열의 오른쪽 부분을 지정한 길이만큼 가져오는 함수
 * argument    : sOrg (원본 문자열)
				 nSize (얻어올 크기)
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_right(sOrg, nSize)
{
	if( utlf_isNull(sOrg) || utlf_isNull(nSize) )		return "";
	
	if( sOrg.length < nSize )
		return sOrg;
	else
		return sOrg.substr(sOrg.length-nSize, nSize);
}

/**********************************************************************************
 * 함수명     : utlf_rPad
 * 설명       : 입력된 sValue에 nLength 만큼 오른쪽에 Char를 채운다.
 * argument    : sValue (문자열)
				 nLength (자리수)
				 Char (문자)
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_rPad(sValue, nLength, Char) {

    if (new String(sValue).valueOf() == "undefined") sValue = "";
    if (utlf_isNull(sValue)) sValue = "";

    var strRetVal = new String(sValue);
    var nIteration = nLength - utlf_getLengB(strRetVal);

    for (var i = 0; i < nIteration; i++) {
        strRetVal = strRetVal + Char;
    }
    return strRetVal;
}

/**********************************************************************************
 * 함수명     : utlf_lPad
 * 설명       : 입력된 sValue에 nLength 만큼 왼쪽에 Char를 채운다.
 * argument    : sValue (문자열)
				 nLength (자리수)
				 Char (문자)
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_lPad(sValue, nLength, Char) {

    if (new String(sValue).valueOf() == "undefined") sValue = "";
    if (utlf_isNull(sValue)) sValue = "";

    var strRetVal = new String(sValue);
    var strChar = "";
    var nIteration = nLength - utlf_getLengB(strRetVal);
    for (var i = 0; i < nIteration; i++) {
        strChar = Char + strChar;
    }
    return (strChar + strRetVal);
}

/**********************************************************************************
 * 함수명     : utlf_getLengB
 * 설명       : 입력된 sValue에 byte를 리턴한다.
 * argument    : sValue (문자열)
 * return Type : String
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_getLengB(sValue)
{
    var v_ChkStr = sValue.toString();
    var v_cnt = 0;

    for (var i=0; i<v_ChkStr.length; i++)
    {
        if (v_ChkStr.charCodeAt(i) > 127)
        {
            v_cnt += 2;
        } else {
            v_cnt += 1;
        }
    }

    return v_cnt;
}

/**********************************************************************************
 * 함수명     : utlf_getStringByte
 * 설명       : 입력된 sValue를 주어진 byte만큼 자른다.
 * argument    : 	sValue (문자열)
 *					StartByte (시작 byte값)
 *					EndByte (종료 byte값)
 * return Type : String
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_getStringByte(sValue, StartByte, EndByte){
	var buf = sValue.toString();
	var Len = 0;
	var strText = "";

	for(var i=0; i<buf.length; i++){
		if (buf.charCodeAt(i) > 127){
			Len += 2;
		}else{
			Len += 1;
		}
		 
		if( Len >= StartByte && Len <= EndByte){
			strText += String.fromCharCode(buf.charCodeAt(i));
		}
	}
	
	return strText;
}

/**********************************************************************************
 * 함수명     : utlf_isNull
 * 설명       : NULL 여부 체크
 * argument    : sValue (문자열)
 * return Type : boolean
 * 작성자		: 임준호
 *********************************************************************************
function utlf_isNull(sValue)
{
    if( ("x"+sValue == "xNaN") && ( new String(sValue.length).valueOf() == "undefined")) return true;
    
    if (sValue == null) return true;
    
    var v_ChkStr = new String(sValue);

    if (v_ChkStr == null) return true;

    if (v_ChkStr.toString().length == 0 ) return true;

    return false;
}
*/

/**********************************************************************************
 * 함수명     : utlf_transNullToEmpty
 * 설명       : NULL 일 경우 빈 값을 리턴한다.
 * argument    : sValue (문자열)
 * return Type : String
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_transNullToEmpty(sValue)
{
	if( utlf_isNull(sValue) )
	{
		return "";
	}
	return sValue;
}

/**********************************************************************************
 * 함수명     : utlf_transEmptyToNull
 * 설명       : Empty 일 경우 Null 값을 리턴한다.
                 Component의 displaynulltext를 사용하기위해 생성(2014.12.02)
 * argument    : sValue (문자열)
 * return Type : String
 * 작성자		: 최재원
  **********************************************************************************/
function utlf_transEmptyToNull(sValue)
{
	if( utlf_isNull(sValue) )
	{
		return null;
	}
	return sValue;
}

/**********************************************************************************
 * 함수명     : utlf_transNull
 * 설명       : NULL 일 경우 예약된 문자열로 리턴한다.
 * argument    : sValue1 (문자열)
 * argument    : sValue2 (Null 일때 사용할 문자열)
 * return Type : String
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_transNull(sValue1, sValue2)
{
	if( utlf_isNull(sValue1) )
	{
		return sValue2;
	}
	return sValue1;
}

/**********************************************************************************
 * 함수명     : utlf_transNullToChar
 * 설명       : NULL 일 경우 새로운 값을 리턴한다.
 * argument    : sValue (문자열)
 * argument    : sNewVal (바뀔 문자열)
 * return Type : String
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_transNullToChar(sValue, sNewVal)
{
	return utlf_transNull(sValue, sNewVal);
}

/**********************************************************************************
 * 함수명     : utlf_transNullToSpace
 * 설명       : NULL 일 경우 공백을 리턴한다.
 * argument    : sValue (문자열)
 * return Type : String
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_transNullToSpace(sValue)
{
	if( utlf_isNull(sValue) )
	{
		return " ";
	}
	return sValue;
}

/**********************************************************************************
 * 함수명      : utlf_mid
 * 설명        : 입력된 문자열에서 가운데 부분을 주어진 길이만큼 Return 한다.
 * argument    : strString (가운데 부문을 얻어올 원본 문자열)
 *               nIndex (얻어올 첫 글자의 Index)
 *               nSize (얻어올 글자수)
 * return Type : String
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_mid(strString, nIndex, nSize)
{
    var nStart = ((nIndex == null) ? 0 : ((nIndex.toString().length <= 0) ? 0 : nIndex-1));
    var nEnd = ((nSize == null) ? strString.toString().length : ((nSize.toString().length <= 0) ? strString.toString().length : nSize));
    var rtnVal = strString.toString().substr(nStart, nEnd);

    return String(rtnVal);
}

/**********************************************************************************
 * 함수명      : utlf_isDigit
 * 설명        : 숫자 정합성 체크
 * argument    : val(문자열)
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
function utlf_isDigit(val)
{
	var lvNum;	
	var lvFlag = "No";
	var lvRetVal = false;	
	var lvLength;
	var i;
	
	if (utlf_isNull(val) == true)
	{
		lvFlag = "Yes";
		lvRetVal = false;
		return lvRetVal;
	}
	
	lvLength = val.length;
	
	if ((val.toString().split(".").length > 2) && lvFlag == "No")
	{
		lvFlag = "Yes";
		lvRetVal = false;
	}
	
	if (lvFlag == "No")
	{
		for (i = 0; i < lvLength ; i++)
		{ 
			lvNum = val.substr(i,1);
			if (i == 0)
			{
				if(utlf_isNum(lvNum) || (lvNum == "-" && val.substr(1,1) != ".") 
					|| (lvNum == "+"  && val.substr(1,1) != "."))
					lvRetVal = true;
				else 
				{
					lvRetVal = false;
					break;
				}
			}
			else
			{
				if(utlf_isNum(lvNum) || (lvNum == "." && val.substr(i+1,1).length != 0))
					lvRetVal = true;
				else 
				{
					lvRetVal = false;
					break;
				}
			}
	     }
	 }
  return lvRetVal;
}

/**********************************************************************************
 * 함수명      : utlf_round
 * 설명        : 인자로 넘어온 숫자를 반올림 처리한다.
 * argument    : nValue(숫자)
 *				 nDigit(자리수)
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_round(nValue, nDigit)
{
    var nRound = 1;
    for ( var i = 0; i < nDigit; i++) {
        nRound = nRound * 10;
    }

    var nRetValue = nValue * nRound;
    nRetValue = Math.round(nRetValue);
    nRetValue = nRetValue / nRound;
    return nRetValue;
}

/**********************************************************************************
 * 함수명      : utlf_setComma
 * 설명        : 숫자에 ","를 집어넣기
 * argument    : sNum ( 문자열 )
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_setComma(sNum)
{
	sNum = sNum.toString().replace(",", "");
	
	var  ppos, sDigit, nEnd, nStart=0, sRet="";
	
	if( sNum.charAt(0) == "+" || sNum.charAt(0) == "-" )
	{
		sRet += sNum.charAt(0);
		nStart = 1;
	}
	ppos = utlf_pos(sNum, ".", nStart);
	if( ppos < 0 )
		nEnd = sNum.length;
	else
		nEnd = ppos;
	sDigit = sNum.substr(nStart, nEnd-nStart);
	for( pos = 0 ; pos < sDigit.length ; pos ++ )
	{
		if( pos != 0 && (sDigit.length-pos)%3 == 0 )
			sRet += ",";
		sRet += sDigit.charAt(pos);
	}
	sRet += sNum.substr(nEnd);
	
	return sRet;
}

/**********************************************************************************
 * 함수명      : utlf_pos
 * 설명        : 문자열의 위치를 대소문자 구별하여 찾는다
 * argument    : sOrg ( 원래 문자열 )
 *				: sFind ( 찾고자 하는 문자열 )
 *				: nStart ( 검색 시작위치 )
 * return Type : Int(찾고자 하는 문자열의 시작위치, 없을시 -1)
 * 작성자		: 임준호
**********************************************************************************/
function utlf_pos(sOrg, sFind, nStart)
{
	if( utlf_isNull(nStart) )		nStart = 0;

	return sOrg.indexOf(sFind, nStart);
}

/**********************************************************************************
 * 함수명      : utlf_isNum
 * 설명        : 문자열이 숫자형식에 맞는지 여부 체크
 * argument    : sNum ( 체크할 문자열 )
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
function utlf_isNum(sNum)
{
	var c;
	var point_cnt=0;
	var ret=true;
	
	if( utlf_isNull(sNum) )		return false;
	
	for( i = 0 ; i < sNum.length ; i++ )
	{
		c = sNum.charAt(i);
		if( i == 0 && ( c == "+" || c == "-" ) );
		else if( c >= "0" && c <= "9" );
		else if( c == "." )
		{
			point_cnt++;
			if( point_cnt > 1 )
			{
				ret = false;
				break;
			}
		}
		else
		{
			ret = false;
			break;
		}
	}
	
	return ret;
}

/********************************************************************
* 함수명 : utlf_getFormat
* 설명 : 문자 포맷 형식 변환 ( 해당 문자는 포맷에서 @ 사용)
* argument :  strVal: 문자열, 
*         strMask: 문자열 포맷, (@:문자, 포맷스트링("-", ",", ".")등
*			예) ("abcdef", "@@@-@@@") -> "abc-def"
* return Type : String - 포맷된 문자
* 작성자		: 임준호
********************************************************************/
function utlf_getFormat(strVal, strMask) {
    
    var strRetVal = "";
	var sUnit;
	
	if(utlf_isNull(strVal)) return "";
	
	strVal = "" + strVal;
	
    for(var i = 0; i < strMask.length; i++) {
		sUnit = strMask.substr(i, 1);
		
		if( sUnit == "@")
		{
		    strRetVal += strVal.substr(0, 1);
		    strVal = strVal.substr(1);
		}
		else
		{
		    strRetVal += sUnit;
		}
    }
    
    return strRetVal;
}

/*******************************************************************************
 * 함수명  : utlf_isHangul
 * 설명 : 한글 여부 확인 (첫텟스트가 한이면 "H" 아니면 "E" 리턴
 * argument  : pData: 한글여부를 비교할 데이터
 * return Type : E: 영문, H: 한글
 * 주의사항 :
 * 작성자		: tobesoft
  ex) var diagnm = dsObj.getColumn(0, "diagnm");
	 frmf_setParameter("SPMMO00800_cond3", utlf_isHangul(diagnm));
 ******************************************************************************/
function utlf_isHangul(pData) {
    var sBit = pData.charAt(0);    
    if (escape(sBit).length <= 4) return "E";    
    return "H";
}

/*******************************************************************************
 * 함수명  : utlf_isAlphabet
 * 설명 : 입력된 문자 또는 문자열이 모두 Alphabet이면 true, 그렇지 않으면 false를 반환합니다.
 * argument  : str: 비교할 데이터
 * return Type : true /false
 * 작성자		: tobesoft
 * ex) var str = "abc가나";
	   var str1 = "abcecAC";
	   utlf_isAlphabet(str);  // return false
	   utlf_isAlphabet(str1);  // return true
 ******************************************************************************/
function utlf_isAlphabet(str) { 
	var chCode; 
	for (var i = 0; i < str.length; i++){ 
		chCode = str.charCodeAt(i); 
		  
		if (!((chCode >= 65 && chCode <= 90) || (chCode >= 97 && chCode <= 122) || (chCode == 32))) 
		{ 
			return false; 
		} 
	} 
	return true; 
} 
/****************************************************************************************
 * Function			: utlf_isSearchString
 * Description		: 전체 문장에서 특정 문장이 있는지를 검사하는 함수
 * Argument			: 01.sSrc	: 전체 문장
 *					: 02.sFind	: 찾을 문장
 * return type		: boolean
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_isSearchString(sSrc, sFind){
	
	var objRe = null;
	var bR = null;
	
	objRe = new RegExp(sFind);
	bR = objRe.exec(sSrc);
	
	if(utlf_isNull(bR))	return false;
	else return true;
}

/****************************************************************************************
 * Function			: utlf_setReplaceWord
 * Description		: 문자열중의 특정 문자 또는 단어를 찾아 원하는 문자 또는 단어로 치환
 * 
 *					1. 찾을 단어를 구분자로 분리한 문자열을 저장할 배열 변수지정
 *					2. 치환하여 리턴할 내용을 담을 변수 지정
 *					3. 원본 문자열을 찾을 단어를 구분자로 분리
 *					4. 찾을 단어의 수만큼 loop
 *						- 찾을 단어 대신 대체 단어를 붙이면서 누적
 *					3. 마지막 찾을 단어의 뒷부분 내용 추가.
 *						- 찾을 단어가 없었다면 원본 문자열 전체가 됨
 * 
 * Argument			: 01.findWord    - 찾을 단어
 *					: 02.replaceWord - 대체 단어
 * return type		: String - 대체하고난 문자열
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_setReplaceWord(findWord, replaceWord){
	
	var tempArray;
	var rtnSting = "";

	tempArray = this.split(findWord);

	for(var i=0; i < tempArray.length-1; i++)
	{
		rtnSting += tempArray[i] + replaceWord;
	}

	rtnSting += tempArray[tempArray.length-1];

	return rtnSting;
}

/****************************************************************************************
 * Function			: utlf_getByteLength
 * Description		: 파라미터 값의 Byte 크기를 리턴
 * Argument			: 
 * return type		: Number - 파라미터 값의 Byte 크기
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getByteLength(){
	
	// Byte 수를 저장할 변수
	var rtnValue = 0;

	// Value 값의 길이만큼 loop
	for(var i=0; i < this.length; i++){
		//한글이 들어오면 255보다 크다
		(this.charCodeAt(i) > 255) ? rtnValue += 2 : rtnValue += 1;
	}

	return rtnValue;
}

/****************************************************************************************
 * Function			: utlf_isByteSize
 * Description		: 문자열의 Byte 크기가 제한값을 벗어나는지 체크 (벗어나면 false 리턴)
 * Argument			: 01.pSize - 제한크기
 * return type		: Boolean - true/false
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_isByteSize(pSize){
	
	return (this.getByteLength() <= eval(pSize) ? true : false);
}

/****************************************************************************************
 * Function			: utlf_getStringAsByte
 * Description		: 문자열을 원하는 바이트 크기로 만든다.
 * Argument			: 01.strValue : 문자열
 *					: 02.pMakeByteSize : 만들고자 하는 바이트수
 *					: 03.pByteSize : 문자열의 바이트수
 * return type		: String
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getStringAsByte(strValue, pMakeByteSize, pByteSize)
{
     var rtnValue = strValue;
     var sSpace = "";
     if (pByteSize > pMakeByteSize) return strValue;

     for( var iCnt = 1; iCnt <= pMakeByteSize-pByteSize; iCnt++) {
         sSpace = " " + sSpace;
     }

     rtnValue = sSpace + rtnValue;

     return rtnValue;
}

/****************************************************************************************
 * Function			: utlf_getTrim
 * Description		: 문자열 앞뒤에있는 공백 제거
 * Argument			: 
 * return type		: String - 공백을 제거한 결과 문자열
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getTrim(){
	
	var startPoint = 0;             // subString 하기 위한 시작 포인트
	var endPoint   = this.length;   // subString 하기 위한 끝 포인트
	
	//문자열앞에 공백문자가 들어 있는 Index 추출
	while( (startPoint < endPoint) && (this.charCodeAt(startPoint) == 32) )
	{
	  startPoint++;
	}
	
	//문자열뒤에 공백문자가 들어 있는 Index 추출
	while( (startPoint < endPoint) && (this.charCodeAt(endPoint-1) == 32) )
	{
	  endPoint--;
	}
	// 공백을 제거했으면 subString하여 결과문자열을 리턴하고 제거한 내용이 없으면 그대로 리턴
	return ( (startPoint > 0) || (endPoint < this.length) ) ? this.substring(startPoint, endPoint) : this;
}

/****************************************************************************************
 * Function			: utlf_getTrimLeft
 * Description		: 문자열 앞에 있는 공백 제거
 * Argument			: 
 * return type		: String - 공백을 제거한 결과 문자열
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getTrimLeft(){
	
	var i, j = 0;


	for (i = 0; i < this.length; i++) {
	  if (this.charAt(i) == ' ') j = j + 1;
	  else break;
	}

	return this.substr(j, this.length - j + 1);
}

/****************************************************************************************
 * Function			: utlf_getTrimRight
 * Description		: 문자열 뒤에 있는 공백 제거
 * Argument			: 
 * return type		: String - 공백을 제거한 결과 문자열
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getTrimRight(){
	
	var i, j = 0;

	for (i = this.length - 1; i >= 0; i--) {
	  if (this.charAt(i) == ' ') j = j + 1;
	  else break;
	}

	return this.substr(0, this.length - j);
}

/****************************************************************************************
 * Function			: utlf_getLeftPad
 * Description		: 숫자 값에 원하는 길이만큼 '0'을 붙여 표현
 * Argument			: 01.pLen - 돌려받을 최종문자의 길이
 *					: 02.padString - 지정된 문자로 대체
 * return type		: String - 지정길이보다 모자른경우 "0"값이 추가된 문자열
 *								지정길이보다 큰경우 원래 문자열을 반환
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getLeftPad(pLength, padString){
	var rtnStr = String(this);
	if (this.length < pLength) {

		for( var i = this.length; i < pLength; i++){
			rtnStr = padString + rtnStr;
		}
	}

	return rtnStr;
}

/****************************************************************************************
 * Function			: utlf_getRightPad
 * Description		: 숫자 값에 원하는 길이만큼 뒤쪽에 ' '을 붙여 표현
 * Argument			: 01.pLen - 돌려받을 최종문자의 길이
 *					: 02.padString - 지정된 문자로 대체
 * return type		: String - 지정길이보다 모자른경우 " "값이 추가된 문자열
 *								지정길이보다 큰경우 원래 문자열을 반환
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getRightPad(pLength, padString){
	var rtnStr = String(this);
	if (this.length < pLength) {

		for( var i = this.length; i < pLength; i++){
			rtnStr = rtnStr + padString;
		}
	}

	return rtnStr;
}

/****************************************************************************************
 * Function			: utlf_getStringLength
 * Description		: 문자열의 길이를 구한다.
 * Argument			: 01.pData - 문자열
 * return type		: Number - 문자열 길이
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getStringLength(pData){
	
    var sBit = "";
    var iLen = 0;

    for (var i = 0; i < pData.length; i++) {
        sBit = pData.charAt(i);

        if (escape(sBit).length > 4) iLen = iLen + 2;
        else iLen = iLen + 1;
    }

    return iLen;
}

/****************************************************************************************
 * Function			: utlf_getCarrigeReturnRemove
 * Description		: CarrigeReturn을 없앤 문자열을 리턴한다.
 * Argument			: 
 * return type		: String - CarrigeReturn을 없앤 문자열
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getCarrigeReturnRemove() {
	return this.replace(/\s/g, "");
}

/****************************************************************************************
 * Function			: utlf_getSearchStringRight
 * Description		: 전체 문장에서 특정 문장을 뒤에서 부터 찾는 함수
 * Argument			: 01.strSrc - 전체 문장
 *					: 02.strFind - 찾을 문장
 * return type		: Number - 위치
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getSearchStringRight(strSrc, strFind){
	var pos = strSrc.indexOf(strFind);
	if(pos == -1)
		return -1;
	
	while(pos != -1)
	{
		var oldPos = pos;
		pos = strSrc.indexOf(strFind, oldPos + 1);
	}

	return oldPos;
}

/****************************************************************************************
 * Function			: utlf_getByteString
 * Description		: 원하는 바이트만큼 문자열을 잘라옴. 만약 현재 문자열보다 자르고자 하는 바이트가 크면 현재 문자열 반환.
 * Argument			: 01.bSize - 자르고자 하는 바이트크기(예:30 => 30byte)
 * return type		: String - bSize 만큼의 문자열
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getByteString(bSize) {
    if (this.getByteLength() <= bSize) {
        return this;
    }

    var rtnValue = "";
    for (var i = 0; i < this.length; i++) {
        if (rtnValue.getByteLength() >= bSize) {
            break;
        }

        rtnValue += this.charAt(i);
    }

    return rtnValue;
}

/****************************************************************************************
 * Function			: utlf_getCarrigeReturnReplace
 * Description		: CarrigeReturn을 원하는 문자로 변경한 다음 리턴한다.
 * Argument			: 01.ch - 바꾸고자 하는 문자열
 * return type		: String
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getCarrigeReturnReplace(ch) {
	return this.replace(/\s/g, ch) ;
}

/****************************************************************************************
 * Function			: utlf_subString2
 * Description		: 영문 한글이 섞인 경우 올바른 인덱스로 subString을 하기 위해 사용
 * Argument			: start : 시작위치
                      end   : 끝나는 위치
 * return type		: subString된 String
 * Creator			: 김상목
 ****************************************************************************************/
function utlf_subString2(start, end) {
	var lim = 0;
	var pos = 0;
	var beg = 0;
	var minus = 0;
	var len = utlf_getLengB(this);
	var size = end - start;
	
	for(var i = 0; pos < start; i++)
		pos += (this.charCodeAt(i) > 127) ? 2 : 1;
		
	beg = i;
	
	for(var i =  beg; i < len; i++) {
		lim += (this.charCodeAt(i) > 127) ? 2 : 1;
		
		if(lim > size) {
			return this.substring(beg, i);
		}
	}
}

/****************************************************************************************
 * Function			: utlf_setAmountToKorean
 * Description		: 금액을 한글로 변환 (단위포함)
 * Argument			: 
 * return type		: String - 단위를 포함한 한글String으로 반환
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_setAmountToKorean(){
	
	var amountTmp = this;                    // Parameter로 받은 값
	var amount    = "";                       // Convert할 값
	var rtnAmt    = "";                       // 전체 CONV된 한글 값
	var amtKor    = "";                       // 각 단위별 CONV된 한글 값
	var flag      = "N";                      // 만단위 이상 FLAG값

	var amtLength = amountTmp.length;
	var fstChar   = "";

	for(i=0; i < amtLength ;i++) {

		fstChar = amountTmp.substring(i,i+1);

		if('0' <= fstChar && '9' >= fstChar) {
		   amount = amount.concat(fstChar);
		}
	}

	amtLength   = amount.length;                // Parameter로 받은 값의 길이

	for(i=1; i<=amtLength ;i++) {

		var amtEng = (amount.substring(amtLength-i,amtLength)).substring(0,1);

		switch(amtEng) {
			case '1':
				amtKor = "일";
				break;
			case '2':
				amtKor = "이";
				break;
			case '3':
				amtKor = "삼";
				break;
			case '4':
				amtKor = "사";
				break;
			case '5':
				amtKor = "오";
				break;
			case '6':
				amtKor = "육";
				break;
			case '7':
				amtKor = "칠";
				break;
			case '8':
				amtKor = "팔";
				break;
			case '9':
				amtKor = "구";
				break;
			case '0':
				continue;
			default:
				continue;
		}

		if(i==1) {
			rtnAmt = amtKor;
		} else {
			switch((i-1)%4) {
				case 1:
					amtKor = amtKor.concat("십");
					break;
				case 2:
					amtKor = amtKor.concat("백");
					break;
				case 3:
					amtKor = amtKor.concat("천");
					break;
				case 0:
				default:
					break;
			}

			if( i>4 && i<9 && flag!='M') {
				amtKor = amtKor.concat("만");
				flag = 'M';
			}

			if( i>8 && i<13 && flag!='U') {
				amtKor = amtKor.concat("억");
				flag = 'U';
			}

			if( i>12 && flag!='J') {
				amtKor = amtKor.concat("조");
				flag = 'J';
			}

			rtnAmt = amtKor.concat(rtnAmt);
		}
	}

	return rtnAmt;
}

/****************************************************************************************
 * Function			: utlf_isNumber
 * Description		: 값이 Number 형인지 점검
 * Argument			: 
 * return type		: Boolean - true/false
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_isNumber(){
	
	if( typeof( this ) == "undefined" ) return false;
	if( this.length == 0 ) return false;

	var thisSting = this.toString();
	for( var i=0; i < thisSting.length; i++ ){
		var thisNumber = thisSting.substring( i, i+1 );

		// 숫자가 아니면 FALSE 리턴
		if( isNaN( thisNumber ) ) return false;

		// 공백이면 FALSE 리턴
		if( " " == thisNumber ) return false;
	}

	return true;
}

/****************************************************************************************
 * Function			: utlf_isFloat
 * Description		: 값이 Float 형인지 점검
 * Argument			: 
 * return type		: Boolean - true/false
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_isFloat()
{
	// 파라미터 값이 parseFloat()후에도 같으면 TRUE 리턴
   return ( this == parseFloat( this ) ) ? true : false;
}

/****************************************************************************************
 * Function			: utlf_getRound
 * Description		: 저장된 값을 지정한 자리에서 올림/반올림/버림 처리
 * Argument			: 01.position - 올림/반올림/버림 할 위치(2:10자리, 1:1자리, -1:소수점이하 첫째자리)
 *					: 02.mode  - UP:올림, HALF_UP:반올림, DOWN:버림
 * return type		: Number
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getRound(position, mode){
	
	// 파라미터 값을 수치화 하여 변수에 저장
   var valueNumber    = eval(this);

   // 소수점을 기준으로 숫자들만 취하여 배열 변수에 저장
   var tempArray = eval(this).toString().setReplaceWord("-", "").split(".");

   // this 가 float 형이 아니면
   if( !this.isFloat() )
   {
      //fAlertMessage(4, "파라미터");
      return "";
   }

	// position 가 float 형이 아니면
   if( !position.toString().isFloat() )
   {
      //fAlertMessage(4, "파라미터");
      return "";
   }

   // 소수점 앞에서 처리하려면
   if(0 < eval( position ))
   {
      // 소수점 이상 자리수보다 크면
      if( tempArray[0].length < eval(position) )
      {
         // 메시지 처리후 리턴
         //fAlertMessage(1, "올림/반올림/버림 할 위치");
         return "";
      }
   }
   // 소수점 뒤에서 처리하려면
   else if(0 > eval(position))
   {
      // 소수점 이하값이 존재하지 않거나 자리수보다 크면
      if(tempArray.length != 2 || tempArray[1].length < eval(position)*(-1))
      {
         return this;
      }
   }

   switch(mode){
   // '올림'이고
	   case "UP" : 
      // 소수점 앞에서 처리하려면
      if(0 < eval(position))
      {
         // 해당 자리(position)에서 올림 처리
         valueNumber = Math.ceil(valueNumber / Math.pow(10, position)) * Math.pow(10, position);

         return valueNumber;
      }
      // 소수점 뒤에서 처리하려면
      else if(0 > eval(position))
      {
         // 해당 자리(position)에서 올림 처리
         valueNumber = Math.ceil(valueNumber * Math.pow(10, position*(-1)-1)) / Math.pow(10, position*(-1)-1);

         return valueNumber;
      }
      else
      {
         //fAlertMessage(4, "올림자리");
         return "";
      }
   // '반올림'이고
	case "HALF_UP" :
      // 소수점 앞에서 처리하려면
      if(0 < eval(position))
      {
         // 해당 자리(position)에서 반올림 처리
         valueNumber = Math.round(valueNumber / Math.pow(10, position)) * Math.pow(10, position);

         return valueNumber;
      }
      // 소수점 뒤에서 처리하려면
      else if(0 > eval(position))
      {
         // 해당 자리(position)에서 반올림 처리
         valueNumber = Math.round(valueNumber * Math.pow(10, position*(-1)-1)) / Math.pow(10, position*(-1)-1);

         return valueNumber;
      }
      else
      {
         //fAlertMessage(4, "올림자리");
         return "";
      }

   // '버림'이고
   case "DOWN" :
      // 소수점 앞에서 처리하려면
      if(0 < eval(position))
      {
         // 해당 자리(position)에서 내림 처리
         valueNumber = Math.floor(valueNumber / Math.pow(10, position)) * Math.pow(10, position);

         return valueNumber;
      }
      // 소수점 뒤에서 처리하려면
      else if(0 > eval(position))
      {
         // 해당 자리(position)에서 내림 처리
         valueNumber = Math.floor(valueNumber * Math.pow(10, position*(-1)-1)) / Math.pow(10, position*(-1)-1);

         return valueNumber;
	  }else{
         //fAlertMessage(4, "올림자리");
         return "";
      }

   // 모두 아니면
   default :
      // 메시지 처리후 리턴
      //fAlertMessage(1, "모드('1'/'0'/'-1')");
      return "";
   }
}

/****************************************************************************************
 * Function			: utlf_getTruncate
 * Description		: 소수점 버리고 정수형 String으로 생성 (음수인경우에도 마찬가지 음수표시는 유효)
 * Argument			: 
 * return type		: String
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getTruncate(){
	
	var TempArray = new Array();
	TempArray = this.split(".");
	return TempArray[0];
}

/****************************************************************************************
 * Function			: utlf_getRandomNo
 * Description		: 랜덤숫자 만들기
 * Argument			: 01.iRange - 랜덤숫자가 발생할 범위 지정 ( 1 ~ iRange )
 * return type		: Number - iRange 범위에 속하는 랜덤숫자
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getRandomNo(iRange){
	iRnt = Math.floor( Math.random() * iRange ) + 1;
	return iRnt;
}

/****************************************************************************************
 * Function			: utlf_isEmpty (->utlf_transNullToEmpty)
 * Description		: 입력값이 null 또는 wihte space로만 이루어져 있으면 빈문자를 리턴하는 함수
 * Argument			: String sValue
 * return type		: String sValue
 * Creator			: 임준호
 ****************************************************************************************/
// function utlf_isEmpty(sValue)
// {	
// 	if (new String(sValue).valueOf() == "undefined") return "";
//     if (sValue == null) return "";
//     var lv_sChkStr = new String(sValue);
//     if (lv_sChkStr == null) return "";
//     if (lv_sChkStr.toString().length == 0 ) return "";
//     return sValue;
// }

/****************************************************************************************
 * Function			: utlf_setColumnTrimStr
 * Description		: 문자열의 앞, 뒤 공백을 제거하여 지정된 dataset의 컬럼에 입력한다.
 * Argument			: 01.sValue - Trim을 적용할 문자열
 *					: 02.objDs - dataset object
 *					: 03.nRownum - dataset의 row number
 *					: 04.sColName - dataset의 column명
 * return type		: Boolean - 완료 여부
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_setColumnTrimStr(sValue, objDs:Dataset, nRownum, sColName){	
	
	var bReturn = false;
	
	if(!utlf_isNull(objDs) && !utlf_isNull(nRowNum) && !utlf_isNull(sColName)){
		objDs.setColumn(nRownum, sColName, sValue.getTrim());
		bReturn = true;
	}
	
	return bReturn;
}

/****************************************************************************************
 * Function			: utlf_getObjFont
 * Description		: Font Object 생성 반환(텍스트 길이를 반환하기 위해서 사전생성)
 * Argument			: iFontSize - 폰트사이즈 : 9
 *					: sFontName - 폰트명	: "Dotum"
 *					: bBold		- 볼드여부 (true/ flase)
 * return type		: Font Object 
 * Creator			: tobesoft
 ex) var objFont = utlf_getObjFont(9, "Dotum", true);
 ****************************************************************************************/
function utlf_getObjFont(iFontSize, sFontName, bBold)
{
	var objFont = new Font;
	objFont.size = iFontSize;
	objFont.name = sFontName;
	if(!utlf_isNull(bBold))
	{
		objFont.bold = bBold;
	}
	return objFont;
}
 
/****************************************************************************************
 * Function			: utlfn_getTextSize
 * Description		: size object를 반환한다.(objFontSize.cx : 사이즈길이 , objFontSize.cy 사이즈 높이)
 * Argument			: sText - 문자열
 *					: objFont - Font Object
 * return type		: objTextSize or flase : Size 오브젝트 나 false를 반환한다. 
 * Creator			: tobesoft
ex)	
	var objFont = utlf_getObjFont(9, "Dotum", true);	//폰트사이즈
	var sText = "가나다라123aAbC";						//사이즈를 잴 텍스트
	var objFontSize =utlf_getTextSize(sText, objFont);	//size Object
	alert("'"+sText+"'  텍스트의 사이즈는 = "+objFontSize.cx+"px 입니다.");
 ****************************************************************************************/
function utlf_getTextSize(sText, objFont)
{
	var objPainter = this.canvas.getPainter();
	if(utlf_isNull(objPainter)==false)
	{
		var objTextSize = objPainter.getTextSize(sText, objFont);
		return objTextSize;
	}
	else
	{
		return false;
	}
}

/****************************************************************************************
 * Function			: utlf_getCountStr
 * Description		: sStr에서 sChar가 포함된 갯수를 구한다.
 * Argument			: sStr - 대상 문자열
 *					: sChar - 대상 문자열에서 갯수를 구할 문자열
 * return type		: Number - 갯수
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getStrCount(sStr, sChar){
	
	var arrDivStr = sStr.split(sChar);
	
	return arrDivStr.length-1;
}


/********************************************************************************************************************/
/************************* 날짜 관련 함수 *************************************************************************/
/********************************************************************************************************************/

/**********************************************************************************
 * 함수명		: utlf_splitDateS
 * 설  명		: yyyyMMdd형태의 날짜를 구분자를 삽입하여 반환한다.
 * argument		: sDate ( yyyyMMdd형태의 날짜 )( 예 : "20121122" )
 *				sDeli (구분자)
 * return Type	: Boolean
 * 예  시		: utlf_splitDateS("20140101", "-"); -> "2014-01-01"
 * 작성자		: 임준호
**********************************************************************************/
function utlf_splitDateS(sDate, sDeli){
	if(!utlf_isNull(sDeli)){
		sDate = sDate.substring(0, 4)+sDeli+sDate.substring(4, 6)+sDeli+sDate.substring(6,9);
	}
	return sDate;
}

/***********************************************************************
* 함수명		: utlf_makeDate
* 설명			: 입력된 문자를 date로 변환.
* argument		: nYear 	- Year : 년도
*					 nMonth 	- Month : 월
*					 nDate 	- Date : 일
* Return Type	: Date
* 예  시		: utlf_makeDate("2010", "05", "01");
* 작성자		: 임준호
**********************************************************************
function utlf_makeDate(nYear, nMonth, nDate)
{
	if( utlf_isNull(nYear) || utlf_isNull(nMonth) || utlf_isNull(nDate) )	return "";
	
	var objDate = new Date(nYear, nMonth-1, nDate);
	
	return objDate;
}
*/

/***********************************************************************
* 함수명		: utlf_makeDateYmd
* 설명			: 입력된 문자를 date로 변환.
* argument		: nYear 	- Year : 년도
*				 nYear 	- Month : 월
*				 nYear 	- Date : 일
* Return Type	: Date
* 예  시		: utlf_makeDate("2010", "05", "01");
* 작성자		: 임준호
***********************************************************************/
function utlf_makeDateYmd(sDate)
{
	var nYear = "";
	var nMonth = "";
	var nDay = "";
	if(utlf_isNull(sDate))	return "";
	
	try{
		nYear = toNumber(sDate.substring(0, 4));
		nMonth = toNumber(sDate.substring(4, 6));
		nDay = toNumber(sDate.substring(6,9));
	}catch(e){
//		trace(e.description);
		return "";
	}
	
	var objDate = new Date(nYear, nMonth-1, nDay);
	
	return objDate;
}

/***********************************************************************
* 함수명		: utlf_makeDateS
* 설명			: [yyyy][MM][dd] -> yyyyMMdd 형태의 문자열 날짜 출력
* argument		: nYear 	- Year : 년도
*					 nYear 	- Month : 월
*					 nYear 	- Date : 일
* Return Type	: string(date)
* 예  시		: utlf_makeDate("2010", "05", "01");
* 작성자		: 임준호
***********************************************************************/
function utlf_makeDateS(nYear, nMonth, nDate)
{
	if( utlf_isNull(nYear) || utlf_isNull(nMonth) || utlf_isNull(nDate) )	return "";
	
	var objDate = new Date(nYear, nMonth-1, nDate);

	var sYear   = objDate.getFullYear().toString();
	var sMonth  = utlf_right("0" + (objDate.getMonth() + 1), 2);
	var sDate   = utlf_right("0" + objDate.getDate(), 2);

	return sYear + sMonth + sDate;
}

/**********************************************************************************
 * 함수명      : utlf_isLeap
 * 설명        : 윤년여부 확인
 * argument    : sDate ( yyyyMMdd형태의 날짜 )( 예 : "20121122" or "2012")
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
function utlf_isLeap(sDate)
{
    var ret;
    var nY;
    
    if(utlf_isNull(sDate))		return false;
    
    if(sDate.length > 4){
		nY = parseInt(sDate.substring(0,4), 10);
    }else{
    	nY = sDate;
    }
	
    if ((nY % 4) == 0) 
    {
        if ((nY % 100) != 0 || (nY % 400) == 0) 
            ret = true;
        else 
            ret = false;
    } 
    else 
        ret = false;
  
    return ret;
}

/**********************************************************************************
 * 함수명      : utlf_addDate
 * 설명        : 입력된 날자에 nOffset 으로 지정된 만큼의 일을 증감한다.
 * argument     : sDate ( 날짜 )( 예 : "20121122" )
 *				: nOffset (일 증감값) ( 예 : 10 또는 -10 )
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_addDate(sDate, nOffset)
{
	if( utlf_isNull(sDate) || utlf_isNull(nOffset) )	return "";
	
    var nYear = parseInt(sDate.substr(0, 4));
    var nMonth = parseInt(sDate.substr(4, 2));
    var nDate = parseInt(sDate.substr(6, 2)) + nOffset;

    return utlf_makeDateS(nYear, nMonth, nDate);
}

/**********************************************************************************
 * 함수명      : utlf_addMonth
 * 설명        : 입력된 날자에 nOffset 으로 지정된 만큼의 월을 증감한다.
 * argument     : sDate ( 날짜 )( 예 : "20121122" )
 *				: nOffset (월 증감값) ( 예 : 10 또는 -10 )
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_addMonth(sDate, nOffset)
{
	if( utlf_isNull(sDate) || utlf_isNull(nOffset) )		return "";
	
    var nYear = parseInt(sDate.substr(0, 4));
    var nMonth = parseInt(sDate.substr(4, 2))+nOffset;
    var nDate = parseInt(sDate.substr(6, 2));
	var nLastDate, sRet;
	
	if(nDate.toString().length==1)
	{
		nDate = "0"+nDate;
	}
	
	sRet = utlf_makeDateS(nYear, nMonth, 1);	
    nLastDate = utlf_lastDateNum(sRet);
    sRet = sRet.substr(0,6);
    if( nDate > nLastDate )
		sRet += nLastDate.toString();
	else
		sRet += nDate.toString();
		
	return sRet;
}

/****************************************************************************************
 * Function			: utlf_getAddDate
 * Description		: 특정일자의 상대일자(+/-)를 계산
 * Argument			: 01.pNum : 구하고자 하는 상대일 수 (+/-)
 *					: 02.pKind : 구하고자 하는 기준
 * return type		: Date
 * Creator			: 임준호
 * ex				:
 *       pKind에 따른 상대일자를 계산한다.
 *
 *           "Y" : 년
 *           "M" : 월
 *           "D" : 일
 *           "h" : 시
 *           "m" : 분
 *           "s" : 초
 *
 *       default는 "D"
 *
 *       함수 호출시 다음과 같이 사용한다.
 *
 *          1) date.getAddDate(10)       --> default로 일에 대한 상대일을 구한다.
 *          2) date.getAddDate(10, "Y")  --> 년도에 대한 상대일을 구한다.
 ****************************************************************************************/
function utlf_getAddDate(pNum, pKind){
	var rtnDate = this;
	
	if(utlf_isNull(pKind)) pKind = "D";
	
	switch(pKind){
		case "Y" : rtnDate.setFullYear(this.getFullYear() + pNum);break;
		case "M" : rtnDate.setMonth(this.getMonth() + pNum);break;
	    case "D" : rtnDate.setDate(this.getDate() + pNum);break;
		case "h" : rtnDate.setHours(this.getHours() + pNum);break;
		case "m" : rtnDate.setMinutes(this.getMinutes() + pNum);break;
		case "s" : rtnDate.setSeconds(this.getSeconds() + pNum);break;
    }
    
    return rtnDate;
}

/***********************************************************************
* 함수명		: utlf_lastDateNum
* 설  명		: 해당월의 마지막 날짜를 가져온다.
* argument		: sDate 	- yyyyMMdd 형태의 날짜
* Return Type	: integer
* 작성자		: 임준호
***********************************************************************/
function utlf_lastDateNum(sDate)
{
	var nMonth, nLastDate;

	if( utlf_isNull(sDate) )		return -1;
	
	nMonth = parseInt(sDate.substr(4,2), 10);
	if( nMonth == 1 || nMonth == 3 || nMonth == 5 || nMonth == 7  || nMonth == 8 || nMonth == 10 || nMonth == 12 )
		nLastDate = 31;
	else if( nMonth == 2 )  
	{
		if( utlf_isLeap(sDate) == true )
			nLastDate = 29;
		else
			nLastDate = 28;
	} 
	else 
		nLastDate = 30;
		
	return nLastDate;
}

/**********************************************************************************
 * 함수명      : utlf_solar2Lunar
 * 설명        : 양력을 음력으로 변환해주는 함수 (처리가능 기간  1841 - 2043년)
 * argument     : sDate ( 날짜 )( 예 : "20121122" )
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_solar2Lunar(sDate)
{
	var sMd = "31,0,31,30,31,30,31,31,30,31,30,31";
	var aMd = new Array();

	var aBaseInfo = new Array();
	var aDt = new Array();		// 매년의 음력일수를 저장할 배열 변수
	var td;					// 음력일을 계산하기 위해 양력일과의 차이를 저장할 변수
	var td1;					// 1840년까지의 날수
	var td2;					// 현재까지의 날수
	var mm;					// 임시변수
	var nLy, nLm, nLd;			// 계산된 음력 년, 월, 일을 저장할 변수
	var sLyoon;					// 현재월이 윤달임을 표시

	if( IsNull(sDate) )		return "";
	
	sY = parseInt(sDate.substr(0,4), 10);
	sM = parseInt(sDate.substr(4,2), 10);
	sD = parseInt(sDate.substr(6,2), 10);
	if( sY < 1841 || sY > 2043 )	return "";

	aBaseInfo = utlf_solarBase();
	aMd = sMd.split(",");
	if( utlf_isLeap(sDate) == true )					
		aMd[1] = 29;
	else
		aMd[1] = 28;	
	
	td1 = 672069; 				 // 672069 = 1840 * 365 + 1840/4 - 1840/100 + 1840/400 + 23  //1840년까지 날수
		
	// 1841년부터 작년까지의 날수
	td2 = (sY - 1) * 365 + parseInt((sY - 1)/4) - parseInt((sY - 1)/100) + parseInt((sY - 1)/400);
		
	// 전월까지의 날수를 더함
	for( i = 0 ; i <= sM - 2 ; i++ )
		td2 = td2 + parseInt(aMd[i]);

	// 현재일까지의 날수를 더함
	td2 = td2 + sD;

	// 양력현재일과 음력 1840년까지의 날수의 차이
	td = td2 - td1 + 1;
	
	// 1841년부터 음력날수를 계산
	for( i = 0 ; i <= sY - 1841 ; i++ )
	{
		aDt[i] = 0;
		for( j = 0 ; j <= 11 ; j++ )
		{
			switch( parseInt(aBaseInfo[i*12 + j]) )
			{
				case 1 : mm = 29;
						 break;
				case 2 : mm = 30;
						 break;				
				case 3 : mm = 58;	// 29 + 29
						 break;				
				case 4 : mm = 59;	// 29 + 30
						 break;				
				case 5 : mm = 59;	// 30 + 29
						 break;				
				case 6 : mm = 60;	// 30 + 30
						 break;				
			}
			aDt[i] = aDt[i] + mm;
		}
	}
		
	// 1840년 이후의 년도를 계산 - 현재까지의 일수에서 위에서 계산된 1841년부터의 매년 음력일수를 빼가면수 년도를 계산
	nLy = 0;
	do
	{
		td = td - aDt[nLy];
		nLy = nLy + 1;
	}
	while(td > aDt[nLy]);
	
	nLm = 0;
	sLyoon = "0";			// 현재월이 윤달임을 표시할 변수 - 기본값 평달
	do
	{
		if( parseInt(aBaseInfo[nLy*12 + nLm]) <= 2 )
		{
			mm = parseInt(aBaseInfo[nLy*12 + nLm]) + 28;
			if( td > mm )
			{
				td = td - mm;
				nLm = nLm + 1;
			}
			else
				break;
		}
		else
		{
			switch( parseInt(aBaseInfo[nLy*12 + nLm]) )
			{
				case 3 :
					m1 = 29;
					m2 = 29;
					break;
				case 4 : 
					m1 = 29;
					m2 = 30;
					break;					
				case 5 : 
					m1 = 30;
					m2 = 29;
					break;					
				case 6 : 
					m1 = 30;
					m2 = 30;
					break;					
			}

			if( td > m1 )
			{
				td = td - m1;
				if( td > m2 )
				{
					td = td - m2;
					nLm = nLm + 1;
				}
				else
				{
					sLyoon = "1";
				}
			}
			else
			{
				break;
			}
		}
	}
	while(1);
	
	nLy = nLy + 1841;
	nLm = nLm + 1;
	nLd = td;

	return sLyoon+nLy+utlf_right("0" + nLm, 2)+utlf_right("0" + nLd, 2);
}

/**********************************************************************************
 * 함수명      : utlf_lunar2Solar
 * 설명        : 음력을 양력으로 변환해주는 함수 (처리가능 기간  1841 - 2043년)
 * argument     : sDate ( 날짜 )( 예 : "20121122" )
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_lunar2Solar(sDate)
{
	var sMd = "31,0,31,30,31,30,31,31,30,31,30,31";
	var aMd = new Array();	
	var aBaseInfo = new Array();	
	
	var nLy, nLm, nLd, sLflag;		// 전해온 음력 인자값을 저장할 년, 월, 일, 윤달여부 임시변수
	var nSy, nSm, nSd;				// 계산된 양력 년, 월, 일을 저장할 변수
	var y1, m1, i, j, y2, y3;	// 임시변수	
	var leap;

	if( utlf_isNull(sDate) )			return "";
	if( sDate.length != 9 )		return "";
	
	sLflag = sDate.substr(0,1);
	nLy = parseInt(sDate.substr(1,4), 10);
	nLm = parseInt(sDate.substr(5,2), 10);
	nLd = parseInt(sDate.substr(7,2), 10);
	if( nLy < 1841 || nLy > 2043 )			return "";
	if( sLflag != "0" && sLflag != "1" )	return "";
		
	aBaseInfo = utlf_solarBase();
	aMd = sMd.split(",");
	if( utlf_isLeap(sDate.substr(1,8)) == true )					
		aMd[1] = 29;
	else
		aMd[1] = 28;	
		
	y1 = nLy - 1841;
	m1 = nLm - 1;
	leap = 0;
	if( parseInt(aBaseInfo[y1*12 + m1]) > 2 )
		leap = IsLeayYear(nLy+"0101");
	
	if( leap == 1 )
	{
		switch( parseInt(aBaseInfo[y1*12 + m1]) )
		{
			case 3 : mm = 29;
					 break;
			case 4 : mm = 30;
					 break;			
			case 5 : mm = 29;
					 break;			
			case 6 : mm = 30;
					 break;
		}
	}
	else
	{
		switch( parseInt(aBaseInfo[y1*12 + m1]) )
		{
			case 1 : mm = 29;
					 break;			
			case 2 : mm = 30;
					 break;			
			case 3 : mm = 29;
					 break;			
			case 4 : mm = 29;
					 break;			
			case 5 : mm = 30;
					 break;			
			case 6 : mm = 30;
					 break;			
		}
	}

	td = 0;
	for( i = 0 ; i <= y1 - 1 ; i++ )
	{
		for( j = 0 ; j <= 11 ; j++ )
		{
			switch( parseInt(aBaseInfo[i*12 + j]) )
			{
				case 1 : td = td + 29;
						 break;
				case 2 : td = td + 30;
						 break;				
				case 3 : td = td + 58;
						 break;				
				case 4 : td = td + 59;
						 break;				
				case 5 : td = td + 59;
						 break;				
				case 6 : td = td + 60;
						 break;				
			}
		}
	}

	for( j = 0 ; j <= m1 - 1 ; j++ )
	{
		switch( parseInt(aBaseInfo[y1*12 + j]) )
		{
			case 1 : td = td + 29;
					 break;			
			case 2 : td = td + 30;
					 break;						
			case 3 : td = td + 58;
					 break;						
			case 4 : td = td + 59;
					 break;						
			case 5 : td = td + 59;
					 break;						
			case 6 : td = td + 60;
					 break;						
		}
	}

	if( leap == 1 )
	{
		switch( parseInt(aBaseInfo[y1*12 + m1]) )
		{
			case 3 : mm = 29;
					 break;						
			case 4 : mm = 29;
					 break;						
			case 5 : mm = 30;
					 break;						
			case 6 : mm = 30;
					 break;						
		}
	}
	
	td = td + nLd + 22;
	
	if( sLflag == "1" )
	{
		switch( parseInt(aBaseInfo[y1*12 + m1]) )
		{
			case 3 : td = td + 29;
					 break;						
			case 4 : td = td + 30;
					 break;						
			case 5 : td = td + 29;
					 break;						
			case 6 : td = td + 30;
					 break;						
		}
	}
	
	y1 = 1840;
	do
	{
		y1 = y1 + 1;
		leap = utlf_isLeap(y1+"0101");

		if( leap == 1 )
			y2 = 366;
		else
			y2 = 365;

		if( td <= y2 )
			break;
			
		td = td - y2;
	}
	while(1);

	nSy = y1;
	aMd[1] = y2 - 337;
	m1 = 0;
	do
	{
		m1 = m1 + 1;
		if( td <= parseInt(aMd[m1-1]) )
			break;
		td = td - parseInt(aMd[m1-1]);
	}
	while(1);
	
	nSm = m1;
	nSd = td;
	y3 = nSy;
	td = y3 * 365 + parseInt(y3/4) - parseInt(y3/100) + parseInt(y3/400);
	for( i = 0 ; i <= nSm - 1 ; i++ )
		td = td + parseInt(aMd[i]);

	td = td + nSd;

	return y3 + utlf_right("0" + nSm, 2)+utlf_right("0" + nSd, 2);
}

/**********************************************************************************
 * 함수명      : utlf_getHolidays
 * 설명        : 양력 nYear에 해당하는 년도의 법정 공휴일(양력) List 모두 구하기
 * argument     : nYear에 ( 년도 )( 예 : 2012 )
 * return Type : Array
 * 작성자		: 임준호
**********************************************************************************/
function utlf_getHolidays(nYear)
{
	var nYear;
	var aHoliday = new Array();

	if( utlf_isNull(nYear) )		return aHoliday;
	
	/////// 음력 체크
	// 구정
	aHoliday[0] = utlf_lunar2Solar( "0" + (nYear-1) + "1230" ) + "설날";
	aHoliday[1] = utlf_addDate(aHoliday[0], 1) + "설날";
	aHoliday[2] = utlf_addDate(aHoliday[1], 1) + "설날";
	// 석가탄신일
	aHoliday[3] = utlf_lunar2Solar( "0" + nYear + "0408" ) + "석가탄신일";
	// 추석
	aHoliday[4] = utlf_lunar2Solar( "0" + nYear + "0814" ) + "추석";
	aHoliday[5] = utlf_addDate(aHoliday[4], 1) + "추석";
	aHoliday[6] = utlf_addDate(aHoliday[5], 1) + "추석";	

	/////// 양력 체크
	aHoliday[7] = nYear+"0101" + "신정";
	aHoliday[8] = nYear+"0301" + "삼일절";
	aHoliday[9] = nYear+"0505" + "어린이날";	
	aHoliday[10] = nYear+"0606" + "현충일";		
	aHoliday[11] = nYear+"0815" + "광복절";			
	aHoliday[12] = nYear+"1225" + "성탄절";			
	
	return aHoliday.sort();
}

/**********************************************************************************
 * 함수명      : utlf_solarBase
 * 설명        : 각 월별 음력 기준 정보를 처리하는 함수(처리가능 기간  1841 - 2043년)
				 단, 내부에서 사용하는 함수임   
 * argument     : 
 * return Type : Array
 * 작성자		: 임준호
*********************************************************************************
function utlf_solarBase()
{
	var kk;
	
	//1841
	kk = "1,2,4,1,1,2,1,2,1,2,2,1,";
	kk += "2,2,1,2,1,1,2,1,2,1,2,1,";
	kk += "2,2,2,1,2,1,4,1,2,1,2,1,";
	kk += "2,2,1,2,1,2,1,2,1,2,1,2,";
	kk += "1,2,1,2,2,1,2,1,2,1,2,1,";
	kk += "2,1,2,1,5,2,1,2,2,1,2,1,";
	kk += "2,1,1,2,1,2,1,2,2,2,1,2,";
	kk += "1,2,1,1,2,1,2,1,2,2,2,1,";
	kk += "2,1,2,3,2,1,2,1,2,1,2,2,";
	kk += "2,1,2,1,1,2,1,1,2,2,1,2,";
	//1851
	kk += "2,2,1,2,1,1,2,1,2,1,5,2,";
	kk += "2,1,2,2,1,1,2,1,2,1,1,2,";
	kk += "2,1,2,2,1,2,1,2,1,2,1,2,";
	kk += "1,2,1,2,1,2,5,2,1,2,1,2,";
	kk += "1,1,2,1,2,2,1,2,2,1,2,1,";
	kk += "2,1,1,2,1,2,1,2,2,2,1,2,";
	kk += "1,2,1,1,5,2,1,2,1,2,2,2,";
	kk += "1,2,1,1,2,1,1,2,2,1,2,2,";
	kk += "2,1,2,1,1,2,1,1,2,1,2,2,";
	kk += "2,1,6,1,1,2,1,1,2,1,2,2,";
	//1861
	kk += "1,2,2,1,2,1,2,1,2,1,1,2,";
	kk += "2,1,2,1,2,2,1,2,2,3,1,2,";
	kk += "1,2,2,1,2,1,2,2,1,2,1,2,";
	kk += "1,1,2,1,2,1,2,2,1,2,2,1,";
	kk += "2,1,1,2,4,1,2,2,1,2,2,1,";
	kk += "2,1,1,2,1,1,2,2,1,2,2,2,";
	kk += "1,2,1,1,2,1,1,2,1,2,2,2,";
	kk += "1,2,2,3,2,1,1,2,1,2,2,1,";
	kk += "2,2,2,1,1,2,1,1,2,1,2,1,";
	kk += "2,2,2,1,2,1,2,1,1,5,2,1,";
	//1871
	kk += "2,2,1,2,2,1,2,1,2,1,1,2,";
	kk += "1,2,1,2,2,1,2,1,2,2,1,2,";
	kk += "1,1,2,1,2,4,2,1,2,2,1,2,";
	kk += "1,1,2,1,2,1,2,1,2,2,2,1,";
	kk += "2,1,1,2,1,1,2,1,2,2,2,1,";
	kk += "2,2,1,1,5,1,2,1,2,2,1,2,";
	kk += "2,2,1,1,2,1,1,2,1,2,1,2,";
	kk += "2,2,1,2,1,2,1,1,2,1,2,1,";
	kk += "2,2,4,2,1,2,1,1,2,1,2,1,";
	kk += "2,1,2,2,1,2,2,1,2,1,1,2,";
	//1881
	kk += "1,2,1,2,1,2,5,2,2,1,2,1,";
	kk += "1,2,1,2,1,2,1,2,2,1,2,2,";
	kk += "1,1,2,1,1,2,1,2,2,2,1,2,";
	kk += "2,1,1,2,3,2,1,2,2,1,2,2,";
	kk += "2,1,1,2,1,1,2,1,2,1,2,2,";
	kk += "2,1,2,1,2,1,1,2,1,2,1,2,";
	kk += "2,2,1,5,2,1,1,2,1,2,1,2,";
	kk += "2,1,2,2,1,2,1,1,2,1,2,1,";
	kk += "2,1,2,2,1,2,1,2,1,2,1,2,";
	kk += "1,5,2,1,2,2,1,2,1,2,1,2,";
	//1891
	kk += "1,2,1,2,1,2,1,2,2,1,2,2,";
	kk += "1,1,2,1,1,5,2,2,1,2,2,2,";
	kk += "1,1,2,1,1,2,1,2,1,2,2,2,";
	kk += "1,2,1,2,1,1,2,1,2,1,2,2,";
	kk += "2,1,2,1,5,1,2,1,2,1,2,1,";
	kk += "2,2,2,1,2,1,1,2,1,2,1,2,";
	kk += "1,2,2,1,2,1,2,1,2,1,2,1,";
	kk += "2,1,5,2,2,1,2,1,2,1,2,1,";
	kk += "2,1,2,1,2,1,2,2,1,2,1,2,";
	kk += "1,2,1,1,2,1,2,5,2,2,1,2,";
	//1901
	kk += "1,2,1,1,2,1,2,1,2,2,2,1,";
	kk += "2,1,2,1,1,2,1,2,1,2,2,2,";
	kk += "1,2,1,2,3,2,1,1,2,2,1,2,";
	kk += "2,2,1,2,1,1,2,1,1,2,2,1,";
	kk += "2,2,1,2,2,1,1,2,1,2,1,2,";
	kk += "1,2,2,4,1,2,1,2,1,2,1,2,";
	kk += "1,2,1,2,1,2,2,1,2,1,2,1,";
	kk += "2,1,1,2,2,1,2,1,2,2,1,2,";
	kk += "1,5,1,2,1,2,1,2,2,2,1,2,";
	kk += "1,2,1,1,2,1,2,1,2,2,2,1,";
	//1911
	kk += "2,1,2,1,1,5,1,2,2,1,2,2,";
	kk += "2,1,2,1,1,2,1,1,2,2,1,2,";
	kk += "2,2,1,2,1,1,2,1,1,2,1,2,";
	kk += "2,2,1,2,5,1,2,1,2,1,1,2,";
	kk += "2,1,2,2,1,2,1,2,1,2,1,2,";
	kk += "1,2,1,2,1,2,2,1,2,1,2,1,";
	kk += "2,3,2,1,2,2,1,2,2,1,2,1,";
	kk += "2,1,1,2,1,2,1,2,2,2,1,2,";
	kk += "1,2,1,1,2,1,5,2,2,1,2,2,";
	kk += "1,2,1,1,2,1,1,2,2,1,2,2,";
	//1921
	kk += "2,1,2,1,1,2,1,1,2,1,2,2,";
	kk += "2,1,2,2,3,2,1,1,2,1,2,2,";
	kk += "1,2,2,1,2,1,2,1,2,1,1,2,";
	kk += "2,1,2,1,2,2,1,2,1,2,1,1,";
	kk += "2,1,2,5,2,1,2,2,1,2,1,2,";
	kk += "1,1,2,1,2,1,2,2,1,2,2,1,";
	kk += "2,1,1,2,1,2,1,2,2,1,2,2,";
	kk += "1,5,1,2,1,1,2,2,1,2,2,2,";
	kk += "1,2,1,1,2,1,1,2,1,2,2,2,";
	kk += "1,2,2,1,1,5,1,2,1,2,2,1,";
	//1931
	kk += "2,2,2,1,1,2,1,1,2,1,2,1,";
	kk += "2,2,2,1,2,1,2,1,1,2,1,2,";
	kk += "1,2,2,1,6,1,2,1,2,1,1,2,";
	kk += "1,2,1,2,2,1,2,2,1,2,1,2,";
	kk += "1,1,2,1,2,1,2,2,1,2,2,1,";
	kk += "2,1,4,1,2,1,2,1,2,2,2,1,";
	kk += "2,1,1,2,1,1,2,1,2,2,2,1,";
	kk += "2,2,1,1,2,1,4,1,2,2,1,2,";
	kk += "2,2,1,1,2,1,1,2,1,2,1,2,";
	kk += "2,2,1,2,1,2,1,1,2,1,2,1,";
	//1941
	kk += "2,2,1,2,2,4,1,1,2,1,2,1,";
	kk += "2,1,2,2,1,2,2,1,2,1,1,2,";
	kk += "1,2,1,2,1,2,2,1,2,2,1,2,";
	kk += "1,1,2,4,1,2,1,2,2,1,2,2,";
	kk += "1,1,2,1,1,2,1,2,2,2,1,2,";
	kk += "2,1,1,2,1,1,2,1,2,2,1,2,";
	kk += "2,5,1,2,1,1,2,1,2,1,2,2,";
	kk += "2,1,2,1,2,1,1,2,1,2,1,2,";
	kk += "2,2,1,2,1,2,3,2,1,2,1,2,";
	kk += "2,1,2,2,1,2,1,1,2,1,2,1,";
	//1951
	kk += "2,1,2,2,1,2,1,2,1,2,1,2,";
	kk += "1,2,1,2,4,2,1,2,1,2,1,2,";
	kk += "1,2,1,1,2,2,1,2,2,1,2,2,";
	kk += "1,1,2,1,1,2,1,2,2,1,2,2,";
	kk += "2,1,4,1,1,2,1,2,1,2,2,2,";
	kk += "1,2,1,2,1,1,2,1,2,1,2,2,";
	kk += "2,1,2,1,2,1,1,5,2,1,2,2,";
	kk += "1,2,2,1,2,1,1,2,1,2,1,2,";
	kk += "1,2,2,1,2,1,2,1,2,1,2,1,";
	kk += "2,1,2,1,2,5,2,1,2,1,2,1,";
	//1961
	kk += "2,1,2,1,2,1,2,2,1,2,1,2,";
	kk += "1,2,1,1,2,1,2,2,1,2,2,1,";
	kk += "2,1,2,3,2,1,2,1,2,2,2,1,";
	kk += "2,1,2,1,1,2,1,2,1,2,2,2,";
	kk += "1,2,1,2,1,1,2,1,1,2,2,1,";
	kk += "2,2,5,2,1,1,2,1,1,2,2,1,";
	kk += "2,2,1,2,2,1,1,2,1,2,1,2,";
	kk += "1,2,2,1,2,1,5,2,1,2,1,2,";
	kk += "1,2,1,2,1,2,2,1,2,1,2,1,";
	kk += "2,1,1,2,2,1,2,1,2,2,1,2,";
	//1971
	kk += "1,2,1,1,5,2,1,2,2,2,1,2,";
	kk += "1,2,1,1,2,1,2,1,2,2,2,1,";
	kk += "2,1,2,1,1,2,1,1,2,2,2,1,";
	kk += "2,2,1,5,1,2,1,1,2,2,1,2,";
	kk += "2,2,1,2,1,1,2,1,1,2,1,2,";
	kk += "2,2,1,2,1,2,1,5,2,1,1,2,";
	kk += "2,1,2,2,1,2,1,2,1,2,1,1,";
	kk += "2,2,1,2,1,2,2,1,2,1,2,1,";
	kk += "2,1,1,2,1,6,1,2,2,1,2,1,";
	kk += "2,1,1,2,1,2,1,2,2,1,2,2,";
	//1981
	kk += "1,2,1,1,2,1,1,2,2,1,2,2,";
	kk += "2,1,2,3,2,1,1,2,2,1,2,2,";
	kk += "2,1,2,1,1,2,1,1,2,1,2,2,";
	kk += "2,1,2,2,1,1,2,1,1,5,2,2,";
	kk += "1,2,2,1,2,1,2,1,1,2,1,2,";
	kk += "1,2,2,1,2,2,1,2,1,2,1,1,";
	kk += "2,1,2,2,1,5,2,2,1,2,1,2,";
	kk += "1,1,2,1,2,1,2,2,1,2,2,1,";
	kk += "2,1,1,2,1,2,1,2,2,1,2,2,";
	kk += "1,2,1,1,5,1,2,1,2,2,2,2,";
	//1991
	kk += "1,2,1,1,2,1,1,2,1,2,2,2,";
	kk += "1,2,2,1,1,2,1,1,2,1,2,2,";
	kk += "1,2,5,2,1,2,1,1,2,1,2,1,";
	kk += "2,2,2,1,2,1,2,1,1,2,1,2,";
	kk += "1,2,2,1,2,2,1,5,2,1,1,2,";
	kk += "1,2,1,2,2,1,2,1,2,2,1,2,";
	kk += "1,1,2,1,2,1,2,2,1,2,2,1,";
	kk += "2,1,1,2,3,2,2,1,2,2,2,1,";
	kk += "2,1,1,2,1,1,2,1,2,2,2,1,";
	kk += "2,2,1,1,2,1,1,2,1,2,2,1,";
	//2001
	kk += "2,2,2,3,2,1,1,2,1,2,1,2,";
	kk += "2,2,1,2,1,2,1,1,2,1,2,1,";
	kk += "2,2,1,2,2,1,2,1,1,2,1,2,";
	kk += "1,5,2,2,1,2,1,2,2,1,1,2,";
	kk += "1,2,1,2,1,2,2,1,2,2,1,2,";
	kk += "1,1,2,1,2,1,5,2,2,1,2,2,";
	kk += "1,1,2,1,1,2,1,2,2,2,1,2,";
	kk += "2,1,1,2,1,1,2,1,2,2,1,2,";
	kk += "2,2,1,1,5,1,2,1,2,1,2,2,";
	kk += "2,1,2,1,2,1,1,2,1,2,1,2,";
	//2011
	kk += "2,1,2,2,1,2,1,1,2,1,2,1,";
	kk += "2,1,6,2,1,2,1,1,2,1,2,1,";
	kk += "2,1,2,2,1,2,1,2,1,2,1,2,";
	kk += "1,2,1,2,1,2,1,2,5,2,1,2,";
	kk += "1,2,1,1,2,1,2,2,2,1,2,2,";
	kk += "1,1,2,1,1,2,1,2,2,1,2,2,";
	kk += "2,1,1,2,3,2,1,2,1,2,2,2,";
	kk += "1,2,1,2,1,1,2,1,2,1,2,2,";
	kk += "2,1,2,1,2,1,1,2,1,2,1,2,";
	kk += "2,1,2,5,2,1,1,2,1,2,1,2,";
	//2021
	kk += "1,2,2,1,2,1,2,1,2,1,2,1,";
	kk += "2,1,2,1,2,2,1,2,1,2,1,2,";
	kk += "1,5,2,1,2,1,2,2,1,2,1,2,";
	kk += "1,2,1,1,2,1,2,2,1,2,2,1,";
	kk += "2,1,2,1,1,5,2,1,2,2,2,1,";
	kk += "2,1,2,1,1,2,1,2,1,2,2,2,";
	kk += "1,2,1,2,1,1,2,1,1,2,2,2,";
	kk += "1,2,2,1,5,1,2,1,1,2,2,1,";
	kk += "2,2,1,2,2,1,1,2,1,1,2,2,";
	kk += "1,2,1,2,2,1,2,1,2,1,2,1,";
	//2031
	kk += "2,1,5,2,1,2,2,1,2,1,2,1,";
	kk += "2,1,1,2,1,2,2,1,2,2,1,2,";
	kk += "1,2,1,1,2,1,5,2,2,2,1,2,";
	kk += "1,2,1,1,2,1,2,1,2,2,2,1,";
	kk += "2,1,2,1,1,2,1,1,2,2,1,2,";
	kk += "2,2,1,2,1,4,1,1,2,1,2,2,";
	kk += "2,2,1,2,1,1,2,1,1,2,1,2,";
	kk += "2,2,1,2,1,2,1,2,1,1,2,1,";
	kk += "2,2,1,2,5,2,1,2,1,2,1,1,";
	kk += "2,1,2,2,1,2,2,1,2,1,2,1,";
	//2041
	kk += "2,1,1,2,1,2,2,1,2,2,1,2,";
	kk += "1,5,1,2,1,2,1,2,2,2,1,2,";
	kk += "1,2,1,1,2,1,1,2,2,1,2,2";
	
	var arr = new Array();
	arr = kk.split(",");
	
	return arr;
}
*/

/**********************************************************************************
 * 함수명      : utlf_isValidDay
 * 설명        : 날짜 정합성 체크
 * argument    : val(문자열)
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
// function utlf_isValidDay(val)
// {
// 	val = "" + val;
// 	try {
// 		var objDate = new Date(utlf_getFormat(val, "@@@@-@@-@@"));
// 		if(utlf_isNull(objDate)) return false;
// 		if(objDate.toFormatString("%Y-%m-%d") != utlf_getFormat(val, "@@@@-@@-@@")) return false;
// 	} catch(e)  {
// 	    return false;
// 	}
//     return true;
// }

/**********************************************************************************
 * 함수명      : utlf_isValidMonth
 * 설명        : 년월 정합성 체크
 * argument    : val(문자열)
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
// function utlf_isValidMonth(val)
// {
//     if (utlf_isDigit(val) != true)
//     {
//         return false;
//     }
// 
//     if (length(val.trim()) != 6)
//     {
//         return false;
//     }
//     
//     var nYear = toNumber(val.toString().substr(0,4));
//     var nMonth = toNumber(val.toString().substr(4,2));
//        
//     if(utlf_isNull(nYear)||utlf_isNull(nMonth))
//     {
// 		return false;
//     }
//     
//     if(nMonth>12||nMonth<1)
//     {
// 		return false;
//     }
//     return true;
// }

// /**********************************************************************************
//  * 함수명      : utlf_isTime (삭제 utlf_isValidateDateTime으로 대체)
//  * 설명        : 시간 정합성 체크
//  * argument    : val(문자열)
//  * return Type : Boolean
//  * 작성자		: 임준호
// **********************************************************************************/
// function utlf_isTime(val)
// {
//     if (utlf_isDigit(val) != true)
//     {
//         return false;
//     }
// 
//     if (val.trim().toString().length != 4)
//     {
//         return false;
//     }
//     
//     var nHH = toNumber(val.toString().substr(0,2));
//     var nMM = toNumber(val.toString().substr(2,2));
//        
//     if(utlf_isNull(nHH)||utlf_isNull(nMM))
//     {
// 		return false;
//     }
//     
//     if(nHH>24||nHH<1)
//     {
// 		return false;
//     }
//     
//     if(nHH>60||nHH<0)
//     {
// 		return false;
//     }
//     
//     return true;
// }

/**********************************************************************************
 * 함수명      : utlf_getEpTime
 * 설명        : 사용시간 계산
 * argument    : strLoginDate(로그인시간)
 *				 strLogoutDate(로그아웃시간)
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_getEpTime(strLoginDate, strLogoutDate)
{
    // 총사용시간
    var SecMilli = 1000;
    var MinMilli = 1000 * 60;
    var HrMilli = MinMilli * 60;
    var DyMilli = HrMilli * 24;

    var objLoginDate = new Date(strLoginDate.substr(0,4),strLoginDate.substr(4,2),strLoginDate.substr(6,2),
                                strLoginDate.substr(8,2),strLoginDate.substr(10,2),strLoginDate.substr(12,2));
    var objLogoutDate = new Date(strLogoutDate.substr(0,4),strLogoutDate.substr(4,2),strLogoutDate.substr(6,2),
                                 strLogoutDate.substr(8,2),strLogoutDate.substr(10,2),strLogoutDate.substr(12,2));
    var nDiffDate = objLogoutDate - objLoginDate;

    var nDays = parseInt(nDiffDate/DyMilli);
    var nHours = parseInt((nDiffDate/HrMilli)%24);
    var nMin = parseInt((nDiffDate/MinMilli)%60);
    var nSec = parseInt((nDiffDate/SecMilli)%60);

    var strReVal = "";
    if (nDays != 0) strReVal += nDays + "일 ";
    if (nHours != 0) strReVal += nHours + "시간 ";
    if (nMin != 0) strReVal += nMin + "분 ";
    if (nSec != 0) strReVal += nSec + "초";
    return(strReVal);
}

/**********************************************************************************
 * 함수명      : utlf_getEpTime2
 * 설명        : 시간 차
 * argument    : strStartDate(시작시간)
 *				 strEndDate(종료시간)                 
 * return Type : String
 * 작성자		: 이돈희
**********************************************************************************/
function utlf_getEpTime2(strStartDate, strEndDate)
{
    // 총사용시간
    var SecMilli = 1000;
    var MinMilli = 1000 * 60;
    var HrMilli = MinMilli * 60;
    var DyMilli = HrMilli * 24;

    var objStartDate = new Date(strStartDate.substr(0,4),strStartDate.substr(4,2),strStartDate.substr(6,2),
                                strStartDate.substr(8,2),strStartDate.substr(10,2),strStartDate.substr(12,2));
    var objEndDate = new Date(strEndDate.substr(0,4),strEndDate.substr(4,2),strEndDate.substr(6,2),
                                 strEndDate.substr(8,2),strEndDate.substr(10,2),strEndDate.substr(12,2));
    var nDiffDate = objEndDate - objStartDate;
    return(nDiffDate);
}

/**********************************************************************************
 * 함수명      : utlf_getDay
 * 설명        : 입력된 날자로부터 요일을 구함
 * argument    : strDate('yyyyMMdd' 형태로 표현된 날짜)
 * return Type : String(0-일요일 ~ 6-토요일)
 * 작성자		: 임준호
**********************************************************************************/
function utlf_getDay(strDate)
{
    var date = new Date(utlf_getFormat(strDate, "@@@@-@@-@@"));
    /*
    date.setYear(strDate.substr(0, 4));
    date.setMonth(strDate.substr(4, 2) - 1);
    date.setDate(strDate.substr(6, 2));
    */
    return date.getDay();
}

/**********************************************************************************
 * 함수명      : utlf_getDayKor
 * 설명        : 입력된 날자로부터 한글로 요일을 구함
 * argument    : strDate('yyyyMMdd' 형태로 표현된 날짜)
 * return Type : String(일, 월, 화, 수, 목, 금, 토)
 * 작성자		: 임준호
**********************************************************************************/
function utlf_getDayKor(strDate)
{
	var week = new Array["일", "월", "화", "수", "목", "금", "토"];		
	var weekDay = week[utlf_getDay(strDate)];
	return weekDay;
}

/**********************************************************************************
 * 함 수 명	: utlf_today
 * 설    명		: client pc의 오늘 날짜를 가져온다.(삭제 사용하지말것..)
 * argument		: 01. sDiv - DT: date타입으로 리턴한다. null일경우 string
 * return Type	: String
 * 작성자		: 임준호
**********************************************************************************/
// function utlf_today(sDiv){
//     var strToday = "";
//     var objDate;
//     var sFlag = "";
//     
//     objDate = new Date();
//     
//     try {
// 		if(utlf_isNull(gv_Today)) {
// 			objDate = new Date(gv_Today);
// 		}
//     }catch(e){}
//     
//     if(!utlf_isNull(sDiv)) sFlag = sDiv.toUpperCase();
//     
//     if(sFlag == "DT"){
// 		return objDate;
//     }else{
// 		return objDate.toFormatString("%Y%m%d");
//     }
// }

/**********************************************************************************
 * 함 수 명	: utlf_getDate
 * 설    명		: client pc의 현재 date정보를 가져온다.
 * argument		: 
 * return Type	: Date
 * 작성자		: 임준호
**********************************************************************************/
// function utlf_todayDt(){
// 	
//     var strToday = "";
//     var objDate;
//     
//     objDate = new Date();
//     
//     try {
// 		if(utlf_isNull(gv_Today)) {
// 			objDate = new Date(gv_Today);
// 		}
//     }catch(e){}
//     
//     return objDate;
// }


/**********************************************************************************
 * 함수명      : utlf_diffDate
 * 설명        : 두 일자간의 차이 일수 계산
 * argument     : sStartDate(yyyyMMdd형태의 From 일자) ( 예 : "20121122" )
 *              : sEndDate(yyyyMMdd형태의 To 일자) ( 예 : "20121202" )
 * return Type : Int
 * 작성자		: 임준호
**********************************************************************************/
function utlf_diffDate(sStartDate, sEndDate)
{
    sStartDate = "" + sStartDate;
    sEndDate   = "" + sEndDate;
    
    var vFromDate = new Date(parseInt(sEndDate.substring(0,4),  10), parseInt(sEndDate.substring(4,6)-1,  10), parseInt(sEndDate.substring(6,8), 10));
    var vToDate = new Date(parseInt(sStartDate.substring(0,4),  10), parseInt(sStartDate.substring(4,6)-1,  10), parseInt(sStartDate.substring(6,8), 10));

    return parseInt((vFromDate - vToDate)/(1000*60*60*24));
}

/**********************************************************************************
 * 함수명      : utlf_diffMonth
 * 설명        : 두 월간의 차이 월수 계산
 * argument     : sStartDate(yyyyMMdd형태의 From 일자) ( 예 : "20121122" )
 *              : sEndDate(yyyyMMdd형태의 To 일자) ( 예 : "20121202" )
 * return Type : Int
 * 작성자		: 임준호
**********************************************************************************/
function utlf_diffMonth(sStartDate, sEndDate)
{
	var nStartMon, nEndMon;

	nStartMon = parseInt(sStartDate.substring(0,4), 10)*12 + parseInt(sStartDate.substring(4,6)-1,  10);
	nEndMon = parseInt(sEndDate.substring(0,4), 10)*12 + parseInt(sEndDate.substring(4,6)-1,  10);

	return (nEndMon - nStartMon);
}

/**********************************************************************************
 * 함수명      : utlf_diffTime
 * 설명        : 두 시간간의 차이 계산
 * argument     : sStartTime(HHmmss형태의 From 시간) ( 예 : "20121122" )
 *              : sEndTime(HHmmss형태의 To 시간) ( 예 : "20121202" )
 *              : sType(구하고자하는 타입(시, 분, 초)) ( 예 : "HH" )
 * return Type : Int
 * 작성자		: 임준호
**********************************************************************************/
// function utlf_diffTime(sStartTime, sEndTime, sType)
// {
// 	var nReturnValue;
// 	var nFrom_HH = toNumber(sStartTime.substring(0,2));
// 	var nFrom_mm = toNumber(sStartTime.substring(2,4));
// 	var nFrom_ss = toNumber(sStartTime.substring(4,6));
// 	
// 	var nTo_HH = toNumber(sEndTime.substring(0,2));
// 	var nTo_mm = toNumber(sEndTime.substring(2,4));
// 	var nTo_ss = toNumber(sEndTime.substring(4,6));
// 	
// 	var nFromTotal_ss = (nFrom_HH*3600)+(nFrom_mm*60)+nFrom_ss;
// 	var nToTotal_ss = (nTo_HH*3600)+(nTo_mm*60)+nTo_ss;
// 	
// 	if(sType=="HH")
// 	{
// 		return (Math.floor((nToTotal_ss - nFromTotal_ss)/3600));
// 	}else if(sType=="mm")
// 	{
// 		return (Math.floor((nToTotal_ss - nFromTotal_ss)/60));
// 	}else if(sType=="ss")
// 	{
// 		return (nToTotal_ss - nFromTotal_ss);
// 	}
// }

/**********************************************************************************
 * 함수명      : utlf_getTimeInterval
 * 설명        : 두 시간의 차를 초단위로 반환
 * argument     : fromTime - 시작시간 문자열 (hhmm or hh:mm or hhmmss or hh:mm:ss)
 *              : endTime   - 종료시간 문자열 (hhmm or hh:mm or hhmmss or hh:mm:ss)
 * return Type : Number - (종료시간 - 시작시간) 를 초단위로 반환
 * 작성자		: 임준호
**********************************************************************************/
function utlf_getTimeInterval(fromTime, endTime)
{
	var arrFromTime = new Array(3);
	var arrEndTime = new Array(3);

	if(fromTime.length == 4 || fromTime.length == 6) {
		arrFromTime[0] = fromTime.substr(0, 2);
		arrFromTime[1] = fromTime.substr(2, 2);
		arrFromTime[2] = fromTime.substr(4, 2);
	} else if(fromTime.length == 5 || fromTime.length == 8) {
		arrFromTime = fromTime.split(":");
	}
	if(arrFromTime[2].length == 0) arrFromTime[2] = 0;

	if(endTime.length == 4 || endTime.length == 6) {
		arrEndTime[0] = endTime.substr(0, 2);
		arrEndTime[1] = endTime.substr(2, 2);
		arrEndTime[2] = endTime.substr(4, 2);
	} else if(endTime.length == 5 || endTime.length == 8) {
		arrEndTime = endTime.split(":");
	}
	if(arrEndTime[2].length == 0) arrEndTime[2] = 0;

	var rstFromTime = new Date(2000, 1, 1, eval(arrFromTime[0]), eval(arrFromTime[1]), eval(arrFromTime[2]), 0);
	var rstEndTime = new Date(2000, 1, 1, eval(arrEndTime[0]), eval(arrEndTime[1]), eval(arrEndTime[2]), 0);
	var diffTime = (rstEndTime - rstFromTime) / 1000;

	return diffTime;
}

/*******************************************************************************
 * 함수명		: utlf_getLastMonth
 * 설명			: 한달 전 날짜 구하는 함수.
 * argument		:
 * return Type	: 해당날짜를 리턴.
 * 주의사항	:
 * 작성자		: 임준호
 ******************************************************************************/
function utlf_getLastMonth(strDate) {
    if (strDate) {
        var date = utlf_str2Date(strDate);
        var d = (new Date(date)).addMonth(-1);
    }
    else {
		var d = (new Date).addMonth(-1);
    }

	var s = (new Date(d)).getFullYear()
		   + (((new Date(d)).getMonth() + 1) + "").padLeft(2, '0')
		   + (((new Date(d)).getDate()) + "").padLeft(2, '0');

	return (s);
}

/*******************************************************************************
 * 함수명  : utlf_getFirstDate
 * 설명 : 현재월 1일 만들기.
 * argument  :
 * return Type :
    - 해당날짜를 리턴.
 * 주의사항 :
 * 작성자		: 임준호
 ******************************************************************************/
function utlf_getFirstDate(strDate) {
    var s = "";

    if (strDate == null) {
	    s = getToday().substr(0,6) + "01";
    }
    else {
	    var date = new Date(parseInt(strDate.substr(0,4)),parseInt(strDate.substr(4,2))-1,1);
	    s = (new Date(date)).getFullYear()
	      + (((new Date(date)).getMonth()+1)+ "").padLeft(2, '0')
	      + ((new Date(date)).getDate() + "").padLeft(2, '0');

    }
	return (s);
}


/*******************************************************************************
 * 함수명  : utlf_getLastDate
 * 설명 : 현재월 마지막일 만들기.
 * argument  :
 * return Type :
    - 해당날짜를 리턴.
 * 주의사항 :
 * 작성자		: 임준호
 ******************************************************************************/
function utlf_getLastDate(strDate) {
    var s = "";
    if (strDate == null) {
	    var date = (new Date()).addMonth(1);
    }
    else {
	    var date = new Date(parseInt(strDate.substr(0,4)),parseInt(strDate.substr(4,2)),1);
    }

	date = (new Date(date)).addDate((new Date(date)).getDate()*-1);

	s = (new Date(date)).getFullYear()
	  + (((new Date(date)).getMonth() + 1) + "").padLeft(2, '0')
	  + ((new Date(date)).getDate() + "").padLeft(2, '0');

	return (s);
}

/*******************************************************************************
 * 함수명  : utlf_getOneMonthAfter
 * 설명 : 한달후 날짜 구하는 함수.
 * argument  : strDate - YYYYMMDD
 * return Type :
    - 해당날짜를 리턴.
 * 주의사항 :
 * 작성자		: 임준호
 ******************************************************************************/
function utlf_getOneMonthAfter(strDate) {
    if (strDate) {
        var date = utlf_str2Date(strDate);
        var d = (new Date(date)).addMonth(1);
    }
    else {
		var d = (new Date).addMonth(1);
    }

	var s = (new Date(d)).getFullYear()
		   + (((new Date(d)).getMonth() + 1) + "").padLeft(2, '0')
		   + (((new Date(d)).getDate()) + "").padLeft(2, '0');

	return (s);
}


/*******************************************************************************
 * 함수명  : utlf_getAddDate
 * 설명 : 지정한 숫자만큼 일(Day)을 더한다.
 * argument  :
 * return Type :
    - 해당날짜를 리턴.
 * 주의사항 :
 * 작성자		: 임준호
 ******************************************************************************/
// function utlf_getAddDate(strDate, diff) {
//     if (strDate) {
//         var date = utlf_str2Date(strDate);
//         var d = (new Date(date)).addDate(diff);
//     }
//     else {
// 		var d = (new Date).addDate(diff);
//     }
// 
// 	var s = (new Date(d)).getFullYear()
// 		   + (((new Date(d)).getMonth() + 1) + "").padLeft(2, '0')
// 		   + (((new Date(d)).getDate()) + "").padLeft(2, '0');
// 
// 	return (s);
// }


/*******************************************************************************
 * 함수명  : utlf_str2Date
 * 설명 : 문자를 Date형으로 변환.
 * argument  : inDate - YYYYMMDD
 * return Type :
    - 해당날짜를 리턴.
 * 주의사항 :
 * 작성자		: 임준호
 ******************************************************************************/
function utlf_str2Date(inDate)
{
  var date =  new Date(parseInt(inDate.substr(0,4)),parseInt(inDate.substr(4,2))-1,parseInt(inDate.substr(6,2)));
  return date;
}

/*******************************************************************************
 * 함수명  : utlf_date2Str
 * 설명 : Date형을 문자로 변환.
 * argument  :
 * return Type :
    - 해당날짜를 리턴.
 * 주의사항 :
 * 작성자		: 임준호
 ******************************************************************************/
function utlf_date2Str(inDate)
{
  return (new Date(inDate)).getFullYear()
		   + "-" +(((new Date(inDate)).getMonth() + 1) + "").padLeft(2, '0')
		   + "-" +(((new Date(inDate)).getDate()) + "").padLeft(2, '0');
}

/****************************************************************************************
 * Function			: utlf_isValidDateTime
 * Description		: 유효한 날짜, 시간 인지 점검
 * Argument			: 01.pDateString : 날짜 문자열
 *					: 02.pFormat : 아래 Syntex 참조
 *     # syntex
 *
 *       YYYY : hour in am/pm (1~12)
 *       MM   : month in year(number)
 *       MON  : month in year(text)  예) "January"
 *       DD   : day in month
 *       DAY  : day in week  예) "Sunday"
 *       HH   : hour in am/pm (1~12)
 *       hh   : hour in day (0~23)
 *       mm   : minute in hour
 *       ss   : second in minute
 *       SS   : millisecond in second
 *       a    : am/pm  예) "AM"
 *
 *     사용예> isValidDateTime("20030229", "YYYYMMDD")
 *             isValidDateTime("11:61", "hh:mm");
 *
 * return type		: Boolean - true/false
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_isValidDateTime(pDateString, pFormat)
{
	// pDateString default value SET!
	pDateString = utlf_isNull(pDateString) ? "1" : pDateString;
	
	var dt = pDateString.toDate(pFormat).getDateFormat(pFormat);

	return (pDateString == dt);
}

/****************************************************************************************
 * Function			: utlf_toDate
 * Description		: 문자열 날짜를 Date로 반환
 * Argument			: 01.pPattern - Date를 표현하고 있는 현재의 String을 pattern으로 표현한다.
 * return type		: 변환된 Date Object
 * Creator			: 임준호
 * ex				:
 * 
 *     var date = "2002-03-05".toDate("YYYY-MM-DD")
 * 
 * @param  : pPattern - Date를 표현하고 있는 현재의 String을 pattern으로 표현한다.
 * 
 *     # syntex
 *
 *       YYYY : year(4자리)
 *       YY   : year(2자리)
 *       MM   : month in year(number)
 *       DD   : day in month
 *       hh   : hour in day (0~23)
 *       mm   : minute in hour
 *       ss   : second in minute
 *       SS   : millisecond in second
 *
 *     <font color=red>주의)</font> 이 중에서 YYYY(YY), MM, DD 는 반드시 있어야 한다.
 * 
 ****************************************************************************************/
function utlf_toDate(pPattern)
{
	var index = -1;
	var year;
	var month;
	var day;
	var hour = 0;
	var min  = 0;
	var sec  = 0;
	var ms   = 0;

	if(utlf_isNull(pPattern)) pPattern = "YYYYMMDD"; 

	if ((index = pPattern.indexOf("YYYY")) == -1 ) {
		index = pPattern.indexOf("YY");
		year = "20" + this.substr(index, 2);
	} else {
		year = this.substr(index, 4);
	}
	
	index = pPattern.indexOf("MM");
	month = this.substr(index, 2);

	index = pPattern.indexOf("DD");
	day = this.substr(index, 2);
//	trace(year);
	if ((index = pPattern.indexOf("hh")) != -1 ) {
		hour = this.substr(index, 2);
	}

	if ((index = pPattern.indexOf("mm")) != -1 ) {
		min = this.substr(index, 2);
	}

	if ((index = pPattern.indexOf("ss")) != -1 ) {
		sec = this.substr(index, 2);
	}

	if ((index = pPattern.indexOf("SS")) != -1 ) {
		ms = this.substr(index, 2);
	}

	return new Date(year, month - 1, day, hour, min, sec, ms);
}

/****************************************************************************************
 * Function			: utlf_getDateFormat
 * Description		: Date type을 문자 포맷으로 바꾼다.
 * Argument			: 01.pPattern : syntex 참조
 * return type		: Pattern 형태의 문자열
 * Creator			: 임준호
 * ex				:
 *     default pattern은 "YYYYMMDD"이다.
 *
 *     함수 호출시 다음과 같이 사용한다.
 *
 *          1) getDateFormat()        --> default로 YYYYMMDD형태로 반환한다.
 *          2) getDateFormat("YYYY/MM/DD") --> pattern 형식으로 반환한다.
 *
 *     # syntex
 *
 *       YYYY : hour in am/pm (1~12)
 *       MM   : month in year(number)
 *       MON  : month in year(text)  예) "January"
 *       DD   : day in month
 *       DAY  : day in week  예) "Sunday"
 *       HH   : hour in am/pm (1~12)
 *       hh   : hour in day (0~23)
 *       mm   : minute in hour
 *       ss   : second in minute
 *       SS   : millisecond in second
 *       a    : am/pm  예) "AM"
 *
 ****************************************************************************************/
function utlf_getDateFormat(pPattern)
{
	var GLB_MONTH_IN_YEAR = new Array("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December");
	var GLB_DAY_IN_WEEK   = new Array("Sunday", "Monday", "Tuesday", "Wednesday","Thursday", "Friday", "Saturday");

    var year      = this.getFullYear();
    var month     = this.getMonth() + 1;
    var day       = this.getDate();
    var dayInWeek = this.getDay();
    var hour24    = this.getHours();
    var ampm      = (hour24 < 12) ? 0 : 1;
    var hour12    = (hour24 > 12) ? (hour24 - 12) : hour24;
    var min       = this.getMinutes();
    var sec       = this.getSeconds();
    var YYYY = "" + year;
    var YY   = YYYY.substr(2);
    var MM   = (("" + month).length == 1) ? "0" + month : "" + month;
    var MON  = GLB_MONTH_IN_YEAR[month-1];
    var DD   = (("" + day).length == 1) ? "0" + day : "" + day;
    var DAY  = GLB_DAY_IN_WEEK[dayInWeek];
    var HH   = (("" + hour12).length == 1) ? "0" + hour12 : "" + hour12;
    var hh   = (("" + hour24).length == 1) ? "0" + hour24 : "" + hour24;
    var mm   = (("" + min).length == 1) ? "0" + min : "" + min;
    var ss   = (("" + sec).length == 1) ? "0" + sec : "" + sec;
    var SS   = "" + this.getMilliseconds();
    var a    = (a == 0) ? "AM" : "PM";

    var dateStr;
    var index = -1;

    if (typeof(pPattern) == "undefined") {
    	dateStr = "YYYYMMDD";
    } else {
    	dateStr = pPattern;
    }

	dateStr = dateStr.replace(/a/g,    a);
	dateStr = dateStr.replace(/YYYY/g, YYYY);
	dateStr = dateStr.replace(/YY/g,   YY);
	dateStr = dateStr.replace(/MM/g,   MM);
	dateStr = dateStr.replace(/MON/g,  MON);
	dateStr = dateStr.replace(/DD/g,   DD);
	dateStr = dateStr.replace(/DAY/g,  DAY);
	dateStr = dateStr.replace(/hh/g,   hh);
	dateStr = dateStr.replace(/HH/g,   HH);
	dateStr = dateStr.replace(/mm/g,   mm);
	dateStr = dateStr.replace(/ss/g,   ss);
	dateStr = dateStr.replace(/SS/g,   SS);

	return dateStr;
}

/****************************************************************************************
 * Function			: utlf_getDayOfWeek
 * Description		: Kind에 해당하는 요일을 반환
 * Argument			: 01.pKind : 종류 (위 참조)
 * return type		: String - 요일 (아래 참조)
 * Creator			: 임준호
 * ex				:
 *     kind
 *           "K" or "k" : 한국어 -> 일,월,화,수,목,금,토
 *           "C" or "c" : 한자   -> 日,月,火,水,木,金,土
 *           "E" or "e" : 영어   -> Sun,Mon,Tue,Wed,Thu,Fri,Sat
 *           "N" or "n" : 숫자   -> 0,1,2,3,4,5,6
 ****************************************************************************************/
function utlf_getDayOfWeek(pKind)
{
	if(pKind.toUpperCase() == "K") {
		var week = new Array("일","월","화","수","목","금","토");
		return week[this.getDay()];
	} else if(pKind.toUpperCase() == "C") {
		var week = new Array("日","月","火","水","木","金","土");
		return week[this.getDay()];
	} else if(pKind.toUpperCase() == "E") {
		var week = new Array("Sun","Mon","Tue","Wed","Thu","Fri","Sat");
		return week[this.getDay()];
	} else if(pKind.toUpperCase() == "N") {
		return this.getDay() + "";
	}

	return "";
}

/****************************************************************************************
 * Function			: utlf_getMonthDay
 * Description		: 해당일의 마지막 일을 계산
 * Argument			: 
 * return type		: String - 마지막 일자
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getMonthDay()
{
	var year = this.getFullYear();
	var month = this.getMonth();


	with(new Date(year, month + 1, 1, 12)) {  //MM = 1 .. 12
		setDate(0);
		return getDate();
	}
}

/****************************************************************************************
 * Function			: utlf_isLeapYear
 * Description		: 윤년인지 아닌지 점검
 * Argument			: 
 * return type		: Boolean - true/false
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_isLeapYear()
{
	var yyyy = this.getFullYear();

	return (new Date(yyyy, 1, 29)).getMonth() == 1
}

/****************************************************************************************
 * Function			: utlf_getDateTime
 * Description		: 옵션에 따라 Date형을 DateTime형 String으로 변환
 * Argument			: 01.pDate : Date 객체
 *					: 02.pMode : 대소문자 구분 없음
 *							'기본' - 일자 + 시간,
 *							'D'    - 일자,
 *							'T'    - 시간,
 *							'W'    - 요일,
 *							'S'    - 시간 + 초,
 *							'A'    - 전체 + 초
 * return type		: String - "200406081415"
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getDateTime( pDate, pMode ){
	var rtnStr = null;

	sFDate = pDate.getFullYear();
	sFDate = sFDate.toString() + (( pDate.getMonth() + 1 > 9 ) ? pDate.getMonth() + 1 : "0" + (pDate.getMonth() + 1));
	sFDate = sFDate.toString() + (( pDate.getDate()      > 9 ) ? pDate.getDate() : "0" + pDate.getDate());

	sFTime = (( pDate.getHours() > 9 ) ? pDate.getHours() : "0" + pDate.getHours());
	sFTime = sFTime.toString() + (( pDate.getMinutes() > 9 ) ? pDate.getMinutes() : "0" + pDate.getMinutes());

	sFSec  = (( pDate.getSeconds() > 9 ) ? pDate.getSeconds() : "0" + pDate.getSeconds() );
	var x = new Array("일", "월", "화", "수", "목", "금", "토");
	sWeek  = x[pDate.getDay()];

	switch( pMode.toUpperCase() ){
		case 'D': // YEAR + MONTH + DATE
			rtnStr = sFDate;
			break;
		case 'T': // HOUR + MINUTE
			rtnStr = sFTime;
			break;
		case 'S': // HOUR + MINUTE + SECONDS
			rtnStr = sFTime + sFSec;
			break;
		case 'A': // YEAR + MONTH + DATE + HOUR + MINUTE + SECONDS
			rtnStr = sFDate + sFTime + sFSec;
			break;
		case 'W': // WEEK
			rtnStr = sWeek;
			break;

		default:  // YEAR + MONTH + DATE + HOUR + MINUTE
			rtnStr = sFDate + sFTime;
	}
	return rtnStr;
}

/****************************************************************************************
 * Function			: utlf_getRemoveFormatter
 * Description		: YYYY/MM/DD or YYYY-MM-DD -> YYYYMMDD 로 변환
 * Argument			: 01.pDateString - 구분자('/' or '-')가 들어간 일자 문자열
 * return type		: String - 구분자 제외한 날짜
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getRemoveFormatter(pDateString)
{
	if(pDateString.length == 10) {
		var arrDate = new Array(3);

		arrDate = pDateString.split("/");
		if(arrDate.length != 3) {
			arrDate = pDateString.split("-");
		}
		return arrDate[0] + arrDate[1] + arrDate[2];
	} else {
		return pDateString;
	}
}


/****************************************************************************************
 * Function			: utlf_getDateInterval
 * Description		: 두 일자사이의 차를 다양한 형태의 날짜 단위로 반환
 * Argument			: 01.fromDate - 시작일자 문자열 (YYYYMMDD or YYYY/MM/DD or YYYY-MM-DD)
 *					: 02.endDate  - 종료일자 문자열 (YYYYMMDD or YYYY/MM/DD or YYYY-MM-DD)
 *					: 03.format - 반환될 날짜차이 포맷(dd:일자, mm:월, yyyy:년, yyyymm:년월, mmdd:월일, yyyymmdd:년월일 / 생략시 일자 반환)
 * return type		: String - 종료일자에서 시작일자를 뺀 일자(format 이 주어진 경우 년/월/일 구분은 "/"로 표현된다.)
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getDateInterval(fromDate, endDate, format)
{
	var arrFromDate = new Array(3);
	var arrEndDate = new Array(3);
	
	fromDate = String(fromDate);
	endDate = String(endDate);
	
	if(fromDate.length == 8) {
		arrFromDate[0] = fromDate.substr(0, 4);
		arrFromDate[1] = fromDate.substr(4, 2);
		arrFromDate[2] = fromDate.substr(6, 2);
	} else if(fromDate.length == 10) {
		arrFromDate = fromDate.split("/");
		if(arrFromDate.length != 3) {
			arrFromDate = fromDate.split("-");
		}
	}

	if(endDate.length == 8) {
		arrEndDate[0] = endDate.substr(0, 4);
		arrEndDate[1] = endDate.substr(4, 2);
		arrEndDate[2] = endDate.substr(6, 2);
	} else if(endDate.length == 10) {
		arrEndDate = endDate.split("/");
		if(arrEndDate.length != 3) {
			arrEndDate = endDate.split("-");
		}
	}

	var rstFromDate = new Date(eval(arrFromDate[0]), eval(arrFromDate[1])-1, eval(arrFromDate[2]));
	var rstEndDate = new Date(eval(arrEndDate[0]), eval(arrEndDate[1])-1, eval(arrEndDate[2]));
	var rstFrom = rstFromDate.getTime();
	var rstEnd = rstEndDate.getTime();
	
	var daydue = Math.ceil((rstEnd - rstFrom) / (24 * 60 * 60 * 1000));
	var yeardue = 0;
	var monthdue = 0;

	// 일자(dd)로 반환
	if (format == null || format == "" || format.toLowerCase() == "dd") {
		return daydue;
	} else {
		format = format.toLowerCase();
	}
	
	var year = arrFromDate[0];
	var month = arrFromDate[1];
	var day = arrFromDate[2];
	
	var dayCount = 0;
	
	// 시작일자가 1일이 아닌경우
	if (day != 1) {
		month += 1;
	}
	
	do {
		if (month > 12) {
			month = 1;
			year += 1;
		}
		
		dayCount = utlf_getDayCountForMonth(year, month);
		
		if (daydue < dayCount) {
			break;
		}
		
		daydue = daydue - dayCount;
		month++;
		monthdue++;
		
		if (format == "yyyy" && daydue < 365 && (monthdue % 12) == 0) {
			break;
		}
		
	} while (true);
	
	// 년도 계산
	if (format != "mmdd" && format != "mm" && monthdue >= 12) {
		yeardue = monthdue / 12;
		monthdue = monthdue % 12;
	}
	
	var result = "";
	if (format == "yyyy") {
		result = yeardue;
	} else if (format == "mm") {
		result = monthdue;
	} else if (format == "mmdd") {
		result = monthdue + "/" + daydue;
	} else if (format == "yyyymm") {
		result = yeardue + "/" + monthdue;
	} else if (format == "yyyymmdd") {
		result = yeardue + "/" + monthdue + "/" + daydue;
	}
	
	return result;
}

/****************************************************************************************
 * Function			: utlf_getDayCountForMonth
 * Description		: 해당년의 해당 월이 몇일인지를 반환
 * Argument			: 01.year - 년도(yyyy)
 *					: 02.month - 달(mm)
 * return type		: String - 해당 년도의 해당 달이 몇일을 가지고 있는지를 반환한다.(윤년계산 포함)
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getDayCountForMonth(year, month) {
	var normal = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
	var leap = new Array(31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);

	if (utlf_isLeap(year)) {
		return leap[month - 1];
	} else {
		return normal[month - 1];
	}
}

/****************************************************************************************
 * Function			: utlf_getNewDate
 * Description		: 현재날짜 시간 서버시간으로 변경
 * Argument			: 
 * return type		: Date
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getNewDate(){
	
	var rtnDate = new Date();
	var timediff = sysf_getGlobalVariable("timediff");
	var serverInterval = 0;
	
	if(!utlf_isNull(timediff)){
		serverInterval = parseInt(timediff);			
	}

	rtnDate.setTime(rtnDate.getTime() + serverInterval);

	return rtnDate;
}

/****************************************************************************************
 * Function			: utlf_getCurrentDate
 * Description		: 현재날짜 반환
 * Argument			: 
 * return type		: String - YYYYMMDD
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getCurrentDate()
{
	    var sDate = utlf_getNewDate();

		rtnDate = sDate.getFullYear();
		rtnDate = rtnDate.toString() + (( sDate.getMonth() + 1 > 9 ) ? sDate.getMonth() + 1 : "0" + (sDate.getMonth() + 1));
		rtnDate = rtnDate.toString() + (( sDate.getDate()      > 9 ) ? sDate.getDate() : "0" + sDate.getDate()) ;

		return rtnDate;
}

/****************************************************************************************
 * Function			: utlf_getCurrentTime
 * Description		: 현재 시간 반환
 * Argument			: 
 * return type		: String - hhmmssSS
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getCurrentTime()
{
	    var sDate = utlf_getNewDate();

		rtnTime = (( sDate.getHours() > 9 ) ? sDate.getHours() : "0" + sDate.getHours());
		rtnTime = rtnTime.toString() + (( sDate.getMinutes() > 9 ) ? sDate.getMinutes() : "0" + sDate.getMinutes());
        rtnTime = rtnTime.toString() + (( sDate.getSeconds() > 9 ) ? sDate.getSeconds() : "0" + sDate.getSeconds());
		
		return rtnTime;
}

/****************************************************************************************
 * Function			: utlf_getCurrentDateTime
 * Description		: 현재날짜 시간 반환
 * Argument			: 
 * return type		: String - YYYYMMDD HHMMSS
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getCurrentDateTime(){
	return utlf_getCurrentDate() + " " + utlf_getCurrentTime();
}

/****************************************************************************************
 * Function			: utlf_getCurrentWeek
 * Description		: 현재 요일 반환
 * Argument			: 01.flag - 한글(K) or 숫자
 * return type		: String - 0, 1, 2.....or 일, 월, 화......
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getCurrentWeek(flag)
{
	    var sDate = utlf_getNewDate();

		sWeek = new Array("일", "월", "화", "수", "목", "금", "토");

		rtnWeek = (flag == "K") ? sWeek[sDate.getDay()] : sDate.getDay();

		return rtnWeek;
}

/****************************************************************************************
 * Function			: urlf_getStrDate
 * Description		: 스트링형태의 날짜데이터 반환
 * Argument			: 01.strDate - 문자열형태 날짜데이터
 * return type		: String - 패턴
 * Creator			: 임준호
 ****************************************************************************************/
function urlf_getStrDate(sDate){
    
    var strYear = "";
    var strMonth = "";
    var strDay = "";
    var strHour = "";
    var strMin = "";
    var strSec = "";
    
    if (sDate.length < 14) {
        alert("데이터는 14자리 이상이어야 합니다.");
        return null;
    }
    
    strYear = sDate.substr(0, 4);
    strMonth = sDate.substr(4, 2);
    strDay = sDate.substr(6, 2);
    strHour = sDate.substr(8, 2);
    strMin = sDate.substr(10, 2);
    strSec = sDate.substr(12, 2);
    
    sDate = strYear + "-";
    sDate += strMonth + "-";
    sDate += strDay + " ";
    sDate += strHour + ":";
    sDate += strMin + ":";
    sDate += strSec;
    
    return sDate;
}

/****************************************************************************************
 * Function			: utlf_getYear
 * Description		: 현재 년도 반환
 * Argument			: 
 * return type		: String - YYYY
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getYear(){
	
	var sDate = utlf_getNewDate();
	return sDate.getFullYear();
}

/****************************************************************************************
 * Function			: utlf_getMonth
 * Description		: 현재 월 반환
 * Argument			: 
 * return type		: String - MM
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getMonth(){
	
	var sDate = utlf_getNewDate();
	return ((sDate.getMonth() + 1 > 9 ) ? sDate.getMonth() + 1 : "0" + (sDate.getMonth() + 1));
}

/****************************************************************************************
 * Function			: utlf_getDate
 * Description		: 현재 일 반환
 * Argument			: 
 * return type		: String - DD
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getDate(){
	
	var sDate = utlf_getNewDate();
	return ((sDate.getDate() > 9 ) ? sDate.getDate() : "0" + sDate.getDate()) ;
}



/********************************************************************************************************************/
/************************* 주민등록/사업자번호/법인번호/이메일주소 체크관련 함수 *****************************/
/********************************************************************************************************************/

/**********************************************************************************
 * 함수명     : utlf_getSex
 * 설명       : 주민번호로 성별을 Return 한다.
 * argument    : strRsrno (주민번호)
 * return Type : String (남자-'M' 여자-'F')
 * 작성자		: 임준호
 **********************************************************************************/
function utlf_getSex(strRsrno)
{
    if (!(utlf_isRsrNo(strRsrno)))
        return false;

    var vSexGb = strRsrno.substr(6,1);

    if (vSexGb == '1' || vSexGb == '3' || vSexGb == '5' || vSexGb == '7') {
        return "M";
    } else if (vSexGb == '2' || vSexGb == '4' || vSexGb == '6' || vSexGb == '8') {
        return "F";
    } else {
        return "X";
    }
}

/**********************************************************************************
 * 함수명      : utlf_isCompRegNo
 * 설명        : 사업자 등록번호 확인
 * argument    : sValue ( 사업자 등록 번호 )
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
function utlf_isCompRegNo(sValue)
{
	if( utlf_isNull(sValue) )	return false;
	
    var vCompNo = sValue.replace("-", "");
	var checkID = new Array(1, 3, 7, 1, 3, 7, 1, 3, 5, 1);
	var i, Sum=0, c2, remander;
	
	if (vCompNo.length != 10) 
		return false; 
	
	for (i = 0; i <= 7; i++) 
		Sum += checkID[i] * vCompNo.charAt(i);

	c2 = "0" + (checkID[8] * vCompNo.charAt(8));
	c2 = c2.substring(c2.length - 2, c2.length);

	Sum += Math.floor(c2.charAt(0)) + Math.floor(c2.charAt(1));

	remander = (10 - (Sum % 10)) % 10;

	if (Math.floor(vCompNo.charAt(9)) != remander) 
		return false;
	return true;
}

/**********************************************************************************
 * 함수명      : utlf_isCorpRegNo
 * 설명        : 법인 등록번호 확인
 * argument    : sValue ( 법인 등록 번호 )
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
function utlf_isCorpRegNo(sValue)
{
	if( utlf_IsNull(sValue) )	return false;
	
	var vCorpNo = sValue.replace("-", "");
	var checkID = new Array(1,2,1,2,1,2,1,2,1,2,1,2);
	var i, Sum=0, c2, remander;
	
	if (vCorpNo.length != 13) 
		return false; 
	
	for (i = 0; i <= 12; i++) 
		Sum += checkID[i] * vCorpNo.charAt(i);
	
	remander = Sum / 10;
	var nIndex = remander.toString().indexOf(".");
	remander = remander.toString().substring(nIndex+1,nIndex+2);
	remander = 10 - remander; 
	
	if (remander > 9 ) 
		remander = 0;
	if (remander == sValue.substring(12, 13)) 
		return true;

	return false
}

/**********************************************************************************
 * 함수명      : utlf_isRsrNo
 * 설명        : 주민 등록번호 확인
 * argument    : val ( 주민등록번호 )
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
function utlf_isRsrNo(val)
{
	var tmp1, tmp2, tmp3;		
	var sum = 0;
	var result = 0;
	
	val = val.replace("-", ""); 
 	
	if(val.length != 13 ) return false;	// 13자리인지 체크
		
	tmp1 = val.substr( 2, 2 );
	tmp2 = val.substr( 4, 2 );
	tmp3 = val.substr( 6, 1 );
	
	
	var j = Array(12);
	j = [2,3,4,5,6,7,8,9,2,3,4,5];
	for(var i=0; i<12; i++)
	{
		sum += 1 * val.substr(i, 1) * j[i];
	}	
	
	if ( (tmp1 < "01") || (tmp1 > "12") ) return false;
	if ( (tmp2 < "01") || (tmp2 > "31") ) return false;
	if ( (tmp3 < "1" ) || (tmp3 > "4" ) ) return false;
	
	result = (1 * sum) % 11;
	result = (11 - result) % 10;
	
	if (result == val.substr( 12, 1 )) {
		return true;
	} else {
		return false;
	}
}

/**********************************************************************************
 * 함수명      : utlf_isEmail
 * 설명        : Email 적합여부 확인
 * argument    : sValue (예 : "oju@yahoo.co.kr" )
 * return Type : Boolean
 * 작성자		: 임준호
**********************************************************************************/
function utlf_isEmail(sValue)
{   
	var vChk = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890-._@";
	var i, pos, vEmailFirst, vEmailLast;
	
	if( utlf_isNull(sValue) )	return false;
	
	for( i = 0 ; i < sValue.length ; i++)
	{
		if(vChk.indexOf(sValue.charAt(i)) < 0) 
			return false;
    }
    pos = utlf_pos(sValue,"@");
    if( pos < 0 )
		return false;
		
	vEmailFirst = sValue.substr(0, pos);
	vEmailLast = sValue.substr(pos+1);
	if( vEmailFirst.length <= 0 || vEmailLast.length <= 0 )
		return false;
	if( utlf_pos(vEmailLast, ".") <= 0 || utlf_pos(vEmailLast, "..") >= 0 || utlf_right(vEmailLast,1) == "." )
		return false;
	if( utlf_pos(vEmailLast, "@") >= 0 )
		return false;
		
    return true;
}

/**********************************************************************************
 * 함수명      : utlf_getBefo
 * 설명        : 주민번호 뒷 첫번째 자리로 년대를 return 한다.
 * argument    : strRsrno (주민등록번호)
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_getBefo(strRsrno)
{
    if (!utlf_isRsrNo(strRsrno))
        return 'N';

    var vGb = strRsrno.substr(6,1);

    if (vGb == '1' || vGb == '2' || vGb == '5' || vGb == '6')
    {
        return '19';
    }
    else if (vGb == '3' || vGb == '4' || vGb == '7' || vGb == '8')
    {
        return '20';
    }
}

/**********************************************************************************
 * 함수명      : utlf_getAge
 * 설명        : 법적연령-만나이를 구한다
 * argument    : sValue (생년월일 또는 주민등록번호)
 * 				 sDate (기준일자)
 * return Type : String
 * 작성자		: 임준호
**********************************************************************************/
function utlf_getAge(sValue, sDate)
{
    var vYear;
    var vMonth;
    var vDay;
	
	if ((sValue).trim().length == 13)
    {
        var vBefor = utlf_getBefo(sValue);
        if (vBefor=="N") return false;

        sValue = vBefor + sValue;
        vYear = parseInt(sValue.substr(0,4),10);
        vMonth = parseInt(sValue.substr(4,2),10);
        vDay =   parseInt(sValue.substr(6,2),10);
    }
    else if ((sValue).trim().length == 8)
    {
        vYear = parseInt(sValue.substr(0,4),10);
        vMonth = parseInt(sValue.substr(4,2),10);
        vDay =   parseInt(sValue.substr(6,2),10);

        if (!utlf_isValidDateTime(sValue, "YYYYMMDD"))
            return false;
    }
    else
    {
        return false;
    }

    var vCurrentSystemDate;

    if (utlf_isValidDateTime(sDate, "YYYYMMDD") == true) {
        vCurrentSystemDate = sDate;
    } else if (utlf_transNullToEmpty(sDate) != "") {
        return false;
    }

    var vCurrentSystemYear = parseInt(vCurrentSystemDate.substr(0,4),10);
    var vCurrentSystemMonth = parseInt(vCurrentSystemDate.substr(4,2),10);
    var vCurrentSystemDay = parseInt(vCurrentSystemDate.substr(6,2),10);
    var vAge = vCurrentSystemYear - vYear;

    if (vMonth > vCurrentSystemMonth) {
        vAge = vAge - 1;
    } else if (vMonth == vCurrentSystemMonth) {
        if (vDay > vCurrentSystemDay) {
            vAge = vAge - 1;
        }
    }

    if (vAge < 0) {
        vAge = 0;
    }

    return vAge;
}

/****************************************************************************************
 * Function			: utlf_getFullAge
 * Description		: 현재일자를 기준으로 나이계산
 * Argument			: 01.pResidentNo	: 중간 구분자를 제외한 주민번호 13자리
 *					: 02.pDate	: 기준이 되는 Date Object 일자 (default는 오늘 일자)
 *					: 03.pPosition : 1세이하시 개월 계산
 * return type		: Number - (오류시-1)
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_getFullAge(pResidentNo, pDate, pPosition)
{
	if(utlf_isNull(pResidentNo)) return -1;

	var pivotYY = "";
	var pivotMM = "";
	var pivotDD = "";
	var regYY = "";
	var regMM = "";
	var regDD = "";

	if(typeof(pDate) == "undefined" || pDate == "" || pDate == null) {
		var today = new Date();
		pivotYY = today.getYear();
		pivotMM = today.getMonth() + 1;
		pivotDD = today.getDate();
	} else {
		pivotYY = pDate.getYear();
		pivotMM = pDate.getMonth() + 1;
		pivotDD = pDate.getDate();
	}

	if(pResidentNo.length == 13 && utlf_isRsrNo(pResidentNo)){
		gender = pResidentNo.substr(6, 1);
		regYY = eval(pResidentNo.substr(0, 2));
		regMM = eval(pResidentNo.substr(2, 2));
		regDD = eval(pResidentNo.substr(4, 2));

		if(gender == '3' || gender == '4' || gender == '7' || gender == '8') {
			regYY += 2000;
		} else if(gender == '0' || gender == '9') {
			regYY += 1800;
		} else {
			regYY += 1900;
		}
	}else if(pResidentNo.length == 8 && utlf_isValidDateTime(pResidentNo, "YYYYMMDD")){ 
		regYY = eval(pResidentNo.substr(0, 4));
		regMM = eval(pResidentNo.substr(4, 2));
		regDD = eval(pResidentNo.substr(6, 2));
	}else{
		return -1;
	}

	var age = pivotYY - regYY;

	if(age > 0) {
		if(pivotMM == regMM) {
			if(pivotDD < regDD) {
				age -= 1;
			}
		} else if(pivotMM < regMM) {
			age -= 1;
		}
	}
	
	if ( pPosition == "M")
	{
		//12개월이하일때 계산
		if(age <= 0){
			if(pivotYY > regYY) {
				pivotMM += 12;
			}
			age = pivotMM - regMM ;
			if(pivotDD < regDD) {
				age -= 1;
			}
			age = "0."+age;
		}
	}

	return age;
}

/****************************************************************************************
 * Function			: utlf_isForegnResidentNo
 * Description		: 외국인 주민등록번호에 대한 검증을 수행
 * Argument			: 01.pResidentNo	: 외국인 주민등록번호
 * return type		: Boolean
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_isForegnResidentNo(pResidentNo) {

    var sum = 0;
    var odd = 0;
    
    buf = new Array(13);
    for (i = 0; i < 13; i++) {
        buf[i] = parseInt(pResidentNo.charAt(i));        
    }
    			
    odd = buf[7]*10 + buf[8];
    
    //기관번호 검사, 기관번호를 2로 나눈 경우, 나머지 있는 경우, 주민등록번호 무효
    if (odd%2 != 0) {
   	    return false;
    }

    //등록자구분이 아래와 같지 않은 경우 오류
    // 6 : ??
    // 7 : 외국국적동포
    // 8 : 재외국인
    // 9 : 순수외국인
    // 2012년 외국인등록번호 11번째 자리가 위와같이 체크되는것에서 일련번호로 변경됨
    // 7번째 자리를 외국인 성별로 사용함으로, 로직 변경 20200106
    if ((buf[6] != 5)&&(buf[6] != 6)&&(buf[6] != 7)&&(buf[6] != 8)) {
   	    return false;
    }
    
    //주민번호 13자리 중 12자리를 처음부터 12자리까지 배열값의 순서대로 곱한 후 합계를 낸다.
    //Total = (A * 2) + (B * 3) + (C * 4) + (D * 5) + (E * 6) + (F * 7)
    //      + (G * 8) + (H * 9) + (I * 2) + (J * 3) + (K * 4) + (L * 5)
    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;
    }
}


/****************************************************************************************
 * Function			: utlf_getGender
 * Description		: 주민번호로 성별을 리턴한다.
 * Argument			: 01.pResidentNo	: 주민등록번호
 * return type		: M/F
 * Creator			: tobesoft
 ****************************************************************************************/
// function utlf_getGender(pResidentNo)
// {
// 
// 	if(pResidentNo.length != 13 && pResidentNo.length != 7) return false;
// 
// 	var rrns = 0;
// 
// 	if(pResidentNo.length == 13) {
// 		rrns = eval(pResidentNo.substr(6, 1));
// 	} else {
// 		rrns = eval(pResidentNo.substr(0, 1));
// 	}
// 
// 	return (rrns % 2) ? "M" : "F";
// }

/********************************************************************************************************************/
/************************* 기타 ************************************************************************************/
/********************************************************************************************************************/

/**********************************************************************************
 * 함수명		: utlf_getRandomSubmitUUID
 * 설명			: uuid 생성
 * argument		: 
 * return Type	: String - uuid
 * 작성자		: 임준호
**********************************************************************************/
function utlf_getRandomSubmitUUID(){
    var s = [], itoh = ['0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'];

    // Make array of random hex digits. The uuid only has 32 digits in it, but we
    // allocate an extra items to make room for the '-'s we'll be inserting.
    for (var i = 0; i <36; i++) {
        s[i] = Math.floor(Math.random()*0x10);
    }

    // Conform to RFC-4122, section 4.4
    s[14] = 4;  // Set 4 high bits of time_high field to version
    s[19] = (s[19] & 0x3) | 0x8;  // Specify 2 high bits of clock sequence

    // Convert to hex chars
    for (var i = 0; i <36; i++) {
        s[i] = itoh[s[i]];
    }

    // Insert '-'s
    // s[8] = s[13] = s[18] = s[23] = '-';

    return s.join('');
}

/****************************************************************************************
 * Function			: utlf_isTelephoneZoneNo
 * Description		: 올바른 DDD번호인지 점검 (필요할까?)
 * Argument			: 01.pDDD	: DDD 번호 문자열 혹은 숫자
 * return type		: Boolean - true/false
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_isTelephoneZoneNo(pDDD)
{
	//pDDD 숫자 점검 logic 필요

	var strDDD = pDDD + "";

	if( strDDD != "02" &&
		strDDD != "031" &&
		strDDD != "032" &&
		strDDD != "033" &&
		strDDD != "041" &&
		strDDD != "042" &&
		strDDD != "043" &&
		strDDD != "051" &&
		strDDD != "052" &&
		strDDD != "053" &&
		strDDD != "054" &&
		strDDD != "055" &&
		strDDD != "061" &&
		strDDD != "062" &&
		strDDD != "063" &&
		strDDD != "064" ) return false;

	return true;
}

/****************************************************************************************
 * Function			: utlf_transBase64ToImg
 * Description		: base64로 인코딩된 이미지를 imageViewer에 출력
 * Argument			: 01.objImg	: imageViewer object
 *					: 02.sImgData : base64 인코딩 문자열
 * return type		: Boolean - true/false 성공여부
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_transBase64ToImg(objImg, sImgData){
	
	var objImage = new Image;
	var ExtObj = new ExtCommon();
	
	var objDebase64 = ExtObj.decodeBase64(sImgData, "OBJ");
	var objBuff = new Buffer(objDebase64);
	var bSucc = objImage.setBinary(objBuff.data);
	
	if(bSucc){
		objImg.image = objImage;
	}
	
	return bSucc;
}

/****************************************************************************************
 * Function			: utlf_transBase64ToBin
 * Description		: base64로 인코딩된 이미지를 binary로 변환
 * Argument			: 01.sImgData : base64 인코딩 문자열
 * return type		: object - 이미지 binary
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_transBase64ToBin(sImgData){
	
	var ExtObj = new ExtCommon();
	var objDebase64 = ExtObj.decodeBase64(sImgData, "OBJ");
	var objBuff = new Buffer(objDebase64);
	
	return objBuff.data;
}

/****************************************************************************************
 * Function			: utlf_saveToImageBinary
 * Description		: imageViewer의 이미지를 binary로 변환
 * Argument			: 01.objImg	: imageViewer object
 * return type		: object - 이미지 binary
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_saveToImageBinary(objImg:ImageViewer){
	var objImage = objImg.saveToImageObject();
	if(!utlf_isNull(objImage)){
		return objImage.getBinary();
	}else{
		return null;
	}
}

/****************************************************************************************
 * Function			: utlf_transFileToImg
 * Description		: 첨부파일(이미지)을 imageViewer에 출력
 * Argument			: 01.objImg	: imageViewer object
 *					: 02.objFile : 첨부파일 데이타
 * return type		: Boolean - true/false 성공여부
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_transFileToImg(objImg:ImageViewer, objFile){
	
	var objBuf = new Buffer(objFile);
	var objImage = new Image;
	var bSucc = objImage.setBinary(objBuf.data);
	
	if(bSucc){
		objImg.image = objImage;
	}
	
	return bSucc;
}

/****************************************************************************************
 * Function			: utlf_screenToImage
 * Description		: 화면을 캡쳐한다.
 * Argument			: 01.sScope - 캡쳐 영역 (this:현재화면, all:전체(default), top:상단, work:업무, bottom:하단)
 *					: 02.bPreview - 미리보기 여부 default - true
 * return type		: Boolean - true/false 성공여부
 * Creator			: 임준호
 ****************************************************************************************/
function utlf_screenToImage(sScope, bPreview){
	
	var sFileName = sysf_getUserId()+"_"+utlf_getCurrentDate()+utlf_getCurrentTime();
	
	var objFd = new FileDialog;
	var objVFile = objFd.open("FileSave", FileDialog.SAVE, "%MYDOCUMENT%", sFileName+".png");
	var bSucc = false;
	
	if(utlf_isNull(sScope))	sScope = "this";
	if(utlf_isNull(bPreview))	bPreview = true;
	
	if(sScope == "all"){
		bSucc = application.mainframe.saveToImage(objVFile.fullpath,"PNG");
	}else if(sScope == "top"){
		bSucc = agv_objAppTopPath.form.saveToImage(objVFile.fullpath,"PNG");
	}else if(sScope == "work"){
		bSucc = agv_objAppWorkPath.form.saveToImage(objVFile.fullpath,"PNG");
	}else if(sScope == "bottom"){
		bSucc = agv_objAppBottomPath.form.saveToImage(objVFile.fullpath,"PNG");
	}else if(sScope == "this"){
		bSucc = this.saveToImage(objVFile.fullpath,"PNG");
	}
	
	if(bSucc && bPreview){
		system.execShell(objVFile.fullpath);
	}
	
	return bSucc;
}

/****************************************************************************************
 * Function			: utlf_setFormat
 * Description		: 입력 값에 format을 적용하여 리턴
 * Argument			: value 입력 값
                      format 적용할 포맷 형식
 * return type		:
 * Creator			: 김상목
 ****************************************************************************************/
function utlf_setFormat(value, format){
	var str = value.toString();
	
	if(format == "#,###") {
		var num = parseFloat(str);
		if( isNaN(num) ) return "0";
	 
		if(str == "0") return 0;
	 
		var reg = /(^[+-]?\d+)(\d{3})/;
		var n = (str + '');
	 
		while (reg.test(n)) n = n.replace(reg, '$1' + ',' + '$2');
	 
		return n;
    } else {					// "#.#"
		if(utlf_isNull(format)) return str;
		
		var num = parseFloat(str);		
		var temp = format.split('.');
		return num.toFixed(temp[1].length);
    }
};

/****************************************************************************************
 * Function			: utlf_setAsterisk
 * Description		: 입력 값에 표시할 문자열의 길이 만큼만 보여주고 나머지는 *처리 해서 보여준다.
 * Argument			: str 입력 값
                      length 표시할 문자열의 길이
 * return type		: expr에 표현 될 형식
 * 예시            : expr:utlf_setAsterisk(mpphonno, 5)
 * Creator			: 김상목
 ****************************************************************************************/
function utlf_setAsterisk(str, length) {
	if(utlf_isNull(str)) return "";

	var text = str.toString();	
	var asteriskCnt = text.length - length;

	if(asteriskCnt <= 0) return "";
	
	var result = "";
	
	for(var i = 0; i < length; i++) {
		result += '@';
	}
	
	result += '{';
	
	for(var i = 0; i < asteriskCnt; i++) {
		result += '@';
	}
	
	result += '}';

	return result;
}

/****************************************************************************************
 * Function			: utlf_getNumberFromString
 * Description		: 문자열에서 숫자값만 추출
 * Argument			: str 입력 값
 * return type		: 숫자값
 * 예시            : expr:utlf_getNumberFromString("010-1234-5678")
 * Creator			: 김상목
 ****************************************************************************************/
 function utlf_getNumberFromString(str) {
	if(utlf_isNull(str)) return "";
	if(typeof str != "string") return "";
	
	return str = str.replace(/[^0-9]/g, "");
 }

/****************************************************************************************
 * Function			: HashArray
 * Description		: 해시 배열을 만들거나 값을 리턴한다(리턴할 때 삭제)
 * Argument			: 01.push (key : 해시키, val : 해시값)
 *					: 02.pop (key : 해시키)
 * return type		: 
 * Creator			: 김상목
 ****************************************************************************************/
function HashArray() {
	var hash = new Array();
	
	this.push = function (key, val) {
		hash[key] = val;
	}
	
	this.pop = function (key) {
		var rtnVal = hash[key];
		delete hash[key];
		return rtnVal;
	}
}

/****************************************************************************************
 * Function			: SortArray
 * Description		: 그리드의 정열을 순서대로 넘기는 값을 리턴해준다.
 * Argument			: 
 * return type		:
 * Creator			: 김상목
 ****************************************************************************************/
function SortArray() {
	var sort = [[0, 'N'],
				[1, '+'],
				[2, '-']];
	var index = 0;
	
	this.getNext = function() {
		index++;
		if(index >= sort.length)
			index = 0;
		return sort[index][1];
	}
}

function utlf_addLog(strLog) {
	if(utlf_isNull(agv_objAppTopPath)) return;
	
	var oDiv_log = agv_objAppTopPath.form.components["div_log"];
	
	if(!utlf_isNull(oDiv_log) && oDiv_log.chk_log.value == true)
		gv_LogData += (new Date()).getDateFormat("YYYY/MM/DD hh시 mm분 ss초 SS") + " : " + strLog + "\n";
}

function utlf_printLog() {
	sysf_trace("========================= LogData 시작 =========================");
	sysf_trace(gv_LogData);
	sysf_trace("========================= LogData 끝   =========================");
	
	utlf_clearLog();	// 한번 출력 후에는 지운다.
}

function utlf_clearLog() {
	gv_LogData = "";
}

/****************************************************************************************
 * Function			: utlf_getEllipsisText
 * Description		: 실제 컨트롤과 글자 길이에 따라 '...'을 붙혀서 값을 반환해준다.
 * Argument			: 
 * return type		:
 * Creator			: 김상목
 ****************************************************************************************/
function utlf_getEllipsisText(ctrlObj, inputText) {
	var text = inputText;
	var result = text;

	if(utlf_isNull(text)) {
		result = "";	
	} else {
		var font = ctrlObj.currentstyle.font;
		if(utlf_isNull(font)) {
			result = "";
		} else {
			var fontStyle = font.toString().split(',');
			var bold = false;
			if(fontStyle.length > 2 && fontStyle[2] == "bold") bold = true;				
			
			var objFont = utlf_getObjFont(fontStyle[1], fontStyle[0], bold);	// 실제 폰트의 너비
			var objFontSize = utlf_getTextSize(text, objFont);
			var width = ctrlObj.position.width					// 실제 글자가 들어갈 수 있는 영역 너비(width - padding 좌우영역)
						- (utlf_isNull(ctrlObj.currentstyle.padding) ? 0 : ctrlObj.currentstyle.padding.left + ctrlObj.currentstyle.padding.right);
			var index = text.length;

			if(objFontSize.cx > width) {
				var first = 0;
				var last = text.length - 1;
				var mid = 0;
				var textSize;
				
				while(first <= last) {
					mid = parseInt((first + last) / 2);				
					textSize = utlf_getTextSize(text.substring(0, mid) + "...", objFont);
					
					if(width == textSize.cx) {
						break;
					} else {
						if(textSize.cx < width)
							first = mid + 1;
						else
							last = mid - 1;
					}
				}
				
				if(textSize.cx > width)	// 글자가 걸쳐 있는 경우 인덱스 하나를 더 빼준다.
					mid -= 1;
				
				if(mid > 0)
					result = text.substring(0, mid) + "...";
			}
		}
	}
	
	return result;
}

//바코드 폰트를 등록한다.
function utlf_installBarcodeFont(fontNm){
	var objActiveX = new ActiveX("LiveUtilOCX", 0, 0, 0, 0); 	
 	objActiveX.progid  = "{7b1f53ab-6137-4773-88cc-53a46af2d289}";
 	objActiveX.FontPath = "C:\\himed\\components\\HIT\\LiveUtil"; 	
 	this.addChild("LiveUtilOCX", objActiveX);
 	objActiveX.show(); 	
 	objActiveX.visible = false;
 	
	if (fontNm == null || fontNm == "") {
		fontNm = "FREE3OF9.TTF";
	}
	
	objActiveX.InstallFont(fontNm);
}

//속도체크를 위한 함수 추가 (2015.08.31. beshon)


function utlf_startLogCheck(logickind) {
	
	if(agv_objAppTopPath.form.arryStartLogTime == null) agv_objAppTopPath.form.arryStartLogTime = new Array();
	
	if(agv_objAppTopPath.form.arryStartLogTime[logickind] != null && agv_objAppTopPath.form.arryStartLogTime[logickind] != undefined)
		delete agv_objAppTopPath.form.arryStartLogTime[logickind];
	
	agv_objAppTopPath.form.arryStartLogTime[logickind] = new Date().getTime();	
	
	
}

function utlf_endLogCheck(logickind, logdata) {
	if(agv_objAppTopPath.form.arryStartLogTime == null || agv_objAppTopPath.form.arryStartLogTime[logickind] == null || agv_objAppTopPath.form.arryStartLogTime[logickind] == undefined)
		return;
	
	var elapsedTime = new Date().getTime() - agv_objAppTopPath.form.arryStartLogTime[logickind];
	
	/*
	model.makeValue("/root/hidden/temp/logcheck/logickind",   logickind);
	model.makeValue("/root/hidden/temp/logcheck/elapsedTime", elapsedTime);
	
	if(logdata != null && logdata != undefined) {
		var rowdata = logdata.split('|');
		
		for(var i = 0; i < rowdata.length; i++) {
			model.makeValue("/root/hidden/temp/logcheck/data" + i, rowdata[i]);
		}
	}
	
	// <submission id="TRZHM00500" mediatype="application/x-www-form-urlencoded" method="post" ref="/root/hidden/temp/logcheck" resultref="/root/temp"/>
	submit ("TRZHM00500", false);	// submission 선언은 상태메시지 창에 있음
	
	model.removeNodeset("/root/hidden/temp/logcheck");
	*/
	
	var sInDsName = dsf_createDsRow("in_ds_searchLogCheck"
	                                , [{col: "logickind",  val: logickind}
							        ,  {col: "elapsedTime",    val: elapsedTime}
							        ]);
    
    if(logdata != null && logdata != undefined) {
		var rowdata = logdata.split('|');
		
		for(var i = 0; i < rowdata.length; i++) {
			//model.makeValue("/root/hidden/temp/logcheck/data" + i, rowdata[i]);
			dsf_makeValue(in_ds_searchLogCheck,"data"+i, "string", rowdata[i]);
		}
    }
    
//trace(in_ds_searchDetl.saveXML());
	var oParam = {};
		oParam.id       = "TRZHM00500";
		oParam.service  = "monitorapp.MonitorMngt";
		oParam.method   = "reqGetElapseTimeCheck";
		oParam.inds     = "req="+sInDsName;
		oParam.outds    = "";
		oParam.async    = false;
		//oParam.callback = "cf_TRZHM00500";

	tranf_submit(oParam);
	
	delete agv_objAppTopPath.form.arryStartLogTime[logickind];
}

function utlf_startLogTempCheck(logickind) {
	if(agv_objAppTopPath.form.arryStartLogTime == null) agv_objAppTopPath.form.arryStartLogTime = new Array();
	
	if(agv_objAppTopPath.form.arryStartLogTime[logickind] != null && agv_objAppTopPath.form.arryStartLogTime[logickind] != undefined)
		delete agv_objAppTopPath.form.arryStartLogTime[logickind];
	
	agv_objAppTopPath.form.arryStartLogTime[logickind] = new Date().getTime();	
}

function utlf_endLogTempCheck(logickind) {
	if(agv_objAppTopPath.form.arryStartLogTime == null || agv_objAppTopPath.form.arryStartLogTime[logickind] == null || agv_objAppTopPath.form.arryStartLogTime[logickind] == undefined)
		return 0;
	
	var elapsedTime = new Date().getTime() - agv_objAppTopPath.form.arryStartLogTime[logickind];
	delete agv_objAppTopPath.form.arryStartLogTime[logickind];
	
	return elapsedTime;
}

function utlf_beforeTimeCheck() {
	if(agv_objAppTopPath.form.arryStartLogTime == null) {
		agv_objAppTopPath.form.arryStartLogTime = 0;
		return;
	}
	
	agv_objAppTopPath.form.modalCallCnt++;
	
	if(agv_objAppTopPath.form.modalCallCnt == 1)				
		return new Date().getTime();
	else
		return 0;
}

function utlf_exceptPopupTime(beforeTime) {
	if(agv_objAppTopPath.form.arryStartLogTime == null) {
		agv_objAppTopPath.form.arryStartLogTime = 0;
		return;
	}
	
	agv_objAppTopPath.form.modalCallCnt--;
	
	if(agv_objAppTopPath.form.modalCallCnt != 0) return;
	
	var currentTime = new Date().getTime();
	for(var i in agv_objAppTopPath.form.arryStartLogTime) {
		var elapseTime = (currentTime - beforeTime);
		agv_objAppTopPath.form.arryStartLogTime[i] += elapseTime;
	}
}

/****************************************************************************************
 * Function			: utlf_validMaskEditTime
 * Description		: MastEdit를 시간으로 사용할 경우, 부정확한 입력을 제한한다.(ontextchange함수에 사용)
 * Argument			: 01.obj - MaskEdit object
 *					: 02.e - TextChangeEventInfo event
 *					: 03.bHalfTime - 12:00 기준인지 여부(defalt는 24:00, true/false)
 * return type		: null
 * Creator			: 추민수
 ****************************************************************************************/
function utlf_validMaskEditTime(obj:MaskEdit,  e:TextChangeEventInfo, bHalfTime){
	var sPosttext = utlf_trim((e.posttext).replace(":", "").replace("_", ""));
	var nFirstTime = 2;
	var nSecondTime = 3;
	
	if( !utlf_isNull(bHalfTime) && bHalfTime == true ){
		nFirstTime = 1;
		nSecondTime = 1;
	}

	if( !utlf_isNull(sPosttext.substring(0, 1)) ){
		if( eval(sPosttext.substring(0, 1)) > nFirstTime ){
			obj.value = "";
			obj.setCaretPos(0);
			return;
		}
	}
	if( !utlf_isNull(sPosttext.substring(1, 2)) ){
		if( eval(sPosttext.substring(0, 1)) > (nFirstTime-1) ){
			if( eval(sPosttext.substring(1, 2)) > nSecondTime ){
				obj.value = sPosttext.substring(0, 1);
				obj.setCaretPos(1);
				return;
			}
		}
	}
	if( !utlf_isNull(sPosttext.substring(2, 3)) ){
		if( eval(sPosttext.substring(2, 3)) > 5 ){
			obj.value = sPosttext.substring(0, 2);
			obj.setCaretPos(2);
			return;
		}
	}
}

/****************************************************************************************
 * Function			: utlf_validMaskEditDateTime
 * Description		: MastEdit를 YYYY-MM-DD hh:mm으로 사용할 경우, 부정확한 입력을 제한한다.(ontextchange함수에 사용)
 * Argument			: 01.obj - MaskEdit object
 *					: 02.e - TextChangeEventInfo event
 *					: 03.bHalfTime - 12:00 기준인지 여부(defalt는 24:00, true/false)
 * return type		: null
 * Creator			: 
 ****************************************************************************************/
function utlf_validMaskEditDateTime(obj:MaskEdit,  e:TextChangeEventInfo, bHalfTime){
	
	if( utlf_isNull(obj.mask) || obj.mask != "####-##-## ##:##" ){
		return;
	}

	var sPosttext = utlf_trim((e.posttext).replace("-", "").replace(":", "").replace("_", "").replace(" ", ""));

	var nFirstDateM = 1;
	var nSecondDateM = 2;
	var nFirstDateD = 3;
	var nFirstTime = 2;
	var nSecondTime = 3;
	
	if( !utlf_isNull(bHalfTime) && bHalfTime == true ){
		nFirstTime = 1;
		nSecondTime = 1;
	}
	// M
	if( !utlf_isNull(sPosttext.substring(4, 5)) ){
		if( eval(sPosttext.substring(4, 5)) > nFirstDateM ){
			obj.value = eval(sPosttext.substring(0, 4));
			obj.setCaretPos(5);
			return true;
		}
	}
	// MM
	if( !utlf_isNull(sPosttext.substring(5, 6)) ){
		if(  eval(sPosttext.substring(4, 5)) > (nFirstDateM-1)
			&& eval(sPosttext.substring(5, 6)) > nSecondDateM ){
			obj.value = sPosttext.substring(0, 5);
			obj.setCaretPos(6);
			return true;
		}
	}
	// D
	if( !utlf_isNull(sPosttext.substring(6, 7)) ){
		if( eval(sPosttext.substring(6, 7)) > nFirstDateD ){
			obj.value = sPosttext.substring(0, 6);
			obj.setCaretPos(8);
			return true;
		}else if( eval(sPosttext.substring(6, 7)) == nFirstDateD ){
			if( utlf_isValidDateTime(sPosttext.substring(0, 7) + "0", "YYYYMMDD") == false ){
				obj.value = sPosttext.substring(0, 6);
				obj.setCaretPos(8);
				return true;
			}
		}
	}
	// DD
	if( !utlf_isNull(sPosttext.substring(7, 8)) ){
		if( utlf_isValidDateTime(sPosttext.substring(0, 8), "YYYYMMDD") == false ){
			obj.value = sPosttext.substring(0, 7);
			obj.setCaretPos(9);
			return true;
		}
	}
	// H
	if( !utlf_isNull(sPosttext.substring(8, 9)) ){
		if( eval(sPosttext.substring(8, 9)) > nFirstTime ){
			obj.value = sPosttext.substring(0, 8);
			obj.setCaretPos(11);
			return true;
		}
	}
	// HH
	if( !utlf_isNull(sPosttext.substring(9, 10)) ){
		if( eval(sPosttext.substring(8, 9)) > (nFirstTime-1) ){
			if( eval(sPosttext.substring(9, 10)) > nSecondTime ){
				obj.value = sPosttext.substring(0, 9);
				obj.setCaretPos(12);
				return true;
			}
		}
	}
	// D
	if( !utlf_isNull(sPosttext.substring(10, 11)) ){
		if( eval(sPosttext.substring(10, 11)) > 5 ){
			obj.value = sPosttext.substring(0, 10);
			obj.setCaretPos(14);
			return true;
		}
	}
}

/**
 * @---------------------------------------------------
 * @desc   : 저장된 값을 지정한 자리에서 올림/반올림/버림 처리
 * @param  : position - 올림/반올림/버림 할 위치(2:10자리, 1:1자리, -1:소수점이하 첫째자리)
 * @param  : mode  - UP:올림, HALF_UP:반올림, DOWN:버림
 * @return : Number
 * @---------------------------------------------------
 */
function utlf_getRound_medirec( position, mode )
{
// 파라미터 값을 수치화 하여 변수에 저장
   var valueNumber = parseFloat(this);
   
   // 소수점을 기준으로 숫자들만 취하여 배열 변수에 저장
   var tempArray = valueNumber.toString().setReplaceWord("-", "").split(".");
   
   // this 가 float 형이 아니면
   if( !this.isFloat() )
   {
      //fAlertMessage(4, "파라미터");
      return "";
   }

   // position 가 float 형이 아니면
   if( !position.toString().isFloat() )
   {
      //fAlertMessage(4, "파라미터");
      return "";
   }
   
   var nPosition = parseInt(position);

   // 소수점 앞에서 처리하려면
   if(0 < nPosition)
   {
      // 소수점 이상 자리수보다 크면
      if( tempArray[0].length < nPosition )
      {
         // 메시지 처리후 리턴
         //fAlertMessage(1, "올림/반올림/버림 할 위치");
         return "";
      }
   }
   // 소수점 뒤에서 처리하려면
   else if(0 > nPosition)
   {
      // 소수점 이하값이 존재하지 않거나 자리수보다 크면
      if(tempArray.length != 2 || tempArray[1].length < nPosition*(-1))
      {
         return this;
      }
   }

   switch(mode){
   // '올림'이고
      case "UP" : 
      // 소수점 앞에서 처리하려면
      if(0 < nPosition)
      {
         // 해당 자리(position)에서 올림 처리
         valueNumber = Math.ceil(valueNumber / Math.pow(10, position)) * Math.pow(10, position);

         return valueNumber;
      }
      // 소수점 뒤에서 처리하려면
      else if(0 > nPosition)
      {
         // 해당 자리(position)에서 올림 처리
         valueNumber = Math.ceil(valueNumber * Math.pow(10, position*(-1)-1)) / Math.pow(10, position*(-1)-1);

         return valueNumber;
      }
      else
      {
         //fAlertMessage(4, "올림자리");
         return "";
      }
   // '반올림'이고
   case "HALF_UP" :
      // 소수점 앞에서 처리하려면
      if(0 < nPosition)
      {
         // 해당 자리(position)에서 반올림 처리
         valueNumber = Math.round(valueNumber / Math.pow(10, position)) * Math.pow(10, position);

         return valueNumber;
      }
      // 소수점 뒤에서 처리하려면
      else if(0 > nPosition)
      {
         // 해당 자리(position)에서 반올림 처리
         valueNumber = Math.round(valueNumber * Math.pow(10, position*(-1)-1)) / Math.pow(10, position*(-1)-1);

         return valueNumber;
      }
      else
      {
         //fAlertMessage(4, "올림자리");
         return "";
      }

   // '버림'이고
   case "DOWN" :
      // 소수점 앞에서 처리하려면
      if(0 < nPosition)
      {
         // 해당 자리(position)에서 내림 처리
         valueNumber = Math.floor(valueNumber / Math.pow(10, position)) * Math.pow(10, position);

         return valueNumber;
      }
      // 소수점 뒤에서 처리하려면
      else if(0 > nPosition)
      {
         // 해당 자리(position)에서 내림 처리
         valueNumber = Math.floor(valueNumber * Math.pow(10, position*(-1)-1)) / Math.pow(10, position*(-1)-1);

         return valueNumber;
     }else{
         //fAlertMessage(4, "올림자리");
         return "";
      }

   // 모두 아니면
   default :
      // 메시지 처리후 리턴
      //fAlertMessage(1, "모드('1'/'0'/'-1')");
      return "";
   }
}]]></Script>