/* 화면 확대 축소 시작 IE 전용 */
var nowZoom = 100; // 현재비율
var maxZoom = 200; // 최대비율(500으로하면 5배 커진다)
var minZoom = 80; // 최소비율

//화면 키운다.
function zoomIn() {
	if (nowZoom < maxZoom) {
		nowZoom += 10; //25%씩 커진다.
	} else {
		return;
	}
	document.body.style.zoom = nowZoom + "%";
}


//화면 줄인다.
function zoomOut() {
	if (nowZoom > minZoom) {
		nowZoom -= 10; //25%씩 작아진다.
	} else {
		return;
	}
	document.body.style.zoom = nowZoom + "%";
}
function isNum (v){
	return (v.toString() && !/\D/.test(v));
}
function onlyNumber(){
	if (event.keyCode < 48 || event.keyCode > 57) event.returnValue = false;
}

function checkJumin( fld ){
	var num = this.trim().onlyNum();
	if(num.length == 13) {
		num = num.substring(0, 6) + "-" + num.substring(6, 13);
	}
	else {
		return false;
	}
	num = num.match(/^([0-9]{6})-?([0-9]{7})$/);
	if(!num) return false;
	var num1 = RegExp.$1;
	var num2 = RegExp.$2;
	if(!num2.substring(0, 1).match(/^[1-4]{1}$/)) return false;
	num = num1 + num2;
	var sum = 0;
	var last = num.charCodeAt(12) - 0x30;
	var bases = "234567892345";
	for (i=0; i<12; i++) {
		sum += (num.charCodeAt(i) - 0x30) * (bases.charCodeAt(i) - 0x30);
	}
	var mod = sum % 11;
	return ((11 - mod) % 10 == last) ? true : false;
}











/*
	내    용 : "enter" 키가 눌러졌으면 파라미터로 받은 스크립트를 실행
	파라미터 : pScript - 실행할 스크립트
	Return값 : 없슴
*/
function fAutoClick(pScript)
{
	// 눌려진 키가 "enter" 이면 파라미터로 받은 스크립트(함수) 실행
	if(event.keyCode == 13) window.execScript(pScript, "javascript");
}

/*
	내    용 : 값이 없는지 체크하여 메시지를 경고창을 띄운다.
	파라미터 :	pString - 체크할 문자열
					pElementName - 해당 객체명
	Return값 : TRUE or FALSE
*/
function fCheckEmpty(pString, pElementName)
{
	if(fTrim(pString) == "")
	{
		if("undefined" != typeof(pElementName)) fAlertMessage(0, pElementName);
		return false;
	}
	return true;   // 공백이 아니라면
}

/*
	내    용 : 년도값 체크 (수치여부, 범위)
	파라미터 : pYear - 체크할 년도
	Return값 : TRUE or FALSE
*/
function fCheckYear(pYear)
{
	// 값이 없으면 false 리턴
	if(pYear == "")
	{
		fAlertMessage(0, "년도");
		return false;
	}

	// 길이가 4가 아니면 false 리턴
	if(pYear.length != 4)
	{
		fAlertMessage(3, "년도");
		return false;
	}

	// 수치가 아니면
	if(isNaN(pYear))
	{
		fAlertMessage(4, "년도");
		return false;
	}

	// 년도값이 0 부터 9999 사이의 수치가 아니면 false 리턴
	if(eval(pYear) < 0 || eval(pYear) > 9999)
	{
		fAlertMessage(1, "년도");
		return false;
	}
	return true;
}

/*
	내    용 : 월값 체크 (수치여부, 범위(1~12월))
	파라미터 : pMonth - 체크할 월
	Return값 : TRUE or FALSE
*/
function fCheckMonth(pMonth)
{
	// 값이 없으면 false 리턴
	if(pMonth == "")
	{
		fAlertMessage(0, "월");
		return false;
	}

	// 길이가 2보다 크면 false 리턴
	if(pMonth.length > 2)
	{
		fAlertMessage(3, "월");
		return false;
	}

	// 수치가 아니면
	if(isNaN(pMonth))
	{
		fAlertMessage(4, "월");
		return false;
	}

	// 월값이 1 부터 12 사이의 수치가 아니면 false 리턴
	if(eval(pMonth) < 1 || eval(pMonth) > 12)
	{
		fAlertMessage(1, "월");
		return false;
	}

	// 이상 없으므로 TRUE 리턴
	return true;
}


/*
	내    용 : 일값 체크 (수치여부, 범위(1~31일))
	파라미터 : pDay - 체크할 날짜(일)
	Return값 : TRUE or FALSE
*/
function fCheckDay(pDay)
{
	// 값이 없으면 false 리턴
	if(pDay == "")
	{
		fAlertMessage(0, "일");
		return false;
	}

	// 길이가 2보다 크면 false 리턴
	if(pDay.length > 2)
	{
		fAlertMessage(3, "일");
		return false;
	}

	// 수치가 아니면
	if(isNaN(pDay))
	{
		fAlertMessage(4, "일");
		return false;
	}

	// 일값이 1 부터 31 사이의 수치가 아니면 false 리턴
	if(eval(pDay) < 1 || eval(pDay) > 31)
	{
		fAlertMessage(1, "일");
		return false;
	}

	// 이상 없으므로 TRUE 리턴
	return true;
}

/*
	내    용 : 일자값 체크 (8문자 수치여부, 년월일값의 범위, 윤년)
	파라미터 : pDate - 체크할 날짜
	Return값 : TRUE or FALSE
*/
function fCheckDate(pDate)
{
	// 일자값 저장 배열
	var vDateArray = new Array(3);

	// Null값이 없으면 false 리턴
	if(pDate == "")
	{
		fAlertMessage(0, "일자");
		return false;
	}

	// "/" 문자가 있으면
	if(pDate.match("/") == "/")
	{
		// "/" 문자를 구분자로 분리하여 배열에 저장
		vDateArray = pDate.split("/");

		// 배열 길이가 3 이 아니면 false 리턴
		if(vDateArray.length != 3)
		{
			fAlertMessage(2, '구분자("/")');
			return false;
		}
	}
	// "-" 문자가 있으면
	else if(pDate.match("-") == "-")
	{
		// "-" 문자를 구분자로 분리하여 배열에 저장
		vDateArray = pDate.split("-");

		// 배열 길이가 3 이 아니면 false 리턴
		if(vDateArray.length != 3)
		{
			fAlertMessage(2, '구분자("-")');
			return false;
		}
	}
	// "." 문자가 있으면
	else if(pDate.split(".").length > 1)
	{
		// "." 문자를 구분자로 분리하여 배열에 저장
		vDateArray = pDate.split(".");

		// 배열 길이가 3 이 아니면 false 리턴
		if(vDateArray.length != 3)
		{
			fAlertMessage(2, '구분자(".")');
			return false;
		}
	}
	// "/"문자가 없으면
	else
	{
		// 길이가 8 이 아니면 false 리턴
		if(pDate.length != 8)
		{
			fAlertMessage(3, "일자");
			return false;
		}

		// 수치가 아니면
		if(isNaN(pDate))
		{
			fAlertMessage(4, "일자");
			return false;
		}

		// 길이대로(년:4, 월:2, 일:2) 잘라서 배열에 저장
		vDateArray[0] = pDate.substr(0,4);
		vDateArray[1] = pDate.substr(4,2);
		vDateArray[2] = pDate.substr(6,2);
	}

	// 년도값이 0 부터 9999 사이의 수치가 아니면 false 리턴
	if(eval(vDateArray[0]) < 0 || eval(vDateArray[0]) > 9999)
	{
		fAlertMessage(1, "일자(년)");
		return false;
	}

	// 월값이 1 부터 12 사이의 수치가 아니면 false 리턴
	if(eval(vDateArray[1]) < 1 || eval(vDateArray[1]) > 12)
	{
		fAlertMessage(1, "일자(월)");
		return false;
	}

	// 일값이 1 부터 31 사이의 수치가 아니면 false 리턴
	if(eval(vDateArray[2]) < 1 || eval(vDateArray[2]) > 31)
	{
		fAlertMessage(1, "일자(일)");
		return false;
	}

	// 월값이 길이가 1 이면 앞에 "0" 을 붙인다
	if(vDateArray[1].length == 1) vDateArray[1] = "0" + vDateArray[1];

	// 일값이 길이가 1 이면 앞에 "0" 을 붙인다
	if(vDateArray[2].length == 1) vDateArray[2] = "0" + vDateArray[1];

	// 30 일까지 있는 달의 일 체크
	if((eval(vDateArray[1]) == 4 || eval(vDateArray[1]) == 6 || eval(vDateArray[1]) == 9 || eval(vDateArray[1]) == 11) && eval(vDateArray[2]) == 31)
	{
		fAlertMessage(1, "일자(일)");
		return false;
	}

	// 윤년일 경우
	if(((eval(vDateArray[0]) % 4 == 0 && eval(vDateArray[0]) % 100 != 0) || eval(vDateArray[0]) % 400 == 0))
	{
		// 2 월의 일 체크
		if(eval(vDateArray[1]) == 2 && eval(vDateArray[2]) > 29)
		{
			fAlertMessage(1, "일자(일)");
			return false;
		}
	}
	// 윤년이 아닐 경우
	else
	{
		// 2월의 일 체크
		if(eval(vDateArray[1]) == 2 && eval(vDateArray[2]) > 28)
		{
			fAlertMessage(1, "일자(일)");
			return false;
		}
	}

	return true;
}

