Saiku导出excel指标列无线条以及0与空值显示问题（三十二）

Saiku导出excel指标列无线条以及0与空值显示问题

描述： 数据库中字段值为0 ，与数据库中字段值为 null 时 ，saiku会将为0 以及为 null 的数据都不展示出来，但是我们其实希望数据库中为0 的数据展示位0 ，为null的时候就是null 可以不展示。

 

table展示0与null有两个点需要处理：

1. 展示在页面上的table数据

2.导出的excel中的数据（导出excel还有个格式问题，指标信息没有线条分割，维度信息正常）

 

1.我们先来解决一下怎么让（0与null）数据在页面中展示正常

在saiku的SaikuTableRenderer.js文件中 添加為0的數據顯示問題 （修改後為0的DATA_CELL也會正常顯示為0），line825-828

if (val == " " || val == '') {
　　val=0;
}

　　

添加位置可参考下图： （SaikuTableRenderer.js）

后台查询接口对于0值返回的结果是 " "，所以我就用了以上判断，可自己debug调试哦。

 

2.导出excel数据时问题处理 后台导出excel使用POI插件

>>>添加线条：

  ExcelWorksheetBuilder.java ---> line 154 添加 setCellBordersColor(numberCS);

添加位置可参考下图： （ExcelWorksheetBuilder.java）

 

 

>>>处理0与null值的问题

1.在FlattenedCellSetFormatter.java中修改cellvalue的值为0.

（这里if里面的判断条件是我debug出来的哦，当数据为空的时候，cellvalue的值时空的，当数据为0的时候，cellvalue的值是 | |style=white ,当数据有其他值的时候（例如33），cellvalue的值为 |33 |style=white）

 

2.接下来就是导出时的样式设置了

在ExcelWorksheetBuilder.java中添加新的样式设定，专门对于cellvalue的值为0.（红色框框中为添加内容）

 

 3.在 ExcelWorksheetBuilder.java的 initCellStyles()方法中添加对 number0CS的初始化

  

4.在 ExcelWorksheetBuilder.java的addExcelTableRows()方法中对0值的添加自定义的样式处理。

（这里说明一下为什么还要判断一下 formatString的值是否为 #，### ，因为有其他样式的时候0值不会被忽略掉，比如 formatString= #,#00.00% 这种百分比形式时，0值对应的值就会为 0.00%）

红色框框为改动后的内容，之前这个位置的代码为：  applyCellFormating(cell,dataCell);

 

 至此，我们对于table渲染0值与空值的问题就处理好了，导出的excel指标数据也会有线条啦~  重新打包编译，启动saiku即可~

 

ps： 顺便提一下iframe嵌入saiku url的问题，会有那种偶然性的 bug,大概是网络问题 导致js加载出问题了，然后嵌入的iframe展示高度就会变得很短。

处理方案：   在saiku的 saiku.table.css中設置.workspace_results 樣式的最小高度為708 min-height  

 

最后提供完整的文件信息：

SaikuTableRenderer.js

function SaikuTableRenderer(data, options) {
    this._data = data;
    this._options = _.extend({}, SaikuRendererOptions, options);
}
 
function getAxisLevelsName(data, axisName) {
    var queryData = data.query.queryModel.axes[axisName].hierarchies;
    var len = queryData.length;
    var arrLevels = [];
 
    for (var i = 0; i < len; i++) {
        for (var level in queryData[i].levels) {
            if (queryData[i].levels.hasOwnProperty(level)) {
                if (Settings.COLUMN_TITLE_TABLE_USE_LEVEL_CAPTION_NAME) {
                    arrLevels.push(queryData[i].levels[level].caption);
                }
                else {
                    arrLevels.push(level);
                }
            }
        }
    }
 
    return arrLevels;
}
 
function setStyleNegativeNumber(value) {
    var className = '';
 
    if (Settings.STYLE_NEGATIVE_NUMBER && parseFloat(value) < 0) {
        className = ' style_negative_number ';
    }
 
    return className;
}
 
function getAxisSize(data, axisName) {
    var queryData = data.query.queryModel.axes[axisName].hierarchies;
    var len = queryData.length;
    var axisSize = 0;
 
    for (var i = 0; i < len; i++) {
        axisSize += _.size(queryData[i].levels);
    }
 
    return axisSize;
}
 
function getDomColumnsLevelsName(htmlObject) {
    var $htmlObject = $(htmlObject.closest('.workspace')
                           .find('.workspace_fields')
                           .find('.columns.axis_fields')
                           .find('.hierarchy')
                           .find('.d_level'));
    var arrLevels = [];
 
    $.each($htmlObject, function(key, level) {
        if ($(level).attr('style') === 'display: list-item;') {
            if (Settings.COLUMN_TITLE_TABLE_USE_LEVEL_CAPTION_NAME) {
                arrLevels.push($(level).find('.level').attr('title'));
            }
            else {
                arrLevels.push($(level).find('.level').attr('level'));
            }
        }
    });
 
    return arrLevels;
}
 
/*table render method*/
SaikuTableRenderer.prototype.render = function(data, options) {
        var self = this;
        if (data) {
            this._data = data;
        }
        if (options) {
            this._options = _.extend({}, SaikuRendererOptions, options);
        }
 
        if (typeof this._data == "undefined") {
            return;
        }
 
        if (this._data != null && this._data.error != null) {
            return;
        }
        if (this._data == null || (this._data.cellset && this._data.cellset.length === 0)) {
            return;
        }
 
        this.hideEmpty = this._options.hideEmpty;
 
        if (this._options.htmlObject) {
//            $(this._options.htmlObject).stickyTableHeaders("destroy");
 
            // in case we have some left over scrollers
            if (self._options.hasOwnProperty('batch')) {
                $(self._options.htmlObject).parent().parent().unbind('scroll');
            }
 
            _.defer(function(that) {
                if (self._options.hasOwnProperty('batch') && !self._options.hasOwnProperty('batchSize')) {
                    self._options['batchSize'] = 1000;
                }
				
				// the key method to render data by table form. 20190423
                var html =  self.internalRender(self._data, self._options);
                $(self._options.htmlObject).html(html);
                // Render the totals summary
                $('#totals_summary').remove(); // Remove one previous totals div, if present
                $(self._options.htmlObject).after(self.renderSummary(data)); // Render the new summary
 
//                $(self._options.htmlObject).stickyTableHeaders( { container: self._options.htmlObject.parent().parent(), fixedOffset: self._options.htmlObject.parent().parent().offset().top });
 
                _.defer(function(that) {
                    if (self._options.hasOwnProperty('batch') && self._options.hasBatchResult) {
                        var batchRow = 0;
                        var batchIsRunning = false;
                        var batchIntervalSize = self._options.hasOwnProperty('batchIntervalSize') ? self._options.batchIntervalSize : 20;
                        var batchIntervalTime = self._options.hasOwnProperty('batchIntervalTime') ? self._options.batchIntervalTime : 20;
 
                        var len = self._options.batchResult.length;
 
                        var batchInsert = function() {
                            // maybe add check for reach table bottom - ($('.workspace_results').scrollTop() , $('.workspace_results table').height()
                            if (!batchIsRunning && len > 0 && batchRow < len) {
                                batchIsRunning = true;
                                var batchContent = "";
                                var startb = batchRow;
                                for (var i = 0;  batchRow < len && i < batchIntervalSize ; i++, batchRow++) {
                                    batchContent += self._options.batchResult[batchRow];
                                }
                                if (batchRow > startb) {
                                    $(self._options.htmlObject).append( $(batchContent));
                                }
                                batchIsRunning = false;
                            }
                            if (batchRow >= len) {
                                $(self._options.htmlObject).parent().parent().unbind('scroll');
                            }
                        };
 
                        var lazyBatchInsert = _.debounce(batchInsert, batchIntervalTime);
                        $(self._options.htmlObject).parent().parent().scroll(function () {
                            lazyBatchInsert();
                        });
                    }
                });
                return html;
            });
        } else {
            var html =  this.internalRender(this._data, self._options);
            return html;
        }
 
};
 
SaikuTableRenderer.prototype.clear = function(data, options) {
    var self = this;
    if (this._options && this._options.htmlObject && this._options.hasOwnProperty('batch')) {
        $(self._options.htmlObject).parent().parent().unbind('scroll');
    }
 
};
 
SaikuTableRenderer.prototype.processData = function(data, options) {
    this._hasProcessed = true;
};
 
function genTotalDataCells(currentIndex, cellIndex, scanSums, scanIndexes, lists) {
    var contents = '';
    var lists = lists[ROWS];
 
    for (var i = scanSums.length - 1; i >= 0; i--) {
        if (currentIndex == scanSums[i]) {
            var currentListNode = lists[i][scanIndexes[i]];
            for (var m = 0; m < currentListNode.cells.length; m++) {
                contents += '<td class="data total">' + currentListNode.cells[m][cellIndex].value + '</td>';
            }
 
            scanIndexes[i]++;
            if (scanIndexes[i] < lists[i].length)
                scanSums[i] += lists[i][scanIndexes[i]].width;
        }
    }
 
    return contents;
}
 
function genTotalHeaderCells(currentIndex, bottom, scanSums, scanIndexes, lists, wrapContent) {
    var contents = '';
    for (var i = bottom; i >= 0; i--) {
        if (currentIndex == scanSums[i]) {
            var currentListNode = lists[i][scanIndexes[i]];
            var cssClass;
            if (i == 0 && bottom == 1)
                cssClass = "col";
            else if (i == bottom)
                cssClass = "col_total_corner";
            else if (i == bottom - 1 && currentListNode.captions)
                cssClass = "col_total_first";
            else cssClass = "col_null";
 
            for (var m = 0; m < currentListNode.cells.length; m++) {
                var text = ' ';
                if (bottom == lists.length - 1) {
                    if (currentListNode.captions) {
                        text = lists[i][scanIndexes[i]].captions[m];
                    }
                    if (i == 0 && scanIndexes[i] == 0) {
                        if (currentListNode.captions)
                            text += " ";
                        else text = "";
                        text += (wrapContent ? "<span class='i18n'>Grand Total</span>" :  "Grand Total");
                    }
                }
                contents += '<th class="' + cssClass + '">'
                  + (wrapContent ? '<div>' + text + '</div>' : text ) + '</th>';
            }
            scanIndexes[i]++;
            if (scanIndexes[i] < lists[i].length)
                scanSums[i] += lists[i][scanIndexes[i]].width;
        }
    }
    return contents;
}
 
function totalIntersectionCells(currentIndex, bottom, scanSums, scanIndexes, lists) {
    var contents = '';
    for (var i = bottom; i >= 0; i--) {
        if (currentIndex == scanSums[i]) {
            var currentListNode = lists[i][scanIndexes[i]];
            var cssClass = "data total";
            for (var m = 0; m < currentListNode.cells.length; m++) {
                var text = ' ';
                contents += '<td class="' + cssClass + '">' + text + '</td>';
            }
            scanIndexes[i]++;
            if (scanIndexes[i] < lists[i].length)
                scanSums[i] += lists[i][scanIndexes[i]].width;
        }
    }
    return contents;
}
 
function isNextTotalsRow(currentIndex, scanSums, scanIndexes, totalsLists, wrapContent) {
    var colLists = totalsLists[COLUMNS];
    var colScanSums = scanSums[COLUMNS];
    var colScanIndexes = scanIndexes[COLUMNS];
    var bottom = colLists.length - 2;
    var contents = -1;
    for (var i = bottom; i >= 0; i--) {
        if (currentIndex == colScanSums[i]) {
            for (var m = 0; m < colLists[i][colScanIndexes[i]].cells.length; m++) {
                contents += '<tr>';
                for (var j = 0; j <= bottom; j++) {
                    var cssClass;
                    var text = ' ';
                    if (i == 0 && j == 0)
                        cssClass = 'row';
                    else if (i == j + 1){
                        cssClass = 'row_total_corner';
                        return j;
                    }
                    else if (i == j && colLists[i][colScanIndexes[i]].captions) {
                        cssClass = 'row_total_first';
                    } else if (i < j + 1)
                        cssClass = 'row_total';
                    else
                        cssClass = 'row_null';
                    if (j == bottom ) {
                        if (colLists[i][colScanIndexes[i]].captions) {
                            text = colLists[i][colScanIndexes[i]].captions[m];
                        }
                        if (i == 0 && colScanIndexes[i] == 0) {
                            if (colLists[i][colScanIndexes[i]].captions)
                                text += " ";
                            else text = "";
                            text += (wrapContent ? "<span class='i18n'>Grand Total</span>" :  "Grand Total");
                        }
                    }
 
                }
            }
        }
    }
    return -1;
}
 
