WebSquare.uiplugin.gridView.prototype.mergeByCol = function(options) {
    try {
        if (typeof options === "undefined" || options == null) {
            options = {};
        }
        var rowCnt = this.getRowCount();
        var colCnt = this.getColumnCount();
        var rowStart = this.options.fixedRow;
        var colStart = this.options.fixedColumn;
        var colEnd = colCnt - this.options.fixedRightColumn;
        var rowEnd = rowCnt;
        var upperColumnRows = {};
        if (options.keepMerge !== true && options.fixedRows !== true && options.fixedCols !== true) {
            this.cellMergeInfo = {};
        }
        var beforeMergedCells = {};
        if (options.keepMerge === true) {
            beforeMergedCells = this.getMergedCells();
        }
        if (options.fixedRows === true) {
            rowStart = 0;
            rowEnd = this.options.fixedRow;
            colStart = 0;
            colEnd = colCnt;
        }
        var fixedColBoth = false;
        if (options.fixedCols === true) {
            if (this.options.fixedColumn == 0) {
                colStart = colCnt - this.options.fixedRightColumn;
                colEnd = colCnt;
            } else if (this.options.fixedRightColumn == 0) {
                colStart = 0;
                colEnd = this.options.fixedColumn;
            } else {
                colStart = 0;
                colEnd = colCnt;
                fixedColBoth = true;
            }
            if (options.fixedRows === false) {
                rowStart = this.options.fixedRow;
                rowEnd = rowCnt;
            } else {
                rowStart = 0;
                rowEnd = rowCnt;
            }
        }
        var useDrilldown = !!(this.isDrillDown && this._dataList.options.depthColumn);
        for (var col = colStart; col < colEnd; col++) {
            if (options.mergeCol) {
                if (options.mergeCol[col] === false) {
                    continue;
                }
            } else if (this.mergeColObj[col] === false) {
                continue;
            }
            if (fixedColBoth) {
                if (col >= this.options.fixedColumn && col < colEnd - this.options.fixedRightColumn) {
                    continue;
                }
            }
            var columnId = this.tdIdList[col];
            for (var row = rowStart; row < rowEnd; row++) {
                var realRow = useDrilldown ? this.getRealRowIndex(row) : row;
                var currentData = this.dataList._getCellData(row, columnId);
                var idx = 1;
                if (options.keepMerge === true) {
                    idx = 0;
                }
                if (options.upperColumn === true) {
                    upperColumnRows[row] = true;
                }
                if (options.mergeRow) {
                    if (options.mergeRow[realRow] === false) {
                        continue;
                    }
                } else if (this.mergeRowObj[realRow] === false) {
                    continue;
                }
                while (idx < rowEnd - row) {
                    var realRow2 = useDrilldown ? this.getRealRowIndex(row + idx) : row + idx;
                    if (options.mergeRow) {
                        if (options.mergeRow[realRow2] === false) {
                            break;
                        }
                    } else if (this.mergeRowObj[realRow2] === false) {
                        break;
                    }
                    if (row + idx > rowEnd) {
                        break;
                    }
                    var nextData = (idx === 0) ? currentData : this.dataList._getCellData(row + idx, columnId);
                    if (currentData != nextData) {
                        break;
                    }
                    if (options.keepMerge === true && beforeMergedCells[realRow2 + "_" + col] === true) {
                        break;
                    }
                    if (options.upperColumn === true && upperColumnRows[row + idx] === true) {
                        break;
                    }
                    idx++;
                }
                if (idx > 1) {
                    this.cellMergeInfo[realRow + "_" + col] = {
                        "rowSpan": idx,
                        "colSpan": 1
                    }
                    row = row + idx - 1;
                }
            }
        }
        upperColumnRows = undefined;
        if (options.noDraw !== true) {
            this.dynamicMergeHTML();
        }
    } catch (e) {
        WebSquare.exception.printStackTrace(e, null, this);
    }
};
WebSquare.uiplugin.gridView.prototype.mergeByRow = function(options) {
    try {
        if (typeof options === "undefined" || options == null) {
            options = {};
        }
        var rowCnt = this.getRowCount();
        var colCnt = this.getColumnCount();
        var rowStart = this.options.fixedRow;
        var colStart = this.options.fixedColumn;
        var colEnd = colCnt - this.options.fixedRightColumn;
        var rowEnd = rowCnt;
        var upperRowColumns = {};
        if (options.keepMerge !== true && options.fixedRows !== true && options.fixedCols !== true) {
            this.cellMergeInfo = {};
        }
        var beforeMergedCells = {};
        if (options.keepMerge === true) {
            beforeMergedCells = this.getMergedCells();
        }
        if (options.fixedRows === true) {
            rowStart = 0;
            rowEnd = this.options.fixedRow;
            colStart = 0;
            colEnd = colCnt;
        }
        var fixedColBoth = false;
        if (options.fixedCols === true) {
            if (this.options.fixedColumn == 0) {
                colStart = colCnt - this.options.fixedRightColumn;
                colEnd = colCnt;
            } else if (this.options.fixedRightColumn == 0) {
                colStart = 0;
                colEnd = this.options.fixedColumn;
            } else {
                colStart = 0;
                colEnd = colCnt;
                fixedColBoth = true;
            }
            if (options.fixedRows === false) {
                rowStart = this.options.fixedRow;
                rowEnd = rowCnt;
            } else {
                rowStart = 0;
                rowEnd = rowCnt;
            }
        }
        var useDrilldown = !!(this.isDrillDown && this._dataList.options.depthColumn);
        for (var row = rowStart; row < rowEnd; row++) {
            var realRow = useDrilldown ? this.getRealRowIndex(row) : row;
            if (options.mergeRow) {
                if (options.mergeRow[realRow] === false) {
                    continue;
                }
            } else if (this.mergeRowObj[realRow] === false) {
                continue;
            }
            for (var col = colStart; col < colEnd; col++) {
                if (fixedColBoth) {
                    if (col >= this.options.fixedColumn && col < colEnd - this.options.fixedRightColumn) {
                        continue;
                    }
                }
                var currentData = this.dataList._getCellData(row, this.tdIdList[col]);
                var idx = 1;
                if (options.keepMerge === true) {
                    idx = 0;
                }
                if (options.upperRow === true) {
                    upperRowColumns[col] = true;
                }
                if (options.mergeCol) {
                    if (options.mergeCol[col] === false) {
                        continue;
                    }
                } else if (this.mergeColObj[col] === false) {
                    continue;
                }
                while (idx < colEnd - col) {
                    if (options.mergeCol) {
                        if (options.mergeCol[col + idx] === false) {
                            break;
                        }
                    } else if (this.mergeColObj[col + idx] === false) {
                        break;
                    }
                    if (fixedColBoth) {
                        if (col + idx >= this.options.fixedColumn && col + idx < colEnd - this.options.fixedRightColumn) {
                            break;
                        }
                    } else if (col + idx > colEnd) {
                        break;
                    }
                    var nextData = (idx === 0) ? currentData : this.dataList._getCellData(row, this.tdIdList[col + idx]);
                    if (currentData != nextData) {
                        break;
                    }
                    if (options.keepMerge === true && beforeMergedCells[realRow + "_" + (col + idx)] === true) {
                        break;
                    }
                    if (options.upperRow === true && upperRowColumns[col + idx] === true) {
                        break;
                    }
                    idx++;
                }
                if (idx > 1) {
                    this.cellMergeInfo[realRow + "_" + col] = {
                        "rowSpan": 1,
                        "colSpan": idx
                    }
                    col = col + idx - 1;
                }
            }
        }
        upperRowColumns = undefined;
        if (options.noDraw !== true) {
            this.dynamicMergeHTML();
        }
    } catch (e) {
        WebSquare.exception.printStackTrace(e, null, this);
    }
};
WebSquare.uiplugin.gridView.prototype.getMergedCells = function() {
    try {
        var ret = {};
        for (var key in this.cellMergeInfo) {
            var _point = key.split('_');
            var mergeInfo = this.cellMergeInfo[key];
            var rowIndex = parseInt(_point[0], 10);
            var colIndex = parseInt(_point[1], 10);
            var rowSpan = mergeInfo.rowSpan || 1;
            var colSpan = mergeInfo.colSpan || 1;
            if (colSpan > 1 || rowSpan > 1) {
                for (var i = 0; i < rowSpan; i++) {
                    for (var j = 0; j < colSpan; j++) {
                        ret[(rowIndex + i) + "_" + (colIndex + j)] = true;
                    }
                }
            }
        }
        return ret;
    } catch (e) {
        WebSquare.exception.printStackTrace(e, null, this);
    }
}
WebSquare.uiplugin.gridView.prototype.mergeCell = function(mergeInfo) {
    try {
        if (mergeInfo == undefined || mergeInfo.rowIndex == undefined || mergeInfo.colIndex == undefined) {
            WebSquare.logger.printLog("gridView mergeCell error : invalid argument [" + this.id + "]");
            return;
        }
        if (mergeInfo.rowSpan == undefined) {
            mergeInfo.rowSpan = 1;
        }
        if (mergeInfo.colSpan == undefined) {
            mergeInfo.colSpan = 1;
        }
        var mergeRowIndex = parseInt(mergeInfo.rowIndex, 10);
        var mergeColIndex = parseInt(mergeInfo.colIndex, 10);
        var mergeRowSpan = parseInt(mergeInfo.rowSpan, 10);
        var mergeColSpan = parseInt(mergeInfo.colSpan, 10);
        var realRowIndex = this.getRealRowIndex(mergeRowIndex);
        if (mergeRowSpan > 1 || mergeColSpan > 1) {
            this.cellMergeInfo[mergeRowIndex + "_" + mergeColIndex] = {
                "rowSpan": mergeRowSpan,
                "colSpan": mergeColSpan
            };
        } else if (this.cellMergeInfo[mergeRowIndex + "_" + mergeColIndex] != undefined) {
            delete this.cellMergeInfo[mergeRowIndex + "_" + mergeColIndex];
        }
        var useDrilldown = !!(this.isDrillDown && this._dataList.options.depthColumn);
        var targetRowIndex = useDrilldown ? mergeRowIndex : realRowIndex;
        var targetData = this.dataList._getCellData(targetRowIndex, mergeColIndex, "3");
        for (var i = 0; i < mergeRowSpan; i++) {
            for (var j = 0; j < mergeColSpan; j++) {
                if (i === 0 && j === 0) {
                    continue;
                }
                var dataObj = {
                    "filteredRowIndex": mergeRowIndex + i,
                    "colID": mergeColIndex + j,
                    "data": targetData,
                    "useRealRowIndex": useDrilldown
                };
                this.dataList._setCellData(dataObj);
                if (this.cellMergeInfo[(mergeRowIndex + i) + "_" + (mergeColIndex + j)]) {
                    delete this.cellMergeInfo[(mergeRowIndex + i) + "_" + (mergeColIndex + j)];
                }
            }
        }
        this.dynamicMergeHTML();
    } catch (e) {
        WebSquare.exception.printStackTrace(e, null, this);
    }
};
WebSquare.uiplugin.mappingController.prototype._setCellData = function(filteredRowIndex, colID, data, noDraw, direction, skipBroadCast, noEvent, excludeId, skipInstance) {
    ["WebSquare.uiplugin.mappingController.prototype._setCellData"];
    try {
        var useRealRowIndex = false;
        if (typeof filteredRowIndex == "object" && filteredRowIndex != null) {
            colID = filteredRowIndex.colID;
            data = filteredRowIndex.data;
            noDraw = filteredRowIndex.noDraw;
            direction = filteredRowIndex.direction;
            skipBroadCast = filteredRowIndex.skipBroadCast;
            noEvent = filteredRowIndex.noEvent;
            excludeId = filteredRowIndex.excludeId;
            skipInstance = filteredRowIndex.skipInstance;
            useRealRowIndex = filteredRowIndex.useRealRowIndex;
            var temp_filteredRowIndex = filteredRowIndex.filteredRowIndex;
            filteredRowIndex = null;
            filteredRowIndex = temp_filteredRowIndex;
        }
        if (data === null || data === undefined) {
            data = "";
        }
        if (this._grid.editedCell != null && !this._grid.getCellOption(filteredRowIndex, colID, "embeddedInput")) {
            this._grid.editedCell.handleCancelEdit();
        }
        var maxRow = this._grid._dataList.getTotalRow();
        var maxCol = this._grid._dataList.getTotalCol();
        var realRowIndex;
        if (useRealRowIndex === true) {
            realRowIndex = filteredRowIndex;
        } else if (this._grid.options && this._grid.options.pluginName === "grid" && this._grid.isDrillDown && this._grid.options.drilldownRealRowIndex && !this._grid._linkedDataList) {
            realRowIndex = filteredRowIndex;
        } else {
            realRowIndex = this._grid.getRealRowIndex(filteredRowIndex);
        }
        var displayRowIndex = filteredRowIndex;
        var oldData = "";
        var colID = this._grid.getColumnID(colID);
        var colIndex = this._grid.getColumnIndex(colID);
        var dColIndex = this._grid._dataList.getColumnIndex(colID);
        var tempRowIndex = this._grid.groupbyStatus.grouped ? realRowIndex : filteredRowIndex;
        if (this._grid.isDrillDown && this._grid._dataList.options.depthColumn) {
            oldData = this.getCellData(realRowIndex, colID, "3");
        } else {
            if (tempRowIndex >= 0 && tempRowIndex < maxRow && dColIndex >= 0 && dColIndex < maxCol) {
                oldData = this.getCellData(filteredRowIndex, colID);
            }
        }
        if (tempRowIndex >= 0 && tempRowIndex < maxRow && dColIndex >= 0 && dColIndex < maxCol) {
            var cellInfo = this._grid.cellInfoHash[this._grid.tdIdList[colIndex]] || {
                "options": {}
            };
            var inputType = cellInfo.options.inputType || "text";
            if ((inputType == "text" || inputType == "textImage" || inputType == "drilldown") && cellInfo.options.applyFormat == "all" && !cellInfo.options.embeddedInput) {
                var curInput = this._grid.getInput(cellInfo);
                oldData = cellInfo.formatter.format(oldData);
                oldData = curInput.validator.validateString(oldData);
            }
            var cellDataType = this._grid.getColumnOption(cellInfo.options.col_id, "dataType");
            if (cellDataType == "bigDecimal" && typeof data == "string") {
                data = WebSquare.bigDecimal(data).toString();
            } else if (cellDataType == "bigDecimal") {
                $l("If dataType is bigDecimal, data must be entered to String." + "[" + this.id + "]");
                data = WebSquare.bigDecimal(data).toString();
            }
            var dataTemp = data.toString().replace(/\r(\n)?/, "\n");
            var oldDataTemp = oldData.toString().replace(/\r(\n)?/, "\n");
            if (dataTemp !== oldDataTemp) {
                var dataRowIndex = filteredRowIndex;
                if (this._grid.isDrillDown && this._grid._dataList.options.depthColumn) {
                    dataRowIndex = realRowIndex;
                }
                if (this._grid.groupbyStatus.grouped) {
                    this._grid._dataList._setCellData({
                        "filteredRowIndex": realRowIndex,
                        "colID": colID,
                        "value": data,
                        "direction": direction,
                        "skipBroadCast": skipBroadCast,
                        "noEvent": noEvent,
                        "excludeId": excludeId,
                        "realRowIndex": true,
                        "notifyRowIndex": filteredRowIndex,
                        "skipInstance": skipInstance
                    });
                } else {
                    this._grid._dataList._setCellData(dataRowIndex, colID, data, direction, skipBroadCast, noEvent, excludeId, skipInstance);
                }
                if (this._grid._dataList.getColumnID(colID) == undefined) {
                    this._grid.notifyCellChanged(displayRowIndex, colIndex);
                }
                WebSquare.event.fireEvent(this._grid, "onchange", filteredRowIndex, colIndex, data, oldData);
                if (cellInfo.options.inputType == "radio" && cellInfo.options.groupName && cellInfo.options.trueValue == data) {
                    cellInfo.resetOthers(filteredRowIndex);
                    if (this._grid.radioGroupRepChk[cellInfo.options.groupName]) {
                        this.setCellData(filteredRowIndex, cellInfo.options.groupName, cellInfo.options.groupValue);
                    }
                }
                if (this._grid.radioGroupRepChk[cellInfo.options.id]) {
                    var colCnt = this._grid.getColumnCount();
                    for (var radioCol = 0; radioCol < colCnt; radioCol++) {
                        var radioCellInfo = this._grid.cellInfoHash[this._grid.tdIdList[radioCol]] || {
                            "options": {}
                        };
                        if (radioCellInfo.options.inputType == "radio" && radioCellInfo.options.groupName == cellInfo.options.id && radioCellInfo.options.groupValue == data) {
                            this.setCellData(filteredRowIndex, radioCol, radioCellInfo.options.trueValue, direction, skipBroadCast, noEvent, excludeId, skipInstance);
                            break;
                        }
                    }
                    if (radioCol == colCnt) {
                        this._grid._resetRadioGroup(filteredRowIndex, cellInfo.id, false);
                    }
                }
                if (this._grid.isDrillDown) {
                    if (this._grid.drilldown.options.depthColumn == colIndex) {
                        this._grid.notifyDataChanged({
                            keepTop: true
                        });
                        if (this._grid.getDataLength() == 0) {
                            this._grid.removeFocusedCell();
                        }
                        this._grid.setScrollYHeight();
                    } else {
                        if (cellInfo.options.inputType == "checkbox" && cellInfo.options.setRecursive) {
                            var childRows = this._grid.drilldown.getChildRowArr(filteredRowIndex, true);
                            for (var i = 0; i < childRows.length; i++) {
                                if (this._getData(childRows[i], colIndex) != data) {
                                    this._setCellData(childRows[i], colIndex, data, noDraw, direction, skipBroadCast, noEvent, excludeId, skipInstance); 
                                }
                            }
                        }
                    }
                }
            } else if (this._grid.editedCell != null && !noDraw) {
                this._grid.notifyCellChanged(displayRowIndex, colIndex);
            }
        }
    } catch (e) {
        WebSquare.exception.printStackTrace(e);
    }
};
WebSquare.uiplugin.gridView.prototype.dynamicMergeHTML = function() {
    ["WebSquare.uiplugin.drawController.prototype.dynamicMergeHTML"];
    try {
        for (var tdIdx in this.tdMergeInfo) {
            var targetTd = this.data_td_list[tdIdx];
            if (this.tdMergeInfo[tdIdx].orgColSpan > 1) {
                targetTd.setAttribute("colSpan", this.tdMergeInfo[tdIdx].orgColSpan);
            } else {
                targetTd.removeAttribute("colSpan");
            }
            if (this.tdMergeInfo[tdIdx].orgRowSpan > 1) {
                targetTd.setAttribute("rowSpan", this.tdMergeInfo[tdIdx].orgRowSpan);
            } else {
                targetTd.removeAttribute("rowSpan");
            }
            targetTd.style.display = this.tdMergeInfo[tdIdx].display;
            delete this.tdMergeInfo[tdIdx];
        }
        var maxRow = this.getRowCount();
        var lastRow = this.options.drawType === "native" ? maxRow : Math.min(this.lastIndex + 2, maxRow);
        var useDrilldown = !!(this.isDrillDown && this._dataList.options.depthColumn);
        var bMerged = false;
        for (var cellIdx in this.cellMergeInfo) {
            var idxArr = cellIdx.split("_");
            var rowIndex = Number(idxArr[0]);
            var drillDownRealRowIndex = rowIndex;
            if (useDrilldown) {
                rowIndex = this.getDisplayRowIndex(rowIndex);
                if (isNaN(rowIndex) || rowIndex < 0) {
                    continue;
                }
            }
            var colIndex = Number(idxArr[1]);
            var trIndex = rowIndex;
            if (this.rowIndex >= 0) {
                if ((this.options.fixedRow > 0 && this.options.fixedRow > rowIndex) || (this.options.lastFixedRow > 0 && rowIndex > this.lastIndex - this.options.lastFixedRow)) {
                } else {
                    trIndex -= this.rowIndex;
                }
            }
            var displayRowSpan = this.cellMergeInfo[cellIdx].rowSpan; 
            var newColSpan = this.cellMergeInfo[cellIdx].colSpan;
            if (useDrilldown) {
                var tempDisplayRowSpan = displayRowSpan;
                for (var i = 0; i < tempDisplayRowSpan; i++) {
                    if (this.drilldown.statusArr[drillDownRealRowIndex + i] == false) {
                        displayRowSpan--;
                    }
                }
                displayRowSpan = Math.max(displayRowSpan, 1);
            }
            var hiddenTrCnt = 0;
            if (this.hiddenRowObj.length > 0) {
                for (var i = this.rowIndex; i < rowIndex; i++) {
                    if (!this._getRowVisible(i)) {
                        hiddenTrCnt++;
                    }
                }
            }
            if ((trIndex < 0 && trIndex + displayRowSpan <= 0) || trIndex - hiddenTrCnt >= lastRow) {
                continue;
            }
            if (trIndex < this.options.fixedRow && trIndex + displayRowSpan > this.options.fixedRow) {
                displayRowSpan = trIndex + displayRowSpan - this.options.fixedRow - hiddenTrCnt;
                trIndex = this.options.fixedRow;
            }
            if (trIndex < this.options.fixedRow && rowIndex >= this.options.fixedRow) {
                continue;
            }
            var mergeRowIndex = 0;
            var hiddenRowCnt = 0;
            if (this.hiddenRowObj.length > 0) {
                for (var i = 0; i < displayRowSpan; i++) {
                    if (!this._getRowVisible(trIndex + i + this.rowIndex)) {
                        hiddenRowCnt++;
                        if (i === mergeRowIndex) {
                            mergeRowIndex++;
                        }
                    }
                }
            }
            displayRowSpan -= hiddenRowCnt;
            if (trIndex + displayRowSpan > lastRow + hiddenTrCnt) {
                displayRowSpan = lastRow - trIndex + hiddenTrCnt;
            }
            var visibleRowSpan = displayRowSpan;
            var multiRowNum = this.oneRowLength;
            for (var i = 0; i < visibleRowSpan; i++) {
                var additonalRow = false;
                for (var j = 0; j < newColSpan; j++) {
                    var tdIdx = (trIndex + i) * this.oneRowDataLength + (colIndex + j);
                    var targetTd = this.data_td_list[tdIdx];
                    if (targetTd == undefined) {
                        continue;
                    }
                    if (this.hiddenRowObj.length > 0 && !this._getRowVisible(trIndex + i + this.rowIndex)) {
                        targetTd.removeAttribute("colSpan");
                        targetTd.removeAttribute("rowSpan");
                        additonalRow = true;
                        continue;
                    }
                    this.tdMergeInfo[tdIdx] = {
                        "orgColSpan": targetTd.getAttribute("colSpan"),
                        "orgRowSpan": targetTd.getAttribute("rowSpan"),
                        "display": targetTd.style.display
                    }
                    if (i === mergeRowIndex && j === 0) {
                        if (newColSpan > 1) {
                            targetTd.setAttribute("colSpan", newColSpan);
                            bMerged = true;
                        } else {
                            targetTd.removeAttribute("colSpan");
                        }
                        var cRowSpan = displayRowSpan * multiRowNum;
                        if (cRowSpan > 1) {
                            if (multiRowNum > 1) {
                                var oldRowSpan = parseInt(targetTd.getAttribute("rowSpan"), 10);
                                if (!isNaN(oldRowSpan) && oldRowSpan > 1) {
                                    targetTd.setAttribute("rowSpan", cRowSpan);
                                    bMerged = true;
                                }
                            } else {
                                targetTd.setAttribute("rowSpan", displayRowSpan);
                                bMerged = true;
                            }
                        } else {
                            targetTd.removeAttribute("rowSpan");
                        }
                        targetTd.style.display = "";
                    } else {
                        targetTd.removeAttribute("colSpan");
                        targetTd.removeAttribute("rowSpan");
                        targetTd.style.display = "none";
                    }
                }
                if (additonalRow === true) {
                    visibleRowSpan++;
                }
            }
        }
        if (bMerged === true && this.isWebKit) {
            WebSquare.util.setTimeout(this.redrawTable, {
                "key": this.id + "_dynamicMergeHTML",
                "delay": 50,
                "caller": this
            });
        }
    } catch (e) {
        WebSquare.exception.printStackTrace(e, null, this);
    }
}
WebSquare.uiplugin.gridView.prototype.fastDrawData = function(startPoint, fastScroll) {
    ["WebSquare.uiplugin.drawController.prototype.fastDrawData"];
    try {
        if (this.options.measureTime) {
            WebSquare.core.measureTime(function(reading) {
                var time = reading.aver;
                var fps = parseInt(1000 / time * 10, 10) / 10;
                WebSquare.logger.printLog("Id : " + this.id + ", time : " + time + "ms   ,fps : " + fps);
            }, {
                key: this.id + "_measureDrawTime",
                caller: this
            });
        }
        var rowIndex = this.rowIndex;
        var dataLen = this.getDataLength();
        var startPoint = startPoint || 0;
        var visibleStart = this._getVisibleTrRowIndex(startPoint, rowIndex);
        var i = visibleStart;
        if (dataLen > 0) {
            if (startPoint == 0 && rowIndex != this.lastTopRowIndex && this.options.visibleRowNum === "") {
                this.drawSubtotalRow(0, rowIndex - 1);
            }
            var stdt = new Date();
            var visibleEnd = this._getVisibleTrRowIndex(this.drawedRowLength, rowIndex);
            var visibleLimitRow = this._getVisibleTrRowIndex(this.options.drawLimitRow, rowIndex);
            for (; i < visibleEnd && (i + rowIndex) < dataLen; i++) {
                if (this._getRowVisible(i + rowIndex)) {
                    this._setRowDisplay(i, "");
                } else {
                    this._setRowDisplay(i, "none");
                    continue;
                }
                if (fastScroll && new Date() - stdt > this.options.drawLimitTime && i >= visibleLimitRow) {
                    this.hideNochangeDataLayer(i);
                    return i;
                }
                if (this.options.fixedRow > 0 && this.options.fixedRow > i) {
                    this.fastDrawRowData(i, i);
                } else if (this.options.lastFixedRow > 0 && i > this.lastIndex - this.options.lastFixedRow) {
                } else {
                    this.fastDrawRowData(i, i + rowIndex);
                }
                if (this.options.backgroundColorMode.toLowerCase() == "always") {
                    if (typeof this.dataList.getRealRowIndex() != "object") {
                        if (this.options.fixedRow > 0 && this.options.fixedRow > i) {
                            this.applyRowStyleOptions(i);
                        } else if (this.options.lastFixedRow > 0 && i > this.lastIndex - this.options.lastFixedRow) {
                        } else {
                            this.applyRowStyleOptions(rowIndex + i);
                        }
                    }
                }
                if (this.lastDisplayedRow < i) {
                    this._setRowDisplay(i, "");
                    this.lastDisplayedRow = i;
                }
            }
        }
        if (this.hideDataLayer) {
            this.hideDataLayer.style.display = "none";
        }
        if (this.lastTopRowIndex !== null && rowIndex >= this.lastTopRowIndex) {
            for (var j = i; j <= this.lastDisplayedRow; j++) {
                this._setRowDisplay(j, "none");
            }
            this.lastDisplayedRow = i - 1;
        }
        if (this.options.mergeRefreshAlways === "true") {
            this._mergeRefresh();
        }
        return i;
    } catch (e) {
        WebSquare.exception.printStackTrace(e, null, this);
    }
};