/*
	내    용 : 날짜값을 체크한 후 "/,-,."가 있으면 제거하고 리턴 ("20020101" 형태)
	파라미터 : pDate - 체크할 날짜
	Return값 : "/,-,." 문자를 제거한 8자리 수치값 (오류가 없을 경우) or ""(오류가 있을 경우)
*/
function fCompleteDate(pDate)
{
	var vDate;
	vDate = fTrim(pDate);

	// 일자값 저장 배열
	var vDateArray = new Array(3);

	// "/" 문자가 있으면
	if(vDate.match("/") == "/")
	{
		// "/" 문자를 구분자로 분리하여 배열에 저장
		vDateArray = vDate.split("/");
	}
	// "-" 문자가 있으면
	else if(vDate.match("-") == "-")
	{
		// "-" 문자를 구분자로 분리하여 배열에 저장
		vDateArray = vDate.split("-");
	}
	// "." 문자가 있으면
	else if(vDate.split(".").length > 1)
	{
		// "-" 문자를 구분자로 분리하여 배열에 저장
		vDateArray = vDate.split(".");
	}
	// "/,-,."문자가 없고 길이가 8이면
	else if(vDate.length == 8)
	{
		// 길이대로(년:4, 월:2, 일:2) 잘라서 배열에 저장
		vDateArray[0] = vDate.substr(0,4);
		vDateArray[1] = vDate.substr(4,2);
		vDateArray[2] = vDate.substr(6,2);
	}

	// 일자 체크 결과가 false 이면 리턴
	if(fCheckDate(vDate) == false) return "";

	// 월값이 길이가 1 이면 앞에 "0" 을 붙인다
	if(vDateArray[1].length == 1) vDateArray[1] = "0" + vDateArray[1];

	// 일값이 길이가 1 이면 앞에 "0" 을 붙인다
	if(vDateArray[2].length == 1) vDateArray[2] = "0" + vDateArray[2];

	vDate = vDateArray[0] + vDateArray[1] + vDateArray[2];

	return vDate;
}

/*
	내    용 : 기간값의 유효성 체크
	파라미터 :	pDateFrom - 기간1
					pDateTo   - 기간2
	Return값 : TRUE of FALSE
*/
function fCheckDateTerm(pDateFrom, pDateTo)
{
	// 두 기간값에 이상이 없으면
	if(fCheckDate(pDateFrom) && fCheckDate(pDateTo))
	{
		// 기간2가 기간1보다 크면 TRUE 리턴
		if(eval(fCompleteDate(pDateTo)) - eval(fCompleteDate(pDateFrom)) >= 0) return true;
	}

	return false;
}

/*
	내    용 : 기간의 일자수를 리턴(시작일자와 끝일자 포함, 일자값 체크도 수행)
	파라미터 :	 pDateFrom - 시작일자
					pDateTo - 끝일자
	Return값 : 기간의 일자수
*/
function fGetDateCount(pDateFrom, pDateTo)
{
	//시작일, 끝일 기간값 유효성 체크
	if(fCheckDateTerm(pDateFrom, pDateTo) == false) return;

	var vDateFrom = new Date(eval(pDateFrom.substring(0, 4)), eval(pDateFrom.substring(4, 6)) - 1, eval(pDateFrom.substring(6, 8)));
	var vDateTo   = new Date(eval(pDateTo.substring(0, 4)),   eval(pDateTo.substring(4, 6) - 1),   eval(pDateTo.substring(6, 8)));

	var vDateCount = ((vDateTo - vDateFrom) / 86400000) + 1;

	return vDateCount;
}

/*
	내    용 : 시작일자와 기간을 받아 종료일자를 리턴
	파라미터 : pStartDate - 시작일자
	           pDateTerm  - 기간
	Return값 : 종료 일자
*/
function fGetEndDate(pStartDate, pDateTerm)
{
	// 파라미터로 받은 날짜로 Date 객체 초기화
	var vStartDate  = new Date(eval(pStartDate.toString(10).substring(0, 4)), eval(pStartDate.toString(10).substring(4, 6)) - 1, eval(pStartDate.toString(10).substring(6, 8)));

	// 파라미터로 받은 숫자만큼 이후 일자로 setting
	vStartDate.setDate(vStartDate.getDate() + eval(pDateTerm));

	// 년도 문자열화
	var vTempYear   = vStartDate.getYear();
	vTempYear   = vTempYear.toString(10);

	// 월 문자열화
	var vTempMonth  = vStartDate.getMonth()+1;
	vTempMonth  = vTempMonth.toString(10);

	// 일 문자열화
	var vTempDate   = vStartDate.getDate();
	vTempDate   = vTempDate.toString(10);

	// 날짜 포맷으로 변환
	var vReturnDate = vTempYear + fCompleteMonth(vTempMonth) + fCompleteDay(vTempDate);

	return vReturnDate;
}

/*
	내    용 : 날짜(일)값을 체크한 후 2자리 수치값으로 리턴 ("01" 또는 "31" 형태)
	파라미터 : pDay - 체크할 날짜(일)
	Return값 : 2자리 수치값 (오류가 없을 경우) or ""(오류가 있을 경우)
*/
function fCompleteDay(pDay)
{
	var vDay;
	vDay = pDay;

	// 일자 체크 결과가 false 이면 리턴
	if(fCheckDay(vDay) == false) return "";
	// 일값이 길이가 1 이면 앞에 "0" 을 붙인다
	if(vDay.length == 1) vDay = "0" + vDay;

	return vDay;
}

/*
	내    용 : 날짜(월)값을 체크한 후 2자리 수치값으로 리턴 ("01" 또는 "12" 형태)
	파라미터 : pMonth - 체크할 날짜(월)
	Return값 : 2자리 수치값 (오류가 없을 경우) or ""(오류가 있을 경우)
*/
function fCompleteMonth(pMonth)
{
	var vMonth;
	vMonth = pMonth;

	// 일자 체크 결과가 false 이면 리턴
	if(fCheckMonth(vMonth) == false) return "";

	// 월값이 길이가 1 이면 앞에 "0" 을 붙인다
	if(vMonth.length == 1) vMonth = "0" + vMonth;

	return vMonth;
}

