yctb-SpringBoot/web/js/v2/ui/fwnupgrid/fwnupgrid.js

(function($) {
	/**
	 * 装载数据到列表中
	 */
	function loadData(target, data) {
		var grid = $.data(target, 'fwnupgrid').grid;
		var opts = $.data(target, 'fwnupgrid').options;
	    var view = $.data(target, 'fwnupgrid').view;  
		var ifrozenColumns = opts.frozenColumns;
		var icolumns = opts.columns; 
		var headers  = data.headers;
		var total = data.total; 
		var rows  = data.rows;
		var tr;
		var iRow = 0;
		var xh = 0;
		
	     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 iMaxRecordRow = Math.ceil(rows.length/opts.nupRow)*opts.nupRow;
		// 循环每一行的数据，优先拼接所有行的数据
		var ptr = "";
		var frag = document.createDocumentFragment();
		 
		tr = opts.tr.cloneNode(true);
		var tr1 = $(tr).html();
		
		for ( var iGltRow = 0; iGltRow < iMaxRecordRow; iGltRow+=opts.nupRow) {
			 
			//准备多记录表一行的数据,预先更新rw行索引的值
			ptr += ("<tr>" + tr1 + "</tr>").replace(/rw=\"(\d+)\"/g,
					function(matchpart, rowNumber) {
						return 'rw="' + (parseInt(rowNumber) + iGltRow) + '"';
					});
		 
		}
	   
	   
	  var tbody=document.createElement('TBODY');
	      $(tbody).html(ptr);
	      
	      table.appendChild(tbody); 
 
		var errMsg ='';
		
		
		//处理一般控件
		$(table).find('input')
			.filter(':checkbox,:radio').each(function(index, element){
			//处理radio和checkbox
			//判断后台记录是否存在，有则设置对应的值，没有则清空
			var qelement = $(element);
			var rowId = parseInt(element.rw);
			var value = (rows[rowId]||{})[element.nd];
			if(value == null){
				value = '';
			}
			var attrs = {};
			if(this.name==element.nd){
			}else{
				attrs['name']=(rowId).toString(10)+element.nd;
			}
			if($(element).val()==value){
				attrs['checked']='checked';
			}else{
				attrs['checked']=false;
			}
			qelement.attr(attrs);
			//只读设置
			if(opts.disableMap[element.nd]){
				CFW.oGt.fnToDisabledObj(element);
			}
		}).end().not('checkbox,:radio').each(function(index, element){
			if(element.nd.indexOf('_CMB')>-1){
				//处理字典控件
				//判断后台记录是否存在，有则设置对应的值，没有则清空
				var value = (rows[parseInt(element.rw)]||{})
					['_DIC_' + element.nd.substr(0,element.nd.length-4)];
				if(value == null){
					value = '';
				}
				element.value = value;
				//只读设置
				if(opts.disableMap[element.nd.substr(0,element.nd.length-4)]){
					CFW.oGt.fnToDisabledObj(element);
				}
			}else{
				//处理一般input控件（非radio和checkbox）
				var value = (rows[parseInt(element.rw)]||{})[element.nd];
				if(value == null){
					value = '';
				}
				element.value=value;
				//只读设置
				if(opts.disableMap[element.nd]){
					CFW.oGt.fnToDisabledObj(element);
				}
			}
		});
		
		//处理只读label控件
		$(table).find('label[nd]').each(function(index, element){
			//判断后台记录是否存在，有则设置对应的值，没有则清空
			var labelValue = null;
			//先看看有没有对应的字典项
			var qelement = $(element);
			labelValue = (rows[parseInt(element.rw)]||{})['_DIC_' + element.nd];
			//如果没有则只用列的实际值
			if(labelValue ==  null){
				labelValue = (rows[parseInt(element.rw)]||{})[element.nd] ;
			}
			if(labelValue == null){
				labelValue = '';
			}
			var value = (rows[parseInt(element.rw)]||{})[element.nd];
			if(value == null){
				value = '';
			}
			element.value=value;
			qelement.html(labelValue);
		});
		
		setAlt(target);
		CFW.oGt._fnInitObject(opts.confid);
	}

	/**
	 * 单击上下页时获取数据库的多记录数据
	 */
	function request(target,pageNumber,pageSize,callFun) {
		var grid = $.data(target, 'fwnupgrid').grid;
		var opts = $.data(target, 'fwnupgrid').options;
		var param;
		var where = opts.whereCls;
		var confid = opts.confid;
		var dsId = opts.dsId;
		var dynDictWhereCls = JSON.stringify(opts.dynDictWhereCls);
		var rowstart = (pageNumber - 1) * pageSize + 1;
	    var pSize = pageSize;
	    if(_ENCRYPT_WHERE){
	        if(where!=null&&where!='null'&&where!=''&&where!='undefined'){
	        	where=stringToHex(encrypt(WHEREKEY,where));
			}
		}
		var param = $.extend({}, {
			'confid' : confid,
			'dynDictWhereCls' : dynDictWhereCls,
			'dsId' : dsId,
			'rowstart' : rowstart,
			'pageSize' : pSize,
			'whereCls' : where
		});

		if (!opts.url)return; 
		setLoadStatus(target, true); 
		
		var wrap = $('.fwnupgrid-wrap', grid);
	 
	 $('<div class="fwnupgrid-mask"></div>').css({
			display : 'block',
			width : wrap.width(),
			height : wrap.height()
		}).appendTo(wrap);
		 
		$('<div class="fwnupgrid-mask-msg"></div>').html(opts.loadMsg).appendTo(wrap).css(
			 {display : 'block',
			  left : (wrap.width() - $('.fwnupgrid-mask-msg',grid).outerWidth()) / 2,
			  top : (wrap.height() - $('.fwnupgrid-mask-msg',grid).outerHeight()) / 2
		 });

		$.ajax({
			type : opts.method,
			url : opts.url,
			data : param,
			dataType : 'json',
			cache : false,
			success : function(data) {
				if(data!=null && data[headtoken]!=null){
					token=data[headtoken];//更新全局变量token标志
				}
				if("1"!=data.FHZ){//出错了，弹出错误提醒
					if("CSRF" == data.FHZ){
						showMsg(data.MSG||'',3);
					}else if("-1" == data.FHZ){
						_FW.oFtl.fnAlert(data.MSG||'');
				    }
					 $(grid).find('a[icon=fwnupgrid-load]').find('.fwnupgrid-load').removeClass('fwnupgrid-loading');
			        $('div.fwnupgrid-mask', grid).remove();
			        $('div.fwnupgrid-mask-msg', grid).remove();
					return;
       			}
				
				 if (callFun != null && typeof(callFun) === "function"){
		             	callFun();
		         }
				 
				opts.loading = false;

				$(grid).find('a[icon=fwnupgrid-load]').find('.fwnupgrid-load').removeClass('fwnupgrid-loading');

				$('div.fwnupgrid-mask', grid).remove();
				$('div.fwnupgrid-mask-msg', grid).remove();

				loadData(target, data); 
				createMsg(target); 
				showInfo(target);
				if (opts.onLoadSuccess) {
					opts.onLoadSuccess.apply(this, arguments);
				}
			},
			error : function(XMLHttpRequest, textStatus, errorThrown) {
				opts.loading = false;

				$('.fwnupgrid-mask', grid).remove();
				$('.fwnupgrid-mask-msg', grid).remove();

				var tipMsg = XMLHttpRequest.responseText;
				CFW.oWin.fnAlert("错误信息：" + tipMsg);
				$(grid).find('a[icon=fwnupgrid-load]')
						.find('.fwnupgrid-load').removeClass('fwnupgrid-loading'); 
				if (opts.onLoadError) {
					opts.onLoadError.apply(this, arguments);
				}
			},
            beforeSend:function(XMLHttpRequest ){
				var cToken = $.cookie(headtoken) || token;XMLHttpRequest.setRequestHeader(headtoken,cToken); 

			}
		});
	}


	function createMsg(target) { 
		/*
		var grid = $.data(target, 'fwnupgrid').grid;
		var opts = $.data(target, 'fwnupgrid').options;
		var rows = opts.data.rows;

		$('div.fwnupgrid-mask:first', grid).remove();
		$('div.fwnupgrid-mask-msg2:first', grid).remove();

		if (rows.length == 0) {

			var wrap = $('div.fwnupgrid-wrap:first', grid);
			$('<div class="fwnupgrid-mask"></div>').css({
				display : 'block',
				width : wrap.width(),
				height : wrap.height()
			}).appendTo(wrap);

			$('<div class="fwnupgrid-mask-msg2"></div>').html(opts.tipMsg).appendTo(wrap).css({
				 display : 'block',
				 left : (wrap.width() - $('div.fwnupgrid-mask-msg2', grid).outerWidth()) / 2,
				 top : (wrap.height() - $('div.fwnupgrid-mask-msg2', grid).outerHeight()) / 2
			 });
		}
		*/
	}
	
	function setLoadStatus(target, loading) {

		var opts = $.data(target, 'fwnupgrid').options;
		var grid = $.data(target, 'fwnupgrid').grid;

		if (!opts.hasPage) {
			return true;
		}

		var pager = $('fwnupgrid-pager', grid);

		opts.loading = loading;

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

	// 设置分页栏的信息
	function buildPage(target) {

		var opts = $.data(target, 'fwnupgrid').options;
		var grid = $.data(target, 'fwnupgrid').grid;
		var expbtn = opts.expbtn;
		if (!opts.hasPage && $.trim(expbtn).length == 0) {
			return true;
		}
		
		if(opts.data.total>1){opts.total = opts.data.total;}
 
		var pager = $('.fwnupgrid .fwnupgrid-wrap .fwnupgrid-pager', grid);
		var t = $('<table cellspacing="0" cellpadding="0" border="0"><tr></tr></table>').appendTo(pager);
		var tr = $('tr', t);
		if (opts.hasPage) {
			var ps = $('<input class="fwnupgrid-page-list"></input>');
			$('<td></td>').append(ps).appendTo(tr);
			ps.val(opts.pageSize);
			//预先准备需要插入到分页栏的所有html数据，然后一次性appendTo到tr中
			var xxc = '<td><div class="fwnupgrid-btn-separator"></div></td>';
			xxc += '<td><a href=\"javascript:void(0)\" icon=\"fwnupgrid-first\"></a></td>';
			xxc += '<td><a href=\"javascript:void(0)\" icon=\"fwnupgrid-prev\"></a></td>';
			xxc += '<td><div class=\"fwnupgrid-btn-separator\"></div></td>';
			xxc += '<td><span style=\"padding-left:6px;\">'+opts.beforePageText+'</span></td>';
			xxc += '<td><input class=\"fwnupgrid-num\" type=\"text\" value=\"1\" size=\"5\"></td>';
			xxc += '<td><span style=\"padding-right:6px;\"></span></td>';
			xxc += '<td><div class=\"fwnupgrid-btn-separator\"></div></td>';
			xxc += '<td><a href=\"javascript:void(0)\" icon=\"fwnupgrid-next\"></a></td>';
			xxc += '<td><a href=\"javascript:void(0)\" icon=\"fwnupgrid-last\"></a></td>';
			xxc += '<td><div class=\"fwnupgrid-btn-separator\"></div></td>';
			xxc += '<td><a href=\"javascript:void(0)\" icon=\"fwnupgrid-load\"></a></td>';
			xxc += '<td><div class=\"fwnupgrid-btn-separator\"></div></td>';
			tr.append(xxc);
		 
		$.each(['NEW'], function(index, value) {
			if (expbtn.indexOf(value) == '-1') {
				return;
			} 
			$("<td><a href=\"javascript:void(0)\" class=\"fwnupgrid-new\">新增一行</a></td>").appendTo(tr);
			
		});
		}
		$("<div class=fwnupgrid-info></div>").appendTo(pager);
		$("<div style=\"clear:both\"></div>").appendTo(pager); 
		$("a[icon^=fwnupgrid]", pager).linkbutton({
			plain : true
		});
		if (opts.hasPage) {
			showInfo(target);
            
			pager.find('a[class=fwnupgrid-new]').bind('click.fwnupgrid', function(){
				$(target).fwnupgrid("addRows");
			});
			
			pager.find('a[icon=fwnupgrid-first]').unbind('.fwnupgrid').bind('click.fwnupgrid', function() {
				 if (opts.pageNumber > 1)selectPage(target, 1); 
			});
			pager.find('a[icon=fwnupgrid-prev]').unbind('.fwnupgrid').bind('click.fwnupgrid', function() {
				 if (opts.pageNumber > 1)selectPage(target, opts.pageNumber - 1);
			});
			pager.find('a[icon=fwnupgrid-next]').unbind('.fwnupgrid').bind('click.fwnupgrid', function() {
				 var pageCount = Math.ceil(opts.total / opts.pageSize);
				 if (opts.pageNumber < pageCount) selectPage(target, opts.pageNumber + 1);
			});
			pager.find('a[icon=fwnupgrid-last]').unbind('.fwnupgrid').bind('click.fwnupgrid', function(){
				  var pageCount = Math.ceil(opts.total / opts.pageSize);
				  if (opts.pageNumber < pageCount)selectPage(target, pageCount);
			});
			pager.find('a[icon=fwnupgrid-load]').unbind('.fwnupgrid').bind('click.fwnupgrid', function(){ 
						selectPage(target, opts.pageNumber); 
			});
			pager.find('input.fwnupgrid-num').unbind('.fwnupgrid').bind('keydown.fwnupgrid',function(e) {

						if (event.keyCode == 8 || event.keyCode == 9
								|| event.keyCode == 46) {
							return true;
						}

						if (e.keyCode == 13) {
							var pageNumber = parseInt($(this).val()) || 1;
							selectPage(target, pageNumber);
						}

						// 小键盘的数字区
						if (e.keyCode >= 96 && e.keyCode <= 105) {
							return true;
						}
						// 键盘的数字区
						if ((e.keyCode >= 48 && e.keyCode <= 57
								&& e.ctrlKey == false && e.shiftKey == false)) {
							return true;
						}

						return false;

					});

			pager.find('.fwnupgrid-page-list').unbind('.fwnupgrid').bind('keydown',function(e) {

						if (event.keyCode == 8 || event.keyCode == 9
								|| event.keyCode == 46) {
							return true;
						}

						// 小键盘的数字区
						if (e.keyCode >= 96 && e.keyCode <= 105) {
							return true;
						}
						// 键盘的数字区
						if ((e.keyCode >= 48 && e.keyCode <= 57
								&& e.ctrlKey == false && e.shiftKey == false)) {
							return true;
						}

						return false;
					});

			$('.fwnupgrid-page-list', pager).each(function() {
				this.value = opts.pageSize;
			});

			pager.find('.fwnupgrid-page-list').unbind('.fwnupgrid').bind(
					'change.fwnupgrid', function() {
						if($(this).val()>200){
							CFW.oWin.fnAlert("每页显示的行数不能大于200!");
							return true;
						}
						opts.pageSize = $(this).val();
						if (opts.pageSize == 0) {
							opts.pageSize = 1;
							this.value = 1;
						}

						// 这里处理的目的是当列表的表头和表尾都有分页栏时，同步两个分页栏的框显示一致。
						$('.fwnupgrid-page-list', pager).each(function() {
							this.value = opts.pageSize;
						});

						var pageCount = Math.ceil(opts.total / opts.pageSize);
						selectPage(target, opts.pageNumber);
					});
		}
	}
	
	
	
	
	// 显示页码
	function showInfo(target) {
		var opts = $.data(target, 'fwnupgrid').options;
		var total = parseInt(opts.total, 10); // 总共的行数

		var pageCount = Math.ceil(opts.total / opts.pageSize);
		var num = $(target).find('input.fwnupgrid-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);

		$(target).find('.fwnupgrid-info').html(pinfo);

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

		if (opts.loading) {
			$(target).find('a[icon=fwnupgrid-load]').find('.fwnupgrid-load').addClass('fwnupgrid-loading');
		} else {
			$(target).find('a[icon=fwnupgrid-load]').find('.fwnupgrid-load').removeClass('fwnupgrid-loading');
		}
	}

	function setLoadStatus(target, loading) {

		var opts = $.data(target, 'fwnupgrid').options;
		var grid = $.data(target, 'fwnupgrid').grid;

		if (!opts.hasPage) {
			return true;
		}

		var pager = $('fwnupgrid-pager', grid);

		opts.loading = loading;

		if (opts.loading) {
			pager.find('a[icon=fwnupgrid-load]').find('.fwnupgrid-load').addClass('fwnupgrid-loading');
		} else {
			pager.find('a[icon=fwnupgrid-load]').find('.fwnupgrid-load').removeClass('fwnupgrid-loading');
		}
		return true;
	}
	 
	// 选择一页
	function selectPage(target, page) {
		//取响应的函数。
		var beforePageFun = $.data(target,'beforePage');
		if (beforePageFun != null && $.isFunction(beforePageFun)
				&& !beforePageFun.call(target)) {
			//响应函数如果返回非true，那么不处理翻页
			return;
		}
		var opts = $.data(target, 'fwnupgrid').options;
		var pageCount = Math.ceil(opts.total / opts.pageSize);
		var pageNumber = page;
		if (page < 1)
			pageNumber = 1;
		if (page > pageCount)
			pageNumber = pageCount;


        request(target,pageNumber,opts.pageSize,function(){
        	 opts.pageNumber = pageNumber;
        }); 
	}
	
	
	
	/**
	 * 获取固定区和扩展区中的行各列的对齐和高度
	 */
	function getHeaderStyle(grid) {
		return $('.fwnupgrid-cell[lastRowIndex]', grid).map(function(){
			return {
				'style' : $(this).parent().attr('_al'),
				'width' : $(this).outerWidth()
			};
		}).get();
	}
	/**
	 * 设置大小 列宽等
	 */ 
	function setSize(target) {
        var grid = $.data(target, 'fwnupgrid').grid;
        var opts = $.data(target, 'fwnupgrid').options;
        var view = $.data(target, 'fwnupgrid').view;
       
        
        /*重置宽度，否则无法缩小*/
        view.width(0).parent().width(0);
      
        if (opts.fit == true) {
            var p = grid.parent();
            opts.width = p.width();
            opts.height = p.height();
        }

        var tmp = opts.width + '';
        var iPos = tmp.indexOf('%');

        if (iPos != -1) {
            opts.width = 'auto';
        }

        if (opts.width != 'auto') {
            opts.width = parseInt(opts.width, 10);
        }

        var gridWidth = opts.width;
        if (gridWidth == 'auto') {
            gridWidth = view.closest('.fwnupgrid').outerWidth();
        }

        var innerWidth = gridWidth - grid.outerWidth() + grid.width();
       
         
        //修复：每次单击分页栏的刷新按钮时框体会自动撑大一点的问题
        if((innerWidth - view.width()) < 20){
            innerWidth = view.parent().width();
        }
        
        view.width(innerWidth)
            .parent()//.fwnupgrid-wrap'
            .width(innerWidth);
         
        var tmp = opts.height + '';
        var iPos = tmp.indexOf('%');
        
        // 凡是包含有100%的都设成自动高度否则会报错
        if (iPos != -1) {
            opts.height = 'auto'; 
        }

        if (opts.height != 'auto') {
            opts.height = parseInt(opts.height, 10);
        }
        
        view.height(opts.height);
    }
 

	/**
	 *初始化多记录表表头的checkbox事件，双击事件等 
	 */
	function initHeader(target){
		var grid = $.data(target, 'fwnupgrid').grid;
		$('div.fwnupgrid-view input.fwnupgrid-header-check',grid).click(function(){
			//取得本checkbox所代表的列的索引
			var index = parseInt(this.parentNode.lastRowIndex)-1;
			//取得列别名
			var opts = $.data(target, 'fwnupgrid').options;
			var alias = opts.data.headers[index];
			var inputs = target.getElementsByTagName('input');
			for(var i=0;i<inputs.length;i++){
				if(inputs[i].name===alias){
					//找到别名相同的就根据表头checkbox的状态设置选中状态
					inputs[i].checked=this.checked;
				}
			}
		});
		//设置标题头，双击可排序
		$('[lastRowIndex]',target).dblclick(function(){
			var data = $.data(target, 'fwnupgrid').options.data;
			var headers = data.headers;
			if($('input',this).length>0){
				//过滤checkbox列
				return;
			}
			var vthis = $(this);
			//获取排序列的别名
			var alias = headers[this.lastRowIndex-1];
			var sortOrder = vthis.attr('sortOrder');
			//重置其它列的排序序号
			$('[lastRowIndex] span:last-child',target).text('');
			if(!sortOrder||'desc'==sortOrder){//升序排序
				vthis.attr('sortOrder','asc');
				vthis.find('span:last').text('+');
				data.rows.sort(function(o1,o2){
					if(o1[alias] == o2[alias]){
						return 0;
					}
					return (o1[alias] < o2[alias]) ? -1 : 1;
				});
			}else{//降序排序
				vthis.attr('sortOrder','desc');
				vthis.find('span:last').text('-');
				data.rows.sort(function(o1,o2){
					if(o1[alias] == o2[alias]){
						return 0;
					}
					return (o1[alias] < o2[alias]) ? 1 : -1;
				});
			}
			loadData(target,data);
		});
	}
	/**
	 * set the common properties
	 */
	function setProperties(target) {
		 var grid = $.data(target, 'fwnupgrid').grid;
	     var opts = $.data(target, 'fwnupgrid').options;
	     var view = $.data(target, 'fwnupgrid').view;
	     var data = opts.data;
	     var headers = data.headers;
	 
	        var icol = 1;
	 
	        setAlt(target);
	 
	        var body   = view.children('table')[0];
	         
	        if (opts.nowrap == false) {
	        	$(body[0]).find('td').css('white-space','normal');
	        }
		
		initHeader(target);
	} 
	/**
	 * 设置间隔行的不同颜色
	 */ 
	function setAlt(target){ 
		 var grid = $.data(target, 'fwnupgrid').grid;
		 var view = $.data(target, 'fwnupgrid').view;
		//隐藏掉多出来的空记录控件
		var nupRow = $.data(target, 'fwnupgrid').options.nupRow;
		var rows =  $.data(target, 'fwnupgrid').options.data.rows; 
		  
		
		if(!rows||rows.length==0){
			//隐藏第一行
			$('.fwnupgrid-view:first', grid).find('input[rw]:first')//查找到最后一行的第一个控件
				.closest('tr.gltDataTableTr')//找到自己的td
				.hide();//全部隐藏
		}else{
			//处理一般控件
			$('.fwnupgrid-view:first', grid).find('input[rw="'+(rows.length-1)+'"]:last')//查找到最后一行的第一个控件
				.closest('td[field]')//找到自己的td
				.nextAll()//找到之后的所有td
				.hide();//全部隐藏
		}
		

	       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['fwnupgrid-row-index']==undefined){
	                    continue;
	                }
	                var className = ' '+thisTr.className+' ';
	                var pair=[' fwnupgrid-row-alt ',' fwnupgrid-row '];
	                if(parseInt(thisTr['fwnupgrid-row-index'])%2!=0){
	                    pair=[' fwnupgrid-row ',' fwnupgrid-row-alt '];
	                }

	                //删除可能的class
	                className = className.replace(pair[0],' ');
	                //添加新的class
	                if(className.indexOf(pair[1])<0){
	                    className+=pair[1];
	                }
	                thisTr.className=$.trim(className);
	            }	
	            
		 
	}
	/**
	 * 键盘单击上键时移动 下拉框的选项
	 */ 
	function selectPrev(target,input,combox){ 
		var panelbody = $('.gltcombox-panel-body',combox);
		
		var item = panelbody.find('div.gltcombox-item-selected');
		if (item.length){
			var prev = item.prev(':visible');
			if (prev.length){
				item = prev;
			}else{
				item = panelbody.find('div.gltcombox-item:visible:last');
			}
		} else {
			item = panelbody.find('div.gltcombox-item:visible:last');
		}
		var value = item.attr('value');
		setValue(target,combox,input,$.trim(item.text()),value);
		if (item.position().top <= 0){
			var h = panelbody.scrollTop() + item.position().top;
			panelbody.scrollTop(h);
		} else if (item.position().top + item.outerHeight() > panelbody.height()){
			var h = panelbody.scrollTop() + item.position().top + item.outerHeight() - panelbody.height();
			panelbody.scrollTop(h);
		}
	}
	
	/**
	 * 键盘单击下键时移动 下拉框的选项
	 */
	function selectNext(target,input,combox){ 
		var panelbody = $('.gltcombox-panel-body',combox); 

		var item = panelbody.find('div.gltcombox-item-selected');
		if (item.length){
			var next = item.next(':visible');
			if (next.length){
				item = next;
			}else{
				item = panelbody.find('div.gltcombox-item:visible:first');	
			}
		} else {
			item = panelbody.find('div.gltcombox-item:visible:first');
		}
		var value = item.attr('value');
		setValue(target,combox,input,$.trim(item.text()),value);
		
		if (item.position().top <= 0){
			var h = $(combox).scrollTop() + item.position().top;
			panelbody.scrollTop(h);
		} else if (item.position().top + item.outerHeight() > panelbody.height()){
			var h = panelbody.scrollTop() + item.position().top + item.outerHeight() - panelbody.height();
			panelbody.scrollTop(h);
		}
	}
	function selectCur(target,input,combox){
		var panelbody = $('.gltcombox-panel-body',combox);
		var item = panelbody.find('div.gltcombox-item-selected');
		//没有选项就不处理
		if(item.length==0)return;
		var value = item.attr('value');
		setValue(target,combox,input,$.trim(item.text()),value,true);
	}
	 /**
	  * 设置该值 HIDDEN input 保存字典值
	  */ 
	function setValue(target,combox,input,text,value,confirm){
		var panelbody = $('.gltcombox-panel-body',combox);
		panelbody.find('div.gltcombox-item-selected').removeClass('gltcombox-item-selected');
		panelbody.find('div.gltcombox-item[value=' + value + ']').addClass('gltcombox-item-selected'); 
		if(confirm){
			var obj=getComHidden(target,input);
			input.value = text;
			obj.value = value;
			var fun = window[input.doselect];
			if(fun){
				fun(input,{AAA102:value,AAA103:text});
			}
		}
	}
   /**
    * 获取下拉字典项保存字典值的HIDDEN input 对象
    */ 
	function getComHidden(target,input){
		var obj;
		var nd = input.nd.replace(/_CMB/gi, "");;
		var rw = input.rw; 
		
 		 $('input[nd='+nd+'][rw='+rw+'][class^=gltcom]',target).each(function(){
 			 obj = this;
		     return false;
		 }); 
 
 		return obj;
	} 
	/**
	 *  初始化下拉框
	 * @param input 录入控件
	 * @param comname 下拉字典的名称
	 * @return 无
	 */
	function setComBox(target,combox,input){ 
			  var panel = $('.gltcombox-panel-body',combox);	
			  $('.gltcombox-item', panel).unbind('hover');
			  $('.gltcombox-item', panel).unbind('click');
			  
			  $('.gltcombox-item', panel).hover(
					function(){$(this).addClass('gltcombox-item-hover');},
					function(){$(this).removeClass('gltcombox-item-hover');}
				).click(function(){  
					var item = $(this); 
					$(combox).css({
			 	      display:'none'
					});
					setValue(target,combox,input,item.text(),item.attr('value'),true); 
		      }); 
			  
			  panel.find('div.gltcombox-item').each(function(){
				  var item = $(this); 
				      item.show();
			  });

				//鼠标点击其他地方就隐藏列表
				$(document).bind('mousedown', function(e){
					$('div.gltcombox-panel').hide();
				});
				
				//鼠标移动到上面屏蔽掉
				panel.bind('mousedown', function(e){
					return false;
				});
				
				jQuery(input).bind('mousedown', function(e){
					return false;
				}); 
			    
				
		//当录入框第一次获取录入焦点，初始话该控件的事件
		if($.data(input, 'input') == null){
			 $(input).data('input', {}); 
			 
			 //单击ENTER键失去焦点时
			 $(input).bind('keydown',function(e){ 
				if(e.keyCode==13||e.keyCode==9){
					$(combox).css({
				 	      display:'none'
					 });
					selectCur(target,input,combox);
				} 
			});
			  
			 //按上下左右键时选择下拉框的内容
			 $(input).bind('keyup', function(e){
					switch(e.keyCode){
						case 37:	// left
						case 38:	// up
							selectPrev(target,input,combox);
							break;
						case 39:	// right
						case 40:	// down
							 selectNext(target,input,combox);
							break;
						case 16://shift
							return true;
							break;	
						case 17://ctrl
							return true;
							break;
						case 18://atl
							return true;
							break;
						case 32://空格
							return true;
							break;
						default:  
							if(!input.readOnly){   
							   setTimeout(function(){  
								filter(target,combox,input); 
							   },1000*0.3); //延迟两秒处理 
							 }
					}
			  });
				 
		} 
	}
	/**
	 * 过滤下拉框的内容
	 */	
	function filter(target,combox,input){
		var query = input.value;
		var panel = $('.gltcombox-panel-body',combox);
		var hidden = getComHidden(target,input);
	    	hidden.value =""; //原来的值
	    	panel.find('div.gltcombox-item').each(function(){
			var item = $(this); 
			if (item.text().indexOf(query) == 0){
				item.show();
				if (item.text() == query){
					item.addClass('gltcombox-item-selected'); 
					hidden.value = item.attr('value');
				} 
			} else {
				item.hide();
			}
		}); 
	}
	
	/**
	 * 生成下拉框的DIV
	 */
	function iniDicts(target){
		var opts = $.data(target, 'fwnupgrid').options;
		var dicts = opts.data.dicts; 
		var confid = opts.confid;
		var div ="";
		var dt;
		
		 for(key in dicts){ 
			 var dts = dicts[key]; 
			 var div  = "<DIV id=\""+confid+"_"+key+"\" class=\"gltcombox-panel\" style=\"width:124px; display:none;\">";
			     div += "<div style=\"height:200px\" class=gltcombox-panel-body>";
			 for(ky in dts){  
				 div += "<div class=gltcombox-item value=\""+ky+"\">"+dts[ky]+"</div>";
			 } 
             div += "<div class=\"gltcombox-item gltcombox-item-selected\" value=\"\">&nbsp;</div>";	 
			 div += " </div> ";
			 div += " </DIV> ";
			  $(div).appendTo('body');
		 } 
	}
	
	/**
	 *修改行号以及序号等
	 *因为每次删除后 行号以及序号等都会发生变化
	 */
  function modifyRowAttr(target){
        var grid = $.data(target, 'fwnupgrid').grid; 
        var opts =  $.data(target, 'fwnupgrid').options;
        var view  = $.data(target, 'fwnupgrid').view;
        var table = view.children('table')[0];
         
        var xh =parseInt(opts.rowxh,10);        
        $.each(table.tBodies[0].rows,function(indexInArray){
        	this['fwnupgrid-row-index']=indexInArray;
            $('input',this).each(function(){this['rw']=indexInArray;});
            this.cells[0].innerHTML=xh+indexInArray; 
        }); 
   }
	 
	
	function storeRow(target){
		var grid = $.data(target, 'fwnupgrid').grid; 
		var opts = $.data(target, 'fwnupgrid').options; 		
	    var view = $.data(target, 'fwnupgrid').view;
	    var table = view.children('table')[0]; 
 
		var tr =""; 
		var rowxh = 0;
	    opts.tr = table.tBodies[0].rows[0].cloneNode(true);
		opts.rowxh = 1;
	}

	/** 
	 * 重新刷新记录表的内容
	 * 修改了WHERE条件后，重新执行查询  
	 */
	function ReLoadData(target, where) {
		var opts = $.data(target, 'fwnupgrid').options;
		opts.whereCls = where;
		
		request(target,pageNum,opts.pageSize,function(){
			 opts.pageNumber = 1;
        });  
	}
	/**
	 * 多记录表的成员函数
	 */
	var methods = { 
		/**
		 * 设置并获取某行某列的值
		 * @param rowIndices
		 *  指定更新的列，可以有三个类型true，整形和整形数组。
		 *  表示更新多记录表所有的行中的数据，
		 *  单个整形值表示更新多记录表中某行的对应别名中的值，
		 *  整形数组表示更新多记录表中指定行中对应别名的值
		 * @param fieldName
		 *  字段别名
		 * @param newValue 新的值，可以是当个值，也可以是值数组。
		 *  不设置该值时表示获取列操作，设置值时表示设置列操作。
		 * 	每个值需要{fieldName:fieldValue}格式，如果是字典项，
		 * 	需要增加'_DIC_'+fieldName这个属性，传入对应的字典中文值
		 * 可能的使用情况：
		 * $.fwnupgrid('field',true,String,Object) return jQuery例子$('#test_glt').fwnupgrid('field',true,'XB',{'XB':1,'_DIC_XB':'男'}) 
		 * 设置多记录表中所有行中性别列的值，代码值为1，中文显示为“男”，返回原jQuery集合对象
		 * $.fwnupgrid('field',true,String) return Array 例子$('#test_glt').fwnupgrid('field',true,'XB')
		 * 获取多记录表中所有行中性别列的值，返回数组，数组中包含每行对应列中别名为'XB'对应的值，
		 * 如果值是字典列，那么同时返回中文，可能的结果是：[{'XB':1,'_DIC_XB':'男'},{'XB':1,'_DIC_XB':'男'}]
		 * 
		 * $.fwnupgrid('field',Integer,String,Object) return jQuery例子$('#test_glt').fwnupgrid('field',0,'XB',{'XB':1,'_DIC_XB':'男'}) 
		 * 设置多记录表中第一行中性别列的值，代码值为1，中文显示为“男”，返回原jQuery集合对象
		 * $.fwnupgrid('field',Integer,String) return Array 例子$('#test_glt').fwnupgrid('field',0,'XB')
		 * 获取多记录表中第一行中性别列的值，返回数组，数组中包含每行对应列中别名为'XB'对应的值，
		 * 如果值是字典列，那么同时返回中文，可能的结果是：[{'XB':1,'_DIC_XB':'男'}]
		 * 
		 * $.fwnupgrid('field',Array,String,Object) return jQuery例子$('#test_glt').fwnupgrid('field',[0,1],'XB',{'XB':1,'_DIC_XB':'男'}) 
		 * 设置多记录表中第1、2行中性别列的值，代码值为1，中文显示为“男”，返回原jQuery集合对象
		 * $.fwnupgrid('field',Array,String) return Array 例子$('#test_glt').fwnupgrid('field',[0,1],'XB')
		 * 获取多记录表中第1、2行中性别列的值，返回数组，数组中包含每行对应列中别名为'XB'对应的值，
		 * 如果值是字典列，那么同时返回中文，可能的结果是：[{'XB':1,'_DIC_XB':'男'},{'XB':1,'_DIC_XB':'男'}]
		 * 
		 * $.fwnupgrid('field',Array,String,Array) return jQuery例子$('#test_glt').fwnupgrid('field',[0,1],'XB',[{'XB':1,'_DIC_XB':'男'},{'XB':2,'_DIC_XB':'女']) 
		 * 分别设置多记录表中第1、2行中性别列的值，第一行代码值为1，中文显示为“男”，第二行代码值为1，中文显示为“女”，返回原jQuery集合对象
		 * 
		 */
		field:function(rowIndices,fieldName,newValue){
			//入参校验，rowIndices必须为true,整形数值，或者整形数组
			if (rowIndices == undefined || rowIndices == null
					|| (typeof rowIndices != 'boolean'
					&& typeof rowIndices != 'number'
					&& !$.isArray(rowIndices))) {
				CFW.oWin.fnAlert('rowIndices入参有误，只能是true,整形数值，或者整形数组');
				return null;
			}
			if(newValue==undefined){
				//处理获取
				return this.map(function(){
					var vRowIndices = null;//存放待更新的行的行索引
					var rows = $.data(this, 'fwnupgrid').options.data.rows;
					var opts = $.data(this, 'fwnupgrid').options;
					if (rowIndices == true) {
						// 更新所有行，那么获取所有行的行索引
						vRowIndices = [];
						for (i in rows) {
							vRowIndices.push(parseInt(i));
						}
					}else if($.isArray(rowIndices)){
						vRowIndices=rowIndices;
					}else{
						vRowIndices=[rowIndices];
					}
					var rst = [];
					if(!opts.mywin){
						//如果窗口还没初始化的话，直接从模型中获取数据
						for (i in vRowIndices) {
							rst[i]={};
							rst[i][fieldName] = rows[vRowIndices[i]];
						}
					}else{
						//预先初始化，避免checkbox或者radiobox一项都没选中时，导致undefined的问题
						for (i in vRowIndices) {
							rst[i]={};
							rst[i][fieldName] = null;
						}
					    $(':input[nd="'+fieldName+'"]', grid).each(function(){
					    	var pos = $.inArray(parseInt(this.rw),vRowIndices);
					    	if(pos == -1){
					    		return ;
					    	}
					    	//只提取所需的行的数据
					    	if(this.type=='checkbox'||this.type=='radio'){
					    		//单选按钮和多选按钮只记录选中行的值
					    		if(this.checked){
					    			rst[pos][fieldName]=this.value;
					    		}
					    	}else{
					    		//普通按钮直接记录其值
					    		rst[pos][fieldName]=this.value;
					    	}
					    });	

					}
					var dicFieldName = '_DIC_' + fieldName;//准备别名对应字典的名称
					//判断该别名是否字典项
					if (dicts[fieldName] != undefined) {
						//获取字典项
						var dict = dicts[fieldName]||{};
						//结果集增加字典项中文列
						for(i in rst){
							var codeValue=rst[i][fieldName];
							if(codeValue==null){
								rst[i][dicFieldName] = null;
							}else{
								rst[i][dicFieldName]=(dict[codeValue] == null)?null:dict[codeValue];	
							}
						}
					}
					return rst;
				}).get();
			}else{
				//处理设置
				return this.each(function(){
					var vRowIndices = null;//存放待更新的行的行索引
					var rows = $.data(this, 'fwnupgrid').options.data.rows;
					var dicts = $.data(this, 'fwnupgrid').dicts;
					var opts = $.data(this, 'fwnupgrid').options;
					var grid = $.data(this, 'fwnupgrid').grid; 

					if (rowIndices == true) {
						// 更新所有行，那么获取所有行的行索引
						vRowIndices = [];
						for (i in rows) {
							vRowIndices.push(parseInt(i));
						}
					}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 (i in rows) {
								vNewValue.push(newValue);
							}
						}
					}
					var isDict = false;//默认认为不是字典项
					var dict = null;
					//判断该别名是否字典项
					if (dicts!= undefined && dicts[fieldName] != undefined) {
						isDict = true;
						dict = dicts[fieldName]||{};
					}
				    $(':input[nd='+fieldName+']', grid).each(function(){
				    	var pos = $.inArray(parseInt(this.rw),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{
				    		//普通按钮直接修改成新的值
				    		var code = vNewValue[pos][fieldName];
				    		if(code == null){
				    			code = "";
				    		}
				    		this.value = code;
				    		rows[parseInt(this.rw)][fieldName] = code;
				    	}
				    });
				});
			}
		},
		/**
		 * 设置多记录表某列控件只读（该函数只能对多记录表中配置了可编辑的列有效，对不可编辑列无效）
		 * @param fields 需要控制只读的列，可以是字符串，表示某列；可以是数组，表示某些列；可以是值true，表示所有列
		 * @param flag boolean值，可选值为true或者false，true时，表示设置fields对应的列为只读，false时表示设置对应的列为非只读。
		 */
		disable:function(fields,flag){
			if (arguments.length == 0 ||arguments.length >2) {
				CFW.oWin.fnAlert('disable函数，要求传入一个或两个参数');
				return this;
			}else if(arguments.length==1){
				flag = fields;
				fields=true;//传入两个表示对所有列操作
			}
			//校验flag的参数类型
			if(flag!=true&&flag!=false){
				CFW.oWin.fnAlert('disable函数的flag参数必需是true或者false');
				return this;
			}
			//校验fields的参数类型
			if(typeof fields == 'string'){
				//先转为数组
				fields = [fields];
			}else if(!$.isArray(fields)&&fields!==true){
				CFW.oWin.fnAlert('disable函数的fields参数必需是字符串、数组或者true');
				return this;
			}
			return this.each(function(){
				//每个多记录表单独处理
				var opts = $.data(this, 'fwnupgrid').options;
				var grid = $.data(this, 'fwnupgrid').grid; 
				var headers = opts.data.headers;
				var v_fields;
				if (fields == true) {
					// true用headers替换
					v_fields = headers;
				} else {
					v_fields = fields;
				}
				// 数组转成map
				var v_map = {};
				for (index in v_fields) {
					v_map[v_fields[index]] = flag;
				}
				//合并原来的disableMap
				$.extend(opts.disableMap,v_map);
				if(!opts.mywin){
					//如果窗口还没初始化，那么不处理，交给loadData处理
					return ;
				}
				//获取所有控件
				$('.fwnupgrid-body 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 {
						// 未记录的列，或者记录为false的列，取消只读
						if (this.className.indexOf('readOnly')!=-1) {// 只处理需要处理的
							CFW.oGt.fnReObjReadOnly(this);
							//如果是字典控件，那么需要将readOnly设置回去
							if (this.nd != nd) {
								this.readOnly = true;
							}
						}
					}
				});
			});
		},
		/**
		 * 保存录入数据到DATA对象并返回多记表的数据集
		*/
		getRows : function(){
			return this.first().map(function(){
				var grid = $.data(this, 'fwnupgrid').grid; 
				var opts = $.data(this, 'fwnupgrid').options;
				var headers = opts.data.headers;
				var rows = opts.data.rows;

				if(!opts.mywin){
					//如果窗口还没初始化，那么直接返回列表数据
					return rows;
				}
				var emptyRow = {};
				//准备一个模板空行
				for(var i=0;i<opts.columns;i++){
					emptyRow[headers[i]]=null;
				}
				//清空行数据
				for(var i in rows){
					rows[i] = $.extend(rows[i],emptyRow);
				}
				//获取有行标识的记录
			    $('.fwnupgrid-view table input[rw]', grid)
			    	.filter(':checkbox:checked,:radio:checked').each(function(){
					    	if(parseInt(this.rw)>=rows.length){
					    		return;
					    	}
					    	rows[this.rw][this.nd]=this.value;
					    }).end()
					.not(':checkbox,:radio').each(function(){
				    	if(parseInt(this.rw)>=rows.length){
				    		return;
				    	}
				    	rows[this.rw][this.nd]=this.value;
				    });
				    // 回写最新的数据
				    opts.data.rows = rows;
				    return rows;
			}).get(); 
		},
		/**
		 * 增加一行或多行的行数据（只作用于jQuery集合中的第一个多记录表）
		 * 
		 * @param options 新的一行或多行数据，可以是object单行数据或array多行数据
		 * @returns int 添加后当前页面的总行数
		 */
		addRows : function(options) {
		 
			var rowsData = [];
			// 获取新增行的数据，如果是单值，那么用数组包装，如果是数组那个直接赋值
			// 如果参数个数不对，那么报错处理
			if (arguments.length == 0) { 
				alert('addRows函数，要求传入一个参数');
			} else if (arguments.length == 1) {
				if ($.isArray(options)) {
					rowsData = options;
				} else {
					rowsData = [ options ];
				}
			} else {
				alert('addRows函数，要求传入一个参数');
			}
			// 如果没有新增数据，那么什么都不用该处理
			if (rowsData.length == 0) {
				return this;
			}
		 
			return this.first().map(function() {
				 
				// 获取本多记录表已经有的行数据
				var opt = $.data(this, 'fwnupgrid').options;
				var view = $.data(this, 'fwnupgrid').view; 
	            var table = view.children('table')[0];
	         
				var data = opt.data;
				var rows = data.rows || [];
				// 增加行数据
				rows = rows.concat(rowsData);
				data.rows = rows;
				// 增加总计
				opt.pageSize = rows.length;
				data.total = rows.length;
				var target = this;
				if(!opt.mywin){
					//如果窗口还没初始化，那么延迟处理
					$(target).clearQueue('lazyAction').queue('lazyAction',function(){
						loadData(target, data);
						view[0].scrollTop = view[0].scrollHeight;  
					});	
				}else{
					//已经初始化了就直接执行
					loadData(this, data);
				}
				createMsg(this);
				if (opt.hasPage) {
					showInfo(this);
				}
				return rows.length;
			}).get(0);
		},
		/**
		 * 更新行数据
		 * 
		 * @param options
		 *            可选，如果不传任何数据，默认表示刷新本多记录表，如果传入新的列表数据
		 *            ，那么直接替换原来的多记录表的数据，同时刷新界面展示
		 * @returns jQuery
		 */
		updateRows : function(options) {
			var rowsData = null;
			// 获取新行的数据，如果是单值，那么用数组包装，如果是数组那个直接赋值
			// 如果参数个数不对，那么报错处理
			if (arguments.length == 0) {
			} else if (arguments.length == 1) {
				if ($.isArray(options)) {
					rowsData = options;
				} else {
					rowsData = [ options ];
				}
			} else {
				$.error('updateRows函数，要求传入一个参数');
			}
			return this.each(function() {
				var errMsg  ="";
				// 获取本多记录表已经有的行数据
				var opt = $.data(this, 'fwnupgrid').options;
				var data = opt.data;
				var rows = data.rows || [];
				// 如果有传入新的行数据，那么全部用新记录替换旧记录
				if (rowsData) {
					data.rows = rowsData;
				} else {
					// 没有的话，当作刷新页面数据处理
				}
				// 增加总计
				data.total = data.rows.length;
				var target = this;
				if(!opt.mywin){
					//如果窗口还没初始化，那么延迟处理
					$(target).clearQueue('lazyAction').queue('lazyAction',function(){
						loadData(target, data);
					});	
				}else{
					//已经初始化的话直接执行
					loadData(this, data);
				}
				createMsg(this);
				if (opt.hasPage) {
					showInfo(this);
				}
			});
		},
		/**
		 * 删除行数据
		 * 
		 * @param options
		 * @returns jQuery
		 */
		removeRows : function(options) {
			var rowIndices = new Array();
			// 获取删除行的索引数据，如果是单值，那么用数组包装，如果是数组那个直接赋值
			if (arguments.length == 0) {
				rowIndices = null;
			} else if (arguments.length == 1) {
				if ($.isArray(options)) {
					rowIndices = options;
				} else {
					rowIndices = [ options ];
				}
			} else {
				$.error('removeRows函数，要求最多传入一个参数');
			}
			// 如果传入的是空串，那么不处理
			if (rowIndices && rowIndices.length == 0) {
				return this;
			}
			return this.each(function() {
				var opt = $.data(this, 'fwnupgrid').options;
				// 获取本多记录表已经有的行数据
				var data = opt.data;
				var rows = data.rows || [];
				// 如果本来就没数据，那么什么都不做
				if (!rows || rows.length == 0)
					return;
				// 删除行数据
				// 如果是不传入行数据，那么删除所有
				if (rowIndices == null) {
					rows = [];
				} else {
					// 根据索引删除现有数据，从后到前删除行数据
					rowIndices.sort(function(a, b) {
						return a - b;
					}).reverse();
					for (i in rowIndices) {
						rows.splice(rowIndices[i], 1);
					}
				}
				data.rows = rows;
				// 减少总计
				data.total = rows.length;
				var target = this;
				if(!opt.mywin){
					//如果窗口还没初始化，那么延迟处理
					$(target).clearQueue('lazyAction').queue('lazyAction',function(){
						loadData(target, data);
					});	
				}else{
					//已经初始化的话直接执行
					loadData(this, data);
				}
		 
				createMsg(this);
				if (opt.hasPage) {
					showInfo(this);
				}
			 
			});
		},
		/**
		 *  显示下拉框
		 * @param input 录入控件
		 * @param comname 下拉字典的名称
		 * @returns 无
		 */
		showComBox : function(input,comname){
			return this.each(function(){
				var opts = $.data(this, 'fwnupgrid').options;
				var zIndex = opts.zIndex;
				var iLeft  = $(input).offset().left;
				var iTop   = $(input).offset().top + 20;
				var combox = $('#'+comname); 
				var comobj;				
				eval('comobj=document.all.'+comname);
				setComBox(this,comobj,input);
				
				var hidden = getComHidden(this,input);
				var panel = $(comobj).find('div.gltcombox-panel-body');
				    panel.find('div.gltcombox-item-selected').removeClass('gltcombox-item-selected');
				    panel.find('div.gltcombox-item[value=' + hidden.value + ']').addClass('gltcombox-item-selected'); 
				
				    var ind = parseInt(combox.css('zIndex'),10);
			 
				    if(zIndex>ind){
				    	ind = zIndex;
				    };
				combox.css({
			 	    display:'block',
				    left:iLeft,
				  	top:iTop,
				  	zIndex:ind
				  });
				 
			}); 
		},
		/**
		 * 初始化可编辑多记录表单
		 */
		init : function(options) {
			options = options || {};
			return this.each(function() {
				var state = $.data(this, 'fwnupgrid');
				var opts;
				if (state) {
					opts = $.extend(state.options, options);
					state.options = opts;
				} else { 
					opts = $.extend({}, $.fn.fwnupgrid.defaults, {fit:$(this).attr('fit') == 'true'}, options);
				    $(this).css('width', null).css('height', null)
				    	.addClass('fwresize').bind('fwresize',function(){setSize(target);}); 
					var view = $(this).children().children().children('.fwnupgrid-view');//主数据区域 
					
					$.data(this,'fwnupgrid', {options:opts, grid:$(this), view:view, dicts:opts.data.dicts}); 
					var state = $.data(this, 'fwnupgrid');
				 
					var target = this;
					var b = false;

				    //检查该多记录的上层是否是弹出窗口(window)
					$(this).parents('.window').each(function(){ 
						b=true;
						return false;
					});

					if(!b){
					 //检查该多记录的上层是否是TAB页(window) 
						$(this).parents('[myclass=fwtab]').each(function(){  
							b=true;
							state.options.fwtab = true;
							return false; 
						});
						
					 }
					//TAB页必须先处理 WINDOW则不用奇怪,要不然显示有问题
					if(state.options.fwtab){ 
						//setSize(this);
					 } 
					$(window).resize(function(){
						setSize(target);
					});
					setProperties(target);
					//处理目的：多记录包含在弹出窗口内时不初始化
					if(!b&&$(target).is(':visible')){ 
					  setSize(target);
					  createMsg(target);
					  buildPage(this);
					  state.options.mywin = true; 
					  iniDicts(target);
					  storeRow(target);
					  if (opts.onLoadSuccess) {
						opts.onLoadSuccess.apply(target, arguments);
					  }
					}else{
						//绑定事件，监听后期可能的初始化事件，一旦初始化，立即重新渲染
						$(document).bind('gridlazyInit',function(){
							if(!$(target).is(':visible')){
								return ;
							}
							var opts = $.data(target, 'fwnupgrid').options;
						    //window必须这样处理,tab不用,要不然显示有问题
							if(!opts.fwtab){
								//setSize(target);
							}
							if(!opts.mywin){
								setSize(target);
								opts.mywin = true;
								buildPage(target); 
								createMsg(target); 
								iniDicts(target);
								storeRow(target);
								if (opts.onLoadSuccess) {
									opts.onLoadSuccess.apply(target, arguments);
								}
							}
							//触发因隐藏而没有执行的操作，可能有些操作在多记录表显示之前已经执行了，
							//但由于没有显示出来所以没有完全执行到位，需要在这里做后续的处理
							$(target).dequeue('lazyAction');
						});
					}
				}

			});
		},
		/**
		 * 获取已选项
		 * @param alias 列别名
		 */
		getSelected:function(alias){
			return this.map(function() {
				//获取别名下所有已选checkbox
				return $('[nd='+alias+']:checked',this)
					.map(function(){
						return parseInt(this.rw,10);
					}).get();
			}).get();
		},
		/**
		 * 注册翻页前的响应函数。
		 * 如果函数返回非true，那么系统不触发翻页操作。
		 * @param pageFun 自定义的响应函数，可以为空，空表示取消之前注册的函数。
		 */
		beforePage:function(pageFun){
			if(pageFun!=null&&!$.isFunction(pageFun)){
				alert('beforePage函数的唯一入参必须是function对象');
				return this;
			}
			return this.each(function(){
				$.data(this,'beforePage',pageFun);
			});
		}

	};
	 
	$.fn.fwnupgrid = function(options) {
		if (methods[options]) {
			return methods[options].apply(this, Array.prototype.slice.call(
					arguments, 1));
		} else if (typeof options === 'object' || !options) {
			return methods.init.apply(this, arguments);
		} else {
			$.error('Method ' + options + ' does not exist on fwnupgrid');
		}
	};

	$.fn.fwnupgrid.defaults = {
			title : null,
			iconCls : null,
			border : true,
			width : 'auto',
			height : 'auto',
			frozenColumns : null,
			columns : null,
			striped : true,
			method : 'post',
			nowrap : true,
			idField : null,
			expbtn : null,
			url : null,
			whereCls : null,
			confid : null,
			dsId : null,
			dynDictWhereCls : null,
			subTotalAlign : 'bottom',
			loadMsg : '正在处理中 ...',
			tipMsg : '没有相关的数据!',
			hasPage : true,// 是否显示标题
			rownumbers : false,
			singleSelect : false,
			fit : false,
			queryParams : {},
			sortName : null,
			sortOrder : 'asc',
			data : null,
			beforePageText : '页码',
			afterPageText : '共 {pages} 页',
			displayMsg : '第 {from} 到 {to} 行  共  {total} 行',
 			total : 1,
			pageSize : 20,
			pageNumber : 1,
			loading : false,
			buttons : null,
			mywin:false,//用于判断是否已经被弹出窗口初始化过详见 fwwindow： setEditGird
			zIndex:0,
			tr:null,
			rowxh:1,
			fwtab:false,
			showRefresh : true,
			disableMap:{},
			ReGetListData : function(target, where) {
				ReLoadData(target, where);
			}
	};

})(jQuery);