function genTotalHeaderRowCells(currentIndex, scanSums, scanIndexes, totalsLists, wrapContent) {
    var colLists = totalsLists[COLUMNS];
    var colScanSums = scanSums[COLUMNS];
    var colScanIndexes = scanIndexes[COLUMNS];
    var bottom = colLists.length - 2;
    var contents = '';
    for (var i = bottom; i >= 0; i--) {
        if (currentIndex == colScanSums[i]) {
            for (var m = 0; m < colLists[i][colScanIndexes[i]].cells.length; m++) {
                contents += '<tr>';
                for (var j = 0; j <= bottom; j++) {
                    var cssClass;
                    var text = ' ';
                    if (i == 0 && j == 0)
                        cssClass = 'row';
                    else if (i == j + 1)
                        cssClass = 'row_total_corner';
                    else if (i == j && colLists[i][colScanIndexes[i]].captions) {
                        cssClass = 'row_total_first';
                    } else if (i < j + 1)
                        cssClass = 'row_total';
                    else
                        cssClass = 'row_null';
                    if (j == bottom ) {
                        if (colLists[i][colScanIndexes[i]].captions) {
                            text = colLists[i][colScanIndexes[i]].captions[m];
                        }
                        if (i == 0 && colScanIndexes[i] == 0) {
                            if (colLists[i][colScanIndexes[i]].captions)
                                text += " ";
                            else text = "";
                            text += (wrapContent ? "<span class='i18n'>Grand Total</span>" :  "Grand Total");
                        }
                    }
                    contents += '<th class="' + cssClass + '">'
                                + (wrapContent ? '<div>' + text + '</div>' : text ) + '</th>';
 
                }
 
                var scanIndexes = {};
                var scanSums = {};
 
                if (totalsLists[ROWS]) {
                    for (var z = 0; z < totalsLists[ROWS].length; z++) {
                        scanIndexes[z] = 0;
                        scanSums[z] = totalsLists[ROWS][z][scanIndexes[z]].width;
                    }
                }
 
                for (var k = 0; k < colLists[i][colScanIndexes[i]].cells[m].length; k++) {
                    contents += '<td class="data total">' + colLists[i][colScanIndexes[i]].cells[m][k].value + '</td>';
 
                    if (totalsLists[ROWS]) {
                        contents += totalIntersectionCells(k + 1, totalsLists[ROWS].length - 1, scanSums, scanIndexes, totalsLists[ROWS]);
                    }
                }
 
                contents += '</tr>';
            }
 
            colScanIndexes[i]++;
 
            if (colScanIndexes[i] < colLists[i].length) {
                colScanSums[i] += colLists[i][colScanIndexes[i]].width;
            }
        }
    }
    return contents;
}
 
var ROWS = "ROWS";
var COLUMNS = "COLUMNS";
 
function nextParentsDiffer(data, row, col) {
    while (row-- > 0) {
        if (data[row][col].properties.uniquename != data[row][col + 1].properties.uniquename)
            return true;
    }
    return false;
}
 
 
function topParentsDiffer(data, row, col) {
    while (col-- > 0)
        if (data[row][col].properties.uniquename != data[row - 1][col].properties.uniquename)
            return true;
    return false;
}
 
/**
 * This function is intended to traverse the totals arrays and cleanup empty
 * totals. This will optimize the query result on screen, displaying just the
 * needed cells.
 * @param dirs The direction array ['ROWS', 'COLUMNS']
 * @param totalsLists The totals from allData.rowTotalsLists and allData.colTotalsLists.
 */
function cleanupTotals(dirs, totalsLists) {
    // For each direction (ROWS/COLUMNS)
    for (var dirIndex = 0; dirIndex < dirs.length; dirIndex++) {
        var dir = dirs[dirIndex];
 
        // If there are defined totals
        if (totalsLists[dir]) {
            var isEmpty = true; // A flag to indicate if this total is empty
            for (var row = 0; row < totalsLists[dir].length; row++) {
                var totalsInfoArray = totalsLists[dir][row];
                for (var totalIndex = 0; totalIndex < totalsInfoArray.length; totalIndex++) {
                    var cells = totalsLists[dir][row][totalIndex].cells;
                    for (var cellIndex = 0; cellIndex < cells.length; cellIndex++) {
                        var cellArray = cells[cellIndex];
                        // For each total cell
                        for (var i = 0; i < cellArray.length; i++) {
                            var cell = cellArray[i];
                            // If it contains a value different from empty
                            if (cell.value !== '-') {
                                isEmpty = false; // So, this total is not empty
                            }
                        }
                    }
                }
            }
 
            if (isEmpty) { // If this total is empty
                totalsLists[dir] = null; // Remove it
            }
        }
    }
}
 