/*
	내    용 : 입력 날짜  "/" 추가 : 19961230(8자리) => 1996/12/30(10자리)
	파라미터 : thisCtrl - 개체명
	Return값 : 없슴
*/
function fAddDateSlash( thisCtrl )
{
	var vNewVal  = "";

	if(thisCtrl.value.match("/") != "/" || thisCtrl.value.length == 8){
		vNewVal = thisCtrl.value.substring(0,4) + "/";
		vNewVal += thisCtrl.value.substring(4,6) + "/";
		vNewVal += thisCtrl.value.substring(6,8);
		thisCtrl.value = vNewVal;
		return true;
	}else return false;
}

/*
	내    용 : 입력 날짜  "/" 삭제 : 1996/12/30(10자리) => 19961230(8자리)
	파라미터 : thisCtrl - 개체명
	Return값 : 없슴
*/
function fDelDateSlash(thisCtrl){
	var  vNewVal="";

	if(thisCtrl.value.match("/") == "/" || thisCtrl.value.length == 10){
		vNewVal = fReplaceWord(thisCtrl.value, "/","");
		thisCtrl.value = vNewVal;
		thisCtrl.select();
		return true;
	}else return false;
}

/*
내    용 : 현재 날짜를 기준으로 주 단위로 리턴
파라미터 : pWeek - 1주전, 2주전...
				pYoIl - 요일의 첫 주를 기준으로 할지 여부
*/
function fSetBeforeWeek(pWeek,pYoIl){

	var date_on = new Date();
	var year = date_on.getYear();
	var month = date_on.getMonth() + 1;
	var day = date_on.getDate();

	var vDate = year + fCompleteMonth(month.toString()) + fCompleteDay(day.toString());

	var vFirstDate;

	if(pYoIl == "Y"){
		//요일 (일, 월,화,수,목,금,토 => 0,1,2,3,4,5,6)
		var strYoIl = date_on.getDay();
		vFirstDate = fGetEndDate(fGetEndDate(vDate, parseInt(-strYoIl)), 7*parseInt(pWeek));
	}else {
		vFirstDate = fGetEndDate(vDate, 7*parseInt(pWeek));
	}

	return vFirstDate;
}

/*
내    용 : 현재 날자를 기준으로 월 단위로 리턴
파라미터 : pMonth - 1달후, 2달후, ... 1달전, 2달전 ...
*/
function fSetBeforeMonth(pMonth){

	var date_on = new Date();
	//이동하려는 달을 먼저 세팅해 준다.
	date_on.setMonth(date_on.getMonth() + parseInt(pMonth));

	var year = date_on.getYear();
	var month = date_on.getMonth()+1;
	var day = date_on.getDate();

	return year + fCompleteMonth(month.toString()) + fCompleteDay(day.toString());
}

/*
내    용 : 받은 날자를 기준으로 월 단위로 리턴
파라미터 : pMonth - 1달후, 2달후, ... 1달전, 2달전 ...
*/
function fSetBeforeMonth_(pYear, pMonth, pDay, pValue){
	var date_on = new Date(pYear, getSingleDateNumber(pMonth) - 1, getSingleDateNumber(pDay));
	//이동하려는 달을 먼저 세팅해 준다.
	date_on.setMonth(date_on.getMonth() + parseInt(pValue));

	var year = date_on.getYear();
	var month = date_on.getMonth()+1;
	var day = date_on.getDate();

	return year + fCompleteMonth(month.toString()) + fCompleteDay(day.toString());
}

/*
	내    용 : 파라미터 값이 숫자로만 이루어져있는지를 체크
	파라미터 : pNumber - 체크할 수치 또는 문자열
	Return값 : TRUE or FALSE
*/
function fCheckNumber(pNumber)
{
	// 값이 없으면 FALSE 리턴
	if(typeof(pNumber) == "undefined") return false;
	if(pNumber.length == 0) return false;

	// 문자열화시켜 변수에 저장
	var vNumber = pNumber.toString();

	// 문자열 길이만큼 loop
	for(var i=0; i<vNumber.length; i++)
	{
		var vTemp = vNumber.substring(i, i+1);

		// 숫자가 아니면 FALSE 리턴
		if(isNaN(vTemp)) return false;

		// 공백이면 FALSE 리턴
		if(" " == vTemp) return false;
	}

	// 이상 없으므로 TRUE 리턴
	return true;
}

/*
	내    용 : 파라미터 값이 Float Type인지를 체크
	파라미터 : pValue - 파라미터 값
	Return값 : TRUE or FALSE
*/
function fCheckFloat(pValue)
{
	// 파라미터 값이 parseFloat()후에도 같으면 TRUE 리턴
	if(pValue == parseFloat(pValue)) return true;
	else return false;
}

/*
	내    용 : 파라미터 값이 정수인지를 체크
	파라미터 : pValue - 파라미터 값
	Return값 : TRUE or FALSE
*/
function fCheckInteger(pValue)
{
	// 값이 없으면 FALSE 리턴
	if(typeof(pValue) == "undefined") return false;
	if(pValue.length == 0) return false;

	// 문자열화시켜 변수에 저장
	var vValue = pValue.toString();

	// 첫번째 문자가 "-" 이면 제거
	if(vValue.substring(0, 1) == "-")
	{
		vValue = vValue.substring(1, vValue.length);
	}

	// 값이 0 이 아니면
	if(vValue != 0)
	{
		// 문자열 길이만큼 loop
		for(var i=0; i<vValue.length; i++)
		{
			// 숫자가 아니면 FALSE 리턴
			if(isNaN(vValue.substring(i, i+1))) return false;
		}
	}

	// 이상 없으므로 TRUE 리턴
	return true;
}

