XinYu_RZMES/WebContents/js/boaCommon.js

//var host =window.document.url;
//var url = host.substring(0,host.lastIndexOf("/"))+"/";

//var url = "http://localhost:8088/xgmes3/";
//var url = "http://172.16.0.172:8040/";
var url = "http://10.10.0.10:8040/";
//var url = "http://172.16.0.126:8040/xgmes3/";
//http://10.10.0.10:8040/

/***************************************************************************************************************/    
/* 1. Setup Global variable & Event 글로벌 변수/ 이벤트 관련 설정 
/***************************************************************************************************************/    		

/* Setup Grid-Cell Style(Adding Grid, Deleting Grid, Initailizing Gird) : 그리드 셀 스타일 설정(그리드 추가, 그리드 삭제시, 그리드 초기화  */
var insertRowStyle = "#FEFFCA";
var deleteRowStyle = "#FFEFE4";
var initCellStyle  = "#FFFFFF";

function xforms_submit() {    }

/*
*  서브미션 종료후 이벤트 처리(error 및 msg 처리)
*
*/
function xforms_submit_done(){
	body.disabled = false;
	if ( event.currentTarget != event.target ) return;
    commMsgBox();
}

/***************************************************************************************************************/
/* 2. TF관련 공통함수 (공통개발)
/*
/* 1)  commSubmit  		 : 서브미션 실행
/* 2)  commSendReq 		 : "/root/reqData"에 노드값을 복사
/* 3)  commCombo   		 : 공통코드 콤보값 호출
/* 4)  commAddFile 		 : 파일추가 (작업중)
/* 5)  commModifyFile  : 파일수정(작업중)
/* 6)  commDelFile 		 : 파일삭제 (작업중)
/* 7)  commDownLoad    : 파일다운로드
/* 8)  commFwdPopClose : 팝업창을 닫으면서 부모창에 노드값을 넘겨준다
/* 9)  commMsgCall     : 화면의 하단바에 메시지 생성(작업중)
/* 10) commAppendData  : 파일복사기능
/* 11) commMultiUpdate : 그리드 멀티업데이트 시 상태값에 따라 노드생성
/* 12) commDetailView  : 그리드 - 폼방식 화면 상세보기
/* 13) commFormSet:	   : 폼 - 폼 같은 인스턴스노드 복사
/* 14) commGroupInit   : 그룹안 컨트롤 값 초기화(삭제)
/* 15) commComfirmBox  : 확인경고창
/* 16) commGridInit    : 그리드 셀 스타일 초기화
/* 17) commAddRow      : 그리드 행 추가
/* 18) commDelRow      : 그리드 행 삭제
/* 19) commPagingList  : 그리드 페이지 처리(관련함수: goPage(),제약조건 그리드 조회시 total 값과 size값을 가져와야함)  
/* 20) commMsgBox      : 메시지 알림창호출
/* 21) commReqCheck    : 필수입력확인
/*****************************************************************************************************************/					


/**
* @function : commSubmit
* @param submitID, serviceTag, action, refresh,type 
* @return 
* @wirter : 
* @write date : 
* @modify datae : 07.08.13
* @description 서브미션 실행
*              submitID 		: 서브미션ID, 글루서비스아이디
*              serviceTag		: 글루 서비스 테그
* 			   action			: url 
			   [refresh]        : 서브미션이후의 refresh 여부 default 값 true
			   [type]           : 서브미션 타입지정 파일업로드시 'file' 적용 default post 
*/

function commSubmit(submitID, serviceTag, action, refresh, type) {
	body.disabled = true;
	var mediatype = "";
	if(!body.isChild(submitID)) {
		model.createChild("xforms:submission", "id:" + submitID + ";"); //서브미션 동적으로 생성
	}

	if(refresh == "" || refresh == null) {
		refresh = true;	
	} else if (refresh == 'file') {
		mediatype = "file";
		refresh = true;	
	}

	if(type == "" || type == null)  type = mediatype;

	if(type == "file") {
		document.all(submitID).attribute("method") = "form-data-post";
		document.all(submitID).attribute("mediatype") = "multipart/form-data";
	} else  {
		document.all(submitID).attribute("method") = "post";
		document.all(submitID).attribute("mediatype") = "application/x-www-form-urlencoded";
	}

	model.makeValue("/root/reqData/" + serviceTag, "1");
	model.makeValue("/root/reqData/ServiceName", submitID);				

	document.all(submitID).attribute("ref") = "/root/reqData";
	document.all(submitID).attribute("resultref") = "/root/resData";	
	document.all(submitID).attribute("action") = url + action;
	document.all(submitID).attribute("encoding") = "utf-8";

	model.send(submitID, refresh);		
}
		
/**
* @function : commSendReq
* @param arguments
* @return 
* @wirter : 
* @write date : 
* @modify datae : 07.08.13
* @description "/root/reqData에 노드값을 복사한다" 
*              arguments        : 서비스에 담을 노드값
*/		
function commSendReq() 		{
	try {
		var length = arguments.length;

		model.removeNodeset("/root/reqData");
		model.makeNode("/root/reqData");

		for(var j = 0; j < length; j++) {
			var srcref = arguments[j];
			var dup_node = instance1.selectSingleNode(srcref); //두번째로 보내고 싶은 노드를 선택
			var dup_nodeList = dup_node.childNodes; //그 노드의 하위노드를 읽음
			var cnt = 1;
			for (var i = 0; i < dup_nodeList.length; i++) {
				var copy_node = srcref + "/" + dup_nodeList.item(i).nodeName; //하위노드의 인스턴스를 읽어서 노드 조합
				var nodeSetYn =  instance1.selectNodes(copy_node);
				if(nodeSetYn.length>1) {
					model.duplicate("/root/reqData", copy_node + "[" + cnt + "]"); // 노드셑인경우 같은 노드이름의 인덱스값으로 찾아서 복사한다
					cnt++;
				} else {
					model.duplicate("/root/reqData", copy_node); 
				}	
			}
		}
	} catch (e) {
		model.alert("Error", "해당노드의 선택이 잘못되었습니다");
		return false;
	}
}	
/**
* @function : commCombo
* @param arguments
* @return 
* @wirter : 
* @write date : 
* @modify datae : 07.08.13
* @description 공통콤보 호출("코드값"+[|A: 전체 |S : 선택  | 없으면 기냥])
*             commCombo("A001|A","A002|S","B002");
*/	
function commCombo() {
											
	var argCnt = arguments.length;
	for(i=0; i<argCnt ; i++) {
		var comboNode =""	
			
			if(arguments[i].indexOf("|")!=-1) {
			
			comboNode =arguments[i].substr(0,arguments[i].indexOf("|"));
		
			} else {
			
			comboNode =arguments[i]; 
			
			}
		
			model.makeValue("/root/reqData/commCombo["+(i+1)+"]",comboNode);
			model.makeNode("/root/codeData/"+comboNode+"_VO");	
		
	}

	commSubmit("comm-service","combo","glueAction.do"); 

	for(i=0; i<argCnt ; i++) {
	
	var comboNode =""		
			if(arguments[i].indexOf("|")!=-1) {
	
				comboNode =arguments[i].substr(0,arguments[i].indexOf("|"));
				commAppendData("/root/codeData/"+comboNode+"_VO","/root/resData/"+comboNode+"_VO");	
				var label =""
				if(arguments[i].indexOf("|A")!=-1 || arguments[i].indexOf("|a")!=-1) {
				
					label = "=전체=";
				} else if(arguments[i].indexOf("|S")!=-1 || arguments[i].indexOf("|s")!=-1) {
				
					label = "=선택=";
				} else {
				
					label ="=전체=";
				}	
				
					model.makeValue("/root/temp/"+comboNode+"_Row/COMM_DETL_CDNM",label);	
				model.makeValue("/root/temp/"+comboNode+"_Row/COMM_DETL_CD","");
				model.duplicate("/root/codeData/"+comboNode+"_VO","/root/temp/"+comboNode+"_Row","*[1]");
				model.removenode("/root/temp"); 	
											
			}else {	comboNode =arguments[i]; 
			
				commAppendData("/root/codeData/"+comboNode+"_VO","/root/resData/"+comboNode+"_VO");
				
			}							
		
	}

model.refresh();		

}

/**
* @param : commAddFile[파일업로드이름], fileGridName[파일그리드]
* @return 
* @wirter : 
* @write date : 2007-07-20
* @description : 파일 선택해서 파일 그리드에 추가한다. 데이타가 넘어가는건 아님
* 				
*/
    function commAddFile(fileUploadName, fileGridName ){
       
        var files = window.fileDialog("open", "|", true);

        var filelist = files.split("|");
        var numberOfFiles = filelist.length;
        
        if (numberOfFiles != 0 && filelist[0] != "") {
            for(var i = 0 ; i < filelist.length ; i++ ) {
              //  model.makeNode("/root/fileData/fileGrid[" + (fileGridName.rows + i) + "]/attach_file_name");
                model.makeValue("/root/fileData/fileGrid[" + (fileGridName.rows + i) + "]/attach_file_name", filelist[i]);
//                alert("File Size : " + fileUploadName.getFileSize(i));
            }
        }

       fileGridName.refresh();

        // 'upload' 버튼을 눌러 실제 업로드를 수행하기 이전에 upload1.revalidate() 를 통해 validation(유효성) 
        // 체크를 수행한다. (여기에서 설정된 유효성은 확장자가 zip인 파일만을 업로드 할 수 있도록 하는 것이다.)
        fileUploadName.revalidate();
    }

/**
* @param : commModifyFile[파일업로드이름], fileGridName[파일그리드]
* @return 
* @wirter : 
* @write date : 2007-07-20
* @description : 선택된 파일그리드 상의 파일을 변경한다. 데이타가 넘어가는건 아님
* 				
*/
    function commModifyFile(fileUploadName, fileGridName){
        var files = window.fileDialog("open", "|", true);

        var filelist = files.split("|");
        var numberOfFiles = filelist.length;
        
        if (numberOfFiles != 0 && filelist[0] != "") {
            for(var i = 0 ; i < filelist.length ; i++ ) {
                if(i==0) {
                    model.setValue("/root/fileData/fileGrid[" + (fileGridName.row) + "]/attach_file_name", filelist[0]);
                    alert("File Size : " + fileUploadName.getFileSize(0));
                } else {						
                    model.makeNode("/root/fileData/fileGrid[" + (fileGridName.rows + (i-1)) + "]/attach_file_name");
                    model.setValue("/root/fileData/fileGrid[" + (fileGridName.rows + (i-1)) + "]/attach_file_name", filelist[i]);
//                    alert("File Size : " + fileUploadName.getFileSize(i));
                }
            }
        }
        fileUploadName.refresh();
        // 'upload' 버튼을 눌러 실제 업로드를 수행하기 이전에 upload1.revalidate() 를 통해 validation(유효성) 
        // 체크를 수행한다. (여기에서 설정된 유효성은 확장자가 zip인 파일만을 업로드 할 수 있도록 하는 것이다.)
        fileUploadName.revalidate();		
    }	