/*the main method to render data by table form. 20190423*/
SaikuTableRenderer.prototype.internalRender = function(allData, options) {
    var tableContent = "";
    var rowContent = "";
    var data = allData.cellset;
 
    var newRowContent = '';
    var arrRowData = [];
    var objRowData = [];
 
    var table = data ? data : [];
    var colSpan;
    var colValue;
    var isHeaderLowestLvl;
    var isBody = false;
    var firstColumn;
    var isLastColumn, isLastRow;
    var nextHeader;
    var processedRowHeader = false;
    var lowestRowLvl = 0;
    var rowGroups = [];
    var batchSize = null;
    var batchStarted = false;
    var isColHeader = false, isColHeaderDone = false;
    var resultRows = [];
    var wrapContent = true;
    if (options) {
        batchSize = options.hasOwnProperty('batchSize') ? options.batchSize : null;
        wrapContent = options.hasOwnProperty('wrapContent') ? options.wrapContent : true;
    }
    var totalsLists = {};
    totalsLists[COLUMNS] = allData.rowTotalsLists;
    totalsLists[ROWS] = allData.colTotalsLists;
 
    var scanSums = {};
    var scanIndexes = {};
 
    var dirs = [ROWS, COLUMNS];
 
    var hasMeasures = allData.query && allData.query.queryModel && allData.query.queryModel.details
                   ? allData.query.queryModel.details.measures.length
                   : 0;
 
    if (typeof this._options.htmlObject === 'object' &&
        Settings.ALLOW_AXIS_COLUMN_TITLE_TABLE &&
        hasMeasures > 0 &&
        allData.query.type === 'QUERYMODEL' &&
        allData.query.queryModel.details.axis === 'COLUMNS' &&
        allData.query.queryModel.details.location === 'BOTTOM') {
 
        var arrColumnTitleTable = getAxisLevelsName(allData, COLUMNS);
        var arrDomColumnTitleTable = getDomColumnsLevelsName(this._options.htmlObject);
        var colspanColumnTitleTable = getAxisSize(allData, ROWS);
        var auxColumnTitleTable = 0;
 
        if (arrColumnTitleTable.length === arrDomColumnTitleTable.length) {
            arrColumnTitleTable = arrDomColumnTitleTable;
        }
        else {
            arrColumnTitleTable = _.intersection(arrDomColumnTitleTable, arrColumnTitleTable);
        }
    }
 
    for (var i = 0; i < dirs.length; i++) {
        scanSums[dirs[i]] = new Array();
        scanIndexes[dirs[i]] = new Array();
    }
 
    // Here we cleaup the empty totals
    cleanupTotals(dirs, totalsLists);
 
    if (totalsLists[COLUMNS]) {
        for (var i = 0; i < totalsLists[COLUMNS].length; i++) {
            scanIndexes[COLUMNS][i] = 0;
            scanSums[COLUMNS][i] = totalsLists[COLUMNS][i][scanIndexes[COLUMNS][i]].width;
        }
    }
	
	var headerFlag=true;// add this flag to solve the bug when same data to merge。 20190423
	var cubename = allData.query.cube.name;
    for (var row = 0, rowLen = table.length; row < rowLen; row++) {
        var rowShifted = row - allData.topOffset;
        colSpan = 1;
        colValue = "";
        isHeaderLowestLvl = false;
        isLastColumn = false;
        isLastRow = false;
        isColHeader = false;
        var headerSame = false;
	
        if (totalsLists[ROWS]) {
            for (var i = 0; i < totalsLists[ROWS].length; i++) {
                scanIndexes[ROWS][i] = 0;
                scanSums[ROWS][i] = totalsLists[ROWS][i][scanIndexes[ROWS][i]].width;
            }
        }
 
        rowWithOnlyEmptyCells = true; //默认行数据为空时不展展示，如果改回来 将此条值置为true即可
        
        //var paramsURI = Saiku.URLParams.paramsURI(); //get the param from url
        //var showEmptyRows = paramsURI.showEmptyRows;
		//if(showEmptyRows != null && showEmptyRows != undefined && showEmptyRows != '' && showEmptyRows=='yes') {
		if(cubename == "SummaryKPI_2018_ext" ||cubename == "SummaryKPI_2019_ext" ||cubename == "SummaryKPI_2019_Dynamic"){
			rowWithOnlyEmptyCells = false; //設置行數據為空的時候也顯示數據！ 20190425 for summaryKPI Data
		}
        rowContent = "<tr>";
        var header = null;
 
        if (row === 0) {
            rowContent = "<thead>" + rowContent;
        }
 
        if (typeof this._options.htmlObject === 'object' &&
            Settings.ALLOW_AXIS_COLUMN_TITLE_TABLE &&
            hasMeasures > 0 &&
            allData.query.type === 'QUERYMODEL' &&
            allData.query.queryModel.details.axis === 'COLUMNS' &&
            allData.query.queryModel.details.location === 'BOTTOM' &&
            auxColumnTitleTable < arrColumnTitleTable.length) {
 
            rowContent += '<th class="row_header" style="text-align: right;" colspan="' + colspanColumnTitleTable + '" title="' + arrColumnTitleTable[auxColumnTitleTable] + '">'
                + (wrapContent ? '<div>' + arrColumnTitleTable[auxColumnTitleTable] + '</div>' : arrColumnTitleTable[auxColumnTitleTable])
                + '</th>';
 
            auxColumnTitleTable += 1;
        }
		
		
		//循環遍歷data 將帶小數的年、月去掉小數位; 例如 2018.0 轉換為 2018
		for (var col = 0, colLen = table[row].length; col < colLen; col++) {
			var tmpRow = data[row][col];
			if(tmpRow.properties.hierarchy=="[年].[年]" || tmpRow.properties.hierarchy=="[月].[月]"){
				var tmpValue = tmpRow.value;
				if(tmpValue != null && tmpValue.indexOf('.')>-1){
					tmpValue = tmpValue.substr(0,tmpValue.indexOf('.'));//去掉小數位
					data[row][col].value = tmpValue;
				}
			}
		}
		
		
		
        for (var col = 0, colLen = table[row].length; col < colLen; col++) {
			
            var colShifted = col - allData.leftOffset;
            header = data[row][col];
 
            if (header.type === "COLUMN_HEADER") {
                isColHeader = true;
            }
 
            // If the cell is a column header and is null (top left of table)
            if (header.type === "COLUMN_HEADER" && header.value === "null" && (firstColumn == null || col < firstColumn)) {
                if (((!Settings.ALLOW_AXIS_COLUMN_TITLE_TABLE || (Settings.ALLOW_AXIS_COLUMN_TITLE_TABLE && allData.query.queryModel.details.location !== 'BOTTOM')) || hasMeasures === 0) ||
                    allData.query.type === 'MDX') {
                    rowContent += '<th class="all_null"> </th>';
                }
            } // If the cell is a column header and isn't null (column header of table)
            else if (header.type === "COLUMN_HEADER") {
                if (firstColumn == null) {
                    firstColumn = col;
                }
                if (table[row].length == col+1)
                    isLastColumn = true;
                else
                    nextHeader = data[row][col+1];
 
 
                if (isLastColumn) {
                    // Last column in a row...
                    if (header.value == "null") {
                        rowContent += '<th class="col_null"> </th>';
                    } else {
                        if (totalsLists[ROWS])
                            colSpan = totalsLists[ROWS][row + 1][scanIndexes[ROWS][row + 1]].span;
                        rowContent += '<th class="col" style="text-align: center;" colspan="' + colSpan + '" title="' + header.value + '">'
                            + (wrapContent ? '<div rel="' + row + ":" + col +'">' + header.value + '</div>' : header.value)
                            + '</th>';
                    }
 
                } else {
                    // All the rest...
                    var groupChange = (col > 1 && row > 1 && !isHeaderLowestLvl && col > firstColumn) ?
                        data[row-1][col+1].value != data[row-1][col].value || data[row-1][col+1].properties.uniquename != data[row-1][col].properties.uniquename
                        : false;
 
                    var maxColspan = colSpan > 999 ? true : false;
                    if (header.value != nextHeader.value || nextParentsDiffer(data, row, col) || isHeaderLowestLvl || groupChange || maxColspan) {
                        if (header.value == "null") {
                            rowContent += '<th class="col_null" colspan="' + colSpan + '"> </th>';
                        } else {
                            if (totalsLists[ROWS])
                                colSpan = totalsLists[ROWS][row + 1][scanIndexes[ROWS][row + 1]].span;
                            rowContent += '<th class="col" style="text-align: center;" colspan="' + (colSpan == 0 ? 1 : colSpan) + '" title="' + header.value + '">'
                            + (wrapContent ? '<div rel="' + row + ":" + col +'">' + header.value + '</div>' : header.value)
                            + '</th>';
                        }
                        colSpan = 1;
                    } else {
                        colSpan++;
                    }
                }
                if (totalsLists[ROWS])
                    rowContent += genTotalHeaderCells(col - allData.leftOffset + 1, row + 1, scanSums[ROWS], scanIndexes[ROWS], totalsLists[ROWS], wrapContent);
            } // If the cell is a row header and is null (grouped row header)
            else if (header.type === "ROW_HEADER" && header.value === "null") {
                rowContent += '<th class="row_null"> </th>';
            } // If the cell is a row header and isn't null (last row header)
            else if (header.type === "ROW_HEADER") {
                if (lowestRowLvl == col)
                    isHeaderLowestLvl = true;
                else
                    nextHeader = data[row][col+1];
 
                var previousRow = data[row - 1];
                var nextRow = data[row + 1];
				// when  same set fixed value is false ，It means the same data will not merge。table data will  show row by row.20190423
				//var same=false; 
				
				/*judge the current value and previousRow value,
				if equals ,all set comeback,set the headerFlag is true, 
				we can judge the data as usual. 20190423*/
				if(header.value !== previousRow[col].value){
					headerFlag =true;
				}
 
				/*judge the tableContent include value or not, if include ,
				set the headerFlag value is true to avoid repeat datas showed in table.20190423*/
				if(tableContent.indexOf(header.value) > -1 ){
					headerFlag =true;
				}
	
				/*add headerFlag to judge the data is same ，then control the data merge wheather or not.20190423 */
				var same = !headerSame && !isHeaderLowestLvl && (col == 0 || !topParentsDiffer(data, row, col)) && header.value === previousRow[col].value && headerFlag;
                headerSame = !same;
                var sameAsPrevValue = false;
                if(Settings.ALLOW_TABLE_DATA_COLLAPSE){
                    if (row > 0 && row < rowLen - 1) {
                        if (totalsLists[ROWS] == null || (col <= colLen - totalsLists[ROWS].length - 1)) {
                            var checkOther = true;
                            if (totalsLists[COLUMNS] && rowShifted >= 0 && col <= isNextTotalsRow(rowShifted + 1, scanSums, scanIndexes, totalsLists, wrapContent)) {
                                sameAsPrevValue = true;
                                checkOther = false;
                            }
                            if (checkOther && nextRow[col].value == header.value) {
                                if (col > 0) {
                                    for (var j = 0; j < col; j++) {
                                        if (nextRow[j].value == data[row][j].value) {
                                            sameAsPrevValue = true;
                                        } else {
                                            sameAsPrevValue = false;
                                            break;
                                        }
                                    }
                                } else {
                                    sameAsPrevValue = true;
                                }
                            }
                        }
                    } else if(row > 0 && row == rowLen - 1) {
                        if (totalsLists[COLUMNS] && rowShifted >= 0 && col <= isNextTotalsRow(rowShifted + 1, scanSums, scanIndexes, totalsLists, wrapContent)) {
                            sameAsPrevValue = true;
                        }
                    }
                }
                var value = (same ? "<div> </div>" : '<div rel="' + row + ":" + col + '">'
                            + (sameAsPrevValue && Settings.ALLOW_TABLE_DATA_COLLAPSE ? '<span class="expander expanded" style="cursor: pointer;">▼</span>' : '' ) + header.value + '</div>');
                if (!wrapContent) {
                    value = (same ? " " : header.value );
                }
                var tipsy = "";
                /* var tipsy = ' original-title="';
                if (!same && header.metaproperties) {
                    for (key in header.metaproperties) {
                        if (key.substring(0,1) != "$" && key.substring(1,2).toUpperCase() != key.substring(1,2)) {
                            tipsy += "<b>" + safe_tags_replace(key) + "</b> : " + safe_tags_replace(header.metaproperties[key]) + "<br>";
                        }
                    }
                }
                tipsy += '"';
                */
                var cssclass = (same ? "row_null" : "row");
                var colspan = 0;
 
                if (!isHeaderLowestLvl && (typeof nextHeader == "undefined" || nextHeader.value === "null")) {
                    colspan = 1;
                    var group = header.properties.dimension;
                    var level = header.properties.level;
                    var groupWidth = (group in rowGroups ? rowGroups[group].length - rowGroups[group].indexOf(level) : 1);
                    for (var k = col + 1; colspan < groupWidth && k <= (lowestRowLvl+1) && data[row][k] !== "null"; k++) {
                        colspan = k - col;
                    }
                    col = col + colspan -1;
                }
				
				/*when the content is to long ,we will set new line to show it.*/
				// eg value: <div rel="3:0">新業務及保單行政部</div>
				if(cssclass == "row" && value.length>0){
					var startPos = value.indexOf('>'); //find  start position of the tag. eg: <div rel="3:0">
					var endPos = value.lastIndexOf('<'); //find  end position of the tag. eg: </div>
					var tmpValue = value.substr( startPos+1 ,endPos-startPos-1); // get the content value. eg: 新業務及保單行政部
					//将value值每隔40个字自动加上换行符
					//each 40 character add one <br> tag to get new line. 
					if(tmpValue.length>120){ 
						tmpValue = tmpValue.substr(0,40)+"<br/>"+tmpValue.substr(40,40)+"<br/>"+tmpValue.substr(80,40)+"<br/>"+tmpValue.substr(120,tmpValue.length-120);
					}else if(tmpValue.length>80){ 
						tmpValue = tmpValue.substr(0,40)+"<br/>"+tmpValue.substr(40,40)+"<br/>"+tmpValue.substr(80,tmpValue.length-80);
					}else if(tmpValue.length>40){
						tmpValue = tmpValue.substr(0,40)+"<br/>"+tmpValue.substr(40,tmpValue.length-40);
					}
					
					// compared with old value, this value only add <br> tag for show data in table more beautiful.
					value = value.substr(0,startPos+1) + tmpValue + value.substr(endPos,value.length-endPos);
				}
                rowContent += '<th class="' + cssclass + '" ' + (colspan > 0 ? ' colspan="' + colspan + '"' : "") + tipsy + '>' + value + '</th>';
            }
            else if (header.type === "ROW_HEADER_HEADER") {
                var hierName = function(data) {
                    var hier = data.properties.hierarchy;
                    var name = hier.replace(/[\[\]]/gi, '').split('.')[1]
                        ? hier.replace(/[\[\]]/gi, '').split('.')[1]
                        : hier.replace(/[\[\]]/gi, '').split('.')[0];
 
                    return name;
                };
                var arrPosRowData = [];
 
                if (_.contains(arrRowData, header.value)) {
                    for (var i = 0; i < arrRowData.length; i++) {
                        if (arrRowData[i] === header.value) {
                            arrPosRowData.push(i);
                        }
                    }
 
                    arrPosRowData.push(col);
                }
 
                rowContent += '<th class="row_header">' + (wrapContent ? '<div>' + header.value + '</div>' : header.value) + '</th>';
 
                arrRowData.push(header.value);
                objRowData.push({
                    name: header.value,
                    hierName: hierName(header) + '/' + header.value
                });
 
                isHeaderLowestLvl = true;
                processedRowHeader = true;
                lowestRowLvl = col;
                if (header.properties.hasOwnProperty("dimension")) {
                    var group = header.properties.dimension;
                    if (!(group in rowGroups)) {
                        rowGroups[group] = [];
                    }
                    rowGroups[group].push(header.properties.level);
                }
 
                if (arrPosRowData.length > 0) {
                    var aux = 0;
 
                    rowContent = '<tr>';
 
                    if (row === 0) {
                        rowContent = '<thead>' + rowContent;
                    }
 
                    for (var i = 0; i < objRowData.length; i++) {
                        if (arrPosRowData[aux] === i) {
                            newRowContent += '<th class="row_header">' + (wrapContent ? '<div>' + objRowData[i].hierName + '</div>' : objRowData[i].hierName) + '</th>';
                            aux += 1;
                        }
                        else {
                            newRowContent += '<th class="row_header">' + (wrapContent ? '<div>' + objRowData[i].name + '</div>' : objRowData[i].name) + '</th>';
                        }
                    }
 
                    rowContent += newRowContent;
                }
            } // If the cell is a normal data cell
            else if (header.type === "DATA_CELL") {
                batchStarted = true;
                var color = "";
                var val = _.isEmpty(header.value) ? Settings.EMPTY_VALUE_CHARACTER : header.value;
                var arrow = "";
 
                if (header.properties.hasOwnProperty('image')) {
                    var img_height = header.properties.hasOwnProperty('image_height') ? " height='" + header.properties.image_height + "'" : "";
                    var img_width = header.properties.hasOwnProperty('image_width') ? " width='" + header.properties.image_width + "'" : "";
                    val = "<img " + img_height + " " + img_width + " style='padding-left: 5px' src='" + header.properties.image + "' border='0'>";
                }
 
                // Just apply formatting to non-empty cells
                if (val !== '-' && val !== '' && header.properties.hasOwnProperty('style')) {
                    color = " style='background-color: " + header.properties.style + "' ";
                }
                if (header.properties.hasOwnProperty('link')) {
                    val = "<a target='__blank' href='" + header.properties.link + "'>" + val + "</a>";
                }
                if (header.properties.hasOwnProperty('arrow')) {
                    arrow = "<img height='10' width='10' style='padding-left: 5px' src='./images/arrow-" + header.properties.arrow + ".gif' border='0'>";
                }
 
                if (val !== '-' && val !== '') {
                    rowWithOnlyEmptyCells = false;
                }
                
                //设置saiku为0的数据正常显示0 ，不显示为空
                if (val == " " || val == '') {
                    val=0;
                }
                
                rowContent += '<td class="data" ' + color + '>'
                        + (wrapContent ? '<div class="datadiv '+ setStyleNegativeNumber(header.properties.raw) + '" alt="' + header.properties.raw + '" rel="' + header.properties.position + '">' : "")
                        + val + arrow
                        + (wrapContent ? '</div>' : '') + '</td>';
                if (totalsLists[ROWS])
                    rowContent += genTotalDataCells(colShifted + 1, rowShifted, scanSums[ROWS], scanIndexes[ROWS], totalsLists, wrapContent);
            }
        }
        rowContent += "</tr>";
 
        // Change it to let hideEmpty true by default
        if (options.hideEmpty && header.type === "DATA_CELL" && rowWithOnlyEmptyCells) {
		   /*when data_cell is null,set the headerFlag is false ，
		   to fix the problem data merge inccrrect.
		   */
		   headerFlag=false;
			rowContent = '';
        }
 
        var totals = "";
        if (totalsLists[COLUMNS] && rowShifted >= 0) {
            totals += genTotalHeaderRowCells(rowShifted + 1, scanSums, scanIndexes, totalsLists, wrapContent);
        }
        if (batchStarted && batchSize) {
                if (row <= batchSize) {
                    if (!isColHeader && !isColHeaderDone) {
                        tableContent += "</thead><tbody>";
                        isColHeaderDone = true;
                    }
                    tableContent += rowContent;
                    if (totals.length > 0) {
                        tableContent += totals;
                    }
 
                } else {
                    resultRows.push(rowContent);
                    if (totals.length > 0) {
                        resultRows.push(totals);
                    }
 
                }
        } else {
            if (!isColHeader && !isColHeaderDone) {
                tableContent += "</thead><tbody>";
                isColHeaderDone = true;
            }
            tableContent += rowContent;
            if (totals.length > 0) {
                tableContent += totals;
            }
        }
    }
    if (options) {
        options['batchResult'] = resultRows;
        options['hasBatchResult'] = resultRows.length > 0;
    }
    return "<table>" + tableContent + "</tbody></table>";
};
 