/*
	내    용 : 수치를 지정한 자리에서 올림/반올림/버림 처리
	파라미터 :	pNumber - 처리할 수치
					pPoint  - 올림/반올림/버림 할 위치(2:10자리, 1:1자리, -1:소수점이하 첫째자리)
					pMode   - 1:올림, 0:반올림, -1:버림
	Return값 : 정상처리시:처리한 값, 오류시:""
*/
function fRound(pNumber, pPoint, pMode)
{
	// 파라미터 값을 수치화 하여 변수에 저장
	var vNumber = eval(pNumber);

	// 소수점을 기준으로 숫자들만 취하여 배열 변수에 저장
	var vTempArray = eval(pNumber).toString().replace("-", "").split(".");

	// pNumber 가 float 형이 아니면
	if(!fCheckFloat(pNumber))
	{
		// 메시지 처리후 리턴
		fAlertMessage(4, "파라미터");
		return "";
	}

	// pPoint 가 float 형이 아니면
	if(!fCheckFloat(pPoint))
	{
		// 메시지 처리후 리턴
		fAlertMessage(4, "파라미터");
		return "";
	}

	// 소수점 앞에서 처리하려면
	if(0 < eval(pPoint))
	{
		// 소수점 이상 자리수보다 크면
		if(vTempArray[0].length < eval(pPoint))
		{
			// 메시지 처리후 리턴
			fAlertMessage(1, "올림/반올림/버림 할 위치");
			return "";
		}
	}
	// 소수점 뒤에서 처리하려면
	else if(0 > eval(pPoint))
	{
		// 소수점 이하값이 존재하지 않거나 자리수보다 크면
		if(vTempArray.length != 2 || vTempArray[1].length < eval(pPoint)*(-1))
		{
			return pNumber;
		}
	}

	// '올림'이고
	if(1 == eval(pMode))
	{
		// 소수점 앞에서 처리하려면
		if(0 < eval(pPoint))
		{
			// 해당 자리(pPoint)에서 올림 처리
			vNumber = Math.ceil(vNumber / Math.pow(10, pPoint)) * Math.pow(10, pPoint);

			return vNumber;
		}
		// 소수점 뒤에서 처리하려면
		else if(0 > eval(pPoint))
		{
			// 해당 자리(pPoint)에서 올림 처리
			vNumber = Math.ceil(vNumber * Math.pow(10, pPoint*(-1)-1)) / Math.pow(10, pPoint*(-1)-1);

			return vNumber;
		}
		else
		{
			fAlertMessage(4, "올림자리");
			return "";
		}
	}
	// '반올림'이고
	else if(0 == eval(pMode))
	{
		// 소수점 앞에서 처리하려면
		if(0 < eval(pPoint))
		{
			// 해당 자리(pPoint)에서 반올림 처리
			vNumber = Math.round(vNumber / Math.pow(10, pPoint)) * Math.pow(10, pPoint);

			return vNumber;
		}
		// 소수점 뒤에서 처리하려면
		else if(0 > eval(pPoint))
		{
			// 해당 자리(pPoint)에서 반올림 처리
			vNumber = Math.round(vNumber * Math.pow(10, pPoint*(-1)-1)) / Math.pow(10, pPoint*(-1)-1);

			return vNumber;
		}
		else
		{
			fAlertMessage(4, "올림자리");
			return "";
		}
	}
	// '버림'이고
	else if(-1 == eval(pMode))
	{
		// 소수점 앞에서 처리하려면
		if(0 < eval(pPoint))
		{
			// 해당 자리(pPoint)에서 내림 처리
			vNumber = Math.floor(vNumber / Math.pow(10, pPoint)) * Math.pow(10, pPoint);

			return vNumber;
		}
		// 소수점 뒤에서 처리하려면
		else if(0 > eval(pPoint))
		{
			// 해당 자리(pPoint)에서 내림 처리
			vNumber = Math.floor(vNumber * Math.pow(10, pPoint*(-1)-1)) / Math.pow(10, pPoint*(-1)-1);

			return vNumber;
		}
		else
		{
			fAlertMessage(4, "올림자리");
			return "";
		}
	}
	// 모두 아니면
	else
	{
		// 메시지 처리후 리턴
		fAlertMessage(1, "모드('1'/'0'/'-1')");
		return "";
	}
}

/*
	내    용 : 파라미터로 받은 금액을 수치형태(',' 제거)로 변환
	파라미터 : pAmount - 금액
	Return값 : 수치 형태로 변환한 값 or ""
*/
function fConvertAmountToNumber(pAmount)
{
	return fReplaceWord(pAmount, ",", "");
}

/*
	내    용 : 파라미터로 받은 수치를 금액 형태(',' 삽입)로 변환
	파라미터 : pNumber - 수치
	Return값 : 금액 형태로 변환한 값 or ""
*/
function fConvertNumberToAmount(pNumber)
{
	var vNumber;
	var vAddPoint = 0;
	var vAmount = "";
	var vTempArray;

	// 정상적인 float 값이면
	if(fCheckFloat(pNumber))
	{
		// 문자열화시켜 변수에 저장
		vNumber = pNumber.toString();

		// 첫번째 문자로 '-' 가 있으면 따로 떼어서 저장
		if(vNumber.substring(0, 1) == "-")
		{
			vAmount = "-";
			vNumber = vNumber.substring(1, pNumber.length);
		}

		// '.' 을 구분자로 나누어 배열 변수에 저장
		vTempArray = vNumber.split(".");

		// 자연수값의 길이가 3 보다 크면
		if(vTempArray[0].length > 3)
		{
			// ',' 를 붙일 위치 설정
			if(vTempArray[0].length % 3 == 0) vAddPoint = 3;
			else vAddPoint = vTempArray[0].length % 3;
		}

		// 자연수값의 길이만큼 loop
		for(var i=0; i<vTempArray[0].length; i++)
		{
			// 한글자씩 리턴값에 추가
			vAmount += vTempArray[0].substring(i, i + 1);

			// i 값이 ',' 를 붙일 위치에 도달하면
			if(i == vAddPoint - 1 && i != vTempArray[0].length - 1)
			{
				// ',' 문자를 붙이고
				vAmount += ",";

				// ',' 를 붙일 위치 재설정
				vAddPoint = eval(vAddPoint) + 3;
			}
		}

		// 소수점 이하값도 있었다면 리턴값에 추가
		if(vTempArray.length == 2) vAmount += "." + vTempArray[1];
	}
	return vAmount;
}

/*
	내    용 : 더블형의 필드값들의 유효길이 체크
	파라미터 :	pCtrl   - 개체명
					pMaxLen - 최대 길이
					pPoint  - 소수점 이하 자리수
	Return값 : 없슴
*/
function fCheckSize(pCtrl, pMaxLen, pPoint)
{
	//소수점이 없을 경우
	if(pCtrl.value.indexOf(".") == -1){
		if(pCtrl.value.length > ( pMaxLen-pPoint)){
			alert(pCtrl.title+"은(는) 소수점이 없을 때는 "+( pMaxLen-pPoint)+"자리 까지만 가능합니다!!");
			return false;
		}
	//소수점이 존재할 경우
	}else{
		if(pCtrl.value.indexOf(".") > ( pMaxLen-pPoint)){
			alert(pCtrl.title+"은(는) 소수점 이상 "+(pMaxLen-pPoint)+"자리 까지만 가능합니다!!");
			return false;
		}

		if((pCtrl.value.length - pCtrl.value.indexOf(".") ) > (pPoint+1)){
			alert(pCtrl.title+"은(는) 소수점 이하 "+pPoint+"자리 까지만 가능합니다!!");
			return false;
		}
	}
	return true;
}

/*
	내    용 : 특수문자 \,",' 의 앞에 \ 를 붙임
	파라미터 : pSourceString - 대상 문자열
	Return값 : 변환한 문자열
*/
function fConvertSpecialCharacter(pSourceString)
{
	var vTempString = pSourceString;

	vTempString = fReplaceWord(vTempString, "\\", "\\\\");
	vTempString = fReplaceWord(vTempString, "\'", "\\'" );
	vTempString = fReplaceWord(vTempString, '"', '&quot;' );
	vTempString = fReplaceWord(vTempString, "\n", "\\n" );

	return vTempString;
}

/*
	내    용 :  문자열에 Quotation Mark 가 있는지 없는지 체크
					있으면 DB 쿼리시 에러발생, 있으면 true
	파라미터 : str - 문자열
*/
function fHaveQuotationChar(str)
{
	for(var intPos=0; intPos < str.length; intPos++)
	{
		var chr = str.charAt(intPos);
		if( chr =="\"" || chr == "'")
			return true;
	}
	return false;
}

/*
	내    용 : 일반 숫자를 개수만큼 앞에 0을 붙여준다.
	파라미터 : pSourceString - 대상 문자열
					pNumber - 리턴할 문자열 갯수
	Return값 : 변환한 문자열
*/
function fPlusZeroChar(pSourceString, pNumber)
{
	var vTempString = pSourceString;
	for(var i=1 ; i < parseInt(pNumber) - pSourceString.length;i++)
	{
		vTempString = "0" + vTempString;
	}

	return vTempString;
}


/*
	내    용 :정해진 바이트 만큼만 입력필드 값으로 채운다. - 경고메세지 포함
	파라미터 : object의 value값으로 string 문자열을 가지고 있는 element (예:textbox, textfield 등)
	Return값 : 없음
*/
	function fCheckByte(pCtrl){
		var intMaxByte = parseInt(pCtrl.MaxBytes);
		var strString = pCtrl.value;
		var currentByte = fGetStringLength(strString);

		if( currentByte > intMaxByte){
			alert( "영문 " + pCtrl.MaxBytes + "자, 한글 " + intMaxByte/2 + "자 이상 입력하실수 없습니다.");
			pCtrl.value = fGetStringToByte(intMaxByte, pCtrl.value);
			return false;
		}else return true;
	}