/**
* @param : commDelFile[파일그리드]
* @return 
* @wirter : 
* @write date : 2007-07-20
* @description : 선택된 파일그리드 상의 파일을 삭제한다. 기존 파일키는 임시 키로 저장한다.(테이블 삭제해주기 위해서)
* (테이블의 정보를 삭제하기 위해서 키가 존재해야 하기 때문). 데이타가 넘어가는건 아님				
*/
    function commDelFile(fileGridName){
        var fileKey = fileGridName.valueMatrix(fileGridName.row , fileGridName.colRef("file_id"));
        if(fileKey != null &&  fileKey != "")  
        {
            model.makeNode("/root/fileData/v_file_key");
            model.setValue("/root/fileData/v_file_key",fileKey);
        }
        
        fileGridName.deleterow(fileGridName.row) ;
        
    }
	


/**
* @param : commDownLoad[파일그리드]
* @return 
* @wirter : 
* @write date : 2007-07-20
* @description : 선택된 파일그리드상의 파일을 다운로드한다.				
*/

//    var downloadPosition = "c:/app/emis/fileupload";
    var downloadPosition = url+"files/";

function commDownLoad(fileGridName){
    var currentTarget = event.target;
    var isCell = fileGridName.isCell(currentTarget);
    var clickedRowPos = fileGridName.row;
    var clickedColPos = fileGridName.col;
    var downloadFileName;
    var completeDownloadPosition;
    var filePath = fileGridName.valueMatrix(fileGridName.row,fileGridName.colRef("attach_file_name"));

    if (isCell && clickedRowPos > 0) {
        downloadFileName = fileGridName.labelMatrix(clickedRowPos, clickedColPos);
        completeDownloadPosition = downloadPosition+downloadFileName;
       
        completeDownloadPosition = encodeURI(completeDownloadPosition);
 
        var file = window.fileDialog("save","","",downloadFileName,"xls","엑셀 문서(*.xls)|*.xls|All Files (*.*)|*.*");
        model.download(completeDownloadPosition,file,false);
    }
}


/**
* @param : fileName[파일명]
* @return 
* @wirter : 
* @write date : 2007-08-07
* @description : 파일을 다운로드한다.				
*/
    function fcDirectDownLoad(fileName){
        var downloadFileName = fileName;
        var completeDownloadPosition;

        completeDownloadPosition = downloadPosition +"/"+ downloadFileName;
        var file = window.fileDialog("save","","",downloadFileName,"xls","엑셀 문서(*.xls)|*.xls|All Files (*.*)|*.*");
        model.download(completeDownloadPosition,file,false);

    }


/**
* @param : fileGridName[파일그리드]
* @return 
* @wirter : 
* @write date : 2007-07-20
* @description : 파일을 업로드한후 파일그리드에 넣어준다.				
*/
    function fcCompleteFile(fileGridName){
        model.resetInstanceNode("/root/fileData/fileGrid");
        fileGridName.refresh();
        var isError = model.getValue("/root/resultData/Err_Msg[1]");
        if (isError != "") {
            //공통메세지 처리
			msgWrite(model.getValue("/root/res/Err_Msg[2]"));
        }
        
      //  appendData("/root/fileData/fileGrid","/root/resultData/fileGrid");
        model.refresh();
    }



/**
* @function :   commFwdPopClose() 
* @param : arguments 넘겨줄 인스턴스 노드값 (/root/fwdData/ 밑에 생성됨)	
* @return 
* @wirter : 
* @write date : 2007-07-25
* @description : 부모창 노드(/root/fwdData/reqData)으로 팝업창의 노드를 넘겨주고 팝업창을 닫는다.
*/
function commFwdPopClose()	{	
	
	try
		{
	var length = arguments.length;	
	
		opener.model.removenode("/root/fwdData/infoData");
	  opener.model.makeNode("/root/fwdData/infoData");
	  
		
			for(var j = 0; j<length; j++){					
	
					var node1 = instance1.selectSingleNode(arguments[j]);
					opener.model.duplicate("/root/fwdData/infoData",node1.cloneNode(true));
	
			}
							
		}					
		catch (e)
		{
			model.alert("Error", "해당노드의 선택이 잘못되었습니다");
			return false;
		}
    
    window.close()			
}	
/*
/**
* @function :   commMsgCall() 
* @param : arguments 메시지코드, 인자값	
* @return 
* @wirter : 
* @write date : 2007-07-25
* @description : 메시지호출 테스트 하단 bar 에 Msg 설정
*/
function commMsgCall() {
	
	//실제화면작업시
	//	htmlwindow.document.Script.msgCall(msg);		
	//테스트 작업시 
	var msg =""
	var argLength = arguments.length;
	
	  if (argLength>1) {
		
			 var vTempArray;
		   var vReturnString = "";
		
		   vTempArray = arguments[0].split("@");
			
			if(vTempArray.length!=(argLength)) {alert('인자값의 수가 다릅니다!');  return; }
				
			   for(var i=0; i<vTempArray.length-1; i++)
				   {
				      vReturnString += vTempArray[i] + arguments[(i+1)];
				   }
		
			   vReturnString += vTempArray[vTempArray.length-1];

  			 msg = vReturnString;	

			} else {
								
	       msg = arguments[0];				
			
			}

				try {
					parent.capMsg.value= msg;
				}catch(e) {
					capMsg.value= msg;		
		  	}

		model.refresh();
}
/**
 * @type   : function
 * @access : public
 * @desc   : 불리언값에 따라 옮길곳에 데이타를 날리고 옮길지, append시키고 날릴지를 판단한다.
 * @sig    : trgXpath, srcXpath, pboolean
 * @param  : trgXpath     - 맵핑을 시킬곳의 위치
 * @param  : srcXpath     - 서버에서 내려온 데이타
 * @param  : pboolean     - trgXpath의 노드를 살릴지 지울지 판단
 * @return : 없음. 
 */ 
function commAppendData(trgXpath, srcXpath, pboolean) {
	if (!pboolean || pboolean == "")
		pboolean = "false"; // 모드가 안들어오면 default(single)로 만듬

	switch (pboolean) {
		case "true":	
			var srcNode = instance1.selectSingleNode(srcXpath);
			var trgNode = instance1.selectSingleNode(trgXpath);

			var srNode_child = srcXpath.childNodes;	
			var trNode_child = trgXpath.childNodes;
			var spl = srcXpath.split("/");
			var tot_path = "";
			var LastNode = spl[spl.length-1];
			for(var z = 1; z < spl.length-1; z++) {
				tot_path += "/"+spl[z];
			}
			var src_sub = instance1.selectSingleNode(tot_path);
			var src_sub_child = src_sub.childNodes;
			var t_spl = trgXpath.split("/");
			var t_tot_path = "";
			var t_LastNode = t_spl[t_spl.length-1];
			for(var h = 1; h < t_spl.length-1; h++) {
				t_tot_path += "/" + t_spl[h];
			}
			var trg_sub = instance1.selectSingleNode(t_tot_path);
			var trg_sub_child = trg_sub.childNodes;

			model.makeNode("/root/srctmpNode");
			model.copyNode("/root/srctmpNode", t_tot_path);

			for(var u = 0; u<trg_sub_child.length; u ++){
				if(trg_sub_child.item(u).tagname != t_LastNode){
					model.removeNodeset("/root/srctmpNode/"+trg_sub_child.item(u).tagname);
				}
			}
			var srctmpNode = instance1.selectSingleNode("/root/srctmpNode");
			var srctmpNode_child = srctmpNode.childNodes;			

			model.makeNode("/root/backupNode");
			model.copyNode("/root/backupNode", tot_path);

			for(var u = 0; u<src_sub_child.length; u ++){
				if(src_sub_child.item(u).tagname != LastNode){
					model.removenodeset("/root/backupNode/"+src_sub_child.item(u).tagname);
				}
			}
			for(var i = srctmpNode_child.length; i>0; i --) {
				model.duplicate("/root/backupNode", "/root/srctmpNode/"+LastNode+"["+i+"]","*[1]");
			}
			model.removeNodeset(trgXpath);
			model.removeNodeset("/root/srctmpNode");
			var bkNode = instance1.selectSingleNode("/root/backupNode");
			var bkNode_child = bkNode.childNodes;
			/*
			for(var i = bkNode_child.length; i>0; i --) {
				model.duplicate(t_tot_path, "/root/backupNode/"+LastNode+"["+i+"]","*[1]");
			}*/
			for(var i =1 ; i<=bkNode_child.length; i ++) {
				model.duplicate(t_tot_path, "/root/backupNode/"+LastNode+"["+i+"]");
			}
			model.removeNodeset("/root/backupNode");
			break;
		case "false":
			var srcNode = instance1.selectSingleNode(srcXpath);
			var trgNode = instance1.selectSingleNode(trgXpath);

			var srNode_child = srcXpath.childNodes;	
			var trNode_child = trgXpath.childNodes;
			var spl = srcXpath.split("/");
			var tot_path = "";
			var LastNode = spl[spl.length-1];
			for(var z = 1; z<spl.length-1; z++) {
				tot_path += "/"+spl[z];
			}
			var src_sub = instance1.selectSingleNode(tot_path);
			var src_sub_child = src_sub.childNodes;
			var t_spl = trgXpath.split("/");
			var t_tot_path = "";
			var t_LastNode = t_spl[t_spl.length-1];
			for(var h = 1; h<t_spl.length-1; h++) {
				t_tot_path += "/"+t_spl[h];
			}
			var trg_sub = instance1.selectSingleNode(t_tot_path);
			var trg_sub_child = trg_sub.childNodes;

			model.removenode(trgXpath);

			model.makeNode("/root/backupNode");
			model.copyNode("/root/backupNode", tot_path);

			for(var u = 0; u<src_sub_child.length; u ++){
				if(src_sub_child.item(u).tagname != LastNode){
					model.removenodeset("/root/backupNode/"+src_sub_child.item(u).tagname);
				}
			}

			var bkNode = instance1.selectSingleNode("/root/backupNode");
			var bkNode_child = bkNode.childNodes;
			for(var i =1 ; i<=(bkNode_child.length+1); i ++) {
				model.duplicate(t_tot_path, "/root/backupNode/"+LastNode+"["+i+"]");
			}
			model.removeNodeset("/root/backupNode");
			break;
	}
}


