(function($) { 
    /**
     * 生成一行数据。
     * @param options 多记录表参数
     * @param startRow 起始行号，不分页时取1，分页上页最大行号+1
     * @param fixTable 固定表数据区域对象
     * @param extTable 扩展表数据区域对象
     * @param rowNum   行索引
     * @param rowsData 行数据
     */
    function genOneRow(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;
                }
            }
            FWObjInit(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;
    }
    /**
     * 装载数据到列表中
     */
    function loadData(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 = genOneRow(opts,headers,iPageNum+1,i,rows);
            frag.appendChild(tr); 
         }//for
//  
        var tbody=document.createElement('TBODY');
        tbody.appendChild(frag);
        table.appendChild(tbody); 
        setAlt(target);
        
//      showErrMsg('loadData:'+(new Date()-startTime),5);
    }

    /**
     * 单击上下页时获取数据库的多记录数据
     */
    function request(target) {
        var grid = $.data(target, 'fweditgrid').grid;
        var opts = $.data(target, 'fweditgrid').options;
        var pager=$.data(target, 'fweditgrid').pager;
        var wrap=$.data(target, 'fweditgrid').view.parent();
        
        var param;
        var where = opts.whereCls;
        var confid = opts.confid;
        var dsId = opts.dsId;
        var dynDictWhereCls = JSON.stringify(opts.dynDictWhereCls);
        var rowstart = (opts.pageNumber - 1) * opts.pageSize + 1;
        var pageSize = opts.pageSize;

        var param = $.extend({}, {
            'confid' : confid,
            'dynDictWhereCls' : dynDictWhereCls,
            'dsId' : dsId,
            'rowstart' : rowstart,
            'pageSize' : pageSize,
            'whereCls' : where
        });

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

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

                pager.find('a[icon=fweditgrid-load]').find('.fweditgrid-load').removeClass('fweditgrid-loading');

                mask.remove();
                mask_msg.remove();
//              var startTime = new Date();
                loadData(target, data); 
//              showErrMsg('loadData:'+(new Date()-startTime),5); 
                createMsg(target); 
                showInfo(target);
                $.data(target, 'fweditgrid').view.scrollTop(0);
                 
                if (opts.onLoadSuccess) {
                    opts.onLoadSuccess.apply(this, arguments);
                }
            },
            error : function(XMLHttpRequest, textStatus, errorThrown) {
                opts.loading = false;

                mask.remove();
                mask_msg.remove();

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


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

        $('.fweditgrid-mask', grid).remove();
        $('.fweditgrid-mask-msg2', grid).remove();

        if (rows.length == 0) {

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

            $('<div class="fweditgrid-mask-msg2"></div>').html(opts.tipMsg).appendTo(wrap).css({
                 display : 'block',
                 left : (wrap.width() - $('.fweditgrid-mask-msg2', grid).outerWidth()) / 2,
                 top : (wrap.height() - $('.fweditgrid-mask-msg2', grid).outerHeight()) / 2
             });
        }
        */
    }
    // 设置分页栏的信息
    function buildPage(target) {
        var opts = $.data(target, 'fweditgrid').options;
        var grid = $.data(target, 'fweditgrid').grid;
        var pager =$.data(target, 'fweditgrid').pager;
        var expbtn = opts.expbtn;
        if (!opts.hasPage && $.trim(expbtn).length == 0) {
            return true;
        }
        
        if(opts.data.total>1){opts.total = opts.data.total;}
 
        var tableStr='<table cellspacing="0" cellpadding="0" border="0"><tr>';
        if (opts.hasPage) {
            tableStr+='<td><input class="fweditgrid-page-list" maxlength=3 value="'+opts.pageSize+'"></td>';
            tableStr+='<td><div class="fweditgrid-btn-separator"></div></td>';
            tableStr+='<td><a href=\"javascript:void(0)\" icon=\"fweditgrid-first\"></a></td>';
            tableStr+='<td><a href=\"javascript:void(0)\" icon=\"fweditgrid-prev\"></a></td>';
            tableStr+='<td><div class=\"fweditgrid-btn-separator\"></div></td>';
            tableStr+='<td><span style=\"padding-left:6px;\">'+opts.beforePageText+'</span></td>';
            tableStr+='<td><input class=\"fweditgrid-num\" type=\"text\" value=\"1\" size=\"5\"></td>';
            tableStr+='<td><span style=\"padding-right:6px;\"></span></td>';
            tableStr+='<td><div class=\"fweditgrid-btn-separator\"></div></td>';
            tableStr+='<td><a href=\"javascript:void(0)\" icon=\"fweditgrid-next\"></a></td>';
            tableStr+='<td><a href=\"javascript:void(0)\" icon=\"fweditgrid-last\"></a></td>';
            tableStr+='<td><div class=\"fweditgrid-btn-separator\"></div></td>';
            tableStr+='<td><a href=\"javascript:void(0)\" icon=\"fweditgrid-load\"></a></td>';
            tableStr+='<td><div class=\"fweditgrid-btn-separator\"></div></td>';
            if(expbtn.indexOf('NEW')!=-1){
                tableStr+='<td><a href=\"javascript:void(0)\" class=\"fweditgrid-new\">新增一行</a></td>';
            }
        }
        tableStr+='</tr></table>';
        pager[0].innerHTML=tableStr+'<div class=fweditgrid-info></div>'+'<div style=\"clear:both\"></div>';

        $("a[icon^=fweditgrid]", pager).linkbutton({
            plain : true
        });
//      var startTime = new Date();
        if (opts.hasPage) {
            showInfo(target);
            pager.find('a[class=fweditgrid-new]').bind('click.fweditgrid', function(){
                $(target).fweditgrid("addRows",{});
            });
            
            pager.find('a[icon=fweditgrid-first]').unbind('.fweditgrid').bind('click.fweditgrid', function() {
                 if (opts.pageNumber > 1)selectPage(target, 1); 
            });
            pager.find('a[icon=fweditgrid-prev]').unbind('.fweditgrid').bind('click.fweditgrid', function() {
                 if (opts.pageNumber > 1)selectPage(target, opts.pageNumber - 1);
            });
            pager.find('a[icon=fweditgrid-next]').unbind('.fweditgrid').bind('click.fweditgrid', function() {
                 var pageCount = Math.ceil(opts.total / opts.pageSize);
                 if (opts.pageNumber < pageCount) selectPage(target, opts.pageNumber + 1);
            });
            pager.find('a[icon=fweditgrid-last]').unbind('.fweditgrid').bind('click.fweditgrid', function(){
                  var pageCount = Math.ceil(opts.total / opts.pageSize);
                  if (opts.pageNumber < pageCount)selectPage(target, pageCount);
            });
            pager.find('a[icon=fweditgrid-load]').unbind('.fweditgrid').bind('click.fweditgrid', function(){ 
                        selectPage(target, opts.pageNumber); 
            });
            pager.find('input.fweditgrid-num').unbind('.fweditgrid').bind('keydown.fweditgrid',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('.fweditgrid-page-list').unbind('.fweditgrid').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;
                    });

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

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

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

                        var pageCount = Math.ceil(opts.total / opts.pageSize);
                        selectPage(target, opts.pageNumber);
                    });
        }
