/*****************************************************************************************************
 * File Name 	: SCClient.js
 * @author ATTO Information Technology Corp. eWork R&D Team 
 * @since 2007. 5. 16
 * @version 3.0
 * ----------------------------------------------------------------------------------------------------
 * Modification Information
 * Date          Developer           Content
 * -------       -------------       ---------------------------
 * 2007.06.07    YongHanLee		     Create     
 * 2007.10.01    Hongki Lee		     Modify Function SCObjectControl.getJspFileName()
 * 2008.05.13    KimKS		     	 메시지 상수 추가(SCMSG_NO_SELDATA)
 * 2008.05.22    KimKS		     	 SCTreeControl추가
 * 2008.06.08    KimKS		     	 isDataSelected에 Data Field 추가, showLayer, showCenterLayer, hiddenLayer 변경, fieldValidation 추가
 * 2008.08.11    KimKS		     	 동적인 combobox 처리기능 SCDataControl에 추가
 * 2008.11.18    KimKS		     	 HTML Editor Xquared --> fckeditor로 변경
 * ----------------------------------------------------------------------------------------------------
 * Copyright (C) 2007 by ATTO Information Technology Corp. eWork R&D Team  All rights reserved.
 *****************************************************************************************************/


/**
 * 상수선언
 */
var SCConst ={
	USE_STATE			: true,
	NO_TRANS 			: 0,
	INS_TRANS 			: 1, 
	UPD_TRANS 			: 2,
	DEL_TRANS 			: 4,
	CHAR_SPLIT 			: "|",
	CHAR_SPLIT1 		: ",",
	CHAR_SPLIT2 		: "__",
	CHAR_SPLIT3 		: "&",
	CHAR_SPLIT4 		: ":",
	CHAR_SPLIT5 		: "-",
	CHAR_SPLIT6 		: "/",
	CHAR_SPLIT7 		: ".",
	CHAR_SPLIT8 		: "__0",
	CHAR_SPLIT9 		: ";",
	CHAR_SPLIT10		: "|*|",
	GROUP_DATA			: "DATA",
	GROUP_KEY			: "KEY",
	DATA_SET 			: "DataSet",
	TABLE 				: "Table",
	DATAFLAG 			: "DataFlag",
	HEADER_CLASS 		: "DataHeader",
	TEMPLATE_CLASS		: "DataTemplate",
	DATAROW_CLASS 		: "DataRow",
	CHECKBOX_CLASS 		: "SelectCheckBox",
	RADIOBTN_CLASS		: "SelectRadioBox",
	DATAFLD_NAME 		: "dataFld",
	UNDEFINED 			: "undefined",
	OBJECT 				: "object",
	ACC_KEY_M 			: "M",
	ACC_KEY_O 			: "O",
	CHK_SELECT 			: "SelectToggle",
	CHK_UNSELECT 		: "UnSelectToggle",
	TOTAL_SEL_IMG 		: "btn03SelectAll.gif",
	TOTAL_UNSEL_IMG 	: "btn03SelectCancel.gif",
	GLOBAL_FORM 		: "frmGlobal",
	ReLoadTIME_SEC		: "10",
	SCMSG_CHECK_TEMROW	: "Template Row가 존재하지 않습니다. \n로우를 추가하기 위해서는 Template Row가 가 반드시 디자인 있어야 합니다.",
	SCMSG_CHECK_TBODY 	: "TBODY 태그가 존재하지 않습니다. \n로우를 추가하기 위해서는 TBODY가 가 반드시 디자인 되어 있어야 합니다.",
	SCMSG_CHECK_INPUT 	: "(을)를 반드시 입력하시기 바랍니다.",
	SCMSG_CHECK_GROUP 	: " 그룹 항목이 없어서 전송하지 않았습니다.",
	SCMSG_PROCESS_OK	: "정상적으로 데이터가 처리되었습니다.",
	SCMSG_NO_CHANGE	 	: "변경된 데이터가 없습니다.",
	SCMSG_NO_DELETE 	: "삭제할 데이터가 없습니다.",
	SCMSG_NO_SAVEDATA 	: "저장할 데이터가 없습니다.",
	SCMSG_NO_SELDATA 	: "선택된 데이터가 없습니다.",
	SCMSG_NO_MULTISEL 	: "여러 개를 선택할 수 없습니다.",
	SCMSG_DUM_DATA 		: "중복된 데이터가 있습니다.",
	SCMSG_SAVE 			: "입력한 데이터를 저장하시겠습니까?",
	SCMSG_SAVE_TEMP		: "입력한 데이터를 임시로 저장하시겠습니까?",
	SCMSG_SAVE_FINAL	: "입력한 데이터를 저장하시겠습니까? \n\r저장한 데이터는 더 이상 수정할 수 없습니다.",
	SCMSG_FILE_TRANSE	: "입력한 파일을 전송하시겠습니까?",
	SCMSG_SELECT_DELETE : "선택한 데이터를 삭제하시겠습니까?",
	SCMSG_SELECT_COPY 	: "복사할 로우를 선택하고 하셔야 합니다.",
	SCMSG_NO_DATE 		: " 데이터가 날짜 형식이 아닙니다.",
	SCMSG_NO_TIME 		: " 데이터가 시간 형식이 아닙니다.",
	SCMSG_NO_TIME24 	: " 24:00는 시간으로 허용하지 않습니다.(ex:23:59)",
	SCMSG_NO_NUMBER 	: " 데이터가 숫자 형식이 아닙니다.",
	SCMSG_SAVE_DO		: "변경된 데이터가 있습니다. \n\r저장 후 작업 하시겠습니까?",
	SCMSG_MOUSE_CLICK 	: "마우스로 클릭하시면 상세내용을 보실 수 있습니다.",
	SCMSG_INPUT_DATA 	: "올바른 값을 입력해주시기 바랍니다.",
	SCMSG_FILE_LIMIT_CNT: "업로드할 수 있는 파일 개수를 초과했습니다.",
	SCMSG_FILE_LIMIT_EXT: "업로드할 수 없는 확장자 입니다.",
	SCMSG_CHAR_LIMIT_OVR: "의 입력한도를 초과했습니다.",
	NO_PRINT_PAGE		: "인쇄를 지원하지 않는 화면입니다.",
	DATA_Y				: "Y",
	DATA_N				: "N",
	MSG9999 			: "" ,
	ENTER_OBJ_NAME		: [] ,
	ENTER_CALL_FUNC		: [] 
};



/**
 * 웹브라우저 체크 컨트롤
 * 호출방법1 : if(SCBrowser.ie){} 
 */
var SCBrowserControl={
    ie     : navigator.userAgent.indexOf('MSIE') != -1 ,
    mac45  : navigator.userAgent.indexOf('MSIE 4.5; Mac_PowerPC') != -1 ,
    opera  : navigator.userAgent.indexOf('Opera') != -1 ,
    safari : navigator.userAgent.indexOf('Safari') != -1 ,
    firefox  : navigator.userAgent.indexOf('Firefox') != -1, 
    khtml  : navigator.userAgent.indexOf('Konqueror') != -1 
};


/**
 * 윈도우 처리 관련 컨트롤
 */
var SCWindowControl={

	/**
	 * 팝업윈도우 호출
	 * 호출방법1 : SCWindowControl.showWindow("AnTaWorksGroupP.jsp", "AnTaWorksGroupP", 700, 400, "");
	 * 호출방법2 : SCWindowControl.showWindow("AnTaWorksGroupP.jsp?Param01=" + strID, "AnTaWorksGroupP", 700, 400, "toolbar=no, location=no, menubar=no, scrollbars=yes, status=yes, resizable=yes");
	 * @param {String} strPageURL 오픈할 윈도우 경로
	 * @param {String} strWindowName 오픈할 윈도우 이름(_self, _blank, ...)
	 * @param {int} intWidth 윈도우의 폭 넓이 
	 * @param {int} intHeight 윈도우의 높이
	 * @param {String} strOptions 팝업 윈도우의 옵션
	 */
	showWindow:function(strPageURL, strWindowName, intWidth, intHeight, strOptions){
		var blnOption = true;
		//intWidth, intHeight, strOptions가 동시에 없을 경우 일반 window.open 처리를 할 수 있게 속성적용를 하지 않는다.
		if(typeof(intWidth) === SCConst.UNDEFINED && typeof(intHeight) === SCConst.UNDEFINED && typeof(strOptions) === SCConst.UNDEFINE){
			blnOption = false;
			strOptions = "";
		}
		
		if(blnOption){
			if (strOptions === ""){
				strOptions = "toolbar=no, location=no, menubar=no, scrollbars=no, status=yes, resizable=yes";	
			}
			var lngTop = (window.screen.height - intHeight) / 2;
			var lngLeft = (window.screen.width - intWidth) / 2;
			
			strOptions += ", width=" + intWidth + ", height=" + intHeight + ", top=" + lngTop + ", left=" + lngLeft;
		}
		
		return window.open(strPageURL,strWindowName,strOptions);
	},
	
	/**
	 * 파일첨부 공통 윈도우 호출
	 * @param {String} strTitleID 파일 첨부 윈도우 타이틀에 표시할 MSGID
	 * @param {String} strCommentID 첨부 첨부 윈도우 COMMENT란에 표시할 MSGID
	 * @param {String} strCallFunc 정상처리 시 부모창에 호출할 함수명
	 *                           주의 : strCallFunc함수명의 파라메터는 한개로 반드시 strValue명을 가지고 있어야 한다. ex)FileUpDownGuide.procFiles(strValue)
	 * @param {String} strFileExt 파일 업로드를 허용할 확장자명 모두 허용 "*" 부분적으로 허용 (jpg|gif|...)
	 * @param {int} intLimitCnt 파일 제한 개수 (-1 or 0 :제한없음)
	 * @param {boolean} blnHash 파일에 대한 Hash 처리를 할지 여부
	 * @param {lng} lngLimitSize 파일 크기 제한 바이트 (-1 or 0 :제한없음)
	 */
	showAttacheFile:function(strTitleID, strCommentID, strCallFunc, strFileExt, intLimitCnt, blnHash, lngLimitSize){
		var strURL = "/srcweb/cm/cmcm/CmCmFileUploadP.jsp";
		//blnHash 초기값설정
		var blnHashData = false;		
		if(typeof(blnHash) !== SCConst.UNDEFINED && typeof(blnHash) === 'boolean'){blnHashData = blnHash;}

		if(typeof(lngLimitSize) === SCConst.UNDEFINED){lngLimitSize = -1;}

		var strAddedParams = "ATTCH_TITLE_ID=" + strTitleID + "&ATTCH_COMMENT_ID=" + strCommentID + "&CALL_FUNCTION=" + strCallFunc + "&FILE_EXT=" + strFileExt + "&LIMIT_CNT=" + intLimitCnt + "&IS_HASHDATA=" + blnHashData + "&MAX_FILE_SIZE=" + lngLimitSize;
		var strOptions = "toolbar=no, location=no, menubar=no, scrollbars=no, status=yes, resizable=no";

		SCActionControl.initAction();
		SCActionControl.linkPage(strURL, strAddedParams,"fileattache", 500, 420, strOptions);
	},
	
	/**
	 * 파일 다운로드
	 * @param {String} strAttchNo 첨부파일번호
	 */
	downLoadFile:function(strAttchNo){
		var strURL = gRootWebContents + "/FileDownload.action?ATTCH_NO=" + strAttchNo + "&RESULT_NAME=error&RESULT_URL=/srcweb/cm/cmcm/CmCmErrorViewR.jsp";
		this.showWindow(strURL, "filedown", 300, 150, "");
	},
	
	/**
	 * 원하는 차수의 이전 윈도우로 이동
	 * @param {int} intSeq 이동할 차수 (-1:이전)
	 */
	goHistory:function(intSeq){
		window.history.back(intSeq);
	}
	
};


var SCErrorControl={
	/**
	 * 윈도우 오류의 원인을 위치와 함께 보여주는 함수
	 * 호출방법 :try{} catch(objErr){SCErrorControl.doErrorRtn(objErr, "자신의함수명");}
	 * @param {Object} objEx Exception 객체
	 * @param {String} strSource 호출한 함수명
	 */
	doErrorRtn:function(objEx, strSource){
		if(objEx.number !== 0 ) {
			var strExName = "";
			if (objEx.name != "undefined"){
				strExName = objEx.name + " <-- ";	
			}
			SCMsgControl.alertMsg( "Error Number : " + objEx.number + "\r\n\r\n" + 
			    	 "Error Description : " + objEx.description + "\r\n\r\n" + 
			     	 "Error Source : " +  strExName + strSource,"");
		}		
	},
	
	
	
	/**
	 * 윈도우 오류 위치를 추적하기 위해 오류 정보 위치와 원인을 에러 객체에 추가하는 함수 
	 * 호출방법 :try{} catch(objErr){throw SCErrorControl.raiseSysErr(objErr, "자신의함수명");}
	 * @param {Object} objEx Exception 객체
	 * @param {String} strSource 호출한 함수명
	 */
	raiseSysErr:function(objEx,strSource){
		objEx.name = objEx.name + " <-- " + strSource ;
		return objEx;
	}
		
	
};



var SCObjectControl={

	/**
	 * 이벤트에서 반환되는 객체를 이용하여 엘리멘트 객체를 반환한다.
	 * 호출방법 : var objElement = SCObjectControl.getObject(event);
	 * @param {Object} event 이벤트에서 반환되는 객체
	 * @return {Object} 엘리멘트 객체
	 */
	getObject:function(event){
		return event.target || event.srcElement;
	}, 
	
	
	/**
	 * 태그 엘리멘트의 왼쪽기준으로 떨어진 좌표를 반환한다.
	 * 호출방법 : alert(SCObjectControl.getOffsetLeft(obj));
	 * @param {Object} obj 태그 엘리멘트
	 * @return {int} 좌표값
	 */
	getOffsetLeft:function(obj){
		var intLeft = obj.offsetLeft;
		while ((obj = obj.offsetParent) !== null){
			intLeft += obj.offsetLeft;	
		}
		return intLeft;
	},	
	
	/**
	 * 태그 엘리멘트의 상단기준으로 떨어진 좌표를 반환한다.
	 * 호출방법 : alert(SCObjectControl.getOffsetTop(obj));
	 * @param {Object} obj 태그 엘리멘트
	 * @return {int} 좌표값
	 */	
	getOffsetTop:function(obj){
		var intTop = obj.offsetTop;
		while ((obj = obj.offsetParent) !== null){
			intTop += obj.offsetTop;	
		}
		return intTop;
	},
	
	/**
	 * Window 객체의 Location정보를 이용하여 JSP명을 추출한다.
	 * @param {Object} objWindow
	 */
	getJspFileName:function(objWindow){
		var strPageURL = objWindow.location.href + "?";
		var strFileName = strPageURL.substring(strPageURL.lastIndexOf("/") + 1, strPageURL.length);
		strFileName = strFileName + "?";
		strFileName = strFileName.substring(0, strFileName.indexOf("?"));
		strFileName = strFileName + "#";
		strFileName = strFileName.substring(0, strFileName.indexOf("#"));
		return strFileName;
	},
	
	
	/**
	 * 스크롤에 따라서 레이어가 따라간다.
	 * @param {Object} strFlowDivId
	 * @param {Object} strOutDivId
	 * @param {Object} intTop
	 * @param {Object} intLeft
	 */
	flowLayer:function(strFlowDivId, strOutDivId, intTop, intLeft){
		$(strFlowDivId).style.top = SCObjectControl.getOffsetTop($(strOutDivId)) + intTop + "px";
		$(strFlowDivId).style.left = SCObjectControl.getOffsetLeft($(strOutDivId)) + intLeft + "px";
		$(strFlowDivId).style.visibility = "visible";
		$(strOutDivId).style.height = $(strFlowDivId).offsetHeight + (intTop*2);
		SCObjectControl.returnFlowLayer( strFlowDivId, strOutDivId, intTop, intLeft);	
	},

	returnFlowLayer:function(strFlowDivId, strOutDivId, intTop, intLeft){
		var intElementStart, intElmentEnd, intOffSet, intTimeoutNextCheck;
		intElementStart = parseInt ($(strFlowDivId).style.top, 10); //레이어의 현재 위치
		
		if( (document.body.scrollTop + $(strFlowDivId).offsetHeight) > (SCObjectControl.getOffsetTop($(strOutDivId)) + $(strOutDivId).offsetHeight - intTop) ) {
			intElmentEnd = SCObjectControl.getOffsetTop($(strOutDivId)) + $(strOutDivId).offsetHeight - $(strFlowDivId).offsetHeight - intTop;
		} else if(document.body.scrollTop >= SCObjectControl.getOffsetTop($(strOutDivId))) {
			intElmentEnd = document.body.scrollTop + intTop; //레이어가 이동해야할 위치
		} else {
			intElmentEnd = SCObjectControl.getOffsetTop($(strOutDivId)) + intTop; //레이어가 이동해야할 위치
		}
		
		intTimeoutNextCheck = SCConst.ReLoadTIME_SEC;
		if ( intElementStart !== intElmentEnd ) {
			intOffSet = Math.ceil( Math.abs( intElmentEnd - intElementStart ) / 10 );
			if ( intElmentEnd < intElementStart ) {intOffSet = -intOffSet;}
	
			$(strFlowDivId).style.top = parseInt ($(strFlowDivId).style.top, 10) + intOffSet + "px";	
		}
		$(strFlowDivId).style.left = SCObjectControl.getOffsetLeft($(strOutDivId)) + intLeft + "px";

		setTimeout ("SCObjectControl.returnFlowLayer('"+strFlowDivId+"','"+strOutDivId+"',"+intTop+","+intLeft+")", intTimeoutNextCheck);
	},
	
	
	/**
	 * 남은 '입력 가능한 글자수' 계산
	 * 
	 * @param {String} 문자 수를 측정하고자 하는 원본 데이터가 있는 영역의 Element ID
	 * @param {String} 측정 결과 메시지를 출력하고자 하는 영역의 Element ID
	 * @param {int} 입력 가능한 최대 글자 수
	 * @param {int} 유니코드 방식 여부 (1 = Unicode, 0 또는 빈칸 = ASCII)
	 * @param {booolean} blnTextBox 텍스트박스여부
	 */
	countChars:function(strTextArea, strLabel, intMaximum, intUnicode, blnTextBox){
		var intChars = 0;
		var strChars = "";
		if(typeof(blnTextBox) === SCConst.UNDEFINED){blnTextBox = false;}

		intChars = this.retCountChars(strTextArea, intUnicode);
		if(intChars > intMaximum) {
			strChars = intChars - intMaximum;
			if(blnTextBox){
				$(strLabel).style.color = "red";
				$(strLabel).value = strChars + " 글자가 초과되었습니다.";
			} else{
				$(strLabel).innerHTML = "<SPAN class='CharBRed'>" + strChars + "</SPAN><SPAN class='CharGray''> 글자가 초과되었습니다.</SPAN>";	
			}
		} else {
			strChars = intMaximum - intChars;
			if(blnTextBox){
				$(strLabel).style.color = "gray";
				$(strLabel).value = strChars + " 글자가 남았습니다.";
			} else{
				$(strLabel).innerHTML = "<SPAN class='CharBGray'>" + strChars + "</SPAN><SPAN class='CharGray'> 글자가 남았습니다.</SPAN>";
			}
			
		}
	},
	
	/**
	 * @param {String} 문자 수를 측정하고자 하는 원본 데이터가 있는 영역의 Element ID
	 * @param {int} 유니코드 방식 여부 (1 = Unicode, 0 또는 빈칸 = ASCII)
	 * @return {int} 문자 수
	 */
	retCountChars: function(strTextArea, iUnicode) {
		var retVal = 0;
		if(iUnicode == 1) {
			retVal = ($(strTextArea).value).length;
		} else {
			retVal = this.SCObjectControl.calBytes($(strTextArea).value);
		}
		
		return retVal;
	},
	
	/**
	 * 문자열의 바이트 수를 계산
	 * 한글 1자 = 2 바이트, 영문 1자 = 1바이트.
	 * function SCObjectControl.countChars()에 의해 호출되며, 직접적인 사용은 금한다.
	 * 
	 * @param {String} 바이트 수를 측정하고자 하는 원본 문자열
	 */
	calBytes:function(str){
		var tcount = 0; 
		var tmpStr = new tmpStr(str); 
		var temp = tmpStr.length;
		var onechar; 
		for (k=0; k<temp; k++ ) { 
			onechar = tmpStr.charAt(k); 
			if (escape(onechar).length > 4) { 
				tcount += 2; 
			} else { 
				tcount += 1; 
			} 
		} 
		return tcount; 
	},
	
	/**
	 * 엘리멘트인지 체크
	 * @param {Object} objData
	 * @return {boolean} 
	 */	
	isElement:function(objData){
		if(objData.tagName === eval(SCConst.UNDEFINED)){
			return false;
		} else {
			return true;
		}
	},
	
	addEvent: function(strElement, strEvent, objProc) {
		if ($(strElement)) {
			Event.observe(strElement, strEvent, objProc);
		}
	},
	
	/**
	 * 오브젝트에서 Enter를 칠 경우 자동으로 호출할 함수정보를 초기화한다.
	 */
	clearEnterCallFunc:function(){
		SCConst.ENTER_OBJ_NAME = [];
		SCConst.ENTER_CALL_FUNC = [];
	},
	
	/**
	 * 해당 ID 이름을 가진 오브젝트에서 Enter를 칠 경우 자동으로 호출할 함수명을 등록한다.
	 * 등록한 해당 ID이름과 함수명은 해당 object에서 사용자가 엔터를 칠경우 내부에서 자동으로 호출해주게 된다.
	 * @param {String} strIDName objectID 이름
	 * @param {String} strFuncName 호출할 함수명
	 */
	addEnterCallFunc:function(strIDName, strFuncName){
		//중복이름으로 처리시 계속 동일 이름이 증가하는 것을 방지하기 위해 이름으로 찾아서 없을 경우 
		//push하고 있으면 해당 인넥스값을 이용하여 해당 strResultURL 값을  업데이트 한다.[20080616-LEEYH]
		var intFindIndex = SCObjectControl.findIDName(strIDName); 

		if (intFindIndex >= 0){
			SCConst.ENTER_CALL_FUNC[intFindIndex] = strFuncName;
		} else {
			SCConst.ENTER_OBJ_NAME.push(strIDName);
			SCConst.ENTER_CALL_FUNC.push (strFuncName);
		}
	},
	
	/**
	 * ENTER_OBJ_NAME객체 안에 동일 이름이 있는지 체크하여 있을 경우 해당 인덱스값을 반환한다.
	 * @param {String} strIDName ENTER_OBJ_NAME의 이름값
	 * @return {int} 찾은 인덱스값, 없을 경우 -1
	 */
	findIDName:function(strIDName){
		for (var i=0; i < SCConst.ENTER_OBJ_NAME.size(); i++){
			if(SCConst.ENTER_OBJ_NAME[i] === strIDName){
				return i;
			}
		}
		return -1;
	},
	
	/**
	 * 해당 엘리멘트 데이터 길이가 MaxLen와 같을 경우 TargetElement로 포커스를 이동시킨다.
	 * 일반적으로 해당오브젝트의 KeyUp이벤트에서 호출된다.
	 * @param {Object} objElement 해당 오브젝트 객체
	 * @param {String} strTargetElementID 포커스가 이동한 오브젝트 객체 ID
	 */
	moveForcusForMaxLen:function(objElement, strTargetElementID){
		var intMaxLen = objElement.maxLength;
		var intLen = $F(objElement).length;
		if (intMaxLen === null || intMaxLen === 0){return;}
		if(intMaxLen <= intLen){
			$(strTargetElementID).focus();
		}
	}
};
	