SaikuTableRenderer.prototype.renderSummary = function(data) {
    if (data && data.query) {
        var hasSomethingToRender = false;
        var measures = data.query.queryModel.details
                       ? data.query.queryModel.details.measures
                       : [];
        var summaryData = {};
 
        for (var i = 0; i < measures.length; i++) {
            var m = measures[i];
            if (m.aggregators) {
                for (var j = 0; j < m.aggregators.length; j++) {
                    var a = m.aggregators[j];
                    if (a.indexOf('_') > 0) {
                        var tokens = a.split('_');
                        var aggregator = tokens[0];
                        var axis = tokens[1];
 
                        if (aggregator !== 'nil' && aggregator !== 'not') {
                            hasSomethingToRender = true;
                            aggregator = aggregator.capitalizeFirstLetter();
                            if (!(axis in summaryData)) summaryData[axis] = [];
                            summaryData[axis].push(m.name + ": " + aggregator);
                        }
                    }
                }
            }
        }
        
        if (hasSomethingToRender) {
            var summary = "<div id='totals_summary'><br/>";
 
            $.each(summaryData, function(key, aggregators) {
                summary += "<h3>" + key.capitalizeFirstLetter();
                for (var i = 0; i < aggregators.length; i++) {
                    summary += "<br/> " + aggregators[i];
                }
                summary += "</h3>";
            });
 
            return summary + "</div>";
        }
    }
 
    return "";
};
 
String.prototype.capitalizeFirstLetter = function() {
    return this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
}

　　

ExcelWorksheetBuilder.java

package org.saiku.service.util.export.excel;
 
import org.apache.commons.lang.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFPalette;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.SpreadsheetVersion;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.olap4j.metadata.Measure;
import org.saiku.olap.dto.resultset.AbstractBaseCell;
import org.saiku.olap.dto.resultset.CellDataSet;
import org.saiku.olap.dto.resultset.DataCell;
import org.saiku.olap.dto.resultset.MemberCell;
import org.saiku.olap.query2.ThinHierarchy;
import org.saiku.olap.query2.ThinLevel;
import org.saiku.olap.query2.ThinMember;
import org.saiku.olap.util.SaikuProperties;
import org.saiku.service.olap.totals.TotalNode;
import org.saiku.service.olap.totals.aggregators.TotalAggregator;
import org.saiku.service.util.exception.SaikuServiceException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.List;
 
/**
 * Created with IntelliJ IDEA. User: sramazzina Date: 21/06/12 Time: 7.35 To
 * change this template use File | Settings | File Templates.
 */
 
public class ExcelWorksheetBuilder {
 
    private static final String BASIC_SHEET_FONT_FAMILY = "Arial";
    private static final short BASIC_SHEET_FONT_SIZE = 11;
    private static final String EMPTY_STRING = "";
    private static final String CSS_COLORS_CODE_PROPERTIES = "css-colors-codes.properties";
 
    private int maxRows = -1;
    private int maxColumns = -1;
 
    private AbstractBaseCell[][] rowsetHeader;
    private AbstractBaseCell[][] rowsetBody;
 
    private Map<Integer, TotalAggregator[][]> rowScanTotals;
    private Map<Integer, TotalAggregator[][]> colScanTotals;
 
    private CellDataSet table;
    private Workbook excelWorkbook;
    private Sheet workbookSheet;
    private String sheetName;
    private int topLeftCornerWidth;
    private int topLeftCornerHeight;
    private CellStyle basicCS;
    private CellStyle totalsCS;
    private CellStyle numberCS;
    private CellStyle number0CS; //use this cellstyle when cell value is 0
    private CellStyle lighterHeaderCellCS;
    private List<ThinHierarchy> queryFilters;
    private Map<String, Integer> colorCodesMap;
 
    private int nextAvailableColorCode = 41;
    private Properties cssColorCodesProperties;
 
    private HSSFPalette customColorsPalette;
    private ExcelBuilderOptions options;
 
    private static final Logger log = LoggerFactory.getLogger(ExcelWorksheetBuilder.class);
 
    public ExcelWorksheetBuilder(CellDataSet table, List<ThinHierarchy> filters, ExcelBuilderOptions options) {
        init(table, filters, options);
    }
 
    private void init(CellDataSet table, List<ThinHierarchy> filters, ExcelBuilderOptions options) {
        this.table = table;
        this.options = options;
        queryFilters = filters;
        maxRows = SpreadsheetVersion.EXCEL2007.getMaxRows();
        maxColumns = SpreadsheetVersion.EXCEL2007.getMaxColumns();
 
        if ("xls".equals(SaikuProperties.webExportExcelFormat)) {
            HSSFWorkbook wb = new HSSFWorkbook();
            customColorsPalette = wb.getCustomPalette();
            excelWorkbook = wb;
            maxRows = SpreadsheetVersion.EXCEL97.getMaxRows();
            maxColumns = SpreadsheetVersion.EXCEL97.getMaxColumns();
        } else if ("xlsx".equals(SaikuProperties.webExportExcelFormat)) {
            excelWorkbook = new XSSFWorkbook();
        } else {
            excelWorkbook = new XSSFWorkbook();
        }
 
        colorCodesMap = new HashMap<>();
        this.sheetName = options.sheetName;
        rowsetHeader = table.getCellSetHeaders();
        rowsetBody = table.getCellSetBody();
 
        topLeftCornerWidth = findTopLeftCornerWidth();
        topLeftCornerHeight = findTopLeftCornerHeight();
 
        initCellStyles();
 
        // Row totals and subtotals
        rowScanTotals = new HashMap<>();
        colScanTotals = new HashMap<>();
        scanRowAndColumnAggregations(table.getRowTotalsLists(), rowScanTotals, table.getColTotalsLists(), colScanTotals);
    }
 
    private void initCellStyles() {
 
        Font font = excelWorkbook.createFont();
        font.setFontHeightInPoints((short) BASIC_SHEET_FONT_SIZE);
        font.setFontName(BASIC_SHEET_FONT_FAMILY);
 
        basicCS = excelWorkbook.createCellStyle();
        basicCS.setFont(font);
        basicCS.setAlignment(HorizontalAlignment.LEFT);
        basicCS.setVerticalAlignment(VerticalAlignment.TOP);
        setCellBordersColor(basicCS);
 
        Font totalsFont = excelWorkbook.createFont();
        totalsFont.setFontHeightInPoints((short) BASIC_SHEET_FONT_SIZE);
        totalsFont.setBold(true);
        totalsFont.setFontName(BASIC_SHEET_FONT_FAMILY);
 
        totalsCS = excelWorkbook.createCellStyle();
        totalsCS.setFont(totalsFont);
        totalsCS.setAlignment(HorizontalAlignment.RIGHT);
        setCellBordersColor(totalsCS);
 
        // Setting the default styling for number cells
        numberCS = excelWorkbook.createCellStyle();
        numberCS.setFont(font);
        numberCS.setAlignment(HorizontalAlignment.RIGHT);
 
        /*
         * justasg: Let's set default format, used if measure has no format at
         * all. More info:
         * http://poi.apache.org/apidocs/org/apache/poi/ss/usermodel/
         * BuiltinFormats.html#getBuiltinFormat(int) If we don't have default
         * format, it will output values up to maximum detail, i.e.
         * 121212.3456789 and we like them as 121,212.346
         */
        DataFormat fmt = excelWorkbook.createDataFormat();
        short dataFormat = fmt.getFormat(SaikuProperties.webExportExcelDefaultNumberFormat);
        numberCS.setDataFormat(dataFormat);
        setCellBordersColor(numberCS);
        
        // Setting the default format for cell value is 0
        number0CS = excelWorkbook.createCellStyle();
        number0CS.setFont(font);
        number0CS.setAlignment(HorizontalAlignment.RIGHT);
        setCellBordersColor(number0CS);
        
        Font headerFont = excelWorkbook.createFont();
        headerFont.setFontHeightInPoints((short) BASIC_SHEET_FONT_SIZE);
        headerFont.setFontName(BASIC_SHEET_FONT_FAMILY);
        headerFont.setBold(true);
 
        lighterHeaderCellCS = excelWorkbook.createCellStyle();
        lighterHeaderCellCS.setFont(headerFont);
        lighterHeaderCellCS.setAlignment(HorizontalAlignment.CENTER);
        lighterHeaderCellCS.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
        lighterHeaderCellCS.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        setCellBordersColor(lighterHeaderCellCS);
 
        CellStyle darkerHeaderCellCS = excelWorkbook.createCellStyle();
        darkerHeaderCellCS.setFont(headerFont);
        darkerHeaderCellCS.setAlignment(HorizontalAlignment.CENTER);
        darkerHeaderCellCS.setFillForegroundColor(IndexedColors.GREY_40_PERCENT.getIndex());
        darkerHeaderCellCS.setFillPattern(FillPatternType.SOLID_FOREGROUND);
        setCellBordersColor(darkerHeaderCellCS);
 
    }
 
    //更改指标分割线条颜色为 黑色20190528
    private void setCellBordersColor(CellStyle style) {
 
    	style.setBorderBottom(BorderStyle.THIN);
        style.setBottomBorderColor(IndexedColors.BLACK.getIndex());
        style.setBorderTop(BorderStyle.THIN);
        style.setTopBorderColor(IndexedColors.BLACK.getIndex());
        style.setBorderLeft(BorderStyle.THIN);
        style.setLeftBorderColor(IndexedColors.BLACK.getIndex());
        style.setBorderRight(BorderStyle.THIN);
        style.setRightBorderColor(IndexedColors.BLACK.getIndex());
        /*style.setBorderBottom(BorderStyle.THIN);
        style.setBottomBorderColor(IndexedColors.GREY_80_PERCENT.getIndex());
        style.setBorderTop(BorderStyle.THIN);
        style.setTopBorderColor(IndexedColors.GREY_80_PERCENT.getIndex());
        style.setBorderLeft(BorderStyle.THIN);
        style.setLeftBorderColor(IndexedColors.GREY_80_PERCENT.getIndex());
        style.setBorderRight(BorderStyle.THIN);
        style.setRightBorderColor(IndexedColors.GREY_80_PERCENT.getIndex());*/
    }
 
    public byte[] build() throws SaikuServiceException {
 
        Long start = (new Date()).getTime();
        int startRow = initExcelSheet();
        Long init = (new Date()).getTime();
        int lastHeaderRow = buildExcelTableHeader(startRow);
        Long header = (new Date()).getTime();
        addExcelTableRows(lastHeaderRow);
        addTotalsSummary(lastHeaderRow);
        Long content = (new Date()).getTime();
        finalizeExcelSheet(startRow);
        Long finalizing = (new Date()).getTime();
 
        log.debug("Init: " + (init - start) + "ms header: " + (header - init) + "ms content: " + (content - header)
                + "ms finalizing: " + (finalizing - content) + "ms ");
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
 
        try {
            excelWorkbook.write(bout);
        } catch (IOException e) {
            throw new SaikuServiceException("Error creating excel export for query", e);
        }
        return bout.toByteArray();
    }
 
    private void checkRowLimit(int rowIndex) {
        if ((rowIndex + 1) > maxRows) {
            log.warn("Excel sheet is truncated, only outputting " + maxRows + " rows of " + (rowIndex + 1));
        }
    }
 
    private void addTotalsSummary(int startingRow) {
        int rowIndex = startingRow + rowsetBody.length + 2; // Lines offset after data, in order to add summary
        checkRowLimit(rowIndex);
 
        // Columns summary
        if (colScanTotals.keySet().size() > 0) {
            Row row = workbookSheet.createRow(rowIndex);
            Cell cell = row.createCell(0);
            cell.setCellStyle(lighterHeaderCellCS);
            cell.setCellValue("Columns");
 
            for (Integer colKey : colScanTotals.keySet()) {
                TotalAggregator[][] colAggregator = colScanTotals.get(colKey);
 
                if (colAggregator == null) continue;
 
                for (int x = 0; x < colAggregator.length; x++) {
                    rowIndex++;
                    checkRowLimit(rowIndex);
 
                    Measure measure = this.table.getSelectedMeasures()[x];
 
                    TotalAggregator agg = colAggregator[x][0];
                    row = workbookSheet.createRow(rowIndex);
 
                    // Measure name
                    cell = row.createCell(0);
                    cell.setCellStyle(lighterHeaderCellCS);
                    cell.setCellValue(measure.getCaption() +  ":");
 
                    // Measure aggregator
                    cell = row.createCell(1);
                    cell.setCellStyle(basicCS);
                    cell.setCellValue(agg.getClass().getSimpleName().substring(0, 3));
                }
            }
        }
 
        // Rows summary
        if (rowScanTotals.keySet().size() > 0) {
            rowIndex++;
            checkRowLimit(rowIndex);
 
            Row row = workbookSheet.createRow(rowIndex);
            Cell cell = row.createCell(0);
            cell.setCellStyle(lighterHeaderCellCS);
            cell.setCellValue("Rows");
 
            for (Integer rowKey : rowScanTotals.keySet()) {
                TotalAggregator[][] rowAggregator = rowScanTotals.get(rowKey);
 
                if (rowAggregator == null) continue;
 
                for (int x = 0; x < rowAggregator.length; x++) {
                    for (int y = 0; y < this.table.getSelectedMeasures().length; y++) {
                        rowIndex++;
                        checkRowLimit(rowIndex);
 
                        Measure measure = this.table.getSelectedMeasures()[y];
                        TotalAggregator agg = rowAggregator[x][y];
 
                        row = workbookSheet.createRow(rowIndex);
 
                        // Measure name
                        cell = row.createCell(0);
                        cell.setCellStyle(lighterHeaderCellCS);
                        cell.setCellValue(measure.getCaption() +  ":");
 
                        // Measure aggregator
                        cell = row.createCell(1);
                        cell.setCellStyle(basicCS);
                        cell.setCellValue(agg.getClass().getSimpleName().substring(0, 3));
                    }
                }
            }
        }
 
    }
 