//      showErrMsg('buildPage:'+(new Date()-startTime),5);
    }
    // 显示页码
    function showInfo(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');
        }
    }

    function setLoadStatus(target, loading) {

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

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

        opts.loading = loading;

        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');
        }
        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, 'fweditgrid').options;
        var pageCount = Math.ceil(opts.total / opts.pageSize);
        var pageNumber = page;
        if(pageCount ==0){
            pageCount = 1;
        }
        if (page < 1)
            pageNumber = 1;
        if (page > pageCount)
            pageNumber = pageCount;

        opts.pageNumber = pageNumber;
        request(target); 
    }
    /**
     * 获取固定区和扩展区中的行各列的对齐和高度
     */
    function getHeaderStyle(target) {
        var opts = $.data(target, 'fweditgrid').options; 
	        return $('.fweditgrid-view table', target).find('td[lastRowIndex]')
	        .map(function(){
	            return {
	                'style' : this.parentNode['_al'],
	                'width' : $(this).outerWidth()
	            };
	        }).get(); 
    }
    /**
     * 设置大小 列宽等
     */ 
 function setSize(target) {
        var grid = $.data(target, 'fweditgrid').grid;
        var opts = $.data(target, 'fweditgrid').options;
        var view = $.data(target, 'fweditgrid').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('.fweditgrid').outerWidth();
        }

        var innerWidth = gridWidth - grid.outerWidth() + grid.width();
       
         
        //修复：每次单击分页栏的刷新按钮时框体会自动撑大一点的问题
        if((innerWidth - view.width()) < 20){
            innerWidth = view.parent().width();
        }
        
        view.width(innerWidth)
            .parent()//.fweditgrid-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);
        $('.fweditgrid',grid).height(opts.height); 
    }
 
    /**
     *初始化多记录表表头的checkbox事件 
     */
    function initHeaderCheckbox(target){
        var grid = $.data(target, 'fweditgrid').grid;
        var view = $.data(target, 'fweditgrid').view;
   
        //定义响应函数
        var checkFun = function(){ 
            //取得本checkbox所代表的列的索引
            var index = parseInt(this.parentNode.lastRowIndex)-1;
            //取得列别名
            var opts = $.data(target, 'fweditgrid').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;
                }
            }
        };
        //绑定函数
        view.find('table thead').find('input.fweditgrid-header-check').click(checkFun);
        
    }
    /**
     * set the common properties
     */
    function setProperties(target) {
        var grid = $.data(target, 'fweditgrid').grid;
        var opts = $.data(target, 'fweditgrid').options;
        var view = $.data(target, 'fweditgrid').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');
        }
        