var SCDateControl = {

	/**
	 * 날짜를 나타내는 문자열에 연,월,일 등을 연산
	 * @param {String} strInterval "Y" : 년, "Q" : 분기, "M" : 월, "D" : 일, "W" : 주, "H" : 시간, "N" : 분, "S" : 초, "MS" : 밀리세컨드 
	 * @param {int} intNumber 증감수
	 * @param {String} strDate 계산할 대상의 날짜
	 * @return {String} 계산된 날짜
	 */
	dateAdd:function(strInterval, intNumber, strDate){
		var strReplace =  /-/i;
		var strDash = "-";
		if(strDate === null || typeof(strDate) === SCConst.UNDEFINED || strDate === "") {return "";}
		var intIndex = strDate.indexOf(strDash);
		
		for(var i=0; i<intIndex; i++){
			strDate = strDate.replace(strReplace,"/");
		}

		intNumber = parseInt(intNumber,10);
		var dtDate = new Date(strDate);
		switch(strInterval.toLowerCase()){
			case "y":
				dtDate.setFullYear(dtDate.getFullYear() + intNumber);
				break;
			case "q": 		// quarter
				dtDate.setMonth(dtDate.getMonth() + (intNumber*3));
				break;
			case "m": 		// month
				dtDate.setMonth(dtDate.getMonth() + intNumber);
				break;
			case "w": 		// weekday
				dtDate.setDate(dtDate.getDate() + (intNumber * 7));
				break;
			case "d": 		// day
				dtDate.setDate(dtDate.getDate() + intNumber);
				break;
			case "h": 		// hour
				dtDate.setHours(dtDate.getHours() + intNumber);
				break;
			case "n": 		// minute
				dtDate.setMinutes(dtDate.getMinutes() + intNumber);
				break;
			case "s": 		// second
				dtDate.setSeconds(dtDate.getSeconds() + intNumber);
				break;
			case "ms": 		// millisecond
				dtDate.setMilliseconds(dtDate.getMilliseconds() + intNumber);
				break;
			default: 
				return "invalid interval: '" + strInterval + "'";
		}
	
		var intMon = dtDate.getMonth() + 1;
		if(intMon < 10){intMon = "0" + intMon.toString();}
		
		var intDay = dtDate.getDate();
		if(intDay < 10){intDay = "0" + intDay.toString();}

		return dtDate.getFullYear() + "-" + intMon + "-" + intDay;
	},
	
	
	
	/**
	 * 날짜타입인지 체크 
	 * @param {Object} strDate 날짜형식의 문자열
	 */
	isDate:function(strDate){
		var strDateInt = SCStringControl.replaceString(strDate,"\-","");
		var blnDate = false;
		strDateInt = SCStringControl.replaceString(strDateInt,"\/","");
		strDateInt = SCStringControl.replaceString(strDateInt,"\:","");
		strDateInt = SCStringControl.replaceString(strDateInt," ","");

		if(SCNumberControl.isInteger(strDateInt)){
			switch (strDateInt.length) {
				case 14 : //YYYYMMDDHHMMSS
					if(strDateInt.substring(0,4).isYear() && strDateInt.substring(4,6).isMonth()  && strDateInt.substring(6,8).isDay() && strDateInt.substring(8,10).isHour() && strDateInt.substring(10,12).isMinute() && strDateInt.substring(12,14).isSecond()){
						blnDate = SCDateControl.isDay(strDateInt.substring(0,4), strDateInt.substring(4,6), strDateInt.substring(6,8));					
					}
					break;
				case 12 : //YYYYMMDDHHMM
					if(strDateInt.substring(0,4).isYear() && strDateInt.substring(4,6).isMonth()  && strDateInt.substring(6,8).isDay() && strDateInt.substring(8,10).isHour() && strDateInt.substring(10,12).isMinute()){
						blnDate = SCDateControl.isDay(strDateInt.substring(0,4), strDateInt.substring(4,6), strDateInt.substring(6,8));					
					}
					break;
				case 8 : //YYYYMMDD
					//alert(strDateInt.substring(4,6) + "      " + strDateInt.substring(4,6).isMonth());
					if(strDateInt.substring(0,4).isYear() && strDateInt.substring(4,6).isMonth()  && strDateInt.substring(6,8).isDay()){
						blnDate = SCDateControl.isDay(strDateInt.substring(0,4), strDateInt.substring(4,6), strDateInt.substring(6,8));					
					}
					break;
				case 6 : //YYYYMM
					if(strDateInt.substring(0,4).isYear() && strDateInt.substring(4,6).isMonth()){
						blnDate = true;					
					}
					break;
			}
		}
		return blnDate;
	},	
	
	/**
	 * 2월 달의 마지막 날짜를 체크한다.
	 * @param {Object} strYear
	 * @param {Object} strMonth
	 * @param {Object} strDay
	 */
	isDay:function(strYear, strMonth, strDay){
		 var intYear = parseInt(strYear,10);
		 var intMonth = parseInt(strMonth,10) - 1;
		 var intDay = parseInt(strDay,10);
		 var objArrayEndDay = new Array(31,28,31,30,31,30,31,31,30,31,30,31);
		 if ((intYear % 4 === 0 && intYear % 100 !== 0) || intYear % 400 === 0){
		 	objArrayEndDay[1] = 29;
		 }	
		 return (intDay >= 1 && intDay <= objArrayEndDay[intMonth]);
	},	

	/**
	 * 시간타입인지 체크 
	 * @param {Object} strDate 날짜형식의 문자열
	 */
	isTime:function(strDate){
		var strDateInt = SCStringControl.replaceString(strDate,"\-","");
		var blnDate = false;
		strDateInt = SCStringControl.replaceString(strDateInt,"\/","");
		strDateInt = SCStringControl.replaceString(strDateInt,"\:","");
		strDateInt = SCStringControl.replaceString(strDateInt," ","");

		if(SCNumberControl.isInteger(strDateInt)){
			switch (strDateInt.length) {
				case 14 : //YYYYMMDDHHMMSS
					if(strDateInt.substring(8,10).isHour() && strDateInt.substring(10,12).isMinute() && strDateInt.substring(12,14).isSecond()){
						blnDate = true;					
					}
					break;
				case 12 : //YYYYMMDDHHMM
					if(strDateInt.substring(8,10).isHour() && strDateInt.substring(10,12).isMinute()){
						blnDate = true;					
					}
					break;
				case 6 : //YYYYMMDD
					if(strDateInt.substring(0,2).isHour() && strDateInt.substring(2,4).isMinute() && strDateInt.substring(4,6).isSecond()){
						blnDate = true;					
					}
					break;
				case 4 : //YYYYMM
					if(strDateInt.substring(0,2).isHour() && strDateInt.substring(2,4).isMinute()){
						blnDate = true;					
					}
					break;
			}
		}
		return blnDate;
	},
	
	/**
	 * 두시간의 차이
	 * @param {String} strCase 단위 S, M, H, D
	 * @param {String} strDateB 시작시간
	 * @param {String} strDateE 종료시간
	 * @return {int} 시간차이
	 */
	getDifferDate:function(strCase,strDateB, strDateE){
		var dtDateB;
		var dtDateE;

		if(typeof(strDateB) == "string"){
			dtDateB = this.getStringToDate((strDateB));
		}else{
			dtDateB = strDateB;
		}
 
		if(typeof(strDateE) == "string"){
			dtDateE = this.getStringToDate((strDateE));
		}else{
			dtDateE = strDateE;
		}

		var lngUnit = 1000;
		switch(strCase.toUpperCase()){
			case "S" : lngUnit = lngUnit; break;
			case "M" : lngUnit = lngUnit * 60; break;
			case "H" : lngUnit = lngUnit * 3600; break;
			case "D" : lngUnit = lngUnit * 86400; break;
		}
		return parseInt((dtDateE - dtDateB) / lngUnit ,10) + 1;
	},
	

	getDifferDateTime:function(strDateB, strDateE){
		var dtDateB = this.getStringToDate((strDateB));
		var dtDateE = this.getStringToDate((strDateE));
		var lngUnit = 1000;
		var intDiffer =  dtDateE - dtDateB;
		var intDay = parseInt(intDiffer / 86400000, 10).toString();
		var intDayMode = intDiffer % 86400000;
		var intHour = parseInt(intDayMode/3600000,10).toString();
		var intHourMode = intDayMode % 3600000;
		var intMin = parseInt(intHourMode/60000,10).toString();
		var intMinMode = intHourMode % 60000;
		var intSec = ((intMinMode % 60000)/1000).toString();
		
		return SCStringControl.getFullChar(intDay,2,"0") + "일 " + SCStringControl.getFullChar(intHour,2,"0") + ":" + SCStringControl.getFullChar(intMin,2,"0") + ":" + SCStringControl.getFullChar(intSec,2,"0");
	},

	/**
	 * 스트링형태의 날짜타입을 DATE 타입으로 반환
	 * @param {String} strDate 스트링형태의 날짜문자
	 * @return {Date} 날짜타입
	 */
	getStringToDate:function(strDate){
		if(strDate === null || typeof(strDate) === SCConst.UNDEFINED || strDate === "") {return "";}
		strDate = SCStringControl.replaceString(strDate,"-","");	
		strDate = SCStringControl.replaceString(strDate,":","");	
		strDate = SCStringControl.replaceString(strDate," ","");	
		return new Date(strDate.substr(0,4), strDate.substr(4,2) - 1, strDate.substr(6,2), strDate.substr(8,2), strDate.substr(10,2), strDate.substr(12,2));
	}



};





var SCViewControl = {
	/**
	 * Layer를 이벤트를 발생시킨 이미지 엘리멘트 태그 근처에 나타날 수 있도록 설정
	 * 
	 * @param {Object} objImg 이미지 엘리멘트 태그 ID
	 * @param {Object} objDiv Layer 엘리멘트 태그 ID
	 * @param {Object} intModiWidth  위치X좌표 보정값
	 * @param {Object} intModiHeight 위치Y좌표 보정값
	 */	
	setPosLayer:function(objImg, objDiv, intModiWidth, intModiHeight){
		var intX =0; var intY=0;
		var intWidth = objDiv.style.width.replace("px","");
		var intHeight = objDiv.style.height.replace("px","");
		if (intHeight === 0){intHeight = 300;} 

		if(objImg !== null){
			intX = SCViewControl.getOffsetLeft(objImg);			//이미지 X좌표
			intY = SCViewControl.getOffsetTop(objImg);			//이미지 Y좌표
			intX = intX - (intWidth/2) + intModiWidth;
			intY = intY - intHeight + intModiHeight;
		} else{ //2008-07-30 by KimKS : scroll 포함하여 수정
			var scroll = this.getScrollPosition();
			intX = (document.body.clientWidth - intWidth) / 2 + scroll.x;
			intY = (document.body.clientHeight - intHeight) / 2 + scroll.y;
		}
		objDiv.style.left = intX;
		objDiv.style.top = intY;
	},
	
	/**
	 * Scroll 크기를 구한다.
	 * @return {x,y} 좌표값 구조체 
	 */
	getScrollPosition:function () {
		var x = 0;
		var y = 0;

		if( typeof( window.pageYOffset ) == 'number' ) {
			x = window.pageXOffset;
			y = window.pageYOffset;
		} else if( document.documentElement && ( document.documentElement.scrollLeft || document.documentElement.scrollTop ) ) {
			x = document.documentElement.scrollLeft;
			y = document.documentElement.scrollTop;
		} else if( document.body && ( document.body.scrollLeft || document.body.scrollTop ) ) {
			x = document.body.scrollLeft;
			y = document.body.scrollTop;
		}

		var position = {
			'x' : x,
			'y' : y
		}

		return position;
	},
	
	/**
	 * 태그 엘리멘트의 왼쪽기준으로 떨어진 좌표를 반환한다.
	 * 호출방법 : alert(SCObjectControl.getOffsetLeft(obj));
	 * @param {Object} obj 태그 엘리멘트
	 * @return {int} 좌표값
	 */
	getOffsetLeft:function(objImg){
		var intLeft = objImg.offsetLeft;
		while ((objImg = objImg.offsetParent) !== null){
			intLeft += objImg.offsetLeft;	
		}
    	return intLeft;
	},

	/**
	 * 태그 엘리멘트의 상단기준으로 떨어진 좌표를 반환한다.
	 * 호출방법 : alert(SCObjectControl.getOffsetTop(obj));
	 * @param {Object} obj 태그 엘리멘트
	 * @return {int} 좌표값
	 */	
	getOffsetTop:function(objImg){
		var intTop = objImg.offsetTop;
		while ((objImg = objImg.offsetParent) !== null){
			intTop += objImg.offsetTop;	
		}
    	return intTop;
	},

	calculator:function(objImg, objId){
		var intX = SCViewControl.getOffsetLeft(objImg);			//이미지 X좌표
		var intY = SCViewControl.getOffsetTop(objImg);			//이미지 Y좌표
		objId.style.left = intX;
		objId.style.top = intY - 120;
		objId.className = "View";
	},


	winClose:function(objId){
		if(objId !== null) {
			objId.className = "Hidden";
		}
	},
	
	
	showLayer:function(objControl, objLayer, intModiWidth, intModiHeight, blnDisableScreen){
		if (typeof(blnDisableScreen) === SCConst.UNDEFINED || blnDisableScreen) { SCViewControl.disableScreen(true); }
		objLayer.className = "PopupLayerOn";
		SCViewControl.setPosLayer(objControl, objLayer, intModiWidth, intModiHeight);
	},

	showCenterLayer:function(objLayer, intModiWidth, intModiHeight, blnDisableScreen){
		if (typeof(blnDisableScreen) === SCConst.UNDEFINED || blnDisableScreen) { SCViewControl.disableScreen(true); }
		objLayer.className = "PopupLayerOn";
		SCViewControl.setPosLayer(null, objLayer, intModiWidth, intModiHeight);
	},

	hiddenLayer:function(objLayer, blnDisableScreen){
		objLayer.className = "PopupLayerOff";
		if (typeof(blnDisableScreen) === SCConst.UNDEFINED || blnDisableScreen) { SCViewControl.disableScreen(false); }
	},
	
	/**
	 * 레이어를 이용하여 모든 화면을 Disable처리 한다.
	 * imgBottomLogo는 최하단 로그이미지 객체로 해당 객체까지의 Y좌표를 구한 후 200정도 보정을 하면 전체 폭을 계산할 수 있다.
	 */	
	disableScreen:function(blnState){
		if(blnState){
			$("dvDisableLayer").className = "ScreenDisable";
			if($("imgBottomLogo") === null){
				$("dvDisableLayer").style.height = document.body.clientHeight;
			}else{
				$("dvDisableLayer").style.height = SCObjectControl.getOffsetTop($("imgBottomLogo")) + 200;
			}
		}else{
			$("dvDisableLayer").className = "ScreenView";
			$("dvDisableLayer").style.height = 0;
		}
	},
	
	/**
	 * 해당 엘리멘트의 배경색을 회색으로 설정한다.
	 * @param {Object} objElement 엘리멘트
	 * @param {Object} blnGray 색적용여부
	 */
	setGrayRow:function(objElement, blnGray){
		if(blnGray){
			objElement.style.backgroundColor = "#F7F7F7";
			objElement.style.cursor = "pointer";
		} else {
			objElement.style.backgroundColor = "#FFFFFF";
			objElement.style.cursor = "default";
		}
	},	

	/**
	 * 해당 엘리멘트의 배경색을 회색으로 설정하면서 마우스 클릭에 대한 메시지를 동적으로 보여준다.
	 * @param {Object} objElement 엘리멘트
	 * @param {Object} blnGray 색적용여부
	 */ 
	setGrayRowMsg01:function(objElement, blnGray){
		if(blnGray){
			objElement.style.backgroundColor = "#F7F7F7";
			objElement.style.cursor = "pointer";
			this.viewDynamicMsg(objElement, true, SCConst.SCMSG_MOUSE_CLICK);
		}else{
			objElement.style.backgroundColor = "#FFFFFF";
			objElement.style.cursor = "default";
			this.viewDynamicMsg(objElement, false);
		}
	},
	
	/**
	 * 해당 엘리멘트 영역에서 동적으로 메시지를 보여준다.
	 * @param {Object} objElement objElement 엘리멘트
	 * @param {Object} blnView 메시지 View여부
	 * @param {Object} strMsg 메시지
	 */
	viewDynamicMsg:function(objElement, blnView, strMsg){
		if(blnView){
			objElement.onmousemove=function(e){
				if(typeof(e) === SCConst.UNDEFINED){e = window.event;}
				$("dvDynamicMsg").innerHTML = strMsg;
				$("dvDynamicMsg").className = "DynamicMsgLayer";
				var intX = 0; var intY = 0;
				if(Prototype.Browser.IE){intX = e.x + document.body.scrollLeft;}else{intX = e.pageX;}	
				if(Prototype.Browser.IE){intY = e.y + document.body.scrollTop;}else{intY = e.pageY;}	
				$("dvDynamicMsg").style.left = intX + 15;
				$("dvDynamicMsg").style.top = intY + 5;
			};
		} else {
			$("dvDynamicMsg").className = "ScreenView";
		}
	},
	

	/**
	 * 선택한 이미지를 팝업으로 띄워 보여준다.
	 * @param {Object} objElement 이미지 엘리먼트
	 */
	showImagePopup: function(objElement) {
		try {
			var oImg = new Image();
			oImg.src = objElement.src;
			winResult = window.open("","_blank","scrollbars=no,status=no,resizable=yes,width=" + oImg.width + ",height=" + oImg.height);
			winResult.document.write("<body style='margin:0 border:0'>");
			winResult.document.write("<img src='" + oImg.src + "' onclick='window.close();' style='cursor:hand;border=0'>");
			return;
		} catch (ex) {
			SCErrorControl.doErrorRtn(ex, "showPopupImage");
		}
	}
};




var SCNumberControl={
	
	formatNumber:function(Data){
		var TempNum = "";
		
		if(!SCNumberControl.isInteger(Data.value)||Data.value<0) {
			SCMsgControl.alertMsg(SCConst.SCMSG_INPUT_DATA);
			Data.value = 0;
		}
		for(var i=0;i<Data.value.length;i++) {
			if(Data.value.indexOf("0") === 0) {
				Data.value = Data.value.substring(i + 1,Data.value.length);	
			}
		}
		for(var j=Data.value.length;j>0; j = j - 3) {
			TempNum = Data.value.substring(j - 3,j) + "," + TempNum ;
		}
		Data.value = TempNum.substring(0,TempNum.length - 1);
	},
	
	isInteger:function(val){
		if(val == "" || val == null) return false;
		for(var i=0;i<val.length;i++) {
			if(!SCNumberControl.isDigit(val.charAt(i))) {
				return false;	
			}
		}
		return true;
	},
	
	isfloat:function(val){
		for(var i=0;i<val.length;i++) {
			if(!SCNumberControl.isDigitAndPoint(val.charAt(i))) {
				return false;	
			}
		}
		return true;
	},
	
	isDigit:function(num) {
		if(num.length > 1){
			return false;
		} 
		var string="1234567890";
		if(string.indexOf(num) !== -1){
			return true;
		} 
		return false;
	},

	isDigitAndPoint:function(num) {
		if(num.length > 1){
			return false;
		} 
		var string="1234567890.,";
		if(string.indexOf(num) !== -1){
			return true;
		} 
		return false;
	},
	
	changeMoney:function(str){
	   var Money = "";
	   while(parseInt(str,10) >= 1000){
	      if((parseInt(str,10)/1000) > 0){
	         if((parseInt(str,10) % 1000) === 0){
	            Money = "," + parseInt(str,10) % 1000 + "00" + Money;
	         } else {
	            if((parseInt(str,10) % 1000) > 99 ){
					Money = "," + parseInt(str,10) % 1000 + Money;
				} else if((parseInt(str,10) % 1000) > 9 ){
					Money = ",0" + parseInt(str,10) % 1000 + Money;	
				}else{
					Money = ",00" + parseInt(str,10) % 1000 + Money;	
				}
	         }
	      }
	      str = parseInt(str,10)/1000;
	   }
	   Money = parseInt(str,10) + Money;
	   return Money;
	},
	
	unchangeMoney:function(Money){
	   var str = "";
	   for(i=0;i<Money.length;i++){
	      if(Money.charAt(i) !== ","){
		  	str = str + Money.charAt(i);
		  }
	   }
	   return str;
	},
	
	
	numberToHangle:function(intNum){
		var re=/[^0-9]+/g;
		var num=this.unchangeMoney(intNum.toString());
		var won=new Array();
		var price_unit0=new Array("","일","이","삼","사","오","육","칠","팔","구");
		var price_unit1=new Array("","십","백","천");
		var price_unit2=new Array("","만","억","조","경","해","시","양","구","간","정");
		while ( num.length > 1) {
			if (num.substr(0, 1) === "0") {
				num = num.substr(1, num.legnth);
			} else {
				break;
			}
		}
		if(num === "0") {return "영원";}
		//if(!this.isDigit(intNum)) {return "영원";}
		for( i = num.length - 1; i >= 0; i-- ){
			won[i] = price_unit0[num.substr(num.length - 1 - i,1)];
			if( i > 0 && won[i] !== "" ){ 
				won[i]+= price_unit1[i%4]; 
			}
			if( i % 4 === 0 ) {
				won[i]+= price_unit2[(i/4)]; 
			}
		}

		for( i = num.length - 1; i >= 0; i-- ){
			if( won[i].length == 2){ 
				won[i-i%4] += "-"; 
			}
			if(won[i].length == 1 && i>0){
				won[i]=""; 
			 }
			if( i%4 !== 0 ){
				won[i] = won[i].replace("일","");
			}	 
		}
		
		won = won.reverse().join("").replace(/-+/g,""); 
		return won + "원";

	},

	
	/**
	 * 현재 금액 Input박스에 해당 금액 단위 만큼 더해주는 함수 
	 * @param {String} strElement 금액이 입력될 박스의 ID
	 * @param {long} lngAmt 금액단위
	 */
	setAmtUnitPlus:function(strElement, lngAmt){
		try{
			var lngTotalAmt = $(strElement).value;
			if(lngAmt === ""){lngTotalAmt = 0;}
			lngTotalAmt = this.unchangeMoney(lngTotalAmt);	
			lngTotalAmt = eval(lngTotalAmt) + lngAmt
			$(strElement).value = this.changeMoney(lngTotalAmt);
		} catch(ex){
			throw SCErrorControl.raiseSysErr(ex, "setAmtUnitPlus");			
		}		
	}
	
};


var SCCookieControl = {
	
	/**
	 * 클라이언트에 쿠키의 키와 값 설정
	 * @param {String} strName 쿠키의 키명
	 * @param {String} strValue 키의 값
	 * @param {Date} strExpires 소멸될 시간
	 * 
	 */
	setCookie:function(strID, strName, strValue, dtExpires){
		document.cookie = "[" + strID + "]" + strName + "=" + escape (strValue) + "; path=/; expires=" + dtExpires.toGMTString();
	},
	
	/**
	 * 클라이언트에 설정된 쿠키값 반환
	 * @param {String} strName 쿠키의 키명
	 * 
	 */
	getCookie:function(strID, strName) {
		var strSearch = "[" + strID + "]" + strName + "=";
		var strReturn = "";
		var intPos = -1;
		var intEnd = -1; 
		// 쿠키값 설정여부
		if (document.cookie.length > 0) { 
			intPos = document.cookie.indexOf(strSearch);
			
			 // 해당 키의 쿠키가 존재하면
			if (intPos !== -1) {
				intPos += strSearch.length;
				intEnd = document.cookie.indexOf(";", intPos);
				if (intEnd == -1){
					intEnd = document.cookie.length;
					strReturn = unescape(document.cookie.substring(intPos, intEnd));
				} else {
					strReturn = unescape(document.cookie.substring(intPos, intEnd));
				}
			} 
		}
		return strReturn;
	}	
};