    private void finalizeExcelSheet(int startRow) {
 
        boolean autoSize = (rowsetBody != null && rowsetBody.length > 0 && rowsetBody.length < 10000
                && rowsetHeader != null && rowsetHeader.length > 0 && rowsetHeader[0].length < 200);
 
        if (autoSize) {
            log.warn("Skipping auto-sizing columns, more than 10000 rows and/or 200 columns");
        }
 
        Long start = (new Date()).getTime();
        if (autoSize) {
            //Detect max column size
            int maxColumnsSize = rowsetBody[0].length;
            if (!colScanTotals.isEmpty()) {
                maxColumnsSize = Collections.max(colScanTotals.keySet()) + 1;
            }
            // Autosize columns
            for (int i = 0; i < maxColumns && i < maxColumnsSize; i++) {
                workbookSheet.autoSizeColumn(i);
            }
        }
        Long end = (new Date()).getTime();
        log.debug("Autosizing: " + (end - start) + "ms");
        // Freeze the header columns
        int headerWidth = rowsetHeader.length;
        workbookSheet.createFreezePane(0, startRow + headerWidth, 0, startRow + headerWidth);
    }
 
    private int initExcelSheet() {
        // Main Workbook Sheet
        if (StringUtils.isNotBlank(options.sheetName)) {
            workbookSheet = excelWorkbook.createSheet(this.sheetName);
        } else {
            workbookSheet = excelWorkbook.createSheet();
        }
        initSummarySheet();
        return 0;
    }
 
    private void initSummarySheet() {
 
        // Main Workbook Sheet
        Sheet summarySheet = excelWorkbook.createSheet("Summary page");
 
        int row = 1;
 
        Row sheetRow = summarySheet.createRow((int) row);
        Cell cell = sheetRow.createCell(0);
        String todayDate = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date());
        cell.setCellValue("Export date and time: " + todayDate);
        summarySheet.addMergedRegion(new CellRangeAddress(1, 1, 0, 2));
        row = row + 2;
 
        sheetRow = summarySheet.createRow((int) row);
        cell = sheetRow.createCell(0);
        cell.setCellValue("Dimension");
        cell = sheetRow.createCell(1);
        cell.setCellValue("Level");
        cell = sheetRow.createCell(2);
        cell.setCellValue("Filter Applied");
        row++;
 
        if (queryFilters != null) {
            for (ThinHierarchy item : queryFilters) {
                for (ThinLevel s : item.getLevels().values()) {
                    for (ThinMember i : s.getSelection().getMembers()) {
                        sheetRow = summarySheet.createRow((short) row);
                        cell = sheetRow.createCell(0);
                        cell.setCellValue(item.getCaption());
                        cell = sheetRow.createCell(1);
                        cell.setCellValue(s.getCaption());
                        cell = sheetRow.createCell(2);
                        cell.setCellValue(i.getCaption());
                        row++;
                    }
                }
            }
        }
 
        row += 2;
 
        int rowLength = (rowsetBody != null) ? rowsetBody.length : 0;
        int columnCount = (rowsetHeader != null && rowsetHeader.length > 0) ? rowsetHeader[0].length : 0;
        int headerLength = (rowsetHeader != null) ? rowsetHeader.length : 0;
 
        if (columnCount > maxColumns) {
            sheetRow = summarySheet.createRow((int) row);
            cell = sheetRow.createCell(0);
            cell.setCellValue("Excel sheet is truncated, only contains " + maxColumns + " columns of " + (columnCount));
            summarySheet.addMergedRegion(new CellRangeAddress(row, row, 0, 10));
            row++;
        }
 
        if ((headerLength + rowLength) > maxRows) {
            sheetRow = summarySheet.createRow((int) row);
            cell = sheetRow.createCell(0);
            cell.setCellValue(
                    "Excel sheet is truncated, only contains " + maxRows + " rows of " + (headerLength + rowLength));
            summarySheet.addMergedRegion(new CellRangeAddress(row, row, 0, 10));
            row++;
        }
 
        row++;
 
        sheetRow = summarySheet.createRow((int) row);
        cell = sheetRow.createCell(0);
        cell.setCellValue(SaikuProperties.webExportExcelPoweredBy);
        summarySheet.addMergedRegion(new CellRangeAddress(row, row, 0, 10));
 