/*
	내    용 : 길이값을 구한다.
	파라미터 : pSourceString - 알고자하는 문자
	Return값 : 변환한 문자열 Byte
*/
	function fGetStringLength(pSourceString){
		var intByteCount = 0;
		for(var i=0; i < pSourceString.length; i++)
		{
			var tmpChar = pSourceString.charAt(i);
			if( escape(tmpChar).length > 4)
				intByteCount += 2;
			else if(tmpChar != '\r')
				intByteCount++;
		}
		return(intByteCount);
	}

/*
	내    용 :전체 문자열에서 지정된 byte수 만큼만 읽어들인 스트링을 리턴한다.
	파라미터 :	pMaxByte - Max byte 수
					pSourceString - byte수를 계산할 스트링
	Return값 : 변환한 문자열
*/
function fGetStringToByte(pMaxByte, pSourceString)
{
	var intByteCount = 0;
	for(var i=0; i < pSourceString.length; i++)
	{
		var tmpChar = pSourceString.charAt(i);
		if( escape(tmpChar).length > 4)
			intByteCount += 2;
		else if(tmpChar != '\r')
			intByteCount++;

		if(intByteCount > pMaxByte) break;
	}
	return pSourceString.substr(0,i);
}

/*
	내    용 : 문자열 앞뒤에있는 공백 제거
	파라미터 : pTargetString - 대상 문자열
	Return값 : 공백을 제거한 결과 문자열
*/
function fTrim(pTargetString)
{
	var vStartPoint = 0; // subString 하기 위한 시작 포인트
	var vEndPoint   = pTargetString.length; // subString 하기 위한 끝 포인트

	//문자열앞에 공백문자가 들어 있는 Index 추출
	while( (vStartPoint < vEndPoint) && (pTargetString.charCodeAt(vStartPoint) == 32) )
	{
		vStartPoint++;
	}

	//문자열뒤에 공백문자가 들어 있는 Index 추출
	while( (vStartPoint < vEndPoint) && (pTargetString.charCodeAt(vEndPoint-1) == 32) )
	{
		vEndPoint--;
	}
	// 공백을 제거했으면 subString하여 결과문자열을 리턴하고 제거한 내용이 없으면 그대로 리턴
	return ((vStartPoint > 0) || (vEndPoint < pTargetString.length) ) ? pTargetString.substring(vStartPoint, vEndPoint) : pTargetString;
	//return pTargetString.replace(/(^\s*)|(\s*$)/ig, "");
}


function trim(value)
{
  var str;
  var end;
  var result = true;
  for(j = 0; j < value.length; j++)
  {
    if(value.substring(j, j+1) != " ") {
      str=j;
      break;
    }
  }
  for(j = value.length-1 ;j> -1; j--)
  {
    if(value.substring(j, j+1) != " ") {
    	end=j;
    	break
    }
  }

  return value.substring(str, end+1);
}

/*
	내    용 : 문자열 앞뒤에있는 공백과 엔터값을 제거한다.
	파라미터 : pTargetString - 대상 문자열
	Return값 : 공백, 엔터값을 제거한 결과 문자열
*/
function fRemoveCRLF(pTargetString)
{
	var vStartPoint = 0; // subString 하기 위한 시작 포인트
	var vEndPoint   = pTargetString.length; // subString 하기 위한 끝 포인트

	//문자열앞에 공백문자가 들어 있는 Index 추출
	while( (vStartPoint < vEndPoint) && (pTargetString.charCodeAt(vStartPoint) == 10 || pTargetString.charCodeAt(vStartPoint) == 13 || pTargetString.charCodeAt(vStartPoint) == 32) )
	{
		vStartPoint++;
	}

	//문자열뒤에 공백문자가 들어 있는 Index 추출
	while( (vStartPoint < vEndPoint) && (pTargetString.charCodeAt(vEndPoint-1) == 10 || pTargetString.charCodeAt(vEndPoint-1) == 13 || pTargetString.charCodeAt(vEndPoint-1) == 32))
	{
		vEndPoint--;
	}

	// 공백을 제거했으면 subString하여 결과문자열을 리턴하고 제거한 내용이 없으면 그대로 리턴
	return ((vStartPoint > 0) || (vEndPoint < pTargetString.length) ) ? pTargetString.substring(vStartPoint, vEndPoint) : pTargetString;
}


/*
	내    용 : 문자열중의 특정 문자 또는 단어를 찾아 원하는 문자 또는 단어로 치환
	파라미터 :	pSourceString - 원본 문자열
					pFindWord     - 찾을 단어
					pReplaceWord  - 대체 단어
	Return값 : 대체하고난 문자열
*/
function fReplaceWord(pSourceString, pFindWord, pReplaceWord)
{
	if(pSourceString != ""){
		// 찾을 단어를 구분자로 분리한 문자열을 저장할 배열 변수
		var vTempArray;

		// 치환하여 리턴할 내용을 담을 변수
		var vReturnString = "";

		// 원본 문자열을 찾을 단어를 구분자로 분리
		vTempArray = pSourceString.split(pFindWord);

		// 찾을 단어의 수만큼 loop
		for(var i=0; i<vTempArray.length-1; i++)
		{
			// 찾을 단어 대신 대체 단어를 붙이면서 누적
			vReturnString += vTempArray[i] + pReplaceWord;
		}

		// 마지막 찾을 단어의 뒷부분 내용 추가. (찾을 단어가 없었다면 원본 문자열 전체가 됨)
		vReturnString += vTempArray[vTempArray.length-1];
	}else vReturnString = pSourceString;
	return vReturnString;
}

/*
	내    용 : 파라미터로 받은 엘리먼트로 포커스 이동
	파라미터 : pTargetElementName - 포커스를 주고자 하는 Element 명
	Return값 : 없슴
*/
function fMoveFocus(pTargetElementName)
{
	// 눌려진 키가 "tab" 이라면 Skip
	if(event.keyCode == 9 || event.keyCode == 16) return;

	// 텍스트박스의 maxLength 만큼 입력한것이 아니면 Skip
	if((event.type == "keyup" || event.type == "click") && event.srcElement.type == "text" && event.srcElement.value.length != event.srcElement.maxLength) return;

	// 파라미터로 받은 Element 명을 통해 얻은 객체로 포커스 이동
	document.getElementById(pTargetElementName).focus();
}

/*
	내    용 : Tab 키를 눌렀을(onKeyDown 이벤트)때 파라미터로 받은 엘리먼트로 포커스 이동
	파라미터 :	 pTargetElementName - 포커스를 주고자 하는 Element 명
					pIndex - 배열일 경우 해당 인덱스
	Return값 : 없슴
*/
function fMoveFocusByTab(pTargetElementName, pIndex)
{
	var vIndex = 0;
	var vTempArray;

	// 인덱스 파라미터 값이 있으면 인덱스 변수에 저장
	if(typeof(pIndex) != "undefined" && pIndex != "") vIndex = eval(pIndex);

	// 눌려진 키가 "tab" 이면
	if(event.keyCode == 9)
	{
		// Tab 키의 onKeyDown Event 를 소멸
		window.event.returnValue  = false;
		window.event.cancelBubble = true;

		// 파라미터로 받은 엘리먼트로 포커스 이동
		vTempArray = document.getElementsByName(pTargetElementName);
		if(vTempArray.length > 1) vTempArray[vIndex].focus();
		else vTempArray[0].focus();
	}
}

/*
	내    용 : 체크박스들의 체크상태를 일괄 변경
	파라미터 : pCheckBoxName - 체크상태를 변경할 체크박스 이름
	Return값 : 없슴
*/
function fSelectAllCheckBox(pCheckBoxName)
{

	// 파라미터로 받은 이름을 가진 Element 의 배열을 변수에 저장
	var vCheckBoxArray = document.getElementsByName(pCheckBoxName);
	// 배열의 갯수만큼 loop
	for(var i=0; i<vCheckBoxArray.length; i++)
	{
		// 체크상태 변경
		vCheckBoxArray[i].checked = event.srcElement.checked;
	}
}