var SCXMLControl = {
	/**
	 * IE와 그외 브라우저에서 XML String을 DOM객체로 로드하는 함수
	 * @param {String} strXML xml형태의 데이터
	 * @return {xml Document} Dom 객체
	 */
	getXMLDoc:function(strXML){
		var xmlDoc=null;
		if (SCBrowserControl.ie){
			xmlDoc=new ActiveXObject("Microsoft.XMLDOM");
			xmlDoc.async="false";
			xmlDoc.loadXML(strXML);
		}else{
			var xmlDomPars=new DOMParser();
			xmlDoc=xmlDomPars.parseFromString(strXML,"text/xml");
		}
		return xmlDoc;	
	},
	
	/**
	 * 태그명을 이용하여 해당 엘리멘트 노드 리스트를 반환한다.
	 * @param {xml Document} xmlDoc
	 * @param {String} strTagName
	 * @return {NodeList} 해당 엘리멘트 노드 리스트
	 */
	getElements:function(xmlDoc, strTagName){
		return xmlDoc.getElementsByTagName(strTagName);
	}, 
	
	/**
	 * IE와 그외 브라우저에서 해당 엘리멘트값을 반환하는 함수
	 * @param {Element} xmlElement 
	 * @param {String} strTagName
	 * @return {String} 해당 엘리멘트의 값
	 */
	getElementValue:function(xmlElement,strTagName){
		var xmlElements = xmlElement.getElementsByTagName(strTagName);
		if (xmlElements.length > 0){
			if (SCBrowserControl.ie){
				return xmlElements[0].text;
			}else{
				return xmlElements[0].textContent;
			}
		} else {
			return "";
		}
	}, 
	/**
	 * XML이 해석할 수 없는 특정 문자를 특수 문자로 변경하거나 복원 시킨다.
	 * @param {String} strValue 대상 문자열
	 * @param {boolean} blnConv  true 특수문자로 치환 false 원상태 문자로 복원
	 */
	getConvSChar:function(strValue, blnConv){
		if(blnConv){
			return strValue.escapeHTML();	
		} else {
			return strValue.unescapeHTML();
		}
		
	},

	/**
	 * 부모엘리멘트에 자식엘리멘트를 추가하여 반환한다.
	 * @param {Object} objParent 부모 Element
	 * @param {String} strTagName  추가할 엘리멘트 태그명
	 * @param {String} strIdValue ID속성 값
	 * @param {String} strNameValue NAME 속성 값
	 * @param {String} strClassValue class속성 값
	 * @param {String} strValue  value값
	 */
	getAddElement:function(objParent, strTagName, strIdValue, strNameValue, strClassValue, strValue){
		var objNewElement = document.createElement(strTagName);
		objNewElement.setAttribute("id", strIdValue);
		objNewElement.setAttribute("name", strNameValue);
		objNewElement.setAttribute("className", strClassValue);
		objNewElement.value = strValue; 
		return  objParent.appendChild(objNewElement,"");
	}

};