        // Autosize columns for summary sheet
        for (int i = 0; i < 5; i++) {
            summarySheet.autoSizeColumn(i);
        }
    }
 
    private void addExcelTableRows(int startingRow) {
 
        Row sheetRow = null;
        Cell cell = null;
        Map<Integer, String> tmpCellUniqueValueByColumn = new HashMap<>();
        Map<Integer, Map<Integer, Boolean>> mergeRowsByColumn = new HashMap<>();
 
        if ((startingRow + rowsetBody.length) > maxRows) {
            log.warn("Excel sheet is truncated, only outputting " + maxRows + " rows of "
                    + (rowsetBody.length + startingRow));
        }
        if (rowsetBody.length > 0 && rowsetBody[0].length > maxColumns) {
            log.warn("Excel sheet is truncated, only outputting " + maxColumns + " columns of "
                    + (rowsetBody[0].length));
        }
 
        int rowCount = startingRow;
 
        for (int x = 0; (x + startingRow) < maxRows && x < rowsetBody.length; x++) {
 
            int excelRowIndex = x + startingRow;
            sheetRow = workbookSheet.createRow(excelRowIndex);
 
            int column = 0;
            for (int y = 0; y < maxColumns && y < rowsetBody[x].length; y++) {
                cell = sheetRow.createCell(column);
 
                AbstractBaseCell baseCell = rowsetBody[x][y];
 
                //Detect merge cells
                findMergeCells(baseCell, excelRowIndex, y, mergeRowsByColumn, tmpCellUniqueValueByColumn);
 
                String value = baseCell.getFormattedValue();
 
                if (value == null && options.repeatValues) {
                    // If the row cells has a null values it means the value is
                    // repeated in the data internally
                    // but not in the interface. To properly format the Excel
                    // export file we need that value so we
                    // get it from the same position in the prev row
                    value = workbookSheet.getRow(sheetRow.getRowNum() - 1).getCell(column).getStringCellValue();
                }
 
                cell.setCellStyle(basicCS);
                cell.setCellValue(value);
                // Use rawNumber only is there is a formatString
                if (rowsetBody[x][y] instanceof DataCell) {
                    DataCell dataCell = (DataCell) rowsetBody[x][y];
                    String formatString = dataCell.getFormatString();
                    if ((dataCell.getRawNumber() != null) && (formatString != null) && !formatString.trim().isEmpty()) {
                        Number numberValue = dataCell.getRawNumber();
                        cell.setCellValue(numberValue.doubleValue());
                        if(numberValue.doubleValue() != 0.0 || !formatString.trim().equals("#,###")){//不等于0.0时 就设置样式
                        	applyCellFormatting(cell, dataCell);
                        }else{
                        	cell.setCellStyle(number0CS);
                        }
                    }
                }
 
                //Set column sub totalstotals
                column = setColTotalAggregationCell(colScanTotals, sheetRow, x, column, true, false);
 
                //Set column grand totals
                if (y == rowsetBody[x].length - 1) {
                    setColTotalAggregationCell(colScanTotals, sheetRow, x, column - 1, true, x == 0);
                }
            }
 
            // Set row sub totals
            startingRow = setRowTotalAggregationCell(rowScanTotals, startingRow, x, false);
            rowCount = startingRow + x;
        }
 
        //Set row grand totals
        setRowTotalAggregationCell(rowScanTotals, rowCount, 0, true);
 
        //Add merge cells
        addMergedRegions(mergeRowsByColumn);
    }
 
    private void scanRowAndColumnAggregations(List<TotalNode>[] rowTotalsLists, Map<Integer, TotalAggregator[][]> rowScanTotals, List<TotalNode>[] colTotalsLists, Map<Integer, TotalAggregator[][]> colScanTotals) {
        if (rowTotalsLists != null) {
            for (List<TotalNode> totalNodes : rowTotalsLists) {
                //Scan row totals
                scanAggregations(true, totalNodes, rowScanTotals);
            }
        }
        if (colTotalsLists != null) {
            for (List<TotalNode> totalNodes : colTotalsLists) {
                //Scan Columns grand totals
                scanAggregations(false, totalNodes, colScanTotals);
            }
        }
    }
 
    private void scanAggregations(boolean row, List<TotalNode> totalNodes, Map<Integer, TotalAggregator[][]> scanSums) {
        if (totalNodes != null && (!totalNodes.isEmpty())) {
            int index;
            if (row) {
                index = rowsetHeader.length - 2;
            } else {
                index = detectColumnStartIndex();
            }
            for (TotalNode n : totalNodes) {
                TotalAggregator[][] tg = n.getTotalGroups();
                if (tg.length > 0) {
                    if (n.getSpan() > n.getWidth()) {
                        index += n.getSpan();
                    } else {
                        index += n.getWidth();
                    }
                    index++;
                    scanSums.put(index, tg);
                }
            }
        }
    }
 
    private int setRowTotalAggregationCell(Map<Integer, TotalAggregator[][]> scanTotals, int startIndex, int subIndex, boolean grandTotal) {
        if (!scanTotals.isEmpty()) {
            int row = subIndex + startIndex;
            TotalAggregator[][] aggregatorsTable = scanTotals.get(row);
            if (aggregatorsTable != null) {
                //Create totals row
                Row sheetRow = workbookSheet.createRow(row + 1);
 
                //Detect column start index
                int startColumnIndex = detectColumnStartIndex();
 
                if (grandTotal) {
                    setGrandTotalLabel(sheetRow, startColumnIndex, false);
                }
 
                for (TotalAggregator[] aggregators : aggregatorsTable) {
 
                    int column = startColumnIndex;
 
                    for (TotalAggregator aggregator : aggregators) {
 
                        //Calculate column sub total index
                        column = setColTotalAggregationCell(colScanTotals, null, -1, column, false, false);
 
                        //Create row totals cell
                        Cell cell = sheetRow.createCell(column);
                        String value = aggregator.getFormattedValue();
                        cell.setCellValue(value);
                        cell.setCellStyle(totalsCS);
                    }
                }
                startIndex++;
            }
        }
        return startIndex;
    }
 
    /**
     * @return columns data start index
     */
    private int detectColumnStartIndex() {
        int index = 0;
        if (rowsetBody.length > 0) {
            for (AbstractBaseCell cell : rowsetBody[0]) {
                if (cell instanceof MemberCell) {
                    index++;
                }
            }
            index--;
        }
        return index;
    }
 
    private int setColTotalAggregationCell(Map<Integer, TotalAggregator[][]> scanTotals, Row sheetRow, int x, int column, boolean setValue, boolean grandTotal) {
        column++;
 
        if (!scanTotals.isEmpty()) {
            TotalAggregator[][] aggregatorsTable = scanTotals.get(column);
 
            if (aggregatorsTable != null) {
                if (setValue) {
                    if (grandTotal) {
                        setGrandTotalLabel(sheetRow.getRowNum() - 1, column, true);
                    }
 
                    for (TotalAggregator[] aggregators : aggregatorsTable) {
                        Cell cell = sheetRow.createCell(column);
                        String value = aggregators[x].getFormattedValue();
                        cell.setCellValue(value);
                        cell.setCellStyle(totalsCS);
                        column++;
                    }
                }
            }
        }
 
        return column;
    }
 
    private void setGrandTotalLabel(int x, int y, boolean header) {
        Row sheetRow = workbookSheet.getRow(x);
        if (sheetRow != null) {
            setGrandTotalLabel(sheetRow, y, header);
        }
    }
 
    private void setGrandTotalLabel(Row sheetRow, int y, boolean header) {
        Cell cell = sheetRow.createCell(y);
        //TODO i18n
        String value = "Grand Total";
        if (header) {
            fillHeaderCell(sheetRow, value, y);
        } else {
            cell.setCellValue(value);
            cell.setCellStyle(basicCS);
        }
    }
 
	/**
	 * Apply exact number format to excel Cell from its DataCell. Caller checks
	 * the DataCell rawNumber and formatString are correct.
	 * 
	 * @param cell The excel cell to apply formatting
	 * @param dataCell The source
	 */
    private void applyCellFormatting(Cell cell, DataCell dataCell) {
        /*
        * Previously, the CellStyles were being kept on a hash map for reuse,
        * but the key used was just the formatString (not considering the
        * colours), so, if many cells shared the same formatString but using
        * different colours, all those cells would have the last cell colour.
        */
        String formatString = dataCell.getFormatString();
        CellStyle numberCSClone = excelWorkbook.createCellStyle();
 
        numberCSClone.cloneStyleFrom(numberCS);
 
        try {
            formatString = FormatUtil.getFormatString(formatString);
            DataFormat fmt = excelWorkbook.createDataFormat();
            short dataFormat = fmt.getFormat(formatString);
            numberCSClone.setDataFormat(dataFormat);
        } catch (Exception ex) {
 
        }
 
        // Check for cell background
        Map<String, String> properties = dataCell.getProperties();
 
        // Just style the cell if it contains a value
        if (dataCell.getRawNumber() != null && properties.containsKey("style")) {
            String colorCode = properties.get("style");
            short colorCodeIndex = getColorFromCustomPalette(colorCode);
 
            if (colorCodeIndex != -1) {
                numberCSClone.setFillForegroundColor(colorCodeIndex);
                numberCSClone.setFillPattern(FillPatternType.SOLID_FOREGROUND);
            } else if (customColorsPalette == null) {
                try {
 
                    if (cssColorCodesProperties != null && cssColorCodesProperties.containsKey(colorCode)) {
                        colorCode = cssColorCodesProperties.getProperty(colorCode);
                    }
 
                    int redCode   = Integer.parseInt(colorCode.substring(1, 3), 16);
                    int greenCode = Integer.parseInt(colorCode.substring(3, 5), 16);
                    int blueCode  = Integer.parseInt(colorCode.substring(5, 7), 16);
 
                    numberCSClone.setFillPattern(FillPatternType.SOLID_FOREGROUND);
 
                    ((XSSFCellStyle) numberCSClone).setFillForegroundColor(
                            new XSSFColor(new java.awt.Color(redCode, greenCode, blueCode)));
                    ((XSSFCellStyle) numberCSClone).setFillBackgroundColor(
                            new XSSFColor(new java.awt.Color(redCode, greenCode, blueCode)));
                } catch (Exception e) {
                    // we tried to set the color, no luck, lets continue
                    // without
                }
 
            }
        } else {
            numberCSClone.setFillForegroundColor(numberCS.getFillForegroundColor());
            numberCSClone.setFillBackgroundColor(numberCS.getFillBackgroundColor());
        }
 
        cell.setCellStyle(numberCSClone);
    }
 
    private short getColorFromCustomPalette(String style) {
 
        short returnedColorIndex = -1;
        InputStream is = null;
 
        if (colorCodesMap.containsKey(style)) {
            returnedColorIndex = colorCodesMap.get(style).shortValue();
        } else {
            try {
 
                if (cssColorCodesProperties == null) {
                    is = getClass().getResourceAsStream(CSS_COLORS_CODE_PROPERTIES);
                    if (is != null) {
                        cssColorCodesProperties = new Properties();
                        cssColorCodesProperties.load(is);
                    }
                }
 
                String colorCode = cssColorCodesProperties.getProperty(style);
                if (colorCode != null) {
                    try {
                        int redCode = Integer.parseInt(colorCode.substring(1, 3), 16);
                        int greenCode = Integer.parseInt(colorCode.substring(3, 5), 16);
                        int blueCode = Integer.parseInt(colorCode.substring(5, 7), 16);
                        if (customColorsPalette != null) {
                            customColorsPalette.setColorAtIndex((byte) nextAvailableColorCode, (byte) redCode,
                                    (byte) greenCode, (byte) blueCode);
                            returnedColorIndex = customColorsPalette.getColor(nextAvailableColorCode).getIndex();
                            colorCodesMap.put(style, (int) returnedColorIndex);
                        } else {
                            return -1;
                        }
                        nextAvailableColorCode++;
                    } catch (Exception e) {
                        // we tried to set the color, no luck, lets continue
                        // without
                        return -1;
                    }
                }
            } catch (IOException e) {
                log.error("IO Exception", e);
            } finally {
                try {
                    if (is != null)
                        is.close();
                } catch (IOException e) {
                    log.error("IO Exception", e);
                }
            }
 
        }
 
        return returnedColorIndex; // To change body of created methods use File
        // | Settings | File Templates.
    }
 
    private int buildExcelTableHeader(int startRow) {
 
        Row sheetRow = null;
        int x = 0;
        int y = 0;
        int startSameFromPos = 0;
        int mergedCellsWidth = 0;
        boolean isLastHeaderRow = false;
        boolean isLastColumn = false;
        String nextHeader = EMPTY_STRING;
        String currentHeader = EMPTY_STRING;
        ArrayList<ExcelMergedRegionItemConfig> mergedItemsConfig = new ArrayList<>();
 
        for (x = 0; x < rowsetHeader.length; x++) {
 
            sheetRow = workbookSheet.createRow((int) x + startRow);
 
            nextHeader = EMPTY_STRING;
            isLastColumn = false;
            startSameFromPos = 0;
            mergedCellsWidth = 0;
 
            if (x + 1 == rowsetHeader.length) {
                isLastHeaderRow = true;
            }
 
            int column = 0;
            for (y = 0; y < maxColumns && y < rowsetHeader[x].length; y++) {
 
                currentHeader = rowsetHeader[x][y].getFormattedValue();
                if (currentHeader != null) {
                    if (rowsetHeader[x].length == y + 1) {
                        isLastColumn = true;
                    } else {
                        nextHeader = rowsetHeader[x][y + 1].getFormattedValue();
                    }
 
                    manageColumnHeaderDisplay(sheetRow, x, column, currentHeader);
 
                    if (!isLastHeaderRow) {
                        if (nextHeader != null && !nextHeader.equals(currentHeader) || isLastColumn) {
                            manageCellsMerge(column, x + startRow, mergedCellsWidth + 1, startSameFromPos,
                                    mergedItemsConfig);
                            startSameFromPos = column + 1;
                            mergedCellsWidth = 0;
                        } else if (nextHeader != null && nextHeader.equals(currentHeader)) {
                            mergedCellsWidth++;
                        }
                    }
                } else {
                    startSameFromPos++;
                }
 
                //Set sub total column space
                int nextColumn = setColTotalAggregationCell(colScanTotals, sheetRow, x, column, false, false);
                if (column != nextColumn - 1) {
                    startSameFromPos++;
                }
                column = nextColumn;
            }
            // Manage the merge condition on exit from columns scan
            if (!isLastHeaderRow)
                manageCellsMerge(y - 1, x, mergedCellsWidth + 1, startSameFromPos, mergedItemsConfig);
        }
 
        if (topLeftCornerHeight > 0 && topLeftCornerWidth > 0) {
            workbookSheet.addMergedRegion(
                    new CellRangeAddress(startRow, startRow + topLeftCornerHeight - 1, 0, topLeftCornerWidth - 1));
        }
 
        if (mergedItemsConfig.size() > 0) {
            for (ExcelMergedRegionItemConfig item : mergedItemsConfig) {
                int lastCol = item.getStartX() + item.getWidth() - 1;
                lastCol = lastCol >= maxColumns ? maxColumns - 1 : lastCol;
                workbookSheet.addMergedRegion(new CellRangeAddress(item.getStartY(),
                        item.getStartY() + item.getHeight(), item.getStartX(), lastCol));
            }
        }
 
        return x + startRow;
    }
 
    private void manageColumnHeaderDisplay(Row sheetRow, int x, int y, String currentHeader) {
        if (topLeftCornerHeight > 0 && x >= topLeftCornerHeight) {
            fillHeaderCell(sheetRow, currentHeader, y);
        } else if ((topLeftCornerHeight > 0 && x < topLeftCornerHeight)
                && (topLeftCornerWidth > 0 && y >= topLeftCornerWidth)) {
            fillHeaderCell(sheetRow, currentHeader, y);
        } else if (topLeftCornerHeight == 0 && topLeftCornerWidth == 0)
            fillHeaderCell(sheetRow, currentHeader, y);
    }
 
    private void manageCellsMerge(int rowPos, int colPos, int width, int startSameFromPos,
                                  ArrayList<ExcelMergedRegionItemConfig> mergedItemsConfig) {
 
        ExcelMergedRegionItemConfig foundItem = null;
        boolean itemGetFromList = false;
 
        if (width == 1)
            return;
 
        for (ExcelMergedRegionItemConfig item : mergedItemsConfig) {
            if (item.getStartY() == colPos && item.getStartX() == rowPos) {
                foundItem = item;
                itemGetFromList = true;
            }
        }
 
        if (foundItem == null)
            foundItem = new ExcelMergedRegionItemConfig();
 
        foundItem.setHeight(0);
        foundItem.setWidth(width);
        foundItem.setStartX(startSameFromPos);
        foundItem.setStartY(colPos);
        if (mergedItemsConfig.isEmpty() || !itemGetFromList)
            mergedItemsConfig.add(foundItem);
    }
 
    private void fillHeaderCell(Row sheetRow, String formattedValue, int y) {
        Cell cell = sheetRow.createCell(y);
        cell.setCellValue(formattedValue);
        cell.setCellStyle(lighterHeaderCellCS);
    }
 
    /**
     * Find the width in cells of the top left corner of the table
     *
     * @return
     */
    private int findTopLeftCornerWidth() {
 
        int width = 0;
        int x = 0;
        boolean exit = (rowsetHeader.length < 1 || rowsetHeader[0][0].getRawValue() != null);
        String cellValue = null;
 
        for (x = 0; (!exit && rowsetHeader[0].length > x); x++) {
 
            cellValue = rowsetHeader[0][x].getRawValue();
            if (cellValue == null) {
                width = x + 1;
            } else {
                exit = true;
            }
        }
 
        return width;
    }
 
    /**
     * Find the height in cells of the top left corner of the table
     *
     * @return
     */
    private int findTopLeftCornerHeight() {
        return rowsetHeader.length > 0 ? rowsetHeader.length - 1 : 0;
    }
 
    /**
     * @param mergeRowsByColumn merged indexes
     */
    private void addMergedRegions(Map<Integer, Map<Integer, Boolean>> mergeRowsByColumn) {
        if (mergeRowsByColumn != null) {
            for (Map.Entry<Integer, Map<Integer, Boolean>> e : mergeRowsByColumn.entrySet()) {
 
                int col = e.getKey();
 
                Map<Integer, Boolean> rows = e.getValue();
 
                if (rows != null) {
 
                    int mergeCount = 1;
                    for (Map.Entry<Integer, Boolean> rowEntry : rows.entrySet()) {
 
                        int row = rowEntry.getKey();
 
                        boolean current = rowEntry.getValue();
 
                        Boolean next = rows.get(rowEntry.getKey() + 1);
 
                        if (current) {
                            if (next == null || !next) {
                                workbookSheet.addMergedRegion(new CellRangeAddress(row - mergeCount, row, col, col));
                            }
                            mergeCount++;
                        } else {
                            mergeCount = 1;
                        }
                    }
                }
            }
        }
    }
 
    /**
     * @param baseCell                   current cell
     * @param excelRowIndex              row index
     * @param y                          column
     * @param mergeRowsByColumn          merge indexes store
     * @param tmpCellUniqueValueByColumn tmp map to compare previews value(max possible value = columns size)
     */
    private void findMergeCells(AbstractBaseCell baseCell,
                                int excelRowIndex,
                                int y,
                                Map<Integer, Map<Integer, Boolean>> mergeRowsByColumn,
                                Map<Integer, String> tmpCellUniqueValueByColumn) {
        if (baseCell instanceof MemberCell) {
 
            MemberCell memberCell = (MemberCell) baseCell;
 
            Map<Integer, Boolean> rowMerge = mergeRowsByColumn.get(y);
            if (rowMerge == null) {
                rowMerge = new TreeMap<>();
                mergeRowsByColumn.put(y, rowMerge);
            }
 
            //Compare preview and current cells
            String previousValue = tmpCellUniqueValueByColumn.get(y);
 
            Map<Integer, Boolean> previousColumn = mergeRowsByColumn.get(y - 1);
 
            boolean merge = previousValue != null && previousValue.equals(memberCell.getUniqueName());
 
            if (previousColumn != null) {
                Boolean previewColumnCellmergeValue = previousColumn.get(excelRowIndex);
                if ((previewColumnCellmergeValue != null) && (!previewColumnCellmergeValue) && merge) {
                    merge = false;
                }
            }
            rowMerge.put(excelRowIndex, merge);
 
            tmpCellUniqueValueByColumn.put(y, memberCell.getUniqueName());
        }
    }
}

　　