/**
 * @type   : function
 * @access : public
 * @desc   : 데이터그리드를 멀티업데이트할때 nodeset을 새로 구성한다.
 *    <pre>
 *         commMultiUpdate(gridID,"/root/dest","A",false,"rowStuts")
 *    </pre>
 * @sig    : gridID,newNodesetPath,multiFlag,bRebuild,newEleName
 * @param  : gridID           - 해당 데이터그리드의 아이디 또는 데이터그리드 객체.
 * @param  : newNodesetPath   - 업데이트 데이터가 저장될 노드패스 Xpath.
 * @param  : multiFlag        - 업데이트모드(A:전체, I:인서트만, U:업데이트만,D:딜리트만)
 * @param  : bRebuild         - 기존 nodeset을 새로구성:true, 기존 req에 각 row의 변경스트링만 추가.
 * @param  : newEleName       - bRebuild->true : 연산플래그(i,u,d)를 저장할 노드명,
 *                              bRebuild->flase: 변경된 각각의 ROW 업데이트스트링을 저장할 노드명
 * @return : boolean
 */
function commMultiUpdate(gridID,newNodesetPath,multiFlag,bRebuild,newEleName) {
	var oGrid = (typeof gridID == 'string')?document.controls(gridID):gridID;
	var data = oGrid.getUpdateData();
	var rowSep = (oGrid.attribute("rowsep")=='')?'|':oGrid.attribute('rowsep');
	var colSep = (oGrid.attribute("colsep")=='')?'^':oGrid.attribute('colsep');
	var up_data    = data.split(rowSep);
	var nHeaderLen = 2;
	var nodesetPath = oGrid.attribute("nodeset");
	if(up_data.length <= nHeaderLen){
	   return false;
	}
	
	var insertFlag = 0;
	var updateFlag = 0;
	var deleteFlag = 0;
		
	var arrHeader = new Array();
	var arrData   = new Array();
	var oldNodeset = model.instances(0).selectSingleNode(nodesetPath);
	var strNodesetName = nodesetPath.substring(nodesetPath.lastIndexOf("/")+1);
	model.makeNode(newNodesetPath);
        var parentNode = model.instances(0).selectSingleNode(newNodesetPath);

	for(var i=0;i<up_data.length-1;i++){
		var vRow = up_data[i].split(colSep);
			
		if(i==0) {
			arrHeader = vRow;
			continue;
		}
		var up_flag = vRow[0];
		var bInsert = (up_flag == "i" && multiFlag=="I")?true:false;
		var bUpdate = (up_flag == "u" && multiFlag=="U")?true:false;
		var bDelete = (up_flag == "d" && multiFlag=="D")?true:false;
		var bMulti  = (multiFlag=="A")?true:false;

		if(bInsert){
    		if(!bRebuild) {
				var rowNode = model.instances(0).createElement(newEleName);
				rowNode.nodeValue = up_data[i];
				parentNode.appendChild(rowNode);
			} else {			    
				arrData[insertFlag++] = vRow;
			}
		} else if(bUpdate){
			if(!bRebuild) {
				var rowNode = model.instances(0).createElement(newEleName);
				rowNode.nodeValue = up_data[i];
				parentNode.appendChild(rowNode);
			} else {   
				arrData[updateFlag++] = vRow;
			}
		}else if(bDelete){
			if(!bRebuild) {
				var rowNode = model.instances(0).createElement(newEleName);
				rowNode.nodeValue = up_data[i];
				parentNode.appendChild(rowNode);
			} else {   
				arrData[deleteFlag++] = vRow;
			}
		}else if(bMulti){
			if(!bRebuild) {
				var rowNode = model.instances(0).createElement(newEleName);
				rowNode.nodeValue = up_data[i];
				parentNode.appendChild(rowNode);
			} else { 
				arrData[(i-1)] = vRow;
			}
		}
	}

	if(arrData.length < 1 && bRebuild) return false;
    
	if(bRebuild) {
		for(var i=0; i<arrData.length; i++) {
			var r = arrData[i];
			var rowNode = model.instances(0).createElement(strNodesetName);
			for(var j=0; j<arrHeader.length; j++) {
				if(j==1)
					continue;
				var colName;
				if(j==0) {
					colName = newEleName;
				} else {
					colName = arrHeader[j];
				}
				var colNode = model.instances(0).createElement(colName);

				colNode.nodeValue = r[j];
				rowNode.appendChild(colNode);
			}
			parentNode.appendChild(rowNode);
			var flagNode = model.instances(0).selectNodes(newNodesetPath+"/"+strNodesetName+"["+(i+1)+"]/"+newEleName);
			if( flagNode.length > 1 ) {
				for( var k = 2; k <= flagNode.length; k++ ) {
					model.removeNode(newNodesetPath+"/"+strNodesetName+"["+(i+1)+"]/"+newEleName+"["+k+"]");
				}
			}
		}
	}
	return true;
}

/**
 * @function   :  commDetailView
 * @access : public
 * @desc   : 두개의 노드를 비교해서 같은 엘리먼트가 있으면 값을 복사한다.
 * @sig    : datagridID, f_set
 * @param  : f_set  - 복사될 곳의 위치
 * @param  : datagridID  - 선택한 행의 그리드ID
 * @return : 없음. 
 */ 
function commDetailView(datagridID,f_set) {

	if( typeof datagridID == 'string' ) datagridID = document.controls(datagridID);
	var f_get = datagridID.attribute("nodeset")+"["+(datagridID.row-datagridID.fixedRows+1)+"]";

	var node = instance1.selectSingleNode(f_get);
	if(node != null){
		var nodeChild = node.childNodes;
		var node_detail = instance1.selectSingleNode(f_set);
		var nodeChild_detail = node_detail.childNodes;
		var tag = "";
		var tag_detail = "";
		var get_value = "";
		var lower_tag = "";
		for(var i = 0; i < nodeChild.length; i ++) {
			tag = nodeChild.item(i).tagname;
			get_value = model.getValue(f_get+ "/"+ tag);
			for(var y = 0 ; y < nodeChild_detail.length; y ++ ) {			
				tag_detail = nodeChild_detail.item(y).tagname;
				if(tag == tag_detail) { 
					model.setValue(f_set+ "/"+ tag_detail, get_value);
				}
			}
		}
		model.refresh();
	}
}

/**
 * @function   :  commFormSet
 * @access : public
 * @desc   : 두개의 노드를 비교해서 같은 엘리먼트가 있으면 값을 복사한다.
 * @sig    : f_get, f_set
 * @param  : f_set  - 복사될 곳의 위치
 * @param  : f_get  - 복사할곳의 위치D
 * @return : 없음. 
 */ 
function commFormSet(f_set,f_get) {

	
	var node = instance1.selectSingleNode(f_get);
	if(node != null){
		var nodeChild = node.childNodes;
		var node_detail = instance1.selectSingleNode(f_set);
		var nodeChild_detail = node_detail.childNodes;
		var tag = "";
		var tag_detail = "";
		var get_value = "";
		var lower_tag = "";
		for(var i = 0; i < nodeChild.length; i ++) {
			tag = nodeChild.item(i).tagname;
			get_value = model.getValue(f_get+ "/"+ tag);
			for(var y = 0 ; y < nodeChild_detail.length; y ++ ) {			
				tag_detail = nodeChild_detail.item(y).tagname;
				if(tag == tag_detail) { 
					model.setValue(f_set+ "/"+ tag_detail, get_value);
				}
			}
		}
		model.refresh();
	}
}


/**
 * @function   :  commGroupInit
 * @access : public
 * @desc   : 그룹하위 control 초기화
 * @sig    :
 * @param  :groupid
 * @return : 없음. 
 */ 
function commGroupInit(groupid)
{
    var ctrCnt = groupid.children.length;

	for(var j=0 ;  j < ctrCnt ; j++)
	{
	
		var ctr = groupid.children.item( j );
		
		if(ctr.elementName == "xforms:input" ||  ctr.elementName == "xforms:output" || ctr.elementName =="xforms:select1") {
			model.setValue(ctr.attribute("ref"),"");	
		} else if(ctr.elementName == "xforms:datagrid" ) 
		{
			model.removeNodeset(ctr.attribute("nodeset"));
		} 
	}
	groupid.refresh();
}

/**
 * @function   :  commComfirmBox
 * @access : public
 * @desc   : 윈도우 comfirm 창
 * @sig    : str, title
 * @param  : str   - 나타낼 문자열
 * @param  : title - 제목 
 * @return : yes 1 , no 0
 */ 
function commComfirmBox(str, title) {
	
	var MyReturn = model.alert( str, title, 0x20 | 4 );   
	if( MyReturn == 6) return 1;
	else			   return 0;
	return MyReturn;

}

/**
 * @function   :  commGridInit
 * @access : public
 * @desc   : 그리드 셀 스타일과 디세이블 상태를 초기화 시켜준다
 * @sig    : datagrid1
 * @param  : datagrid1   - 그리드 id
 * @return : 
 */ 
function commGridInit(datagrid1) {
		if( typeof datagrid1 == 'string' ) datagrid1 = document.controls(datagrid1);
		datagrid1.allStyle("data","background-color")= initCellStyle;
		datagrid1.isReadOnly(0,0,(datagrid1.rows-1),(datagrid1.cols-1))=false;
}

/**
 * @function   :  commAddRow
 * @access : public
 * @desc   : 그리드 행추가
 * @sig    : datagrid1
 * @param  : datagrid1   - 그리드 id
 * @return : 
 */ 
function commAddRow(datagrid1) {
	if( typeof datagrid1 == 'string' ) datagrid1 = document.controls(datagrid1);
	datagrid1.addRow();
	datagrid1.rowStyle(datagrid1.rows-1,"data","background-color") =insertRowStyle;
	datagrid1.row=datagrid1.rows-1;
	datagrid1.isSelected(datagrid1.rows)=true;
}	

/**
 * @function   :  commDelRow
 * @access : public
 * @desc   : 그리드 행삭제
 * @sig    : datagrid1
 * @param  : datagrid1   - 그리드 id
 * @return : 
 */ 
function commDelRow(datagrid1,chkRef) {
					
		for(var i=datagrid1.rows; i>(datagrid1.fixedRows-1) ; i--) {
				
				if(datagrid1.valueMatrix(i,datagrid1.colRef(chkRef))=='true') {
					
					if( datagrid1.rowStatus(i)==1 ||datagrid1.rowStatus(i)==3 ) 
					{ 
						datagrid1.deleteRow(i);	
					}else if(datagrid1.rowStatus(i)==4 || datagrid1.rowStatus(i)==0) 
					{
						datagrid1.isReadOnly(i,0,i,(datagrid1.cols-1))=true;
						datagrid1.rowStyle(i,"data","background-color") = deleteRowStyle; 
						datagrid1.addStatus(i,"delete");
					}
					
				} 	
		}
}