var SCGridControl = {
	objRowCnt : new Object(),
	
	/**
	 * 해당 그리드에 Row의 개수를 설정한다
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {int} intCnt 설정한 RowCnt
	 */
	setRowCnt:function(strGridID, intCnt){
		SCGridControl.objRowCnt[strGridID] = intCnt;
	},

	/**
	 * 현재 설정된 그리드의 RowCnt
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @return {int} 해당 그리드의 RonCnt
	 */
	getRowCnt:function(strGridID){
		if(SCGridControl.objRowCnt[strGridID] === null || typeof(SCGridControl.objRowCnt[strGridID]) === SCConst.UNDEFINED){
			return 0;
		} else {
			return SCGridControl.objRowCnt[strGridID];	
		}
		
	},

	/**
	 * 데이터 로우 플래그를 반환한다.
	 * @param {Element} objElement 데이터 로우 태그 엘리멘트
	 */
	getFlag:function(objElement){
		var objElemnets = objElement.getElementsBySelector("INPUT[class='" + SCConst.DATAFLAG + "']");
		if (objElemnets.length > 0) {
			return objElemnets[0].value;	
		} 
	},
		
	/**
	 * 데이터 로우 플래그 를 설정한다.
	 * @param {Element} objElement 데이터 로우 태그 엘리멘트
	 * @param {String} strValue 설정할 플래그
	 * @return {String} 해당 플래그 값
	 */
	setFlag:function(objElement, strValue){
		var objElemnets = objElement.getElementsBySelector("INPUT[class='" + SCConst.DATAFLAG + "']");
		if (objElemnets.length > 0) {objElemnets[0].value = strValue;}
	},
	
	/**
	 * 그리드에 로우를 추가한다.
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @return {Object} 추가된 DataRow의 TR 태그 객체
	 */
	addRowData:function(strGridID){
		var objDataTemplateRow = $(strGridID).getElementsBySelector("TR[class='" + SCConst.TEMPLATE_CLASS + "']");
		
		//DataTemplate 클래스명을 가지고 있는 로우가 있을 경우만 실행한다.
		if(objDataTemplateRow.length !== 0){
			//TBODY Tag 엘리멘트에 Appending하기 위해 해당 엘리멘트를 찾는다.
			var objTBODY = $(strGridID).getElementsBySelector("TBODY");
			//채번할 시컨스를 구한다.
			var intSeq = SCGridControl.getSequence(strGridID);
			
			if (objTBODY.length === 0) {
				SCMsgControl.alertMsg(SCConst.SCMSG_CHECK_TBODY); return false;
			}
			
			//Template Row의 복사본을 만든다.
			var objDataRow = objDataTemplateRow[0].cloneNode(true);
			
			//클래스 이름을 DataTemplate => DataRow로 변경한다.
			objDataRow.className = SCConst.DATAROW_CLASS;
			
			//데이터 플래그를 설정한다.
			SCGridControl.setFlag(objDataRow, SCConst.INS_TRANS);

			//name속성과 id속성을 찾아서 Sequence하게 값을 증가시킨다.
			var objElements = objDataRow.getElementsBySelector("INPUT[id], SELECT[id], TEXTAREA[id]");
			objElements.each(
				function(Element, i){
					Element.id = Element.id.replace(SCConst.CHAR_SPLIT8, intSeq);
					Element.name = Element.name.replace(SCConst.CHAR_SPLIT8, intSeq);
				}
			);
			
			//Data Row의 복사본을 TBODY에 추가 한다.
			objTBODY[0].appendChild(objDataRow);
					
			return objDataRow;
		} else {
			SCMsgControl.alertMsg(SCConst.SCMSG_CHECK_TEMROW);
			return null;
		}
	},
	 
	
	/**
	 * 그리드에 로드된 전체 로우를 대상으로 조건에 맞게 XML형식으로 변환하여 반환한다.
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {String} strColList 특정 컬럼만 취합할 경우에 대한 바인딩 리스트 값 COL01|COL02|....
	 * @param {boolean} blnChanged 변경된 데이터만 취합할 지에 대한 여부 true 추가 변경된 데이터만 취합, false 모두 취합
	 * @return {String} XML형식의 데이터
	 */
	getDataRows:function(strGridID, strColList, blnChanged){
		var objDataRow = $(strGridID).getElementsBySelector("TR[class]");
		var arrayColList = null;
		var strRetData = "";
		//추출할 컬럼 리스트를 배열로 변환
		if(strColList !== "" || strColList !== "-1") {arrayColList = strColList.split(SCConst.CHAR_SPLIT);}

		objDataRow.each(
			function(DataRow, i){
				//로우중에 className이 DataRow인 것만 처리 한다.
				if(DataRow.className === SCConst.DATAROW_CLASS){
					if (blnChanged){
						if(SCGridControl.getFlag(DataRow) == SCConst.INS_TRANS || SCGridControl.getFlag(DataRow) == SCConst.UPD_TRANS){
							strRetData += SCGridControl.getDataRow(DataRow,arrayColList);
						}
					} else {
						strRetData += SCGridControl.getDataRow(DataRow,arrayColList);
					}
				}
			}
		);
		
		if (strRetData !== ""){
			strRetData =   "<" + SCConst.DATA_SET + ">" + strRetData + "</" + SCConst.DATA_SET + ">";
		}
		
		return strRetData;
	},
	
	
	/**
	 * 그리드의 특정 컬럼 데이터를 XML형식으로 변환한다.
	 * @param {Element} objDataRow
	 * @param {String} strColList 특정 컬럼만 취합할 경우에 대한 바인딩 리스트 값 COL01|COL02|....
	 * @return {String} XML형식의 데이터
	 */
	getDataRow:function(objDataRow, arrayColList){
		var strRetData = "";
		var objDataCol = objDataRow.getElementsBySelector("TD");

		//플래그 데이터 처리를 먼저 한다.
		strRetData += SCGridControl.getMakeStringTag(SCConst.DATAFLAG, SCGridControl.getFlag(objDataRow)); 

		//컬럼개수 만큼 처리한다.
		objDataCol.each(
			function(DataCol,i){
				//컬럼의 Data Binding 정보를 읽어온다
				var strDataFld = Element.readAttribute(DataCol, SCConst.DATAFLD_NAME);

				if (strDataFld !== null || strDataFld !== ""){
					if (strDataFld !== SCConst.DATAFLAG){
						if(arrayColList === null || arrayColList === ""){
							//해당 데이터 로우에서 바인정보를 이용하여 데이터를 가지고 온다.
							var strColValue = SCGridControl.getDataValue(DataCol, false);
							strRetData += 	 SCGridControl.getMakeStringTag(strDataFld, strColValue); 
						} else {
							arrayColList.each(
								function(ColName,i){
									ColName = ColName.trim();
									if (ColName == strDataFld) {
										//해당 데이터 로우에서 바인정보를 이용하여 데이터를 가지고 온다.
										var strColValue = SCGridControl.getDataValue(DataCol, false);
										strRetData += 	 SCGridControl.getMakeStringTag(strDataFld, strColValue); 
									}
								}
							);									
						}
					}
				}
			}							
		);
		if (strRetData !== ""){
			strRetData =  "<" + SCConst.TABLE+ ">" + strRetData + "</" + SCConst.TABLE + ">";
		}
		return strRetData;
	},	
	
	/**
	 * 선택된 로우 정보를 반환한다. ---체크박스
	 * 주의 blnData가 false일 경우에는 strColList구분 없이 모든 태그를 반환한다.
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {String} strColList 특정 컬럼만 취합할 경우에 대한 바인딩 리스트 값 COL01|COL02|....
	 * @param {boolean} blnData 데이터를 반환할 경우 true / Element객체를 반환할 경우 false
	 * @return {String} XML형식의 데이터 또는 Array객체(Element객체를 가지고 있는)
	 */
	getSelectedItem:function(strGridID, strColList, blnData){
		var objDataRow = $(strGridID).getElementsBySelector("TR[class]");
		var arrayColList = null;
		var strRetData = "";
		var objArrayRetData = new Array();
		var intIndex = 0;
		//추출할 컬럼 리스트를 배열로 변환
		if(strColList !== "" && strColList !== "-1") {arrayColList = strColList.split(SCConst.CHAR_SPLIT);}
		
		objDataRow.each(
			function(DataRow, i){
				//로우중에 className이 DataRow인 것만 처리 한다.
				if(DataRow.className === SCConst.DATAROW_CLASS){
					//삭제된 로우는 제외
					if(eval(SCGridControl.getFlag(DataRow)) !== SCConst.DEL_TRANS){
						var objElements = DataRow.getElementsBySelector("INPUT[class=" + SCConst.CHECKBOX_CLASS + "]");
						if(objElements.length > 0){
							if(objElements[0].checked){
								if(blnData){
									strRetData += SCGridControl.getDataRow(DataRow,arrayColList);
								} else {
									objArrayRetData[intIndex] = DataRow; intIndex += 1;
								}
							}
						}
					}	
				}
			}
		);
		
		if (blnData && strRetData !== ""){
			strRetData =   "<" + SCConst.DATA_SET + ">" + strRetData + "</" + SCConst.DATA_SET + ">";
		}
		if(blnData){
			return strRetData;
		} else {
			return objArrayRetData;
		}
	},
	
	/**
	 * 선택된 로우 정보를 반환한다. -- 라디오버튼
	 * 주의 blnData가 false일 경우에는 strColList구분 없이 모든 태그를 반환한다.
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {String} strColList 특정 컬럼만 취합할 경우에 대한 바인딩 리스트 값 COL01|COL02|....
	 * @param {boolean} blnData 데이터를 반환할 경우 true / Element객체를 반환할 경우 false
	 * @return {String} XML형식의 데이터 또는 Array객체(Element객체를 가지고 있는)
	 */
	getSelectedItemRadio:function(strGridID, strColList, blnData){
		var objDataRow = $(strGridID).getElementsBySelector("TR[class]");
		var arrayColList = null;
		var strRetData = "";
		var objArrayRetData = new Array();
		var intIndex = 0;
		//추출할 컬럼 리스트를 배열로 변환
		if(strColList !== "" && strColList !== "-1") {arrayColList = strColList.split(SCConst.CHAR_SPLIT);}
		
		objDataRow.each(
			function(DataRow, i){
				//로우중에 className이 DataRow인 것만 처리 한다.
				if(DataRow.className === SCConst.DATAROW_CLASS){
					//삭제된 로우는 제외
					if(eval(SCGridControl.getFlag(DataRow)) !== SCConst.DEL_TRANS){
						var objElements = DataRow.getElementsBySelector("INPUT[class=" + SCConst.RADIOBTN_CLASS + "]");
						if(objElements.length > 0){
							if(objElements[0].checked){
								if(blnData){
									strRetData += SCGridControl.getDataRow(DataRow,arrayColList);
								} else {
									objArrayRetData[intIndex] = DataRow; intIndex += 1;
								}
							}
						}
					}	
				}
			}
		);
		
		if (blnData && strRetData !== ""){
			strRetData =   "<" + SCConst.DATA_SET + ">" + strRetData + "</" + SCConst.DATA_SET + ">";
		}
		if(blnData){
			return strRetData;
		} else {
			return objArrayRetData;
		}
	},
	
	/**
	 * 그리드의 로우를 삭제한다.
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @return {int} 삭제된 로우의 개수
	 */
	deleteSelectedRows:function(strGridID){
		var objDataRow = $(strGridID).getElementsBySelector('TR[class]');
		for(var i = objDataRow.length - 1 ; i >= 0 ; i --){
			//로우중에 className이 DataRow인 것만 처리 한다.
			if(objDataRow[i].className === SCConst.DATAROW_CLASS){
				var objCheckBox = objDataRow[i].getElementsBySelector("INPUT[type='checkbox']");
				var blnDelete = false;		//삭제할 로우인지 체크
				var intCnt = 0;				//삭제건수

				//해당 로우의 체크박스 중에 로우선택 전용 박스인지 체크하여 해당 박스가 선택되었는지 찾는다.
				objCheckBox.each(
					function(objCheckBoxItem, index){
						if(objCheckBoxItem.className == SCConst.CHECKBOX_CLASS && objCheckBoxItem.checked){blnDelete=true;}
					}	
				);
				
				//선택이 된 로우를 삭제 한다.
				if (blnDelete){
					//해더와 타입로우가 있으므로  2개의 로우를 더해서 보정한다.
					if(eval(SCGridControl.getFlag(objDataRow[i])) === SCConst.INS_TRANS){
						$(strGridID).deleteRow(i);
					} else {
						SCGridControl.setFlag(objDataRow[i],SCConst.DEL_TRANS);			
						objDataRow[i].style.display = "none";		
					}
					intCnt += 1;
					blnDelete = false;
				}
			}
		}
		return intCnt;
	},
	
 
	/**
	 * 해당 엘리멘트의 값을 체크하여 동일한 그리드의 로우를 삭제한다.
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {String} strColName 바인딩명
	 * @param {String} strValue 비교값
	 * @return {int} 삭제된 로우의 개수
	 */
	deleteCompareRows:function(strGridID, strColName,strValue){
		var objDataRow = $(strGridID).getElementsBySelector('TR[class]');
		for(var i = objDataRow.length - 1 ; i >= 0 ; i --){
			//로우중에 className이 DataRow인 것만 처리 한다.
			if(objDataRow[i].className === SCConst.DATAROW_CLASS){
				//삭제플래그값을 체크하지 않는다.
				if(SCGridControl.getFlag(Element) !== SCConst.DEL_TRANS){
					var intCnt = 0;				//삭제건수
					var strCompareValue = SCGridControl.getDataValueUseRow(objDataRow[i],strColName, false);
					
					//비교값이 같은 것을 삭제한다.
					if (strCompareValue === strValue){
						if(eval(SCGridControl.getFlag(objDataRow[i])) === SCConst.INS_TRANS){
							$(strGridID).deleteRow(i);
						} else {
							SCGridControl.setFlag(objDataRow[i],SCConst.DEL_TRANS);			
							objDataRow[i].style.display = "none";		
						}
						intCnt += 1;
					}
				}
			}
		}
		return intCnt;
	},
 

	/**
	 * 데이터 바인딩 처리
	 * @param {String}  strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {String} objData 바인딩 할 XML 데이터
	 * @param {boolean} blnClear 그리드 초기화 후 데이터를 바인딩할 지 여부
	 */
	setClipBinding:function(strGridID, objData, blnClear){
		SCGridControl.setAddClipBinding(strGridID, objData, blnClear, SCConst.NO_TRANS);
	},
	

	/**
	 * 플래그를 설정하면서 데이터 바인딩 
	 * @param {String}  strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {String} objData 바인딩 할 XML 데이터
	 * @param {boolean} blnClear 그리드 초기화 후 데이터를 바인딩할 지 여부
	 * @param {int} intSetFlag 데이터 바인딩시 설정할 플래그
	 */
	setAddClipBinding:function(strGridID, objData, blnClear, intSetFlag){
		//DataRow를 초기화 한다.
		if (blnClear) {SCGridControl.initDataRow(strGridID);SCGridControl.setRowCnt(strGridID,1);}

		//데이터를 XMLDOM으로 로드하여 로우별로 추출한다.
		var xmlDoc = SCXMLControl.getXMLDoc(objData);
		var xmlElements = SCXMLControl.getElements(xmlDoc, SCConst.TABLE);
		$A(xmlElements).each(
			function(xmlElement,i){
				var objNewDataRow = SCGridControl.addRowData(strGridID, true);		
				var objDataCol = objNewDataRow.getElementsBySelector("TD");
	        	//컬럼수 만 큼 처리
				objDataCol.each(
					function(objDataColItem, j){
						//컬럼의 Data Binding 정보를 읽어온다
						var strDataFld = Element.readAttribute(objDataColItem, SCConst.DATAFLD_NAME);

						if (strDataFld !== null){
							if (strDataFld === SCConst.DATAFLAG){
								//데이터 플래그 초기화 설정
								SCGridControl.setFlag(objDataColItem, intSetFlag);
							} else {
								//해당 데이터 로우에서 바인정보를 이용하여 데이터를 가지고 온다.
								var strColValue = SCXMLControl.getElementValue(xmlElement, strDataFld);
								if (strColValue !== "" && strColValue !== null ){
									SCGridControl.setDataValue(objDataColItem, strColValue);	
								} 
							}
						}
					}
				);
			}
			
		);
	},


	/**
	 * 전체로우를 대상으로 특정위치의 값을 설정한다.
	 * @param {String}  strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {Object} strDataFldList
	 * @param {Object} strValue
	 */
	setDataValueAllRows:function(strGridID, strDataFldList,strValue){
		var objDataRow = $(strGridID).getElementsBySelector('TR[class]');
		for(var i = 0;  i < objDataRow.size(); i++){
			//로우중에 className이 DataRow인 것만 처리 한다.
			if(objDataRow[i].className === SCConst.DATAROW_CLASS){
				//삭제플래그로우는 처리하지 않는다.
				if(SCGridControl.getFlag(Element) !== SCConst.DEL_TRANS){
					SCGridControl.setDataValueUseRow(objDataRow[i], strDataFldList, strValue);
				}
			}
		}
	},



	/**
	 * 로우객체를 이용하여 해당 바인드 객체에 값 설정
	 * @param {Object} objRowElement
	 * @param {Object} strDataFldList
	 * @param {Object} strValue
	 */
	setDataValueUseRow:function(objRowElement, strDataFldList, strValue){
		var objDataCol = objRowElement.getElementsBySelector("TD");
		var arrayColList = null;
		if(strDataFldList !== "" && strDataFldList !== "-1") {arrayColList = strDataFldList.split(SCConst.CHAR_SPLIT);}
		for(var i=0; i<objDataCol.size();i++){

			//컬럼의 Data Binding 정보를 읽어온다
			var strDataFldValue = Element.readAttribute(objDataCol[i], SCConst.DATAFLD_NAME);
			if(arrayColList === null || arrayColList === ""){

			} else {
				//리스트개수만큼 처리
				for(var j=0; j<arrayColList.size(); j++){
					var ColName = arrayColList[j].trim();
					if (ColName == strDataFldValue) {
						SCGridControl.setDataValue(objDataCol[i], strValue);
					}
				}
			}					
		}
	},


	/**
	 * 컬럼 태그 하위에 태그 엘리멘트를 분석하여 각 태그 엘리메트에 맞게 값을 설정한다.
	 * @param {Element} objColElement 컬럼 태그 엘리멘트
	 * @param {String} strValue 설정할 값
	 */
	setDataValue:function(objColElement, strValue){
		var strSetValue = "";
		//objColElement 하위에 자식 엘리멘트를 먼저 처리
		$A(objColElement.childNodes).each(
			function(objElement, i){
				
				switch (objElement.tagName) {
				   case "INPUT" :
				   		SCGridControl.setInputDataValue(objElement, strValue);
						strSetValue = strValue;
						return;
				   case "SELECT" :
				   case "TEXTAREA" :
				   		strSetValue = strValue;
				     	objElement.value = strValue;
					  	return;
				} 
			}
		);

		//하위에 없을 경우 컬럼 엘리멘트 하위를 모두 찾는다.
		if (strSetValue === "") {
			var objINPUT = objColElement.getElementsBySelector("INPUT");
			if (objINPUT.length > 0) {
				SCGridControl.setInputDataValue(objINPUT[0], strValue);
				strSetValue = strValue;
				return;
			} else {
				var objSELECT = objColElement.getElementsBySelector("SELECT");
				if (objSELECT.length > 0) {
					objSELECT[0].value = strValue;
					strSetValue = strValue;
				    return;
				} else {
					var objTEXTAREA = objColElement.getElementsBySelector("TEXTAREA");
					if (objTEXTAREA.length > 0) {
						objTEXTAREA[0].value = strValue;
						strSetValue = strValue;
						return;
					}				
				}
			}
			
			if(strSetValue === ""){objColElement.innerHTML = strValue;}
		}
	},



	/**
	 * 로우객체를 이용하여 해당 바인드 객체에 값 반환
	 * @param {Object} objRowElement
	 * @param {Object} strDataFld
	 * @param {Object} strValue
	 */
	getDataValueUseRow:function(objRowElement, strDataFld, blnConvHTML){
		var objDataCol = objRowElement.getElementsBySelector("TD");
		for(var i=0; i<objDataCol.size();i++){
			//컬럼의 Data Binding 정보를 읽어온다
			var strDataFldValue = Element.readAttribute(objDataCol[i], SCConst.DATAFLD_NAME);
			if (strDataFld !== null){
				if (strDataFld === strDataFldValue){
					return SCGridControl.getDataValue(objDataCol[i], blnConvHTML);
				}
			}
		}
	},
	
	/**
	 * 컬럼 태그 하위에 태그 엘리멘트를 분석하여 각 태그 엘리메트에 값을 반환한다.
	 * @param {Element} objColElement 컬럼 태그 엘리멘트
	 * @param {Element} blnConvHTML HTML데이터를 태그문자를 인식하지 못하게 컨버전할지 여부 true:인식/false:비인식하도록 convert
	 */
	getDataValue:function(objColElement, blnConvHTML){
		var strRetValue = "";
		var blnControl = false;
		if(blnConvHTML === null) {blnConvHTML = false;}
		
		//objColElement 하위에 자식 엘리멘트가 있는지 체크한다.
		$A(objColElement.childNodes).each(
			function(objElement, i){
				if (objElement.tagName !== SCConst.UNDEFINED){
					switch (objElement.tagName) {
					   case "INPUT" :
					   		strRetValue = SCGridControl.getInputDataValue(objElement);
							blnControl = true;
							break;
					   case "SELECT" :
					   case "TEXTAREA" :
					     	strRetValue = objElement.value;
							blnControl = true;
						  	break;
					} 
				}
			}
		);
		
		//하위에 없을 경우 컬럼 엘리멘트 하위를 모두 찾는다.
		if (strRetValue === "" && !blnControl) {
			var objINPUT = objColElement.getElementsBySelector("INPUT");
			if (objINPUT.length > 0) {
				strRetValue = SCGridControl.getInputDataValue(objINPUT[0]);
				blnControl = true;
			} else {
				var objSELECT = objColElement.getElementsBySelector("SELECT");
				if (objSELECT.length > 0) {
			     	strRetValue = objSELECT[0].value;
					blnControl = true;
				} else {
					var objTEXTAREA = objColElement.getElementsBySelector("TEXTAREA");
					if (objTEXTAREA.length > 0) {
				     	strRetValue = objTEXTAREA[0].value;
						blnControl = true;
					}				
				}
			}
			
			
			if (strRetValue === "" && !blnControl) {
				if(!blnConvHTML){
					//strRetValue = SCXMLControl.getConvSChar(objColElement.innerHTML, true);	
					//HTML태그는 의미가 없으므로 제거하고 반환
					strRetValue = objColElement.innerHTML.stripTags();					
				} else {
					strRetValue = objColElement.innerHTML;
				}
			}
		}
		//2008-07-29 by KimKS : trim 추가
		if (typeof(strRetValue) === "string") {
			return strRetValue.trim();
		}else{
			return strRetValue;
		}
	},


	/**
	 * INPUT 박스 태그 엘리멘트의 type에 맞게 값을 설정한다.
	 * @param {Element} objElement	태그 엘리멘트
	 * @param {String} strValue	설정할 값
	 */
	setInputDataValue:function(objElement, strValue){
   		if(objElement.type === "checkbox" || objElement.type === "radio"  ){
			if (strValue === "1" || strValue === 1 || strValue === "Y" ){
				objElement.checked = true;
			} else {
				objElement.checked = false;
			}
		} else {
			objElement.value = strValue;
		}
	},

	/**
	 * INPUT 박스 태그 엘리멘트의 type에 맞게 값을 반환한다.
	 * @param {Element} objElement	태그 엘리멘트
	 */
	getInputDataValue:function(objElement){
		var strRetValue = "";
   		if(objElement.type === "checkbox" || objElement.type === "radio"  ){
			if (objElement.checked){
				strRetValue =  1;
			} else {
				strRetValue = 0;
			}
		} else {
	    	strRetValue = objElement.value;
		}
		return strRetValue;
	},


	

	
	/**
	 * 그리드 DataRow를 모두 삭제하고 초기화 한다.
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 */
	initDataRow:function(strGridID){
		var objDataRow = $(strGridID).getElementsBySelector("TR[class]");
		for(var i = objDataRow.length - 1 ; i >= 0 ; i --){
			//로우중에 className이 DataRow인 것만 처리 한다.
			if(objDataRow[i].className === SCConst.DATAROW_CLASS){
				$(strGridID).deleteRow(i);
			}
		}
	},
	
	/**
	 * 태그 엘리멘트 스트링을 생성하여 반환한다.
	 * @param {String} strTag 태그 엘리멘트명
	 * @param {String} strValue 해당 엘리멘트값
	 * @return {String} 엘리멘트 형태의 스트링 값
	 */
	getMakeStringTag:function(strTag, strValue){
		return "<" + strTag + ">" + strValue + "</" + strTag + ">";	
	},

	/**
	 * 그리드 관련 순차적인 번호를 채번한다.(해당 화면이 재로드되면 1로 초기화 된다.
	 * @return {int} 채번한 순번
	 */
	getSequence:function(strGridID){
		var intCnt = parseInt(SCGridControl.getRowCnt(strGridID), 10);
		intCnt += 1;
		SCGridControl.setRowCnt(strGridID,intCnt);
		return SCConst.CHAR_SPLIT2 + intCnt;
	},
	

	/**
	 * 필수 입력 항목을 입력했는지 체크
	 * 
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {boolean} 변경 체크 여부
	 * @param {boolean} blnCheckUPD 데이터 변경여부 체크 (true:체크, false:체크하지 않음)
	 */
	dataValidation:function(strGridID, blnCheckUPD){
		if(SCGridControl.getMaxRows(strGridID) === 0){
			if(typeof(blnCheckUPD) === SCConst.UNDEFINED || blnCheckUPD === true){
				SCMsgControl.alertMsg(SCConst.SCMSG_NO_SAVEDATA);
				return false;
			}
		}
		var intCnt = 0;
		var objDataRow = $(strGridID).getElementsBySelector("TR[class]");

		for (i=0 ; i < objDataRow.length ; i++){
			if(objDataRow[i].className === SCConst.DATAROW_CLASS){
				if(eval(SCGridControl.getFlag(objDataRow[i])) !== SCConst.NO_TRANS){
					if(eval(SCGridControl.getFlag(objDataRow[i])) !== SCConst.DEL_TRANS){
						var oblElment = objDataRow[i].getElementsBySelector("*");
						for (j=0 ; j < oblElment.length ; j++){
							var strAccessKey = oblElment[j].accessKey;
							if (strAccessKey !== null  && strAccessKey !== "" && typeof(strAccessKey) !== SCConst.UNDEFINED){
								var arrayAccessKey = strAccessKey.split(SCConst.CHAR_SPLIT1);
								if (arrayAccessKey.length > 2){
									if (arrayAccessKey[1].trim() == SCConst.ACC_KEY_M){
										if(SCGridControl.getDataValue(oblElment[j].parentNode, false) === ""){
											SCMsgControl.alertMsg(oblElment[j].title + SCConst.SCMSG_CHECK_INPUT);
											try{
												oblElment[j].focus();
											} catch(ex){
												oblElment[j].select();
											}
											return false;
										}	
									}									
								}	
							}
						}
					}
					intCnt += 1;
				} 
				
			}
		}

		if (intCnt === 0){
			if(typeof(blnCheckUPD) === SCConst.UNDEFINED || blnCheckUPD === true){
				SCMsgControl.alertMsg(SCConst.SCMSG_NO_SAVEDATA);	
				return false;
			}
		} 
		return true;
	},


	/**
	 * 해당 데이터 로우가 변경된 것을 데이터 로우 플래그에 적용시킴
	 * @param {Element} objElement 데이터가 변경된 엘리멘트 
	 */
	cellChanged:function(objElement){
		objElement = $(objElement);
		var objParentElement = objElement.up("TR");
		if (objParentElement !== null || objParentElement == SCConst.UNDEFINED){
			var objFlagElemnet = objParentElement.getElementsBySelector("INPUT[class='" + SCConst.DATAFLAG + "']");
			 if (objFlagElemnet.length !== 0){
			 	//플래그 상태에 따라 데이터 변경시 플래그를 변경한다.[Delete는 차 후 생각]
				switch (eval(objFlagElemnet[0].value)) {
					case SCConst.NO_TRANS :
						objFlagElemnet[0].value = SCConst.UPD_TRANS;
					  	break;
					case  SCConst.INS_TRANS :
						objFlagElemnet[0].value = SCConst.INS_TRANS;
						break;
					case  SCConst.UPD_TRANS :
						objFlagElemnet[0].value = SCConst.UPD_TRANS;
						break;
					default :
					  	break;
				}
			 } 
			}
		},

	/**
	 * 전체 Row의 플래그를 일괄 설정한다.
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {int} intDataFlag 설정할 플래그
	 */
	setFlagAll:function(strGridID, intDataFlag){
		var objSelectElemnet = $(strGridID).getElementsBySelector("INPUT[class='" + SCConst.DATAFLAG + "']");
		objSelectElemnet.each(
			function(Element, i){
				SCGridControl.setFlag(Element.up("TR"),intDataFlag);
			}
		);
	},

	/**
	 * 전체 Row를 선택하거나 해제할 수  있으며 데이터 플래그도 설정할 수 있다
	 * @param {String} strGridID 그리드 ID
	 * @param {Object} objImg 선택 해제 버튼이미지 객체
	 * @param {boolean} blnSetFlag 플래그 변경 여부 변경(true)/미변경(false)
	 * @param {integer} intDataFlag blnSetFlag가 true일 경우 변경할 플래그 값
	 * @param {String} strDataFld Binding 컬럼명
	 */
	selectAll:function(strGridID, objImg, blnSetFlag, intDataFlag, strDataFld){
		
		var strIMGURL = objImg.src;
		var blnSelect = false;
		var objSelectElemne = null;
		//파라메터초기화
		if(typeof(blnSetFlag) === SCConst.UNDEFINED) {blnSetFlag = false;}
		if(typeof(strDataFld) === SCConst.UNDEFINED) {strDataFld = "";}

		//데이터 바인딩으로 처리할지 아니면 사전에 정의된 클래스명으로 할지 판다.
		if(strDataFld === ""){
			objSelectElemnet = $(strGridID).getElementsBySelector("INPUT[class='" + SCConst.CHECKBOX_CLASS + "']");
		} else {
			objSelectElemnet = $(strGridID).getElementsBySelector("TD[dataFld='" + strDataFld + "']");
		}

		strIMGURL = strIMGURL.substring(0,strIMGURL.lastIndexOf("\/") + 1);
		//선택 이미지의 className 정보를 이용하여 선택 해제 토글을 처리한다.	
		if (objImg.className == SCConst.CHK_SELECT){
			objImg.className = SCConst.CHK_UNSELECT;						
			objImg.src = strIMGURL + SCConst.TOTAL_UNSEL_IMG;	//해제로 그림을 변경하고 모두 선택 처리 한다.
			blnSelect = true;
		} else {
			objImg.className = SCConst.CHK_SELECT;
			objImg.src = strIMGURL + SCConst.TOTAL_SEL_IMG;		//선택으로 그림을 변경하고 모두 해제 처리 한다.
			blnSelect = false;
		}	
							
		objSelectElemnet.each(
			function(Element, i){
				if(strDataFld === ""){
					Element.checked = blnSelect;
				} else {
					objSubElemnet = Element.getElementsBySelector("INPUT[type='checkbox']");
					objSubElemnet.each(
						function(SubElement, j){
							SubElement.checked = blnSelect;
						}
					);
				}
				if(blnSetFlag){
					if(blnSelect){
						SCGridControl.setFlag(Element.up("TR"), intDataFlag);
					} else {
						SCGridControl.setFlag(Element.up("TR"), SCConst.NO_TRANS);
					}
				}
			}
		);
	},
	
	
	
	/**
	 * 해당 엘리멘트의 ID를 이용하여 그룹ID를 추출하여 반환한다.
	 * @param {Object} Element 
	 * @return {String} 그룹ID 
	 */
	getSeqID:function(Element){
		var strSeqID = "";
		if(Element !== null && Element.id !== ""){
			strSeqID = Element.id.substring(Element.id.lastIndexOf(SCConst.CHAR_SPLIT2)); 
		}
		return strSeqID;
	}, 
	

	/**
	 * 그리드가 변경되었는지 체크
	 * 
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @return {boolean} 변경 true, 변경이 되지 않음 false
	 */
	isDataChanged:function(strGridID){
		var objDataRow = $(strGridID).getElementsBySelector("TR[class]");
		var intDataFlag = 0;
		var blnChanged = false;
		objDataRow.each(
			function(Element, i){
				if(Element.className === SCConst.DATAROW_CLASS){
					intDataFlag = eval(SCGridControl.getFlag(Element));
					if(intDataFlag == SCConst.INS_TRANS || intDataFlag == SCConst.UPD_TRANS || intDataFlag == SCConst.DEL_TRANS){
						blnChanged = true;
					}
				}
			}
		);
		return blnChanged;
	},

	/**
	 * 그리드 로우가 선택되었는지 체크
	 * 
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {String} strDataFld Binding 컬럼명
	 * @return {boolean} 선택되었으면 true, 선택 되지 않으면 false
	 */
	isDataSelected:function(strGridID, strDataFld){
		//파라메터초기화
		if(typeof(strDataFld) === SCConst.UNDEFINED) {strDataFld = "";}

		var objDataRow = $(strGridID).getElementsBySelector("TR[class]");
		for(var i=0;i<objDataRow.length; i++){
			if(objDataRow[i].className === SCConst.DATAROW_CLASS){
				var objElements;
				//데이터 바인딩으로 처리할지 아니면 사전에 정의된 클래스명으로 할지 판다.
				if(strDataFld === ""){
					objElements = objDataRow[i].getElementsBySelector("INPUT[class=" + SCConst.CHECKBOX_CLASS + "]");
				} else {
					objElements = objDataRow[i].getElementsBySelector("TD[dataFld='" + strDataFld + "']");
					objElements = objElements[0].getElementsBySelector("INPUT[type='checkbox']");
				}
				if(objElements.length > 0){
					if(objElements[0].checked){
						return true;
					}
				}
			}
		}
		return false;
	},

	/**
	 * 그리드가 삭제되었는지 체크
	 * 
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @return {boolean} 삭제 true, 삭제 되지 않음 false
	 */
	isDataDeleted:function(strGridID){
		var objDataRow = $(strGridID).getElementsBySelector("TR[class]");
		var intDataFlag = 0;
		var blnChanged = false;
		objDataRow.each(
			function(Element, i){
				if(Element.className === SCConst.DATAROW_CLASS){
					intDataFlag = eval(SCGridControl.getFlag(Element));
					if(intDataFlag == SCConst.DEL_TRANS){
						blnChanged = true;
					}
				}
			}
		);
		return blnChanged;
	},
	
	/**
	 * 그리드의 MaxRow값을 반환한다.
	 * 
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @return {String} MaxRow의 값
	 */
	getMaxRows:function(strGridID){
		var objDataRows = $(strGridID).getElementsBySelector("TR[class]");
		var intLength =0;
		var intDataFlag;
		objDataRows.each(
			function(RowElement, j){
				if(RowElement.className === SCConst.DATAROW_CLASS){
					intDataFlag = SCGridControl.getFlag(RowElement);
					if(parseInt(intDataFlag,10) !== SCConst.DEL_TRANS){
						intLength += 1;	
					}
				}				
			}
		);
		return intLength;
	}, 
	

	/**
	 * 그리드의 특정 컬럼을 Sum한다.
	 * 
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @param {String} strColName SUM할 컬럼명
	 * @return {String} SUM값
	 */
	getSumRows:function(strGridID, strColName){
		var objDataRows = $(strGridID).getElementsBySelector("TR[class]");
		var intDataFlag = "";
		var objDataCol = "";
		var strDataFld = "";
		var lngValue = 0;
		var lngSum = 0;
		objDataRows.each( 
			function(Element, i){
				if(Element.className === SCConst.DATAROW_CLASS){
					intDataFlag = SCGridControl.getFlag(Element);
					if(eval(intDataFlag) !== SCConst.DEL_TRANS){
						objDataCol = Element.getElementsBySelector("TD");
						objDataCol.each(
							function(ColElement, j){
								strDataFld = SCGridControl.readAttribute(ColElement,SCConst.DATAFLD_NAME);
								if(strDataFld === strColName){
									lngValue = SCGridControl.getDataValue(ColElement, false);
									if(lngValue !== "" && lngValue !== "null"){
										lngValue = SCStringControl.replaceString(lngValue,",","");
										lngSum += parseFloat(lngValue); 
									}
								}
							}						
						);
					}
				}
			}
		);
		return lngSum;
	}, 






	/**
	 * 그리드의 MaxRow의 시퀀스ID를 반환한다.
	 * 
	 * @param {String} strGridID 그리드로 사용하는 TABLE 태그의 ID
	 * @return {String} MaxRow의 시퀀스ID
	 */
	getMaxRowsSeq:function(strGridID){
		var objDataRows = $(strGridID).getElementsBySelector("TR[class]");
		var strSeqID = "0";
		objDataRows.each(
			function(Element, i){
				if(Element.className === SCConst.DATAROW_CLASS){
					var objElements = Element.getElementsBySelector("INPUT[class=" + SCConst.DATAFLAG+ "]");
					if(objElements.length > 0){
						strSeqID = objElements[0].id;
						strSeqID = strSeqID.substring(strSeqID.indexOf(SCConst.CHAR_SPLIT2) + SCConst.CHAR_SPLIT2.length);
					}
				}
			}
		);
		return strSeqID
	},



	setSelectedFlag:function(strGridID, intDataFlag){
		var objDataRows = SCGridControl.getSelectedItem(strGridID, "", false);
		for(var i=0; i < objDataRows.length; i++){
			SCGridControl.setFlag(objDataRows[i], intDataFlag);	
		}
	},
		
	
	/**
	 * 그리드의 선택된 로우를 대상 그리드로 복사한다. 
	 * 조건 : 붙여넣을 그리드 디자인에도 DataTemplate 클래스를 가지고 있는 로우가 존재해야 한다.
	 * @param {Object} strGridID 복사할 그리드 TABLE 태그의 ID
	 * @param {Object} strTargetGridID 붙여넣을 그리드 TABLE 태그의 ID
	 * @param {Object} strColList 복사할 그리드 컬럼 리스트("", "-1"일 경우 순서대로 추가한다.)
	 * @param {Object} strTargetColList 붙여넣을 그리드 컬럼 리스트(복사할 그리드 컬럼 순서와 동일하게 처리된다.)
	 * @param {Object} blnSetFlag 플래그 적용 여부 true:intDataFlag값으로 초기화 / false:인서트 1로 통일
	 * @param {Object} intDataFlag 플래그 복사여부가 false일 경우 초기화할 플래그 값
	 */
	selectedRowCopyPaste:function(strGridID, strTargetGridID, strColList, strTargetColList,  blnSetFlag, intDataFlag){
		var objDataRows = SCGridControl.getSelectedItem(strGridID, strColList, false);
		var objDataCols = null;
		var objDataTargetCols = null;
		if(objDataRows.length > 0){
			for(var i=0; i < objDataRows.length; i++){
				//붙여넣을 그리드 로우를 하나 추가한다.
				var objDataTargetRow = SCGridControl.addRowData(strTargetGridID);

				//복사할 그리드의 컬럼 리스트와 붙여넣을 그리드의 컬럼 리스트를 추출한다.
				objDataCols = objDataRows[i].getElementsBySelector("TD");
				objDataTargetCols = objDataTargetRow.getElementsBySelector("TD");

				if(strColList === "" || strColList === "-1" || strTargetColList === "" || strTargetColList === "-1"){
					//순서대로 전체 컬럼을 대상으로 처리한다.
					var intTargetMaxCol =  objDataTargetCols.length;
					objDataCols.each(
						function(objCol,j){
							if(j > intTargetMaxCol - 1) {return "";}
							var strDataFld = Element.readAttribute(objCol, SCConst.DATAFLD_NAME);
							if(strDataFld != SCConst.DATAFLAG){
								SCGridControl.setDataValue(objDataTargetCols[j],SCGridControl.getDataValue(objCol, true));
							} 
						}
					);
				} else{
					//입력한 컬럼만 찾아서 처리한다.
					var objArrayColList = strColList.split(SCConst.CHAR_SPLIT);
					var objArrayTargetColList = strTargetColList.split(SCConst.CHAR_SPLIT);

					objArrayColList.each(
						function(strColName, k){
							strColName = strColName.trim();
							var strTagetColName = objArrayTargetColList[k];
							objDataCols = objDataRows[i].getElementsBySelector("TD[dataFld=" + strColName + "]");
							objDataTargetCols = objDataTargetRow.getElementsBySelector("TD[dataFld=" + strTagetColName.trim() + "]");
							if(objDataCols.length >0 && objDataTargetCols.length > 0){
								SCGridControl.setDataValue(objDataTargetCols[0],SCGridControl.getDataValue(objDataCols[0], true));	
							}
						}
					);
				}
				
				//플래그 설정
				if(blnSetFlag){
					SCGridControl.setFlag(objDataTargetRow, intDataFlag);
				}
				
			}
		} else {
			SCMsgControl.alertMsg(SCConst.SCMSG_SELECT_COPY);		
		}
	},
	
	/**
	 * 그리드의 선택된 로우를 대상 그리드로 복사한다. 
	 * 조건 : 붙여넣을 그리드 디자인에도 DataTemplate 클래스를 가지고 있는 로우가 존재해야 한다.
	 * @param {Object} strGridID 복사할 그리드 TABLE 태그의 ID
	 * @param {Object} strTargetGridID 붙여넣을 그리드 TABLE 태그의 ID
	 * @param {Object} strColList 복사할 그리드 컬럼 리스트("", "-1"일 경우 순서대로 추가한다.)
	 * @param {Object} strTargetColList 붙여넣을 그리드 컬럼 리스트(복사할 그리드 컬럼 순서와 동일하게 처리된다.)
	 * @param {Object} blnSetFlag 플래그 적용 여부 true:intDataFlag값으로 초기화 / false:인서트 1로 통일
	 * @param {Object} intDataFlag 플래그 복사여부가 false일 경우 초기화할 플래그 값
	 */
	selectedRowCopyPasteWithChkDup:function(strGridID, strTargetGridID, strColList, strTargetColList, blnSetFlag, intDataFlag, strDupColumn){
		var objDataRows = SCGridControl.getSelectedItem(strGridID, strColList, false);
		var objDataCols = null;
		var objDataTargetCols = null;
		if(objDataRows.length > 0){
			for(var i=0; i < objDataRows.length; i++){
				if(!this.checkDuplicate(objDataRows[i], strTargetGridID, strDupColumn)) {
					//붙여넣을 그리드 로우를 하나 추가한다.
					var objDataTargetRow = SCGridControl.addRowData(strTargetGridID);
	
					//복사할 그리드의 컬럼 리스트와 붙여넣을 그리드의 컬럼 리스트를 추출한다.
					objDataCols = objDataRows[i].getElementsBySelector("TD");
					objDataTargetCols = objDataTargetRow.getElementsBySelector("TD");
	
					if(strColList === "" || strColList === "-1" || strTargetColList === "" || strTargetColList === "-1"){
						//순서대로 전체 컬럼을 대상으로 처리한다.
						var intTargetMaxCol =  objDataTargetCols.length;
						objDataCols.each(
							function(objCol,j){
								if(j > intTargetMaxCol - 1) {return "";}
								var strDataFld = Element.readAttribute(objCol, SCConst.DATAFLD_NAME);
								if(strDataFld != SCConst.DATAFLAG){
									SCGridControl.setDataValue(objDataTargetCols[j],SCGridControl.getDataValue(objCol, true));
								} 
							}
						);
					} else{
						//입력한 컬럼만 찾아서 처리한다.
						var objArrayColList = strColList.split(SCConst.CHAR_SPLIT);
						var objArrayTargetColList = strTargetColList.split(SCConst.CHAR_SPLIT);
	
						objArrayColList.each(
							function(strColName, k){
								strColName = strColName.trim();
								var strTagetColName = objArrayTargetColList[k];
								objDataCols = objDataRows[i].getElementsBySelector("TD[dataFld=" + strColName + "]");
								objDataTargetCols = objDataTargetRow.getElementsBySelector("TD[dataFld=" + strTagetColName.trim() + "]");
								if(objDataCols.length >0 && objDataTargetCols.length > 0){
									SCGridControl.setDataValue(objDataTargetCols[0],SCGridControl.getDataValue(objDataCols[0], true));	
								}
							}
						);
					}
					
					//플래그 설정
					if(blnSetFlag){
						SCGridControl.setFlag(objDataTargetRow, intDataFlag);
					}
				}
			}
		} else {
			SCMsgControl.alertMsg(SCConst.SCMSG_SELECT_COPY);		
		}
	},
	
	checkDuplicate: function(objDataRow, strTargetGridID, strDupColumn) {
		var objTarget = $(strTargetGridID);
		var arrRows = objTarget.getElementsBySelector("TR");
		for (var i = 0 ; i < arrRows.length ; i++) {
			if (arrRows[i].className == "DataRow") {
				if (SCGridControl.chkEquals(objDataRow, arrRows[i], strDupColumn)) {
					if (SCGridControl.getFlag(arrRows[i]) == SCConst.DEL_TRANS) {
						SCGridControl.setFlag(arrRows[i], SCConst.NO_TRANS);
						arrRows[i].style.display="";
					}
					return true;
				}
			}
		}
		return false;
	},
	
	chkEquals: function(objRow1, objRow2, strColumns) {
		var arrColumns = strColumns.split(SCConst.CHAR_SPLIT);
		for (var i = 0 ; i < arrColumns.length ; i++) {
			data1 = SCGridControl.getDataValueUseRow(objRow1, arrColumns[i], true);
			data2 = SCGridControl.getDataValueUseRow(objRow2, arrColumns[i], true);
			if (data1 != data2) {
				return false;
			}
		} 
		return true;
	},
	
	/**
	 * 특정컬럼 중복체크
	 * @param {String} strGridID 그리드 TABLE 태그의 ID
	 * @param {String} strColName 중복체크할 컬럼의 이름
	 */
	checkDumData:function(strGridID, strColName){
		var objDataRows = $(strGridID).getElementsBySelector("TR[class]");
		var strDataValue = SCConst.CHAR_SPLIT10;
		for(var i=0; i<objDataRows.size(); i++){
			if(objDataRows[i].className === SCConst.DATAROW_CLASS){
				//삭제플래그값을 체크하지 않는다.
				if(SCGridControl.getFlag(objDataRows[i]) != SCConst.DEL_TRANS){
					var strValue = SCGridControl.getDataValueUseRow(objDataRows[i],strColName, false);

					if(strValue != "" && strDataValue.indexOf(SCConst.CHAR_SPLIT10 + strValue + SCConst.CHAR_SPLIT10) >= 0){
						return false;
					}
					strDataValue += strValue + SCConst.CHAR_SPLIT10;
				}
			}
		}
		return true;		
	},
	
	/**
	 * 그리드에 있는 로우 데이터를 추출하여 단일 레코드 데이터에 바인딩 시킨다.
	 * @param {String} strFormID	바인딩 할 데이터가 있는 formID
	 * @param {String} strGroupID 바인딩 할 데이터가 소속된 GroupID
	 * @param {Element} objElement 해당 로우 데이터의 TR 또는 TD 객체
	 */
	gridToData:function(strFormID, strGroupID, objElement){
		//해당 엘리멘트 객체가 TD일 경우 TR객체를 찾는다.
		if(objElement.tagName.toUpperCase() !== "TR"){objElement = objElement.parentNode;}
		for(var i=0; i<objElement.childNodes.length; i++){
			var objTDElement = objElement.childNodes[i];
			if(objTDElement.nodeName !== "#text"){
				var strDataFld = Element.readAttribute(objTDElement, SCConst.DATAFLD_NAME);
				if(strDataFld !== null && strDataFld !== ""){
					//해당 데이터 로우에서 바인정보를 이용하여 데이터를 가지고 온다.
					var strColValue = SCGridControl.getDataValue(objElement.childNodes[i], true);
					SCDataControl.setData(strFormID, strGroupID, strDataFld, strColValue.stripTags());
				}
			}
		}
		//플래그 초기화
		SCDataControl.setDataFlag(strFormID, strGroupID, SCConst.NO_TRANS);
	},
	

	readAttribute:function(element, name) {
		element = $(element);
		if (Prototype.Browser.IE) {
		  if (!element.attributes) return null;
		  var t = Element._attributeTranslations;
		  if (t.values[name]) return t.values[name](element, name);
		  if (t.names[name])  name = t.names[name];
		  var attribute = element.attributes[name];
		  return attribute ? attribute.nodeValue : null;
		}
		return element.getAttribute(name);
	}
	
};


 
var SCDataControl = {


	/**
	 * 폼 ID 하위에 있는 데이터 그룹의 모든 오브젝트 태그(INPUT, SELECT, TEXTAREA)를 조사하여 accesskey에 설정된 타입에 맞게 포멧과 모드를 설정하고, 
	 * className이 No or View인 태그의 속성에 readOnly를 설정한다.  
	 * 일반적으로 화면이 최초 로드 시점에 데이터가 모두 바인딩 된 후 호출한다.
	 * @param {String} strFormID 폼ID
	 * @param {String} strGroupID 데이터 그룹ID
	 * @param {boolean} blnNewFlag 데이터 플래그 값
	 */
	setDataInit:function(strFormID, strGroupID, blnNewFlag){
		if(typeof(blnNewFlag) === SCConst.UNDEFINED){blnNewFlag = true;}
		var strRetData = "";
		var strFindID = "";
		strGroupID !== "" ? strFindID=strGroupID + SCConst.CHAR_SPLIT2 : strFindID= "";
		var objElements = $(strFormID).getElementsBySelector("INPUT[name], SELECT[name], TEXTAREA[name]");

		//플래그 신규로 초기화
		if(blnNewFlag){this.setDataFlag(strFormID, strGroupID, SCConst.INS_TRANS);}
		
		//name이 있는 엘리멘트 개수  만큼 처리한다.
		objElements.each(
			function(objElement,i){
				//strGroupID가 없거나 또는 name이 strFindID를 포함한 것만 처리
				if(strGroupID === "" || objElement.name.indexOf(strFindID) >= 0){
					//클래스명에 No와 View를 찾아서 readonly로 설정
					if(objElement.className.substring(0,2).toUpperCase() === "NO" || objElement.className.substring(0,4).toUpperCase() === "VIEW"){
						objElement.readOnly = true;						
					}
					
					//accesskey 추출하여 포멧을 설정하고 한영모드를 설정한다.
					var objArrayAccess = objElement.accessKey.split(SCConst.CHAR_SPLIT1);
					if (objArrayAccess.length === 3 && objArrayAccess[0] !== ""){
						SCDataControl.setDataFormat(objElement, objArrayAccess[0].trim());
					} else if(objArrayAccess.length === 3 && objArrayAccess[2] !== ""){
						switch(objArrayAccess[2].trim()){
							case "H":
								objElement.style.imeMode  = "active";
								break;
							case "E":
								objElement.style.imeMode  = "inactive";
								break;
						}	
					}
				}
			}							
		);
	},
	
	/**
	 * aaccesskey 속성값 중에 첫번째 정의된 타입(숫자,날짜,시간,…) 포멧으로 자동 설정한다.
	 * @param {Object} objElement 엘리멘트 객체
	 * @param {String} strFormat accesskey의 0번째 선언된 포멧 정보
	 */
	setDataFormat:function(objElement, strFormat){
		var strData = $F(objElement);
		var objArrayFormat = strFormat.split(SCConst.CHAR_SPLIT4);
		
	 	//정의된 포멧으로 설정한다.
		switch (objArrayFormat[0].trim()) {
			case "DATE" :
				strData = SCDataControl.getFormatDate(strData, false);break;
			case "TIME" :
				strData = SCDataControl.getFormatTime(strData, false);break;
			case "LONGTIME" :
				strData = SCDataControl.getFormatTimeLong(strData, false, true);break;
			case "MON" :
				strData = SCDataControl.getFormatMonth(strData, false, true);break;
			case "NUM" :
				if(!SCNumberControl.isInteger(strData)){strData = "";} break;
			case "INT" :
				strData = SCDataControl.getFormatNumber(strData,0, false);break;
			case "DEC" :
				if(objArrayFormat.length === 2){
					strData = SCDataControl.getFormatNumber(strData,objArrayFormat[1].trim(),false);
				} else {
					strData = SCDataControl.getFormatNumber(strData,0,false);
				}
				break;
			case "MASK" :
				if(objArrayFormat.length === 2){
					strData = SCDataControl.getFormatMask(strData,objArrayFormat[1].trim());
				} 
				break;
		}

		if(strData !== null && strData !== "" && strData !== eval(SCConst.UNDEFINED)){
			objElement.value = strData;	
		} else{
			objElement.value = ""
		}
		
	},
	
	/**
	 * 데이트 포멧(YYYY-MM-DD)에 맞게 설정, 데이트 타입 체크
	 * @param {Object} objData 날짜문자 또는 객체
	 * @param {boolean} blnCheck 체크여부 
	 * @return {String} 날짜 형식 반환 YYYY-MM-DD
	 */
	getFormatDate:function(objData, blnCheck){
		return this.getFormatMonth(objData, blnCheck, false);
	},


	/**
	 * 데이트 형식인지 체크해주며, 입력한 데이터의 크기에 따라 자동으로 데이터 포멧을 설정하여 반환한다.
	 * @param {Object} objData 날짜문자 또는 객체
	 * @param {boolean} blnCheck 날짜형식인지 체크할지 여부 
	 * @param {boolean} blnMonth false:날짜 부분을 제외 시킨 후 반환함
	 * @return {String} 날짜 타입의 문자열
	 */
	getFormatMonth:function(objData, blnCheck, blnMonth){
		var strRetValue = "";
		var blnErrorState = false;
		var dtDate = new Date();
		if(SCObjectControl.isElement(objData)){
			strRetValue = $F(objData).trim();
		} else {
			strRetValue = objData.trim();
		}
		//값이 없을 경우 처리하지 않는다.
		if(strRetValue === ""){return "";}
		strRetValue = SCStringControl.replaceString(strRetValue,"\-","");
		strRetValue = SCStringControl.replaceString(strRetValue,"\/","");
		if(SCNumberControl.isInteger(strRetValue)){
			switch (strRetValue.length) {
				case 8 : //YYYYMMDD
					if(blnMonth){
						strRetValue = strRetValue.substring(0,4) + SCConst.CHAR_SPLIT5 + strRetValue.substring(4,6);
					} else {
						strRetValue = strRetValue.substring(0,4) + SCConst.CHAR_SPLIT5 + strRetValue.substring(4,6) + SCConst.CHAR_SPLIT5 + strRetValue.substring(6,8);						
					}
					break;
				case 6 : //YYYYMM
					if(blnMonth){
						strRetValue = strRetValue.substring(0,4) + SCConst.CHAR_SPLIT5 + strRetValue.substring(4,6);
					} 
					break;
				case 4 : //MMDD
					if(!blnMonth){
						strRetValue = dtDate.getFullYear() + SCConst.CHAR_SPLIT5 + strRetValue.substring(0,2) + SCConst.CHAR_SPLIT5 + strRetValue.substring(2,4);
					}
					break;
				case 3 : //MDD
					if(!blnMonth){
						strRetValue = dtDate.getFullYear() + SCConst.CHAR_SPLIT5 + SCStringControl.getFullChar(strRetValue.substring(0,1),2,"0") + SCConst.CHAR_SPLIT5 + strRetValue.substring(1,3);
					} 
					break;
				case 2 : //DD
					if(blnMonth){
						strRetValue = dtDate.getFullYear() + SCConst.CHAR_SPLIT5 + SCConst.CHAR_SPLIT5 + strRetValue.substring(0,2);
					} else {
						strRetValue = dtDate.getFullYear() + SCConst.CHAR_SPLIT5 + SCStringControl.getFullChar((dtDate.getMonth()+1).toString(),2,"0") + SCConst.CHAR_SPLIT5 + strRetValue.substring(0,2);
					}
					break;
				case 1 : //D
					if(blnMonth){
						strRetValue = dtDate.getFullYear() + SCConst.CHAR_SPLIT5 + SCConst.CHAR_SPLIT5 + SCStringControl.getFullChar(strRetValue.substring(0,1),2,"0");
					} else {
						strRetValue = dtDate.getFullYear() + SCConst.CHAR_SPLIT5 + SCStringControl.getFullChar((dtDate.getMonth()+1).toString(),2,"0") + SCConst.CHAR_SPLIT5 + SCStringControl.getFullChar(strRetValue.substring(0,1),2,"0");
					}
					break;
				default : blnErrorState = true; break;
			}

			//날짜체크
			if(!SCDateControl.isDate(strRetValue)){blnErrorState = true;}
		} else {
			blnErrorState = true;
		}
		
		//처리결과 
		if(blnCheck && blnErrorState){
			if(SCObjectControl.isElement(objData)){
				SCMsgControl.alertMsg(objData.title + SCConst.SCMSG_NO_DATE);
				objData.select();
				objData.value = "";
			} else{
				SCMsgControl.alertMsg(SCConst.SCMSG_NO_DATE);
			}	
			return "";
		} else{
			return strRetValue;	
		}	
	},


	
	/**
	 * 시간 포멧(초 제외)에 맞게 설정, 시간 타입 체크
	 * @param {Object} objData 시간 문자 또는 객체
	 * @param {boolean} blnCheck 체크여부 
	 * @return {String} 시간 형식 반환 24HH:MM
	 */
	getFormatTime:function(objData, blnCheck){
		return this.getFormatTimeLong(objData, blnCheck, false);

	},

	/**
	 * 날짜 + 시간 형식인지 체크해주며, 입력한 데이터의 크기에 따라 자동으로 시간 포멧을 설정하여 날짜 + 시간 형태로 반환한다. 24HH:MM:SS
	 * @param {Object} objData 시간 문자 또는 객체
	 * @param {boolean} blnCheck 날짜 + 시간 형식인지 체크 여부 
	 * @param {boolean} blnLong true: false:초를 포함하지 않고 제외시킨 후 반환
	 * @return {String} 날짜 + 시간 타입의 문자열
	 */
	getFormatTimeLong:function(objData, blnCheck, blnLong){
		var strRetValue = "";
		var blnErrorState = false;
		if(SCObjectControl.isElement(objData)){
			strRetValue = $F(objData).trim();
		} else {
			strRetValue = objData.trim();
		}
		//값이 없을 경우 처리하지 않는다.
		if(strRetValue === ""){return "";}
		
		strRetValue = SCStringControl.replaceString(strRetValue,"\-","");
		strRetValue = SCStringControl.replaceString(strRetValue,"\/","");
		strRetValue = SCStringControl.replaceString(strRetValue," ","");
		strRetValue = SCStringControl.replaceString(strRetValue,"\:","");

		if(SCNumberControl.isInteger(strRetValue)){
			switch (strRetValue.length) {
				case 14 : //YYYYMMDDHHMMSS
					if(blnLong){
						strRetValue = strRetValue.substring(8,10) + SCConst.CHAR_SPLIT4 + strRetValue.substring(10,12) + SCConst.CHAR_SPLIT4 + strRetValue.substring(12,14);						
					} else {
						strRetValue = strRetValue.substring(8,10) + SCConst.CHAR_SPLIT4 + strRetValue.substring(10,12);					
					}
					break;
				case 12 : //YYYYMMDDHHMM
					if(blnLong){
						strRetValue = strRetValue.substring(8,10) + SCConst.CHAR_SPLIT4 + strRetValue.substring(10,12) + SCConst.CHAR_SPLIT4 + "00";
					} else {
						strRetValue = strRetValue.substring(8,10) + SCConst.CHAR_SPLIT4 + strRetValue.substring(10,12);
					}
					break;
				case 6 : //HHMMSS
					if(blnLong){
						strRetValue = strRetValue.substring(0,2) + SCConst.CHAR_SPLIT4 + strRetValue.substring(2,4) + SCConst.CHAR_SPLIT4 + strRetValue.substring(4,6);
					} else {
						strRetValue = strRetValue.substring(0,2) + SCConst.CHAR_SPLIT4 + strRetValue.substring(2,4);
					}
					break;
				case 4 : //HHMM
					if(blnLong){
						strRetValue = strRetValue.substring(0,2) + SCConst.CHAR_SPLIT4 + strRetValue.substring(2,4) + SCConst.CHAR_SPLIT4 + "00";
					} else {
						strRetValue = strRetValue.substring(0,2) + SCConst.CHAR_SPLIT4 + strRetValue.substring(2,4);
					}
					break;
				case 2 : //HH
					if(blnLong){
						strRetValue = strRetValue.substring(0,2) + SCConst.CHAR_SPLIT4 + "00" + SCConst.CHAR_SPLIT4 + "00";
					} else {
						strRetValue = strRetValue.substring(0,2) + SCConst.CHAR_SPLIT4 + "00";
					}
					break;
				case 1 : //H
					if(blnLong){
						strRetValue = "0" + strRetValue + SCConst.CHAR_SPLIT4 + "00" + SCConst.CHAR_SPLIT4 + "00";
					} else {
						strRetValue = "0" + strRetValue + SCConst.CHAR_SPLIT4 + "00";
					}
					break;
				default : blnErrorState = true; break;
			}

		} else {
			blnErrorState = true;
		}

		//처리결과 
		if(blnCheck && blnErrorState){
			if(SCObjectControl.isElement(objData)){
				SCMsgControl.alertMsg(objData.title + SCConst.SCMSG_NO_TIME);
				objData.select();
				objData.value = "";
			} else{
				SCMsgControl.alertMsg(SCConst.SCMSG_NO_TIME);
			}	
			return "";
		} else{
			//시간체크
			//24:00 또는 24:00:00은 허용하지 않는다.
			if(strRetValue.length === 5){if(strRetValue.indexOf("24:00") >= 0){blnErrorState = true;}}
			if(strRetValue.length === 8){if(strRetValue.indexOf("24:00:") >= 0){blnErrorState = true;}}
			if(blnCheck && blnErrorState){
				if(SCObjectControl.isElement(objData)){
					SCMsgControl.alertMsg(objData.title + SCConst.SCMSG_NO_TIME24);
					objData.select();
					objData.value = "";
				} else{
					SCMsgControl.alertMsg(SCConst.SCMSG_NO_TIME24);
				}	
				return "";
				
			} 

			return strRetValue;		
		}	
	},
	
	/**
	 * 천자리와 소숫점 자리수를 맞춰서 숫자 타입형태로 반환한다.(소숫점은 절삭 처리한다.)
	 * @param {Object} objData 숫자데이터 또는 객체
	 * @param {int} intLength 소숫점 길이
	 * @param {boolean} blnCheck 숫자를 체크 할지 여부
	 * @return {String} 천자리 구분과 소수점이 있는 숫자형태의 문자열
	 */
	getFormatNumber:function(objData, intLength, blnCheck){
		var blnErrorState = false;
		var strRetValue = "";
		if(SCObjectControl.isElement(objData)){
			strRetValue = $F(objData).trim();
		} else {
			strRetValue = objData.trim();
		}
		//값이 없을 경우 처리하지 않는다.
		if(strRetValue === ""){return "";}
		
		strRetValue = SCStringControl.replaceString(strRetValue,"\,","");

		var objArrayRetValue = strRetValue.split(".");
		if(SCNumberControl.isInteger(objArrayRetValue[0].trim())){
			if(parseInt(intLength,10) === 0){
				strRetValue = SCNumberControl.changeMoney(objArrayRetValue[0].trim());
			} else {
				if(objArrayRetValue.length === 2){
					if(SCNumberControl.isInteger(objArrayRetValue[1].trim())){
						if(objArrayRetValue[1].length <= intLength){
							strRetValue = SCNumberControl.changeMoney(objArrayRetValue[0].trim()) + SCConst.CHAR_SPLIT7 + SCStringControl.getFullCharBack(objArrayRetValue[1].trim(),intLength,"0");					
						} else {
							strRetValue = SCNumberControl.changeMoney(objArrayRetValue[0].trim()) + SCConst.CHAR_SPLIT7 + objArrayRetValue[1].trim().substring(0,intLength);					
						}
					} else{
						blnErrorState = true;
					}
				} else {
					strRetValue = SCNumberControl.changeMoney(objArrayRetValue[0].trim()) + SCConst.CHAR_SPLIT7 + SCStringControl.getFullCharBack("",intLength,"0");					
				}
			}
		} else {
			blnErrorState = true;
		}

		//처리결과 
		if(blnCheck && blnErrorState){
			if(SCObjectControl.isElement(objData)){
				SCMsgControl.alertMsg(objData.title + SCConst.SCMSG_NO_NUMBER);
				objData.select();
				objData.value= "";
			} else{
				SCMsgControl.alertMsg(SCConst.SCMSG_NO_NUMBER);
			}	
			return "";
		} else{
			return strRetValue;	
		}	
	},
	
	/**
	 * 마스크 처리
	 * @param {Object} objData
	 * @param {Object} strMask
	 * @param {Object} blnCheck
	 */
	getFormatMask:function(objData, strMask, blnCheck){
		//SCMsgControl.alertMsg("getFormatMask");
	},
		
	/**
	 * 데이터 플래그 를 설정한다.
	 * @param {String} strFormID 폼ID
	 * @param {String} strGroupID 데이터 그룹ID
	 * @param {String} strValue 설정할 플래그
	 */
	setDataFlag:function(strFormID, strGroupID, strValue){
		var strFindID = "";
		strGroupID !== "" ? strFindID=strGroupID + SCConst.CHAR_SPLIT2 + SCConst.DATAFLAG : strFindID=SCConst.DATAFLAG;

		if(strFormID === ""){
			var objElemnets = $$('INPUT[name="' + strFindID + '"]');	
		} else {
			var objElemnets = $(strFormID).getElementsBySelector('INPUT[name="' + strFindID + '"]');	
		}
		
		if (objElemnets.length > 0) {
			objElemnets[0].value = strValue;	
		} 
	},
	

	/**
	 * 데이터 플래그를 반환한다.
	 * @param {String} strFormID 폼ID
	 * @param {String} strGroupID 데이터 그룹ID
	 * @return {int} 현재 설정된 데이터 플래그 값
	 */
	getDataFlag:function(strFormID, strGroupID){
		var strFindID = "";
		strGroupID !== "" ? strFindID=strGroupID + SCConst.CHAR_SPLIT2 + SCConst.DATAFLAG : strFindID=SCConst.DATAFLAG;

		if(strFormID === ""){
			var objElemnets = $$('INPUT[name="' + strFindID + '"]');	
		} else {
			var objElemnets = $(strFormID).getElementsBySelector('INPUT[name="' + strFindID + '"]');	
		}
		if (objElemnets.length > 0) {
			return objElemnets[0].value;	
		} 
	},

	


	/**
	 * 화면에 디자인 된 Object Tag의 dataFld명을 기준으로 XML String데이터를 생성하연 반환한다.
	 * @param {String} strFormID 폼ID
	 * @param {String} strGroupID 데이터 그룹ID
	 * @param {String} strDataList 특정 데이만 XML 데이터에 포함하고 싶을 경우 COL01|COL02|…형태로 입력한다. 빈 문자열일 경우 디자인 된 모든 Element를 XML 데이터로 만들어 반환한다.
	 * @return {String} XML형식의 String 문자열
	 */
	getBindingData:function(strFormID, strGroupID, strDataList){
		var strRetData = "";
		var strFindID = "";
		strGroupID !== "" ? strFindID=strGroupID + SCConst.CHAR_SPLIT2 : strFindID= "";
		var objElements = $(strFormID).getElementsBySelector("INPUT[name], SELECT[name], TEXTAREA[name]");

		//플래그 데이터 처리를 먼저 한다.
		strRetData += SCGridControl.getMakeStringTag(SCConst.DATAFLAG, SCDataControl.getDataFlag(strFormID, strGroupID)); 

		//name이 있는 엘리멘트 개수  만큼 처리한다.
		objElements.each(
			function(objElement,i){
				//strGroupID가 없거나 또는 name이 strFindID를 포함한 것만 처리
				if(strGroupID === "" || objElement.name.indexOf(strFindID) >= 0){
					var strDataFld = Element.readAttribute(objElement, SCConst.DATAFLD_NAME);
					if (strDataFld !== null || strDataFld !== ""){
						if(strDataFld !== SCConst.DATAFLAG){
							if(strDataList === "-1" || strDataList === ""){
								//해당 데이터 로우에서 바인정보를 이용하여 데이터를 가지고 온다.
								var strDataValue = $F(objElement);
								strRetData += 	 SCGridControl.getMakeStringTag(strDataFld, strDataValue); 
							} else {
								var arrayDataList = strDataList.split(SCConst.CHAR_SPLIT);
								arrayDataList.each(
									function(strBindingName,j){
										if (strBindingName == strDataFld) {
											//해당 데이터 로우에서 바인정보를 이용하여 데이터를 가지고 온다.
											var strDataValue = $F(objElement);
											strRetData += 	 SCGridControl.getMakeStringTag(strDataFld, strDataValue); 
										}
									}
								);
							}							
						}
					}
				}
			}							
		);
		if (strRetData !== ""){
			strRetData =  "<" + SCConst.TABLE+ ">" + strRetData + "</" + SCConst.TABLE + ">";
		}
		return strRetData;
	},
	

	/**
	 * XML형식의 데이터를 디자인 화면에 바인딩 처리하여 데이터가 자동으로 화면에 입력할 수 있게 한다.
	 * @param {String} strFormID 폼ID
	 * @param {String} strGroupID 데이터 그룹ID
	 * @param {String} strXMLData XML형식의 데이터
	 * @param {int} intFlagValue 설정할 플래그 값 (없을 경우 0으로 자동 설정됨)
	 */
	setBindingData:function(strFormID, strGroupID, strXMLData, intFlagValue){
		//플래그 초기값 설정
		if(typeof(intFlagValue) === SCConst.UNDEFINED){intFlagValue = SCConst.NO_TRANS;}

		//데이터를 XMLDOM으로 로드하여 로우별로 추출한다.
		var xmlDoc = SCXMLControl.getXMLDoc(strXMLData);
		var xmlElements = SCXMLControl.getElements(xmlDoc, SCConst.TABLE);
		$A(xmlElements[0].childNodes).each(
			function(xmlElement,i){
				//Element명과 값 추출
				var strElementName = xmlElement.tagName;
				if (SCBrowserControl.ie){
					var strElementValue =  xmlElement.text;
				}else{
					var strElementValue =  xmlElement.textContent;
				}
				//값설정
				SCDataControl.setData(strFormID, strGroupID, strElementName, strElementValue);
			}
		);

		//데이터플래그설정
		SCDataControl.setDataFlag(strFormID, strGroupID, intFlagValue);		
	},


	/**
	 * 해당 데이터가 변경된 것을 플래그에 적용시킴
	 * @param {String} strFormID 폼ID
	 * @param {Element} objElement 데이터가 변경된 엘리멘트 
	 */
	dataChanged:function(strFormID, objElement, strGID){
		var strFlagValue = "";
		var strGroupID  = "";
		
		//그룹ID가 있을 경우 GroupID를 설정한다.
		if(typeof(strGID) !== SCConst.UNDEFINED && strGID !== ""){
			strGroupID  = strGID;
		}

		
		//엘리멘트객체가 있을경우에는 해당 엘리멘트의 객체의 GroupID로 설정한다.
		if(objElement !== ""){
			if(objElement.name.indexOf(SCConst.CHAR_SPLIT2) >= 0){
				strGroupID = objElement.name.substring(0,objElement.name.indexOf(SCConst.CHAR_SPLIT2));
			}
		}
		
		strFlagValue = this.getDataFlag(strFormID, strGroupID);

	 	//플래그 상태에 따라 데이터 변경시 플래그를 변경한다.[Delete는 차 후 생각]
		switch (eval(strFlagValue)) {
			case SCConst.NO_TRANS :
				this.setDataFlag(strFormID, strGroupID, SCConst.UPD_TRANS);
			  	break;
			case  SCConst.INS_TRANS :
				this.setDataFlag(strFormID, strGroupID, SCConst.INS_TRANS);
				break;
			case  SCConst.UPD_TRANS :
				this.setDataFlag(strFormID, strGroupID, SCConst.UPD_TRANS);
				break;
			default :
			  	break;
		}
	}, 	


	/**
	 * 필수 데이터 입력 또는 데이터 변경여부와 같은 기본적인 데이터 체크를 처리한다.
	 * @param {String} strFormID 폼ID
	 * @param {String} strGroupID 데이터 그룹ID
	 * @param {boolean} blnCheckUPD 데이터 변경여부 체크 (true:체크, false:체크하지 않음)
	 */
	dataValidation:function(strFormID, strGroupID, blnCheckUPD){
		if(typeof(blnCheckUPD) === SCConst.UNDEFINED){blnCheckUPD = true;}
		
		strGroupID !== "" ? strFindID=strGroupID + SCConst.CHAR_SPLIT2 : strFindID= "";
		var objElements = $(strFormID).getElementsBySelector("INPUT[name], SELECT[name], TEXTAREA[name]");

		//데이터 변경여부 체크
		if(blnCheckUPD){
			if(parseInt(this.getDataFlag(strFormID, strGroupID),10) === SCConst.NO_TRANS){
				SCMsgControl.alertMsg(SCConst.SCMSG_NO_CHANGE);
				return false;
			}
		}
		
		
		//name이 있는 엘리멘트 개수  만큼 처리한다.
		for (var i=0; i < objElements.length; i++){
			//strGroupID가 없거나 또는 name이 strFindID를 포함한 것만 처리
			if(strGroupID === "" || objElements[i].name.indexOf(strFindID) >= 0){
				var strAccessKey = objElements[i].accessKey;
				if (strAccessKey !== null  && strAccessKey !== "" && typeof(strAccessKey) !== SCConst.UNDEFINED){
					var objArrayAccessKey = strAccessKey.split(SCConst.CHAR_SPLIT1);
					if (objArrayAccessKey.length > 2){
						//필수입력체크
						if (objArrayAccessKey[1] == SCConst.ACC_KEY_M){
							if($F(objElements[i]) === ""){
								SCMsgControl.alertMsg(objElements[i].title + SCConst.SCMSG_CHECK_INPUT);
								
								try{
									objElements[i].focus();
								} catch(ex){
									objElements[i].select();
								}
								
								return false;
							}	
						}
						
						//데이터 포멧체크
						if (objArrayAccessKey.length === 3 && objArrayAccessKey[0] !== ""){
							if(!SCDataControl.checkDataFormat(objElements[i], objArrayAccessKey[0])){
								return false;
							}									
						}

					}
				}
			}
		}
		return true;
	},

	/**
	 * 각 입력 필드들의 데이터 체크
	 * @param {Object} objElement 입력 필드 오브젝트
	 */
	fieldValidation:function(objElement){
		if($F(objElement) === ""){
			SCMsgControl.alertMsg(objElement.title + SCConst.SCMSG_CHECK_INPUT);
			return false;
		}
		return true;
	},
	
	/**
	 * 정의된 포멧으로 데이터를 체크한다.
	 * @param {Object} objElement 엘리멘트 객체
	 * @param {String} strFormat accesskey의 0번째 선언된 포멧 정보
	 */
	checkDataFormat:function(objElement, strFormat){
		var strData = $F(objElement);
		var objArrayFormat = strFormat.split(SCConst.CHAR_SPLIT4);
	 	//정의된 포멧으로 설정한다.
		if(strData !== "" ){
			switch (objArrayFormat[0]) {
				case "DATE" :
					strData = SCDataControl.getFormatDate(objElement, true); break;
				case "TIME" :
					strData = SCDataControl.getFormatTime(objElement, true); break;
				case "LONGTIME" :
					strData = SCDataControl.getFormatTimeLong(objElement, true, true); break;
				case "MON" :
					strData = SCDataControl.getFormatMonth(objElement, true, true); break;
				case "NUM" :
					if(!SCNumberControl.isInteger(strData)){
						SCMsgControl.alertMsg(SCConst.SCMSG_NO_NUMBER);
						strData = 0;				
					} 
					break;
				case "INT" :
					strData = SCDataControl.getFormatNumber(objElement, 0, true); break;
				case "DEC" :
					if(objArrayFormat.length === 2){
						strData = SCDataControl.getFormatNumber(objElement,objArrayFormat[1],true);
					} else {
						strData = SCDataControl.getFormatNumber(objElement,2,true);
					}
					break;
				case "MASK" :
					if(objArrayFormat.length === 2){
						strData = SCDataControl.getFormatMask(strData,objArrayFormat[1]);
					} 
					break;
			}			

			if(strData === ""){return false;}
		}
		return true;
	},
	
	/**
	 * 데이터가 변경되었는지 체크
	 * @param {String} strFormID 폼ID
	 * @param {String} strGroupID 데이터 그룹ID
	 * @return {boolean} 데이터 변경여부
	 */
	isDataChanged:function(strFormID, strGroupID){
		if(eval(SCDataControl.getDataFlag(strFormID, strGroupID)) === SCConst.UPD_TRANS){
			return true;
		} else {
			return false;
		}
	},
	
	/**
	 * 폼ID와 그룹아이디, 필드명을 이용하여 데이터를 설정한다.
	 * @param {Object} strFormID
	 * @param {Object} strGroupID
	 * @param {Object} strDataFld
	 * @param {Object} strValue
	 */
	setData:function(strFormID, strGroupID, strDataFld, strValue){
		var strFindID = "";
		strGroupID !== "" ? strFindID=strGroupID + SCConst.CHAR_SPLIT2 : strFindID= "";
		var objElements = $(strFormID).getElementsBySelector("INPUT[name], SELECT[name], TEXTAREA[name]");
		//name이 있는 엘리멘트 개수  만큼 처리한다.
		objElements.each(
			function(objElement,i){
				//strGroupID가 없거나 또는 name이 strFindID를 포함한 것만 처리
				if(strGroupID === "" || objElement.name.indexOf(strFindID) >= 0){
					var strDataFldName = Element.readAttribute(objElement, SCConst.DATAFLD_NAME);
					if (strDataFldName !== null || strDataFldName !== ""){
						if(strDataFldName === strDataFld){
							
							SCDataControl.setDataValue(objElement, strValue);
						}
					}
				}
			}							
		);
	},
		
	
	/**
	 * 필드명을 이용하여 데이터 설정
	 * @param {Object} objElement
	 * @param {Object} strValue
	 */
	setDataValue:function(objElement, strValue){
		switch (objElement.tagName.toUpperCase()) {
		   case "INPUT" :
		   		if(objElement.type === "checkbox" || objElement.type === "radio"  ){
					if (strValue === "1" || strValue === 1 || eval(strValue) === true || strValue === "Y" ){
						objElement.checked = true;
					} else {
						objElement.checked = false;
					}
				} else {
					objElement.value = strValue;
				}
				break;
		   case "SELECT" :
		   case "TEXTAREA" :
		     	objElement.value = strValue;
			  	break;
		} 
	},
	
	
	/**
	 * 필드리스트와 데이터리스트를 이용하여 XML데이터를 생성한다.(필드와 데이터 순서가 동일해야 한다.
	 * @param {Object} strFildList 필드리스트(구분자 |) 
	 * @param {Object} strDataList 데이터리스트(구분자 |)
	 */
	getMakeXmlData:function(strFildList, strDataList){
		var objFildList = strFildList.split(SCConst.CHAR_SPLIT);
		var objDataList = strDataList.split(SCConst.CHAR_SPLIT);
		var strXmlData = "<DataSet><Table>";

		//필드 개수와 데이터 개수가 동일할 겨우만 처리
		if(objFildList.size() === objDataList.size()){
			for(var i=0;i<objFildList.size();i++){
				strXmlData += SCGridControl.getMakeStringTag(objFildList[i], objDataList[i]);
			}		
		}
		strXmlData += "</Table></DataSet>";
		return strXmlData;
	},
	
	/**
	 * 테스트 오브젝트의 최고 길이 체크
	 * @param {Object} strID 테스트 오브젝트 ID
	 * @param {Object} intMax 체크할 최대길이
	 * @param {int} 유니코드 방식 여부 (1 = Unicode, 0 또는 빈칸 = ASCII)
	 * @return {boolean} 초과되었을 경우 false
	 */
	chkMaxLength:function(strID, intMax, intUnicode){
		if (SCObjectControl.retCountChars(strID, intUnicode) > intMax) {
    		SCMsgControl.alertMsg($(strID).title + SCConst.SCMSG_CHAR_LIMIT_OVR);
    		$(strID).focus();
    		return false;
  		} else	{
			return true;
		}	
	},

	/**
	 * 콤보박스에 데이터를 동적으로 로딩한다.
	 * @param {Object} cmbBox 콤보박스 오브젝트
	 * @param {Object} list 데이터 리스트 객체(ArrayList)
	 * @param {Object} listKey Key명
	 * @param {Object} listValue Value명
	 * @param {Object} headerKey header가 되는 key 값(optional)
	 * @param {Object} headerValue header가 되는 value 값(optional)
	 */
	loadComboBox:function(cmbBox, list, listKey, listValue, headerKey, headerValue){
		this.removeComboBox (cmbBox);
		this.addComboBox (cmbBox, list, listKey, listValue, headerKey, headerValue);
		cmbBox.selectedIndex = 0;
	},

	/**
	 * 콤보박스에 데이터를 삭제한다.
	 * @param {Object} cmbBox cmbBox 콤보박스 오브젝트
	 */
	removeComboBox:function(cmbBox){
		for (i = 0; i < cmbBox.length; i++){
			cmbBox.options.remove(i);
		}
	
		cmbBox.length=0;
	},
	
	/**
	 * 콤보박스에 데이터를 동적으로 추가한다.
	 * @param {Object} cmbBox 콤보박스 오브젝트
	 * @param {Object} list 데이터 리스트 객체(ArrayList)
	 * @param {Object} listKey Key명
	 * @param {Object} listValue Value명
	 * @param {Object} headerKey header가 되는 key 값(optional)
	 * @param {Object} headerValue header가 되는 value 값(optional)
	 */
	addComboBox:function(cmbBox, list, listKey, listValue, headerKey, headerValue){
		//header 처리
		if (headerKey !== undefined && headerValue !== undefined) {
			var objOption = document.createElement ("OPTION");
			objOption.value = headerKey;
			objOption.text = headerValue;
//			cmbBox.add (objOption);
			cmbBox.options.add (objOption);					// FF 에서 작동되게끔 수정 
		}
		
		//list 데이터를 combo에 추가
		for (i=0; i < list.length; i++) {
			var objOption = document.createElement ("OPTION");
			objOption.value = list[i][listKey]; //list[i].code;
			objOption.text = list[i][listValue]; //list[i].name;
//			cmbBox.add (objOption);
			cmbBox.options.add (objOption);					// FF 에서 작동되게끔 수정 
		}
	}
};