//      var startTime = new Date();
        
//      showErrMsg('nowrap:'+(new Date()-startTime),5);
        initHeaderCheckbox(target);
    } 
    /**
     * 设置间隔行的不同颜色
     */ 
    function setAlt(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);
            }	
    
//      var startTime = new Date();
//      showErrMsg('thisInput:'+(new Date()-startTime),5);
    }
    /**
     * 键盘单击上键时移动 下拉框的选项
     */ 
    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');
        var tx = item.attr('text');
        setValue(target,combox,input,$.trim(tx),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');
        var tx = item.attr('text');
        setValue(target,combox,input,$.trim(tx),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');
        var tx = item.attr('text');
        setValue(target,combox,input,$.trim(tx),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,$.trim(item.attr('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 = $('div.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 if(item.attr('text').indexOf(query) == 0){//若是跟下拉列表内比较不成功，则跟隐藏的比较
                if(item.attr('text') == query){ 
               	   item.addClass('gltcombox-item-selected'); 
                   hidden.value = item.attr('value');
               }
            }else{
              item.hide();
            }
        }); 
    }
    
    /**
     * 生成下拉框的DIV
     */
    function iniDicts(target){
        var opts = $.data(target, 'fweditgrid').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:134px; display:none;\">";
             div += "<div style=\"height:200px\" class=gltcombox-panel-body>";
             for(ky in dts){  
                 div += "<div class=gltcombox-item value=\""+ky+"\" text=\""+dts[ky]+"\">"+ky+"-"+dts[ky]+"</div>";
             } 
             div += "<div class=\"gltcombox-item gltcombox-item-selected\" value=\"\"  text=\"\">&nbsp;</div>";     
             div += " </div> ";
             div += " </DIV> ";
              $(div).appendTo('body');
         } 
    }
    
    /**
     *修改行号以及序号等
     *因为每次删除后 行号以及序号等都会发生变化
     */
    function modifyRowAttr(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; 
        });
        
    }
    
    function storeRow(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]; 
        if(table.tBodies[0].rows.length==0)return;
        opts.tr = table.tBodies[0].rows[0].cloneNode(true);
 
        //如果没数据，那么删除掉模板行，如果还没初始化，那么先不删除
        var rows = $.data(target, 'fweditgrid').options.data.rows;
        if((!rows||rows.length==0)){
        	var row = table.tBodies[0].removeChild(table.tBodies[0].rows[0]); 
        }
        opts.rowxh = 1;
    }
    
    /** 
     * 重新刷新记录表的内容
     * 修改了WHERE条件后，重新执行查询  
     */
    function ReLoadData(target, where, pageNum) {
        var opts = $.data(target, 'fweditgrid').options;
            opts.whereCls = where;
        
        if(pageNum==null){
        	opts.pageNumber = 1; 
         }else if(pageNum!=-1){ 
        	opts.pageNumber = pageNum;
         }
       
        request(target);  
    }
    
    /**
     * 多记录表的成员函数
     */
    var methods = { 
        /**
         * 设置并获取某行某列的值
         * @param rowIndices
         *  指定更新的列，可以有三个类型true，整形和整形数组。
         *  表示更新多记录表所有的行中的数据，
         *  单个整形值表示更新多记录表中某行的对应别名中的值，
         *  整形数组表示更新多记录表中指定行中对应别名的值
         * @param fieldName
         *  字段别名
         * @param newValue 新的值，可以是当个值，也可以是值数组。
         *  不设置该值时表示获取列操作，设置值时表示设置列操作。
         *  每个值需要{fieldName:fieldValue}格式，如果是字典项，
         *  需要增加'_DIC_'+fieldName这个属性，传入对应的字典中文值
         * 可能的使用情况：
         * $.fweditgrid('field',true,String,Object) return jQuery例子$('#test_glt').fweditgrid('field',true,'XB',{'XB':1,'_DIC_XB':'男'}) 
         * 设置多记录表中所有行中性别列的值，代码值为1，中文显示为“男”，返回原jQuery集合对象
         * $.fweditgrid('field',true,String) return Array 例子$('#test_glt').fweditgrid('field',true,'XB')
         * 获取多记录表中所有行中性别列的值，返回数组，数组中包含每行对应列中别名为'XB'对应的值，
         * 如果值是字典列，那么同时返回中文，可能的结果是：[{'XB':1,'_DIC_XB':'男'},{'XB':1,'_DIC_XB':'男'}]
         * 
         * $.fweditgrid('field',Integer,String,Object) return jQuery例子$('#test_glt').fweditgrid('field',0,'XB',{'XB':1,'_DIC_XB':'男'}) 
         * 设置多记录表中第一行中性别列的值，代码值为1，中文显示为“男”，返回原jQuery集合对象
         * $.fweditgrid('field',Integer,String) return Array 例子$('#test_glt').fweditgrid('field',0,'XB')
         * 获取多记录表中第一行中性别列的值，返回数组，数组中包含每行对应列中别名为'XB'对应的值，
         * 如果值是字典列，那么同时返回中文，可能的结果是：[{'XB':1,'_DIC_XB':'男'}]
         * 
         * $.fweditgrid('field',Array,String,Object) return jQuery例子$('#test_glt').fweditgrid('field',[0,1],'XB',{'XB':1,'_DIC_XB':'男'}) 
         * 设置多记录表中第1、2行中性别列的值，代码值为1，中文显示为“男”，返回原jQuery集合对象
         * $.fweditgrid('field',Array,String) return Array 例子$('#test_glt').fweditgrid('field',[0,1],'XB')
         * 获取多记录表中第1、2行中性别列的值，返回数组，数组中包含每行对应列中别名为'XB'对应的值，
         * 如果值是字典列，那么同时返回中文，可能的结果是：[{'XB':1,'_DIC_XB':'男'},{'XB':1,'_DIC_XB':'男'}]
         * 
         * $.fweditgrid('field',Array,String,Array) return jQuery例子$('#test_glt').fweditgrid('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))) {
                FWalert('rowIndices入参有误，只能是true,整形数值，或者整形数组');
                return null;
            }
            if(newValue==undefined){
                //读别名列处理
                return this.map(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 (i in rows) {
                            vRowIndices.push(parseInt(i,10)); 
                        } 
                    }else if($.isArray(rowIndices)){
                        vRowIndices=rowIndices;
                    }else{
                        vRowIndices=[rowIndices];
                    }
                    var rst = [];
                    //预先初始化，避免checkbox或者radiobox一项都没选中时，导致undefined的问题
                    for (i in vRowIndices) {
                        rst[i]={};
                        rst[i][fieldName] = null;
                    }
                  
                    $('input[nd="'+fieldName+'"]', view).each(function(){
                    	 
                        var pos = $.inArray(parseInt(this.rw,10),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, '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 (i in rows) {
                            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 (i in rows) {
                                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 fields 需要控制只读的列，可以是字符串，表示某列；可以是数组，表示某些列；可以是值true，表示所有列
         * @param flag boolean值，可选值为true或者false，true时，表示设置fields对应的列为只读，false时表示设置对应的列为非只读。
         */
        disable:function(fields,flag){
            if (arguments.length == 0 ||arguments.length >2) {
                FWalert('disable函数，要求传入一个或两个参数');
                return this;
            }else if(arguments.length==1){
                flag = fields;
                fields=true;//传入两个表示对所有列操作
            }
            //校验flag的参数类型
            if(flag!=true&&flag!=false){
                FWalert('disable函数的flag参数必需是true或者false');
                return this;
            }
            //校验fields的参数类型
            if(typeof fields == 'string'){
                //先转为数组
                fields = [fields];
            }else if(!$.isArray(fields)&&fields!==true){
                FWalert('disable函数的fields参数必需是字符串、数组或者true');
                return this;
            }
            return this.each(function(){
                //每个多记录表单独处理
                var opts = $.data(this, 'fweditgrid').options;
                var grid = $.data(this, 'fweditgrid').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 ;
                }
                //获取所有控件
                $('.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) {// 只处理需要处理的
                            toDisabledObj(this);
                        }
                    } else {
                        // 未记录的列，或者记录为false的列，取消只读
                        if (this.className.indexOf('readOnly')!=-1) {// 只处理需要处理的
                            reObjReadOnly(this);
                            //如果是字典控件，那么需要将readOnly设置回去
                            if (this.nd != nd) {
                                this.readOnly = true;
                            }
                        }
                    }
                });
            });
        },
        /**
         * 保存录入数据到DATA对象并返回多记表的数据集
        */
        getRows : function(){
            return this.first().map(function(){
                var grid = $.data(this, 'fweditgrid').grid; 
                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++){
                    emptyRow[headers[i]]=null;
                }
                //清空行数据
                for(var i in rows){
                    rows[i] = $.extend(rows[i],emptyRow);
                }
                 
                //获取有行标识的记录
                $('tbody [rw]', view)
                    .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;
                    var rows2= $.extend(true,[],rows);
                    return rows2; 
                     
            }).get(); 
        },
        /**
         * 增加一行或多行的行数据（只作用于jQuery集合中的第一个多记录表）
         * @param newRows 新的一行或多行数据，可以是object单行数据或array多行数据
         * @returns int 添加后当前页面的总行数
         */
        addRows: function(newRows){
            var rowsData = [];
            // 获取新增行的数据，如果是单值，那么用数组包装，如果是数组那个直接赋值
            // 如果参数个数不对，那么报错处理
            if (arguments.length == 0) {
                $.error('addRows函数，要求传入一个参数');
            } else if (arguments.length == 1) {
                if ($.isArray(newRows)) {
                    rowsData = newRows;
                } else {
                    rowsData = [ newRows ];
                }
            } else {
                $.error('addRows函数，要求传入一个参数');
            }
            // 如果没有新增数据，那么什么都不用该处理
            if (rowsData.length == 0) {
                return this;
            }
            return this.first().map(function(){
                // 获取本多记录表已经有的行数据
                var opts = $.data(this, 'fweditgrid').options;
                var view = $.data(this, 'fweditgrid').view; 
                var table = view.children('table')[0];
                var grid = $.data(this, 'fweditgrid').grid; 
                
                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 = genOneRow(opts, opts.data.headers,iPageNum+1,iRow, rows);
                    frag.appendChild(tr); 
                }
                table.tBodies[0].appendChild(frag);
                view[0].scrollTop = view[0].scrollHeight; 
              //调整底部的颜色
                setAlt(this);
                createMsg(this);
                return rows.length;
            }).get(0);  
        },
        /**
         * 删除一行的数据
         */
        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 grid = $.data(this, 'fweditgrid').grid; 
                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 (i in rowIndices) {
                    	var k = parseInt(rowIndices[i],10);
                        rows.splice(k, 1);
                    } 
                    //删除ui相关的东西
                    for(var index in rowIndices){ 
                    	var k = parseInt(rowIndices[index],10); 
                        $('tr[fweditgrid-row-index='+k+']',table).remove(); 
                    }   
                 
                    createMsg(this); 
                    //重新排序
                    modifyRowAttr(this);
                     //调整底部的颜色
                    setAlt(this);
                    if(rows.length>0){
                        //保持同样的滚动偏移量 
                        view.scrollTop(view.scrollTop());
                    }
                }
                data.rows = rows;
                // 减少总计
                data.total = rows.length;
                createMsg(this);
             }); 
            
        
        },
        /**
         * 更新行数据
         * 
         * @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 opts = $.data(this, 'fweditgrid').options;
                var data = opts.data;
                var rows = data.rows || [];
                // 如果有传入新的行数据，那么全部用新记录替换旧记录
                if (rowsData) {
                    data.rows = rowsData;
                } else {
                    // 没有的话，当作刷新页面数据处理
                }
                loadData(this, data);
             
                createMsg(this); 
                showInfo(this);
                
            });
        },
        /**     
         *  显示下拉框
         * @param input 录入控件
         * @param comname 下拉字典的名称
         * @returns 无
         */
        showComBox : function(input,comname){
            return this.each(function(){
                var opts = $.data(this, 'fweditgrid').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, 'fweditgrid');
                var opts;
                if (state) {
                    opts = $.extend(state.options, options);
                    state.options = opts;
                } else { 
                    opts = $.extend({}, $.fn.fweditgrid.defaults, {fit:$(this).attr('fit') == 'true'}, options);
                    $(this).css('width', null).css('height', null)
                    .addClass('fwresize').bind('fwresize',function(){setSize(this);});
                    
                    var view = $(this).children().children().children('.fweditgrid-view');//主数据区域 
                    var pager = view.siblings('.fweditgrid-pager');//分页区
                    var bodyTable = view.children('table');
                    
                    $.data(this,'fweditgrid', {
                        options:opts,
                        grid:$(this),
                        dicts:opts.data.dicts,
                        view :view, 
                        pager:pager
                        }); 
                    var state = $.data(this, 'fweditgrid');
                    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);
                     //}
                    var grid = $.data(target, 'fweditgrid').grid;
                    $(window).resize(function(){

                        if (opts.width == 'auto') {
                            // 先修改成初始值 
                            $('div.fweditgrid-view', grid).width(50);
                            $('div.fweditgrid-wrap', grid).width(50);
                            $('div.fweditgrid', grid).width(50);
                            grid.width(50);

                            // 再调整
                            var iWd = grid.parent().outerWidth(); 
                            $('div.fweditgrid-view', grid).width(iWd);
                            $('div.fweditgrid-wrap', grid).width(iWd);
                            $('div.fweditgrid', grid).width(iWd);
                            grid.width(iWd); 
                        }
                    });
                    //先保存模板行数据，预防没初始化就开始操作多记录表，而这时还没初始化，导致出错
                    storeRow(target);
                    //处理目的：多记录包含在弹出窗口内时不初始化
                    if(!b&&$(target).is(':visible')){ 
                  //  var startTime = new Date();
                      setSize(this);
                      buildPage(this);
                      setProperties(target); 
                      state.options.mywin = true;  
                      iniDicts(target);
                      
                    //控件初始化
                    var inputs = bodyTable[0].getElementsByTagName('INPUT');
                    for(var i =0,len=inputs.length;i<len;i++){
                        var input = inputs[i];
                        FWObjInit(input);
                    }
                
                      createMsg(target);
                      if (opts.onLoadSuccess) {
                          opts.onLoadSuccess.apply(this, arguments);
                      }
                  //  showErrMsg('glt Total:'+(new Date()-startTime),5);
                    }else{
                        //绑定事件，监听后期可能的初始化事件，一旦初始化，立即重新渲染
                        $(document).bind('gridlazyInit',function(){
                            if(!$(target).is(':visible')){
                                return ;
                            }
                            var opts = $.data(target, 'fweditgrid').options;
                            //window必须这样处理,tab不用,要不然显示有问题
                            if(!opts.fwtab){
                                //setSize(target);
                            }
                            if(!opts.mywin){
                                setSize(target);
                                opts.mywin = true;
                                buildPage(target);
                                setProperties(target);                            
                                iniDicts(target);
                                
                                //控件初始化
                                var inputs = bodyTable[0].getElementsByTagName('INPUT');
                                for(var i =0,len=inputs.length;i<len;i++){FWObjInit(inputs[i]);}
                            
                                storeRow(target);
                                createMsg(target);
                                if (opts.onLoadSuccess) {
                                    opts.onLoadSuccess.apply(this, arguments);
                                }   
                            }
                        
                        });
                    }
                }

            });
        },
        
        /**
         * 获取已选项，数组形式，数组中是选中列的列索引（数字类型）
         * @param alias 列别名
         */
        getSelected:function(alias){
            return this.map(function() {
                //获取别名下所有已选checkbox
                return $('[nd='+alias+']:checked',this)
                    .map(function(){
                        return parseInt(this.rw,10);
                    }).get();
            }).get();
        },
        
        /**
         * 获取已选项的行数据
         * @param 控件的NAME
         */
        getSelectedData:function(alias){ 
        	   return this.map(function(){ 
        		   var rows = $.data(this, 'fweditgrid').options.data.rows;  
        		   var opts = $.data(this, 'fweditgrid').options;
                   var view = $.data(this, 'fweditgrid').view;
              
                     
        		   var NewRows = [];  
        		
        		      $('tbody [rw]', view)
                      .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;
                      });
        		       
                   
                   
	               	$('[nd='+alias+']:checked',this).each(function (){  
	               		var i= parseInt(this.rw,10);  
	               		NewRows.push(rows[i]);
	               	}); 
               	return NewRows;  
        	   }).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.fweditgrid = 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 fweditgrid');
        }
    };

    $.fn.fweditgrid.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, pageNum) {
                ReLoadData(target, where, pageNum);
            }
    };

})(jQuery);