/**
*  @function : goPage 
*  @ param : gridID - 페이징 처리할 gridID
*  @ param : blockSize - 페이질 블럭 크기
*  @ param : submissionID - 그리드를 조회하는 서브미션ID
*  @ param : txCode - 그리드를 조회하는 txCode
*  @ param : resGridNodeSet - resultRef 중 그리드의 Nodeset으로 복사될 Node
*  @ param : page - 이동할 페이지	 	   
*  desc    : 지정한 페이지로 이동. 
*/

function goPage (gridID,serviceName,serviceTag,action,page,pageSize, blockSize,resGridNodeSet,funcNm,importID) {
       action = action+"&pageEvent=1";
	commSubmit(serviceName,serviceTag,action);

	if( typeof gridID == 'string' ) gridID = document.controls(gridID);
	
		var gridNode = gridID.attribute("nodeset");
		var pageNode =gridNode.substr(0,gridNode.lastIndexOf("/"))
		
		commAppendData(pageNode,resGridNodeSet);   //<-- 가져온 값을 그리드 데이터에 붙인다
		//var page
		gridID.rebuild();
		gridID.setSeqRowHeader((page-1)*pageSize+1-gridID.fixedRows);
		model.makeValue("/root/pageInfo/currentPage",page);
	
		if(action.indexOf("?")!=-1) action = action.substr(0,action.indexOf("?"));
			
		commPagingList(gridID, blockSize, serviceName, serviceTag, action, resGridNodeSet, page, funcNm,importID) ;
	
		if ( funcNm != "" && funcNm != null ) {	
			eval(funcNm + "();");
		}
	}
	
	
/**
	*  @ function :	commPagingList 
	*  @ param : gridID - 페이징 처리할 gridID
	*  @ param : blockSize - 페이질 블럭 크기
	*  @ param : serviceName - 그리드를 조회하는 serviceName
	*  @ param : serviceTag - 그리드를 조회하는 serviceTag
	*  @ param : actionName - 그리드를 조회하는 actionName
	*  @ param : resGridNodeSet - resultRef 중 그리드의 Nodeset으로 복사될 Node
	*  @ param : page       - 호출할 현재페이지
	*  @ param : funcNm     - 페이지 생성 후 
	*  @ param : importID   - import가 여러개일경우 임포트 아이디를 지정해준다.
	*  @ description : 페이징 블럭 생성 
    
 */
function commPagingList(gridID, blockSize, serviceName, serviceTag, actionName, resGridNodeSet, page, funcNm ,importID) {
			
		
		var gridId = gridID.attribute("id");
		
		if( typeof gridID == 'string' ) gridID = document.controls(gridID);
		if (importID != "" && importID != null && importID !='undefined') {
		   if( typeof importID == 'string' ) importID = document.controls(importID);	
		} 
		
		var gridNode = gridID.attribute("nodeset");
		
		var pageNode =gridNode.substr(0,gridNode.lastIndexOf("/"))+"/PageSize";
		var totSizeNode =gridNode.substr(0,gridNode.lastIndexOf("/"))+"/ToTal";	
					
		var pageSize = Number(model.getValue(pageNode));
		var totSize =  Number(model.getValue(totSizeNode));
		
		if(instance1.selectSingleNode("/root/pageInfo/currentPage")!=null) page = Number(model.getValue("/root/pageInfo/currentPage")); 								
							
		var  currentPage = page;

		var  totalPageCount = Number(Math.ceil(totSize/pageSize));
		
		var  totalItemCount  = totSize;    // 총 건수
	

		// 현재페이지 설정
		if ( currentPage == 0  ) currentPage = 1 ;
		// 페이징블럭 시작번호, 끝번호
		var startPageNo = ((Math.ceil(currentPage/blockSize)-1) * blockSize) + 1;   // 페이징블럭 시작번호
		
		var endPageNo = Math.ceil(currentPage/blockSize) * blockSize;	             // 페이징블럭 끝번호    
		if ( endPageNo > totalPageCount ) endPageNo = totalPageCount ;                // 끝번호는 최대가 총페이지수
		
		var prevStart = startPageNo - blockSize ;                                                   // 이전일 경우 시작할 페이지번호
		if ( prevStart < 1 ) prevStart = 1;                                                                 // 이전 시작 페이지는 최소 1 
		var nextStart = startPageNo + blockSize ;                                                   //  다음일 경우 시작할 페이지번호
		var lastStart = (Math.ceil(totalPageCount/blockSize) - 1) * blockSize + 1 ;     // 맨끝일 경우 시작할 페이지번호
		
		// 버튼들의 시작 위치 정하기
		var pageNoCnt = endPageNo - startPageNo + 1 ;                                        // 페이징블럭에 생길 페이지갯수
		var q = 22 * pageNoCnt - 2 + 100 ; // 필요한 크기: 숫자당크기(숫자+숫자간간격) * 페이지숫자갯수 - 2(마지막 숫자간 간격) + 양옆버튼총크기(간격포함)
		
		var importSize = 0;
		var importSize1;
		
		if(importID!='undefined' && importID!=null && importID!=""){ 
			
			importSize1 = importID.attribute("width");
		    importSize = Number(importSize1.substr(0,importSize1.indexOf("px")));
		} else {  
			var ctrCnt = body.children.length;

			for ( var i = 0 ; i < ctrCnt ; i++ ) {
				var ctr = body.children.item(i);
				if ( ctr.elementName == "xforms:import") {
				importSize1 = ctr.attribute("width");
				importSize = Number(importSize1.substr(0,importSize1.indexOf("px")));
				}
			}				
		}	  
		
		var s = Math.ceil((importSize - q) / 2) ;  // 시작점 : ( 334(전체크기) - 필요한크기 ) / 2
		
		// 이전,맨앞 버튼 처리
		btn_nav_first.attribute("left") = s ;
		btn_nav_first.visible = true;							
		s += 15 ;
		
		btn_nav_prev.attribute("left") = s ;
		btn_nav_prev.visible = true;		
		s += 35 ;
					
		if ( currentPage <= blockSize ) {
			btn_nav_first.disabled =true;
			btn_nav_prev.disabled = true;						
		} else {

			oFirstButton = grp_nav.children.item("btn_nav_first") ;
			oFirstButton.attribute("onclick")  = "goPage('"+gridId+"','"+serviceName+"','"+serviceTag+"','"+actionName+"?curPageNum=1',"+1+","+pageSize+","+blockSize+",'"+resGridNodeSet+"','"+funcNm+"');"  ;

			oPrevButton = grp_nav.children.item("btn_nav_prev") ;
			oPrevButton.attribute("onclick") =  "goPage('"+gridId+"','"+serviceName+"','"+serviceTag+"','"+actionName+"?curPageNum="+prevStart+"',"+prevStart+","+pageSize+","+blockSize+",'"+resGridNodeSet+"','"+funcNm+"');"  ;
			
			btn_nav_first.disabled = false;
			btn_nav_prev.disabled = false;
		}

		// 해당하는 페이지만큼 생성
	
		var j = 0;
		for ( var i = startPageNo ; i <= endPageNo ; i++ ) {
			j ++ ;
			if ( grp_nav.children.item("caption_nav_"+ j ) != null) {
	
				oCaption =  grp_nav.children.item("caption_nav_"+j);
				oCaption.attribute("visibility") = "visible" ;
			} else {	
						
				var propText = "id:caption_nav_" + (j) + ";left:" + s + "px; top:5px; width:23px; height:15px;";
				oCaption = grp_nav.createChild("xforms:caption", propText);
			}
			
			if (i==currentPage) {
				oCaption.attribute("font-weight") = "bold;";
				oCaption.attribute("onclick") = "";
			} else  {

				oCaption.attribute("font-weight") ="normal;";
				oCaption.attribute("onclick") =  "goPage('"+gridId+"','"+serviceName+"','"+serviceTag+"','"+actionName+"?curPageNum="+i+"',"+i+","+pageSize+","+blockSize+",'"+resGridNodeSet+"','"+funcNm+"');"  ;
			}
			
			oCaption.attribute("text") = i;
			oCaption.attribute("left") = s;
			
			s += 15 ; // 다음 숫자의 포지션 계산(숫자의 width(23) + 2
		}

		for ( var i = (endPageNo-startPageNo+2) ; i <= blockSize; i++ ) {

			if ( grp_nav.children.item("caption_nav_"+ i ) != null) {
				oCaption =  grp_nav.children.item("caption_nav_"+i);
				oCaption.attribute("visibility") = "hidden" ;
			}
		}

		// 다음,맨뒤 버튼 처리
		s += 15;
		btn_nav_next.attribute("left") = s ;
		btn_nav_next.visible = true;	

		s += 33 ;					
		btn_nav_last.attribute("left") = s ;
		btn_nav_last.visible = true;		
		
		if ( Math.ceil(currentPage/blockSize) == Math.ceil(totalPageCount/blockSize) ) {				
			btn_nav_next.disabled = true;
			btn_nav_last.disabled = true;
		} else {
			oNextButton = grp_nav.children.item("btn_nav_next") ;						
			oNextButton.attribute("onclick") = "goPage('"+gridId+"','"+serviceName+"','"+serviceTag+"','"+actionName+"?curPageNum="+nextStart+"',"+nextStart+","+pageSize+","+blockSize+",'"+resGridNodeSet+"','"+funcNm+"');"  ;

			oLastButton = grp_nav.children.item("btn_nav_last") ;
			oLastButton.attribute("onclick")  = "goPage('"+gridId+"','"+serviceName+"','"+serviceTag+"','"+actionName+"?curPageNum="+lastStart+"',"+lastStart+","+pageSize+","+blockSize+",'"+resGridNodeSet+"','"+funcNm+"');"  ;
			
			btn_nav_next.disabled = false;
			btn_nav_last.disabled = false;
		}
		
		
}

/**
 * @function   :  commMsgBox
 * @access : public
 * @desc   : 메시지 알림 창
 * @sig    : str, title
 * @param  : arguments - 메시지코드, 인자값
 * @param  :  
 * @return : 
 */ 
function commMsgBox() {
	var argLength =	arguments.length;
	if(argLength == 0) {
		if(instance1.selectSingleNode("/root/resData/Message") != null) {
			var msg = model.getValue("/root/resData/Message");
			if (msg != "" && msg != null && msg.length > 0) {
			      model.alert(msg, "알림");
			}	
		}
	} else {
		var msg = arguments[0];
		var vTempArray = msg.split("@");
		// vTempArray = arguments[0].split("@");
		var vReturnString = "";

		if(vTempArray.length != argLength) {
			alert('인자값의 수가 다릅니다!');
			return;
		}

		for(var i = 0; i < vTempArray.length-1 ; i++) {
			vReturnString += vTempArray[i] + arguments[(i+1)];
		}

		vReturnString += vTempArray[vTempArray.length-1];
		model.alert( vReturnString, "알림");   	
	}
}