var SCStringControl={
	/**
	 * 문자열에서 특정문자를 찾아 모두 다른 문자로 치환한다.
	 * @param {String} strData 대상문자열
	 * @param {String} strSearch 바꿀 대상문자
	 * @param {String} strReplace 바꿀 문자
	 * @return {String} 치환된 문자열
	 */
	replaceString:function(strData, strSearch, strReplace){
		var strTmp = "";
		do {
			strTmp = strData;
			strData = strData.replace (strSearch, strReplace);
		} while (strTmp != strData);
		return strData;
	},	
	
	/**
	 * 데이터 길이가 입력한 글자 길이보다 작을 경우 작은 만큼 해당문자열을 채워서 반환한다.
	 * @param {String} strData 문자열
	 * @param {int} intLength 전체 문자열의 길이
	 * @param {String} strChar 문자열이 작을 경우 채워넣어야 할 문자
	 */
	getFullChar:function(strData, intLength, strChar){
		var strChars = "";
		if(strData.length < intLength){
			for(var i = 0; i < intLength - strData.length; i++){
				strChars += strChar;
			}
		}
		return strChars + strData;
	},	
	getFullCharBack:function(strData, intLength, strChar){
		var strChars = "";
		if(strData.length < intLength){
			for(var i = 0; i < intLength - strData.length; i++){
				strChars += strChar;
			}
		}
		return strData + strChars;
	},
	
	/**
	 * 올바른 전화번호 형식(숫자-숫자-숫자)인지 체크
	 */	
	isValidPhone:function(strData){
	    if (strData.search(/^(\d+)-(\d+)-(\d+)$/g)!=-1){ return true;}
	    else { return false;}
	}, 

	/**
	 * 알파벳만으로 구성된 문자열인지 체크
	 */	
	isAlphabet:function(strData){
	    if (strData.search(/[^a-zA-Z]/g)===-1){ return true;}
	    else {return false;}
	}, 
	
	/**
	 * 대문자로만 구성된 문자열인지 체크
	 */	
	isUpperCase:function(strData){
    if (strData.search(/[^A-Z]/g)==-1){ return true;}
    else { return false;}
	}, 

	/**
	 * 소문자로만 구성된 문자열인지 체크
	 */	
	isLowerCase:function(strData){
	    if (strData.search(/[^a-z]/g)==-1){ return true;}
	    else { return false;}
	}, 

	/**
	 * 한글로만 구성된 문자열인지 체크
	 */	
	isKorean:function(strData){
	    var strLength = strData.length;
	    var i;
	    var Unicode;
	
	    for (i=0;i<strLength;i++) 
	    {
	        Unicode = strData.charCodeAt(i);
	        if ( !(44032 <= Unicode && Unicode <= 55203) ){ return false; }
	    }
	    return true;
	}, 
	
	/**
	 * 한글로된 문자인지 체크
	 */	
	isKoreanChar:function(strData){
        if (strData.search(/[ㄱ-ㅎ|ㅏ-ㅣ|가-힝]/)==-1){ return false; }
        else { return true; }
	},	


	/**
	 * 문자열이 NULL인지 체크
	 */	
	isNull:function(strData){
	    if (strData === null || strData === ""){ return true;}
	    else { return false;}
	}, 

	/**
	 * 문자열에 한칸이상의 스페이스 입력이 있는지를 체크
	 */	
	isValidSpace:function(strData){
		if(strData.indexOf(" ") >-1){return true;}
		else {return false;}
	},
	
	/**
	 * 특수문자 체크
	 */	
	isSpecialChar:function(strData){
        if (strData.search(/[0-9|a-z|A-Z|ㄱ-ㅎ|ㅏ-ㅣ|가-힝]/)!=-1){ return false;}
        else { return true;}

	},
	/**
	 * 문자열에 하나이상의 특수문자가 있는지 체크
	 */	
	isSpecial:function(strData){
        strData = strData.replace(/[0-9|a-z|A-Z|ㄱ-ㅎ|ㅏ-ㅣ|가-힝]/g,'');
		if(strData !==""){return true;}
		else {return false;}
	},	
	
	/**
	 * 문자를 URI 엔코딩으로 변환하여 반환
	 * 주의 : & 특수문자는 GET방식 처리 시 문제가 발생할 수 있으므로 %26으로 강제 치환 함.
	 * @param {Object} strData
	 * @param {Object} blnReplace "&" 변경여부
	 */
	getEncodingURI:function(strData, blnReplace){
		if(typeof(blnReplace) === SCConst.UNDEFINED){blnReplace = true;}
		strData = encodeURI(strData);
		if(blnReplace){strData = SCStringControl.replaceString(strData,"&","%26");}
		return strData;
	}
};




