/**
f * @fileoverview 프로젝트 utility 공통함수
 */
if (!JsNamespace.exist("LGE.Util")) {
	/**
	 * @namespace
	 * @name LGE.Util
	 * @author 
	 * @memberof! <global>	
	 */
	JsNamespace.declare("LGE.Util", {
		/**
		 * this formFile object 선언 변수
		 * @private
		 * @type string		 
		 * @memberOf LGE.Util
		 */ 
		ffobj : undefined,
		/**
		 * _msgFormSize
		 * @private
		 * @memberOf private
		 */
		_msgFormSize : {
			width : "400",
			height : "210",
			middle :{
				width : "400",
				height : "280"
			},
			max :{
				width : "600",
				height : "280"
			}
		},

		/**
		 * 객체 초기 onload 생성	
		 * @param {obj} Form obj
		 * @type 
		 * @example 
		 * @memberOf LGE.Util
		 */
		init : function(formObj) {
			this.ffobj = formObj; 
		},
		/**
		 * Message Popup(Alert, Confirm, Error) 공통 폼 사이즈 설정.
		 * @param {string} Size Type(max, min, middle)
		 * @type 
		 * @example 
		 * @memberOf LGE.Util
		 */
		setOpenMsg : function(sSizeType) {
			var strWidth, strHeight;

			if (Eco.isEmpty(sSizeType)) {
				sSizeType = "min";
			}
			
			switch(sSizeType) {
				case "max":
					strWidth = this._msgFormSize.max.width;
					strHeight = this._msgFormSize.max.height;
					break;
				case "middle":
					strWidth = this._msgFormSize.middle.width;
					strHeight = this._msgFormSize.middle.height;
					break;
				default:
					strWidth = LGE.Util._msgFormSize.width;
					strHeight = LGE.Util._msgFormSize.height;
					break;
			}

			return {width: strWidth, height: strHeight};
		},
		/**
		 * 부모에 존재하는 함수명 검색하여 호출
		 * @param {string} function명
		 * @return {string} 공백으로 치환값
		 * @example
		 *  LGE.Util.searchParentFunc("fn_func").call(this, arg1...);
		 * @memberOf LGE.Util
		 */
		searchParentFunc : function(fnName) {
			if(Eco.isEmpty(fnName)) {
				return;
			}

			var idx = 1, i = 0;
			var parentStr = "";
			var pThis = "this.ffobj.";
            var isFind = false;

			while(idx < 5) {
				if(Eco.isFunction(eval(pThis + parentStr + fnName)) == true) {
					isFind= true;
					break;
				}
				else {
					parentStr =  "parent." + parentStr;
					idx++;
				}
			}

			if(isFind) {
				isFind = eval(pThis + parentStr + fnName);
			}
			else {
				isFind = null;
			}

			return isFind;
	    },
	    
	    /**
		 * 호스트 정보 리턴
		 * @param 
		 * @return {string} host정보
		 * @example
		 *  var isHost = Ex.isGetHost() //output : LOCAL OR DEV OR OP	 
		 * @memberOf LGE.Util
		 */
		isGetHost : function() {
			if(Eco.isEmpty(application.gv_op)) {
				return "LOCAL";
			}

			if(application.gv_op.indexOf("LOCAL") != -1) {
				return "LOCAL";
			}
			else if(application.gv_op.indexOf("DEV") != -1) {
				return "DEV";
			}
			else if(application.gv_op.indexOf("QA") != -1) {
				return "QA";
			}
			else {
				return "OP";
			}
	    },
		/**
		 * 메인 폼인지 팝업인지 구분 
		 * @param {object} Form Object
		 * @return  Popup 여부(P 팝업 M 메인)
		 * @example
		 *  var isHost = LGE.Util.isForm() //output : p 팝업 M 메인 
		 * @memberOf LGE.Util
		 */
		isForm : function(obj) {
			if(Eco.isEmpty(obj)) {
				obj = this.ffobj;
			}

			if(Eco.isEmpty(obj.opener)) {
				return "M";
			}
			else {
				return "P";
			}
	    },
	    /**
	     * 디버그 메세지 출력
	     * @param {string} 메세지
	     * @return  debug message
	     * @example
	     *  LGE.Util.isDebug("Debug Mode On");
	     * @memberOf LGE.Util
	     */
	    isDebug : function(sMsg) {
			if(application.gv_debug == "Y") {
				//Ex.Logger.debug({message: "debug message !!!" + sMsg, elapsed: true, stack:true});
			}
	    },
		/**
		 * 해당 데이터셋명으로 검색하여 데이터셋이 없으면 데이터셋을 생성
		 * @param {string} 데이터셋명
		 * @return {string} dataset
		 * @example
		 * @memberOf LGE.Util
		 */
		isCheckDs : function(sDsNm, oForm) {
			if(Eco.isEmpty(oForm)) {
				oForm = this.ffobj;
			}

			var oDs = Eco.XComp.lookup(oForm, sDsNm);

			if (Eco.isEmpty(oDs)) {
				oDs = new Dataset;
				oDs.name = sDsNm;

				oForm.addChild(sDsNm, oDs);
			}
			else {
				oDs.clearData();
			}

			return oDs;
		},
		/**
		 * 해당 데이터셋명으로 검색하여 데이터셋 찾아서 리턴.
		 * @param {string} 데이터셋명
		 * @return {string} dataset(없으면 -1을 반환)
		 * @example
		 * @memberOf LGE.Util
		 */  
		getDataset : function(sDsNm) {
			return Eco.XComp.query(this.ffobj, "typeOf == 'Dataset' && prop[name] == '"+sDsNm+"'")[0];
		},
		/**
		 * = 을 배열로 분리 처리
		 * @param {string} objString (inds=inds)
		 * @param {number} 0 : 배열 첫번째값 1: 배열 두번째값
		 * @return {string} return 된 배열값
		 * @example
		 * @memberOf LGE.Util
		 */ 
		splitDsName : function(objString, type) {
			var objReturn = new Array();

			if(Eco.isEmpty(objString)) {
				return objReturn;
			}

			var strDsMapping = objString.split(" ");			//mapping string
			var objArr;					//dataset name array

			for (var i=0; i<strDsMapping.length; i++ ) {
				objArr = strDsMapping[i].split("=");    // objArr = a,cd
				if (type == 0) {
					objReturn[i] = objArr[0];
				}
				else {
					objReturn[i] = objArr[1];
				}
			}

			return objReturn;
		},
		/**
		 * dataset object에서 키에 해당되는 Row를 찾아서 삭제
		 * @param {object} dataset
		 * @param {string} 키칼럼
		 * @param {string} :키값
		 * @param {string} 서브키칼럼
		 * @param {string} :서브 키값
		 * @return N/A
		 * @example
		 * @memberOf LGE.Util
		 */  
		deleteData : function (ObjDs, strIdCol, strId, strSubCol, strSubId) {
			var curRow = LGE.Util.findData(ObjDs, strIdCol, strId, strSubCol, strSubId);

			ObjDs.deleteRow(curRow);
		},
		/**
		 * dataSet object에서 키에 해당되는 Row를 찾아서 rowpostion 리턴.
		 * @param {object} dataset
		 * @param {string} 키칼럼
		 * @param {string} :키값
		 * @param {string} : 서브키칼럼
		 * @param {string} :서브 키값
		 * @return N/A
		 * @example
		 * @memberOf LGE.Util
		 */  
		findData : function (ObjDs, strIdCol, strId, strSubCol, strSubId) {
			if (Eco.isEmpty(strSubCol)) {
				return ObjDs.findRow(strIdCol, strId.toString());
			}

			return ObjDs.findRowExpr(strIdCol + " == '" + strId + "' && " + strSubCol + " == '" + strSubId + "'");
		},
		/**
		 * dataset object에서 키에 해당되는 Row를 찾아서 이동
		 * @param {object} dataset
		 * @param {string} 키칼럼
		 * @param {string} :키값
		 * @param {string} : 이동할 Row,
		 * @param {string} :서브키칼럼
		 * @param {string} : 서브 키값
		 * @return N/A
		 * @example
		 * @memberOf LGE.Util
		 */
		moveData : function (ObjDs, strIdCol, strId, newRow, strSubCol, strSubId) {
			var curRow = LGE.Util.findData(ObjDs, strIdCol, strId, strSubCol, strSubId);

			ObjDs.moveRow(curRow, newRow);
		},
		/**
		 * dataset object에서 키에 해당되는 Row를 찾아서 값을 변경.
		 * @param {object} dataset
		 * @param {string} 키칼럼
		 * @param {string} :키값
		 * @param {string} : 변경할 칼럼
		 * @param {string} :변경값
		 * @param {string} : 서브키칼럼
		 * @param {string} : 서브 키값
		 * @return N/A
		 * @example
		 * @memberOf LGE.Util
		 */
		editData : function (ObjDs, strIdCol, strId, valCol, newVal, strSubCol, strSubId) {
			var curRow = LGE.Util.findData(ObjDs, strIdCol, strId, strSubCol, strSubId);
			
			return ObjDs.setColumn(curRow, valCol, newVal);
		},
		/**
		 * dataset object에서 가져오는 함수 Null경우에는 Type에 의한 예외처리 하여 반환
		 * @param {object} dataset
		 * @param {string} 키칼럼
		 * @param {string} :키값
		 * @param {string} : 변경할 칼럼
		 * @param {string} :변경값
		 * @param {string} : 서브키칼럼
		 * @param {string} : 서브 키값
		 * @return N/A
		 * @example
		 * @memberOf LGE.Util
		 */
		getData : function(ObjDs, nRow, sColId, sVal) {
			var oData = ObjDs.getColumn(nRow, sColId);
		    var oColInfo = ObjDs.getColumnInfo(sColId);
		    if (Eco.isEmpty(oColInfo)) {
				return "";
			}
		    var sType = oColInfo.type;

		    if (Eco.isEmpty(sVal)) {
				switch (sType.toUpperCase()) {
					case "STRING" : 
						sVal = "";
						break;
					case "BIGDECIMAL":
					case "INT":
					case "FLOAT":
						sVal = 0;
						break;
				}
			}

			return (Eco.isEmpty(oData)) ? sVal : oData;
		},
		/**
		 * dataSet object에서 키에 해당되는 Row를 찾아서 칼럼값을 리턴
		 * @param {object} dataset
		 * @param {string} 키칼럼
		 * @param {string} :키값
		 * @param {string} : dataSet 칼럼
		 * @param {string} :변경값
		 * @param {string} : 서브키칼럼
		 * @param {string} : 서브 키값
		 * @return N/A
		 * @example
		 * @memberOf LGE.Util
		 */
		getLookupData : function (ObjDs, strIdCol, strId, strInfo, strSubCol, strSubId) {
			var strVal;
			var curRow = LGE.Util.findData(ObjDs, strIdCol, strId, strSubCol, strSubId);
			
			if (curRow < 0) {
				return "";
			}

			strVal = ObjDs.getColumn(curRow, strInfo);

			return Eco.isEmpty(strVal) ? "" : strVal;
		},
		/**
		 * dataSet의 Row 중에서 변경된 내용이 있는지 여부를 리턴
		 * @param {object} DataSet
		 * @return {boolen} true = 변경 된 데이터가 존재 , false = 변경 된 데이터가 없음
		 * @example
		 * @memberOf LGE.Util
		 */
		isUpdated : function (objDs) {
			if(objDs.getDeletedRowCount() > 0) {
				return true;
			}

			if(objDs.findRowExpr("(this.getRowType(rowidx)==Dataset.ROWTYPE_UPDATE)||(this.getRowType(rowidx)==Dataset.ROWTYPE_INSERT)") > -1) {
				return true;
			}

			return false;
		},
		/**
		 * dataSet의 Row가 변경되었는지 여부를 리턴
		 * @param {object} objDs(DataSet)
		 * @param {number} 체크할 Row index
		 * @return {boolen} true = 변경 된 데이터가 존재 , false = 변경 된 데이터가 없음
		 * @example
		 * @memberOf LGE.Util
		 */
		isUpdatedRow : function (objDs, nRow) {
			if (objDs.updatecontrol == true) {
				if (objDs.getRowType(nRow) == 2 || objDs.getRowType(nRow) == 4) {
					return true;
				}

				return false;
			}
			else {
				for (var i = 0; objDs.getColCount(); i++) {
					if (this.gfn_IsUpdateColumn(objDs, nRow, i) == true) {
						return true;
					}
				}
			}

			return false;
		},
		/**
		 * dataSet의 Row 에서 해당 칼럼이 변경되었는지 여부를 리턴.
		 * @param {object} objDs(DataSet)
		 * @param {number} 체크할 Row index
		 * @param {string} 체크할 컬럼값
		 * @return {boolen} true = 변경 된 데이터가 존재 , false = 변경 된 데이터가 없음
		 * @example
		 * @memberOf LGE.Util
		 */
		isUpdateColumn : function (objDs, nRow, Column) {
			if (objDs.getRowType(nRow) == 2) {
				if (Eco.isEmpty(objDs.getColumn(nRow, Column))) {
					return false;
				}
			}
			else {
				if (objDs.getColumn(nRow, Column) == objDs.getOrgColumn(nRow, Column)) {
					return false;
				}
			}

			return true;
		},
		/**
		 * Dataset의 모든 행을(혹은 변경된 행만) 함수의 인자로 넘겨주고 함수 호출
		 * @param {object} objDs(DataSet)
		 * @param {string} 호출할 함수
		 *                 Function(oDs, nRowIdx)으로 선언해야 함.
		 *                 false를 리턴하면 반복문 skip.
		 * @param {boolen} 변경된 데이터만 호출할지 여부
		 * @return {string} Skip 해당 RowNum or 반복한 총 횟수
		 * @example
		 * @memberOf LGE.Util
		 */
		allRowDataCall : function (dsObj, callFncObj, bModifiedOnly) {
			var retVal;

			for (var i=0,j=0; i<dsObj.getRowCount(); i++) {
				if (bModifiedOnly && !(dsObj.getRowType(i) == 2 || dsObj.getRowType(i) == 4)) {
					continue;
				}

				retVal = callFncObj(dsObj, i);
				j++;

				if(retVal == false) {
					return i;
				}
			}

			return j;
		},
		/**
		 * Dataset의 필터한 정보를 대상 Dataset으로 Copy
		 * @param {object} 목적데이타셋dsDs(DataSet)
		 * @param {string} 처리데이타셋
		 * @param {string} 필터표현
		 * @return N/A
		 * @example
		 * @memberOf LGE.Util
		 */
		dsFilter : function(dsSc, dsTg, sFilterExpr) {
			var sKeyString = dsSc.keystring;
			
			if (!Eco.isEmpty(sKeyString)) {
				sKeyString = sKeyString.toString();
			}

			dsSc.set_keystring("");
			dsSc.filter(sFilterExpr);
			dsTg.copyData(dsSc, true);
			dsSc.filter("");

			if (!Eco.isEmpty(sKeyString)) {
				dsSc.set_keystring(sKeyString);
			}
		},
		getColumnIdx : function(objDs, sColumnId) {
			var nColumnCnt = (objDs.getColCount() - objDs.getConstCount());
			if(objDs == null || nColumnCnt == 0) {
				return -1;
			}

			for(var i=0; i<nColumnCnt; i++) {
				if(objDs.getColID(i) == sColumnId) {
					return i;
				}
			}

			return -1;
		},
		/**
		 * 해당 PC의 오늘 날짜를 리턴.
		 * @return {string] 오늘날짜
		 * @example
		 * @memberOf LGE.Util
		 */
		today : function () {
			return Eco.date.getMaskFormatString(new Date(), "yyyyMMdd");
		},
		/**
		 * 해당 PC의 오늘 날짜를 사용자 Locale에 맞춰 리턴.
		 * @return {string] 오늘날짜
		 * @example
		 * @memberOf LGE.Util
		 */
		localeToday : function () {
			sMask = application.gds_UserInfo.getColumn(0, "dbseparatedateformat");
				
			return Eco.date.getMaskFormatString(new Date(), sMask);
		},
		/**
		 * 해당 PC의 오늘 날짜+시간를 리턴.
		 * @return {string] 오늘날짜 + 시간
		 * @example
		 * @memberOf LGE.Util
		 */
		todayTime : function () {
			return Eco.date.getMaskFormatString(new Date(), "yyyyMMddHHmmss");
		},
		/**
		 * 해당 PC의 오늘 날짜+시간를 사용자 Locale에 맞춰 리턴.
		 * @return {string] 오늘날짜 + 시간
		 * @example
		 * @memberOf LGE.Util
		 */
		localeTodayTime : function () {
			sMask = application.gds_UserInfo.getColumn(0, "dbseparatedateformat")
					+ " " + application.gds_UserInfo.getColumn(0, "dbseparatetimeformat");
			return Eco.date.getMaskFormatString(new Date(), sMask);
		},
		getlocaleDate: function(sDate, sMask){
			if(Eco.isEmpty(sDate)) {
				return "";
			}

			if(Eco.isEmpty(sMask)) {
				sMask = application.gds_UserInfo.getColumn(0, "dbseparatedateformat");
			}

			if(Eco.isEmpty(sMask)) {
				return sDateTime;
			}

			return Eco.date.getMaskFormatString(Eco.date.strToDate(sDate), sMask);
		},
		/**
		 * 문자열이 날짜 형식에 맞지는 체크.
		 * @param {string} 날짜 형식의 문자열
		 * @return {boolean} 날짜 형식에 맞는 지 여부
		 * @example LGE.Util.getlocaleDateTime("20150101121212")
		 * @memberOf LGE.Util
		 */
		getlocaleDateTime: function(sDateTime, sMask) {
			if(Eco.isEmpty(sDateTime)) {
				return "";
			}

			sDateTime = nexacro.replaceAll(sDateTime, " ", "");

			if(Eco.isEmpty(sMask)) {
				sMask = application.gds_UserInfo.getColumn(0, "dbseparatedateformat");
				sMask += " " + application.gds_UserInfo.getColumn(0, "dbseparatetimeformat");
			}
			
			if(Eco.isEmpty(sMask)) {
				return sDateTime;
			}

			return Eco.date.getMaskFormatString(Eco.date.strToDate(sDateTime), sMask);
		},
		/**
		 * 문자열이 날짜 형식에 맞지는 체크.
		 * @param {string} 날짜 형식의 문자열
		 * @return {boolean} 날짜 형식에 맞는 지 여부
		 * @example LGE.Util.isVaildDate("20150101")
		 * @memberOf LGE.Util
		 */
		isVaildDate : function (sDate) {
			var sDate = String(sDate).toString();
			var oDate = Eco.date.strToDate(sDate);

			return (sDate == Eco.date.getMaskFormatString(oDate, "yyyyMMdd"));
		},
		/**
		 * 두 날짜의 차이를 리턴.
		 * @param {string} 시작일자
		 * @param {string} 종료일자
		 * @return {number} 두 날짜의 차이 값(시작이 클 경우 음수)
		 * @example
		 * @memberOf LGE.Util
		 */
		diffdate : function (sFrom, sTo) {
			return Eco.date.getDiffDay(Eco.date.strToDate(sFrom), Eco.date.strToDate(sTo));
		},
		removeSpecialChar : function(sVal, sSpecial) {
			if(Eco.isEmpty(sVal)) {
				return sVal;
			}

			if(Eco.isEmpty(sSpecial)) {
				sSpecial = "~!@#$%^&*-+:;,./=_`{|}()[]\\?<>";
			}

			var sRetValue = "";

			for(var i=0; i<sVal.length; i++){
				if(sSpecial.indexOf(sVal.charAt(i)) == -1)
					sRetValue += sVal.charAt(i);
			}
			return sRetValue;
		},
		/**
		 * 입력값이 e-mail Type인지 체크하는 함수
		 * @param {string} strValue
		 * @return true = 입력값이 email형태일 경우
		 * @example
		 * @memberOf LGE.Util
		 */
		checkEmail : function (strValue) {
			if (Eco.isEmpty(strValue)) {
				return false;
			}

			var nIndexOfAt = strValue.indexOf("@");
			var nIndexOfDot = strValue.indexOf(".");
			var nLength = strValue.length;

			// "@" 이 하나도 없거나 맨 끝에 위치한  경우
			if (nIndexOfAt <= 0 || nIndexOfAt == nLength) {
				return false;
			}

			// "." 이 하나도 없거나 맨 끝에 위치한 경우
			if (nIndexOfDot <= 0 || nIndexOfDot == nLength) {
				return false;
			}

			// "@"이 두개 이상 존재하는 경우
			if (strValue.indexOf("@", nIndexOfAt + 1) != -1) {
				return false;
			}

			// ".@" 인 경우 또는 "@."인 경우
			if (strValue.substr(nIndexOfAt - 1, 1) == "." || strValue.substr(nIndexOfAt + 1, 1) == ".") {
				return false;
			}

			// "@" 이후에 "."이 존재하지 않는 경우
			if (strValue.indexOf(".", (nIndexOfAt + 2)) == -1) {
				return false;
			}

			// 공백문자가 존재하는 경우
			if (strValue.indexOf(" ") != -1) {
				return false;
			}

			return true;
		},
		getBindColumn: function(obj, icell) {
			var sText = String(obj.getCellProperty("body", icell, "text"));
			if(sText.indexOf("bind:") == -1) {
				return "";
			}

			return sText.split(":")[1];
		},
		/**
		 * Font Object 생성 후 리턴.
		 * @param {object} obj
		 * @param {number} iFontSize
		 * @param {string} 폰트명
		 * @param {string} sType
		 * @return {array] 변형문자열
		 * @example
		 * @memberOf LGE.Util
		 */ 
		getObjFont : function (obj, iFontSize, sFontName, sType) {
			var objFont = obj.currentstyle.font;
			
			sType = (Eco.isEmpty(sType)) ? "normal" : sType;
			objFont.set_size(iFontSize);
			objFont.set_face(sFontName);
			objFont.set_type(sType);

			return objFont;
		},
		/**
		 * 인자를 넘겨줄 경우에 넘겨주는 규칙대로 '인자=값'으로 리턴
		 * @param {string} 설정할 파리미터명
		 * @param {string} p_value - 설정할 값
		 * @return {string] String
		 * @example
		 *     paramStr += gfn_SetParam("sql_xml", "gspl_sql_common");
		 * @memberOf LGE.Util
		 */
		setParam : function (p_name, p_value) {
			return p_name + "=" + this.isNvl(p_value, "") + "&nbsp;";
		},
		/**
		 * 입력값이 null에 해당되면 val2(대체문자열)로 리턴.
		 * @param {string} val : 체크할 문자열( 예 : null 또는 undefined 또는 "" 또는 "abc" )
		 * @return {string}  val값이 null에 해당하는 경우 val2값으로 대체 반환
		 * @example
		 * @memberOf LGE.Util
		 */   
		isNvl : function(val, val2) {
			var rtnVal = (Eco.isEmpty(val)) ? val2 : val;
			return rtnVal;
		},
		/**
		 * decode 처리
		 * @param {string} val : 체크할 문자열( 예 : null 또는 undefined 또는 "" 또는 "abc" )
		 * @return {string}  val값이 null에 해당하는 경우 val2값으로 대체 반환
		 * @example
		 * @memberOf LGE.Util
		 */ 
		gDecode : function() {
		   	var varRtnValue = null;
		   	var arrArgument = arguments;
		   	var varValue = arrArgument[0];
		   	var bIsDefault = false;
		   	var nCount = 0;

		   	if ((arrArgument.length % 2) == 0) {
				nCount = arrArgument.length - 1;
				bIsDefault = true;
		   	}
		   	else {
				nCount = arrArgument.length;
				bIsDefault = false;
			}

			for (var i = 1; i < nCount; i+=2) {
				if (varValue == arrArgument[i]) {
					varRtnValue = arrArgument[i+1];
					i = nCount;
				}
			}

			if (varRtnValue == null && bIsDefault) {
				varRtnValue = arrArgument[arrArgument.length-1];
			}

			return varRtnValue;
		},
		/**
		 * 해당 Object의 Child Component value를 Empty 처리.
		 * @param {object} Child Component를 가질 수 있는 object(Form, div, tab...)
		 * @return N/A
		 * @example LGE.Util.setEmptyValue(this.divTest);
		 * @memberOf LGE.Util
		 */ 
		setEmptyValue : function (obj) {
			var sCompType = "typeOf == 'Combo'"
						+ " || typeOf == 'Edit'"
						+ " || typeOf == 'MaskEdit'"
						+ " || typeOf == 'TextArea'"
						+ " || typeOf == 'Calendar'"
						+ " || typeOf == 'ExtCombo'"
						+ " || typeOf == 'ExtMultiCombo'"
						+ " || typeOf == 'Ext2DepthCombo'"
						+ " || typeOf == 'Ext2DepthMultiCombo'"
						+ " || typeOf == 'SearchCombo'"
						+ " || typeOf == 'FromToCalendar'";
			var oComp = Eco.XComp.query(obj, sCompType);
			var strType = "";

			for (var i=0; i<oComp.length; i++) {
				switch(oComp[i].toString().toUpperCase()) {
					case "[OBJECT CALENDAR]":
					case "[OBJECT EDIT]":
					case "[OBJECT MASKEDIT]":
					case "[OBJECT TEXTAREA]":
						oComp[i].set_value("");
						break;
					case "[OBJECT COMBO]":
						oComp[i].set_index(0);
						break;
					case "[OBJECT EXTCOMBO]":
					case "[OBJECT EXTMULTICOMBO]":
					case "[OBJECT EXT2DEPTHCOMBO]":
						oComp[i].setValue("");
						break;
					case "[OBJECT EXT2DEPTHMULTICOMBO]":
						oComp[i].setEmptyValue();
						break;
					case "[OBJECT SEARCHCOMBO]":
						oComp[i].setValue(null);
						break;
					case "[OBJECT FROMTOCALENDAR]":
						oComp[i].set_fromValue("");
						oComp[i].set_toValue("");
						break;
				}
			}
		},
		/**
		 * 현재 플랫폼의 OS종류를 리턴.
		 * @return {string}  반환os
		 * @example
		 * @memberOf LGE.Util
		 */ 
		getOS : function() {
			var osVersion = system.osversion;
			
			if (Eco.isEmpty(osVersion)) {
				return "ETC";
			}

			osVersion = osVersion.toUpperCase();

			if (osVersion.indexOf("ANDROID") >= 0) {	// android 
				return "ANDROID";
			}
			else if ( osVersion.indexOf("IOS") >= 0 ) {
				return "IOS";
	   		}
			else if ( osVersion.indexOf("WINDOWS") >= 0 ) {
				return "WINDOWS";
			}
			else {
				return "ETC";
			}
		}
	});
}