FlattenedCellSetFormatter.java

/*  
 *   Copyright 2012 OSBI Ltd
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
package org.saiku.olap.util.formatter;
 
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.AbstractList;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
 
import org.olap4j.Cell;
import org.olap4j.CellSet;
import org.olap4j.CellSetAxis;
import org.olap4j.Position;
import org.olap4j.impl.CoordinateIterator;
import org.olap4j.impl.Olap4jUtil;
import org.olap4j.metadata.Level;
import org.olap4j.metadata.Member;
import org.olap4j.metadata.Property;
import org.saiku.olap.dto.resultset.DataCell;
import org.saiku.olap.dto.resultset.Matrix;
import org.saiku.olap.dto.resultset.MemberCell;
import org.saiku.olap.util.SaikuProperties;
 
 
public class FlattenedCellSetFormatter implements ICellSetFormatter {
 
  /**
   * Description of an axis.
   */
  private static class AxisInfo {
    final List<AxisOrdinalInfo> ordinalInfos;
 
    /**
     * Creates an AxisInfo.
     *
     * @param ordinalCount Number of hierarchies on this axis
     */
    AxisInfo(final int ordinalCount) {
      ordinalInfos = new ArrayList<>(ordinalCount);
 
      // For each index from 0 to the number of hierarchies  ...
      for (int i = 0; i < ordinalCount; i++) {
        // Associate an AxisOrdinalInfo instance
        ordinalInfos.add(new AxisOrdinalInfo());
      }
    }
 
    /**
     * Returns the number of matrix columns required by this axis. The sum of
     * the width of the hierarchies on this axis.
     *
     * @return Width of axis
     */
    public int getWidth() {
      int width = 0;
      for (final AxisOrdinalInfo info : ordinalInfos) {
        width += info.getWidth();
      }
      return width;
    }
  }
 
  /**
   * Description of a particular hierarchy mapped to an axis.
   */
  private static class AxisOrdinalInfo {
    private final List<Integer> depths = new ArrayList<>();
    private final Map<Integer,Level> depthLevel = new HashMap<>();
 
    public int getWidth() {
      return depths.size();
    }
 
    public List<Integer> getDepths() {
      return depths;
    }
 
    public Level getLevel(Integer depth) {
      return depthLevel.get(depth);
    }
 
    public void addLevel(Integer depth, Level level) {
      depthLevel.put(depth, level);
    }
  }
 
  /**
   * Returns an iterator over cells in a result.
   */
  private static Iterable<Cell> cellIter(final int[] pageCoords, final CellSet cellSet) {
    return new Iterable<Cell>() {
      public Iterator<Cell> iterator() {
        final int[] axisDimensions = new int[cellSet.getAxes().size() - pageCoords.length];
        assert pageCoords.length <= axisDimensions.length;
        for (int i = 0; i < axisDimensions.length; i++) {
          final CellSetAxis axis = cellSet.getAxes().get(i);
          axisDimensions[i] = axis.getPositions().size();
        }
        final CoordinateIterator coordIter = new CoordinateIterator(axisDimensions, true);
        return new Iterator<Cell>() {
          public boolean hasNext() {
            return coordIter.hasNext();
          }
 
          public Cell next() {
            final int[] ints = coordIter.next();
            final AbstractList<Integer> intList = new AbstractList<Integer>() {
              @Override
              public Integer get(final int index) {
                return index < ints.length ? ints[index] : pageCoords[index - ints.length];
              }
 
              @Override
              public int size() {
                return pageCoords.length + ints.length;
              }
            };
            return cellSet.getCell(intList);
          }
 
          public void remove() {
            throw new UnsupportedOperationException();
          }
        };
      }
    };
  }
 
  private Matrix matrix;
 
  private final List<Integer> ignorex = new ArrayList<>();
  private final List<Integer> ignorey = new ArrayList<>();
 
  /**
   * This is the main method of a cellset formatter, it receives a cellset as
   * input and converts it on a matrix, a bidimensional representation of query
   * values, arranged in a xy cartesian coordinate system.
   * @param cellSet
   * @return
   */
  public Matrix format(final CellSet cellSet) {
    // Compute how many rows are required to display the columns axis.
    final CellSetAxis columnsAxis;
 
    // If the axes are not empty, the first one is the column axis
    if (cellSet.getAxes().size() > 0) {
      // As a convention, the columns axis is associated with the index 0
      columnsAxis = cellSet.getAxes().get(0);
    } else {
      columnsAxis = null;
    }
 
    final AxisInfo columnsAxisInfo = computeAxisInfo(columnsAxis);
 
    // Compute how many columns are required to display the rows axis.
    final CellSetAxis rowsAxis;
 
    // If there are more than one axis, the second one is the rows axis
    if (cellSet.getAxes().size() > 1) {
      // As a convention, the rows axis is associated with the index 1
      rowsAxis = cellSet.getAxes().get(1);
    } else {
      rowsAxis = null;
    }
 
    final AxisInfo rowsAxisInfo = computeAxisInfo(rowsAxis);
 
    if (cellSet.getAxes().size() > 2) {
      final int[] dimensions = new int[cellSet.getAxes().size() - 2];
      for (int i = 2; i < cellSet.getAxes().size(); i++) {
        final CellSetAxis cellSetAxis = cellSet.getAxes().get(i);
        dimensions[i - 2] = cellSetAxis.getPositions().size();
      }
      for (final int[] pageCoords : CoordinateIterator.iterate(dimensions)) {
        matrix = formatPage(cellSet, pageCoords, columnsAxis, columnsAxisInfo, rowsAxis, rowsAxisInfo);
      }
    } else {
      matrix = formatPage(cellSet, new int[] {}, columnsAxis, columnsAxisInfo, rowsAxis, rowsAxisInfo);
    }
 
    return matrix;
  }
 
  /**
   * Computes a description of an axis. Each axis is composed by many positions,
   * each position is then composed by many members. A member is a 'point' on a
   * dimension of a cube. Every member belongs to a Level of a Hierarchy. The
   * member's depth is its distance to the root member.
   *
   * @param axis Axis
   * @return Description of axis
   */
  private AxisInfo computeAxisInfo(final CellSetAxis axis) {
    if (axis == null) {
      return new AxisInfo(0);
    }
 
    // An axis info is created by informing the number of hierarchies of axis
    final AxisInfo axisInfo = new AxisInfo(axis.getAxisMetaData().getHierarchies().size());
    int p = -1;
 
    // For each axis position
    for (final Position position : axis.getPositions()) {
      ++p;
      int k = -1;
 
      // For each member of the axis
      for (final Member member : position.getMembers()) {
        ++k;
 
        // Fetch the AxisOrdinalInfo instance of the position index k
        final AxisOrdinalInfo axisOrdinalInfo = axisInfo.ordinalInfos.get(k);
 
        // We avoid duplicating information for members with the same depth
        if (!axisOrdinalInfo.getDepths().contains(member.getDepth())) {
          axisOrdinalInfo.getDepths().add(member.getDepth());
          // For each depth of the hiearchy, add its level
          axisOrdinalInfo.addLevel(member.getDepth(), member.getLevel());
          Collections.sort(axisOrdinalInfo.depths);
        }
      }
    }
 
    // The axisInfo object, contains a collection of the hiearchy's levels
    // sorted by their depths.
    return axisInfo;
  }
 
  /**
   * Formats a two-dimensional page.
   *
   * @param cellSet
   *            Cell set
   * @param pageCoords
   *            Print writer
   * @param pageCoords
   *            Coordinates of page [page, chapter, section, ...]
   * @param columnsAxis
   *            Columns axis
   * @param columnsAxisInfo
   *            Description of columns axis
   * @param rowsAxis
   *            Rows axis
   * @param rowsAxisInfo
   *            Description of rows axis
   */
  private Matrix formatPage(final CellSet cellSet, final int[] pageCoords, final CellSetAxis columnsAxis,
                            final AxisInfo columnsAxisInfo, final CellSetAxis rowsAxis, final AxisInfo rowsAxisInfo) {
 
    // Figure out the dimensions of the blank rectangle in the top left
    // corner.
    final int yOffset = columnsAxisInfo.getWidth();
    final int xOffsset = rowsAxisInfo.getWidth();
 
    // Populate a string matrix
    final Matrix matrix = new Matrix(xOffsset + (columnsAxis == null ? 1 : columnsAxis.getPositions().size()),
      yOffset + (rowsAxis == null ? 1 : rowsAxis.getPositions().size()));
 
    // Populate corner
    List<Level> levels = new ArrayList<>();
    if (rowsAxis != null && rowsAxis.getPositions().size() > 0) {
      // We assume that every position contains members with same levels,
      // so, we just need the first position to retrieve this information.
      Position p = rowsAxis.getPositions().get(0);
 
      for (int m = 0; m < p.getMembers().size(); m++) {
        AxisOrdinalInfo a = rowsAxisInfo.ordinalInfos.get(m);
 
        // For each member's depth of the first position, add its level
        for (Integer depth : a.getDepths()) {
          levels.add(a.getLevel(depth));
        }
      }
 
      for (int x = 0; x < xOffsset; x++) {
        Level xLevel = levels.get(x);
        String s = xLevel.getCaption();
        for (int y = 0; y < yOffset; y++) {
          final MemberCell memberInfo = new MemberCell(false, x > 0);
          if (y == yOffset-1) {
            memberInfo.setRawValue(s);
            memberInfo.setFormattedValue(s);
            memberInfo.setProperty("__headertype", "row_header_header");
            memberInfo.setProperty("levelindex", "" + levels.indexOf(xLevel));
            memberInfo.setHierarchy(xLevel.getHierarchy().getUniqueName());
            memberInfo.setParentDimension(xLevel.getDimension().getName());
            memberInfo.setLevel(xLevel.getUniqueName());
          }
          matrix.set(x, y, memberInfo);
        }
 
      }
    }
    // Populate matrix with cells representing axes
    populateAxis(matrix, columnsAxis, columnsAxisInfo, true, xOffsset);
    populateAxis(matrix, rowsAxis, rowsAxisInfo, false, yOffset);
 
    // TODO - why did we do this in the first place??? HERE BE DRAGONS
    //		int headerwidth = matrix.getMatrixWidth();
    //		if (headerwidth > 2) {
    //			for(int yy=matrix.getMatrixHeight(); yy > matrix.getOffset() ; yy--) {
    //				for(int xx=0; xx < headerwidth-1;xx++) {
    //							if (matrix.get(xx,yy-1) != null && matrix.get(xx,yy) != null &&  matrix.get(xx,yy-1).getRawValue() != null
    //									&& matrix.get(xx,yy-1).getRawValue().equals(matrix.get(xx, yy).getRawValue()))
    //							{
    //								matrix.set(xx, yy, new MemberCell());
    //							}
    //							else {
    //								break;
    //							}
    //					}
    //			}
    //		}
 
 
    // Populate cell values
    int newyOffset = yOffset;
    int newxOffset = xOffsset;
    List<Integer> donex = new ArrayList<>();
    List<Integer> doney = new ArrayList<>();
    for (final Cell cell : cellIter(pageCoords, cellSet)) {
      final List<Integer> coordList = cell.getCoordinateList();
      int y = newyOffset;
      int x = newxOffset;
      if (coordList.size() > 0) {
        if (coordList.get(0) == 0) {
          newxOffset = xOffsset;
          donex = new ArrayList<>();
        }
        x = newxOffset;
        if (coordList.size() > 0)
          x += coordList.get(0);
        y = newyOffset;
        if (coordList.size() > 1)
          y += coordList.get(1);
 
        boolean stop = false;
        if (coordList.size() > 0 && ignorex.contains(coordList.get(0))) {
          if (!donex.contains(coordList.get(0))) {
            newxOffset--;
            donex.add(coordList.get(0));
          }
          stop = true;
        }
        if (coordList.size() > 1 && ignorey.contains(coordList.get(1))) {
          if (!doney.contains(coordList.get(1))) {
            newyOffset--;
            doney.add(coordList.get(1));
          }
          stop = true;
        }
        if (stop) {
          continue;
        }
      }
 
      final DataCell cellInfo = new DataCell(true, false, coordList);
      cellInfo.setCoordinates(cell.getCoordinateList());
 
      if (cell.getValue() != null) {
        try {
          cellInfo.setRawNumber(cell.getDoubleValue());
        } catch (Exception e1) {
        }
      }
      String cellValue = cell.getFormattedValue(); // First try to get a
      // formatted value
 
      if (cellValue == null || cellValue.equals("null")) { //$NON-NLS-1$
        cellValue =""; //$NON-NLS-1$
      }
      
      //0值处理 为"null"的时候 ,cellValue.startsWith("| |style=")表示原值为0,直接让其为0
      
      if (cellValue.startsWith("| |style=")) { //$NON-NLS-1$
          cellValue ="0"; 
          cellInfo.setRawValue(cellValue);
        }
      
      if ( cellValue.length() < 1) {
        final Object value =  cell.getValue();
        if (value == null  || value.equals("null")) //$NON-NLS-1$
          cellValue = ""; //$NON-NLS-1$
        else {
          try {
            // TODO this needs to become query / execution specific
            DecimalFormat myFormatter = new DecimalFormat(SaikuProperties.formatDefautNumberFormat); //$NON-NLS-1$
            DecimalFormatSymbols dfs = new DecimalFormatSymbols(SaikuProperties.locale);
            myFormatter.setDecimalFormatSymbols(dfs);
            cellValue = myFormatter.format(cell.getValue());
          }
          catch (Exception e) {
            // TODO: handle exception
          }
        }
        // the raw value
      }
 
      // Format string is relevant for Excel export
      // xmla cells can throw an error on this
      try {
        String formatString = (String) cell.getPropertyValue(Property.StandardCellProperty.FORMAT_STRING);
        if (formatString != null && !formatString.startsWith("|")) {
          cellInfo.setFormatString(formatString);
        } else {
          formatString = formatString.substring(1, formatString.length());
          cellInfo.setFormatString(formatString.substring(0, formatString.indexOf("|")));
        }
      } catch (Exception e) {
        // we tried
      }
 
      Map<String, String> cellProperties = new HashMap<>();
      String val = Olap4jUtil.parseFormattedCellValue(cellValue, cellProperties);
      
      //注釋掉properties style=white設置，防止導出的excel 指標信息無線條
      /*if (!cellProperties.isEmpty()) {
        cellInfo.setProperties(cellProperties);
      }*/
      cellInfo.setFormattedValue(val);
      matrix.set(x, y, cellInfo);
    }
    return matrix;
 
  }
 
  /**
   * Populates cells in the matrix corresponding to a particular axis.
   *
   * @param matrix
   *            Matrix to populate
   * @param axis
   *            Axis
   * @param axisInfo
   *            Description of axis
   * @param isColumns
   *            True if columns, false if rows
   * @param oldoffset
   *            Ordinal of first cell to populate in matrix
   */
  private void populateAxis(final Matrix matrix, final CellSetAxis axis, final AxisInfo axisInfo,
                            final boolean isColumns, final int oldoffset) {
    if (axis == null) {
      return;
    }
 
    int offset = oldoffset;
 
    final Member[] prevMembers = new Member[axisInfo.getWidth()];
    final MemberCell[] prevMemberInfo = new MemberCell[axisInfo.getWidth()];
    final Member[] members = new Member[axisInfo.getWidth()];
 
    // For each axis' position
    for (int i = 0; i < axis.getPositions().size(); i++) {
      final int x = offset + i;
      final Position position = axis.getPositions().get(i);
      int yOffset = 0;
      final List<Member> memberList = position.getMembers();
      boolean stop = false;
 
      // For each position's member
      for (int j = 0; j < memberList.size(); j++) {
        Member member = memberList.get(j);
        final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(j);
        List<Integer> depths = ordinalInfo.depths;
        Collections.sort(depths);
 
        // If it is not the last member (the one with the highest depth)
        if (member.getDepth() < Collections.max(depths)) {
          stop = true;
 
          if (isColumns) {
            ignorex.add(i);
          } else {
            ignorey.add(i);
          }
 
          break;
        }
 
        if (ordinalInfo.getDepths().size() > 0 && member.getDepth() < ordinalInfo.getDepths().get(0)) {
          break;
        }
 
        // It stores each position's member in members array sorted by its depth
        final int y = yOffset + ordinalInfo.depths.indexOf(member.getDepth());
        members[y] = member;
        yOffset += ordinalInfo.getWidth();
      }
 
      if (stop) {
        offset--;
        continue;
      }
 
      boolean expanded = false;
      boolean same = true;
 
      for (int y = 0; y < members.length; y++) {
        final MemberCell memberInfo = new MemberCell();
        final Member member = members[y];
 
        // The index of the member on its position
        int index = memberList.indexOf(member);
 
        if (index >= 0) {
          final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(index);
          int depth_i = ordinalInfo.getDepths().indexOf(member.getDepth());
          if (depth_i > 0) {
            expanded = true;
          }
        }
 
        memberInfo.setExpanded(expanded);
        same = same && i > 0 && Olap4jUtil.equal(prevMembers[y], member);
 
        if (member != null) {
          if (x - 1 == offset)
            memberInfo.setLastRow(true);
 
          matrix.setOffset(oldoffset);
          memberInfo.setRawValue(member.getUniqueName());
          memberInfo.setFormattedValue(member.getCaption()); // First try to get a formatted value
          memberInfo.setParentDimension(member.getDimension().getName());
          memberInfo.setUniquename(member.getUniqueName());
          memberInfo.setHierarchy(member.getHierarchy().getUniqueName());
          memberInfo.setLevel(member.getLevel().getUniqueName());
          //					try {
          //						memberInfo.setChildMemberCount(member.getChildMemberCount());
          //					} catch (OlapException e) {
          //						e.printStackTrace();
          //						throw new RuntimeException(e);
          //					}
          //					NamedList<Property> values = member.getLevel().getProperties();
          //					for(int j=0; j<values.size();j++){
          //						String val;
          //						try {
          //							val = member.getPropertyFormattedValue(values.get(j));
          //						} catch (OlapException e) {
          //							e.printStackTrace();
          //							throw new RuntimeException(e);
          //						}
          //						memberInfo.setProperty(values.get(j).getCaption(), val);
          //					}
 
          //					if (y > 0) {
          //						for (int previ = y-1; previ >= 0;previ--) {
          //							if(prevMembers[previ] != null) {
          //								memberInfo.setRightOf(prevMemberInfo[previ]);
          //								memberInfo.setRightOfDimension(prevMembers[previ].getDimension().getName());
          //								previ = -1;
          //							}
          //						}
          //					}
 
 
          //					if (member.getParentMember() != null)
          //						memberInfo.setParentMember(member.getParentMember().getUniqueName());
 
        } else {
          memberInfo.setRawValue(null);
          memberInfo.setFormattedValue(null);
          memberInfo.setParentDimension(null);
        }
 
        if (isColumns) {
          memberInfo.setRight(false);
          memberInfo.setSameAsPrev(same);
          if (member != null)
            memberInfo.setParentDimension(member.getDimension().getName());
          matrix.set(x, y, memberInfo);
        } else {
          memberInfo.setRight(false);
          memberInfo.setSameAsPrev(false);
          matrix.set(y, x, memberInfo);
        }
 
        int x_parent = isColumns ? x : y-1;
        int y_parent = isColumns ? y-1 : x;
 
        if (index >= 0) {
          final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(index);
          int depth_i = ordinalInfo.getDepths().indexOf(member.getDepth());
          while (depth_i > 0) {
            depth_i--;
            int parentDepth = (ordinalInfo.getDepths().get(depth_i));
            Member parent = member.getParentMember();
            while (parent != null && parent.getDepth() > parentDepth) {
              parent = parent.getParentMember();
            }
            final MemberCell pInfo = new MemberCell();
            if (parent != null) {
              pInfo.setRawValue(parent.getUniqueName());
              pInfo.setFormattedValue(parent.getCaption()); // First try to get a formatted value
              pInfo.setParentDimension(parent.getDimension().getName());
              pInfo.setHierarchy(parent.getHierarchy().getUniqueName());
              pInfo.setUniquename(parent.getUniqueName());
              pInfo.setLevel(parent.getLevel().getUniqueName());
            } else {
              pInfo.setRawValue("");
              pInfo.setFormattedValue(""); // First try to get a formatted value
              pInfo.setParentDimension(member.getDimension().getName());
              pInfo.setHierarchy(member.getHierarchy().getUniqueName());
              pInfo.setLevel(member.getLevel().getUniqueName());
              pInfo.setUniquename("");
            }
            matrix.set(x_parent, y_parent, pInfo);
            if (isColumns) {
              y_parent--;
            } else {
              x_parent--;
            }
          }
        }
 
        prevMembers[y] = member;
        prevMemberInfo[y] = memberInfo;
        members[y] = null;
      }
    }
  }
}

　　