var SCMsgControl = {
	/**
	 * 정보 표시 메시지
	 * @param {Object} strMsg 정보메시지
	 */
	alertMsg:function(strMsg){
		alert(strMsg);
	},
	
	/**
	 * 확인 메시지
	 * @param {Object} strMsg 정보메시지
	 * @return true:확인/false:취소
	 */
	confirmMsg:function(strMsg){
		return confirm(strMsg);
	},
	/**
	 * 질문 메시지
	 * @param {Object} strMsg 메시지 
	 * @param {Object} strTitle 타이틀
	 * @return 사용자가 입력한 내용
	 */
	promptMsg:function(strMsg, strTitle){
		return prompt(strTitle,strMsg);
	}
};


/**
 * HTML 에디터 관련 컨트롤 ('FCKeditor' or 'xquered')
 */
var SCEditorControl={
	EDITOR_TYPE : 'fck',		// 'fck' or 'xq'
	DEFAULT_TOOLBARSET : "General",
	DEFAULT_HEIGHT : "360px",
	objEditorData : null,
	
	/**
	 * Editor Config
	 */
	config : { userPath    : '',	//UserID or 일감번호 or 공모번호 or 클럽번호
			   toolbarSet  : '',
			   linkUpload  : false,
			   imageUpload : false,
			   flashUpload : false
			 },

	/*
	 * default config 상태로 설정
	 */
	setDefaultConfig:function() {
		this.config.userPath = '';
		this.config.toolbarSet = '';
		this.config.linkUpload = false;
		this.config.imageUpload = false;
		this.config.flashUpload = false;
	},	
			 
	/**
	 * 에디터 생성 : Textarea 위치에 생성된다.
	 * 
	 * @param {Object} contentElementID TEXTAREA to be replaced with editable area, or DOM ID string for TEXTAREA.
	 * @param {Object} userPath UserID or 일감번호 or 공모번호 or 클럽번호
	 * @param {Object} width Editor width
	 * @param {Object} height Editor Height 
	 * @param {Object} value Editor content value
	 */
	createEditor:function(contentElementID, width, height, value) {
		if (this.EDITOR_TYPE == 'fck') {
			//var strBasePath = gRootWebEtc + '/fckeditor/'; //fileBrowser가 동작하지 않음
			var strBasePath = gRootWebContents + '/fckeditor/'; 
			var objEditor = new FCKeditor( contentElementID ) ;
			
			objEditor.Config["CustomConfigurationsPath"] = gRootWebEtc + "/SCFckConfig.js"  ;

			//에디터에 삽입되는 link, image, flash 등의 저장위치를 지정
			objEditor.Config["UserPath"] = this.config.userPath;
			
			//link에서 서버보기와 업로드 탭을 나타나지 않게 하는 경우 설정
			objEditor.Config["LinkBrowser"] = this.config.linkUpload;
			objEditor.Config["LinkUpload"] = this.config.linkUpload;

			//image에서 서버보기와 업로드 탭을 나타나지 않게 하는 경우 설정
			objEditor.Config["ImageBrowser"] = this.config.imageUpload ;
			objEditor.Config["ImageUpload"] = this.config.imageUpload ;
			
			//flash에서 서버보기와 업로드 탭을 나타나지 않게 하는 경우 설정
			objEditor.Config["FlashBrowser"] = this.config.flashUpload ;
			objEditor.Config["FlashUpload"] = this.config.flashUpload ;

			objEditor.BasePath	= strBasePath ;
			
			if(typeof(width) !== "undefined") 		{objEditor.Width = width;}
			if(typeof(height) !== "undefined") 	{objEditor.Height = height;} else {objEditor.Height = this.DEFAULT_HEIGHT;} 
			if(typeof(value) !== "undefined") 		{objEditor.Value	= value;}
			if(this.config.toolbarSet === "") 		{objEditor.ToolbarSet	= this.DEFAULT_TOOLBARSET;} else {objEditor.ToolbarSet	= this.config.toolbarSet;}
	
			objEditor.ReplaceTextarea() ;

			return objEditor;
		}
		else {
			var objEditor = new xq.Editor(contentElementID);
	
			//에디터 툴바 이미지 폴더 설정	
			objEditor.config.imagePathForDefaultToolbar = gRootWebEtc + "/editor/images/toolbar/";
			
			//에디터 CSS파일 설정
			objEditor.loadStylesheet(gRootWebEtc + "/editor/stylesheets/xq_ui.css");
	
			//에디터 모드 설정	
			objEditor.setEditMode("wysiwyg");

			//에디터 툴바 이미지 폴더 설정	
			objEditor.config.contentCssList = [gRootWebEtc + '/editor/stylesheets/xq_contents.css'];
		
			if(typeof(width) !== "undefined") {objEditor.setWidth(width);}
			if(typeof(height) !== "undefined") {objEditor.setHeight(height);} else {objEditor.Height = this.DefaultHeight;} 
			
			return objEditor;
		}		
	},
	
	
	/**
	 * 툴바 영역 지정 에디터 생성
	 * @param {Object} contentElementID TEXTAREA to be replaced with editable area, or DOM ID string for TEXTAREA.
	 * @param {Object} toolBarElementID ToolBar area 
	 */
	createEditorToolBar:function(contentElementID, width, height, value, toolBarElementID) {
		if (this.EDITOR_TYPE == 'fck') {
			//var strBasePath = gRootWebEtc + '/fckeditor/'; //fileBrowser가 동작하지 않음
			var strBasePath = gRootWebContents + '/fckeditor/';
			var objEditor = new FCKeditor(contentElementID);
			
			objEditor.Config["CustomConfigurationsPath"] = gRootWebEtc + "/SCFckConfig.js";
			
			//에디터에 삽입되는 파일, 이미지 등의 저장위치를 지정
			objEditor.Config["UserPath"] = this.config.userPath;
			
			// 툴바 영역 설정
			objEditor.Config['ToolbarLocation'] = 'Out:' + toolBarElementID;
			
			objEditor.BasePath = strBasePath;
			
			if (typeof(width) !== "undefined") {
				objEditor.Width = width;
			}
			if (typeof(height) !== "undefined") {
				objEditor.Height = height;
			}
			else {
				objEditor.Height = this.DEFAULT_HEIGHT;
			}
			if (typeof(value) !== "undefined") {
				objEditor.Value = value;
			}
			if (this.config.toolbarSet === "") {
				objEditor.ToolbarSet = this.DEFAULT_TOOLBARSET;
			}
			else {
				objEditor.ToolbarSet = this.config.toolbarSet;
			}
			
			objEditor.ReplaceTextarea();
			
			return objEditor;
		} else {
			var objEditor = new xq.Editor(contentElementID, toolBarElementID);
			
			//에디터 툴바 이미지 폴더 설정	
			objEditor.config.imagePathForDefaultToolbar = gRootWebEtc + "/editor/images/toolbar/";
			
			//에디터 CSS파일 설정
			objEditor.loadStylesheet(gRootWebEtc + "/editor/stylesheets/xq_ui.css");
			
			//에디터 모드 설정	
			objEditor.setEditMode("wysiwyg");
			
			//에디터 툴바 이미지 폴더 설정	
			objEditor.config.contentCssList = [gRootWebEtc + '/editor/stylesheets/xq_contents.css'];
			
			if (typeof(width) !== "undefined") {
				objEditor.setWidth(width);
			}
			if (typeof(height) !== "undefined") {
				objEditor.setHeight(height);
			}
			else {
				objEditor.Height = this.DefaultHeight;
			}
			
			return objEditor;
		}
	},

	/**
	 * 에디터 툴바 속성을 정의
	 */
	getToolbarButtonMap:function(){
		if (this.EDITOR_TYPE == 'fck') return;
		
		return [
			[
				{className:"foregroundColor", title:"Foreground color", handler:"xed.handleForegroundColor()"},
				{className:"backgroundColor", title:"Background color", handler:"xed.handleBackgroundColor()"}
			],
			[
				{className:"fontFace", title:"Font face", list:[
                    {title:"Arial", handler:"xed.handleFontFace('Arial')"},
                    {title:"Helvetica", handler:"xed.handleFontFace('Helvetica')"},
                    {title:"Serif", handler:"xed.handleFontFace('Serif')"},
                    {title:"Tahoma", handler:"xed.handleFontFace('Tahoma')"},
                    {title:"Verdana", handler:"xed.handleFontFace('Verdana')"}
				]},
				{className:"fontSize", title:"Font size", list:[
                    {title:"1", handler:"xed.handleFontSize('1')"},
                    {title:"2", handler:"xed.handleFontSize('2')"},
                    {title:"3", handler:"xed.handleFontSize('3')"},
                    {title:"4", handler:"xed.handleFontSize('4')"},
                    {title:"5", handler:"xed.handleFontSize('5')"},
                    {title:"6", handler:"xed.handleFontSize('6')"}
				]}
			],
			[
				{className:"link", title:"Link", handler:"xed.handleLink()"},
				{className:"strongEmphasis", title:"Strong emphasis", handler:"xed.handleStrongEmphasis()"},
				{className:"emphasis", title:"Emphasis", handler:"xed.handleEmphasis()"},
				{className:"underline", title:"Underline", handler:"xed.handleUnderline()"},
				{className:"strike", title:"Strike", handler:"xed.handleStrike()"},
				{className:"superscription", title:"Superscription", handler:"xed.handleSuperscription()"},
				{className:"subscription", title:"Subscription", handler:"xed.handleSubscription()"}
			],
			[
				{className:"removeFormat", title:"Remove format", handler:"xed.handleRemoveFormat()"}
			],
			[
				{className:"justifyLeft", title:"Justify left", handler:"xed.handleJustify('left')"},
				{className:"justifyCenter", title:"Justify center", handler:"xed.handleJustify('center')"},
				{className:"justifyRight", title:"Justify right", handler:"xed.handleJustify('right')"},
				{className:"justifyBoth", title:"Justify both", handler:"xed.handleJustify('both')"}
			],
			[
				{className:"indent", title:"Indent", handler:"xed.handleIndent()"},
				{className:"outdent", title:"Outdent", handler:"xed.handleOutdent()"}
			],
			[
				{className:"unorderedList", title:"Unordered list", handler:"xed.handleList('UL')"},
				{className:"orderedList", title:"Ordered list", handler:"xed.handleList('OL')"}
			],
			[
				{className:"paragraph", title:"Paragraph", handler:"xed.handleApplyBlock('P')"},
				{className:"heading1", title:"Heading 1", handler:"xed.handleApplyBlock('H1')"},
				{className:"blockquote", title:"Blockquote", handler:"xed.handleApplyBlock('BLOCKQUOTE')"},
				{className:"code", title:"Code", handler:"xed.handleList('OL', 'code')"},
				{className:"division", title:"Division", handler:"xed.handleApplyBlock('DIV')"}
			],
			[
				{className:"table", title:"Table", handler:"xed.handleTable(4, 4,'tl')"},
				{className:"separator", title:"Separator", handler:"xed.handleSeparator()"}
			],
			[
				{className:"html", title:"Edit source", handler:"xed.toggleSourceAndWysiwygMode()"}
			],
			[
				{className:"undo", title:"Undo", handler:"xed.handleUndo()"},
				{className:"redo", title:"Redo", handler:"xed.handleRedo()"}
			]
		];
	},
	
	/**
	 * 에디터의 내용이 변경 되었는지 체크
	 * (중요)에디터는 자동으로 데이터 변경 플래그를 설정하지 못하므로 이를 호출하여 처리해야 함.
	 * @param {Object} objEditor 에디터
	 * @param {String} strFormID Form ID
	 * @param {String} 데이터 그룹 ID
	 */
	isDataChanged :function(objEditor, strFormID, strGroupID) {
		if (this.EDITOR_TYPE == 'fck') {
			var objFCK = FCKeditorAPI.GetInstance(objEditor.InstanceName) ;
			if(objFCK.IsDirty()) {
				//원본 Textarea에 변경된 데이터 저장
				objFCK.UpdateLinkedField();
				
				if (SCDataControl.getDataFlag(strFormID, strGroupID) == SCConst.NO_TRANS) {
					SCDataControl.setDataFlag(strFormID, strGroupID, SCConst.UPD_TRANS);
				}
				return true;		
			}
		}
		else {
			if(objEditor.getCurrentContent() !== objEditor.contentElement.value) {
				objEditor.contentElement.value = objEditor.getCurrentContent();
				if (SCDataControl.getDataFlag(strFormID, strGroupID) == SCConst.NO_TRANS) {
					SCDataControl.setDataFlag(strFormID, strGroupID, SCConst.UPD_TRANS);
				}
				return true;		
			}
		}
		return false;
	},
	
	/**
	 * 에디터 사이즈 설정
	 * @param {Object} objEditor 에디터
	 * @param {Object} width 넓이 (For example, "100%", "200px")
	 * @param {Object} height 높이 (For example, "100%", "200px")
	 */
	setSize :function(objEditor, width, height) {
		if (this.EDITOR_TYPE == 'fck') {
			/* FCK Editor */
			document.getElementById(objEditor.InstanceName + '___Frame').style.width = width;
			document.getElementById(objEditor.InstanceName + '___Frame').style.height = height;
		}
		else {
			/* Xquered Editor */
			objEditor.setWidth(width);
			objEditor.setHeight(height);
		}	
		
	},
	
	/**
	 * 에디터 데이터 설정
	 * @param {Object} objEditor 에디터
	 * @param {Object} html 데이터
	 */
	setHtmlContent: function (objEditor, html) {
		if (this.EDITOR_TYPE == 'fck') {
			var objFCK = FCKeditorAPI.GetInstance(objEditor.InstanceName) ;
			objFCK.SetHTML(html);
		}
		else {
			objEditor.setStaticContent(html);
			objEditor.loadCurrentContentFromStaticContent();		
		}		
	},
	
	/**
	 * 에디터의 데이터를 얻음
	 * @param {Object} objEditor 에디터
	 */
	getHtmlContent: function (objEditor) {
		if (this.EDITOR_TYPE == 'fck') {
			var objFCK = FCKeditorAPI.GetInstance(objEditor.InstanceName) ;
			return objFCK.GetHTML();
		}
		else {
			return objEditor.getCurrentContent();
		}		
	},
	
	/**
	 * 에디터에 포커스를 설정
	 * (주의)FCKeditor의 경우 에디터가 로드된 후에 호출해야 한다.
	 * @param {Object} objEditor 에디터
	 */
	setFocus: function (objEditor) {
		if (this.EDITOR_TYPE == 'fck') {
			try{
				var objFCK = FCKeditorAPI.GetInstance(objEditor.InstanceName) ;
				objFCK.Focus();
			}catch(ex){}		
		}
		else {
			objEditor.focus();
		}
	},
	
	
	unescapeQuot:function(content) {
		content = content.replace(/'/g, "&apos;");
		return content;
	},
	
	
	escapeQuot:function(content) {
		content = content.replace(/&apos;/g, "'");
		return content;
	}
};


/**
 * Treeview 컨트롤
 */
var SCTreeControl={
	
	/**
	 * Node가 선택되었는지 체크
	 * 
	 * @param {String} trDivID Tree를 Div로 감싼 태그의 ID
	 * @return {boolean} 선택된 노드가 있는 경우 true, 없는 경우 false
	 */
	isNodeSelected:function(strDivID){
		var objSelected = $(strDivID).getElementsBySelector("input[type=checkbox]");
		for(var i=0;i<objSelected.length; i++){
			if(objSelected[i].checked){ return true; }
		}
		return false;
	},
	
	/**
	 * 선택된 노드 정보를 반환한다. 
	 * @param {String} strDivID Tree를 Div로 감싼 태그의 ID
	 * @param {boolean} blnXml 결과를 xml로 반환할 경우 true /  Array객체로 반환할 경우 false
	 * @return {String or Array} XML형식의 데이터 또는 Array객체(node id, pid 값을 가짐)
	 */
	getSelectedNode:function(strDivID, blnXml) {
		var objSelected = $(strDivID).getElementsBySelector("input[type=checkbox]");
		var strRetXml = "";
		var objRetArray = new Array();
		var intIndex = 0;
	
		objSelected.each(
			function(objControl, i){
				if (objControl.checked) {
					
					if (blnXml) {
						strRetXml += "<" + SCConst.TABLE+ ">" + "<ID>" + objControl.id + "</ID>" + "<PID>" + objControl.pid + "</PID>" + "</" + SCConst.TABLE + ">";	
					} else {
						var objArray = new Array();
						objArray[0] = objControl.id;
						objArray[1] = objControl.pid;
						objRetArray[intIndex] = objArray; intIndex += 1;
					}
					
				}
			}
		);
		
		if (blnXml && strRetXml !== ""){
			strRetXml =   "<" + SCConst.DATA_SET + ">" + strRetXml + "</" + SCConst.DATA_SET + ">";
		}
		if(blnXml){
			return strRetXml;
		} else {
			return objRetArray;
		}
	},
	
	/**
	 * Tree 생성 스크립트에서 document.write를 제거하여 특정 영역으로 트리가 생성되도록 한다. 
	 * @param {Object} strTreeData 트리 생성 스크립트를 포함하는 HTML Tag
	 */
	removeTreeWriteScript:function(strTreeData) {
		//Tree를 특정 영역에 표시하기 위해 document에 표시하는 script 제거
		return SCStringControl.replaceString (strTreeData, "document.write", "//Tree Write");
	},
		
	/**
	 * Tree 생성 스크립트를 실행하여 트리 Tag를 만든다.
	 * @param {Object} strTreeID Tree Object ID
	 */
	runTreeScript:function(strTreeID) {
		//Tree 생성 스크립트를 실행 : Tree ID_script
		eval($(strTreeID + "_script").innerHTML);
	}	

};




/**
 * 자주 사용하는  prototype
 */

/**
 * 문자의 좌, 우 공백 제거
 * @return {String} 좌,우 공백이 제거된 문자열
 */
String.prototype.trim = function() {
	return this.replace(/(^\s*)|(\s*$)/g, "");
};

/**
 * 문자의 좌 공백 제거
 * @return {String} 좌 공백이 제거된 문자열
 */
String.prototype.ltrim = function() {
	return this.replace(/(^\s*)/, "");
};

/**
 * 문자의 유 공백 제거
 * @return {String} 우 공백이 제거된 문자열
 */	
String.prototype.rtrim = function() {
	return this.replace(/(\s*$)/, "");
};


/**
 * 주민번호 체크 
 * @param {Object} arguments[0] : 주민번호 구분자
 * @return {boolean} 
 */	
String.prototype.isJumin = function() {
	var arg = arguments[0] ? arguments[0] : "";
	var jumin = eval("this.match(/[0-9]{2}[01]{1}[0-9]{1}[0123]{1}[0-9]{1}" + arg + "[1234]{1}[0-9]{6}$/)");
	if(jumin === null) {
		return false;
	} else {
		jumin = jumin.toString().num().toString();
	}
	// 생년월일 체크
	var birthYY = (parseInt(jumin.charAt(6),10) == (1 ||2)) ? "19" : "20";
	birthYY += jumin.substr(0, 2);
	var birthMM = jumin.substr(2, 2) - 1;
	var birthDD = jumin.substr(4, 2);
	var birthDay = new Date(birthYY, birthMM, birthDD);
	if(birthDay.getYear() % 100 != jumin.substr(0,2) || birthDay.getMonth() != birthMM || birthDay.getDate() != birthDD) {
		return false;
	}
	var sum = 0;
	var num = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5];
	var last = parseInt(jumin.charAt(12),10);
	for(var i = 0; i < 12; i++) {
		sum += parseInt(jumin.charAt(i),10) * num[i];		
	}
	return ((11 - sum % 11) % 10 == last) ? true : false;	
};


