yctb-SpringBoot/web/js/v2/fw/fw.eglt.js

/**
 * @author herong 可编辑多记录组件
 */
var CFWEGlt = _FW.fCreateClass();
/**
 * 可编辑多记录组件API
 */
CFWEGlt.prototype = {
	fInitialize : function(options) {

	},
	
	/**
     * 多记录列表数据显示完毕后调用自定义函数
     * @param  String sListID(必需)  多记录表的配置ID名称
     * @param  String sFunName(必需) 自定义的函数名
     * @return true、false
     * <pre>
     * 使用举例：
     *     CFW.oEGlt.doLoad(ListID,'myfun') ;
     *     function myfun(){}
     *   或
	 *     CFW.oEGlt.doLoad(ListID,CBxgx.oComm.myfun) ;
     * </pre>
     */
    doLoad : function (sListID, sFunName) {
    	if(CFW.oValid.fnIsNull(sListID,"CFW.oEGlt.doLoad 多记录表的配置ID名称")){
		     return false;
	    }
    	if(CFW.oValid.fnIsNull(sFunName,"CFW.oEGlt.doLoad 自定义的函数名")){
		     return false;
	    }
    	
        var target = eval('document.all.' + sListID);
        var opts = null;
        if (jQuery.data(target, 'fwdatagrid') != null) {
            opts = jQuery.data(target, 'fwdatagrid').options;
        } else {
            opts = jQuery.data(target, 'fweditgrid').options;
        }
        
        var fun = window[sFunName];
        if (typeof sFunName == 'function') {
        	 fun = sFunName;
    	}
        opts.onLoadSuccess = fun;
        return true;
    },
    
    
    /**
     * 行选择函数
     * 改变选中行的颜色或是单击某行记录的任何地方进行勾选
     * 主要是配合 doClick、doDblClick使用
     * @param String sListID(必需)  只读多记录表单的配置ID
     * @param int    rowindex(必需) 行序号(从0开始)
     * @param String type(必需)     应用的类型字符串例如：row=s|input=checkbox
     *   其中 row 属性表示行的颜色需要改变 
     *   若 row=n 表示不需要改变行颜色
     *   若 row=s 表示单选行只改变选中行的颜色
     *   若 row=m 表示只要选中都改变颜色
     *   input 属性表示选择行后勾选框的勾选上
     *   若 input=checkbox 表示多选框
     *   若 input=radio 表示单选框
     * <pre>
     * 使用举例：
     *     1.改变行颜色而且是单选行,若列表有勾选框不自动勾选
     *       var sMark='row=s'
     *       CFW.oEGlt.fnSelectedRows('zhcx_grjbzltest3',0,sMark);
     *     2.改变行颜色,若列表有勾选框自动勾选
     *       var sMark='row=s|input=checkbox'
     *       CFW.oEGlt.fnSelectedRows('zhcx_grjbzltest3',0,sMark);
     * </pre>
     */
    fnSelectedRows : function(sListID,rowindex,type){
    	if(CFW.oValid.fnIsNull(sListID,"CFW.oEGlt.fnSelectedRows 多记录表单的配置ID")){
		     return ;
	    }
    	if(CFW.oValid.fnIsNull(rowindex,"CFW.oEGlt.fnSelectedRows 行序号")){
		     return ;
	    }
	    if(CFW.oValid.fnIsNull(type,"CFW.oEGlt.fnSelectedRows 应用的类型字符串")){
		     return ;
	    }
    	 var grid =$('#'+sListID);
    	 var tmp,chk,arry1,arry2,sRow='',sInput='';
    	 var str = type.toLowerCase();
    	 
        if(str==''||str==null){
       	   str='row=s|input=checkbox'; 
        } 
        arry1 = str.split('|');
        
        for(var i=0;i<arry1.length;i++){ 
       	 tmp   = arry1[i];
       	 arry2 = tmp.split('=');
       	 
       	 if(arry2[0]=='row'){sRow=arry2[1];}
       	 if(arry2[0]=='input'){sInput=arry2[1];}
        }
        
        //执行单行选择并改变颜色时，需要去掉已选的颜色
        if(sRow=='s'){ 
           $('.fweditgrid-view tbody tr[class*=fweditgrid-row-selected]', grid).each(function(){
    		   $(this).removeClass('fweditgrid-row-selected');
    	    }); 
         }
        
    	 $('.fweditgrid-view tbody tr[fweditgrid-row-index='+rowindex+']', grid).each(function(){
    		 //单行或是多行选择
    		 if(sRow=='s'||sRow=='m'){ 
    		    $(this).addClass('fweditgrid-row-selected');
    		 }
    		 
    		 //需要对选择框做处理
    		 if(sInput!=''){ 
    			 chk = $('[type="'+sInput+'"]',$(this)).attr("checked"); 
    			 if(!chk){ 
    			     $('[type="'+sInput+'"]',$(this)).attr("checked",true);
    			 }//else{ 
    			   //  $('[type="'+sInput+'"]',$(this)).attr("checked",false);
    			 //} 
    		 } 
    	 });	   
    }, 
    
	 /**
     * where条件修改后，重新刷新多记录表的数据
     * @param  String sListID(必需) 多记录表的配置ID名称
     * @param  String sWhere(必需)  新的查询条件
     * @param  int    pageNum 为刷新列表后显示第几页的数据，-1表示当前页，默认为1，不能输入0或负数
     * @return true、false
     * <pre>
     * 使用举例：
     *     第一种应用的方式：
     *         刷新后显示第一页，第三个入参可以不用写
     *         CFW.oEGlt.fnGetData('fw_blank_todolist'," OPERID='23' ") ;
     *     第二种应用的方式：
     *         刷新后显示第6页的内容
     *         CFW.oEGlt.fnGetData('fw_blank_todolist'," OPERID='23' ",6) ;
     * </pre>
     */
    fnGetData : function(sListID, sWhere, iPageNum,successFunName,erroFunName){
    	iPageNum = iPageNum || 1;
    	if(CFW.oValid.fnIsNull(sListID,"CFW.oEGlt.fnGetData 多记录表的配置ID名称")){
		     return false;
	    }
    	if(CFW.oValid.fnIsNull(sWhere,"CFW.oEGlt.fnGetData 新的查询条件")){
		     return false;
	    }
    	if(!CFW.oValid.fnIsInteger(iPageNum)){
    		CFW.oWin.fnAlert('页号必须为整数');
		     return false;
	    }
    	if(iPageNum <= 0 && iPageNum!=-1){
    		CFW.oWin.fnAlert('页号不能为0或负数');
    		return false;
    	}
        var target = eval('document.all.'+sListID);
        var opts ;
        if (jQuery.data(target, 'fwdatagrid') != null) {
            opts = jQuery.data(target, 'fwdatagrid').options;
            var successfun = window[successFunName];
	   	     if (typeof successFunName == 'function') {
	   	    	 successfun = successFunName;
	   	    	 opts.onLoadSuccess = successfun;
	   	     }
	   	     
	   	     var errorfun = window[erroFunName];
	   	     if (typeof erroFunName == 'function') {
	   	    	 errorfun = erroFunName;
	   	    	opts.onLoadError = errorfun;
	   	     }
            opts.ReGetListData(target, sWhere, iPageNum);
            return true;
        }
        
        if (jQuery.data(target, 'fweditgrid') != null) {
            opts = jQuery.data(target, 'fweditgrid').options;
            var successfun = window[successFunName];
	   	     if (typeof successFunName == 'function') {
	   	    	 successfun = successFunName;
	   	    	 opts.onLoadSuccess = successfun;
	   	     }
	   	     
	   	     var errorfun = window[erroFunName];
	   	     if (typeof erroFunName == 'function') {
	   	    	 errorfun = erroFunName;
	   	    	opts.onLoadError = errorfun;
	   	     }
            opts.ReGetListData(target, sWhere, iPageNum);
            return true;
        }
         return true;
    },

	/**
	* 功能描述:增加一行或多行的行数据（只作用于jQuery集合中的第一个多记录表）。
	* 功能详细说明:此处增加只是在页面多记录表中增加显示内容，并未增加实际数据。
	*
	* @param sGltID
	*            (必需) 多记录配置ID，String
	* @param oDatas(必需)
	*            行数据对象
	* @Returns: int 添加后当前页面的总行数
	*
	* <pre>
	* 使用方法举例:
	*  	var rowDatas=[
	*     		{
	*         		&quot;ETEXT&quot;:&quot;20011502&quot;,&quot;RDATE&quot;:&quot;2111-11-02&quot;,
	*         		&quot;EDATE&quot;:&quot;2211-12-12&quot;,&quot;SPBZ&quot;:&quot;1&quot;,
	*        		&quot;ROWNUM_&quot;:&quot;3&quot;,&quot;TBID&quot;:null,&quot;RTEXT&quot;:&quot;20111202&quot;,
	*        		&quot;_DIC_SPBZ&quot;:&quot;已审批&quot;,&quot;SPBZ_CMB&quot;:&quot;已审批&quot;
	*     		}
	*    	];
	*  	var rstLen=CFW.oEGlt.fnAddRows('demo_api_eglt_test', rowDatas);
	*  	alert("fnAddRows()返回结果: " + rstLen);    //输出测试 打印返回结果
	* </pre>
	*/
	fnAddRows : function(sGltID, oDatas) {
		if (CFW.oValid.fnIsNull(sGltID, "CFW.oEGlt.fnAddRows  多记录表配置ID")) {
			return;
		}
		if (CFW.oValid.fnIsNull(oDatas, "CFW.oEGlt.fnAddRows  行数据对象")) {
			return;
		}
		var rowsData = [];
		if ($.isArray(oDatas)) {
			rowsData = oDatas;
		} else {
			rowsData = [ oDatas ];
		}
		// 如果没有新增数据，那么什么都不用该处理
		if (rowsData.length == 0) {
			return $("#" + sGltID);
		}
		return $("#" + sGltID)
				.first()
				.map(
						function() {
							// 获取本多记录表已经有的行数据
							var opts = $.data(this, 'fweditgrid').options;
							var view = $.data(this, 'fweditgrid').view;
							var table = view.children('table')[0];
							var data = opts.data;
							var rows = data.rows || [];
							var startRow = rows.length;
							// 增加行数据
							rows = rows.concat(rowsData);
							data.rows = rows;
							// 增加总计
							data.total += rowsData.length;
							var iPageNum = (parseInt(opts.pageNumber, 10) - 1)
									* parseInt(opts.pageSize, 10);

							// 逐行处理
							var frag = document.createDocumentFragment();
							for ( var iRow = startRow, len = rows.length; iRow < len; iRow++) {
								var tr = CFW.oEGlt._fnGenOneRow(opts, opts.data.headers,
										iPageNum + 1, iRow, rows);
								frag.appendChild(tr);
							}
							table.tBodies[0].appendChild(frag);
							view[0].scrollTop = view[0].scrollHeight;
							// 调整底部的颜色
							CFW.oEGlt._fnSetAlt(this);
							return rows.length;
						}).get(0);

		// return $('#'+sGltID).fweditgrid('addRows',oDatas);
	},
	/**
	* 功能描述:更新多记录表中的行数据。 功能详细说明:此处更新只是更新页面上多记录表的显示内容，并未更新实际数据。
	*
	* @param sGltID
	*            (必需) 多记录配置ID，String
	* @param aDatas
	*            oDatas 行数据对象,可* 以不传，不传表示根据多记录表现有
	*            数据刷新界面ui。如果配置了第二个参数，那么将用传入的参数替换原有数据。
	*
	* <pre>
	* 使用方法举例:
	*    使用方法：
	*    //要更新的行数据
	*    var rowDatas=[
	*       {
	*           &quot;ETEXT&quot;:&quot;20011502&quot;,&quot;RDATE&quot;:&quot;2111-11-02&quot;,
	*           &quot;EDATE&quot;:&quot;2211-12-12&quot;,&quot;SPBZ&quot;:&quot;1&quot;,
	*           &quot;ROWNUM_&quot;:&quot;3&quot;,&quot;TBID&quot;:null,
	*           &quot;RTEXT&quot;:&quot;20111202&quot;,
	*           &quot;_DIC_SPBZ&quot;:&quot;已审批&quot;,&quot;SPBZ_CMB&quot;:&quot;已审批&quot;
	*       }
	*    ];
	*    CFW.oEGlt.fnUpdateRows('demo_api_eglt_test');  无参数
	*    CFW.oEGlt.fnUpdateRows('demo_api_eglt_test',rowDatas);  带参数
	* </pre>
	*/
	fnUpdateRows : function() {
		if (CFW.oValid.fnIsNull(arguments[0], "CFW.oEGlt.fnUpdateRows  多记录表配置ID")) {
			return;
		}
		var rowsData = null;
		// 获取新行的数据，如果是单值，那么用数组包装，如果是数组那个直接赋值
		// 如果参数个数不对，那么报错处理
		if (arguments.length == 1) {
		} else if (arguments.length == 2) {
			if ($.isArray(arguments[1])) {
				rowsData = arguments[1];
			} else {
				rowsData = [ arguments[1] ];
			}
		}
		return $("#" + arguments[0]).each(function() {
			// 获取本多记录表已经有的行数据
			var opts = $.data(this, 'fweditgrid').options;
			var data = opts.data;
			// 如果有传入新的行数据，那么全部用新记录替换旧记录
			if (rowsData) {
				data.rows = rowsData;
			} else {
				// 没有的话，当作刷新页面数据处理
			}
			CFW.oEGlt._fnLoadData(this, data);

			// createMsg(this);
			CFW.oEGlt._fnShowInfo(this);

		});
	},
    /**
     * 按当前条件刷新列表
     * @param  String sListID(必需) 多记录表的配置ID名称
     * @return true、false
     * <pre>
     * 使用举例：
     *         CFW.oEGlt.fnRefreshData('fw_blank_todolist') ;
     * </pre>
     */
    fnRefreshData : function (sListID) {

        var target = eval('document.all.' + sListID);
        var opts;
        
        if (jQuery.data(target, 'fwdatagrid') != null) {
            opts = jQuery.data(target, 'fwdatagrid').options;
            var sWhere=opts.whereCls;
            var iPageNum=opts.pageNumber;
            opts.ReGetListData(target, sWhere, iPageNum);
            return true;
        }
        
        if (jQuery.data(target, 'fweditgrid') != null) {
            opts = jQuery.data(target, 'fweditgrid').options;
            var sWhere=opts.whereCls;
            var iPageNum=opts.pageNumber;
            opts.ReGetListData(target, sWhere, iPageNum);
            return true;
        }
        
        return true;
    },
	/**
	* 功能描述:删除多记录表格中的行。 功能详细说明:此处删除只是删除页面上多记录表的显示内容，并未删除实际数据。
	*
	* @param sGltID
	*            (必需) 多记录配置ID，String
	* @param aArrayIndex
	*            aArrayIndex　行索引数组，类型Array 数组;不传表示全部删除
	*
	* <pre>
	* 使用方法举例:
	*     使用方法1:调用以下方法删除第1、3行
	*     CFW.oEGlt.fnRemoveRows('demo_api_eglt_test',[1,3]);
	*     使用方法2:全部删除：
	*     CFW.oEGlt.fnRemoveRows('demo_api_eglt_test');
	* </pre>
	*/
	fnRemoveRows : function() {
		if (CFW.oValid.fnIsNull(arguments[0], "CFW.oEGlt.fnRemoveRows  多记录表配置ID")) {
			return;
		}
		var rowIndices = new Array();
		// 获取删除行的索引数据，如果是单值，那么用数组包装，如果是数组那个直接赋值
		if (arguments.length == 1) {
			rowIndices = null;
		} else if (arguments.length == 2) {
			if ($.isArray(arguments[1])) {
				rowIndices = arguments[1];
			} else {
				rowIndices = [ arguments[1] ];
			}
		}
		// 如果传入的是空串，那么不处理
		if (rowIndices != null && rowIndices.length == 0) {
			return this;
		}
		return $("#" + arguments[0]).each(function() {
			var opts = $.data(this, 'fweditgrid').options;
			var view = $.data(this, 'fweditgrid').view;
			var data = opts.data;
			var rows = data.rows || [];
			var table = view.children('table')[0];

			// 如果本来就没数据，那么什么都不做
			if (!rows || rows.length == 0)
				return;
			// 删除行数据
			// 如果是不传入行数据，那么删除所有
			if (rowIndices == null) {
				// 全部删除处理
				rows = [];
				// 删除所有行的数据
				$(table.tBodies[0]).empty();

				// createMsg(this);
			} else {// 部分删除处理
				// 根据索引删除现有数据，从后到前删除行数据
				rowIndices.sort(function(a, b) {
					return a - b;
				}).reverse();
				// 删除数据模型（由后向前删除）
				for (var i=0;i< rowIndices.length;i++) {
					var k = parseInt(rowIndices[i], 10);
					rows.splice(k, 1);
				}
				// 删除ui相关的东西
				for (var index=0;index<rowIndices.length;index++) {
					var kst = parseInt(rowIndices[index], 10);
					$('tr[fweditgrid-row-index=' + kst + ']', table).remove();
				}

				// createMsg(this);
				// 重新排序
				CFW.oEGlt._fnModifyRowAttr(this);
				// 调整底部的颜色
				CFW.oEGlt._fnSetAlt(this);
				if (rows.length > 0) {
					// 保持同样的滚动偏移量
					view.scrollTop(view.scrollTop());
				}
			}
			data.rows = rows;
			// 减少总计
			data.total = rows.length;
		});
	},
	/**
	* 功能描述:可编辑多记录表设置列控件只读 (‘disable’)。
	* 功能详细说明:设置多记录表某列控件只读（该函数只能对多记录表中配置了可编辑的列有效， 对不可编辑列无效）
	*
	* @param sGltID
	*            (必需) 多记录配置ID，String
	* @param sFields
	*            列别名，String
	* @param bBlag(必需)
	*            boolean值，可选值为true或者false，true时，表示设置fields对应
	*
	* <pre>
	*	使用方法举例:
	*	使用方法：设置多记录表demo_api_eglt_test的PSBZ(审批标志) 列只读
	*	fnSetItemsReadOnly('demo_api_eglt_test','SPBZ',true);
	*	设置整个多记录表只读时, 不传入第二个参数：
	*	fnSetItemsReadOnly('demo_api_eglt_test',true);
	*	取消只读只需要修改上例最后一个参数，有true改成false即可
	* </pre>
	*/
	fnSetItemsReadOnly : function(sGltID, fields, flag) {
		if (CFW.oValid.fnIsNull(sGltID, "CFW.oEGlt.fnSetItemsReadOnly  多记录表配置ID")) {
			return;
		}
		if (CFW.oValid.fnIsNull(fields, "CFW.oEGlt.fnSetItemsReadOnly  参数boolean值")) {
			return;
		}
		if (arguments.length == 2) {
			flag = fields;
			fields = true;// 传入两个表示对所有列操作
		}
		// 校验flag的参数类型
		if (flag != true && flag != false) {
			CFW.oWin.fnAlert('fnSetItemsReadOnly函数的flag参数必需是true或者false; flag:' + flag);
			return this;
		}
		// 校验fields的参数类型
		if (typeof fields == 'string') {
			// 先转为数组
			fields = [ fields ];
		} else if (!$.isArray(fields) && !fields) {
			CFW.oWin.fnAlert('fnSetItemsReadOnly函数的fields参数必需是字符串、数组或者true');
			return this;
		}
		return $("#" + sGltID).each(function() {
			// 每个多记录表单独处理
			var opts = $.data(this, 'fweditgrid').options;
			var grid = $.data(this, 'fweditgrid').grid;
			var headers = opts.data.headers;
			var v_fields;
			if (fields!=null && $.isArray(fields)) {
				v_fields = fields;
			} else {
				// true用headers替换
				v_fields = headers;
			}
			// 数组转成map
			var v_map = {};
			for (var index=0;index<v_fields.length;index++) {
				v_map[v_fields[index]] = flag;
			}
			// 合并原来的disableMap
			$.extend(opts.disableMap, v_map);
			if (!opts.mywin) {
				// 如果窗口还没初始化，那么不处理，交给loadData处理
				return;
			}
			// 获取所有控件
			$('.fweditgrid-view tbody input', grid).each(function() {
				// 不处理hidden
				if (this.type == 'hidden')
					return;
				var nd = this.nd.replace(/_CMB$/gi, "");
				if (opts.disableMap[nd]) {
					// 记录为只读的列，必需设置为只读
					if (this.className.indexOf('readOnly') == -1) {// 只处理需要处理的
						CFW.oGt.fnToDisabledObj(this);
					}
				} else {
					// 复选框特殊处理, 因为 框架没有添加上 readOnly属性
					if (this.type == "checkbox" && this.disabled) {
						$(this).removeAttr("disabled");
					}
					// 未记录的列，或者记录为false的列，取消只读
					if (this.className.indexOf('readOnly') != -1) {// 只处理需要处理的
						CFW.oGt.fnReObjReadOnly(this);
						// 如果是字典控件，那么需要将readOnly设置回去
						if (this.nd != nd) {
							this.readOnly = true;
						}
					}
				}
			});
		});
	},
    /**
    * 功能描述:获取可编辑多记录表的数据集。 功能详细说明:主要用于获取可编辑多记录表中所有数据对象，也可以获取每行中某个数据对象的值，
    * 或者获取整个数据集对象行数等。
    *
    * @param sTableId(必需)
    *            多记录表配置ID,类型：Stirng
    * @param bAllData
    *           boolean值，true表示全部获取, false只获取可编辑字段; 默认 true
    * @Returns 数据集对象
    *
    * <pre>
    * 使用方法举例:
    *  var rowsData=CFW.oEGlt.fnGetRows('demo_api_eglt_test'); // JSON格式
    *  alert(JSON.stringify(rowsData));    //输出测试: 打印出 获取到的JSON对象,转换为字符串
    * </pre>
    */
	fnGetRows : function(sTableId,bAllData) {
		if (CFW.oValid.fnIsNull(sTableId, "CFW.oEGlt.fnGetData  多记录表配置ID")) {
			return;
		}
		var eGltObj = $("#" + sTableId);
		return eGltObj.first().map(
				function() {
					var opts = $.data(this, 'fweditgrid').options;
					var view = $.data(this, 'fweditgrid').view;

					var headers = opts.data.headers;
					var rows = opts.data.rows;

					var emptyRow = {};
					// 准备一个模板空行
					for ( var i = 0; i < opts.columns; i++) {
						var h = headers[i];
						 if(!bAllData){
						emptyRow[h] = null;
						}
					}

					// 清空行数据
					for ( var i=0; i<rows.length;i++) {
						rows[i] = $.extend(rows[i], emptyRow);
					}
                    if(!bAllData){
                    /* 在这里去掉了 不可编辑的字段 */
                    var str = JSON.stringify(rows);
                    $("#" + sTableId + " tbody tr:eq(0) label").each(
                            function(i) {
                                labelN = $(this).attr("nd");
                                str = str.replace(new RegExp("\"" + labelN
                                        + "\":null,", "gm"), "");// 在前面
                                str = str.replace(new RegExp(",\"" + labelN
                                        + "\":null", "gm"), "");// 在后面
                            });
                    rows = JSON.parse(str);
                    }

					// 获取有行标识的记录
					$('tbody [rw]', view).filter(
							':checkbox:checked,:radio:checked').each(
							function() {
								if (parseInt($(this).attr('rw')) >= rows.length) {
									return;
								}
								if (this.nodeName == "INPUT") {
									rows[$(this).attr('rw')][$(this).attr('nd')] = this.value;
								}
							}).end().not(':checkbox,:radio').each(function() {
						if (parseInt($(this).attr('rw')) >= rows.length) {
							return;
						}
						if (this.nodeName == "INPUT") {
							rows[$(this).attr('rw')][$(this).attr('nd')] = this.value;
						}
					});
					opts.data.rows = rows;
					var rows2 = $.extend(true, [], rows);
					return rows2;

				}).get();
	},
	/**
	* 功能描述: 多记录表获取checkbox列的行号 功能详细说明:主要用于获取多记录中，获取复选框checkbox所在行号，
	* 第二个参数就是复选框checkbox的别名。
	*
	* @param sGltID
	*            (必需) 多记录配置ID，String
	* @param sAlias(必需)
	*            表示checkbox列的列别名,类型：Stirng
	* @returns 行号 数组
	*
	* <pre>
	* 使用方法举例:
	*	使用方法：以下方法获取选中复选框checkbox别名为TBID的行号数组。
	*	var datas=CFW.oEGlt.fnNListGetRowIndexByWhere('demo_api_eglt_test', 'TBID');
	*	alert(datas);
	* </pre>
	*/
	fnNListGetRowIndexByWhere : function(sGltID, sAlias) {
		if (CFW.oValid.fnIsNull(sGltID, "CFW.oEGlt.fnNListGetRowIndexByWhere  多记录表配置ID")) {
			return;
		}
		if (CFW.oValid.fnIsNull(sAlias, "CFW.oEGlt.fnNListGetRowIndexByWhere  checkbox列的列别名")) {
			return;
		}
		return $("#" + sGltID).map(function() {
			// 获取别名下所有已选checkbox
			return $('[nd=' + sAlias + ']:checked', this).map(function() {
				return parseInt($(this).attr("rw"), 10);
			}).get();
		}).get();
	},

	/**
	* 功能描述:可编辑多记录表翻页监听函数 (‘regBeforePageFun’) 功能详细说明:
	* 注册翻页前的响应函数,如果函数返回非true，那么系统不触发翻页操作。
	*
	* @param sGltID
	*            (必需) 多记录配置ID，String
	* @param fnPageFun
	*            (必需) 响应函数对象 function
	*
	* <pre>
	* 使用方法举例:
	*	function fnPageFunFalse() {
	*	    alert("fnPageFunFalse: return false");
	*	    return false;   //不翻页
	*	}
	*	function fnPageFunTrue() {
	*	    alert("fnPageFunTrue: return true");
	*	    return true;    //翻页
	*	}
	*	方法1: 可编辑多记录表demo_api_eglt_test 注册翻页监听函数 fnPageFunTrue
	*	CFW.oEGlt.fnRegBeforePageFun('demo_api_eglt_test',fnPageFunTrue):
	*	方法2: 可编辑多记录表demo_api_eglt_test 注册翻页监听函数 fnPageFunFalse
	*	CFW.oEGlt.fnRegBeforePageFun('demo_api_eglt_test',fnPageFunFalse):
	*	方法3: 可编辑多记录表demo_api_eglt_test 取消翻页监听函数
	*	CFW.oEGlt.fnRegBeforePageFun('demo_api_eglt_test'):
	* </pre>
	*/
	fnRegBeforePageFun : function() {
		var sGltID=arguments[0];
		var fnPageFun=arguments.length==2?arguments[1]:null;
		if (CFW.oValid.fnIsNull(sGltID, "CFW.oEGlt.fnNListGetRowIndexByWhere  多记录表配置ID")) {
			return;
		}
		if (fnPageFun != null && !$.isFunction(fnPageFun)) {
			alert('fnRegBeforePageFun函数的fnPageFun入参必须是function对象');
			return $("#" + sGltID);
		}
		return $("#" + sGltID).each(function() {
			$.data(this, 'beforePage', fnPageFun);
		});
	},

	/**
	* 功能描述: 更新和获取多记录表某列的值 (‘SetItem’) 功能详细说明:可以通过行号和列号，更新或者获取指定某字段值。更新某列值时，可以设置
	* sNewValue的参数，当获取某列值时，此参数可以不传入。同时，也可以通过字段名，获取 列的值。
	*
	* @param sGltID
	*            (必需) 多记录配置ID，String
	* @param iRowIndex
	*            行索引，int
	* @param iColIndex
	*            列索引，int(或字段别名, String)
	* @param sNewValue
	*            设置值，类型String
	*
	* <pre>
	* 使用方法举例:
	*    使用方法1：更新多记录表某列的值  通过行号和列号(或字段名)，更新指定某字段或者某列的值。
	*	使用方法举例:
	*	使用方法1：更新多记录表指定 行索引为2,列索引为6的值为: 1
	*	CFW.oEGlt.fnSetItem('demo_api_eglt_test', 2, 6, {'SPBZ' : 1});
	*	使用方法2：更新多记录表索引列为6的值为0
	*	CFW.oEGlt.fnSetItem('demo_api_eglt_test',6,{'SPBZ':0}) ;
	* </pre>
	*/
	fnSetItem : function() {
		if (CFW.oValid.fnIsNull(arguments[0], "CFW.oEGlt.fnSetItem  多记录表配置ID")) {
			return;
		}
		if (CFW.oValid.fnIsNull(arguments[1], "CFW.oEGlt.fnSetItem  多记录表指定位置")) {
			return;
		}
		if (CFW.oValid.fnIsNull(arguments[2], "CFW.oEGlt.fnSetItem  设置值")) {
			return;
		}
		 var rowIndices, fieldName, newValue;
	        var len = arguments.length;
	       if (len == 3) {
	            
	                // 更新某列的值 .fweditgrid('field',true,'XB',{'XB':1,'_DIC_XB':'男'}
	                rowIndices = true;
	                fieldName = arguments[1];
	                newValue = arguments[2];
	        } else if (len == 4) {
	            // 设置指定 某行某列的值 fweditgrid('field',0,'XB',{'XB':1,'_DIC_XB':'男'}
	            if (!CFW.oValid.fnIsInteger(arguments[1])) {
	                CFW.oWin.fnAlert('iRowIndex入参有误，只能是整形数值');
	                return null;
	            }
	            rowIndices = arguments[1];
	            fieldName = arguments[2];
	            newValue = arguments[3];
	        }
	        // 如果 fieldName 是 列索引, 需要转换为 列名称
	        if (CFW.oValid.fnIsInteger(fieldName)) {
	            fieldName = $(
	                "#" + arguments[0] + " tbody tr:eq(0) td:eq(" + fieldName
	                    + ")").children().last().attr("nd");
	        }

	       
	            // 写别名列处理
	            return $("#" + arguments[0])
	                .each(
	                function () {
	                    var vRowIndices = null;// 存放待更新的行的行索引
	                    var rows = $.data(this, 'fweditgrid').options.data.rows;
	                    var dicts = $.data(this, 'fweditgrid').dicts;
	                    var opts = $.data(this, 'fweditgrid').options;
	                    var view = $.data(this, 'fweditgrid').view;
	                    if (rowIndices == true
	                        && typeof rowIndices == 'boolean') {
	                        // 更新所有行，那么获取所有行的行索引
	                        vRowIndices = [];
	                        for (var i=0; i<rows.length;i++) {
	                            vRowIndices.push(parseInt(i, 10));
	                        }
	                    } else if ($.isArray(rowIndices)) {
	                        vRowIndices = rowIndices;
	                    } else {
	                        vRowIndices = [ rowIndices ];
	                    }

	                    var vNewValue = null;// 存放待更新的行对应列的值
	                    if (newValue != undefined || newValue != null) {

	                        if ($.isArray(newValue)) {
	                            vNewValue = newValue;
	                        } else {
	                            vNewValue = [];
	                            for (var i=0; i<rows.length;i++) {
	                                vNewValue.push(newValue);
	                            }
	                        }
	                    }
	                    var isDict = false;// 默认认为不是字典项
	                    var dict = null;
	                    // 判断该别名是否字典项
	                    if (dicts != undefined
	                        && dicts[fieldName] != undefined) {
	                        isDict = true;
	                        dict = dicts[fieldName] || {};
	                    }

	                    $('[nd=' + fieldName + ']', view)
	                        .each(
	                        function () {
	                            var pos = $.inArray(
	                                parseInt(this.rw,
	                                    10),
	                                vRowIndices);

	                            if (pos == -1) {
	                                return;
	                            }
	                            // 只处理所需的行的数据
	                            if (this.type == 'checkbox'
	                                || this.type == 'radio') {
	                                // 更新模型的数据
	                                rows[parseInt(this.rw)][fieldName] = vNewValue[pos][fieldName];
	                                // 单选按钮和多选按钮值不相符的都取消选中状态
	                                if (this.value != vNewValue[pos][fieldName]) {
	                                    this.checked = false;
	                                } else {
	                                    this.checked = true;
	                                }
	                            } else if (this.type == 'hidden') {
	                                // 隐藏控件先修改成新的值，后修改关联控件的值
	                                var code = vNewValue[pos][fieldName];
	                                if (code == null) {
	                                    code = "";
	                                }
	                                this.value = code;
	                                rows[parseInt(this.rw)][fieldName] = code;
	                                if (this.className
	                                    .indexOf('gltcom') == -1) {
	                                    // 一般只读控件的处理，修改label值
	                                    // 准备显示的值
	                                    var showValue = this.value;
	                                    if (isDict) {
	                                        showValue = (dict[this.value] == null) ? ''
	                                            : dict[this.value];
	                                    }
	                                    var labelNode = this.previousSibling;
	                                    while (labelNode != null
	                                        && labelNode.nodeName != 'LABEL') {
	                                        labelNode = labelNode.previousSibling;
	                                    }
	                                    if (labelNode) {
	                                        labelNode.innerHTML = showValue;
	                                    }
	                                } else {

	                                    // 字典项处理
	                                    if (isDict) {
	                                        var showValue = (dict[this.value] == null) ? ''
	                                            : dict[this.value];
	                                        // 获取字典控件
	                                        var comboxNode = this.previousSibling;
	                                        while (comboxNode != null
	                                            && comboxNode.nodeName != 'INPUT') {
	                                            comboxNode = comboxNode.previousSibling;
	                                        }
	                                        comboxNode.value = showValue;
	                                    }
	                                }
	                            } else if (this.nodeName == "LABEL") {
	                                // 隐藏控件先修改成新的值，后修改关联控件的值
	                                var code = vNewValue[pos][fieldName];
	                                if (code == null) {
	                                    code = "";
	                                }
	                                this.value = code;
	                                rows[parseInt(this.rw)][fieldName] = code;
	                                // 字典项处理
	                                if (isDict) {
	                                    var showValue = (dict[this.value] == null) ? ''
	                                        : dict[this.value];
	                                    // 获取字典控件
	                                    var comboxNode = this.previousSibling;
	                                    while (comboxNode != null
	                                        && comboxNode.nodeName != 'INPUT') {
	                                        comboxNode = comboxNode.previousSibling;
	                                    }
	                                    comboxNode.value = showValue;
	                                } else {
	                                    this.innerHTML = code;
	                                }

	                            } else {
	                                // 普通录入直接修改成新的值
	                                var code = vNewValue[pos][fieldName];
	                                if (code == null) {
	                                    code = "";
	                                }
	                                this.value = code;
	                                rows[parseInt(this.rw)][fieldName] = code;
	                            }
	                        });
	                });
	    },
	

	/**
	* 生成一行数据。
	*
	* @param options
	*            多记录表参数
	* @param startRow
	*            起始行号，不分页时取1，分页上页最大行号+1
	* @param fixTable
	*            固定表数据区域对象
	* @param extTable
	*            扩展表数据区域对象
	* @param rowNum
	*            行索引
	* @param rowsData
	*            行数据
	*/
	_fnGenOneRow : function(options, headers, startRow, rowNum, rowsData) {
		function inputFun(input) {
			var rowId = rowNum + parseInt(input.rw);
			input.rw = rowId;
			if (input.type == 'checkbox' || input.type == 'radio') {
				// 处理checkbox或者radiobox的情况
				// 判断后台记录是否存在，有则设置对应的值，没有则清空
				var value = (rowsData[rowId] || {})[input.nd];
				if (value == null) {
					value = '';
				}
				if (input.name != input.nd) {
					input.name = (rowId).toString(10) + input.nd;
				}
				// 设置选中状态
				input.checked = (input.value == value);
				// 只读设置
				if (options.disableMap[input.nd]) {
					input.disabled = true;
				}
			} else if (/.*_CMB/.test(input.nd)) {
				// 处理字典控件
				var value = (rowsData[rowId] || {})['_DIC_'
						+ input.nd.substr(0, input.nd.length - 4)];
				if (value == null) {
					value = '';
				}
				input.value = value;
				// 只读设置
				if (options.disableMap[input.nd.substr(0, input.nd.length - 4)]) {
					input.disabled = true;
				}
			} else {
				// 处理一般控件
				var value = (rowsData[rowId] || {})[input.nd];
				if (value == null) {
					value = '';
				}
				input.value = value;
				// 只读设置
				if (options.disableMap[input.nd]) {
					input.disabled = true;
				}
			}
			CFW.oGt._fnObjInit(input);
		}

		function labelFun(label) {
			// 判断后台记录是否存在，有则设置对应的值，没有则清空
			var rowId = rowNum + parseInt(label.rw);
			var labelValue = null;
			// 先看看有没有对应的字典项
			labelValue = (rowsData[rowId] || {})['_DIC_' + label.nd];
			// 如果没有则只用列的实际值
			if (labelValue == null) {
				labelValue = (rowsData[rowId] || {})[label.nd];
			}
			if (labelValue == null) {
				labelValue = '';
			}
			var value = (rowsData[rowId] || {})[label.nd];
			if (value == null) {
				value = '';
			}
			label.value = value;
			label.rw = rowId;
			label.innerHTML = labelValue;
		}

		var tr = options.tr.cloneNode(true);
		var t = document.createElement('TR');
		t = tr;
		// $(t).html($(tr).html());

		// 设置rowIndex
		t['fweditgrid-row-index'] = rowNum;
		// 设置序号列
		t.firstChild/* td */.innerHTML = startRow + rowNum;

		// 输入控件一个个的遍历
		var set = t.getElementsByTagName('INPUT');

		for ( var i = 0, len = set.length; i < len; i++) {
			inputFun(set[i]);
		}
		// label控件一个个处理
		set = t.getElementsByTagName('LABEL');
		for ( var i = 0, len = set.length; i < len; i++) {
			labelFun(set[i]);
		}
		return t;
	},

	/**
	* 设置间隔行的不同颜色
	*/
	_fnSetAlt : function (target) {
		var opts = $.data(target, 'fweditgrid').options;
		var grid = $.data(target, 'fweditgrid').grid;
		var view = $.data(target, 'fweditgrid').view;

		var trs = view.children('table')[0].getElementsByTagName('TBODY')[0]
				.getElementsByTagName('TR');

		// 生成各行不同颜色的效果
		for ( var i = 0, l = trs.length; i < l; i++) {
			var thisTr = trs[i];
			if (thisTr['fweditgrid-row-index'] == undefined) {
				continue;
			}
			var className = ' ' + thisTr.className + ' ';
			var pair = [ ' fweditgrid-row-alt ', ' fweditgrid-row ' ];
			if (parseInt(thisTr['fweditgrid-row-index']) % 2 != 0) {
				pair = [ ' fweditgrid-row ', ' fweditgrid-row-alt ' ];
			}

			// 删除可能的class
			className = className.replace(pair[0], ' ');
			// 添加新的class
			if (className.indexOf(pair[1]) < 0) {
				className += pair[1];
			}
			thisTr.className = $.trim(className);
		}
	},
	/**
	* 装载数据到列表中
	*/
	_fnLoadData : function (target, data) {
		// var startTime = new Date();
		var grid = $.data(target, 'fweditgrid').grid;
		var opts = $.data(target, 'fweditgrid').options;
		var view = $.data(target, 'fweditgrid').view;
		var headers = data.headers;
		var total = data.total;
		var rows = data.rows;
		var sValue = "";
		var table = view.children('table')[0];
		var ViewBody = table.tBodies[0];
		$(ViewBody).remove();

		var iPageNum = 0;
		// 计算当前页的起始行号
		iPageNum = (parseInt(opts.pageNumber, 10) - 1)
				* parseInt(opts.pageSize, 10);

		opts.total = total;
		opts.data = null;
		opts.data = data;
		opts.rowxh = iPageNum + 1;

		var frag = document.createDocumentFragment();

		// 循环每一行的数据
		// var startTime = new Date();
		for ( var i = 0; i < rows.length; i++) {
			var tr = CFW.oEGlt._fnGenOneRow(opts, headers, iPageNum + 1, i, rows);
			frag.appendChild(tr);
		}// for
		//
		var tbody = document.createElement('TBODY');
		tbody.appendChild(frag);
		table.appendChild(tbody);
		CFW.oEGlt._fnSetAlt(target);
		// showErrMsg('loadData:'+(new Date()-startTime),5);
	},

	// 显示页码
	_fnShowInfo : function(target) {
		var opts = $.data(target, 'fweditgrid').options;
		var pager = $.data(target, 'fweditgrid').pager;
		var total = parseInt(opts.total, 10); // 总共的行数

		var pageCount = Math.ceil(opts.total / opts.pageSize);
		var num = pager.find('input.fweditgrid-num');
		num.val(opts.pageNumber);
		num.parent().next().find('span').html(
				opts.afterPageText.replace(/{pages}/, pageCount));

		var pinfo = opts.displayMsg;
		pinfo = pinfo.replace(/{from}/, opts.pageSize * (opts.pageNumber - 1) + 1);
		pinfo = pinfo.replace(/{to}/, Math.min(opts.pageSize * (opts.pageNumber),
				opts.total));
		pinfo = pinfo.replace(/{total}/, opts.total);

		pager.find('div.fweditgrid-info').html(pinfo);

		$('a[icon=fweditgrid-first],a[icon=fweditgrid-prev]', pager).linkbutton({
			disabled : (opts.pageNumber == 1)
		});
		$('a[icon=fweditgrid-next],a[icon=fweditgrid-last]', pager).linkbutton({
			disabled : (opts.pageNumber >= pageCount)
		});

		if (opts.loading) {
			pager.find('a[icon=fweditgrid-load]').find('.fweditgrid-load')
					.addClass('fweditgrid-loading');
		} else {
			pager.find('a[icon=fweditgrid-load]').find('.fweditgrid-load')
					.removeClass('fweditgrid-loading');
		}
	},

	/**
	* 修改行号以及序号等 因为每次删除后 行号以及序号等都会发生变化
	*/
	_fnModifyRowAttr : function (target) {
		var grid = $.data(target, 'fweditgrid').grid;
		var opts = $.data(target, 'fweditgrid').options;
		var view = $.data(target, 'fweditgrid').view;
		var table = view.children('table')[0];

		var xh = parseInt(opts.rowxh, 10);
		$.each(table.tBodies[0].rows, function(indexInArray) {
			this['fweditgrid-row-index'] = indexInArray;
			$('input', this).each(function() {
				this['rw'] = indexInArray;
			});
			this.cells[0].innerHTML = xh + indexInArray;
		});

	},
	/**
	 * 功能说明：获取可编辑多记录表的数据集
	 * @param sTableId 必须，配置多记录表单的ID字符
	 * @return JSON数组，包含了每一行的数据
	 * <pre>
	 * 	CFW.oEGlt.fnGetEditGridData('gltId');
	 * </pre>
	 */
	fnGetEditGridData : function(sTableId){
		 var rows = $("#"+sTableId).fweditgrid("getRows");
		 return rows;
	}
};