/**
 * @function   :  commReqCheck
 * @access : public
 * @desc   : 필수입력 확인 
 * @sig    : 
 * @param  : group ID
 * @param  :  
 * @return : 
 */ 
	function commReqCheck(group1) {	
		var chk =true;	
		if( typeof group1 == 'string' ) group1 = document.controls(group1);			
		var cnt = group1.children.length;
		
		for(i=0 ; i<cnt ; i++) {
			var ctr = group1.children.item(i);
			if(ctr.elementName=="xforms:input" || ctr.elementName=="xforms:select1") {
				
				if(ctr.attribute("class")=="req" && model.getValue(ctr.attribute("ref"))=="") {
					model.setFocus(ctr.attribute("id"));	
					commMsgBox(bz_common_reqConfirm);
					chk =false;
					break;
				}	
			}							
		}
	   return chk;
	}				
	
/**
 * @type   : function
 * @access : public
 * @desc   : Progress Bar와 관련된 함수이다.
 */
cf_progress_bar = new function() {
	var N = -1;
	var width  = 300;
	var height = 15;
	var left   = 0;
	var top    = 0;
	var bg_color = "white";
	var bd_width = "1";
	var bd_color = "#666699";
	var block_color  = "#CC99FF";
	var speed        = 100;
	var block_count  = 17;
	var scroll_count = 5;
	var action       = "";
	left =  Math.ceil((window.width - width)/2);
	top  = Math.ceil((window.height - height)/2);

    var oProgressBar, oOuterBlock, sProperty = 'id:grp_progress'+ N +';visibility:hidden;overflow:hidden;font-size:1px;border-style:solid;';
	sProperty += "width:"  + width  +";";
	sProperty += "height:" + height +";";
	sProperty += "left:"   + left  +";";
	sProperty += "top:"    + top  +";";
	sProperty += "background-color:" +  bg_color +";";
	sProperty += "border-width:"     +  bd_width +";";
	sProperty += "border-color:"     +  bd_color +";";
	oProgressBar = body.createChild("xforms:group", sProperty);
       
	sProperty = 'id:grp_outer_block'+ N +';visibility:visible;overflow:hidden;font-size:1px;';
	sProperty += "background-color:" +  "white" +";";
	sProperty += "left:-"   + (height*2+1)  +";";
    sProperty += "top:"    + (0)  +";";		
    sProperty += "width:"  + width  +";";
	sProperty += "height:" + height +";";
	oOuterBlock = oProgressBar.createChild("xforms:group", sProperty);
	
	for(i=0;i<block_count;i++){
		sProperty = "id:cap_bar"+(i)+";visibility:visible;font-size:1px;";
		sProperty += "background-color:" +  block_color +";";
		sProperty += "width:"   + height +";";
		sProperty += "height:"  + height +";";
		sProperty += "left:"   + ((height*i)+i)  +";"; 
		sProperty += "top:"     + 0  +";";
		sProperty += "opacity:" +  (100-i*(100/block_count)) +";";
		oOuterBlock.createChild("xforms:caption", sProperty);
	}
	
	this.bar = oProgressBar;
	this.block_count=block_count;
	this.N=N;
	this.left2=left;
	this.top2=top;
	this.w=width;
	this.h=height;
	this.speed=speed;
	this.ctr=0;
	this.count=scroll_count;
	this.action=action;

	this.startBar = function(bn){
		if(oOuterBlock.currentStyle.left+oOuterBlock.currentStyle.height+1-(cf_progress_bar.block_count*oOuterBlock.currentStyle.height+cf_progress_bar.block_count)>oOuterBlock.currentStyle.width){
			oOuterBlock.attribute("left") =-(oOuterBlock.currentStyle.height*2+1)+'px';
			cf_progress_bar.ctr++;
			if(cf_progress_bar.ctr>=cf_progress_bar.scroll_count){
				eval(cf_progress_bar.action);
				cf_progress_bar.ctr=0;
		       }
		} else oOuterBlock.attribute("left")=(parseInt(oOuterBlock.currentStyle.left)+oOuterBlock.currentStyle.height+1)+'px';
	}

	this.togglePause = function (){
		if(cf_progress_bar.tid==0){
			cf_progress_bar.tid=window.setInterval('cf_progress_bar.startBar('+cf_progress_bar.N+')',cf_progress_bar.speed);
		} else {
			window.clearInterval(cf_progress_bar.tid);
			cf_progress_bar.tid=0;
		}
	}

	this.showBar=function(){
		cf_progress_bar.moveCenter(true);
		cf_progress_bar.bar.attribute("visibility")="visible";
	}

	this.hideBar=function() {
		cf_progress_bar.bar.attribute("visibility")="hidden";
		cf_progress_bar.moveCenter(false);
	}
	
	this.start = function() {
		cf_progress_bar.showBar();
		cf_progress_bar.tid=window.setInterval('cf_progress_bar.startBar('+N+')',cf_progress_bar.speed);
	}
		
	this.finish = function() {
		cf_progress_bar.togglePause();
		cf_progress_bar.hideBar();
	}		
		
	this.moveCenter = function(flag) {
		if(!flag) {
			cf_progress_bar.left2 = cf_progress_bar.bar.attribute("left");
			cf_progress_bar.top2  = cf_progress_bar.bar.attribute("top");
			cf_progress_bar.bar.attribute("left") = -cf_progress_bar.bar.attribute("width");
			cf_progress_bar.bar.attribute("top")  = -cf_progress_bar.bar.attribute("height");
		} else {
			cf_progress_bar.bar.attribute("left") = cf_progress_bar.left2;
		    cf_progress_bar.bar.attribute("top") = cf_progress_bar.top2;
		}
	}
}


/**
 * @type   : function
 * @access : public
 * @desc   : progress bar를 표시한다.
 *    <pre>
 *        cf_progress('S')
 *    </pre>
 * @param  : mode - progress bar 시작('S') / 끝내기('E')
 * @return : boolean - 성공/실패
 */
function commProgress(mode) {
    try{
       	var progressGroup = null;
        if( mode == 'S' ) {
            /* create group : 파일 저장 시에 화면의 컨트롤을 클릭하는 것 방지해 줌. */
        	var width = 200, height = 18;
        	
        	sPropertyText = 'id:progressGroup; left:50%; top:50%; width:'+width+'px; height:'+height+'px; ';
        
        	progressGroup = body.createChild("xforms:group",sPropertyText);
        	if( progressGroup == null ) {
        		//model.alert("group 생성 실패");
        		return false;
        	}
        	progressGroup.attribute('background-color') = 'transparent';
        	cf_progress_bar.start(); progressGroup.attribute('width') = width; progressGroup.attribute('height') = height;
        } else if( mode == 'E' ) {
           	progressGroup = document.controls('progressGroup');
           	if( progressGroup == null ) { return false; }
            cf_progress_bar.finish(); progressGroup.attribute('width') = 0; progressGroup.attribute('height') = 0;
        }
    } catch(e) {}
}
	
/***************************************************************************************************************/
/* 3 . ProtoType 관련 함수 (String)
/*
/* 1)  String.prototype.ReplaceWord        : 문자열중의 특정 문자 또는 단어를 찾아 원하는 문자 또는 단어로 치환   
/* 2)  String.prototype.CheckNum           : 저장된 값이 Number 형인지 점검
/* 3)  String.prototype.CheckFloat         : 저장된 값이 Float 형인지 점검
/* 4)  String.prototype.GetRound           : 저장된 값을 지정한 자리에서 올림/반올림/버림 처리 GetRound( pPoint, pMode )   
/* 5)  String.prototype.GetTruncate        : 소수점 버리고 정수형 String으로 생성 (음수인경우에도 마찬가지 음수표시는 유효)   
/* 6)  String.prototype.GetZeroString      : 저장된 숫자 값에 원하는 길이만큼 '0'을 붙여 표현 GetZeroString( pLen )  
/* 7)  String.prototype.GetByteSize        : 파라미터 값의 Byte 크기를 리턴   
/* 8)  String.prototype.Trim               : 문자열 앞뒤에있는 공백 제거   
/* 9)  String.prototype.CheckByteSize      : 문자열의 Byte 크기가 제한값을 벗어나는지 체크 (벗어나면 false 리턴)   
/* 10) String.prototype.CheckEmpty         : 값이 없는지 체크     
/* 11) String.prototype.ReplaceString      : 문자열중의 특정 문자 또는 단어를 찾아 원하는 문자 또는 단어로 치환     
/* 12) String.prototype.TrimLeft           : 문자열 앞에 있는 공백 제거     
/* 13) String.prototype.TrimRight          : 문자열 뒤에 있는 공백 제거     
/* 14) String.prototype.ToLower            : 문자열을 모두 소문자로 변환     
/* 15) String.prototype.ToUpper            : 문자열을 모두 대문자로 변환     
/* 16) String.prototype.GetLength          : 문자열의 길이를 구한다.     
/* 17) String.prototype.IsNull             : 주어진 값이 null인지 확인한다.
/* 18) String.prototype.AmtToHangleName    :  금액을 한글금액으로 변경 
*****************************************************************************************************************/		


String.prototype.ReplaceWord       = ReplaceWord;
String.prototype.CheckNum          = CheckNum;
String.prototype.CheckFloat        = CheckFloat;
String.prototype.GetRound          = GetRound;
String.prototype.GetTruncate       = GetTruncate;
String.prototype.GetZeroString     = GetZeroString;
String.prototype.GetByteSize       = GetByteSize;
String.prototype.Trim              = Trim;
String.prototype.CheckByteSize     = CheckByteSize;
String.prototype.CheckEmpty        = CheckEmpty;
String.prototype.ReplaceString     = ReplaceString;
String.prototype.TrimLeft          = TrimLeft;
String.prototype.TrimRight         = TrimRight;
String.prototype.ToLower           = ToLower;
String.prototype.ToUpper           = ToUpper;
String.prototype.GetLength         = GetLength;
String.prototype.IsNull            = IsNull;
String.prototype.AmtToHangleName   = AmtToHangleName;

/**
 * @group  : String 확장
 * @ver    : 2004.06.30 (KUHDEV-0001)
 * @by     : je2kwan2.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열중의 특정 문자 또는 단어를 찾아 원하는 문자 또는 단어로 치환
 * <pre>
 *				1. 찾을 단어를 구분자로 분리한 문자열을 저장할 배열 변수지정
 *				2. 치환하여 리턴할 내용을 담을 변수 지정
 *				3. 원본 문자열을 찾을 단어를 구분자로 분리
 *				4. 찾을 단어의 수만큼 loop
 *					- 찾을 단어 대신 대체 단어를 붙이면서 누적
 *				3. 마지막 찾을 단어의 뒷부분 내용 추가.
 *					- 찾을 단어가 없었다면 원본 문자열 전체가 됨
 * </pre>
 * @param  : pFindWord    - 찾을 단어
 * @param  : pReplaceWord - 대체 단어
 * @return : String - 대체하고난 문자열
 * @---------------------------------------------------
 */