/**
 * 외국인등록번호 체크 
 * @param {Object} arguments[0] : 등록번호 구분자
 * @return {boolean} 
 */	
String.prototype.isForeign = function() {
	var arg = arguments[0] ? arguments[0] : "";
	var jumin = eval("this.match(/[0-9]{2}[01]{1}[0-9]{1}[0123]{1}[0-9]{1}" + arg + "[5678]{1}[0-9]{1}[02468]{1}[0-9]{2}[6789]{1}[0-9]{1}$/)");
	if(jumin === null) {
	    return false;
	} else {
		jumin = jumin.toString().num().toString();
	}	
	// 생년월일 체크
	var birthYY = (parseInt(jumin.charAt(6),10) == (5 || 6)) ? "19" : "20";
	birthYY += jumin.substr(0, 2);
	var birthMM = jumin.substr(2, 2) - 1;
	var birthDD = jumin.substr(4, 2);
	var birthDay = new Date(birthYY, birthMM, birthDD);
	if(birthDay.getYear() % 100 != jumin.substr(0,2) || birthDay.getMonth() != birthMM || birthDay.getDate() != birthDD) {
		return false;
	}
	if((parseInt(jumin.charAt(7),10) * 10 + parseInt(jumin.charAt(8),10)) % 2 !== 0) {
		return false;
	}	
	var sum = 0;
	var num = [2, 3, 4, 5, 6, 7, 8, 9, 2, 3, 4, 5];
	var last = parseInt(jumin.charAt(12),10);
	for(var i = 0; i < 12; i++) {
		sum += parseInt(jumin.charAt(i),10) * num[i];
	}
	return (((11 - sum % 11) % 10) + 2 == last) ? true : false;

};

/**
 * 사업자번호  체크 
 * @param {Object} arguments[0] : 등록번호 구분자
 * @return {boolean} 
 */	
String.prototype.isBizNum = function() {
	var arg = arguments[0] ? arguments[0] : "";
	var biznum = eval("this.match(/[0-9]{3}" + arg + "[0-9]{2}" + arg + "[0-9]{5}$/)");
	if(biznum === null) {
		return false;
	} else {
		biznum = biznum.toString().num().toString();
	}
	var sum = parseInt(biznum.charAt(0),10);
	var num = [0, 3, 7, 1, 3, 7, 1, 3];
	for(var i = 1; i < 8; i++) {sum += (parseInt(biznum.charAt(i),10) * num[i]) % 10;}
	sum += Math.floor(parseInt(parseInt(biznum.charAt(8),10),10) * 5 / 10);
	sum += (parseInt(biznum.charAt(8),10) * 5) % 10 + parseInt(biznum.charAt(9),10);
	return (sum % 10 === 0) ? true : false;
	
};


/**
 * 전화번호 체크 
 * @param {Object} arguments[0] : 전화번호 구분자 
 * @return {boolean} 
 */	
String.prototype.isPhone = function() {
	var arg = arguments[0] ? arguments[0] : "";
	return eval("(/(02|0[3-9]{1}[0-9]{1})" + arg + "[1-9]{1}[0-9]{2,3}" + arg + "[0-9]{4}$/).test(this)");
};

/**
 * 핸드폰번호 체크 
 * @param {Object} arguments[0] : 핸드폰 	구분자 
 * @return {boolean} 
 */	
String.prototype.isMobile = function() {
	var arg = arguments[0] ? arguments[0] : "";
	return eval("(/01[016789]" + arg + "[1-9]{1}[0-9]{2,3}" + arg + "[0-9]{4}$/).test(this)");
};

/**
 * 년도체크
 */	
String.prototype.isYear = function() {
	if(this.length == 4){
		return true;
	} else {
		return false;
	}
};

/**
 * 월체크
 */	
String.prototype.isMonth = function() {
	if((parseInt(this,10) >= 1 && parseInt(this,10) <= 12)){
		return true;
	} else {
		return false;
	}
};

/**
 * 부분적인 일체크
 */	
String.prototype.isDay = function() {
	if((parseInt(this,10) >= 1 && parseInt(this,10) <= 31)){
		return true;
	} else {
		return false;
	}
};

/**
 * 시간 체크
 */	
String.prototype.isHour = function() {
	if((parseInt(this,10) >= 0 && parseInt(this,10) <= 24)){
		return true;
	} else {
		return false;
	}
};

/**
 * 분 체크
 */	
String.prototype.isMinute= function() {
	if((parseInt(this,10) >= 0 && parseInt(this,10) <= 59)){
		return true;
	} else {
		return false;
	}
};

/**
 * 초 체크
 */	
String.prototype.isSecond= function() {
	if((parseInt(this,10) >= 0 && parseInt(this,10) <= 59)){
		return true;
	} else {
		return false;
	}
};



/**
 * 화면전체 이벤트
 */
/*by kimks
document.oncontextmenu = function () {
	//return false;	//마우스 오른쪽 버튼을 사용하지 못하게 한다.
	return true;	//마우스 오른쪽 버튼을 사용하게 한다.
};
*/
document.onkeypress = function(e){
	var intKeyCode = 0;
	var objElement = null;
	var strType = "";

	if(typeof(e) != SCConst.UNDEFINED){
		objElement = e.originalTarget; 
		intKeyCode = e.keyCode;
	} else {
		objElement =  window.event.srcElement;
		intKeyCode = window.event.keyCode;
	}
	
	strType = objElement.type;
	if(strType === "text"){
		var strAccess = objElement.accessKey;

		if(strAccess !== eval(SCConst.UNDEFINED)){
			var objArrayAccess= strAccess.split(SCConst.CHAR_SPLIT1);
			objArrayAccess = objArrayAccess[0].split(SCConst.CHAR_SPLIT4);
			switch(objArrayAccess[0]){
				case "DATE":
				case "MON":
					if((intKeyCode >= 48 && intKeyCode <= 57) || intKeyCode === 45){
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = true : "";
					} else {
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = false : e.preventDefault();
					}
					break;
				case "TIME":
				case "LONGTIME":
					if((intKeyCode >= 48 && intKeyCode <= 57) || intKeyCode === 58){
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = true : "";
					} else {
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = false : e.preventDefault();
					}
					break;
				case "NUM":
					if((intKeyCode >= 48 && intKeyCode <= 57)){
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = true : "";
					} else {
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = false : e.preventDefault();
					}
					break;
				case "DEC":
					if((intKeyCode >= 48 && intKeyCode <= 57) || intKeyCode === 45 || intKeyCode === 46){
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = true : "";
					} else {
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = false : e.preventDefault();
					}
					break;
				case "INT":
					if((intKeyCode >= 48 && intKeyCode <= 57) || intKeyCode === 45){
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = true : "";
					} else {
						typeof(e) === SCConst.UNDEFINED ? window.event.returnValue = false : e.preventDefault();
					}
					break;
			}	
		}
	}

};


document.onkeyup = function(e){

	var objElement = null;
	var intKeyCode = 0;
	if(typeof(e) != SCConst.UNDEFINED){
		objElement = e.originalTarget; 
		intKeyCode = e.keyCode;
	} else {
		objElement =  window.event.srcElement;
		intKeyCode = window.event.keyCode;
	}

	//document.title = "KEYCOD" + intKeyCode;
	
	//Enter를 칠 경우 자동으로 호출할 함수 처리
	if(intKeyCode == 13){
		for (var i=0; i < SCConst.ENTER_OBJ_NAME.size(); i++){
			if(SCConst.ENTER_OBJ_NAME[i] === objElement.id){
				eval(SCConst.ENTER_CALL_FUNC[i]);
			}
		}
	}


	//if(intKeyCode == 8){return;}							//의미없는 KeyPress제외[BackSpace,]
	if(intKeyCode == 9){return;}							//의미없는 KeyPress제외[TAB,]
	if(intKeyCode == 13){return;}							//의미없는 KeyPress제외[Enter,]
	if(intKeyCode >= 16 && intKeyCode <= 19){return;}		//의미없는 KeyPress제외[Shift,Ctrl,Alt,PauseBreak]
	if(intKeyCode == 20){return;}							//의미없는 KeyPress제외[CapsLock,]
	if(intKeyCode == 27){return;}							//의미없는 KeyPress제외[Esc,]
	if(intKeyCode == 32){return;}							//의미없는 KeyPress제외[Space,]
	if(intKeyCode >= 37 && intKeyCode <= 40){return;}		//의미없는 KeyPress제외[방향키]
	if(intKeyCode == 91){return;}							//의미없는 KeyPress제외[Window메뉴,]
	if(intKeyCode >= 112 && intKeyCode <= 122){return;}	//의미없는 KeyPress제외[기능키]
	if(intKeyCode >= 144 && intKeyCode <= 145){return;}	//의미없는 KeyPress제외[NumLock,ScrollLock,]

	if(objElement.tagName.toUpperCase() === "INPUT" || objElement.tagName.toUpperCase() === "TEXTAREA"){
		//데이터포멧
		var objArrayAccess = objElement.accessKey.split(SCConst.CHAR_SPLIT1);
		if(objArrayAccess[0] === "NUM" || objArrayAccess[0] === "INT" || objArrayAccess[0] === "DEC"){
			//SCDataControl.setDataFormat(objElement, objArrayAccess[0]); 
		}
	}

	//해당 엘리멘트에서 포커스가 빠져 나갈때 처리
	//objElement.onchange = function(e){
	objElement.onblur = function(e){
		//전체 포멧설정
		if(objArrayAccess !== null && typeof(objArrayAccess) !== SCConst.UNDEFINED){
			if(SCDataControl.checkDataFormat(objElement, objArrayAccess[0])){
				//데이터포멧
				SCDataControl.setDataFormat(objElement, objArrayAccess[0]); 
				//데이터변경
				SCDataControl.dataChanged('', objElement);
			} else {
				//objElement.value = "";
			}
		}
	};
};




document.onclick = function(e){
	var objElement = null;
	if(typeof(e) != SCConst.UNDEFINED){
		objElement = e.originalTarget; 
	} else {
		objElement =  window.event.srcElement;
	}

	//라디오, 체크박스일 경우 자동 업데이트 처리
	if(objElement.type === "radio" || objElement.type === "checkbox"){
		//데이터변경
		SCDataControl.dataChanged('', objElement);
	}
	
};

/**
 * SCCalendar
 */
/* 
'****************************************************************************************
'시스템구분 		: 	synergyweb
'실행  환경  		: 	Java Script 
'프로그램명 		: 	SCCalendarPop.js
'기      능     	: 	Calendar 처리 스크립트.
'파라  메터  		: 	현재일자
'----------------------------------------------------------------------------------------
'HISTORY    		:	1)Bazillyo's Spiffy DHTML Popup Calendar v. 1.0
'		    		:	2)2003/04/15 By KimKS = Popup용으로 변경
'		    		:	3)2006/02/28 By LeeHJ = 디자인변경
'		    		:	4)2008/02/09 By LeeYH = Layer로 변경
'****************************************************************************************
*/
 
// initialize variables... 
var ppcIE=((navigator.appName == "Microsoft Internet Explorer") || ((navigator.appName == "Netscape") && (parseInt(navigator.appVersion,10)==5)));
var ppcNN6=((navigator.appName == "Netscape") && (parseInt(navigator.appVersion,10)==5));
//var ppcIE=(navigator.appName == "Microsoft Internet Explorer");
var ppcNN=((navigator.appName == "Netscape")&&(document.layers));
var ppcX = 4;
var ppcY = 4;
 
