define(function (require, exports, module) {
    var editorHandler = require('../views/editors/handler');

    function GridAdapter(id, args, pageId) {
        args = _.clone(args);
        this.id = id;
        this.pageId = pageId;
        this.data = {
            columns: [],
            rows: []
        };
        this.vmodel = {};
        this.selectedRows = [];
        this.isGroupHeader = false;

        args = args || {};

        _init(this, args);

    }

    function _init(self, args) {

        _initOpts(self, args);

        _initActions(self, args);

        self.isGroupHeader = isGroupHeader(args.data.columns);

        //数据源专属操作
        if (args.data && args.data.isDataSource) {
            _initDs(self, args);
        } else {
            if (self.isGroupHeader) {
                self.data.columns = treeTanversal(flatten2Tree(columns2Flatten(args.data.columns)));
            } else {
                self.data.columns = _setColumns(self, args.data.columns);
            }
            self.data.rows = args.data.rows;
        }
    }

    function _initOpts(self, args) {
        var opts = {
            autoEdit: true,
            editable: false,
            pageSize: -1,
            pagenum: 0,
            totalRows: -1,
            enableAddRow: false,
            enableCellNavigation: true,
            defaultColumnWidth: 100,
            enableColumnRecorder: true,
            dataItemColumnValueExtractor: function (item, columnDef) {
                if (item && item.getColumnText) {
                    return item.getColumnText(columnDef.field);
                }
                return item[columnDef.field];
            }
        };

        if (args.opts) {
            self.opts = _.extend(opts, args.opts);
        } else {
            self.opts = opts;
        }

        //分页信息设置
        if (args.data && args.data.isDataSource) {
            args.data.setPageSize(self.opts.pageSize);
            args.data.setPagenum(self.opts.pagenum);
        }
    }

    function _initActions(self, _args) {
        self.actions = {
            onClick: function (e, args) {
                if (_args.actions && typeof _args.actions.onClick == 'function') {
                    _args.actions.onClick(e, args);
                }
            },
            //grid中删除整行按钮的点击
            onColumndeleteButtonClick: function (row) {
                if (_args.actions && typeof _args.actions.onColumndeleteButtonClick == 'function') {
                    _args.actions.onColumndeleteButtonClick(row);
                }
            },
            //点击grid中cell里按钮的方法
            onGridCellClick: function (object, row) {
                if (_args.actions && typeof _args.actions.onGridCellClick == 'function') {
                    _args.actions.onGridCellClick(object, row);
                }
            },
            onDblClick: function (e, args) {
                if (_args.actions && typeof _args.actions.onDblClick == 'function') {
                    _args.actions.onDblClick(e, args);
                }
            },
            onRClick: function (e, args) {
                self.onRClick(e, args);
                if (_args.actions && typeof _args.actions.onRClick == 'function') {
                    _args.actions.onRClick(e, args);
                }
            },
            onBeforeEditCell: function (e, args) {
                if (self.dataSrc && !self.dataSrc.allowEdit) return false;
                return self.onBeforeEditCell(e, args);
            },
            onActiveCellChanged: function (e, args) {
                self.onActiveCellChanged(e, args);
            },
            onBeforeActiveCellChanged: function (e, args) {
                return self.onBeforeActiveCellChanged(e, args)
            },
            onSelectedRowsChanged: function (e, args) {
                self.onSelectedRowsChanged(e, args);
                if (_args.actions && typeof _args.actions.onSelectedRowsChanged == 'function') {
                    _args.actions.onSelectedRowsChanged(e, args);
                }
            },
            onSortClicked: function (field, asc) {
                if (_args.actions && typeof _args.actions.onSortClicked == 'function') {
                    _args.actions.onSortClicked(field, asc);
                }
            },
            onAddNewRow: function (e, args) {
                if (typeof self.onAddNewRow == 'function') {
                    self.onAddNewRow(e, args);
                }

                if (_args.actions && typeof _args.actions.onAddNewRow == 'function') {
                    _args.actions.onAddNewRow(e, args);
                }
            },
            onRowCountChanged: function (e, args) {
                self.onRowCountChanged(e, args);
            },
            onRowsChanged: function (e, args) {
                self.onRowsChanged(e, args);
            },
            onPagingInfoChanged: function (e, args) {

                if (_args.actions && typeof _args.actions.onPagingInfoChanged === 'function') {
                    _args.actions.onPagingInfoChanged(e, args);
                    return;
                } else {
                    self.onPagingInfoChanged(e, args);
                }

            },
            onKeyDown: function (e, args) {
                if (e.ctrlKey && (e.which == 46 || e.which == 110)) {
                    var grid = args.grid;
                    var editable = grid.getOptions().editable;
                    if (!editable || !self.dataSrc.allowDel) {
                        return;
                    }

                    var dataRow = grid.getDataItem(args.row);
                    if (dataRow && dataRow.isDataRow) {
                        dataRow.delete(true);
                    }
                }

                if (e.ctrlKey && e.which == 45) {
                    var grid = args.grid;
                    var editable = grid.getOptions().editable;
                    if (!editable || !self.dataSrc.allowInsert) {
                        return;
                    }

                    if (self.dataSrc.currentRow && self.dataSrc.currentRow.validate()) {
                        self.dataSrc.addRow();
                    }
                }
            },
            onActiveFirstCell: function () {
                if (_args.actions && typeof _args.actions.onActiveFirstCell == 'function') {
                    _args.actions.onActiveFirstCell();
                    return;
                }
                var grid = self.vmodel.$grid;
                var nowEditor;
                if (grid.getColumns().length) {
                    for (i = 0; i < grid.getColumns().length; i++) {
                        grid.setActiveCell(0, i);
                        grid.editActiveCell();
                        if (grid.getCellEditor()) {
                            nowEditor = grid.getCellEditor();
                            break;
                        }
                    }
                }
                nowEditor.focus();
            }
        };

        // 参数actions覆盖adpter actions，不知道原来为什么被注释掉
        // if (_args.actions) {
        //     _.extend(self.actions, _args.actions);
        // }

    }

    function _initDs(self, args) {
        self.dataSrc = args.data;
        self.opts.editable = self.opts.editable ? true : self.dataSrc.getEditable();
        self.opts.enableAddRow = self.dataSrc.allowInsert && self.opts.editable;

        self.dataSrc.on('onCollectChanged', function (ds, args) {
            if (args.action != Store.Enums.CollectionChangedAction.REPLACE) {
                self.setData(ds.rows);

                // 分页以及排序情况下不必重置排序
                if (ds.isMaster || (!ds.isMaster && !ds.detailPageOrderList)) {
                    self.resetSort();
                }

                if (self.dataSrc.getPagenum() == 0) {
                    self.setPagingOptions({ pageNum: self.dataSrc.getPagenum() }, true);
                }

                //通常只有reject操作才会出现该现象
                if (args.action == Store.Enums.CollectionChangedAction.RESET && ds.currentRow !== null) {
                    _setGridCurrentRow(self, ds.currentRow, 0);
                }
            } else {
                if (self.vmodel.$grid) {
                    var grid = self.vmodel.$grid;
                    var row = self.vmodel.$dataView.getRowById(args.row['$id']);
                    grid.updateRow(row);
                }
            }
            self.afterDataSrcLoadData();
        }, self);

        self.dataSrc.on('onValueChanged', function (ds, e) {
            if (self.vmodel.$grid) {
                var grid = self.vmodel.$grid;
                //var idx = self.vmodel.$dataView.getIdxById(e.row['$id']);
                var row = self.vmodel.$dataView.getRowById(e.row['$id']);
                var col = grid.getColumnIndex(e.col.fieldName);
                grid.updateCell(row, col);
                //grid.resizeCanvas();
            }

            // self.afterDataSrcLoadData();
        }, self);
        self.dataSrc.on('onPropertyChanged', function (ds, e) {
            if (e.propertyName == 'Editable') {
                self.setEditable(ds.getEditable());
            }
        }, self);

        self.dataSrc.on('onCurrentChanged', function (ds, e) {
            _setGridCurrentRow(self, e.newRow);
        }, self);

        self.dataSrc.on('commitEdit', function (ds, e) {
            e.isCancel = !self.commitEditor();
            //在beforeSave前移除空行
            if (!e.isCancel) {
                self.dataSrc.removeEmptyRow();
            }
        }, self);

        self.dataSrc.on('onAfterDataSrcLoadData', function (ds, e) {
            self.afterDataSrcLoadData();
            self.resizeGrid();
        }, self);

        self.dataSrc.on('onAfterDataSrcSave', function (ds, e) {
            self.afterDataSrcLoadData();
        }, self);
   

        args.data = {
            columns: _setColumns(self, self.dataSrc.columns),
            rows: self.dataSrc.rows
        };

        self.data = args.data;
    }

    //////////////////////////////////////////////////////////////////////////////////////////////
    //提供的方法实现

    function _setGridCurrentRow(self, dataRow, cellCol) {
        if (self.vmodel.$dataView && self.vmodel.$grid) {
            var newCell = null
            if (!dataRow) {
                self.vmodel.$grid.resetActiveCell()
                return
            }

            var index = self.vmodel.$dataView.getRowById(dataRow.$id);
            var oldActiveCell = self.vmodel.$grid.getActiveCell();
            if (oldActiveCell && oldActiveCell.row == index) {
                return
            }
            newCell = {
                row: index > -1 ? index : 0,
                col: oldActiveCell ? oldActiveCell.cell : 0
            };

            if (cellCol !== undefined) {
                newCell.col = cellCol;
            }

            if (self.vmodel.$grid.getEditorLock()) {
                self.vmodel.$grid.getEditorLock().cancelCurrentEdit()
            }            

            self.vmodel.$grid.setActiveCell(newCell.row, newCell.col);
            // self.vmodel.$grid.scrollRowIntoView(newCell.row, false);
        }
    }

    /**
     * 设置网格列的属性
     * @param {[type]} gridColumn [description]
     * @param {[type]} dataColumn [description]
     */
    function _setColumnOptions(gridColumn, dataColumn) {

        gridColumn.id = dataColumn.fieldName;
        gridColumn.sortable = true;
        gridColumn.field = dataColumn.fieldName;
        gridColumn.width = parseInt(dataColumn.headerWidth) * 12;
        if (gridColumn.width < 56) {
            gridColumn.width = 56;
        }

        gridColumn.name = dataColumn.dispName;
        gridColumn.isCalc = dataColumn.isCalc;
        gridColumn.formatter = dataColumn.getFormatter();
        gridColumn.isEditable = dataColumn.isEditable;
        gridColumn.dataColumn = dataColumn;
        gridColumn.cannotTriggerInsert = !dataColumn.isEditable;
        //2015-10-08添加这个属性，用来判断时是否可以编辑。
        gridColumn.isReadonly = !dataColumn.isEditable;
        if (!dataColumn.isEditable) {
            gridColumn.cssClass = 'column-un-editable';
        } else {
            gridColumn.cssClass = 'column-un-edit';
        }
        if (dataColumn.editStyle === Store.Enums.EditStyle.DECIMAL) {
            gridColumn.cssClass = gridColumn.cssClass ? gridColumn.cssClass + ' decimal-column-show' : 'decimal-column-show';
        }
        gridColumn.validator = function (item, newValue) {
            var result = {};
            if (dataColumn) {
                result.valid = dataColumn.validator(item, newValue);
                if (!result.valid) {
                    result.msg = item.getColumnError(dataColumn.fieldName);
                }
            }
            return result;
        }
        gridColumn.editor = editorHandler.getEditor(dataColumn.editStyle);
        if (dataColumn.dataSrc) {
            gridColumn.cache = (dataColumn.dataSrc.datasetName + '_' + dataColumn.fieldName).toLowerCase();
        }

    }

    function _setColumns(self, dataColumns) {
        var columns = [];
        var orderCols = [];
        var sortedColumns = _.sortBy(dataColumns, 'dispIndex');
        var pageIdArray = null;
        if (self.opts.pageId) {
            pageIdArray = self.opts.pageId.split(',');
            for (var i = 0; i < pageIdArray.length; i++) {
                orderCols = orderCols.concat(_.where(dataColumns, {
                    'pageId': parseInt(pageIdArray[i])
                }));
            }
            orderCols = _.sortBy(orderCols, 'dispIndex');
        } else {
            orderCols = sortedColumns;
        }
        for (var i = 0; i < orderCols.length; i++) {
            var column = {};
            var item = orderCols[i];
            if ((item.procParaType == Store.Enums.ProcParaType.NONE || !item.procParaType)
                && (item.dispPosition == '0' || item.dispPosition == '1')) {
                _setColumnOptions(column, item);
                columns.push(column);
            }

        }

        if (self.isGroupHeader) {
            columns = treeTanversal(flatten2Tree(columns2Flatten(columns)));
        }

        return columns;
    }

    function columns2Flatten(columns) {
        var array = [];
        for (var i = 0; i < columns.length; i++) {
            var names = columns[i].name.split('|');
            var fields = columns[i].field.split('|');
            if (fields.length > 1) { //分组
                for (var j = 0; j < fields.length; j++) {
                    var column = {};
                    column.name = names[j];
                    column.sid = fields[j];
                    column.headerCssClass = 'text-center';
                    if (j == 0) {
                        column.pid = 0;
                    } else {
                        column.pid = fields[j - 1];
                    }

                    if (j < (fields.length - 1)) {
                        column.id = fields[0];
                        array.push(column);
                    } else if (j == (fields.length - 1)) { //末级
                        columns[i].name = names[j];
                        columns[i].sid = fields[j];
                        columns[i].pid = fields[j - 1];
                        array.push(columns[i]);
                    }
                }
                ;
            } else { //无分组
                columns[i].sid = columns[i].id;
                columns[i].pid = 0;
                array.push(columns[i]);
            }

        }
        ;

        return array;
    }

    function isGroupHeader(columns) {
        for (var i = 0; i < columns.length; i++) {
            if (columns[i].field) {
                var fields = columns[i].field.split('|');
                if (fields.length > 1) {
                    return true;
                }
            }
            ;
        }
        ;

        return false;
    }

    function flatten2Tree(arr) {
        var tree = [],
            mappedArr = {},
            arrElem,
            mappedElem;

        for (var i = 0, len = arr.length; i < len; i++) {
            arrElem = arr[i];
            mappedArr[arrElem.id] = arrElem;
            mappedArr[arrElem.id]['columns'] = [];
        }

        for (var sid in mappedArr) {
            if (mappedArr.hasOwnProperty(sid)) {
                mappedElem = mappedArr[sid];
                if (mappedElem.pid) {
                    mappedArr[mappedElem['pid']]['columns'].push(mappedElem);
                } else {
                    tree.push(mappedElem);
                }
            }
        }

        return tree;
    }

    function treeTanversal(tree) {
        for (var i = 0; i < tree.length; i++) {
            if (tree[i].hasOwnProperty('columns')) {
                if (tree[i].columns.length == 0) {
                    var column = _.clone(tree[i]); //JSON.parse(JSON.stringify(tree[i]));
                    delete column.columns;
                    tree[i].columns.push(column);
                    tree[i].name = '';
                    delete tree[i].field;
                } else {
                    trimArray(tree[i].columns);
                }
            }
        }

        return tree;
    }

    function trimArray(arr) {
        for (var i = 0; i < arr.length; i++) {
            if (arr[i].hasOwnProperty('columns')) {
                if (arr[i].columns.length == 0) {
                    delete arr[i].columns;
                } else {
                    trimArray(arr[i].columns);
                }
            }
        }
        ;
    }

    GridAdapter.prototype.onPagingInfoChanged = function (e, args) {
        var self = this;
        if (Number.isNaN(args.pageNum) || args.pageNum < 0 || args.pageNum == self.dataSrc.getPagenum() || self.dataSrc.getTotalRows() <= 0) {
            return;
        }

        self.dataSrc.setPagenum(args.pageNum);
        self.dataSrc.search(function () {
            //self.vmodel.$grid.resizeCanvas();
            self.vmodel.$resizeGrid();
        }, {
            reset: false
        });

        /*
         var prevPageSize = self.dataSrc._pageSize;
         var prevPageNum = self.dataSrc._pagenum;
         var prevTotalRows = self.dataSrc._totalRows;
         if ((prevPageSize == args.pageSize && prevPageNum == args.pageNum) || (args.totalRows == 0 && args.totalPages == 1)) {
         //DataSurce.clear()触发onCollectChanged引起pageingInfo改变，不作处理
         self.vmodel.$grid.resizeCanvas();
         return;
         }

         if (prevPageSize == -1 && (args.pageSize == 0 || args.pageNum == 0)) {
         self.dataSrc.setPageSize(args.pageSize);
         self.vmodel.$grid.resizeCanvas();
         return;
         }

         if (prevPageNum != args.pageNum) { //页码改变
         if (prevPageSize == -1) { //刷新按钮，重置为第1页
         self.dataSrc.setPagenum(0);
         self.setPagingOptions({
         pageNum: 0
         }, true);
         } else {
         self.dataSrc.setPagenum(args.pageNum);
         }

         }

         if (prevPageSize != args.pageSize) { //每页显示行数发生改变
         self.dataSrc.setPagenum(0);
         self.dataSrc.setPageSize(args.pageSize);
         self.setPagingOptions({
         pageNum: 0
         });
         }

         self.dataSrc.search(function() {
         self.vmodel.$grid.resizeCanvas();
         });*/
    }

    GridAdapter.prototype.setOptions = function (opts) {
        this.vmodel.$grid.getEditorLock().cancelCurrentEdit();
        this.vmodel.$grid.setOptions(opts);
    };
    /**
     * 重绘行高
     */
    GridAdapter.prototype.resizeRowHeight = function () {
        this.vmodel.$resizeRowHeight();
    };
    GridAdapter.prototype.resizeGrid = function () {
        this.vmodel.$resizeGrid && this.vmodel.$resizeGrid();
    };
    /**
     * 下移一行
     * @return {Function} [description]
     */
    GridAdapter.prototype.next = function () {
        this.vmodel.$grid.navigateDown();
    };

    /**
     * 上移一行
     * @return {[type]} [description]
     */
    GridAdapter.prototype.prev = function () {
        this.vmodel.$grid.navigateUp();
    };

    /**
     * 根据显示行地址获取行数据
     * @param  {[type]} index [description]
     * @return {[type]}       [description]
     */
    GridAdapter.prototype.getData = function (index) {
        if (!this.vmodel.$dataView) {
            return null;
        }
        return this.vmodel.$dataView.getItem(index);
    };

    /**
     * 修改网格整体数据
     * @param {[type]} rows [description]
     */
    GridAdapter.prototype.setData = function (rows) {
        if (!this.vmodel.$dataView) {
            return;
        }

        var grid = this.vmodel.$grid
        if (grid) {
            grid.invalidateAllRows();
        }
        

        this.vmodel.$dataView.setItems(rows, '$id');
    };

    GridAdapter.prototype.getItems = function () {
        if (!this.vmodel.$dataView) {
            return [];
        }
        return this.vmodel.$dataView.getItems();
    };

    GridAdapter.prototype.selectAll = function () {
        this.setSelectedRows(_.range(this.vmodel.$dataView.getItems().length))
    };

    GridAdapter.prototype.resetSort = function () {
        if (this.vmodel && this.vmodel.$grid) {
            this.vmodel.$grid.setSortColumn(null);
        }
    }

    GridAdapter.prototype.setEditable = function (isOk) {
        if (!this.vmodel || !this.vmodel.$grid)
            return;

        var args = {};
        args.editable = isOk;
        args.enableAddRow = isOk && this.dataSrc.allowInsert;

        this.setOptions(args);

        this.vmodel.$resetSelectorScrollSize();
    };

    GridAdapter.prototype.updateSelection = function () {
        if (!this.vmodel.$grid) return;

        var items = this.getItems()
        var rows = []
        for (var i = 0; i < items.length; i++) {
            if (items[i].$is_sel) {
                rows.push(i)
            }
        }


        this.vmodel.$grid.setSelectedRows(rows)
    }

    GridAdapter.prototype.setSelectedRows = function (rows) {
        if (!this.vmodel.$grid) return;
        this.vmodel.$grid.setSelectedRows(rows)
    };

    GridAdapter.prototype.getSelectedRows = function (rows) {
        if (!this.vmodel.$grid) return [];
        return this.vmodel.$grid.getSelectedRows();
    };

    GridAdapter.prototype.onAddNewRow = function (e, args) {
        if (!args.item) {
            var grid = args.grid;
            var dataView = grid.getData();
            grid.invalidateRow(dataView.getLength());
            if (this.dataSrc.allowInsert && this.dataSrc.beforeAddFirstRow()) {
                var dsMaster = this.dataSrc.getMaster();
                if (!dsMaster) {
                    this.dataSrc.addRow()
                    return
                }

                if (dsMaster.currentRow) {
                    this.dataSrc.addRow()
                    return
                }
            }

            setTimeout(function () {
                grid.resetActiveCell();
                grid.render();
            }, 100);
        }
    };

    GridAdapter.prototype.onRowsChanged = function (e, args) {
        var grid = args.grid;
        grid.invalidateAllRows();
        grid.render();
    };

    GridAdapter.prototype.render = function () {
        if (!this.vmodel.$grid) return;
        var grid = this.vmodel.$grid
        grid.invalidateAllRows();
        grid.render();
    }

    GridAdapter.prototype.onRowCountChanged = function (e, args) {
        var grid = args.grid;
        grid.updateRowCount();
        grid.render();
    };

    GridAdapter.prototype.onBeforeEditCell = function (e, args) {
        var grid = args.grid;
        if (this.dataSrc && args.cell !== null && args.row != null) {
            var dr = args.item,
                dc = grid.getColumns()[args.cell].dataColumn;

            if (!dr || !dr.isDataRow) {
                return true;
            }

            if (!dc) {
                return true;
            }

            //主键字段在行编辑时，不允许编辑
            var allowEdit = !this.dataSrc.getFieldReadOnly(dr, dc);

            if (!allowEdit) {
                return false;
            }
        }

        return true;
    };

    function checkEditLimitRequire(ds) {
        var curRow = ds.currentRow,
            pass = true;

        for (var i = 0; i < ds.columns.length; i++) {
            var item = ds.columns[i];
            if ((item.fieldName !== "DepId") && (item.fieldName !== "DepCode")) {  //2020-06-03临时加上，主要是明细表增加行时老报主表部门不能为空错误
                if (item.isEditLimit && !item.isEmptyField && !curRow[item.fieldName] && curRow[item.fieldName] !== 0) {
                    var msg = Store.format(Store.MSG.GRID_EDITLIMIT_FORBIDDEN, item.dispName);
                    Store.messager.warn(msg);
                    pass = false;
                    return pass;
                }
            }
        }

        return pass;
    }


    GridAdapter.prototype.onBeforeActiveCellChanged = function (e, args) {
        var grid = args.grid;
        if (!grid.getOptions().editable) { //grid不可编辑时，不进行行切换校验
            return true;
        }

        var cell = grid.getActiveCell() || {};
        var newCell = args.newCell
        if (!newCell) return false

        if (newCell.row != undefined && newCell.cell != undefined && newCell.row !== cell.row) { //行切换校验
            var dataRow = grid.getDataItem(cell.row);
            var onerror = function (msg) {
                //grid.goBackToCell(activeRow, activeCell, true);
                Store.messager.err(msg);
            };

            if (dataRow && !this.dataSrc.validateDataRow(dataRow, onerror)) {
                return false;
            }
        }

        return true;

    };

    GridAdapter.prototype.onActiveCellChanged = function (e, args) {
        if (!this.dataSrc) {
            return;
        }

        var grid = args.grid;
        var dataSrc = this.dataSrc;
        var cell = grid.getActiveCell();
        if (cell) {
            var dataRow = grid.getDataItem(cell.row);

            //如果dataRow为有效行，且与数据源当前行不一致则更新当前行
            if (dataRow && dataRow !== dataSrc.currentRow) {
                var oldRow = dataSrc.currentRow;
                dataSrc.setCurrentRow(dataRow);
            }
        } else {
            //界面操作不会导致空行
            //dataSrc.setCurrentRow(null);
            var s = 1;
        }
    };

    function setRowIsSelected(grid, rowIndexs, isSelected) {
        let selectedRows = []
        for (var i = 0; i < rowIndexs.length; i++) {
            var idx = rowIndexs[i];
            var row = grid.getDataItem(idx);
            selectedRows.push(row)
            if (row) {
                row.$is_sel = isSelected;
            }
        }

        return selectedRows
    }

    GridAdapter.prototype.onSelectedRowsChanged = function (e, args) {
        var grid = args.grid;
        setRowIsSelected(grid, args.previousSelectedRows, false)
        args.selectedRows = setRowIsSelected(grid, args.rows, true)
    };

    GridAdapter.prototype.setFilter = function (filter) {
        var dataView = this.vmodel.$dataView;
        if (dataView) {
            dataView.setFilter(filter);
        }
    };

    /**
     * [setSelectboxDisable 设置grid第一列的checkbox是否可以点击]
     * @param {[type]} flag [flag为true时设置checkbox为disable，flag为false时设置checkbox为enable]
     */
    GridAdapter.prototype.setSelectboxDisable = function (flag) {
        var headerId = this.vmodel.$grid.getColumns()[0].id;
        //判断第一列是不是checkboxselector
        if (headerId != "_checkbox_selector") return;
        var headerNode = "<input type='checkbox'" + (flag ? " disabled=true>" : ">");
        if (flag) {
            this.vmodel.$grid.updateColumnHeader(headerId, headerNode);
        }
        for (var i = 0; i < this.vmodel.$columns.length; i++) {
            if (this.vmodel.$columns[i].id === "_checkbox_selector") {
                this.vmodel.$columns[i].uncheckable = flag;
                break;
            }
        }
        this.vmodel.$grid.invalidateAllRows();
        this.vmodel.$grid.render();
    }

    GridAdapter.prototype.setColumnEditable = function (field, flag) {
        var columns = this.vmodel.$columns;
        for (var i = 0; i < columns.length; i++) {
            if (columns[i].field == field) {
                columns[i].isReadonly = !flag;
            }
        }
        ;
    }

    GridAdapter.prototype.setPagingOptions = function (options, force) {
        if (!this.vmodel.$dataView) {
            return;
        }
        this.vmodel.$dataView.setPagingOptions(options, force);
    }

    GridAdapter.prototype.commitEditor = function () {
        return this.vmodel.$grid.getEditorLock().commitCurrentEdit();
    }

    GridAdapter.prototype.addContextMenu = function (fn) {
        this._contextMenu = fn;
    };

    GridAdapter.prototype.removeContextMenu = function () {
        delete this._contextMenu;
    };

    GridAdapter.prototype.onRClick = function (e, args) {
        if (this._contextMenu) {

            //只有网格允许编辑时，才可以弹出右键
            // var editable = this.vmodel.$grid.getOptions().editable;
            // if (editable) {
            e.preventDefault();
            this._contextMenu({
                top: e.pageY,
                left: e.pageX
            }, {
                data: this.dataSrc,
                items: this.dataSrc.onGetContextMenus(this.id) || []
            });
            // }

        }
    };

    GridAdapter.prototype.toggleRowsSelection = function () {
        this.vmodel.$toggleRowsSelection();
    };

    GridAdapter.prototype.afterDataSrcLoadData = function () {
        this.vmodel.$setHeaderColumnData();
        this.vmodel.$resetSelectorScrollSize();
    };

    GridAdapter.prototype.getSchemaData = function (hasData) {
        if (!this.dataSrc) {
            return [];
        }

        var rows = [],
            columns = [],
            vmodel = this.vmodel;
        var $columns = vmodel.$grid.getColumns();
        for (var i = 0; i < $columns.length; i++) {
            var gridCol = $columns[i];
            if (gridCol.dataColumn) {
                columns.push({
                    fieldName: gridCol.dataColumn.fieldName,
                    dispName: gridCol.dataColumn.dispName,
                    paraValue: gridCol.dataColumn.paraValue
                });
            }
        }

        if (hasData) {
            for (var j = 0; j < this.dataSrc.rows.length; j++) {
                var dr = this.dataSrc.rows[j];
                var row = {};
                for (var k = 0; k < columns.length; k++) {
                    row[columns[k].fieldName] = dr.getColumnText(columns[k].fieldName);
                }
                ;
                rows.push(row);
            }
        }

        var searchParams = this.dataSrc.getSchemaData();
        return {
            uiObjCode: this.dataSrc.uiObjCode,
            funcCode: this.dataSrc.funcCode,
            queryParams: searchParams.queryParams,
            columnParams: searchParams.columnParams,
            rows: rows,
            columns: columns
        };
    };
    GridAdapter.prototype.getNode = function (row, column) {
        var self = this;
        for (var i = 0; i < self.vmodel.$grid.getOptions().pageSize; i++) {
            if (self.vmodel.$grid.getDataItem(i).$id === row.$id) {
                var rownum = i;
                break;
            }
        }
        return self.vmodel.$grid.getCellNode(rownum, column);
    };

    GridAdapter.prototype.destroy = function() {
        if (this.vmodel.$grid) {
            this.vmodel.$grid.destroy()
        }

        if (this.dataSrc) {
            this.dataSrc.unmount(this)
        }
    }


    return GridAdapter;

})