YNU_JEUS/app_home/himed/xpapps/emr/medirecxp/xp/MMRBind.xjs

<?xml version="1.0" encoding="utf-8"?>
<Script type="xscript4.0"><![CDATA[/***************************************************************************************  
 * System Name		:	DBS
 * Job Name 		:	
 * File Name 		:	MMRBind.xjs
 * Creator 	    	:	
 * Make Date 		:	2015.02.02
 *                                                                                        
 * Description  	:	                                                                   
 *--------------------------------------------------------------------------------------- 
 * Modify Date     	Modifier  	Modify Description                                     
 *--------------------------------------------------------------------------------------- 
 *            
 *                                                                                        
 *--------------------------------------------------------------------------------------- 
*/
var strConcat = new String("");

/**********************************************************************************
 * Method Name  : lf_calculateInit
 * Description  : 서식로드시 산술식, Readonly 기능 초기화
 * argument     : 
 * return Type  : 
 * Creator 	    : 
**********************************************************************************/
function lf_calculateInit()
{
utlf_addLog("***** lf_calculateInit() *****");
	if(isValidObject("ds_bind") && ds_bind.getRowCount() > 0)
	{

		var vRow;
		var vCompID;
		var vReadonly;
		var vCalculate;
		var vResult;
	
		var vSSUs;
		var vSSUdiv;
		
		var vDs = this.objects["ds_data_itemvalue"];
		dsf_createDs("ds_tempItemValue");
		ds_tempItemValue.copyData(ds_data_itemvalue);
		
		//산술식 계산 전(ds_bind에 선언된 componentid 중 RDO가 들어가는 것에 대해서만 처리) RDO초기값 세팅
		//lf_initRdoVal("ds_bind");
		if(fGetFormRec("status") == "C")
		{
			//Step 0. 산술식 계산 준비
			for(i=0; i<ds_bind.getRowCount(); i++)
			{
				if(!utlf_isNull(ds_bind.getColumn(i, "calculate")))
				{
					var vResultTemp = "";
					
					
					vCompID = ds_bind.getColumn(i, "componentid");
					var  vCalculateDs = ds_bind.getColumn(i, "calculate");
					
					if(vCalculateDs.indexOf("concat") > -1 && vCalculateDs.indexOf("strConcat.concat") == -1)
					{
						vCalculateDs = vCalculateDs.replace("concat", "strConcat.concat");
						ds_bind.setColumn(i, "calculate", vCalculateDs);
					}
					
					// ceiling 처리
					if(vCalculateDs.indexOf("ceiling") > -1 && vCalculateDs.indexOf("Math.ceil") == -1)
					{
						vCalculateDs = vCalculateDs.replace("ceiling", "Math.ceil");
						ds_bind.setColumn(i, "calculate", vCalculateDs);
					}
					
					// floor 처리
					if(vCalculateDs.indexOf("floor") > -1 && vCalculateDs.indexOf("Math.floor") == -1)
					{
						vCalculateDs = vCalculateDs.replace("floor", "Math.floor");
						ds_bind.setColumn(i, "calculate", vCalculateDs);
					}
					
					// round 처리
					if(vCalculateDs.indexOf("round") > -1 && vCalculateDs.indexOf("Math.round") == -1)
					{
						vCalculateDs = vCalculateDs.replace("round", "Math.round");
						ds_bind.setColumn(i, "calculate", vCalculateDs);
					}
					
					// power 처리
					if(vCalculateDs.indexOf("power") > -1 && vCalculateDs.indexOf("Math.pow") == -1)
					{
						vCalculateDs = vCalculateDs.replace("power", "Math.pow");
						ds_bind.setColumn(i, "calculate", vCalculateDs);
					}
					
					var vChangeEquls = lf_getChangeEquls(i);
					
					try
					{

						//Step 1. 산술식 계산
						vCalculate = fn_nvl(vChangeEquls);					
						vResult = eval(vCalculate);
						//Step 2. 계산값 적용함수
						//sysf_trace(vCompID + " : 1. vCompID -> " + vResult);
						vResultTemp = lf_setCalResult(vCompID, vResult, vCalculateDs);
						
						//sysf_trace(vCompID + " : 1. vCompID  ******************************* lf_setCalResult-> " + vResultTemp);
						var vFcompIDcompare = ds_bind.getColumn(i, "calculate");
						if(vFcompIDcompare.indexOf("CAL_") > -1)
						{
							var calCheck = lf_calCal(vFcompIDcompare);
							
							if(!utlf_isNull(calCheck) && calCheck != "noCal")
							{
								vResultTemp = calCheck;
							}
							else if(!utlf_isNull(calCheck) && calCheck == "noCal")
							{
								
							}
							else
							{
								vResultTemp	= null;
							}
						}
						
						if(vResultTemp == 0 && !(vCalculateDs.indexOf("-") >-1) && !(vCalculateDs.indexOf("+") >-1) && !(vCalculateDs.indexOf("/") >-1) && !(vCalculateDs.indexOf("*") > -1))
						{
							//vResultTemp = "";
						}
						
						if((vResultTemp.toString().indexOf("nonevalue") > -1 || vResultTemp.toString().indexOf("undefined") > -1) &&             
							vFcompIDcompare.indexOf("concat") > -1)
						{
							vResultTemp = vResultTemp.replace("nonevalue" ,"");
							vResultTemp = vResultTemp.replace("undefined" ,"");
						}
						
						//삼항연산자 ''에 대한 처리
						if(vCompID.indexOf("RDO_") > -1 && vCalculateDs.indexOf("?") == -1 && vResult == 0)
						{
							vResultTemp="";
							this.components[vCompID].ufn_initComp();	
							
						}
						else
						{
							//삼항연산자 && RDO가 아닌경우
						}
						ds_tempItemValue.setColumn(0,vCompID,vResultTemp);
						
						strConcat = "";
						
					}
					catch(e)
					{
						sysf_trace("산술식 오류 : " + e + ", vCompID : " + vCompID);
						sysf_catchTrace(e);
					}
						
				}
			}
			//ds_tempItemValue 세팅 끝
			//value 값 세팅 
			for(var j=0; j < ds_tempItemValue.getColCount(); j++)
			{
				var vColNm = ds_tempItemValue.getColID(j);
				var vDsVal = ds_tempItemValue.getColumn(0, vColNm);

				//bol, rdo(composite), stx만 고려
				if(vColNm.indexOf("BOL") !=-1 && vColNm.indexOf("EXTN") == -1)
				{
					this.components[vColNm].value = vDsVal;
				}
				else if(vColNm.indexOf("RDO") !=-1 && !utlf_isNull(vDsVal) && vColNm.indexOf("EXTN") == -1)
				{
					this.components[vColNm].setData(vDsVal);
				}
			
			}

			//임시 데이터셋 복사 
			ds_data_itemvalue.assign(ds_tempItemValue);
			ds_data_itemvalue.enableevent = false;
			for(h = 0; h < ds_data_itemvalue.colcount; h++)
			{
				var ColId =  ds_data_itemvalue.getColID(h);
				if(!utlf_isNull(ColId))
				{
					lf_setRecDS(ColId);	// MMRCommon
					if(ColId.indexOf("RDO_") != -1)
					{
						try
						{
							var grupcd = eval(ColId).grupcd;
							if(!utlf_isNull(grupcd))
							{
								var dsNm = "ds_data_V_"+ grupcd;
								var ColNo = ColId.replace("RDO_", "");
								var sVal = ds_data_itemvalue.getColumn(0, ColId);
								var sLabel = eval(dsNm).lookup("termbasecd", sVal, "valitemnm");
								var nRow = ds_data_recitem.findRowExpr("degnitemno == '"+ ColNo +"' && degnitemkind == 'RDO'");
								ds_data_recitem.setColumn(nRow, "rectermnm", sLabel);						
							}
						}
						catch(e)
						{
							sysf_trace("산술식 오류 : " + e + ", ColId : " + ColId);
							sysf_catchTrace(e);
						}
					}
				}
			}
			ds_data_itemvalue.enableevent = true;

		}
	

		/*****************************************************************************************************/
		/* 산술식 연산 끝
		/* Readonly는 ds_data_itemvalue value를 통해 작동하기 때문에 산술식을 통해 ds_data_itemvalue값을 채우고 
		/* 그후 Readonly기능에 대한 반복실행하여 구현
		/*****************************************************************************************************/
		
		for(k=0; k<ds_bind.getRowCount(); k++)
		{	
			if(!utlf_isNull(ds_bind.getColumn(k, "readonly")))
			{
				vCompID = ds_bind.getColumn(k, "componentid");
				vChangeEquls = ds_bind.getColumn(k, "readonly");
				//var vChangeEquls = ds_bind.getColumn(i, "calculate");
				vSSUs = "";
				vSSUdiv ="";
					
				if(vChangeEquls.indexOf("')='") > 0)
				{
					vChangeEquls = vChangeEquls.replace("')='", "')=='"); 		
				}
				
				vReadonly = fn_nvl(vChangeEquls);
				
				try
				{
					//Step 0. Readonly 연산
					vResult = eval(vReadonly);
					
					//sysf_trace("Readonly 초기화 결과 : " + vCompID + " / " + vResult);
					//Step 1. 연산결과 값 적용준비
					if(vCompID.indexOf("SL") > -1)
					{//SSL, MSL류
						vSSUs = ds_bind.getColumn(k, "supitem");
						vSSUdiv = vSSUs.split(",");	
					}
					//composite는 readonly기능이 없으므로, enable을 사용하여 처리한다.
					var vChkComp = new String(this.components[vCompID])

					//Step 2. 연산 결과 적용
					lf_applyReadOnly(vCompID, vChangeEquls, vResult, vChkComp, vSSUdiv);
					
					//Step 3. 확장 컨트롤 처리
					if(!utlf_isNull(this.components[vCompID]))
					{
						lf_changeEnable(this.components[vCompID]);
					}
				}
				catch(e)
				{
					sysf_trace("산술식 오류 : " + e + ", vCompID : " + vCompID);
					sysf_catchTrace(e);
				}

			}
		}
	}
}


/**********************************************************************************
 * Method Name  : lf_sslEnable
 * Description  : SSL의 SSU에 대한 enable true, false value를 부여 
 * argument     : vSSUdiv - SSU들의 집합(array), value - true or false
 * return Type  : 
 * Creator 	    : 
**********************************************************************************/
function lf_sslEnable(vSSUdiv, value)
{	
utlf_addLog("***** lf_sslEnable("+vSSUdiv+", "+value+") *****");
	for(var i=0; i<vSSUdiv.length; i++)
	{
	
		//산술식내의 해당 components가 없는 경우가 존재함
		if(!utlf_isNull(this.components[vSSUdiv[i]]))
		{
			this.components[vSSUdiv[i]]["enable"] = value;
			
			if(value == false)
			{
				this.components[vSSUdiv[i]].value = "";
			}
		}
		else
		{
		
		}

	}
}


/**********************************************************************************
 * Method Name  : lf_extnEnable
 * Description  : extn 처리 함수, SSL만 대상
 * argument     : vCol, vDs
 * return Type  : 
 * Creator 	    : 
**********************************************************************************/
function lf_extnEnable(vCol, vDs)
{
utlf_addLog("***** lf_extnEnable("+vCol+", "+vDs+") *****");
	//"SL"이 들어가는 component에 대한 extn 활성화 여부함수
	
	var vSup; 
	var vOrgCol = vCol;
	var vValue = "";
	var vSupTemp = "";
	var vCompID = "";
			
	if(vCol.indexOf("SL") > -1)
	{
		//vCol가 SSL, MSL인 경우
		vValue = vDs.getColumn(0, vCol);
		vCompID = vCol;
	}
	else
	{
		for(var i=0; i < vDs.getRowCount(); i++)
		{
			vCompID = vDs.getColID(i);
			if(vCompID == vCol)
			{
				vCompID = vCol;				
				break;
			}
			else
			{
				vCompID = "";
			}	
		}
	}
	
	if(utlf_isNull(vCompID))
	{
		vValue = lf_getSLValue(vCompID, vCol, vDs);
	}
	

	if(!utlf_isNull(vValue))
	{
		lf_setExtnEnable(vCol, vValue);
	}
	
}

/**********************************************************************************
 * Method Name  : lf_getSLValue
 * Description  : SSL의 value를 구하는 함수(lf_extnEnable의 서브함수)
 * argument     : vCompID, vCol, vDs
 * return Type  : vValue(string)
 * Creator 	    : 
**********************************************************************************/
function lf_getSLValue(vCompID, vCol, vDs)
{
utlf_addLog("***** lf_getSLValue("+vCompID+", "+vCol+", "+vDs+") *****");
	var vChekName="";
	var vSupTempset="";
	vSupTemp =  this.components[vCol]["supdegnitemno"];
	vChekName = new String(this.components[vCol]);
	
	if(vChekName.indexOf("Radio") > -1)
	{
		vSupTempset =	"SSL_" + vSupTemp;
	}
	else
	{
		vSupTempset = "MSL";
	}
	
	if(vSupTempset.indexOf("undefined")== -1 && !utlf_isNull(vSupTempset))
	{	
		if(vSupTempset == "MSL")
		{//MSL일 경우 사용안하는 것으로 적용
			vValue = "";
		}
		else
		{
			vValue = vDs.getColumn(0, vSupTempset);
		}
			
	}
	else
	{
		vValue = "";
	}
	
	return vValue;
	
}


/**********************************************************************************
 * Method Name  : lf_setExtnEnable
 * Description  : SSL 확장컨트롤에 대한 enable처리를 하는 함수(lf_extnEnable의 서브함수)
 * argument     : vCol, vValue
 * return Type  : N/A
 * Creator 	    : 
**********************************************************************************/
function lf_setExtnEnable(vCol, vValue)
{
utlf_addLog("***** lf_setExtnEnable("+vCol+", "+vValue+") *****");
	var vDsValue;
	var vExtnStx;
	var vNo;
	var vBool =false;
	var extnEnable;
	
	var vSup = this.components[vCol]["supdegnitemno"];
	
	for(var j=0; j < this.components.length; j++)
	{	
		
		if(!utlf_isNull(vSup) && !utlf_isNull(this.components[j]["supdegnitemno"]) && this.components[j]["supdegnitemno"] == vSup)
		{
			var vSSU =this.components[j].name;	
			vNo = vSSU.split("_"); //vNo[1];
			
			//ssu dataset
			var vDsSSU = new String("ds_"+vSSU);
			if(!utlf_isNull(this.objects[vDsSSU]))
			{
				vDsValue = this.objects[vDsSSU].getColumn(0, "termbasecd");
			}
			
			//extn stx
			var vSTX = new String("STX_"+vNo[1]);
			if(!utlf_isNull(this.components[vSTX]) && !utlf_isNull(this.components[vSTX]["ctrltype"]) 
			&& this.components[vSTX]["ctrltype"] == "extn")
			{
				vExtnStx = this.components[vSTX];
			}
			
			if(!utlf_isNull(vDsValue) && !utlf_isNull(vExtnStx))
			{
				if(vDsValue == vValue)
				{
					extnEnable = vExtnStx;
					vBool = true;
				}
				else
				{
					vExtnStx["enable"] = false;
					vExtnStx.value ="";
				}

			}

		}
	}
	
	if(vBool == true)
	{	
		extnEnable["enable"] = true;
	}
	extnEnable = "";
	vBool = false;
}

/**********************************************************************************
 * Method Name  : fReCalculate
 * Description  : 산술식 연산 함수 
 * argument     : fCompID
 * return Type  : N/A
 * Creator 	    : 
**********************************************************************************/
function fReCalculate(fCompID)
{
utlf_addLog("***** fReCalculate("+fCompID+") *****");
	var vRow;
	var fRef;
	var vCompID;
	var vRef;
	var vReadonly;
	var vCalculate;
	var vArr;
	var vDs;
	var vCol;
	var vResult;
	var vType;
	
	var vFcompID = new String(fCompID);	
 	var vDegnitempnts = new String(fCompID["degnitempnts"]);
 	var vSupdegnitemno = new String(fCompID["supdegnitemno"]);
	var vFcompIDName = new String(fCompID.name);

	if(ds_bind.getRowCount() > 0)
	{	
		//Step 0. 초기화
		if("init" == fCompID)
		{
		
		}
		else
		{
			vRow = ds_bind.findRow("componentid",fCompID.name);
			// findRow를 통해 상수로 값을 변환 없을 경우는 -1 반환, 첫번째 row일경우 1반환		 
			 if(vRow == -1)
			 {
				//ds_bind에 해당 값이 없음.
			 }
			 else
			 {			
				//vRow -= 1; 			
				fRef = ds_bind.getColumn(vRow,"ref");				   
			 }		 
		}
		
		//Step 1. 산술식 계산	
		for(i=0; i<ds_bind.getRowCount(); i++)
		{
			vResult ="";
			vCompID = ds_bind.getColumn(i, "componentid");
			vRef = ds_bind.getColumn(i, "ref");
			
			var vFcompIDcompare = new String(ds_bind.getColumn(i, "calculate"));
			
			vFcompIDName = lf_getCalid(fCompID, vFcompID, vSupdegnitemno);	
			var vCheckInSide = "fn_getInt('ds_data_itemvalue."+vFcompIDName+"')";		
			var vCheck = false;
		
 			if(ds_bind.getColumn(i, "componentid") == vFcompIDName)
 			{
 				vCheck = true;
 			}

			//&& vCompID != vFcompIDName
			//if(vCheck == true && !utlf_isNull(ds_bind.getColumn(i, "calculate")) && (vCompID != vFcompIDName
			//&& vFcompIDcompare.indexOf(vCheckInSide) > -1 || (!utlf_isNull(ds_bind.getColumn(i, "calculate")) && vFcompIDName.indexOf("STX") > -1 )))
			//if문 주석처리
			//
			if(((vCompID.indexOf("STX") > -1 && vCheck == false)  || (vCheck == false && vFcompIDcompare.indexOf(vCheckInSide) > -1 ))&& !utlf_isNull(ds_bind.getColumn(i, "calculate")))
			//if(!utlf_isNull(ds_bind.getColumn(i, "calculate")))
			{
				var vChangeEquls = ds_bind.getColumn(i, "calculate");
				// = 기호 처리
				
 				if(vChangeEquls.indexOf("')='") > 0)
 				{
 					vChangeEquls = vChangeEquls.replace("')='", "')=='"); 		
 				}
				
				//Bol값에 대한 판단일때 cal경우 체크된 상태를 0, readonly에서는 1로 판단하므로
				//cal일때도 1로 판단하도록 산술식변경 
				if(vChangeEquls.indexOf("fn_getInt('ds_data_itemvalue.BOL_") >0 && vChangeEquls.indexOf("='0'") > 0 )
				{
					vChangeEquls = vChangeEquls.replace("='0'", "='1'"); 		
				}
				
				// concat 처리
				if(vChangeEquls.indexOf("concat") > -1 && vChangeEquls.indexOf("strConcat.concat") == -1)
				{
					vChangeEquls = vChangeEquls.replace("concat", "strConcat.concat");
					ds_bind.setColumn(i, "calculate", vChangeEquls);
				}
				
				// ceiling 처리
				if(vChangeEquls.indexOf("ceiling") > -1 && vChangeEquls.indexOf("Math.ceil") == -1)
				{
					vChangeEquls = vChangeEquls.replace("ceiling", "Math.ceil");
					ds_bind.setColumn(i, "calculate", vChangeEquls);
				}
				
				// floor 처리
				if(vChangeEquls.indexOf("floor") > -1 && vChangeEquls.indexOf("Math.floor") == -1)
				{
					vChangeEquls = vChangeEquls.replace("floor", "Math.floor");
					ds_bind.setColumn(i, "calculate", vChangeEquls);
				}
				
				// round 처리
				if(vChangeEquls.indexOf("round") > -1 && vChangeEquls.indexOf("Math.round") == -1)
				{
					vChangeEquls = vChangeEquls.replace("round", "Math.round");
					ds_bind.setColumn(i, "calculate", vChangeEquls);
				}
				
				// power 처리
				if(vChangeEquls.indexOf("power") > -1 && vChangeEquls.indexOf("Math.pow") == -1)
				{
					vChangeEquls = vChangeEquls.replace("power", "Math.pow");
					ds_bind.setColumn(i, "calculate", vChangeEquls);
				}
				
				vArr = vRef.split(".");	
				vDs = this.all[vArr[0]]; //ds_data_itemvalue 		
				vCol = vArr[1]; // component를 의미
				
				vCalculate = fn_nvl(vChangeEquls);
				
				try
				{
					vResult = eval(vCalculate);
					//sysf_trace(vResult + " / " + vCompID);
				
					if(vCompID.indexOf("BOL") !=-1 || vCompID.indexOf("CHK") !=-1  )
					{
						var vResultBol = "";
						
						if(!utlf_isNull(vResult) && vResult !="nonevalue")
						{
							//vResultBol = this.components[vCol].truevalue; 
								
							if(vResult ==0 && utlf_isNull(this.components[vCompID]["degnitempnts"]))
							{
								//vResultBol = this.components[vCompID].falsevalue; 
								vResultBol = this.components[vCompID].truevalue; 
							}
							else if(vResult !=0 && !utlf_isNull(this.components[vCompID]["degnitempnts"]))
							{
								vResultBol = this.components[vCompID].truevalue; 
							}
							else
							{
								vResultBol = this.components[vCompID].falsevalue; 
								//vResultBol = this.components[vCompID].truevalue; 
							}	
						}
						else
						{	
							vResultBol = this.components[vCol].falsevalue; 	
						}
						
						vDs.setColumn(0,vCol,vResultBol);
												
					}
					//Radio Composite 일때 
					else if(vCompID.indexOf("RDO") !=-1 && !utlf_isNull(this.components[vCompID]["grupcd"]))
					{	
						var vResultTemp = "";
						var vValitemnm = "";
						var vDegnNo = vCompID.replace("RDO_", "");
						var vCheckDataSetName = new String(this.components[vCompID]["grupcd"]);
						var vRow = ds_data_recitem.findRowExpr("degnitemno == '"+ vDegnNo +"' && degnitemkind == 'RDO'");
						vCheckDataSetName = "ds_data_V_"+vCheckDataSetName;
						var vCheckDataSet = this.objects[vCheckDataSetName];
						
						for(var h=0; h <vCheckDataSet.getRowCount(); h++ )
						{
							if(vCheckDataSet.getColumn(h, "valitempnt") == vResult)
							{
								vResultTemp = vCheckDataSet.getColumn(h, "termbasecd");
								vValitemnm = vCheckDataSet.getColumn(h, "valitemnm");
							}
							else
							{	
							
							}
						}
						if(!utlf_isNull(vResultTemp))
						{
							vDs.setColumn(0,vCol,vResultTemp);
							this.components[vCompID].setData(vResultTemp);
							ds_data_recitem.setColumn(vRow, "rectermnm", vValitemnm);
						}
						else
						{
							vDs.setColumn(0,vCol,"");
							this.components[vCompID].ufn_initComp();
							ds_data_recitem.setColumn(vRow, "rectermnm", "");
						}
						
					}
					else
					{
					
						//vResult = lf_stxCheckNotNull(vCol, vResult, vFcompIDcompare);
						//vChangeEquls
						var vResultTemp = vResult;
						
						//STX의 경우 사칙연산이 없는 경우 0이 나오면 ""로
						if(vResultTemp == 0 && !(vChangeEquls.indexOf("-") > -1 || vChangeEquls.indexOf("+") > -1 || vChangeEquls.indexOf("/") > -1 || vChangeEquls.indexOf("*") > -1 ))
						{
						
							/*
							var No = vCompID.replace("STX_", "");
							if(!utlf_isNull(ds_data_syncdata) && !utlf_isNull(No))
							{
								var nRowNo = ds_data_syncdata.findRowExpr("item_kind == 'STX' && degnitemno =='"+No+"'");
								if(!utlf_isNull(nRowNo) && nRowNo > -1)
								{
									var value = ds_data_syncdata.getColumn(nRowNo, "item_value"); 
									
									if(value == 0)
									{
										vResultTemp = 0;
									}
									else
									{
										//계산값에 문제가 있을 수도 있는 case
										//처리보류
									}
								}
								else
								{
									vResultTemp = "";
								}
							}
							else
							{
								//값변경없음
							}
							*/
						}
						
						
						
						// 달력연산 추가
						if(vFcompIDcompare.indexOf("CAL_") > -1)
						{
							var calCheck = lf_calCal(vFcompIDcompare);
							
							if(!utlf_isNull(calCheck) && calCheck != "noCal")
							{
								vResultTemp = calCheck;
							}
							else if(!utlf_isNull(calCheck) && calCheck == "noCal")
							{
								
							}
							else
							{
								vResultTemp	= null;
							}
						}
						

						
						var roundposition="";
	
						if(isNaN(vResultTemp) == false && !utlf_isNull(vResultTemp)) 
						{
							try
							{
							
								if(!utlf_isNull(this.components[vCompID].roundposition))
								{
									roundposition = this.components[vCompID].roundposition
								}
								
								if(roundposition.indexOf("-") > -1)
								{
									roundposition = roundposition.replace("-", "" );
									
								}
								else if(roundposition.indexOf("+") > -1)
								{
									roundposition = roundposition.replace("+", "" );
								}
								else
								{
									roundposition = 5;
								}	
								
								//vResultTemp = Math.round(vResultTemp,roundposition);  
							}
							catch(e)
							{
								roundposition = 2;
								//vResultTemp = Math.round(vResultTemp,roundposition);
							
							}
							finally
							{
								vResultTemp = Math.round(vResultTemp,roundposition);  
							}
						}
											
						
						var vCheckResultNaNOrInfinity = new String(vResultTemp);
	
						if(("x" + vCheckResultNaNOrInfinity)  == "xNaN")
						{		
							vResultTemp = "";
						}
						else if(("x" + vCheckResultNaNOrInfinity)  == "xInfinity")
						{		
							vResultTemp = "";
						}
						
						if(vResultTemp == 0 && !(vChangeEquls.indexOf("-") >-1) && !(vChangeEquls.indexOf("+") >-1) && !(vChangeEquls.indexOf("/") >-1) && !(vChangeEquls.indexOf("*") > -1))
						{
							//vResultTemp = "";
						}
						
						// concat 처리
						if((vResultTemp.toString().indexOf("nonevalue") > -1 || vResultTemp.toString().indexOf("undefined") > -1) &&             
							vChangeEquls.indexOf("concat") > -1)
						{
							vResultTemp = vResultTemp.replace("nonevalue" ,"");
							vResultTemp = vResultTemp.replace("undefined" ,"");
						}

						
						//sysf_trace("vResultTemp : " + vResultTemp);	
						vDs.setColumn(0,vCol,vResultTemp);
						strConcat = "";
						//vDs.setColumn(0,vCol,vResult);
						//sysf_trace(vResult + " : lf_stxCheckNotNull" );

// 						if(("x" + vResult)  == "xNaN" || ("x" + vResult)  == "xInfinity")
// 						{		
// 							vResult ="";
// 							vDs.setColumn(0,vCol,"");
// 						}
						
// 						if(!utlf_isNull(vResult) && isNaN(vResult) == false)
//  						{
// 							vResult = Math.round(vResult, 2);
// 							vDs.setColumn(0,vCol,vResult);
//  						}

//  						if(vFcompIDcompare.indexOf("+") >-1 || vFcompIDcompare.indexOf("-") >-1
//  						|| vFcompIDcompare.indexOf("/") >-1 || vFcompIDcompare.indexOf("*") >-1
//  						|| vFcompIDcompare.indexOf("%") >-1)
//  						{
// 							//사칙연산이 있는 경우
//  						}
//  						else
//  						{
// 							if(vResult == 0)
// 							{
// 								vDs.setColumn(0,vCol,"");
// 							}
// 							else
// 							{
// 								vDs.setColumn(0,vCol,vResult);
// 							}
//  						}
 						
 						
 						// readonly일 경우 값 세팅 X 
 						//|| this.components[vCol]["enable"] == false 
 						try
 						{
							if(this.components[vCol].readonly == true )
							{
								vDs.setColumn(0,vCol,"");
							}
 						}
 						catch(e)
 						{
 						
 						}
 						
					}
				}
				catch(e)
				{
					sysf_trace("산술식 오류 : " + e + ", vCompID : " + vCompID);
					sysf_catchTrace(e);
				}				
			}
			else
			{
				//sysf_trace("산술식 적용대상 아님");
			}
		}
		
		/*****************************************************************************************************/
		/* 산술식 연산 끝
		/* Readonly는 ds_data_itemvalue value를 통해 작동하기 때문에 산술식을 통해 ds_data_itemvalue값을 채우고 
		/* 그후 Readonly기능에 대한 반복실행하여 구현
		/*****************************************************************************************************/
		for(k=0; k<ds_bind.getRowCount(); k++)
		{	
			if(!utlf_isNull(ds_bind.getColumn(k, "readonly")))
			{
				vCompID = ds_bind.getColumn(k, "componentid");
				var vChangeEquls = ds_bind.getColumn(k, "readonly");
				//var vChangeEquls = ds_bind.getColumn(i, "calculate");
				vSSUs = "";
				vSSUdiv ="";
				
				 if(vChangeEquls.indexOf("')='") > 0)
 				{
 					vChangeEquls = vChangeEquls.replace("')='", "')=='"); 		
 				}
					
				vReadonly = fn_nvl(vChangeEquls);
				
				vArr = vRef.split(".");	
				vDs = this.all[vArr[0]]; //ds_data_itemvalue 		
				vCol = vArr[1]; // component를 의미
				
				try
				{
					vResult = eval(vReadonly);
						
					if(vFcompIDName.indexOf("STX") == -1)
					{
						if(vCompID.indexOf("SL") > -1)
						{//SSL, MSL류
							vSSUs = ds_bind.getColumn(k, "supitem");
							vSSUdiv = vSSUs.split(",");	
						}
						
						var vChkComp = new String(this.components[vCompID]);

											
						if(vChangeEquls.indexOf("!") > -1)
						{
							if(vResult == true)
							{	
								if(vSSUdiv.length>0)
								{
									lf_sslEnable(vSSUdiv, false);	
								}
								else if(!utlf_isNull(this.components[vCompID]))
								{
									if(this.components[vCompID] == "cp_recradioList" || this.components[vCompID] == "cp_reccheckList")
									{
										this.components[vCompID].ufn_initComp();
										vDs.setColumn(0,vCompID,"");
										this.components[vCompID]["enable"] = false;
									}
									else
									{
										this.components[vCompID].readonly = true;
										this.components[vCompID].value = "";
									}
	
								}
							}
							else
							{
								if(vSSUdiv.length>0)
								{
									lf_sslEnable(vSSUdiv, true);	
								}
								else if(!utlf_isNull(this.components[vCompID]))
								{
									if(this.components[vCompID] == "cp_recradioList" || this.components[vCompID] == "cp_reccheckList")
									{
										this.components[vCompID]["enable"] = true;
									}
									else
									{
										this.components[vCompID].readonly = false;
										// 2016.10.14 this.components[vCompID].enable False 상태일 경우 활성화 처리[임시] 
// 										if(this.components[vCompID].enable == false){
// 											this.components[vCompID].enable = true;
// 										}
									}
								
									
								}
								
							}
								
						}
						else
						{
							if(vResult == true)
							{
								if(vSSUdiv.length>0)
								{
									lf_sslEnable(vSSUdiv, false);	
								}
								else if(!utlf_isNull(this.components[vCompID]))
								{
									if(this.components[vCompID] == "cp_recradioList" || this.components[vCompID] == "cp_reccheckList")
									{	
										this.components[vCompID].ufn_initComp();	
										vDs.setColumn(0,vCompID,"");
										this.components[vCompID]["enable"] = false;
									}
									else
									{
										this.components[vCompID].value = "";
										this.components[vCompID].readonly = true;
									}
								
									
								}
							}
							else
							{
								if(vSSUdiv.length>0)
								{
									lf_sslEnable(vSSUdiv, true);	
								}
								else if(!utlf_isNull(this.components[vCompID]))
								{
									if(this.components[vCompID] == "cp_recradioList" || this.components[vCompID] == "cp_reccheckList")
									{
										this.components[vCompID]["enable"] = true;
									}
									else
									{
										this.components[vCompID].readonly = false;
									}
		
								}
							}
						
						}
					
					}
					else
					{
						//STX일때
						if(vFcompIDName == vCompID)
						{
							if(vChangeEquls.indexOf("!") > -1)
							{
								if(vResult == true)
								{
									this.components[vCompID].readonly = true;
									this.components[vCompID].value = "";
								}
								else
								{
									this.components[vCompID].readonly = false;
								}
							}
							else
							{
								if(vResult == true)
								{
									this.components[vCompID].value = "";
									this.components[vCompID].readonly = true;
								}
								else
								{
									this.components[vCompID].readonly = false;
								}
							
							}
							
							
						}
					
					}
					//1121
					if(!utlf_isNull(this.components[vCompID]))
					{
						lf_changeEnable(this.components[vCompID]);
					}
				}
				catch(e)
				{
					sysf_trace("산술식 오류 : " + e + ", vCompID : " + vCompID);
				}
				
			}
			else
			{
				//readonly 적용대상아님
			}
		}
		
	}
	
	vFcompIDName = new String(fCompID.name);
	
	//&& vFcompIDName.indexOf("SL") == -1 , utlf_isNull(vDs) &&utlf_isNull(vDs) && (vFcompIDName.indexOf("STX") == -1 &&
	if(vFcompIDName.indexOf("ds") == -1 && vFcompIDName.indexOf("SSL") == -1)
	{
		
		//산술식 및 readonly기능에 관한 것이 아닌 단순 extn 활성화일때 적용
		lf_extnEnable(vFcompIDName, ds_data_itemvalue);
		
	}

}


/**********************************************************************************
 * Method Name  : fn_getInt
 * Description  : Dataset에 해당 값을 구해 숫자형으로 변경 전달.
 * argument     : DATASETName.ColumnID, currentRownum
 * return Type  : int
 * Creator 	    :
**********************************************************************************/
function fn_getInt(vStr,vRow){
utlf_addLog("***** fn_getInt("+vStr+","+vRow+") *****");

	var objArr;
	if(utlf_isNull(vRow)) vRow = 0;
	objArr = vStr.split("."); // ref 값을 받아 Data 추출 ref형식 : ds.col
	var vDs  = this.objects[objArr[0]];	//dataset
	var vCol  = objArr[1];	//component id	
	var v1="";
	
	//sysf_trace(vCol);
	if(vCol.indexOf("SL_") > -1)
	{
		//var vDsValue = vDs.getCoulmn(0, vCol);
		//함수
		//lf_extnEnable(vCol, vDs);	
	}
	else
	{
				
	}
				

utlf_addLog("vCol : " + vCol);	
	//rdo, bol, chk의 값이 있을 경우 처리 - value값과 point값이 다르기 때문에
	if(vCol.indexOf("RDO") != -1 || vCol.indexOf("BOL") != -1 || vCol.indexOf("CHK") != -1 || vCol.indexOf("SSL") != -1 
	|| vCol.indexOf("CMB") != -1 || vCol.indexOf("MSL") != -1 || vCol.indexOf("IMG") != -1)
	{
	
		// Composite check에 대한 처리 추가
	
		if(vCol.indexOf("BOL") != -1 || (vCol.indexOf("CHK") != -1 && this.components[vCol] != "cp_reccheckList" ))
		{
			var vCompValue = vDs.getColumn(0,vCol);
			
			//선택하지 않았을 때
			if(vCompValue == "nonevalue" || utlf_isNull(vCompValue))
			{
				v1 = "";	
				// 만약에 연산으로 계산이 되는거면 0 값을 부여
			}
			else
			{
				if(!utlf_isNull(this.components[vCol]["degnitempnts"]))//degnitempnts
				{
					v1 = parseInt(this.components[vCol]["degnitempnts"]);
					
					if( isNaN(v1) == true )
						v1 = this.components[vCol]["degnitempnts"];
					
				}
				else
				{
					//BOL에 대한 degnitempnts를 설정하지 않으면 0로 판단
					v1 = 0;
				}	
			}

		}
		
		else if(vCol.indexOf("CHK") != -1 && this.components[vCol] == "cp_reccheckList" )
		{
			//0. dataset 찾기 - component grupcd로 조합
			var sGrupcd =  this.components[vCol].grupcd;
			
			if(utlf_isNull(sGrupcd))
			{
				sysf_trace("no bindind dataset");
				return;
				
			}
			
			var dsNm = "ds_data_V_" + sGrupcd;
			//this.objects[dsNm] -> dataset 
			
			//1. 해당 component의 value찾기
			//getData() -> ds_data_itemvalue를 이용함
			//dataset 구조
			//<Col id="valitemnm">
			//<Col id="termbasecd">
			//<Col id="valitempnt">
			var sVal =  this.objects["ds_data_itemvalue"].getColumn(0, vCol);
			
			//2. value값을 통해 다중 체크 여부 판단
			var sVals = sVal.split(" "); //체크여부를 공백으로 자른다.
			var sValsCount = sVals.length;
			
			var nSumPoint =0; //Point 합산
			var nFullyZero = 0; 
		
			for(var i=0; i <sValsCount; i++ )
			{
				if(utlf_isNull(sVals[i]))
				{
					//v1 +=0;
				}
				else
				{
					var nValRow  = this.objects[dsNm].findRow("termbasecd", sVals[i]);
					
					if(nValRow !=-1)
					{
						nFullyZero +=1;
						nSumPoint += toNumber(this.objects[dsNm].getColumn(nValRow, "valitempnt"));
					}	
				}
					
			}
			
							
			if((!utlf_isNull(nSumPoint) && nSumPoint !=0)  || (nFullyZero > 0 && nSumPoint == 0))
			{
				v1 = nSumPoint;		
			}
		}
		else if(vCol.indexOf("RDO") != -1 )
		{
			
			var sVal =  this.objects["ds_data_itemvalue"].getColumn(0, vCol);
			
		
			var vCheckDataSetName = new String(this.components[vCol]["grupcd"]);
			
			vCheckDataSetName = "ds_data_V_"+vCheckDataSetName;
			
			
			var vCheckDataSet = this.objects[vCheckDataSetName];	
			
			for(var j=0; j <vCheckDataSet.getRowCount(); j++)
			{

				
				if( (vCheckDataSet.getColumn(j, "termbasecd") == sVal) && !utlf_isNull(sVal) )
 				{	
 					v1 = vCheckDataSet.getColumn(j, "valitempnt");
 					break;
 				} 
			}

			//sysf_trace("v1 : " + v1);

		}
		else if(vCol.indexOf("SSL") != -1)
		{
			var vSupitemNo;
			vSupitemNo = vCol.split("_"); // vSupitemNo[1] -> supdegnitemno
			
			
			for(var k=0; k < this.components.length; k++)
			{
				if(!utlf_isNull(this.components[k]["supdegnitemno"]) && this.components[k]["supdegnitemno"] == vSupitemNo[1])
				{
					
					var vSupdegnitemnoValue = this.components[k].value;
					var vInnerDataset = new String("ds_" + this.components[k].name);
					
					var vInnerDatasetValue = this.objects[vInnerDataset].getColumn(0, "termbasecd");
					
					
					if(vSupdegnitemnoValue == vDs.getColumn(0, vCol) && !utlf_isNull(vSupdegnitemnoValue) && vInnerDatasetValue == vDs.getColumn(0, vCol))
					{
						v1 = this.components[k]["degnitempnts"];
					}
					else
					{
					
					}
				}
			}
			//sysf_trace("vCol.indexOf(SSL) -> " +v1);

		}
		else if(vCol.indexOf("CMB") != -1)
		{
			var vCompValue = vDs.getColumn(0,vCol);
		
			if(!utlf_isNull(vCompValue) && !utlf_isNull(this.components[vCol]["innerdataset"]))
			{
				var vInnerDs =  this.components[vCol]["innerdataset"];
				//	var vInnerDsNm = vInnerDs.name; 
				
				//sysf_trace(vCompValue);
				var vMatchRow = vInnerDs.findRow("termbasecd",vCompValue);
				//일치하는 Row값 
				
				if(vMatchRow > -1)
				{// 일치하는 것이 있는 경우 
					v1 = vInnerDs.getColumn(vMatchRow, "valitempnt");
				}
				else
				{// 일치하는 것이 없는 경우 
					//v1 = "";
					v1 =0;
				}	
			}
			else
			{//콤보박스 값이 없는 경우 v1 = ""로 설정
				//v1 = "";
				v1 = 0;
			}
		}
		//추가
		else if(vCol.indexOf("MSL") != -1 || vCol.indexOf("IMG") != -1)
		{
			var vPno = vCol.split("_");
			//vPno[0] - MSL, vPno[1] - no
			var vTotalPoint = 0;
			//세부 SSU의 찾기
			for(var a=0; a < this.components.length; a++)
			{//degnitempnts
				if(!utlf_isNull(this.components[a]["supdegnitemno"]) && this.components[a]["supdegnitemno"] ==  vPno[1] && !utlf_isNull(this.components[a]["degnitempnts"]))
				{
					if(!utlf_isNull(this.components[a].value) && this.components[a].value != "nonevalue"  )
					{
						vTotalPoint += toNumber(this.components[a]["degnitempnts"]);
					}
				}
			}
			

			v1 = vTotalPoint;
			
			//sysf_trace(vTotalPoint + " : vTotalPoint");
			if(utlf_isNull(vTotalPoint))
			{
				v1 = "";
				
			}
			
		}		
		else
		{
		
		}
		
		
		
		if(utlf_isNull(v1) || v1== "nonevalue")
		{
			var vRowCount = new String(vCol+"'");
			this.objects["ds_bind"].filter("String(calculate).indexOf("+"\""+vRowCount+"\""+") >= 0");
				
			if(this.objects["ds_bind"].getRowCount() > 0)
			{
				var vArithmetics = new String(this.objects["ds_bind"].getColumn(0, "calculate"));
					
				if(vArithmetics.indexOf("+") > -1 || vArithmetics.indexOf("-") > -1 || vArithmetics.indexOf("*") > -1 
					|| vArithmetics.indexOf("/") > -1 || (( vArithmetics.indexOf("MSL") > -1  //vArithmetics.indexOf("SSL") > -1 ||
					|| vArithmetics.indexOf("RDO") > -1 || vArithmetics.indexOf("CHK") > -1) && (vArithmetics.indexOf("=") == -1)))
				{
					v1= 0;
				}
				else if( vArithmetics.indexOf("SSL") > -1 && vArithmetics.indexOf("=") == -1 )
				{
					
				}
				else
				{
					v1= "nonevalue";
						
				}
			}
			this.objects["ds_bind"].filter("");	

		}
		
		
	}

	else
	{	//STX일 경우 
		v1 =  vDs.getColumn(vRow,vCol);
	
		var vRowCount = new String(vCol+"'");
		
		this.objects["ds_bind"].filter("String(calculate).indexOf("+"\""+vRowCount+"\""+") >= 0");
		
		/*STX 중 연산으로 사용되는 것과 일반 text구분 calculate컬럼에 사칙연산이 있으면 연산으로 없으면 text로 구분한다.
		           - 두가지를 동시에 갖는 것은 없다고 가정 -> 그러므로 첫번째 row의 calculate 값으로 사칙연산 판단가능
		*/ 
		if(this.objects["ds_bind"].getRowCount() > 0)
		{
			var vArithmetics = new String(this.objects["ds_bind"].getColumn(0, "calculate"));
utlf_addLog("vArithmetics : " + vArithmetics);		
			//사칙연산 판단
// 			if(vArithmetics.indexOf("+") > -1 || vArithmetics.indexOf("-") > -1 || vArithmetics.indexOf("*") > -1 
// 			|| vArithmetics.indexOf("/") > -1 || vArithmetics.indexOf("SSL") > -1 || vArithmetics.indexOf("MSL") > -1)
			if(vArithmetics.indexOf("+") > -1 || vArithmetics.indexOf("-") > -1 || vArithmetics.indexOf("*") > -1 
			|| vArithmetics.indexOf("/") > -1 ||((vArithmetics.indexOf("SSL") > -1 || vArithmetics.indexOf("MSL") > -1 
			|| vArithmetics.indexOf("RDO") > -1 || vArithmetics.indexOf("CHK") > -1
			|| vArithmetics.indexOf("sqrt") > -1 || vArithmetics.indexOf("ln") > -1
			) && (vArithmetics.indexOf("=") == -1)))
			{

				if(utlf_isNull(v1))
				{
					v1= 0;
				}
				else
				{	
					//소수점 계산 처리를 위해 주석처리 20150210
					//v1 = parseInt(v1)					
				}
				
				
				//v1 =  Math.round(v1, 1);
				v1 = parseFloat(v1);
					
			}
			else
			{
				//v1 = v1.toString();
			}
			
		}
		else
		{
			//일반 TEXT인 경우
			if(utlf_isNull(v1))
			{
				//v1="";
			}
		}
		
		this.objects["ds_bind"].filter("");	
			
	}
	
	// 2017.09.22 isFinite 체크 추가
	if(isNaN(v1) == false && (isNumeric(v1) == true || (!utlf_isNull(v1) && isFinite(v1) == true)))
	{	
		//v1 =  Math.round(v1, 3);
		v1 = parseFloat(v1);
		//v1 = v1;
	}
	
	//값이 없어도 0으로 판단하여 계산
	if(utlf_isNull(v1))
	{
		//v1 = 0;
	}
	
	return v1;
}
/**********************************************************************************
 * Method Name  : fn_sum
 * Description  : Dataset에 해당 컬럼에 합계를 구함.
 * argument     : DATASETName.ColumnID
 * return Type  : int
 * etc		    : 계산식에 ds1.getSum("col1")을 사용하면 "ds1.col1"로 연관 bind 찾을때 누락된다. 
				  그래서 fn_sum('ds1.col1')을 적용하여 검색가능하게 변경
 * Creator 	    :
**********************************************************************************/
function fn_sum(vStr){
utlf_addLog("***** fn_sum("+vStr+") *****");
	var objArr;
	objArr = vStr.split("."); // ref 값을 받아 Data 추출 ref형식 : ds.col
	var vDs  = this.all[objArr[0]];
	var vCol  = objArr[1];
	return vDs.getSum(vCol);
	
}
/**********************************************************************************
 * Method Name  : fn_nvl
 * Description  : null 처리
 * argument     : Object
 * return Type  : String
 * Creator 	    :
**********************************************************************************/
function fn_nvl(vStr){
	if(null == vStr) vStr = "";
	
	return vStr;
}


/**********************************************************************************
 * Method Name  : lf_chkExtn
 * Description  : extn 컨트롤 처리 이벤트
 * argument     : obj, e
 * return Type  : 
 * Creator 	    :
**********************************************************************************/
function lf_chkExtn(obj, e)
{
utlf_addLog("***** lf_chkExtn("+obj+", "+e+") *****");
	lf_changeEnable(obj);
}	

/**********************************************************************************
 * Method Name  : lf_changeEnable
 * Description  : 산술식내에서 연산되는 extn처리 
 * argument     : obj
 * return Type  : 
 * Creator 	    :
**********************************************************************************/	
//라디오일때와 체크박스일때를 구분하여 구현 필수
//현재는  체크박스에 대한 extn ctrl의 enable 기능만 작동
function lf_changeEnable(obj)
{
utlf_addLog("***** lf_changeEnable("+obj+") *****");
	//obj.updateToDataset();

	var vID = obj.name;	
	var vObj = new String(obj);
	
	var vExtn;
	vExtn = vID.split("_"); // vExtn[1]	
	var vExtnID = new String("STX_" + vExtn[1]);
	
	

	if(!utlf_isNull(this.components[vExtnID]) && !utlf_isNull(this.components[vExtnID]["ctrltype"]) && this.components[vExtnID]["ctrltype"] == "extn")
	{
		if(this.components[vID]["enable"] == false || this.components[vID].readonly ==true || (vObj.indexOf("CheckBox") > -1 && this.components[vID].value =="nonevalue") )
		{
			
			this.components[vExtnID]["enable"] = false;
			this.components[vExtnID].value = "";
		}
		else
		{	
			this.components[vExtnID]["enable"] = true;
		}
		
		
	}
	else
	{
	
	}
		
	
}	

/**********************************************************************************
 * Method Name  : lf_deselectCMP
 * Description  : composite(라디오) 초기화 함수 (onclick)
 * argument     : obj, e
 * return Type  : 
 * Creator 	    :
**********************************************************************************/	
function  lf_deselectCMP(obj, e)
{
utlf_addLog("***** lf_deselectCMP(obj, e) *****");
	obj.ufn_initComp();
}

/**********************************************************************************
 * Method Name  : lf_changeGrid
 * Description  : 특수 그리드 처리함수 (누적그리드)
				   최초 로드시점에 사용
 * argument     : dataset
 * return Type  : ds
 * Creator 	    :
**********************************************************************************/	
function lf_changeGrid(ds)
{
utlf_addLog("***** lf_changeGrid(ds) *****");
	ds.updatecontrol = false;
		
	var vDsNm = ds.name;
	var vGridNo = vDsNm.replace("ds_data_grd_", "");
	//GRD로 시작하는 것만 고려
	vGridNo = "GRD_" + vGridNo;
	var vCount = ds.getColCount();
	
	for(var i=1; i <vCount; i++ )
	{
		if(!utlf_isNull(this.components[vGridNo].getCellText(-1, i)))
		{
			var vName = this.components[vGridNo].getCellText(-1, i);
			ds.addRow();
			ds.setColumn(i-1,0,vName);
			this.components[vGridNo].setCellProperty( "Head", i, "text", "");
			//this.objects[vChangeGrid].updateColID(i, vName);
		}
	}
	
	//데이터 정리 시작
	var vRowCount = ds.getRowCount();
	vRowCount = toNumber(vRowCount);
	
	//row삭제
	for(var d=vRowCount; -1<d; d--)
	{
		if(utlf_isNull(ds.getColumn(d,0)))
		{
			ds.deleteRow(d);		
		}
	}
	
	//col삭제
	for(var j=vCount-1;  0<j ; j--)
	{
		if(utlf_isNull(ds.getColumn(1,j)) && ds.getColCount()!=2)
		{		
			this.components[vGridNo].deleteContentsCol(j);
			//ds.updatecontrol = false;
			ds.deleteColumn(j);
		}
	}

	ds.updatecontrol = true;	

}

/**********************************************************************************
 * Method Name  : lf_dsOncolumnchanged
 * Description  : 특수 그리드 데이터 변환 함수 (누적 그리드)
				  
 * argument     : dataset
 * return Type  : 
 * Creator 	    :
**********************************************************************************/	
function lf_dsOncolumnchanged(obj, e)
{
utlf_addLog("***** lf_dsOncolumnchanged(obj, e) *****");
// 	sysf_trace("dataset 이벤트");
// 
// 
// 	var vChangeGrid = obj.name;
// 	var vChangeGridNm;
// 	
// 	vChangeGrid = vChangeGrid.split("_temp");
// 	vChangeGridNm = vChangeGrid[0];
// 	
// 	this.objects[vChangeGridNm].updatecontrol = false;
// 	
// 	//column 수 체크 
// 	if(obj.getColCount() > (this.objects[vChangeGridNm].getRowCount()+1))
// 	{
// 		
// 		var add = obj.getColCount()	- (this.objects[vChangeGridNm].getRowCount()+1);
// 		for(var i=0; i <add; i++)
// 		{
// 			this.objects[vChangeGridNm].addRow();
// 		}
// 	
// 	}
// 	else if(obj.getColCount() < this.objects[vChangeGridNm].getRowCount())
// 	{
// 		var del = this.objects[vChangeGridNm].getRowCount() - obj.getColCount();
// 		for(var i=del; -1 <i; i--)
// 		{
// 			this.objects[vChangeGridNm].deleteRow(i);
// 
// 		}	
// 	}
// 	  	
// 	if(obj.getRowType(e.row) == 2)
// 	{
// 		this.objects[vChangeGridNm].addRow();
// 	}
// 	else if(obj.getRowType(e.row) == 8)
// 	{
// 		this.objects[vChangeGridNm].deleteRow();
// 	}
// 	else if(obj.getRowType(e.row) == 4 || obj.getRowType(e.row) == 1 )
// 	{
// 		var vVal = obj.getColumn(e.row, e.col);
// 				
// 		if(e.col-1 !=-1)
// 		{
// 			this.objects[vChangeGridNm].setColumn(e.col-1, e.row, vVal);
// 		}
// 		
// 	}

}

/**********************************************************************************
 * Method Name  : lf_getCalid
 * Description  : 산술식 내부함수, 산술식을 실행할 components id 반환
 * argument     : fCompID(Components), vFcompID(Components id), vSupdegnitemno(Cmponents Supdegnitemno)
 * return Type  : String(vFcompIDName)
 * Creator 	    :
**********************************************************************************/	
function lf_getCalid(fCompID, vFcompID, vSupdegnitemno)
{
utlf_addLog("***** lf_getCalid("+fCompID+", "+vFcompID+", "+vSupdegnitemno+") *****");
	var vFcompIDName= "";
	
	if(vFcompID.indexOf("Radio") >-1 && vSupdegnitemno.indexOf("undefined") ==-1)
	{
		vFcompIDName = "SSL_"+vSupdegnitemno;
	}
	else if(vFcompID.indexOf("Check" ) >-1 &&vSupdegnitemno.indexOf("undefined") ==-1)
	{
		vFcompIDName = "MSL_"+vSupdegnitemno;
	}
	else
	{
		vFcompIDName = new String(fCompID.name);
	}
	
	return vFcompIDName;
}



/**********************************************************************************
 * Method Name  : lf_getChangeEquls
 * Description  : 변환되어나온 산술식 문법상의 오류를 처리하는 함수(괄호오류처리)
 * argument     : i
 * return Type  : String(vChangeEquls )
 * Creator 	    :
**********************************************************************************/	
function lf_getChangeEquls(i)
{
utlf_addLog("***** lf_getChangeEquls("+i+") *****");
	var vChangeEquls = this.objects["ds_bind"].getColumn(i, "calculate");	
	
	// = 기호 처리
	if(vChangeEquls.indexOf("')='") > 0)
 	{
 		vChangeEquls = vChangeEquls.replace("')='", "')=='"); 		
 	}
 	
 	//Bol값에 대한 판단일때 cal경우 체크된 상태를 0, readonly에서는 1로 판단하므로
	//cal일때도 1로 판단하도록 산술식변경 
	if(vChangeEquls.indexOf("fn_getInt('ds_data_itemvalue.BOL_") >0 && vChangeEquls.indexOf("='0'") > 0 )
	{
		//vChangeEquls = vChangeEquls.replace("='0'", "='1'"); 		
	}
	
	
	return vChangeEquls;
	
}
/**********************************************************************************
 * Method Name  : lf_setResult
 * Description  : 산술식 결과 적용함수
 * argument     : vCompID
 * return Type  : String(vResultTemp )
 * Creator 	    :
**********************************************************************************/	
function lf_setCalResult(vCompID, vResult, vCalculateDs)
{	
utlf_addLog("***** lf_setCalResult("+vCompID+", "+vResult+", "+vCalculateDs+") *****");

	var vResultTemp = vResult;
	var vCalculateDs = new String(vCalculateDs);

	//MSL, SSL은 고려하지 않음.
	if(vCompID.indexOf("SSL") !=-1 || vCompID.indexOf("MSL") !=-1)
	{
		sysf_trace("SSL, MSL은 고려하지 않음 - lf_setCalResult함수");
		return vResultTemp;
	}
	
	if(vCompID.indexOf("BOL") !=-1 || vCompID.indexOf("CHK") !=-1)
	{
		if(!utlf_isNull(vResult) && vResultTemp !="nonevalue")
		{	
			//degnitempnts를 선언하지 않은 경우에 대한 처리
			if(vResultTemp ==0 && utlf_isNull(this.components[vCompID]["degnitempnts"]))
			{
				//vResultTemp = this.components[vCompID].falsevalue; 
				vResultTemp = this.components[vCompID].truevalue;
			}
			else
			{
				//vResultTemp = this.components[vCompID].truevalue;
				vResultTemp = this.components[vCompID].falsevalue; 
			}
			
		}
		else
		{	
			vResultTemp = this.components[vCompID].falsevalue; 
		}
	}
	else if(vCompID.indexOf("RDO") !=-1 && !utlf_isNull(this.components[vCompID]["grupcd"]))
	{
		var vCheckDataSetName = new String(this.components[vCompID]["grupcd"]);
		vCheckDataSetName = "ds_data_V_"+vCheckDataSetName;
		
		var vCheckDataSet = this.objects[vCheckDataSetName];

		
		for(var h=0; h <vCheckDataSet.getRowCount(); h++ )
		{
			if(vCheckDataSet.getColumn(h, "valitempnt") == vResult)
			{	
				vResultTemp = vCheckDataSet.getColumn(h, "termbasecd");	
				//break;
			}
		}
		
		
		if(utlf_isNull(vResultTemp) || vResultTemp =="nonevalue")
		{
		//	vResultTemp = vCheckDataSet.getColumn(0, "termbasecd");	//초기값의 경우 0번째 row의 값으로 임의 설정
		}
		
	}
	else
	{
		//vResultTemp = lf_stxCheckNull(vCompID, vResult, vCalculateDs);
		var roundposition="";
	
	if(isNaN(vResultTemp) == false && !utlf_isNull(vResultTemp)) 
	{
		try
		{
		
			if(!utlf_isNull(this.components[vCompID].roundposition))
			{
				roundposition = this.components[vCompID].roundposition
			}
			
			if(roundposition.indexOf("-") > -1)
			{
				roundposition = roundposition.replace("-", "" );
				
			}
			else if(roundposition.indexOf("+") > -1)
			{
				roundposition = roundposition.replace("+", "" );
			}
			else
			{
				roundposition = 5;
			}	
			
			//vResultTemp = Math.round(vResultTemp,roundposition);  
		}
		catch(e)
		{
			roundposition = 2;
			//vResultTemp = Math.round(vResultTemp,roundposition);
		
		}
		finally
		{
			vResultTemp = Math.round(vResultTemp,roundposition);  
		}
	}
		
	}
	

	
	
	
	var vCheckResultNaNOrInfinity = new String(vResultTemp);
	
utlf_addLog("vCheckResultNaNOrInfinity : " + vCheckResultNaNOrInfinity);	
	if(("x" + vCheckResultNaNOrInfinity)  == "xNaN")
	{		
		vResultTemp = "";
	}
	else if(("x" + vCheckResultNaNOrInfinity)  == "xInfinity")
	{		
		vResultTemp = "";
	}
	
	
	//sysf_trace("2. vResultTemp : "+ vCompID+" , "+ vResultTemp + ", " + vResult);
	
	return vResultTemp;
	

}

/**********************************************************************************
 * Method Name  : IsDate
 * Description  : 날짜 형식이 맞는지 확인
 * argument     : sDate
 * return Type  :  - 날짜형식이 맞는 경우 = true
				   - 날짜형식이 맞지 않는 경우 = false
				   - sDate가 입력되지 않은 경우 = false
 * Creator 	    :
**********************************************************************************/	 
function IsDate(sDate)
{
utlf_addLog("***** IsDate("+sDate+") *****");
	if( IsNull(sDate) )		return false;
	
	var sDate = sDate.toString();
	
    if( sDate.length != 8 )
        return false;
    
    if( IsNum(sDate) != true )
        return false;
    
	var nMonth  = parseInt(sDate.substring(4,6), 10);
	var nDate  = parseInt(sDate.substring(6,8), 10);
	var nYear = parseInt(sDate.substring(0,4), 10);
	
    if( nMonth < 1 || nMonth > 12 ) 
        return false;
        
    if( nDate < 1 || nDate > LastDateNum(sDate) )
        return false;
    
    return true;
}

/**********************************************************************************
 * Method Name  : IsNum
 * Description  :  문자열이 숫자형식에 맞는지 여부 체크
 * argument     : sNum
 * return Type  : - 숫자형식에 맞는경우 = true
				  - 숫자형식에 맞지않는 경우 = false
 * Creator 	    :
**********************************************************************************/	 
function IsNum(sNum)
{
utlf_addLog("***** IsNum("+sNum+") *****");
	var c;
	var point_cnt=0;
	var ret=true;
	
	if( IsNull(sNum) )		return false;
	
	for( i = 0 ; i < sNum.length ; i++ )
	{
		c = sNum.charAt(i);
		if( i == 0 && ( c == "+" || c == "-" ) );
		else if( c >= "0" && c <= "9" );
		else if( c == "." )
		{
			point_cnt++;
			if( point_cnt > 1 )
			{
				ret = false;
				break;
			}
		}
		else
		{
			ret = false;
			break;
		}
	}
	
	return ret;
}

/**********************************************************************************
 * Method Name  : IsLeapYear
 * Description  :   윤년여부 확인
 * argument     : sDate(yyyyMMdd형태의 날짜)
 * return Type  : - sDate가 윤년인 경우 = true
                  - sDate가 윤년이 아닌 경우 = false
                  - sDate가 입력되지 않은 경우 = false
 * Creator 	    :
**********************************************************************************/	 
function IsLeapYear(sDate)
{
utlf_addLog("***** IsLeapYear("+sDate+") *****");
    var ret;
    var nY;
    
    if( IsNull(sDate) )		return false;
    
    nY = parseInt(sDate.substring(0,4), 10);

    if ((nY % 4) == 0) 
    {
        if ((nY % 100) != 0 || (nY % 400) == 0) 
            ret = true;
        else 
            ret = false;
    } 
    else 
        ret = false;
  
    return ret;
}

/**********************************************************************************
 * Method Name  : LastDateNum
 * Description  : 해당월의 마지막 날짜를 숫자로 구하기 
 * argument     : sDate(yyyyMMdd형태의 날짜)
 * return Type  :  - 성공 = 마지막 날짜 숫자값 ( 예 : 30 )
				   - 실패 = -1
 * Creator 	    :
**********************************************************************************/	 
function LastDateNum(sDate)
{
utlf_addLog("***** LastDateNum("+sDate+") *****");
    var nMonth, nLastDate;

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

/**********************************************************************************
 * Method Name  : IsNull
 * Description  : 입력값이 null에 해당하는 경우 모두를 한번에 체크한다. 
 * argument     : sValue (체크할 문자열)
 * return Type  : - sValue가 undefined, null, NaN, "", Array.length = 0인 경우 = true
                  - 이외의 경우 = false
 * Creator 	    :
**********************************************************************************/	
function IsNull(sValue)
{
utlf_addLog("***** IsNull("+sValue+") *****");
	if( new String(sValue).valueOf() == "undefined") 
		return true;
	if( sValue == null )
		return true;
	if( ("x"+sValue == "xNaN") && ( new String(sValue.length).valueOf() == "undefined" ) )
		return true;
	if( sValue.length == 0 )
		return true;
	return false;
}


/**********************************************************************************
 * Method Name  : lf_changeMask
 * Description  : (서식로드 시)주로 영문서식의 MaskEdit의 value값을 변경하는 기능을 한다.
 * argument     : 
 * return Type  : 
 * Creator 	    :
**********************************************************************************/	
function lf_changeMask()
{
utlf_addLog("***** lf_changeMask() *****");
	for(var i=0; i < this.components.length; i++)
	{
		var vComp = this.components[i];

		if(vComp == "[object MaskEdit]" && !utlf_isNull(vComp.value) )
		{
			var vMask = new String(vComp.mask);
			var vMaskVal = new String(vComp.value);
			var nMonth;
			var nDate;
			var nYear;


			if(vMask.indexOf("##/##/####") > -1  && !utlf_isNull(vMaskVal))
			{
				var vSubyyyymmdd = vMaskVal.substring(0,8);
				
				var vExtraVal = vMaskVal.split(vSubyyyymmdd);
				//vExtraVal[1]
				
				var vReVal = new String();
				
				//날짜타입인지 판단 
				var rtn = IsDate(vSubyyyymmdd.value);
				
				if(rtn = false)
				{
				
				}
				else
				{
					nMonth  = vSubyyyymmdd.substring(4,6);
					nDate  = vSubyyyymmdd.substring(6,8);
					nYear = vSubyyyymmdd.substring(0,4);
								
					if(!utlf_isNull(vExtraVal[1]))
					{
						vReVal =  nMonth + nDate + nYear + vExtraVal[1];
					}
					else
					{
						vReVal =  nMonth + nDate + nYear;
					}
									
					vComp.value = vReVal;
				
				}
					
			}

		}
	}

}



/**********************************************************************************
 * Method Name  : lf_saveMask
 * Description  : (서식저장 시)주로 영문서식의 MaskEdit의 value값을 변경하는 기능을 한다. -> SMMMR02900화면 이동
 * argument     : 
 * return Type  : 
 * Creator 	    :
**********************************************************************************/	
function lf_saveMask()
{
utlf_addLog("***** lf_saveMask() *****");
	for(var i=0; i < this.components.length; i++)
	{
		var vComp = this.components[i];

		if(vComp == "[object MaskEdit]" && !utlf_isNull(vComp.value) )
		{
			var vMask = new String(vComp.mask);
			var vMaskVal = new String(vComp.value);
			var nMonth;
			var nDate;
			var nYear;


			if(vMask.indexOf("##/##/####") > -1  && !utlf_isNull(vMaskVal))
			{
				var vSubyyyymmdd = vMaskVal.substring(0,8);
				
				var vExtraVal = vMaskVal.split(vSubyyyymmdd);
				//vExtraVal[1]
				
				var vReVal = new String();

				nDate  = vSubyyyymmdd.substring(2,4);
				nYear  = vSubyyyymmdd.substring(4,8);
				nMonth = vSubyyyymmdd.substring(0,2);
								
				if(!utlf_isNull(vExtraVal[1]))
				{
					vReVal =  nYear + nMonth + nDate + vExtraVal[1];
				}
				else
				{
					vReVal =  nYear + nMonth + nDate;
				}
									
				vComp.value = vReVal;
		
			}

		}
	}

}

/**********************************************************************************
 * Method Name  : lf_applyReadOnly
 * Description  : readonly 산술결과 적용함수
 * argument     : vCompID(compnent id), vChangeEquls(readonly 산술식), vResult(연산 결과), vChkComp, vSSUdiv(SSU집합)
 * return Type  : none
 * Creator 	    :
**********************************************************************************/	
function lf_applyReadOnly(vCompID, vChangeEquls, vResult, vChkComp, vSSUdiv)
{
utlf_addLog("***** lf_applyReadOnly("+vCompID+", "+vChangeEquls+", "+vResult+", "+vChkComp+", "+vSSUdiv+") *****");
	if(vChangeEquls.indexOf("!") > -1 && !utlf_isNull(this.components[vCompID]))
	{
		if(vResult == true)
		{	
			if(vSSUdiv.length>0)
			{
				lf_sslEnable(vSSUdiv, false);	
			}
			else
			{
				if(vChkComp.indexOf("cp_rec") > -1)
				{
					this.components[vCompID]["enable"] = false;
					this.components[vCompID].ufn_initComp();
				}
				else
				{
					this.components[vCompID].readonly = true;
					this.components[vCompID].value = "";
				}
			
				
				
			}
		}
		else
		{
			if(vSSUdiv.length>0)
			{
				lf_sslEnable(vSSUdiv, true);	
			}
			else if(!utlf_isNull(this.components[vCompID]))
			{
				
				if(vChkComp.indexOf("cp_rec") > -1)
				{
					this.components[vCompID]["enable"] = true;
				}
				else
				{
					this.components[vCompID].readonly = false;
				}

				
			}
		}
			
	}
	else if(!utlf_isNull(this.components[vCompID]))
	{
		if(vResult == true)
		{
			if(vSSUdiv.length>0)
			{
				lf_sslEnable(vSSUdiv, false);	
			}
			else if(!utlf_isNull(this.components[vCompID]))
			{
				if(vChkComp.indexOf("cp_rec") > -1)
				{
					this.components[vCompID]["enable"] = false;
					this.components[vCompID].ufn_initComp();
				}
				else
				{
					this.components[vCompID].readonly = true;
					this.components[vCompID].value = "";
				}
				
			}
		}
		else
		{
			if(vSSUdiv.length>0)
			{
				lf_sslEnable(vSSUdiv, true);	
			}
			else if(!utlf_isNull(this.components[vCompID]))
			{
				if(vChkComp.indexOf("cp_rec") > -1)
				{
					this.components[vCompID]["enable"] = true;
				}
				else
				{
					this.components[vCompID].readonly = false;
				}
			}
		}

	}
	else
	{

	}
}



/**********************************************************************************
 * Method Name  : lf_initRdoVal
 * Description  : 산술식 계산 전 RDO component 초기값 세팅(산술식 해당 component만 대상)
 * argument     : oDsBind(dataset)
 * return Type  : N/A
 * Creator 	    :
**********************************************************************************/	
function lf_initRdoVal(oDsBind)
{
utlf_addLog("***** lf_initRdoVal("+oDsBind+") *****");
	//sysf_trace("초기값 연산함수");
	var vDsBind = this.objects[oDsBind];

	if(utlf_isNull(vDsBind))
	{
		sysf_trace("선언되지 않은 DataSet입니다.");
		return;
	}
	
	//component id가 RDO인것만 처리, 추후 다른 component id 처리가 필요한 경우 수정필요
	var filterStr = "componentid.toString().indexOf('"+"RDO_"+"') >=0";
	vDsBind.filter(filterStr);
	
	for(var i=0; i <vDsBind.getRowCount(); i++)
	{
		var vDsComp = vDsBind.getColumn(i, "componentid");
		var vCalculate = vDsBind.getColumn(i, "calculate");
		
		//var vGetData = this.components[vDsComp].getData();
		var vGetData = this.objects["ds_tempItemValue"].getColumn(0, vDsComp);		
	
		var vValueComps;
		var vVal;
		
// 		if(utlf_isNull(vDsComp))
// 		{
// 			sysf_trace("선언되지 않은 Component입니다. /" + vDsComp);
// 			break;
// 		}
		
		if(vDsComp.indexOf("RDO_") > -1 && utlf_isNull(vGetData) &&!utlf_isNull(vCalculate))
		{
			//초기값 세팅
			var vCheckDataSetName = new String(this.components[vDsComp]["grupcd"]);
			vCheckDataSetName = "ds_data_V_"+vCheckDataSetName;
			var vCheckDataSet = this.objects[vCheckDataSetName];
			
			if(!utlf_isNull(vCheckDataSet))
			{
				//초기값 세팅
				this.components[vDsComp].setData(vCheckDataSet.getColumn(0, "termbasecd"));
				ds_tempItemValue.setColumn(0, vDsComp, vCheckDataSet.getColumn(0, "termbasecd"));
			}
			else
			{
				//dataset없음
			}
		
		}
		else if(!utlf_isNull(this.objects["ds_tempItemValue"].getColumn(0, vDsComp)))
		{	//value가 세팅이 실패했을때을 대비하여 선언
			//sysf_trace(vDsComp);
			this.components[vDsComp].setData(this.objects["ds_tempItemValue"].getColumn(0, vDsComp));
		}

		
	}
	
	vDsBind.filter("");
	//////////////////
	
	filterStr = "calculate.toString().indexOf('"+"RDO_"+"') >=0";
	vDsBind.filter(filterStr);
	

	for(var j=0; j <vDsBind.getRowCount(); j++)
	{
		var vCalculate = new String(vDsBind.getColumn(i, "calculate"));
		vValueComps = vCalculate.split("fn_getInt('ds_data_itemvalue.");
		vValueComps[0] ="";
		
		for(var h=1; h < vValueComps.length; h++)
		{
			var vSplit;
			vSplit = vValueComps[i].split("'");
			
			
			if(!utlf_isNull(vSplit[0]))
			{
				vValueComps[h] = vSplit[0];
				
				//sysf_trace("vValueComps[h] : " + vValueComps[h] + " , " + h);
				

				var vCompNm = vValueComps[h];
				var vVal="";
				
				if(vCompNm.indexOf("RDO") > -1)
				{
					if(utlf_isNull(this.objects["ds_tempItemValue"].getColumn(0, vCompNm)))
					{
						var vCheckDataSetName = new String(this.components[vCompNm]["grupcd"]);
						vCheckDataSetName = "ds_data_V_"+vCheckDataSetName;
						var vCheckDataSet = this.objects[vCheckDataSetName];
						
					}
					else if(!utlf_isNull(this.objects["ds_tempItemValue"].getColumn(0, vCompNm)))
					{
						this.components[vCompNm].setData(this.objects["ds_tempItemValue"].getColumn(0, vCompNm));
					}
						
				}
			
			}
			
		}
		
	}
	vDsBind.filter("");
	
}

/**********************************************************************************
 * Method Name  : lf_stxCheckNull
 * Description  : 산술식의 연산 결과를 반환하는 함수
 * argument     : component id : vCompID, 산술식 연산 결과 :vResult, 실제 산술식 : vCalculateDs
 * return Type  : vResultTemp(string)
 * Creator 	    :
**********************************************************************************/	
function lf_stxCheckNull(vCompID, vResult, vCalculateDs)
{
utlf_addLog("***** lf_stxCheckNull("+vCompID+", "+vResult+", "+vCalculateDs+") *****");
	var vCalculateDs = new String(vCalculateDs);
	var vResultTemp = vResult;
	
	
	//해당 산술식에 사칙연산이 있는 경우 SSL과 MSL은 사칙연산으로 판단
	if(vCalculateDs.indexOf("+") > -1 || vCalculateDs.indexOf("-") > -1 || vCalculateDs.indexOf("*") > -1 || vCalculateDs.indexOf("/") > -1
	|| vCalculateDs.indexOf("SSL_") > -1 || vCalculateDs.indexOf("MSL_") > -1)
	{
		var vNull;
		var vValueComps;
		vValueComps = vCalculateDs.split("fn_getInt('ds_data_itemvalue.");
		
		var vCheckNull = true;
		
		
		
		for(var i=1; i < vValueComps.length; i++)
		{
			var vSplit;
			vSplit = vValueComps[i].split("'");
			
			if(!utlf_isNull(vSplit[0]))
			{
				vValueComps[i] = vSplit[0];
				//sysf_trace(vValueComps[i]);
			}
			else
			{
				sysf_trace("오류 : lf_stxCheckNull 함수 0번 오류 발생");
				break;
			}
			
			
			var vCompNm = vValueComps[i];
			var vVal="";
			
				
			if(vCompNm.indexOf("RDO") > -1)
			{
				vVal = this.components[vValueComps[i]].getData();
			}
			else if(vCompNm.indexOf("BOL") > -1 || vCompNm.indexOf("CHK") > -1)
			{
				vVal = this.components[vValueComps[i]].value;
				if(vVal == "nonevalue")
				{
					vVal = "";
				}
			}
			else if(vCompNm.indexOf("MSL") > -1 || vCompNm.indexOf("SSL") > -1 )
			{
				if(vCompNm.indexOf("SSL") > -1)
				{
					vVal = this.objects["ds_data_itemvalue"].getColumn(0, vCompNm);
					
				}
				else
				{
					var vPno = vCompNm.split("_");
					
					//vPno[0] - MSL, vPno[1] - no
					//세부 SSU의 찾기
					for(var a=0; a < this.components.length; a++)
					{//degnitempnts
						if(!utlf_isNull(this.components[a]["supdegnitemno"]) && this.components[a]["supdegnitemno"] ==  vPno[1] && !utlf_isNull(this.components[a]["degnitempnts"]))
						{
							if(utlf_isNull(this.components[a].value))
							{
								//vVal = "";
							}
							else
							{
								vVal = "!Null";
								break;
							}
						}
					}
				}
			}
			else
			{
				vVal = this.components[vValueComps[i]].value;
			}		


			if(utlf_isNull(vVal))
			{
				vCheckNull = false;
				break;
			}
			
				
		}
		
		
	
		if(vCheckNull == false)
		{
			vResultTemp = "";
		}
			
		if(!utlf_isNull(vResultTemp))
		{
			if(vResultTemp == 0)
			{
				//vResultTemp = "";
			}
				
		}
		else
		{
			//vResultTemp = "";
		}


	}
	else if(vResultTemp == 0)
	{
		vResultTemp ="";
	}
	
	
	var vCheckResultNaNOrInfinity = new String(vResultTemp);
		
		
	if(("x" + vCheckResultNaNOrInfinity)  == "xNaN")
	{		
		vResultTemp = "";
	}
	else if(("x" + vCheckResultNaNOrInfinity)  == "xInfinity")
	{		
		vResultTemp = "";
	}
	
	var roundposition="";
	
	if(isNaN(vResultTemp) == false && !utlf_isNull(vResultTemp)) 
	{
		try
		{
		
				if(!utlf_isNull(this.components[vCompID].roundposition))
				{
					roundposition = this.components[vCompID].roundposition
				}
			
				if(roundposition.indexOf("-") > -1)
				{
					roundposition = roundposition.replace("-", "" );
				
				}
				else if(roundposition.indexOf("+") > -1)
				{
					roundposition = roundposition.replace("+", "" );
				}
				else
				{
					roundposition = 5;
				}	
			
			//vResultTemp = Math.round(vResultTemp,roundposition);  
		}
		catch(e)
		{
			roundposition = 2;
			//vResultTemp = Math.round(vResultTemp,roundposition);
		
		}
		finally
		{
			vResultTemp = Math.round(vResultTemp,roundposition);  
		}
	}

		
		
	return vResultTemp;
}







/**********************************************************************************
 * Method Name  : lf_stxCheckNotNull
 * Description  : 추후 lf_stxCheckNull와 통합
 * argument     : component id : vCompID, 산술식 연산 결과 :vResult, 실제 산술식 : vCalculateDs
 * return Type  : vResultTemp(string)
 * Creator 	    :
**********************************************************************************/	
function lf_stxCheckNotNull(vCompID, vResult, vCalculateDs)
{
utlf_addLog("***** lf_stxCheckNotNull("+vCompID+", "+vResult+", "+vCalculateDs+") *****");
	var vCalculateDs = new String(vCalculateDs);
	var vResultTemp = vResult;
	
	//sysf_trace("vCalculateDs : " + vCalculateDs);
	var vCheckNull = true;

	
	
	if(vCalculateDs.indexOf("+") > -1 || vCalculateDs.indexOf("-") > -1 || vCalculateDs.indexOf("*") > -1 || vCalculateDs.indexOf("/") > -1
	//|| vCalculateDs.indexOf("SSL_") > -1 || vCalculateDs.indexOf("MSL_") > -1)
	||((vCalculateDs.indexOf("SSL") > -1 || vCalculateDs.indexOf("MSL") > -1 || vCalculateDs.indexOf("RDO") > -1 || vCalculateDs.indexOf("CHK") > -1 || vCalculateDs.indexOf("CMB") > -1) 
	&& (vCalculateDs.indexOf("=") == -1)))
	{
		var vNull;
		var vValueComps;
		vValueComps = vCalculateDs.split("fn_getInt('ds_data_itemvalue.");
		
		vValueComps[0] ="";
		
		for(var i=1; i < vValueComps.length; i++)
		{
			var vSplit;
			vSplit = vValueComps[i].split("'");
			
			if(!utlf_isNull(vSplit[0]))
			{
				vValueComps[i] = vSplit[0];
				//sysf_trace(vValueComps[i]);
			}
			else
			{
				sysf_trace("오류 : lf_stxCheckNull 함수 0번 오류 발생");
				break;
			}
			
			
			var vCompNm = vValueComps[i];
			var vVal="";
			
				
			if(vCompNm.indexOf("RDO") > -1)
			{
				vVal = this.components[vValueComps[i]].getData();
			}
			
			else if(vCompNm.indexOf("CMB") > -1)
			{
				vVal =  vValueComps[i].value;
				if(!utlf_isNull(vVal))
				{
					vVal = 0;
				}
			}
			else if(vCompNm.indexOf("BOL") > -1 || vCompNm.indexOf("CHK") > -1)
			{
				vVal = this.components[vValueComps[i]].value;
				if(vVal == "nonevalue")
				{
					vVal = "";
				}
			}
			else if(vCompNm.indexOf("MSL") > -1 || vCompNm.indexOf("SSL") > -1 )
			{
				if(vCompNm.indexOf("SSL") > -1)
				{
					vVal = this.objects["ds_data_itemvalue"].getColumn(0, vCompNm);
					
				}
				else
				{
					var vPno = vCompNm.split("_");
					
					//vPno[0] - MSL, vPno[1] - no
					//세부 SSU의 찾기
					for(var a=0; a < this.components.length; a++)
					{//degnitempnts
						if(!utlf_isNull(this.components[a]["supdegnitemno"]) && this.components[a]["supdegnitemno"] ==  vPno[1] && !utlf_isNull(this.components[a]["degnitempnts"]))
						{
							if(utlf_isNull(this.components[a].value) || this.components[a].value == "nonevalue" )
							{
								//vVal = "";
							}
							else
							{
								vVal = "!Null";
								break;
								
							}
						}
					}
				}
			}
			else
			{
				vVal = this.components[vValueComps[i]].value;
				
				if(utlf_isNull(vVal))
				{
					vCheckNull = false;
					break;
				}
			
			}		

			if(utlf_isNull(vVal))
			{
				vVal="";
			}
			
			
			vValueComps[i] = vVal;
		
		}
		
		
		var vCk ="";
		for(var b=0; b < vValueComps.length; b++ )
		{
			vCk += vValueComps[b];
		}
		
		//sysf_trace("vCk :" + vCk);
		

		if(utlf_isNull(vCk))
		{	
			vResultTemp ="";
			return vResultTemp;
			
		}


	}
	else if(vResultTemp == 0)
	{
		vResultTemp ="";
	}
	
	
	
	if(vCheckNull == false)
	{
		vResultTemp = "";
	}
	

	
	var vCheckResultNaNOrInfinity = new String(vResultTemp);
		
		
	if(("x" + vCheckResultNaNOrInfinity)  == "xNaN")
	{		
		vResultTemp = "";
	}
	else if(("x" + vCheckResultNaNOrInfinity)  == "xInfinity")
	{		
		vResultTemp = "";
	}
	
	var roundposition="";
	

	if(isNaN(vResultTemp) == false && !utlf_isNull(vResultTemp)) 
	{
		try
		{
		
				if(!utlf_isNull(this.components[vCompID].roundposition))
				{
					roundposition = this.components[vCompID].roundposition;
				}
			
				if(roundposition.indexOf("-") > -1)
				{
					roundposition = roundposition.replace("-", "" );
				
				}
				else if(roundposition.indexOf("+") > -1)
				{
					roundposition = roundposition.replace("+", "" );
				}
				else
				{
					roundposition = 5;
				}	
			
			//vResultTemp = Math.round(vResultTemp,roundposition);  
		}
		catch(e)
		{
			roundposition = 2;
			//vResultTemp = Math.round(vResultTemp,roundposition);
		
		}
		finally
		{
			vResultTemp = Math.round(vResultTemp,roundposition);  
		}
	}

	return vResultTemp;
}


/**********************************************************************************
 * Method Name  : lf_tabKey
 * Description  : STX(Edit)로 포커스가 이동하였을때, 발생하는 이벤트
 * argument     : 
 * return Type  : 
 * Creator 	    : 
**********************************************************************************/	
function lf_tabKey(obj, e:SetFocusEventInfo)
{
	if(!utlf_isNull(obj.value))
	{
		var sVal = obj.value;
		var length =  sVal.length;
		 
		obj.setSelect(0,length);
	}
}




/**********************************************************************************
 * Method Name  : lf_calCal
 * Description  : 달력일자 계산
 * argument     : vFcompIDcompare
 * return Type  : 
 * Creator 	    : 
**********************************************************************************/	
 function lf_calCal(vFcompIDcompare)
 {
	if(utlf_isNull(vFcompIDcompare))
	{
		return;
	}
	
	var split;
	split = vFcompIDcompare.split("fn_getInt('ds_data_itemvalue.");
	
	var Count = split.length;

	if(Count > 4)
	{
		return;
	}
	
	if(Count == 2){
		return "noCal";
	}
	
	for(var i=1; i<Count; i++)
	{
		if(split[i].indexOf("CAL") > -1)
		{
			//var sFirstDesignNo = sCalculateSplit[0].replace(new RegExp("^[0-9]*$"),sCalculateSplit[0]);
			//var DesignNo = split[i].replace(new RegExp("^[0-9]*$"), split[i]);
			var DesignNo = split[i].split("'");
			split[i] = DesignNo[0]; 	
		}
		else
		{
			return;
		}
	}
	
	var sEndDate = ds_data_itemvalue.getColumn(0, split[1]);
	var sStartDate = ds_data_itemvalue.getColumn(0, split[2]);

	
	if(!utlf_isNull(sEndDate) && !utlf_isNull(sStartDate))
	{
		var returnvalue = utlf_diffDate(sStartDate, sEndDate);
		
		if(!utlf_isNull(returnvalue))
		{
			return returnvalue;
		}
		else
		{
			return null;
		}
		
	}
	else
	{
		return null;
	}
	
 }
 
 //제곱근 계산
function sqrt(value){
	if(utlf_isNull(value)) 
		return NaN;
	
    return Math.sqrt(value);
}

//자연로그 계산
function ln(value){

	if(utlf_isNull(value)) 
		return NaN;
	
    return Math.log(value);
}]]></Script>