/*
	내      용 : 체크된 체크박스 갯수를 리턴한다.
	파라미터 : pCheckBoxName - 체크상태를 변경할 체크박스 이름
	Return값 : 갯수
*/
function fCountCheckedCheckBox(pCheckBoxName)
{
	// 파라미터로 받은 이름을 가진 Element 의 배열을 변수에 저장
	var vCheckBoxArray = document.getElementsByName(pCheckBoxName);
	var nChk = 0;			//Checked CheckBox Count

	// 배열의 갯수만큼 loop
	for(var i=0; i<vCheckBoxArray.length; i++){
		// 체크상태 변경
		if(vCheckBoxArray[i].checked)  nChk++;
	}

	return nChk;
}

/*
	내    용 : Radio Box 체크
	파라미터 :	 pRadioBoxName - 라디오박스 이름
					pCheckedValue - 체크할 값
	Return값 : 없슴
*/
function fSetRadioChecked(pRadioBoxName, pCheckedValue){
	// 파라미터로 받은 이름을 가진 Element 의 배열을 변수에 저장
	var vRadioBoxArray = document.getElementsByName(pRadioBoxName);
	// 배열의 갯수만큼 loop
	for(var i=0; i<vRadioBoxArray.length; i++){
		// 체크상태 변경
		if(vRadioBoxArray[i].value == pCheckedValue) vRadioBoxArray[i].checked = true;
		else vRadioBoxArray[i].checked = false;
	}
}

/*
	내    용 :Radio Box checked True인 값을 리턴
	파라미터 :  pCtlName(개체명)
	Return값 : 없슴
*/
function fGetRadioChecked(pRadioBoxName){

	var vRtn = "";
	// 파라미터로 받은 이름을 가진 Element 의 배열을 변수에 저장
	var vRadioBoxArray = document.getElementsByName(pRadioBoxName);
	// 배열의 갯수만큼 loop

	for(var i=0; i<vRadioBoxArray.length; i++){
		// 체크상태 변경
		if(vRadioBoxArray[i].checked){
			vRtn = vRadioBoxArray[i].value;break;
		}
	}
	return vRtn
}


/*
	내    용 : 활성화, 비활성화 setting - 한 개
	파라미터 :	pCtrl - 개체명
					pBoolean - True or False
	Return값 : 없슴
*/
function fSetDisable(pCtrl, pBoolean){
	pCtrl.disabled = pBoolean;
}

/*
	내    용 : 활성화, 비활성화 setting - 다수
	파라미터 :	pCtrl - 개체명
					pBoolean - True or False
	Return값 : 없슴
*/
function fSetDisable_(pCtrl, pBoolean){
	for(var intCtrl=0;intCtrl<pCtrl.length;intCtrl++) pCtrl[intCtrl].disabled = pBoolean;
}

/*
	내    용 : Display setting 한 건
	파라미터 :	pCtrlName    - 개체명
					pBoolean - True or False
	Return값 : 없슴
*/
function fSetDisplay(pCtrl, pBoolean)
{

	if(pBoolean) pCtrl.style.display = '';
	else pCtrl.style.display = 'none';
}

/*
	내    용 : 파라미터로 받은 DIV 영역에 새로운 HTML Code 를 삽입
	파라미터 : pDivName - Target DIV 객체명
					[pHtml]  - Display할 HTML Code
	Return값 : 없슴
*/
function fDisplayDiv(pDivName, pHtml)
{
	// 파라미터로 받은 DIV 영역에 새로운 HTML Code 를 삽입
	document.getElementById(pDivName).innerHTML = pHtml;
}

/*
	내    용 : 파라미터로 받은 DIV 영역의 HTML Code를 제거
	파라미터 : pDiv - Target DIV 객체
	Return값 : 없슴
*/
function fClearDiv(pDivName)
{
	document.getElementById(pDivName).innerHTML = "";
}


/*
	내    용 : 넘어온 값에서 앞에 0을 빼고 리턴한다.
	파라미터 : strNum : 01
*/
function getSingleDateNumber(strNum) {
	if (strNum.length == 2 && strNum.charAt(0) == '0') return strNum.charAt(1);

	return strNum;

}

/*
	내    용 : 넘어온 값에서 앞에 0을 더하고 리턴한다.
	파라미터 : strNum : 01
*/
function getDoubleDateNumber(strNum) {
	if (strNum.toString().length == 1) return "0" + strNum.toString();
	return strNum;

}


/*
	내    용 : selectbox multiple일 경우 모든 값을 넘기기 위한..
	파라미터 : pCtl - 적용할 개체명
*/
function fGetMultiSelected(pCtrl){
	for(var intLoop=0; intLoop < pCtrl.length;intLoop++){
		pCtrl.options[intLoop].selected = true;
	}
	return true;
}

/*
	내    용 : 정확한 이메일을 입력받기 위한 이메일 유효성 체크
	파라미터 : pCtl - 적용할 개체명
*/
function fCheckEmail_ (pCtrl)
{
	var strEmail = pCtrl.value;
	if ((fTrim(strEmail) != "") && (strEmail.search(/(^\..*)|(.*\.$)/) != -1 || strEmail.search(/\S+@(\S+)\.(\S+)/) == -1)) {
		alert("이메일주소가 올바르지 않습니다.");
		pCtrl.focus();
		return false;
	}else return true;
}

/*
	내    용 : 정확한 이메일을 입력받기 위한 이메일 유효성 체크
	파라미터 : pCtl - 적용할 개체명
*/
function fCheckEmail (pCtrl)
{
	var strEmail = pCtrl.value;
	if ((fTrim(strEmail) != "") && isEmail(strEmail) == false) {
		var strRepEmail = fReplaceWord(strEmail, "@", "");
		if(!(fIsAlphabet(strRepEmail) || fCheckNumber(fConvertAmountToNumber(strRepEmail))))
		{
			alert("이메일주소은(는) 영문자 또는 숫자형이어야 합니다.");
			pCtrl.focus();
			return false;
		}else{
			alert("이메일주소가 올바르지 않습니다.");
			pCtrl.focus();
			return false;
		}
	}else return true;
}

/*
	이메일 체크 정규식
*/
function isEmail(s)
{
  return s.search(/^\s*[\w\~\-\.]+\@[\w\~\-]+(\.[\w\~\-]+)+\s*$/g)>=0;
}



/*
	내    용 : 문자열이 영문으로 구성되어 있는지 체크
				영문이면 true, 아니면 false 리턴	('060623 Made By Yun)
	파라미터 : str - 문자열
			   type - 'small' : 소문자
				      'big' : 대문자
					  'all' : 대소문자 모두
				      'small_s' : 대문자 + 공백 포함
				      'big_s' : 대문자 + 공백 포함
					  'all_s' : 대소문자 모두, 공백 포함
*/
function fIsEnglish(str,type)
{
    switch(type){
        case 'small':chars = /[^a-z]/g;break;
        case 'big':chars = /[^A-Z]/g;break;
        case 'all':chars = /[^a-z]/i;break;
        case 'small_s':chars = /[^a-z\s]/g;break;
        case 'big_s':chars = /[^A-Z\s]/g;break;
        case 'all_s':chars = /[^a-z\s]/i;break;
        default :chars = /[^a-z]/i;break;
    }
	if(str.match(chars) == null){
		return true;
	}
	return false;
}