function ReplaceWord( pFindWord, pReplaceWord )
{
   var vTempArray;
   var vReturnString = "";

   vTempArray = this.split(pFindWord);

   for(var i=0; i<vTempArray.length-1; i++)
   {
   	vReturnString += vTempArray[i] + pReplaceWord;
   }

   vReturnString += vTempArray[vTempArray.length-1];

   return vReturnString;
}

//numArray.max( sint,mint )  --- (X)
//numArray.max( sint, mint ) --- (O)


/**
 * @group  : String 확장
 * @ver    : 2004.06.30 (KUHDEV-0001)
 * @by     : je2kwan2.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 저장된 값이 Number 형인지 점검
 * @param  : N/A
 * @return : true/false
 * @---------------------------------------------------
 */
function CheckNum()
{
	if( typeof( this ) == "undefined" ) return false;
	if( this.length == 0 ) return false;

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

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

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

	return true;
}

/**
 * @group  : String 확장
 * @ver    : 2004.06.30 (KUHDEV-0001)
 * @by     : je2kwan2.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 저장된 값이 Float 형인지 점검
 * @param  : N/A
 * @return : true/false
 * @---------------------------------------------------
 */
function CheckFloat()
{
	// 파라미터 값이 parseFloat()후에도 같으면 TRUE 리턴
   if( this == parseFloat( this ) ) {
   	return true;
   } else {
   	return false;
   }
}

/**
 * @group  : String 확장
 * @ver    : 2004.06.30 (KUHDEV-0001)
 * @by     : je2kwan2.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 저장된 값을 지정한 자리에서 올림/반올림/버림 처리
 * <pre>
 *           1.
 * </pre>
 * @param  : pPoint - 올림/반올림/버림 할 위치(2:10자리, 1:1자리, -1:소수점이하 첫째자리)
 * @param  : pMode  - 1:올림, 0:반올림, -1:버림
 * @return : Number
 * @---------------------------------------------------
 */
function GetRound( pPoint, pMode )
{
// 파라미터 값을 수치화 하여 변수에 저장
   var vNumber    = eval(this);

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

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

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

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

         return this;
      }
   }

   // '올림'이고
   if(1 == eval(pMode))
   {
      // 소수점 앞에서 처리하려면
      if(0 < eval(pPoint))
      {
         // 해당 자리(pPoint)에서 올림 처리
         vNumber = Math.ceil(vNumber / Math.pow(10, pPoint)) * Math.pow(10, pPoint);

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

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

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

         return vNumber;
      }
      else
      {
         //fAlertMessage(4, "올림자리");
         return "";
      }
   }
   // '버림'이고
   else if(-1 == eval(pMode))
   {
      // 소수점 앞에서 처리하려면
      if(0 < eval(pPoint))
      {
         // 해당 자리(pPoint)에서 내림 처리
         vNumber = Math.floor(vNumber / Math.pow(10, pPoint)) * Math.pow(10, pPoint);

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

         return vNumber;
      }
      else
      {
         //fAlertMessage(4, "올림자리");
         return "";
      }
   }
   // 모두 아니면
   else
   {
      // 메시지 처리후 리턴
      //fAlertMessage(1, "모드('1'/'0'/'-1')");
      return "";
   }
}

/**
 * @group  : String 확장
 * @ver    : 2004.06.30 (KUHDEV-0001)
 * @by     : je2kwan2.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 소수점 버리고 정수형 String으로 생성 (음수인경우에도 마찬가지 음수표시는 유효)
 * @param  : N/A
 * @return : Number
 * @---------------------------------------------------
 */
function GetTruncate()
{
	var TempArray = new Array();
	TempArray = this.split(".");
	return TempArray[0];
}

/**
 * @group  : String 확장
 * @ver    : 2004.06.30 (KUHDEV-0001)
 * @by     : je2kwan2.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   :  저장된 숫자 값에 원하는 길이만큼 '0'을 붙여 표현
 * @param  : pLen - 돌려받을 최종문자의 길이
 * @return : 지정길이보다 모자른경우 "0"값이 추가된 문자열
 * @return : 지정길이보다 큰경우 원래 문자열을 반환
 * @---------------------------------------------------
 */
function GetZeroString( pLen )
{
	var sTemp = eval(this);
	if (this.length > pLen) return this;

	for( var iCnt = this.length; iCnt < pLen; iCnt++){
		sTemp = "0" + sTemp;
	}

	return sTemp;
}





/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 파라미터 값의 Byte 크기를 리턴
 * @param  : N/A
 * @return : 파라미터 값의 Byte 크기
 * @---------------------------------------------------
 */
function GetByteSize()
{
   // Byte 수를 저장할 변수
   var vByteSize = 0;

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

  return vByteSize;
}


/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열 앞뒤에있는 공백 제거
 * @param  : N/A
 * @return : 공백을 제거한 결과 문자열
 * @---------------------------------------------------
 */
function Trim()
{
   var vStartPoint = 0;             // subString 하기 위한 시작 포인트
   var vEndPoint   = this.length;   // subString 하기 위한 끝 포인트

   //문자열앞에 공백문자가 들어 있는 Index 추출
   while( (vStartPoint < vEndPoint) && (this.charCodeAt(vStartPoint) == 32) )
   {
      vStartPoint++;
   }

   //문자열뒤에 공백문자가 들어 있는 Index 추출
   while( (vStartPoint < vEndPoint) && (this.charCodeAt(vEndPoint-1) == 32) )
   {
      vEndPoint--;
   }
   // 공백을 제거했으면 subString하여 결과문자열을 리턴하고 제거한 내용이 없으면 그대로 리턴
   return ( (vStartPoint > 0) || (vEndPoint < this.length) ) ? this.substring(vStartPoint, vEndPoint) : this;
}


/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열의 Byte 크기가 제한값을 벗어나는지 체크 (벗어나면 false 리턴)
 * @param  : pSize - 제한크기
 * @return : TRUE or FALSE
 * @---------------------------------------------------
 */
function CheckByteSize(pSize)
{
   if(this.GetByteSize() <= eval(pSize)) return true;
   return false;
}


/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 값이 없는지 체크
 * @param  : N/A
 * @return : TRUE or FALSE
 * @---------------------------------------------------
 */
function CheckEmpty()
{
   if(this.Trim() == "")
   {
      return false;
   }
   return true;   // 공백이 아니라면

}


/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열중의 특정 문자 또는 단어를 찾아 원하는 문자 또는 단어로 치환
 * @param  : pOldStr - 찾을 단어   pNewStr - 대체 단어
 * @return : 대체하고난 문자열
 * @---------------------------------------------------
 */
function ReplaceString(pOldStr, pNewStr)
{
   var vTempArray;
   var vReturnString = "";

   vTempArray = this.split(pOldStr);

   for(var i=0; i<vTempArray.length-1; i++)
   {
      vReturnString += vTempArray[i] + pNewStr;
   }

   vReturnString += vTempArray[vTempArray.length-1];

   return vReturnString;
}


/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열 앞에 있는 공백 제거
 * @param  : N/A
 * @return : 공백을 제거한 결과 문자열
 * @---------------------------------------------------
 */