saiku.table.css

.workspace_results {
  overflow: auto;
  margin-right: 10px;
  margin-left: 10px;
  padding-top: 10px;
  line-height: 1.3;
  min-height: 708px;
}
 
.workspace_results table {
  width: auto;
  margin-bottom: 0;
  table-layout: fixed;
  border-spacing: 0;
  border-collapse: separate;
  border-right: 1px solid #d5d5d5;
  border-bottom: 1px solid #d5d5d5;
}
 
.workspace_results th,
.workspace_results td {
  padding: 3px 9px 3px 4px;
}
 
.workspace_results td {
  font-size: 10px;
}
 
.workspace_results table th {
  margin-bottom: 0;
  font-weight: 500;
  border-left: 1px solid #d5d5d5;
  white-space: normal;
}
 
.workspace_results table th.all_null {
  border: none;
  text-align: center;
}
 
.workspace_results table th.col {
  border-top: 1px solid #d5d5d5;
  background: #f9f9f9;
  text-align: left;
}
 
.workspace_results table th.col_total_corner {
  border-top: 1px solid #d5d5d5;
  border-bottom: 1px none #d5d5d5;
  border-left: 1px none #d5d5d5;
  background: #f9f9f9;
  text-align: left;
}
 
.workspace_results table th.col_total_first {
  border-top: 1px solid #d5d5d5;
  border-left: 1px solid #d5d5d5;
  background: #f9f9f9;
  text-align: left;
}
 
.workspace_results table th.col_null {
  background: #f9f9f9;
}
 
.workspace_results table th.row {
  border-top: 1px solid #d5d5d5;
  background: #f9f9f9;
  text-align: left;
  white-space: nowrap;
}
 
.workspace_results table th.row_total {
  border-top: 1px solid #d5d5d5;
  border-left: 1px none #d5d5d5;
  background: #f9f9f9;
  text-align: left;
}
 
.workspace_results table th.row_total_first {
  border-top: 1px solid #d5d5d5;
  border-left: 1px solid #d5d5d5;
  background: #f9f9f9;
  text-align: left;
}
 
.workspace_results table th.row_total_corner {
  border-top: 1px none #d5d5d5;
  border-right: 1px none #d5d5d5;
  border-bottom: 1px none #d5d5d5;
  border-left: 1px solid #d5d5d5;
  background: #f9f9f9;
  text-align: left;
}
 
.workspace_results table th.row_header {
  border-top: 1px solid #d5d5d5;
  /*border-bottom: 1px solid #d5d5d5;*/
  background: #ececec;
}
 
.workspace_results table th.row_null {
  background: #f9f9f9;
}
 
.workspace_results table td.data {
  border-top: 1px solid #d5d5d5;
  border-left: 1px solid #d5d5d5;
  text-align: right;
  white-space: nowrap;
}
 
.workspace_results table td.total {
  font-weight: bold;
  background: #fbfbfb;
}
 
.workspace_results table tbody tr:hover {
  background: #edf4fa !important;
}
 
.workspace_results table td.cellhighlight:hover {
  background: #c2d5e2 !important;
}
 
.workspace_results table td.cellhighlight {
  cursor: pointer;
}
 
.workspace_results .headerhighlight th.row:hover,
.workspace_results .headerhighlight th.col:hover {
  background: #c2d5e2 !important;
}
 
.workspace_results .headerhighlight th.row,
.workspace_results .headerhighlight th.col {
  cursor: pointer;
}
 
.workspace_results table td.selected,
.workspace_results table td.ui-selected,
.workspace_results table td.ui-selecting {
  background: #c2d5e2 !important;
}
 
/* For some weird reason you can not have all css queries
   separated by commas, and have just one of these: */
 
.workspace_results:fullscreen {
  width: 100%;
  height: 100%;
  background-color: #fff;
  font-weight: 500;
}
 
.workspace_results:-moz-full-screen {
  width: 100%;
  height: 100%;
  background-color: #fff;
}
 
.workspace_results:-webkit-full-screen {
  width: 100%;
  height: 100%;
  background-color: #fff;
}
 
.workspace_results:fullscreen table {
  margin: 0 auto;
  font-size: 200%;
  font-weight: 500;
}
 
.workspace_results: table td {
  font-size: 100%;
}
 
.workspace_results:-webkit-full-screen table {
  margin: 0 auto;
  font-size: 200%;
  font-weight: 500;
}
 
.workspace_results:-webkit-full-screen table td {
  font-size: 100%;
}
 
.workspace_results:-moz-full-screen table {
  margin: 0 auto;
  font-size: 200%;
}
 
.workspace_results:-moz-full-screen table td {
  font-size: 100%;
}