/*
	내    용 : 문자열이 영문자, 숫자, _로 구성되어 있는지 체크
				영문자이면 true, 아니면 false 리턴, 전부 숫자이면 false
	파라미터 : str - 문자열
*/
function fIsAlphabet(str)
{
	if(isNaN(str))
	{
		for(var intLoop = 0; intLoop < str.length; intLoop++) {
			//var chr = str.substr(intLoop,1).toLowerCase();
			var chr = str.charAt(intLoop).toLowerCase();
			/* 영문과 숫자, '_' 사용 */
			if((chr < '0' || chr > '9') && (chr < 'a' || chr > 'z')&&(chr != '_'))
				return false;
		}
		return true;
	}
	else
	{
		return false;
	}
}

/*
	내    용 : 첫글자가 숫자이면 true, 그렇지 않으면 false
	파라미터 : str - 문자열
*/
function fIsFirstCharNumber(str)
{
	return !isNaN(str.charAt(0));
}

/*
	내    용 :  문자열이 공백을 가지고 있는지 없는지 체크
					공백이 있으면 true, 없으면 false 리턴
	파라미터 : str - 문자열
*/
function fIsWithEmpty(str)
{
	for(var intLoop=0; intLoop<str.length; intLoop++){
		if( " " == str.charAt(intLoop)) return true;
	}
	return false;
}

/*
	내    용 : 팝업화면 오픈하기
	파라미터 : pPath - 팝업이름
					pName - 팝업명
					pWidth - 가로 사이즈
					pHeight - 세로 사이즈
	Return값 : 없슴
*/
function fOpenWindow(pPath, pName, pWidth, pHeight, pState, pScroll, pReSize){
	var features;
	var t = screen.height / 2 - pHeight / 2;
	var l = screen.width  / 2 - pWidth  / 2;
	var option = "toolbar=no,menubar=no,location=no,scrollbars="+pScroll+",status="+pState+",resizable="+pReSize;

	features = "top=" + t + ",left=" + l + ",width=" + pWidth + ",height=" + pHeight + "," + option;

	var remote = window.open(pPath, pName, features);
	if (remote.opener == null){ remote.opener=window;}
	remote.focus();
}

/*
	내    용 : 위치지정 팝업화면 오픈하기
	파라미터 : pPath - 팝업이름
					pName - 팝업명
					pWidth - 가로 사이즈
					pHeight - 세로 사이즈
	Return값 : 없슴
*/
function fOpenWindow2(pPath, pName, pWidth, pHeight,pState, pScroll, pReSize, pTop, pLeft){
	var features;
	var t = pTop;
	var l = pLeft;
	var option = "toolbar=no,menubar=no,location=no,scrollbars="+pScroll+",status="+pState+",resizable="+pReSize;

	features = "top=" + t + ",left=" + l + ",width=" + pWidth + ",height=" + pHeight + "," + option;

	var remote = window.open(pPath, pName, features);
	if (remote.opener == null){ remote.opener=window;}

	remote.focus();

}

/*
	내    용 : selectbox multiple일 경우 모든 값을 넘기기 위한..
	파라미터 : pCtl - 적용할 개체명
*/
function fSetSelected(pCtl){
	for(var intLoop=0; intLoop < pCtl.length;intLoop++){
		pCtl.options[intLoop].selected = true;
	}
	return true;
}

/*
	내    용 : 차트 이미지를 크게 볼 수 있도록 윈도우를 오픈한다.
	파라미터 : pCtrl - 미리보기할 개체명
					pImgPath - 미리볼 파일 경로 [상수선언]
					pImgFileInfo - 미리 볼 파일 경로
	Return값 : 없슴
*/
function fShowBigGraph(pWidth,pHeight,pCtrl)
{
	theURL = pCtrl.src;
	//원본이미지 사이즈에 맞게 크게 조회할 팝업 사이즈를 저장한다.
	form.hiddenIMGPoPupWidth.value =pWidth;
	form.hiddenIMGPoPupHeight.value =pHeight;
	form.hiddenIMGPoPupUrl.value =theURL;
	fOpenWindow("/common/asp/showGraphWindow.asp", "imgChartPreViewWin", pWidth , pHeight, 'yes','yes','yes' );
}

/*
	내    용 : 승인알림 레이어 숨김/보임
	파라미터 : img - 이미지 개체명
	Return값 : 없슴
*/

function fShowhide_AlarmLayer(img) {
//alert(top.frames("main").frames("center").location.href);
	if (document.form.hiddenOnoff_flg.value == "open") {

		//top.frames("main").frames("center").document.all.alarmDIV.style.visibility="hidden";	//제어버튼위치가 top 프레임일때
		document.all.alarmDIV.style.visibility="hidden";	//제어버튼위치가 center 프레임일때
		//img.src = "/images/common/icon_next00.gif";
		document.form.hiddenOnoff_flg.value = "close";

	}else{
		//top.frames("main").frames("center").document.all.alarmDIV.style.visibility="visible";	//제어버튼위치가 top 프레임일때
		document.all.alarmDIV.style.visibility="visible";	//제어버튼위치가 center 프레임일때
		//img.src = "/images/common/icon_prev00.gif";
		document.form.hiddenOnoff_flg.value = "open";

	}
}

/*
	내    용 : 나의 즐겨찾기 추가 시 호출 함수
	파라미터 :
	Return값 : 없슴
*/
function OpenFavorite(){
	var vPath = "/myTourInfo/W08_FavoritePopup.asp";
	//window.open(url,"favoriteWin","toolbar=no,location=no,directories=no,status=1,menubar=no,scrollbars=no,resizable=1,width=800,height=520");
	fOpenWindow(vPath, 'favoriteWin', '800', '520', 'yes', 'no', 'yes');
}

/*
	내    용 : 쿠키 설정 값 가져오기
	파라미터 :
	Return값 : 없슴
*/
function getPopCookie(name) {
	var index = document.cookie.indexOf(name + "=");
	if (index == -1) return null;
	index = document.cookie.indexOf("=", index) + 1;
	var endstr = document.cookie.indexOf(";", index);
	if (endstr == -1) endstr = document.cookie.length;
	return unescape(document.cookie.substring(index, endstr));
}

/*
	내    용 : 쿠키 설정 값 세팅하기
	파라미터 :
	Return값 : 없슴
*/
function setPopCookie(sName, sValue) {
	var dT = new Date();
	// 파라미터로 받은 숫자만큼 이후 일자로 setting
	dT.setDate( dT.getDate() + eval(1));
	document.cookie = sName + "=" + escape(sValue) + "; expires=" + dT.toGMTString();
}

/*
	주민등록번호 체크하기
*/
function fCheckJumin(pJumin1, pJumin2){
	var bReturn = true;
	var tmp = 0;
	var vJumin1 = eval(pJumin1);
	var vJumin2 = eval(pJumin2);
	var yy = vJumin1.value.substring(0,2);
	var mm = vJumin1.value.substring(2,4);
	var dd = vJumin1.value.substring(4,6);
	var sex = vJumin2.value.substring(0,1);

	if ((vJumin1.value.length != 6 ) || ( mm < 1 || mm > 12 || dd < 1) )
	{
		alert ("주민등록번호를 제대로 입력하여 주십시오.");
		vJumin1.focus();
		return false;
	}

	if ( (sex != 1 && sex !=2 && sex !=3 && sex != 4) || (vJumin2.value.length != 7 ) )
	{
		alert( "주민등록번호를 제대로 입력하여 주십시오." );
		vJumin2.focus();
		return false;
	}

	for ( var i = 0; i <=5 ; i++ )
	{
		tmp = tmp + ((i%8+2) * parseInt(vJumin1.value.substring(i,i+1)));
	}

	for ( var i = 6 ; i <= 11 ; i++ )
	{
		tmp = tmp + ((i%8+2) * parseInt(vJumin2.value.substring(i-6,i-5)))
	}
	tmp = 11 - (tmp %11)
	tmp = tmp % 10

	if(tmp != vJumin2.value.substring(6, 7) )
	{
		alert ("잘못된 주민등록번호입니다.");
		vJumin1.focus();
		return false;
	}

	return true;
}