var IsCalendarVisible;
var calfrmName;
var maxYearList;
var minYearList;
var todayDate = new Date; 
var curDate = new Date; 
var curImg;
var curDateBox;
var minDate = new Date;
var maxDate = new Date;
var hideDropDowns;
var IsUsingMinMax;
var FuncsToRun;		//일자변경시 호출함수
var FuncsToRun_T;		//시간변경시 호출함수
var img_del;
var img_close;



img_del=new Image();
//img_del.src=gRootWebContents + "/images/CalDelSmall.gif";
img_close=new Image();
//img_close.src=gRootWebContents + "/ework/images/CalCloseSmall.gif";

minYearList=todayDate.getFullYear()-40;
maxYearList=todayDate.getFullYear()+10;
IsCalendarVisible=false;

function calSwapImg(whatID, NewImg,override) {
    if (document.images) {
     if (!( IsCalendarVisible && override )) {
        document.images[whatID].src = eval(NewImg + ".src");
     }
    }
    window.status=' ';
    return true;
}

function getOffsetLeft (el) {
    var ol = el.offsetLeft;
    while ((el = el.offsetParent) != null)
        ol += el.offsetLeft;
    return ol;
}

function getOffsetTop (el) {
    var ot = el.offsetTop;
    while((el = el.offsetParent) != null)
        ot += el.offsetTop;
    return ot;
}

function showCalendar(frmName, dteBox,btnImg, runFuncs,hideDrops, MnDt, MnMo, MnYr, MxDt, MxMo, MxYr) {
	hideDropDowns = hideDrops;
    FuncsToRun = runFuncs;
    calfrmName = frmName;
	var strTempMonth = "";
	var strTempYear = "";

    if (IsCalendarVisible) {
        hideCalendar();
    }
    else {
        if (document.images['calbtn1']!=null ) document.images['calbtn1'].src=img_del.src;
        if (document.images['calbtn2']!=null ) document.images['calbtn2'].src=img_close.src;
        
        if (hideDropDowns) {toggleDropDowns('hidden');}
        if ((MnDt!=null) && (MnMo!=null) && (MnYr!=null) && (MxDt!=null) && (MxMo!=null) && (MxYr!=null)) {
            IsUsingMinMax = true;
            minDate.setDate(MnDt);
            minDate.setMonth(MnMo-1);
            minDate.setFullYear(MnYr);
            maxDate.setDate(MxDt);
            maxDate.setMonth(MxMo-1);
            maxDate.setFullYear(MxYr);
        }
        else {
            IsUsingMinMax = false;
        }
        
        curImg = btnImg;
        curDateBox = dteBox;
        if ( ppcIE ) { 
            ppcX = getOffsetLeft(document.images[btnImg]);    
            ppcY = getOffsetTop(document.images[btnImg]) + document.images[btnImg].height;
        }
        else if (ppcNN){
            ppcX = document.images[btnImg].x; 
            ppcY = document.images[btnImg].y + document.images[btnImg].height;
        }
		
		if($(dteBox).value) {
			strTempYear = $(dteBox).value.substring(0,4);
			strTempMonth = $(dteBox).value.substring(5,7) - 1;
		}
		
		if(strTempYear)
			domlay('PopupCalendar',1,ppcX,ppcY,Calendar(strTempMonth,strTempYear));
		else 
        	domlay('PopupCalendar',1,ppcX,ppcY,Calendar(todayDate.getMonth(),todayDate.getFullYear()));       

        //domlay('PopupCalendar',1,ppcX,ppcY,Calendar(curDate.getMonth(),curDate.getFullYear()));

        IsCalendarVisible = true;
    }
}

function toggleDropDowns(showHow){
    var i; var j;
    for (i=0;i<document.forms.length;i++) {
        for (j=0;j<document.forms[i].elements.length;j++) {
            if (document.forms[i].elements[j].tagName == "SELECT") {
                if (document.forms[i].name != "Cal")
                    document.forms[i].elements[j].style.visibility=showHow;
            }
        }
    }
}

function hideCalendar(){
    domlay('PopupCalendar',0,ppcX,ppcY);
    //calSwapImg(curImg, 'img_Date_UP');    
    IsCalendarVisible = false;
    if (hideDropDowns) {toggleDropDowns('visible');}
}

function calClick() {
        window.focus();
}

function domlay(id,trigger,lax,lay,content) {
    // Layer visible
    if (trigger=="1"){
		if (document.layers) {document.layers[''+id+''].display = "block";}
        else if (document.all) {document.all[''+id+''].style.display="block";}
        else if (document.getElementById) {document.getElementById(''+id+'').style.display = "block";}
        }
    // Layer hidden
    else if (trigger=="0"){
        if (document.layers) document.layers[''+id+''].display = "none"
        else if (document.all) document.all[''+id+''].style.display = "none"
        else if (document.getElementById) document.getElementById(''+id+'').style.display = "none"             
        }
    // Set horizontal position  
    if (lax){
        if (document.layers){document.layers[''+id+''].left = lax}
        else if (document.all){document.all[''+id+''].style.left=lax}
        else if (document.getElementById){document.getElementById(''+id+'').style.left=lax+"px"}
        }
    // Set vertical position
    if (lay){
        if (document.layers){document.layers[''+id+''].top = lay}
        else if (document.all){document.all[''+id+''].style.top=lay}
        else if (document.getElementById){document.getElementById(''+id+'').style.top=lay+"px"}
        }
    // change content
    if (content){
    if (document.layers){
        sprite=document.layers[''+id+''].document;
        // add father layers if needed! document.layers[''+father+'']...
        sprite.open();
        sprite.write(content);
        sprite.close();
        }
    else if (document.all) {document.all[''+id+''].innerHTML = content; }
    else if (document.getElementById){
        //Thanx Reyn!
        rng = document.createRange();
        el = document.getElementById(''+id+'');
        rng.setStartBefore(el);
        htmlFrag = rng.createContextualFragment(content)
        while(el.hasChildNodes()) el.removeChild(el.lastChild);
        el.appendChild(htmlFrag);
        // end of Reyn ;)
        }
    }
}

function Calendar(whatMonth,whatYear) {
    var output = '';
    var datecolwidth;
    var startMonth;
    var startYear;

    startMonth=whatMonth;
    startYear=whatYear;
    curDate.setMonth(whatMonth);
    curDate.setFullYear(whatYear);
    curDate.setDate(todayDate.getDate());
    if (ppcNN6) {
        output += '<form name="Cal"><table width="213" height="194" border="0" class="cal-Table" cellspacing="0" cellpadding="0">';
    }
    else {
        output += '<table width="213" height="194" border="0" class="cal-Table" cellspacing="0" cellpadding="0"><form name="Cal">';
    }
    
    output += '<tr><td valign="top" class="cal-HeadCell" align="center" background="' + gRootWebContents + '/images/CalBG.gif"><table width="213" border="0" cellspacing="1" cellpadding="0"><tr><td height="16" colspan="3" align="right"><a href="javascript:clearDay();" class="cal-DayLink"><img src="' + gRootWebContents + '/images/imgClubMinus.gif" border="0"> </a></td></tr>';
    output += '<tr><td width="39" height="29" align="right"><a href="javascript:scrollMonth(-1);"  class="cal-DayLink"><img src="' + gRootWebContents + '/images/imgCalLeft.gif" border="0"></a></td><td width="135" align="center">';
    output += '<SELECT class="cal-TextBox" NAME="cboYear" onChange="changeYear();">';

    for (year=minYearList; year<maxYearList; year++) {
        if (year == whatYear) output += '<OPTION VALUE="' + year + '" SELECTED>' + year + '<\/OPTION>';
        else              output += '<OPTION VALUE="' + year + '">'          + year + '<\/OPTION>';
    }
    
    output += '</SELECT>&nbsp;';
    output += '<SELECT class="cal-TextBox" NAME="cboMonth" onChange="changeMonth();">';
    for (month=0; month<12; month++) {
        if (month == whatMonth) output += '<OPTION VALUE="' + month + '" SELECTED>' + names[month] + '<\/OPTION>';
        else                output += '<OPTION VALUE="' + month + '">'          + names[month] + '<\/OPTION>';
    }

    
    output += '</SELECT></td><td width="39"><a href="javascript:scrollMonth(1);"  class="cal-DayLink"><img src="' + gRootWebContents + '/images/imgCalRight.gif" border="0"></a></td></tr><tr><td height="6" colspan="3"></td></tr>';

    firstDay = new Date(whatYear,whatMonth,1);
    startDay = firstDay.getDay();

    if (((whatYear % 4 == 0) && (whatYear % 100 != 0)) || (whatYear % 400 == 0))
         days[1] = 29;
    else
         days[1] = 28;

    output += '<tr><td colspan="3" align="center"><table width="185" border="0" cellpadding="0" cellspacing="1" bgcolor="CACACA"><tr align="center" bgcolor="#E7E7E7">';

    for (i=0; i<7; i++) {
        if (i==0) {
            datecolwidth="15%"
            output += '<td class="cal-HeadCellBrown" width="' + datecolwidth + '" align="center" valign="middle">'+ dow[i] +'<\/td>';
        }
        else
        {
            datecolwidth="14%"
            output += '<td class="cal-HeadCellBlue" width="' + datecolwidth + '" align="center" valign="middle">'+ dow[i] +'<\/td>';
        }
    }
    
    output += '</tr><tr class="cal-Date">';

    var column = 0; weekcnt =0;
    var isSunday = false;
    var lastMonth = whatMonth - 1;
    var lastYear = whatYear;
    if (lastMonth == -1) { lastMonth = 11; lastYear=lastYear-1;}

    for (i=0; i<startDay; i++, column++) {
        output += getDayLink((days[lastMonth]-startDay+i+1),true,lastMonth,lastYear, false);
    }

    for (i=1; i<=days[whatMonth]; i++, column++) {
    	//일요일 여부
    	if (column == 0) isSunday = true;
    	else isSunday = false;
    	output += getDayLink(i,false,whatMonth,whatYear, isSunday);
    	if (column == 6) {
            output += '</tr><tr class="cal-Date">';
            column = -1; weekcnt += 1;
        }
    }
    
    var nextMonth = whatMonth+1;
    var nextYear = whatYear;
    if (nextMonth==12) { nextMonth=0; nextYear=nextYear+1;}

    //나머지 부분을 채운다.     
    i=1;
    if (column > 0) {
    	//alert("1=" + column + "," + weekcnt);
        for (; column<7; i++, column++) {
            output +=  getDayLink(i,true,nextMonth,nextYear, false);
        }
        weekcnt += 1;
        output += '</tr><tr>';
    }
    //popup창 크기에 맞게 1주를 더 생성한다.
     if (weekcnt < 6) {
         column = -1;
	 for (; column<6; i++, column++) {
		output +=  getDayLink(i,true,nextMonth,nextYear, false);
	 }
         output += '</tr><tr>';
    }
    output = output.substr(0,output.length-4); // remove the <tr> from the end if there's no last row
    output += '</table></td></tr>';
    
    if (ppcNN6) {
        output += '</table></form>';
    }
    else {
        output += '</form></table>';
    }
    curDate.setDate(1);
    curDate.setMonth(startMonth);
    curDate.setFullYear(startYear);

    return output;
}

function getDayLink(linkDay,isGreyDate,linkMonth,linkYear,isSunday) {
    var templink;
    if (!(IsUsingMinMax)) {
        if (isGreyDate) {
            templink='<td align="center" class="cal-GreyDate">' + linkDay + '</td>';
        }
        else if (isSunday) {
        	templink='<td align="center" class="cal-DayCellOrange">' + '<a class="cal-SunDayLink" onmouseover="self.status=\' \';return true" href="javascript:changeDay(' + linkDay + ');">' + linkDay + '<\/a>' +'<\/td>';
        }
        else { //By KimKS for Popup
            if (isDayToday(linkDay)) {
                templink='<td align="center" class="cal-DayCellToday">' + '<a class="cal-TodayLink" onmouseover="self.status=\' \';return true" href="javascript:changeDay(' + linkDay + ');">' + linkDay + '<\/a>' +'<\/td>';
            }
            else {
                templink='<td align="center" class="cal-DayCell">' + '<a class="cal-DayLink" onmouseover="self.status=\' \';return true" href="javascript:changeDay(' + linkDay + ');">' + linkDay + '<\/a>' +'<\/td>';
            }
        }
    }
    else {
        if (isDayValid(linkDay,linkMonth,linkYear)) {

            if (isGreyDate){
                templink='<td align="center" class="cal-GreyDate">' + linkDay + '</td>';
            }
            else if (isSunday) {
            	templink='<td align="center" class="cal-DayCellOrange">' + '<a class="cal-SunDayLink" onmouseover="self.status=\' \';return true" href="javascript:changeDay(' + linkDay + ');" >' + linkDay + '<\/a>' +'<\/td>';
            }
            else {
                if (isDayToday(linkDay)) { //By KimKS for Popup
                    templink='<td align="center" class="cal-DayCell">' + '<a class="cal-TodayLink" onmouseover="self.status=\' \';return true" href="javascript:changeDay(' + linkDay + ');" >' + linkDay + '<\/a>' +'<\/td>';
                }
                else {
                    templink='<td align="center" class="cal-DayCell">' + '<a class="cal-DayLink" onmouseover="self.status=\' \';return true" href="javascript:changeDay(' + linkDay + ');">' + linkDay + '<\/a>' +'<\/td>';
                }
            }
        }
        else {
            templink='<td align="center" class="cal-GreyInvalidDate">'+ linkDay + '<\/td>';
        }
    }
    return templink;
}

function isDayToday(isDay) {
    if ((curDate.getFullYear() == todayDate.getFullYear()) && (curDate.getMonth() == todayDate.getMonth()) && (isDay == todayDate.getDate())) {
        return true;
    }
    else {
        return false;
    }
}

function isDayValid(validDay, validMonth, validYear){
    
    curDate.setDate(validDay);
    curDate.setMonth(validMonth);
    curDate.setFullYear(validYear);
    
    if ((curDate>=minDate) && (curDate<=maxDate)) {
        return true;
    }
    else {
        return false;
    }
}

function padout(number) { return (number < 10) ? '0' + number : number; }

function clearDay() {
	//By KimKS for Popup - Clear기능을 취소기능으로 변경
	//if (calfrmName != null)
	//	eval(calfrmName + '.' + curDateBox + '.value = \'\'');
	//else
	//	eval(curDateBox + '.value = \'\'');
		
    hideCalendar();

    //if (FuncsToRun !== null || FuncsToRun === ""){eval(FuncsToRun);}
}

function changeDay(whatDay) {
    curDate.setDate(whatDay);
    //by Kimks year-mon-day
    
    if (calfrmName != null)
    	//By KimKS for Popup --> document가 적용 안됨
		//eval('document.' + calfrmName + '.' + curDateBox + '.value = "'+ curDate.getFullYear() + '-' + names[curDate.getMonth()] + '-' + padout(curDate.getDate()) + '"');
    	eval(calfrmName + '.' + curDateBox + '.value = "'+ curDate.getFullYear() + '-' + names[curDate.getMonth()] + '-' + padout(curDate.getDate()) + '"');
    else
		eval(curDateBox + '.value = "'+ curDate.getFullYear() + '-' + names[curDate.getMonth()] + '-' + padout(curDate.getDate()) + '"');

    if (FuncsToRun !== null || FuncsToRun === ""){eval(FuncsToRun);}

    hideCalendar();

}

function scrollMonth(amount) {
    var monthCheck;
    var yearCheck;
    
    if (ppcIE) {
        monthCheck = document.forms["Cal"].cboMonth.selectedIndex + amount;
    }
    else if (ppcNN) {
        monthCheck = document.PopupCalendar.document.forms["Cal"].cboMonth.selectedIndex + amount;    
    }
    if (monthCheck < 0) {
        yearCheck = curDate.getFullYear() - 1;
        if ( yearCheck < minYearList ) {
            yearCheck = minYearList;
            monthCheck = 0;
        }
        else {
            monthCheck = 11;
        }
        curDate.setFullYear(yearCheck);
    }
    else if (monthCheck >11) {
        yearCheck = curDate.getFullYear() + 1;
        if ( yearCheck > maxYearList-1 ) {
            yearCheck = maxYearList-1;
            monthCheck = 11;
        }
        else {
            monthCheck = 0;
        }      
        curDate.setFullYear(yearCheck);
    }
    
    if (ppcIE) {
        curDate.setMonth(document.forms["Cal"].cboMonth.options[monthCheck].value);
    }
    else if (ppcNN) {
        curDate.setMonth(document.PopupCalendar.document.forms["Cal"].cboMonth.options[monthCheck].value );
    }
    domlay('PopupCalendar',1,ppcX,ppcY,Calendar(curDate.getMonth(),curDate.getFullYear()));
}

function changeMonth() {

    if (ppcIE) {        
        curDate.setMonth(document.forms["Cal"].cboMonth.options[document.forms["Cal"].cboMonth.selectedIndex].value);
        domlay('PopupCalendar',1,ppcX,ppcY,Calendar(curDate.getMonth(),curDate.getFullYear()));
    }
    else if (ppcNN) {

        curDate.setMonth(document.PopupCalendar.document.forms["Cal"].cboMonth.options[document.PopupCalendar.document.forms["Cal"].cboMonth.selectedIndex].value);
        domlay('PopupCalendar',1,ppcX,ppcY,Calendar(curDate.getMonth(),curDate.getFullYear()));
    }

}

function changeYear() {
    if (ppcIE) {

        curDate.setFullYear(document.forms["Cal"].cboYear.options[document.forms["Cal"].cboYear.selectedIndex].value);
        domlay('PopupCalendar',1,ppcX,ppcY,Calendar(curDate.getMonth(),curDate.getFullYear()));
    }
    else if (ppcNN) {

        curDate.setFullYear(document.PopupCalendar.document.forms["Cal"].cboYear.options[document.PopupCalendar.document.forms["Cal"].cboYear.selectedIndex].value);
        domlay('PopupCalendar',1,ppcX,ppcY,Calendar(curDate.getMonth(),curDate.getFullYear()));
    }

}

function makeArray0() {
    for (i = 0; i<makeArray0.arguments.length; i++)
        this[i] = makeArray0.arguments[i];
}

//var names     = new makeArray0('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec');
var names     = new makeArray0('01','02','03','04','05','06','07','08','09','10','11','12');
var days      = new makeArray0(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
var dow       = new makeArray0('일','월','화','수','목','금','토');




function showClock(frmName, dteBox,btnImg, runFuncs,hideDrops) {
	hideDropDowns = hideDrops;
    FuncsToRun_T = runFuncs;
    calfrmName = frmName;
	var strTempHour = "";
	
    if (IsCalendarVisible) {
        hideCalendar();
    }
    else {
        if (hideDropDowns) {toggleDropDowns('hidden');}
        
        curImg = btnImg;
        curDateBox = dteBox;
        if ( ppcIE ) { 
            ppcX = getOffsetLeft(document.images[btnImg]);    
            ppcY = getOffsetTop(document.images[btnImg]) + document.images[btnImg].height;
        }
        else if (ppcNN){
            ppcX = document.images[btnImg].x; 
            ppcY = document.images[btnImg].y + document.images[btnImg].height;
        }
		
		if($(dteBox).value)
			strTempHour = ($(dteBox).value.substring(0,2));
		
        domlay('PopupCalendar',1,ppcX,ppcY,Clock(strTempHour));       
        IsCalendarVisible = true;
    }
}


function Clock(tempHour) {
	var output = "";
	
	if(ppcNN6) {		output += '<form name="Cal"><table border="0" class="cal-Table" cellspacing="0" cellpadding="0">'; }
	else {				output += '<table width="210px" border="0" class="cal-Table" cellspacing="0" cellpadding="0"><form name="Cal">'; }
    output += '<tr><td valign="top" class="cal-HeadCell" align="center" background="' + gRootWebContents + '/images/CalBG.gif"><table width="210px" border="0" cellspacing="1" cellpadding="0"><tr><td height="16" colspan="3" align="right"><a href="javascript:clearDay();"  class="cal-DayLink"><img src="' + gRootWebContents + '/images/imgClubMinus.gif" border="0"></a></td></tr>';
	output += '<tr><td  align="center"><table style="margin:0 auto;" border="0" ><tr>';
	
	// 입력 폼: 시(hour)
	output += '<td>&nbsp;&nbsp;<select name="cmbHour" id="cmbHour" style="font-size:12px">';
		
	for(hour=0; hour<24; hour++) {
		if(hour<10) {
			if(tempHour == hour)	
				output += '<option value="0' + hour + '" selected>0' + hour + '</option>';
			else
			 	output += '<option value="0' + hour + '">0' + hour + '</option>';
		}
		else {
			if(tempHour == hour)	
				output += '<option value="' + hour + '" selected>' + hour + '</option>';
			else 
				output += '<option value="' + hour + '">' + hour + '</option>';
		}
	}
	output += '</select></td>';
	output += '<td><table>';
	output += '<tr><td style="text-align:left;font-size:5pt;">&nbsp;<img onclick="javascript:scrollHour(-1);" src="' + gRootWebContents + '/images/btn03InputUp.gif" alt="위로" style="cursor: pointer;" /></td></tr>';
	output += '<tr><td style="text-align:left;font-size:5pt;">&nbsp;<img onclick="javascript:scrollHour(1);" src="' + gRootWebContents + '/images/btn03InputDown.gif" alt="아래로" style="cursor: pointer;" /></td></tr>';
	output += '</table></td><td style="text-align:center;font-size: 12px;">&nbsp;시&nbsp;</td>';
	
	// 입력 폼: 분(minute)
	output += '<td><select name="cmbMinute" id="cmbMinute"  style="font-size:12px">';
	for(min=0; min<60; min = min + 5 ) {
		if(min<10) {		output += '<option value="0' + min + '">0' + min + '</option>'; }
		else {				output += '<option value="' + min + '">' + min +'</option>'; }
	}
	output += '</select></td>';
	output += '<td><table>';
	output += '<tr><td style="text-align:left;font-size:5pt;">&nbsp;<img onclick="javascript:scrollMin(-10);"src="' + gRootWebContents + '/images/btn03InputUp.gif" alt="위로" style="cursor: pointer;" /></td></tr>';
	output += '<tr><td style="text-align:left;font-size:5pt;">&nbsp;<img onclick="javascript:scrollMin(10);"src="' + gRootWebContents + '/images/btn03InputDown.gif" alt="아래로" style="cursor: pointer;" /></td></tr>';
	output += '</table></td><td style="text-align:center;font-size: 12px;">&nbsp;분&nbsp;</td>';
	output += '</tr>';
	
	// 입력 폼: 처리버튼
	output += '<tr height="40"><td colspan="6" style="text-align:center;">';
	output += '<a class="cal-DayLink" href="javascript:changeTime();" ><img src="' + gRootWebContents + '/images/btn02Confirm.gif" alt="확인" style="cursor: pointer;" /></a>&nbsp;';
	output += '<a class="cal-DayLink" href="javascript:hideCalendar();" ><img src="' + gRootWebContents + '/images/btn01Cancel.gif" alt="취소" style="cursor: pointer;" /></a>';
	output += '</td>';
	
	output += '</tr></table></td></tr>';
    if (ppcNN6) {	output += '</table></form>'; }
    else {				output += '</form></table>'; }
    return output;
}

function changeTime() {
	var strTime = $("cmbHour").value + ":" + $("cmbMinute").value;
	if(calfrmName != null) {
		eval(calfrmName + '.' + curDateBox + '.value = "' + strTime + '"');
	}
	else {
		eval(curDateBox + '.value = "' + strTime + '"');
	}
	if (FuncsToRun_T !== null || FuncsToRun_T === ""){eval(FuncsToRun_T);}
	hideCalendar();
}

function scrollHour(amount) {
	var strHour = $("cmbHour").value*1 + amount;
	if(strHour<0) strHour = 23;
	if(strHour==0) strHour = 00;
	if(strHour==25) strHour = 1;
	if(strHour<10) strHour = "0" + strHour;
	$("cmbHour").value = strHour;
}

function scrollMin(amount) {
	var strMin = $("cmbMinute").value*1 + amount;
	if(strMin==-10) strMin = 50;
	if(strMin==60) strMin = 0;
	if(strMin<10) strMin = "0" + strMin;
	$("cmbMinute").value = strMin;
}