function TrimLeft()
{
   var i, j = 0;


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

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

/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열 뒤에 있는 공백 제거
 * @param  : N/A
 * @return : 공백을 제거한 결과 문자열
 * @---------------------------------------------------
 */
function TrimRight()
{

   var i, j = 0;

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

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



/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열을 모두 소문자로 변환
 * @param  : N/A
 * @return : 문자열
 * @---------------------------------------------------
 */
function ToLower()
{
   return this.toLowerCase();
}


/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열을 모두 대문자로 변환
 * @param  : N/A
 * @return : 문자열
 * @---------------------------------------------------
 */
function ToUpper()
{
   return this.toUpperCase();
}

/**
 * @group  : String 확장
 * @ver    : 2004.07.29 (KUHDEV-0002)
 * @by     : LeeHJ.
 * @---------------------------------------------------
 * @type   : function
 * @access : public
 * @desc   : 문자열의 길이를 구한다.
 * @param  : N/A
 * @return : 문자열의 길이
 * @---------------------------------------------------
 */
function GetLength()
{
   return this.length;
}

/**
 * @type   : function
 * @access : public
 * @desc   : 주어진 값이 null인지 확인한다.
 *    <pre>
 *        IsNull();
 *    </pre>
 * @sig    : value
 * @param  : value   - null 체크할 값  
 * @return : boolean - true/false
 */
function IsNull() {
	
    if(this.indexOf("_") != -1) {
    	return false;
    }

	var oMsg=null,bNull=true;
		if(this.indexOf("_") == -1) 
	    return false;

	try {
		oMsg = eval("window."+this);
		bNull = (typeof oMsg == 'undefined')?true:false;
	} catch(e) {
		if(e =='[object Error]') {
			try {
				oMsg = eval(this);
				if(oMsg != null) bNull = false;
			} catch (e) {
				bNull = true;
			}
	    } else
	    	bNull = false;
	}
	
	return bNull;
}

/*  
 * @type   : function
 * @access : public
 * @desc   : 금액을 한글금액으로 변경
 *    <pre>
 *        var amtNm = commamtToHangleName(amt);
 *    </pre>
 * @sig    : amt
 * @param  : amt    - 한글로 바꿀 금액 
 * @return : string - 한글금액
 */ 
function AmtToHangleName() {
	var amt = this;
	var unitNm = ["천","백","십","조","천", "백","십","억","천","백","십","만","천","백","십","원"] ;
	var numNm = ["","일","이","삼","사","오","육","칠","팔","구"];
	var amtNm = "";
	
	for ( var i = 0 ; i < amt.length ; i++ ){
		var num = numNm[amt.charAt(i)] ;
		var idx = unitNm.length - amt.length + i ;
		if ( num != "" || (idx+1)/4 == Math.ceil((idx+1)/4 )) {
			amtNm += num + unitNm[idx] ;
		}						
	}					
	return amtNm; //+ "정";
}

/***************************************************************************************************************/
/* 4 . Validation 관련 함수 시작
/*
/* 1)   commIsValidMonth    :  유효한(존재하는) 월(月)인지 체크.                      
/* 2)   commIsValidHour     :  유효한(존재하는) 시(時)인지 체크.                      
/* 3)   commIsValidMin      :  유효한(존재하는) 분(分)인지 체크.                      
/* 4)   commIsValidSecond   :  유효한(존재하는) 초(秒)인지 체크.                      
/* 5)   commGhkCal          :  날짜를 입력받는 input 컨트롤의 유효성 검사.            
/* 6)   commGhkMonth				: 	월을 입력받는 input 컨트롤의 유효성 검사              
/* 7)   commGhkTerm         :  날짜를 입력받는 from~to input 컨트롤의 유효성 검사     
/* 8)   commGhkDateHM       :  날짜형(일자와 시간, 분) input 컨트롤의 유효성 검사      
/* 9)   commGhkDateHMS      :  날짜형(일자와 시간, 분, 초) input 컨트롤의 유효성 검사 
/* 10)  commIsNull					:  주어진 값이 null인지 확인한다.                               
/* 11)  commCheckRrnoVal 	  :  주민번호 유효성 체크                                    
/* 12)  commCheckBrnoVal		:  사업자 등록번호 유효성 체크                           
/* 13)  commCheckCrnoVal    :  법인번호 유효성 체크                                   
/* 14)  commValidateTelNo   :  전화번호의 validation을 확인한다.                      
/* 15)  commValidateEmail   :  이메일주소의 validation을 확인한다.                    
/* 16)
/* 17) 

/************************************************************************************/	
    

/**
 * @type   : function
 * @access : public
 * @desc   : 유효한(존재하는) 월(月)인지 체크.
 *    <pre>
 *        if (!commIsValidMonth("12"))
 *    </pre>
 * @sig    : mm
 * @param  : mm - 체크할 월
 * @return : boolean - 유효여부
 */ 
function commIsValidMonth(mm) {
    var m = parseInt(mm,10);
    return (m >= 1 && m <= 12);
}



/**
 * @type   : function
 * @access : public
 * @desc   : 유효한(존재하는) 시(時)인지 체크.
 *    <pre>
 *        if (!commIsValidHour("12")) 
 *    </pre> 
 * @sig    : hh
 * @param  : hh - 체크할 시
 * @return : boolean  유효여부
 */ 
function commIsValidHour(hh) {
    var h = parseInt(hh,10);
    return (h >= 0 && h <= 23);
}


/**
 * @type   : function
 * @access : public
 * @desc   : 유효한(존재하는) 분(分)인지 체크.
 *    <pre>
 *        if (!commIsValidMin("12")) 
 *    </pre> 
 * @sig    : mi
 * @param  : mi      - 체크할 분  
 * @return : boolean - 유효여부
 */ 
function commIsValidMin(mi) {
    var m = parseInt(mi,10);
    return (m >= 0 && m <= 59);
}


/**
 * @type   : function
 * @access : public
 * @desc   : 유효한(존재하는) 초(秒)인지 체크.
 *    <pre>
 *        if (!commIsValidSecond("12")) 
 *    </pre> 
 * @sig    : ss
 * @param  : ss      - 체크할 초
 * @return : boolean - 유효여부
 */
function commIsValidSecond(ss) {
    var m = parseInt(ss,10);
    return (m >= 0 && m <= 59);
}
 
/**
 * @type   : function
 * @access : public
 * @desc   : 날짜를 입력받는 input 컨트롤의 유효성 검사.
 *    <pre>
 *        if (!commGhkCal("/root/input_date")) 
 *    </pre> 
 * @sig    : chkRef
 * @param  : chkRef  - 체크할 control의 ref
 * @return : boolean - 유효여부
 */ 
function commGhkCal( chkRef ) {
    var s = model.getValue(chkRef);
    if ( s.length < 8 ) return false;
    
    var iYear = s.substr(0,4);
    var iMonth = s.substr(4,2);
    var iDay = s.substr(6,2);
    var monthArr = new Array(31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31);
    
    if( iMonth == 2 ) {
    	if ( ( (iYear % 4 == 0) && (iYear % 100 != 0) ) || (iYear % 400 == 0) ) {
    		monthArr[1] = "29";
    	}
    }
    
    if( iYear < 9999 && iYear > 0 && iMonth <= 12 && iMonth > 0 && iDay <= monthArr[iMonth-1] && iDay > 0 ) {
    	return true;
    }
    
    return false;
}



/**
 * @type   : function
 * @access : public
 * @desc   : 월를 입력받는 input 컨트롤의 유효성 검사     
 *    <pre>
 *        if (!commchkMonth("/root/input_month")) 
 *    </pre>
 * @sig    : chkRef
 * @param  : chkRef  - 체크할 input의 Ref  
 * @return : boolean - 유효여부
 */
function commGhkMonth( chkRef ) {
    var s = model.getValue(chkRef);
    if ( s.length < 6 ) return false;
    
    var iYear = s.substr(0,4);
    var iMonth = s.substr(4,2);
    
    if( iYear < 9999 && iYear > 0 && iMonth <= 12 && iMonth > 0 ) {
    	return true;
    }
    
    return false;
}

/**
 * @type   : function
 * @access : public
 * @desc   : 날짜를 입력받는 from~to input 컨트롤의 유효성 검사    
 *    <pre>
 *        if (!commchkTerm( "/root/inputFrom", "/root/inputTo" )) 
 *    </pre>
 * @sig    : chkRefFrom, chkRefTo
 * @param  : chkRefFrom  - 체크할 inputFrom의 Ref  
 * @param  : chkRefTo    - 체크할 inputTo의 Ref  
 * @return : boolean     - 유효여부
 */
function commGhkTerm( chkRefFrom, chkRefTo ) {

	var rtnVal = false;
	
	if ( commGhkCal(chkRefFrom) && commGhkCal(chkRefTo) ) {
		if ( model.getValue(chkRefFrom) <= model.getValue(chkRefTo) ) {
			rtnVal = true;
		}
	}
    return rtnVal;
}



/**
 * @type   : function
 * @access : public
 * @desc   : 날짜형(일자와 시간, 분) input 컨트롤의 유효성 검사    
 *    <pre>
 *        if (!commchkDateHM("/root/inputDate")) 
 *    </pre>
 * @sig    : chkRef
 * @param  : chkRef  - 체크할 inputFrom의 Ref  
 * @return : boolean - 유효여부
 */
function commGhkDateHM( chkRef ) {
	var rtnVal = false;
    var s = model.getValue(chkRef);
    if ( s.length < 12 ) return false;
    
	var iHour = s.substr(8,2); 
	var iMin  = s.substr(10,2); 
	
	if ( commGhkCal( chkRef ) && commIsValidHour(iHour) && commIsValidMin(iMin) ) {
		rtnVal = true ;
	}
	
    return rtnVal;
}

/**
 * @type   : function
 * @access : public
 * @desc   : 날짜형(일자와 시간, 분, 초) input 컨트롤의 유효성 검사    
 *    <pre>
 *        if (!commchkDateHMS("/root/inputDate")) 
 *    </pre>
 * @sig    : chkRef
 * @param  : chkRef  - 체크할 inputFrom의 Ref  
 * @return : boolean - 유효여부
 */
function commGhkDateHMS( chkRef ) {
	var rtnVal = false;
    var s = model.getValue(chkRef);
    if ( s.length < 14 ) return false;
    
	var iHour = s.substr(8,2); 
	var iMin  = s.substr(10,2); 
	var iSec  = s.substr(12,2); 
	
	if ( commGhkCal( chkRef ) && commIsValidHour(iHour) && commIsValidMin(iMin) && commIsValidSecond(iSec) ) {
		rtnVal = true ;
	}
	
    return rtnVal;
}



/**
 * @type   : function
 * @access : public
 * @desc   : 주민번호 유효성 체크 
 *    <pre>
 *        commcheckRrnoVal("6601011234567");
 *    </pre>
 * @sig    : val
 * @param  : val     - 체크할 주민등록번호값
 * @return : boolean - 유효여부
 */
function commCheckRrnoVal(val) {
	if ( val.length < 13 ) {
		alert("주민등록번호의 자릿수가 잘못 입력되었습니다.");
		return false;
	}
	
	var varCk1 = val.substring(0,6);
	var varCk2 = val.substring(6);

	var ckValue = new Array(13);
	var ckLastid,ckMod,ckMinus,ckLast;

	ckLastid    = parseFloat(varCk2.substring(6,7));
	ckValue[0]  = parseFloat(varCk1.substring(0,1))  * 2;
	ckValue[1]  = parseFloat(varCk1.substring(1,2))  * 3;
	ckValue[2]  = parseFloat(varCk1.substring(2,3))  * 4;
	ckValue[3]  = parseFloat(varCk1.substring(3,4))  * 5;
	ckValue[4]  = parseFloat(varCk1.substring(4,5))  * 6;
	ckValue[5]  = parseFloat(varCk1.substring(5,6))  * 7;
	ckValue[6]  = parseFloat(varCk2.substring(0,1))  * 8;
	ckValue[7]  = parseFloat(varCk2.substring(1,2))  * 9;
	ckValue[8]  = parseFloat(varCk2.substring(2,3))  * 2;
	ckValue[9]  = parseFloat(varCk2.substring(3,4))  * 3;
	ckValue[10] = parseFloat(varCk2.substring(4,5))  * 4;
	ckValue[11] = parseFloat(varCk2.substring(5,6))  * 5;
	ckValue[12] = 0;

	for (var i = 0; i<12;i++) {
		ckValue[12] = ckValue[12] + ckValue[i];
	}
	ckMod   = ckValue[12] %11;
	ckMinus = 11 - ckMod;
	ckLast  = ckMinus % 10;
	if (ckLast != ckLastid) {
		alert ("잘못된 주민등록번호입니다. 다시 확인해 주십시오");
		return false;
	} else {
		return true;
	}
}


/**
 * @type   : function
 * @access : public
 * @desc   : 사업자 등록번호 유효성 체크 
 *    <pre>
 *        commcheckBrnoVal("1231212345");
 *    </pre>
 * @sig    : val
 * @param  : val     - 체크할 사업자 등록번호
 * @return : boolean - 유효여부
 */
function commCheckBrnoVal(val) {
	
	if ( val.length < 10 ) {
		alert("사업자등록번호의 자릿수가 잘못 입력되었습니다.");
		return false;
	}
	
	var varCk1 = val.substring(0,3);
	var varCk2 = val.substring(3,5);
	var varCk3 = val.substring(5);

	var ckValue = new Array(10);
	
	ckValue[0] = ( parseFloat(varCk1.substring(0 ,1))  * 1 ) % 10;
	ckValue[1] = ( parseFloat(varCk1.substring(1 ,2))  * 3 ) % 10;
	ckValue[2] = ( parseFloat(varCk1.substring(2 ,3))  * 7 ) % 10;
	ckValue[3] = ( parseFloat(varCk2.substring(0 ,1))  * 1 ) % 10;
	ckValue[4] = ( parseFloat(varCk2.substring(1 ,2))  * 3 ) % 10;
	ckValue[5] = ( parseFloat(varCk3.substring(0 ,1))  * 7 ) % 10;
	ckValue[6] = ( parseFloat(varCk3.substring(1 ,2))  * 1 ) % 10;
	ckValue[7] = ( parseFloat(varCk3.substring(2 ,3))  * 3 ) % 10;
	ckTemp     = parseFloat(varCk3.substring(3 ,4))  * 5  + "0";
	ckValue[8] = parseFloat(ckTemp.substring(0,1)) + parseFloat(ckTemp.substring(1,2));
	ckValue[9] = parseFloat(varCk3.substring(4,5));
	ckLastid = ( 10 - ( ( ckValue[0]+ckValue[1]+ckValue[2]+ckValue[3]+ckValue[4]+ckValue[5]+ckValue[6]+ckValue[7]+ckValue[8] ) % 10 ) ) % 10;
	if (ckValue[9] != ckLastid) {
		alert ("잘못된 사업자등록번호입니다. 다시 확인해 주십시오");
		return false;
	} else {
		return true;
	}
}


/**
 * @type   : function
 * @access : public
 * @desc   : 법인번호 유효성 체크 
 *    <pre>
 *        commCheckCrnoVal("1231212345");
 *    </pre>
 * @sig    : varCk
 * @param  : varCk   - 체크할 법인번호
 * @return : boolean - 유효여부
 */
function commCheckCrnoVal(varCk) {
	
	if ( varCk.length < 13 ) {
		alert("법인번호의 자릿수가 잘못 입력되었습니다.");
		return false;
	}

	var checkNum = new Array("1","2","1","2","1","2","1","2","1","2","1","2");

	//등기관서별 분류번호, 법인종류별 분류번호 및 일련번호를 차례로 연결한 12자리
	//의 숫자를 만든다.
	var newNum = new Array();
	for(var i = 0; i < varCk.length -1; i++)
		newNum[i] = varCk.charAt(i);

	//각 숫자에 차례로 1과 2를 곱한 다.값을 모두 더하여 합을 구한다.
	var multiNum = new Array();
	for(var k = 0; k < newNum.length; k++)
		multiNum[k] = checkNum[k] * newNum[k];

	//alert("각 숫자에 차례로 1과 2를 곱한 다: "+ multiNum[11]);
	//곱한 값을 모두 더하여 합을 구한다.
	var addNum = 0;
	for(var y = 0; y < multiNum.length; y++)
		addNum = addNum + Number(multiNum[y]);

	//alert("곱한 값을 모두 더하여 합을 구한다: "+ addNum);
	//합을 10으로 나누어 몫과 나머지를 구한다.
	var remainder;
	var quota;
	remainder = Number(addNum) % 10;
	quota = Number(addNum) / 10;
	//10에서 나머지를 뺀 값을 오류검색번호로 한다. 다만, 10에서 나머지를 뺀 값이
	//10인 때에는 0을 오류검색번호로 한다.
	var failCheckNum;
	if( (10 - Number(remainder)) == 10 )
	{
		failCheckNum = 0;
	}
	else
	{
		failCheckNum = 10 - Number(remainder);
	}
	//alert("오류검색번호: "+ failCheckNum);
	if(failCheckNum != varCk.charAt(12)) {
		alert ("잘못된 법인번호입니다. 다시 확인해 주십시오");
		return false;
	}
	return true;

}



/**
 * @type   : function
 * @access : public
 * @desc   : 전화번호의 validation을 확인한다.
 *    <pre>
 *         commvalidateTelNo("12-232-2323");
 *    </pre>
 * @sig    : tel
 * @param  : tel     - 전화번호
 * @return : boolean - 유효?
 */
function commValidateTelNo(tel) {  
    var re = new RegExp("^([0-9]{2,4})(-[0-9]{3,4})(-[0-9]{3,4})","g");
    var resultFind = re.exec(tel);
    return resultFind==null?false:true;
}


/**
 * @type   : function
 * @access : public
 * @desc   : 이메일주소의 validation을 확인한다.
 *    <pre>
 *         commvalidateEmail("doog@moe.com");
 *    </pre>
 * @sig    : tel
 * @param  : tel     - 전화번호
 * @return : boolean - 유효?
 */
function commValidateEmail(email) {
    var re = new RegExp("([\.a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(([a-zA-Z0-9_-])*\.([a-zA-Z0-9_-])+)+");
    var resultFind = re.exec(email);
    return resultFind==null?false:true;
}




/*******************************************************************************************/
/* 5. 날짜관련 및 기타 함수  
/* 
/* 1)  commCurDate      :  현재날짜가져오기(( y-년, m-월, d-일  ym -년월 등)포맷지정가능
/* 2)  commLastDay      :  해당년월의 마지막 날짜를 구해온다.예)199802->28일 , 200002->29일      
/* 3)  commGetDay				:  yyyyMMdd 형식의 일자를 받아서 요일을 리턴해줌 
/* 4)  commCurDTime     :  현재날짜 + 시간 가져오기
/* 5)  commFirstDay			:  현재달의 첫번째 일을 가져오는 매소드
/* 6)  commLateDate     :  현재날자로 부터 정해진 지난날 가져오는 매소드        
/* 7)
/* 8)
/*******************************************************************************************/					


/**
 * @type   : function
 * @access : public
 * @desc   : getDate날짜 가져오기( y-년, m-월, d-일  ym -년월 등)
 *    <pre>
 *        if ( commgetStringLength(str) > lgth ) 
 *    </pre>
 * @sig    : str
 * @param  : str     - 문자열
 * @return : int     - 문자열의 byte수
 */
function commCurDate(optSetting){
	  var dte, c_dte="",month;   // 화면의 Calendar 에 월초와  현재 날자를 Setting 한다
	  var c_year,c_month,c_day
	  dte = new Date();

	  month = (dte.getMonth() + 1)+"" ;
	  
	  c_year = dte.getYear();

	  if(month.length==1)
	  {                         
		c_month = "0"+(dte.getMonth() + 1 ); 
	  }
	  else 
	  {
		c_month  = (dte.getMonth() + 1 ); 
	  }

	  var d_ay = dte.getDate()+"";

	  if(d_ay.length == 1)
	  {                         
		c_day= "0"+(dte.getDate()); 
	  }
	  else 
	  {
		c_day = (dte.getDate()); 
	  }

	  //년월일 구하기
	  if(optSetting == "ymd" || optSetting == "" || optSetting == null)
	  {
		 c_dte =  c_year + "" +c_month +""+ c_day;
	  }//<end> if(optSetting == "ymd")		
	  else if(optSetting == "ym")
	  {
		 c_dte = c_year +""+ c_month;
	  }//<end> else if(optSetting == "ym")		
	  else if(optSetting == "y")
	  {
		  c_dte = c_year;
	  }
	  else if(optSetting == "m")
	  {
		  c_dte = c_month;
	  }
	  else if(optSetting == "d")
	  {
		  c_dte = c_day;
	   }
	  else
	  {
		  c_dte = false;
	  }

	  return c_dte;
}

//해당년월의 마지막 날짜를 구해온다.예)199802->28일 , 200002->29일
function commLastDay(date){
	
	var ny = date.substring(0,4);
	var nm = date.substring(4,6);
	nm = eval(nm);
									
	var arr_d = new Array('31','28','31','30','31','30','31','31','30','31','30','31');

	if(((ny % 4 == 0)&&(ny % 100 !=0)) || (ny % 400 == 0)){
		arr_d[1] = 29;
	}

	return arr_d[nm-1];

}

/**
 * @type   : function
 * @access : public
 * @desc   : yyyyMMdd 형식의 일자를 받아서 요일을 리턴해줌   
 *    <pre>
 *        var day = commgetDay("20061231");
 *    </pre>
 * @sig    : yyyyMMdd
 * @param  : yyyyMMdd  - 요일로 변환할 일자
 * @return : day       - 요일
 */
function commGetDay(yyyyMMdd)
{
	var week = new Array("일", "월", "화", "수", "목", "금", "토");
	if ( yyyyMMdd.length != 8 ) return;
	var year = yyyyMMdd.substring(0,4);
	var month = yyyyMMdd.substring(4,6);
	var date = yyyyMMdd.substring(6);
	var day = new Date(parseInt(year),parseInt(month)-1,parseInt(date));
	return week[day.getDay()];
}


function commDiffDay(time1,time2)

{
	var 	t1 = Date.UTC(time1.substring(0,4), time1.substring(4,6), time1.substring(6));
	var 	t2 = Date.UTC(time2.substring(0,4), time2.substring(4,6), time2.substring(6));

	var d, r,   t3;
	var MinMilli = 1000 * 60
	var HrMilli = MinMilli * 60
	var DyMilli = HrMilli * 24
 
	t3 = t2 - t1;
	r = Math.round(t3 / DyMilli);

	return r;

}



/*-----------------------------------------------------------------------------------
 * NAME  : f_getDTime()
 * DESC  : 현재날짜+시간을 가져오는 매소드               
 * PARAM :     
 * DATE  : 2006.05.10 11:38                          
 * AUTH  : wooks
 *----------------------------------------------------------------------------------*/
function commCurDTime(){

		 var now = new Date();
		 var hour = now.getHours();
		 var minute = now.getMinutes();
		 var seconds = now.getSeconds();
		 var ampm;
		 now = null;
		
		 if (hour >= 12) { 
		  hour = hour - 12;
		  ampm = "오후";
		 } 
		 else 
		  ampm = "오전";
		
		 hour = (hour == 0) ? 12 : hour;
		
		 if (minute < 10) 
		  minute = "0" + minute;
		 if (seconds < 10) 
		  seconds = "0" + seconds;
		   
		  
		return hour + ":" + minute + ":"+seconds;
		// return ampm+" "+hour + ":" + minute + ":"+seconds;
}

/*-----------------------------------------------------------------------------------
 * NAME  : commFirstDay()
 * DESC  : 현재달의 첫번째 일을 가져오는 매소드
 * PARAM :     
 * DATE  : 2006.05.10 11:38                          
 * AUTH  : 
 *----------------------------------------------------------------------------------*/
function commFirstDay(){
	var curDate = "";
	var d = new Date();
	var monString = (d.getMonth() + 1)+"";
	var dateString ="01";

	if(monString.length == 1){
		monString = "0" + monString;
	}
	
	curDate += d.getYear();
	curDate += monString;
	curDate += dateString;

	return curDate;
}

/*-----------------------------------------------------------------------------------
 * NAME  : commLateDate()
 * DESC  : 현재날자로 부터 정해진 지난날 가져오는 매소드               
 * PARAM :     
 * DATE  : 2006.05.10 11:38                          
 * AUTH  : wooks
 *----------------------------------------------------------------------------------*/
	function commLateDate(ldate){
		
		ldate =(typeof ldate == 'string')? Number(ldate) : ldate;						
		var curDate = "";
		var d = new Date;
		d.setDate(d.getDate( ) + ldate);
		var monString = (d.getMonth() + 1)+"";
		var dateString = d.getDate()+"";
		if(monString.length == 1){
			monString = "0" + monString;
		}
		if(dateString.length == 1){
			dateString = "0"+ dateString;
		}
		curDate += d.getYear();
		curDate += monString;
		curDate += dateString;

	return curDate;
}