/*
내    용 : 받은 날짜의 넘겨진 구분값에 따라 평일수 혹은 주말수를 리턴한다.
파라미터 : pYear - 년도
		   pMonth - 월
		   pGubun - 평일 0, 주말 1
*/
function fSetOneMonthWeek(pYear, pMonth, pGubun){
	var sYear = ""; //년
	var sMonth = ""; //월
	var sDay = "01"; //일자
	var nDay = 0; //해당 년월에 일갯수
	var strYoIl = "0"; //요일
	var nWeekCount = 0; //주말수
	var nDayCount = 0; //평일수

	//넘겨진 날짜가 없을 경우에는 현재 날짜를 기준으로 계산한다.
	if(pYear == "" && pMonth == ""){
		//현재 날짜만 세팅할 경우
		var vCurrentDate = new Date();
		sYear = vCurrentDate.getYear();
		sMonth = getDoubleDateNumber(vCurrentDate.getMonth()+1);
	}else{
		sYear = pYear;
		sMonth = pMonth;
	}
	///////////////////////////////////////////////////////////
	//넘겨진 년월로 날짜 가져오기
	var vCurrentDate = new Date(sYear, getSingleDateNumber(sMonth)-1, getSingleDateNumber(sDay));
	// 현재 월의 일수 구하기
	var vCurrentMonthDateCount;
	var vTempMonth = vCurrentDate.getMonth();
	// 4,6,9,11월이면 30일
	if(vTempMonth == 3 || vTempMonth == 5 || vTempMonth == 8 || vTempMonth == 10){
		vCurrentMonthDateCount = 30;
	}else{
		if(vTempMonth == 1){
			// 윤년의 2월이면 29일
			if (vCurrentDate.getFullYear() % 4 == 0 && (vCurrentDate.getFullYear() % 100 != 0 || vCurrentDate.getFullYear() % 400 == 0)){
				vCurrentMonthDateCount = 29;
			// 그외의 2월이면 28일
			}else{
				vCurrentMonthDateCount = 28;
			}
		// 나머지는 31일
		}else{
			vCurrentMonthDateCount = 31;
		}
	}

	///////////////////////////////////////////////////////////
	//넘겨진 년월로 날짜별 평일, 주말 구하기
	//일자는 달에 따라 다르기 때문..
	var objDate;
	for(var intDay=0;intDay<vCurrentMonthDateCount;intDay++){
		nDay = intDay+1;
		objDate = new Date(sYear, getSingleDateNumber(sMonth)-1, getSingleDateNumber(nDay));
		//요일 (일, 월,화,수,목,금,토 => 0,1,2,3,4,5,6)
		strYoIl = objDate.getDay();
		if(strYoIl == "0" || strYoIl == "6"){
			++nWeekCount; //주말수
		}else if(strYoIl == "1" || strYoIl == "2"|| strYoIl == "3"|| strYoIl == "4"|| strYoIl == "5"){
			++nDayCount; //평일수
		}
	}

	//구분값에 따라 리턴한다.
	if (pGubun=="0") return nDayCount;
	else if(pGubun=="1") return nWeekCount;
}

/*
	내    용 : 파라미터로 받은 SPAN 영역에 새로운 TEXT 를 삽입
	파라미터 : pSpanName - Target SPAN 객체명
			   [pText]  - Display할 pText
	Return값 : 없슴
*/
function fDisplaySpan(pSpanName, pText)
{
	// 파라미터로 받은 SPAN 영역에 새로운 TEXT를 삽입
	document.getElementById(pSpanName).innerText = pText;
}

/*
	내    용 : 파라미터로 받은 SPAN 영역에 TEXT 를 지운다.
	파라미터 : pSpanName - Target SPAN 객체명
	Return값 : 없슴
*/
function fClearSpan(pSpanName)
{
	// 파라미터로 받은 SPAN 영역에 지운다.
	document.getElementById(pSpanName).innerText = "";
}



/**
* iframe 크기 자동 조절
*/

function resizeFrameSpam(frameName)
{
    try
    {
        //var oBody  = document.frames("dataFrame").document.body;
        //var oFrame  = document.all("dataFrame");
		var oBody = eval("document.frames('"+frameName+"').document.body;");
		var oFrame = eval("document.all('"+frameName+"');");

        if(oBody.readyState != "complete")
        {
            setTimeout( "reSize()", 100 );
            return; // 모든 객체가 완전히 로드된 후 한번만 조정하기 위해
        }

        var nMin = 200;
        oFrame.style.height = nMin;    // 조절 전 초기 사이즈를 잡아주지 않으면
                                      // IFRAME 내 페이지 Refresh 시 사이즈가 계속 증가할 수 있다.

        var nHeight = oBody.scrollHeight + (oBody.offsetHeight - oBody.clientHeight);
        if(nHeight < nMin) nHeight = nMin;

        oFrame.style.height = nHeight;
		oFrame.style.width=oBody.scrollWidth;
    }
    catch(e)
    {
        window.status = 'Error: ' + e.number + '; ' + e.description;
    }
}

// 플래시
function flashWrite(url,w,h,id,bg,win){

	// 플래시 코드 정의
	var flashStr=
	"<object classid='clsid:d27cdb6e-ae6d-11cf-96b8-444553540000' codebase='http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=8,0,0,0' width='"+w+"' height='"+h+"' id='"+id+"' align='middle'>"+
	"<param name='movie' value='"+url+"' />"+
	"<param name='wmode' value='"+win+"' />"+
	"<param name='menu' value='false' />"+
	"<param name='quality' value='high' />"+
	"<param name='bgcolor' value='"+bg+"' />"+
	"<embed src='"+url+"' wmode='"+win+"' menu='false' quality='high' bgcolor='"+bg+"' width='"+w+"' height='"+h+"' name='"+id+"' align='middle' type='application/x-shockwave-flash' pluginspage='http://www.macromedia.com/go/getflashplayer' />"+
	"</object>";
	// 플래시 코드 출력
	document.write(flashStr);
}


/**
* 글 등록시 TextArea에 바이트 제한 함수
* @name		getByteLen
* @param 	str	문자열
*			maxbyte 제한길이
* @return
*/
function getByteLen(str, array, maxbyte, inobj){

	var msgtext, msglen;
	msgtext = inobj.value;

	var i=0,l=0;
	var temp,lastl;

	//길이를 구한다.
	while(i < msgtext.length)
	{
		temp = msgtext.charAt(i);

		if (escape(temp).length > 4)
			l+=2;
		else if (temp!='\r')
			l++;
		// OverFlow
		if(l>maxbyte)
		{
			alert("이항목은 항목당 "+maxbyte+"Byte 이상 쓰실 수 없습니다.");
			temp = inobj.value.substr(0,i);
			inobj.value = temp;
			l = lastl;
			break;
		}
		lastl = l;
		i++;
	}
}






function CheckBank( f ){

	if( !f.bank_code.value ){
		alert("은행을 선택하세요.");
		f.bank_code.focus();
		return false;
	}

	if( !f.bank_account.value ){
		alert("계좌번호를 입력하세요.");
		f.bank_account.focus();
		return false;
	}
	if( !f.bank_account_name.value ){
		alert("예금주를 입력하세요.");
		f.bank_account_name.focus();
		return false;
	}
	if( !f.bank_account_regist.value ){
		alert("예금주 주민등록(사업자)번호를 입력하세요.");
		f.bank_account_regist.focus();
		return false;
	}
	if( !f.bank_account_regist.value.jumin() && !f.bank_account_regist.value.biznum() ){
		alert("예금주 주민등록(사업자)번호를 올바르게  입력하세요.");
		f.bank_account_regist.focus();
		return false;
	}
	return true;
}