@visactor/vtable 0.9.0-alpha.0-alpha.0

package/es/scenegraph/scenegraph.js

@@ -0,0 +1,818 @@
+import { createStage, createRect, IContainPointMode, container } from "@visactor/vrender";
+
+import { Group } from "./graphic/group";
+
+import { createBodyColGroup, createColHeaderColGroup, createCornerHeaderColGroup, createRowHeaderColGroup } from "./group-creater/column";
+
+import { updateAutoRowHeight } from "./layout/auto-height";
+
+import { getCellMergeInfo } from "./utils/get-cell-merge";
+
+import { updateColWidth } from "./layout/update-width";
+
+import { TableComponent } from "./component/table-component";
+
+import { updateRowHeight } from "./layout/update-height";
+
+import { updateImageCellContentWhileResize } from "./group-creater/cell-type/image-cell";
+
+import { getPadding } from "./utils/padding";
+
+import { createFrameBorder } from "./style/frame-border";
+
+import { ResizeColumnHotSpotSize } from "../tools/global";
+
+import splitModule from "./graphic/contributions";
+
+import { getProp } from "./utils/get-prop";
+
+import { dealWithIcon } from "./utils/text-icon-layout";
+
+import { SceneProxy } from "./group-creater/progress/proxy";
+
+import { SortOrder } from "../state/state";
+
+import { computeColWidth, computeColsWidth } from "./layout/compute-col-width";
+
+import { moveHeaderPosition } from "./layout/move-cell";
+
+import { updateCell } from "./group-creater/cell-helper";
+
+container.load(splitModule);
+
+const groupForDebug = new Group({});
+
+groupForDebug.role = "empty";
+
+export class Scenegraph {
+    constructor(table) {
+        this.table = table, this.hasFrozen = !1, this.clear = !0, this.stage = createStage({
+            canvas: table.canvas,
+            width: table.canvas.width,
+            height: table.canvas.height,
+            disableDirtyBounds: !1,
+            background: table.theme.underlayBackgroundColor
+        }), this.stage.defaultLayer.setTheme({
+            group: {
+                boundsPadding: 0,
+                strokeBoundsBuffer: 0,
+                lineJoin: "round"
+            }
+        }), this.initSceneGraph(), this.stage.defaultLayer.add(this.tableGroup), this.stage.table = this.table, 
+        this.createComponent();
+    }
+    get width() {
+        var _a, _b;
+        return null !== (_b = null === (_a = this.tableGroup.attribute) || void 0 === _a ? void 0 : _a.width) && void 0 !== _b ? _b : 0;
+    }
+    get height() {
+        var _a, _b;
+        return null !== (_b = null === (_a = this.tableGroup.attribute) || void 0 === _a ? void 0 : _a.height) && void 0 !== _b ? _b : 0;
+    }
+    get x() {
+        var _a, _b;
+        return null !== (_b = null === (_a = this.tableGroup.attribute) || void 0 === _a ? void 0 : _a.x) && void 0 !== _b ? _b : 0;
+    }
+    get y() {
+        var _a, _b;
+        return null !== (_b = null === (_a = this.tableGroup.attribute) || void 0 === _a ? void 0 : _a.y) && void 0 !== _b ? _b : 0;
+    }
+    get bodyRowStart() {
+        var _a;
+        return this.transpose || this.isPivot ? this.table.columnHeaderLevelCount : null !== (_a = this.proxy.rowStart) && void 0 !== _a ? _a : 0;
+    }
+    get bodyRowEnd() {
+        var _a;
+        return this.transpose || this.isPivot ? this.table.rowCount - 1 : null !== (_a = this.proxy.rowEnd) && void 0 !== _a ? _a : 0;
+    }
+    initSceneGraph() {
+        this.isPivot = this.table.isPivotTable(), this.transpose = this.table.options.transpose;
+        const width = this.table.tableNoFrameWidth, height = this.table.tableNoFrameHeight;
+        this.tableGroup = new Group({
+            x: 0,
+            y: 0,
+            width: width,
+            height: height,
+            clip: !0,
+            pickable: !1
+        }), this.tableGroup.role = "table";
+        const colHeaderGroup = new Group({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            clip: !1,
+            pickable: !1
+        });
+        colHeaderGroup.role = "col-header", this.colHeaderGroup = colHeaderGroup;
+        const cornerHeaderGroup = new Group({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            clip: !1,
+            pickable: !1
+        });
+        cornerHeaderGroup.role = "corner-header", this.cornerHeaderGroup = cornerHeaderGroup;
+        const rowHeaderGroup = new Group({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            clip: !1,
+            pickable: !1
+        });
+        rowHeaderGroup.role = "row-header", this.rowHeaderGroup = rowHeaderGroup;
+        const bodyGroup = new Group({
+            x: 0,
+            y: 0,
+            width: width,
+            height: 0,
+            clip: !1,
+            pickable: !1
+        });
+        bodyGroup.role = "body", this.bodyGroup = bodyGroup;
+        const componentGroup = new Group({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0,
+            clip: !1,
+            pickable: !1,
+            childrenPickable: !0
+        });
+        componentGroup.role = "component", this.componentGroup = componentGroup, this.tableGroup.addChild(bodyGroup), 
+        this.tableGroup.addChild(rowHeaderGroup), this.tableGroup.addChild(colHeaderGroup), 
+        this.tableGroup.addChild(cornerHeaderGroup), this.tableGroup.addChild(componentGroup);
+    }
+    createComponent() {
+        this.component = new TableComponent(this.table), this.component.addToGroup(this.componentGroup), 
+        this.selectedRangeComponents = new Map, this.selectingRangeComponents = new Map;
+    }
+    createSceneGraph() {
+        this.clear = !1, computeColsWidth(this.table), this.frozenColCount = this.table.rowHeaderLevelCount, 
+        this.frozenRowCount = this.table.columnHeaderLevelCount, this.proxy = new SceneProxy(this.table), 
+        this.createHeaderSceneGraph(), this.transpose || this.isPivot ? this.createBodySceneGraph() : this.createBodySceneGraphForFirstScreen();
+    }
+    createHeaderSceneGraph() {
+        createCornerHeaderColGroup(this.cornerHeaderGroup, 0, 0, this.table), this.colHeaderGroup.setAttribute("x", this.cornerHeaderGroup.attribute.width), 
+        createColHeaderColGroup(this.colHeaderGroup, 0, 0, this.table);
+    }
+    createBodySceneGraph() {
+        this.rowHeaderGroup.setAttribute("y", this.colHeaderGroup.attribute.height), createRowHeaderColGroup(this.rowHeaderGroup, 0, 0, this.table), 
+        this.bodyGroup.setAttributes({
+            y: this.colHeaderGroup.attribute.height,
+            x: this.rowHeaderGroup.attribute.width
+        }), createBodyColGroup(this.bodyGroup, 0, 0, this.table), this.afterScenegraphCreated();
+    }
+    createBodySceneGraphForFirstScreen() {
+        this.rowHeaderGroup.setAttribute("y", this.colHeaderGroup.attribute.height), this.bodyGroup.setAttributes({
+            y: this.colHeaderGroup.attribute.height,
+            x: this.rowHeaderGroup.attribute.width
+        }), console.log("before-createBodyColGroupForFirstScreen"), this.proxy.createColGroupForFirstScreen(this.rowHeaderGroup, this.bodyGroup, 0, 0, this.table), 
+        console.log("after-createBodyColGroupForFirstScreen"), this.afterScenegraphCreated();
+    }
+    renderSceneGraph() {
+        this.stage.render();
+    }
+    getCellOld(col, row) {
+        var _a, _b, _c, _d;
+        let element;
+        if (element = this.hasFrozen && col < this.table.frozenColCount && row < this.table.frozenRowCount ? null === (_a = this.cornerHeaderGroup.getChildAt(col)) || void 0 === _a ? void 0 : _a.getChildAt(row) : row < this.table.frozenRowCount ? null === (_b = this.colHeaderGroup.getChildAt(this.hasFrozen ? col - this.table.frozenColCount : col)) || void 0 === _b ? void 0 : _b.getChildAt(row) : col < this.table.frozenColCount ? null === (_c = this.rowHeaderGroup.getChildAt(col)) || void 0 === _c ? void 0 : _c.getChildAt(row - this.table.frozenRowCount) : null === (_d = this.bodyGroup.getChildAt(col - this.table.frozenColCount)) || void 0 === _d ? void 0 : _d.getChildAt(row - this.table.frozenRowCount), 
+        element && "shadow-cell" === element.role) {
+            const range = this.table.getCellRange(col, row);
+            element = this.getCell(range.start.col, range.start.row);
+        }
+        return element || void 0;
+    }
+    getColGroupOld(col, isHeader = !1) {
+        let element;
+        return element = col < this.frozenColCount && isHeader ? this.cornerHeaderGroup.getChildAt(col) : col < this.frozenColCount ? this.rowHeaderGroup.getChildAt(col) : isHeader ? this.rowHeaderGroup.getChildAt(col - this.frozenColCount) : this.bodyGroup.getChildAt(col - this.frozenColCount), 
+        element || void 0;
+    }
+    getCell(col, row, getShadow) {
+        var _a;
+        let cell = null === (_a = this.getColGroup(col, row < this.frozenRowCount)) || void 0 === _a ? void 0 : _a.getRowGroup(row);
+        if (cell && "shadow-cell" === cell.role && !getShadow) {
+            const range = this.table.getCellRange(col, row);
+            cell = this.getCell(range.start.col, range.start.row);
+        }
+        return cell || groupForDebug;
+    }
+    getColGroup(col, isCornerOrColHeader = !1) {
+        let element;
+        return element = col < this.frozenColCount && isCornerOrColHeader ? this.cornerHeaderGroup.getColGroup(col) : col < this.frozenColCount ? this.rowHeaderGroup.getColGroup(col) : isCornerOrColHeader ? this.colHeaderGroup.getColGroup(col) : this.bodyGroup.getColGroup(col), 
+        element || void 0;
+    }
+    getCellSize(col, row) {
+        const cell = this.getCell(col, row), mergeInfo = getCellMergeInfo(this.table, col, row);
+        let width = cell.attribute.width, height = cell.attribute.height;
+        return mergeInfo && (width /= mergeInfo.end.col - mergeInfo.start.col + 1, height /= mergeInfo.end.row - mergeInfo.start.row + 1), 
+        {
+            width: width,
+            height: height
+        };
+    }
+    updateNextFrame() {
+        this.resetAllSelectComponent(), this.stage.renderNextFrame();
+    }
+    resetAllSelectComponent() {
+        this.selectingRangeComponents.forEach(((selectComp, key) => {
+            const [startCol, startRow, endCol, endRow] = key.split("-");
+            let cellsBounds;
+            for (let i = parseInt(startCol, 10); i <= parseInt(endCol, 10); i++) for (let j = parseInt(startRow, 10); j <= parseInt(endRow, 10); j++) {
+                const cellGroup = this.getCell(i, j);
+                cellGroup.AABBBounds.width();
+                const bounds = cellGroup.globalAABBBounds;
+                cellsBounds ? cellsBounds.union(bounds) : cellsBounds = bounds;
+            }
+            selectComp.rect.setAttributes({
+                x: cellsBounds.x1 - this.tableGroup.attribute.x,
+                y: cellsBounds.y1 - this.tableGroup.attribute.y,
+                width: cellsBounds.width(),
+                height: cellsBounds.height(),
+                visible: !0
+            });
+            const isNearRowHeader = parseInt(startCol, 10) === this.table.frozenColCount, isNearColHeader = parseInt(startRow, 10) === this.table.frozenRowCount;
+            isNearRowHeader && selectComp.rect.attribute.stroke[3] || isNearColHeader && selectComp.rect.attribute.stroke[0] ? (isNearRowHeader && this.tableGroup.insertAfter(selectComp.rect, "columnHeader" === selectComp.role ? this.cornerHeaderGroup : this.rowHeaderGroup), 
+            isNearColHeader && this.tableGroup.insertAfter(selectComp.rect, "rowHeader" === selectComp.role ? this.cornerHeaderGroup : this.colHeaderGroup), 
+            selectComp.rect.attribute.x < this.rowHeaderGroup.attribute.width && this.table.scrollLeft > 0 && ("body" === selectComp.role || "columnHeader" === selectComp.role) && selectComp.rect.setAttributes({
+                x: selectComp.rect.attribute.x + (this.rowHeaderGroup.attribute.width - selectComp.rect.attribute.x),
+                width: selectComp.rect.attribute.width - (this.rowHeaderGroup.attribute.width - selectComp.rect.attribute.x)
+            }), selectComp.rect.attribute.y < this.colHeaderGroup.attribute.height && this.table.scrollTop > 0 && ("body" === selectComp.role || "rowHeader" === selectComp.role) && selectComp.rect.setAttributes({
+                y: selectComp.rect.attribute.y + (this.colHeaderGroup.attribute.height - selectComp.rect.attribute.y),
+                height: selectComp.rect.attribute.height - (this.colHeaderGroup.attribute.height - selectComp.rect.attribute.y)
+            })) : this.tableGroup.insertAfter(selectComp.rect, "body" === selectComp.role ? this.bodyGroup : "columnHeader" === selectComp.role ? this.colHeaderGroup : "rowHeader" === selectComp.role ? this.rowHeaderGroup : this.cornerHeaderGroup);
+        })), this.selectedRangeComponents.forEach(((selectComp, key) => {
+            const [startCol, startRow, endCol, endRow] = key.split("-");
+            let cellsBounds;
+            for (let i = parseInt(startCol, 10); i <= parseInt(endCol, 10); i++) for (let j = parseInt(startRow, 10); j <= parseInt(endRow, 10); j++) {
+                const cellGroup = this.getCell(i, j);
+                cellGroup.AABBBounds.width();
+                const bounds = cellGroup.globalAABBBounds;
+                cellsBounds ? cellsBounds.union(bounds) : cellsBounds = bounds;
+            }
+            selectComp.rect.setAttributes({
+                x: cellsBounds.x1 - this.tableGroup.attribute.x,
+                y: cellsBounds.y1 - this.tableGroup.attribute.y,
+                width: cellsBounds.width(),
+                height: cellsBounds.height(),
+                visible: !0
+            });
+            const isNearRowHeader = parseInt(startCol, 10) === this.table.frozenColCount, isNearColHeader = parseInt(startRow, 10) === this.table.frozenRowCount;
+            isNearRowHeader && selectComp.rect.attribute.stroke[3] || isNearColHeader && selectComp.rect.attribute.stroke[0] ? (isNearRowHeader && this.tableGroup.insertAfter(selectComp.rect, "columnHeader" === selectComp.role ? this.cornerHeaderGroup : this.rowHeaderGroup), 
+            isNearColHeader && this.tableGroup.insertAfter(selectComp.rect, "rowHeader" === selectComp.role ? this.cornerHeaderGroup : this.colHeaderGroup), 
+            selectComp.rect.attribute.x < this.rowHeaderGroup.attribute.width && this.table.scrollLeft > 0 && ("body" === selectComp.role || "columnHeader" === selectComp.role) && selectComp.rect.setAttributes({
+                x: selectComp.rect.attribute.x + (this.rowHeaderGroup.attribute.width - selectComp.rect.attribute.x),
+                width: selectComp.rect.attribute.width - (this.rowHeaderGroup.attribute.width - selectComp.rect.attribute.x)
+            }), selectComp.rect.attribute.y < this.colHeaderGroup.attribute.height && this.table.scrollTop > 0 && ("body" === selectComp.role || "rowHeader" === selectComp.role) && selectComp.rect.setAttributes({
+                y: selectComp.rect.attribute.y + (this.colHeaderGroup.attribute.height - selectComp.rect.attribute.y),
+                height: selectComp.rect.attribute.height - (this.colHeaderGroup.attribute.height - selectComp.rect.attribute.y)
+            })) : this.tableGroup.insertAfter(selectComp.rect, "body" === selectComp.role ? this.bodyGroup : "columnHeader" === selectComp.role ? this.colHeaderGroup : "rowHeader" === selectComp.role ? this.rowHeaderGroup : this.cornerHeaderGroup);
+        }));
+    }
+    removeInteractionBorder(col, row) {
+        const cellGroup = this.getCell(col, row);
+        cellGroup.setAttribute("highlightStroke", void 0), cellGroup.setAttribute("highlightStrokeArrayWidth", void 0), 
+        cellGroup.setAttribute("highlightStrokeArrayColor", void 0);
+    }
+    hideHoverIcon(col, row) {
+        if (-1 === col || -1 === row) return;
+        hideIcon(this, this.getCell(col, row), "mouseenter_cell");
+    }
+    showHoverIcon(col, row) {
+        if (-1 === col || -1 === row) return;
+        showIcon(this, this.getCell(col, row), "mouseenter_cell");
+    }
+    hideClickIcon(col, row) {
+        if (-1 === col || -1 === row) return;
+        hideIcon(this, this.getCell(col, row), "click_cell");
+    }
+    showClickIcon(col, row) {
+        if (-1 === col || -1 === row) return;
+        showIcon(this, this.getCell(col, row), "click_cell");
+    }
+    deactivateChart(col, row) {
+        var _a, _b;
+        if (-1 === col || -1 === row) return;
+        const cellGroup = this.getCell(col, row);
+        null === (_b = null === (_a = null == cellGroup ? void 0 : cellGroup.firstChild) || void 0 === _a ? void 0 : _a.deactivate) || void 0 === _b || _b.call(_a);
+    }
+    activateChart(col, row) {
+        var _a, _b;
+        if (-1 === col || -1 === row) return;
+        const cellGroup = this.getCell(col, row);
+        null === (_b = null === (_a = null == cellGroup ? void 0 : cellGroup.firstChild) || void 0 === _a ? void 0 : _a.activate) || void 0 === _b || _b.call(_a, this.table);
+    }
+    createCellSelectBorder(start_Col, start_Row, end_Col, end_Row, selectRangeType, selectId, strokes) {
+        var _a, _b, _c, _d;
+        const startCol = Math.min(start_Col, end_Col), startRow = Math.min(start_Row, end_Row), endCol = Math.max(start_Col, end_Col), endRow = Math.max(start_Row, end_Row);
+        let cellsBounds;
+        for (let i = startCol; i <= endCol; i++) for (let j = startRow; j <= endRow; j++) {
+            const cellGroup = this.getCell(i, j);
+            if ("shadow-cell" === cellGroup.role) continue;
+            const bounds = cellGroup.globalAABBBounds;
+            cellsBounds ? cellsBounds.union(bounds) : cellsBounds = bounds;
+        }
+        const theme = this.table.theme, bodyClickBorderColor = null === (_a = theme.selectionStyle) || void 0 === _a ? void 0 : _a.cellBorderColor, bodyClickLineWidth = null === (_b = theme.selectionStyle) || void 0 === _b ? void 0 : _b.cellBorderLineWidth, rect = createRect({
+            pickable: !1,
+            fill: !0,
+            fillColor: null !== (_d = null === (_c = theme.selectionStyle) || void 0 === _c ? void 0 : _c.cellBgColor) && void 0 !== _d ? _d : "rgba(0, 0, 255,0.1)",
+            strokeColor: bodyClickBorderColor,
+            lineWidth: bodyClickLineWidth,
+            stroke: strokes,
+            x: cellsBounds.x1 - this.tableGroup.attribute.x,
+            y: cellsBounds.y1 - this.tableGroup.attribute.y,
+            width: cellsBounds.width(),
+            height: cellsBounds.height(),
+            visible: !0
+        });
+        this.lastSelectId = selectId, this.selectingRangeComponents.set(`${startCol}-${startRow}-${endCol}-${endRow}-${selectId}`, {
+            rect: rect,
+            role: selectRangeType
+        }), this.tableGroup.insertAfter(rect, "body" === selectRangeType ? this.bodyGroup : "columnHeader" === selectRangeType ? this.colHeaderGroup : "rowHeader" === selectRangeType ? this.rowHeaderGroup : this.cornerHeaderGroup);
+    }
+    moveSelectingRangeComponentsToSelectedRangeComponents() {
+        this.selectingRangeComponents.forEach(((rangeComponent, key) => {
+            this.selectedRangeComponents.get(key) && this.selectedRangeComponents.get(key).rect.delete(), 
+            this.selectedRangeComponents.set(key, rangeComponent);
+        })), this.selectingRangeComponents = new Map, this.updateNextFrame();
+    }
+    deleteLastSelectedRangeComponents() {
+        this.selectedRangeComponents.forEach(((selectComp, key) => {
+            key.split("-")[4] === this.lastSelectId && (selectComp.rect.delete(), this.selectedRangeComponents.delete(key));
+        }));
+    }
+    deleteAllSelectBorder() {
+        this.selectedRangeComponents.forEach(((selectComp, key) => {
+            selectComp.rect.delete();
+        })), this.selectedRangeComponents = new Map;
+    }
+    updateCellSelectBorder(newStartCol, newStartRow, newEndCol, newEndRow) {
+        let startCol = Math.min(newEndCol, newStartCol), startRow = Math.min(newEndRow, newStartRow), endCol = Math.max(newEndCol, newStartCol), endRow = Math.max(newEndRow, newStartRow);
+        const extendSelectRange = () => {
+            let isExtend = !1;
+            for (let col = startCol; col <= endCol; col++) {
+                if (col === startCol) for (let row = startRow; row <= endRow; row++) {
+                    const mergeInfo = getCellMergeInfo(this.table, col, row);
+                    if (mergeInfo && mergeInfo.start.col < startCol) {
+                        startCol = mergeInfo.start.col, isExtend = !0;
+                        break;
+                    }
+                }
+                if (!isExtend && col === endCol) for (let row = startRow; row <= endRow; row++) {
+                    const mergeInfo = getCellMergeInfo(this.table, col, row);
+                    if (mergeInfo && mergeInfo.end.col > endCol) {
+                        endCol = mergeInfo.end.col, isExtend = !0;
+                        break;
+                    }
+                }
+                if (isExtend) break;
+            }
+            if (!isExtend) for (let row = startRow; row <= endRow; row++) {
+                if (row === startRow) for (let col = startCol; col <= endCol; col++) {
+                    const mergeInfo = getCellMergeInfo(this.table, col, row);
+                    if (mergeInfo && mergeInfo.start.row < startRow) {
+                        startRow = mergeInfo.start.row, isExtend = !0;
+                        break;
+                    }
+                }
+                if (!isExtend && row === endRow) for (let col = startCol; col <= endCol; col++) {
+                    const mergeInfo = getCellMergeInfo(this.table, col, row);
+                    if (mergeInfo && mergeInfo.end.row > endRow) {
+                        endRow = mergeInfo.end.row, isExtend = !0;
+                        break;
+                    }
+                }
+                if (isExtend) break;
+            }
+            isExtend && extendSelectRange();
+        };
+        extendSelectRange(), this.selectingRangeComponents.forEach(((selectComp, key) => {
+            selectComp.rect.delete();
+        })), this.selectingRangeComponents = new Map;
+        let needRowHeader = !1, needColumnHeader = !1, needBody = !1, needCornerHeader = !1;
+        if (startCol <= this.table.frozenColCount - 1 && startRow <= this.table.frozenRowCount - 1 && (needCornerHeader = !0), 
+        startCol <= this.table.frozenColCount - 1 && endRow >= this.table.frozenRowCount && (needRowHeader = !0), 
+        startRow <= this.table.frozenRowCount - 1 && endCol >= this.table.frozenColCount && (needColumnHeader = !0), 
+        endCol >= this.table.frozenColCount && endRow >= this.table.frozenRowCount && (needBody = !0), 
+        needCornerHeader) {
+            const cornerEndCol = Math.min(endCol, this.table.frozenColCount - 1), cornerEndRow = Math.min(endRow, this.table.frozenRowCount - 1), strokeArray = [ !0, !needColumnHeader, !needRowHeader, !0 ];
+            this.createCellSelectBorder(startCol, startRow, cornerEndCol, cornerEndRow, "cornerHeader", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
+        }
+        if (needColumnHeader) {
+            const columnHeaderStartCol = Math.max(startCol, this.table.frozenColCount), columnHeaderEndRow = Math.min(endRow, this.table.frozenRowCount - 1), strokeArray = [ !0, !0, !needBody, !needCornerHeader ];
+            this.createCellSelectBorder(columnHeaderStartCol, startRow, endCol, columnHeaderEndRow, "columnHeader", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
+        }
+        if (needRowHeader) {
+            const columnHeaderStartRow = Math.max(startRow, this.table.frozenRowCount), columnHeaderEndCol = Math.min(endCol, this.table.frozenColCount - 1), strokeArray = [ !needCornerHeader, !needBody, !0, !0 ];
+            this.createCellSelectBorder(startCol, columnHeaderStartRow, columnHeaderEndCol, endRow, "rowHeader", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
+        }
+        if (needBody) {
+            const columnHeaderStartCol = Math.max(startCol, this.table.frozenColCount), columnHeaderStartRow = Math.max(startRow, this.table.frozenRowCount), strokeArray = [ !needColumnHeader, !0, !0, !needRowHeader ];
+            this.createCellSelectBorder(columnHeaderStartCol, columnHeaderStartRow, endCol, endRow, "body", `${startCol}${startRow}${endCol}${endRow}`, strokeArray);
+        }
+    }
+    getIcon(col, row, x, y) {
+        let pickMark;
+        return this.getCell(col, row).forEachChildren((mark => {
+            "icon" === mark.role && mark.containsPoint(x, y, IContainPointMode.GLOBAL) && (pickMark = mark);
+        })), pickMark;
+    }
+    setIconHoverStyle(icon, col, row, cellGroup) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (icon.attribute.backgroundColor) {
+            let iconBack = icon.parent.getChildByName("icon-back");
+            iconBack ? iconBack.setAttributes({
+                x: (null !== (_a = icon.attribute.x) && void 0 !== _a ? _a : 0) + (null !== (_b = icon.attribute.dx) && void 0 !== _b ? _b : 0) + (icon.AABBBounds.width() - icon.backgroundWidth) / 2,
+                y: (null !== (_c = icon.attribute.y) && void 0 !== _c ? _c : 0) + (icon.AABBBounds.height() - icon.backgroundHeight) / 2,
+                width: icon.backgroundWidth,
+                height: icon.backgroundHeight,
+                fillColor: icon.attribute.backgroundColor,
+                borderRadius: 5,
+                visible: !0
+            }) : (iconBack = createRect({
+                x: (null !== (_d = icon.attribute.x) && void 0 !== _d ? _d : 0) + (null !== (_e = icon.attribute.dx) && void 0 !== _e ? _e : 0) + (icon.AABBBounds.width() - icon.backgroundWidth) / 2,
+                y: (null !== (_f = icon.attribute.y) && void 0 !== _f ? _f : 0) + (icon.AABBBounds.height() - icon.backgroundHeight) / 2,
+                width: icon.backgroundWidth,
+                height: icon.backgroundHeight,
+                fillColor: icon.attribute.backgroundColor,
+                borderRadius: 5,
+                pickable: !1,
+                visible: !0
+            }), iconBack.name = "icon-back"), icon.parent.insertBefore(iconBack, icon);
+        }
+        if (icon.attribute.hoverImage && icon.attribute.image !== icon.attribute.hoverImage && (icon.image = icon.attribute.hoverImage), 
+        icon.tooltip) {
+            const {x1: left, x2: right, y1: top, y2: bottom} = icon.globalAABBBounds, tooltipOptions = {
+                content: icon.tooltip.title,
+                referencePosition: {
+                    rect: {
+                        left: left - this.table.tableX,
+                        right: right - this.table.tableX,
+                        top: top - this.table.tableY,
+                        bottom: bottom - this.table.tableY,
+                        width: icon.globalAABBBounds.width(),
+                        height: icon.globalAABBBounds.height()
+                    },
+                    placement: icon.tooltip.placement
+                },
+                style: Object.assign({}, null === (_g = this.table.internalProps.theme) || void 0 === _g ? void 0 : _g.tooltipStyle, null === (_h = icon.tooltip) || void 0 === _h ? void 0 : _h.style)
+            };
+            this.table.internalProps.tooltipHandler.isBinded(tooltipOptions) || this.table.showTooltip(col, row, tooltipOptions);
+        }
+    }
+    setIconNormalStyle(icon, col, row) {
+        const iconBack = icon.parent.getChildByName("icon-back");
+        iconBack && iconBack.setAttribute("visible", !1), icon.attribute.hoverImage && icon.attribute.image !== icon.attribute.originImage && (icon.image = icon.attribute.originImage);
+    }
+    updateColWidth(col, detaX) {
+        updateColWidth(this, col, detaX), this.updateContainerWidth(col, detaX);
+    }
+    updateAutoColWidth(col) {
+        const oldWidth = this.table.getColWidth(col), newWidth = computeColWidth(col, 0, this.table.rowCount - 1, this.table, !0);
+        newWidth !== oldWidth && this.updateColWidth(col, newWidth - oldWidth);
+    }
+    updateTableSize() {
+        var _a, _b;
+        this.tableGroup.setAttributes({
+            width: Math.min(this.table.tableNoFrameWidth, Math.max(this.colHeaderGroup.attribute.width, this.bodyGroup.attribute.width, 0) + Math.max(this.cornerHeaderGroup.attribute.width, this.rowHeaderGroup.attribute.width, 0)),
+            height: Math.min(this.table.tableNoFrameHeight, (null !== (_a = this.colHeaderGroup.attribute.height) && void 0 !== _a ? _a : 0) + (null !== (_b = this.bodyGroup.attribute.height) && void 0 !== _b ? _b : 0))
+        }), this.tableGroup.border && this.tableGroup.border.setAttributes({
+            width: this.tableGroup.attribute.width + this.tableGroup.border.attribute.lineWidth,
+            height: this.tableGroup.attribute.height + this.tableGroup.border.attribute.lineWidth
+        });
+    }
+    updateRowHeight(row, detaY) {
+        updateRowHeight(this, row, detaY), this.updateContainerHeight(row, detaY);
+    }
+    updateContainerWidth(col, detaX) {
+        col < this.frozenColCount ? (this.rowHeaderGroup.setDeltaWidth(detaX), this.cornerHeaderGroup.setDeltaWidth(detaX), 
+        this.colHeaderGroup.setDeltaX(detaX), this.bodyGroup.setDeltaX(detaX)) : (this.colHeaderGroup.setDeltaWidth(detaX), 
+        this.bodyGroup.setDeltaWidth(detaX)), this.updateTableSize(), this.component.updateScrollBar(), 
+        this.updateNextFrame();
+    }
+    updateContainerHeight(row, detaY) {
+        row < this.frozenRowCount ? (this.colHeaderGroup.setDeltaHeight(detaY), this.cornerHeaderGroup.setDeltaHeight(detaY), 
+        this.rowHeaderGroup.setDeltaY(detaY), this.bodyGroup.setDeltaY(detaY)) : (this.rowHeaderGroup.setDeltaHeight(detaY), 
+        this.bodyGroup.setDeltaHeight(detaY)), this.updateTableSize(), this.component.updateScrollBar(), 
+        this.updateNextFrame();
+    }
+    setColWidth(col, width) {
+        const oldWidth = this.table.getColWidth(col);
+        oldWidth !== width && this.updateColWidth(col, width - oldWidth);
+    }
+    setRowHeight(row, height) {
+        const oldHeight = this.table.getRowHeight(row);
+        this.updateRowHeight(row, height - oldHeight);
+    }
+    setX(x) {
+        this.colHeaderGroup.attribute.width + x !== this.bodyGroup.attribute.x && (this.bodyGroup.setAttribute("x", this.rowHeaderGroup.attribute.width + x), 
+        this.colHeaderGroup.setAttribute("x", this.rowHeaderGroup.attribute.width + x), 
+        this.updateNextFrame());
+    }
+    setY(y) {
+        if (this.transpose || this.isPivot) {
+            if (this.colHeaderGroup.attribute.height + y === this.bodyGroup.attribute.y) return;
+            this.bodyGroup.setAttribute("y", this.colHeaderGroup.attribute.height + y), this.rowHeaderGroup.setAttribute("y", this.colHeaderGroup.attribute.height + y), 
+            this.updateNextFrame();
+        } else this.table.scenegraph.proxy && this.table.scenegraph.proxy.setY(-y);
+    }
+    setBodyAndRowHeaderY(y) {
+        this.colHeaderGroup.attribute.height + y !== this.bodyGroup.attribute.y && (this.bodyGroup.setAttribute("y", this.colHeaderGroup.attribute.height + y), 
+        this.rowHeaderGroup.setAttribute("y", this.colHeaderGroup.attribute.height + y), 
+        this.updateNextFrame());
+    }
+    afterScenegraphCreated() {
+        const {autoRowHeight: autoRowHeight} = this.table.internalProps;
+        autoRowHeight && updateAutoRowHeight(this), this.dealWidthMode(), this.dealFrozen(), 
+        this.createFrameBorder(), this.component.updateScrollBar();
+    }
+    dealWidthMode() {
+        const table = this.table;
+        if ("adaptive" === table.widthMode) {
+            const totalDrawWidth = table.tableNoFrameWidth;
+            let actualWidth = 0;
+            for (let col = 0; col < table.colCount; col++) actualWidth += table.getColWidth(col);
+            const factor = totalDrawWidth / actualWidth;
+            for (let col = 0; col < table.colCount; col++) {
+                let colWidth;
+                colWidth = col === table.colCount - 1 ? totalDrawWidth - table.getColsWidth(0, table.colCount - 2) : Math.round(table.getColWidth(col) * factor), 
+                this.setColWidth(col, colWidth);
+            }
+        } else if ("standard-aeolus" === table.widthMode && this.transpose) {
+            const canvasWidth = table.tableNoFrameWidth;
+            let actualWidth = 0, actualHeaderWidth = 0;
+            for (let col = 0; col < table.colCount; col++) {
+                const colWidth = table.getColWidth(col);
+                col < table.frozenColCount && (actualHeaderWidth += colWidth), actualWidth += colWidth;
+            }
+            if (actualWidth < canvasWidth && actualWidth - actualHeaderWidth > 0) {
+                const factor = (canvasWidth - actualHeaderWidth) / (actualWidth - actualHeaderWidth);
+                for (let col = table.frozenColCount; col < table.colCount; col++) this.setColWidth(col, table.getColWidth(col) * factor);
+            }
+        }
+        let bodyWidth = 0;
+        this.bodyGroup.forEachChildrenSkipChild((column => {
+            bodyWidth += column.attribute.width;
+        })), this.bodyGroup.setAttribute("width", bodyWidth);
+        let colHeaderWidth = 0;
+        this.colHeaderGroup.forEachChildrenSkipChild((column => {
+            colHeaderWidth += column.attribute.width;
+        })), this.colHeaderGroup.setAttribute("width", colHeaderWidth);
+        let rowHeaderWidth = 0;
+        this.rowHeaderGroup.forEachChildrenSkipChild((column => {
+            rowHeaderWidth += column.attribute.width;
+        })), this.rowHeaderGroup.setAttribute("width", rowHeaderWidth);
+        let cornerHeaderWidth = 0;
+        this.cornerHeaderGroup.forEachChildrenSkipChild((column => {
+            cornerHeaderWidth += column.attribute.width;
+        })), this.cornerHeaderGroup.setAttribute("width", cornerHeaderWidth), this.colHeaderGroup.setAttribute("x", this.cornerHeaderGroup.attribute.width), 
+        this.rowHeaderGroup.setAttribute("y", this.colHeaderGroup.attribute.height), this.bodyGroup.setAttributes({
+            x: this.rowHeaderGroup.attribute.width,
+            y: this.colHeaderGroup.attribute.height
+        });
+    }
+    dealFrozen() {
+        var _a, _b, _c, _d, _e, _f;
+        if (this.table.frozenColCount > this.table.rowHeaderLevelCount) {
+            this.rowHeaderGroup.setAttribute("height", this.bodyGroup.attribute.height), this.rowHeaderGroup.setAttribute("y", this.bodyGroup.attribute.y), 
+            this.cornerHeaderGroup.setAttribute("height", this.colHeaderGroup.attribute.height);
+            for (let i = 0; i < this.table.frozenColCount - this.table.rowHeaderLevelCount; i++) {
+                const column = this.bodyGroup.firstChild;
+                column && (this.rowHeaderGroup.appendChild(column), this.rowHeaderGroup.setAttribute("width", this.rowHeaderGroup.attribute.width + column.attribute.width), 
+                this.bodyGroup.setAttribute("width", this.bodyGroup.attribute.width - column.attribute.width));
+                const headerColumn = this.colHeaderGroup.firstChild;
+                headerColumn && (this.cornerHeaderGroup.appendChild(headerColumn), this.cornerHeaderGroup.setAttribute("width", this.cornerHeaderGroup.attribute.width + headerColumn.attribute.width), 
+                this.colHeaderGroup.setAttribute("width", this.colHeaderGroup.attribute.width - headerColumn.attribute.width));
+            }
+        }
+        this.bodyGroup.setAttribute("x", this.rowHeaderGroup.attribute.width), this.colHeaderGroup.setAttribute("x", this.cornerHeaderGroup.attribute.width);
+        const bodyDeltaX = null !== (_b = null === (_a = this.bodyGroup.firstChild) || void 0 === _a ? void 0 : _a.attribute.x) && void 0 !== _b ? _b : 0;
+        this.bodyGroup.forEachChildrenSkipChild((column => {
+            column.setAttribute("x", column.attribute.x - bodyDeltaX);
+        }));
+        const colDeltaX = null !== (_d = null === (_c = this.colHeaderGroup.firstChild) || void 0 === _c ? void 0 : _c.attribute.x) && void 0 !== _d ? _d : 0;
+        this.colHeaderGroup.forEachChildrenSkipChild((column => {
+            column.setAttribute("x", column.attribute.x - colDeltaX);
+        })), this.updateBorderSizeAndPosition(), this.isPivot || this.transpose || this.component.setFrozenColumnShadow(this.table.frozenColCount - 1), 
+        this.hasFrozen = !0, this.frozenColCount = this.table.frozenColCount, this.frozenRowCount = null !== (_f = null === (_e = this.colHeaderGroup.firstChild) || void 0 === _e ? void 0 : _e.childrenCount) && void 0 !== _f ? _f : 0;
+    }
+    resetFrozen() {
+        var _a, _b;
+        if (this.frozenColCount > this.table.rowHeaderLevelCount) for (let i = 0; i < this.frozenColCount - this.table.rowHeaderLevelCount; i++) {
+            const column = this.rowHeaderGroup.lastChild instanceof Group ? this.rowHeaderGroup.lastChild : this.rowHeaderGroup.lastChild._prev;
+            column && (this.bodyGroup.insertBefore(column, this.bodyGroup.firstChild), this.bodyGroup.setAttribute("width", this.bodyGroup.attribute.width + column.attribute.width), 
+            this.rowHeaderGroup.setAttribute("width", this.rowHeaderGroup.attribute.width - column.attribute.width));
+            const headerColumn = this.cornerHeaderGroup.lastChild instanceof Group ? this.cornerHeaderGroup.lastChild : this.cornerHeaderGroup.lastChild._prev;
+            headerColumn && (this.colHeaderGroup.insertBefore(headerColumn, this.colHeaderGroup.firstChild), 
+            this.colHeaderGroup.setAttribute("width", this.colHeaderGroup.attribute.width + headerColumn.attribute.width), 
+            this.cornerHeaderGroup.setAttribute("width", this.cornerHeaderGroup.attribute.width - headerColumn.attribute.width));
+        }
+        this.bodyGroup.setAttribute("x", this.rowHeaderGroup.attribute.width), this.colHeaderGroup.setAttribute("x", this.cornerHeaderGroup.attribute.width);
+        let bodyX = 0;
+        this.bodyGroup.forEachChildrenSkipChild((column => {
+            column.setAttribute("x", bodyX), bodyX += column.attribute.width;
+        }));
+        let colX = 0;
+        this.colHeaderGroup.forEachChildrenSkipChild((column => {
+            column.setAttribute("x", colX), colX += column.attribute.width;
+        })), this.updateBorderSizeAndPosition(), this.isPivot || this.transpose || this.component.setFrozenColumnShadow(this.table.frozenColCount - 1), 
+        this.hasFrozen = !0, this.frozenColCount = this.table.rowHeaderLevelCount, this.frozenRowCount = null !== (_b = null === (_a = this.colHeaderGroup.firstChild) || void 0 === _a ? void 0 : _a.childrenCount) && void 0 !== _b ? _b : 0;
+    }
+    updateCellLayoutWidthCertainWidth(columnGroup, detaRow, col) {
+        const width = columnGroup.attribute.width;
+        let isUpdate = !1;
+        return columnGroup.forEachChildren(((cellGroup, row) => {
+            row += detaRow;
+            const mergeInfo = getCellMergeInfo(this.table, col, row);
+            mergeInfo ? cellGroup = this.getCell(mergeInfo.start.col, mergeInfo.start.row) : cellGroup.setAttribute("width", width);
+            const headerStyle = this.table._getCellStyle(col, row), padding = getPadding(getProp("padding", headerStyle, col, row, this.table)), text = cellGroup.getChildByName("text");
+            let oldCellHeight = 0, newCellHeight = 0;
+            if (text) oldCellHeight = text.AABBBounds.height() + (padding[0] + padding[2]), 
+            text.setAttribute("maxLineWidth", width - (padding[1] + padding[3])), newCellHeight = text.AABBBounds.height() + (padding[0] + padding[2]); else {
+                const group = cellGroup.getChildAt(1);
+                oldCellHeight = group.AABBBounds.height() + (padding[0] + padding[2]), group._cellWidth = width - (padding[1] + padding[3]), 
+                group.layout(), newCellHeight = group.AABBBounds.height() + (padding[0] + padding[2]);
+            }
+            const rowHeight = this.table.getRowHeight(row);
+            cellGroup.attribute.height !== newCellHeight && (cellGroup.setAttribute("height", newCellHeight), 
+            (rowHeight === oldCellHeight || newCellHeight > rowHeight) && (isUpdate = !0));
+        })), isUpdate;
+    }
+    updateHeaderPosition(colSource, rowSource, colTarget, rowTarget) {
+        moveHeaderPosition(colSource, rowSource, colTarget, rowTarget, this.table);
+    }
+    updateContainer() {
+        let cornerX = 0;
+        this.cornerHeaderGroup.forEachChildrenSkipChild(((column, index) => {
+            column.setAttribute("x", cornerX), cornerX += column.attribute.width;
+        }));
+        let rowHeaderX = 0;
+        this.rowHeaderGroup.forEachChildrenSkipChild(((column, index) => {
+            column.setAttribute("x", rowHeaderX), rowHeaderX += column.attribute.width;
+        }));
+        let colHeaderX = 0;
+        this.colHeaderGroup.forEachChildrenSkipChild(((column, index) => {
+            column.setAttribute("x", colHeaderX), colHeaderX += column.attribute.width;
+        }));
+        let bodyX = 0;
+        this.bodyGroup.forEachChildrenSkipChild(((column, index) => {
+            column.setAttribute("x", bodyX), bodyX += column.attribute.width;
+        })), this.cornerHeaderGroup.setDeltaWidth(cornerX - this.cornerHeaderGroup.attribute.width), 
+        this.colHeaderGroup.setDeltaWidth(colHeaderX - this.colHeaderGroup.attribute.width), 
+        this.rowHeaderGroup.setDeltaWidth(rowHeaderX - this.rowHeaderGroup.attribute.width), 
+        this.bodyGroup.setDeltaWidth(bodyX - this.bodyGroup.attribute.width), this.colHeaderGroup.setAttribute("x", this.cornerHeaderGroup.attribute.width), 
+        this.bodyGroup.setAttribute("x", this.rowHeaderGroup.attribute.width);
+        const oldHorizontalBarPos = this.table.stateManeger.scroll.horizontalBarPos, oldVerticalBarPos = this.table.stateManeger.scroll.verticalBarPos;
+        this.component.updateScrollBar(), this.table.stateManeger.setScrollLeft(oldHorizontalBarPos), 
+        this.table.stateManeger.setScrollTop(oldVerticalBarPos), this.updateNextFrame();
+    }
+    clearCells() {
+        this.clear = !0, this.hasFrozen = !1, this.colHeaderGroup.clear(), this.rowHeaderGroup.clear(), 
+        this.cornerHeaderGroup.clear(), this.bodyGroup.clear(), this.colHeaderGroup.setAttributes({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        }), this.rowHeaderGroup.setAttributes({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        }), this.cornerHeaderGroup.setAttributes({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        }), this.bodyGroup.setAttributes({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        }), this.tableGroup.setAttributes({
+            x: 0,
+            y: 0,
+            width: 0,
+            height: 0
+        }), this.tableGroup.border && (this.tableGroup.parent.removeChild(this.tableGroup.border), 
+        delete this.tableGroup.border);
+    }
+    updateCellContentWhileResize(col, row) {
+        const type = this.table.getBodyColumnType(col, row), cellGroup = this.getCell(col, row);
+        "image" !== type && "video" !== type || updateImageCellContentWhileResize(cellGroup, col, row, this.table);
+    }
+    createFrameBorder() {
+        this.updateTableSize();
+        const isListTableWithFrozen = !this.isPivot && this.rowHeaderGroup.attribute.width;
+        createFrameBorder(this.bodyGroup, this.table.theme.bodyStyle.frameStyle, this.bodyGroup.role, isListTableWithFrozen ? [ !0, !0, !0, !1 ] : void 0), 
+        createFrameBorder(this.rowHeaderGroup, this.isPivot ? this.table.theme.rowHeaderStyle.frameStyle : this.table.theme.bodyStyle.frameStyle, this.rowHeaderGroup.role, isListTableWithFrozen ? [ !0, !1, !0, !0 ] : void 0), 
+        createFrameBorder(this.colHeaderGroup, this.table.theme.headerStyle.frameStyle, this.colHeaderGroup.role, isListTableWithFrozen ? [ !0, !0, !0, !1 ] : void 0), 
+        createFrameBorder(this.cornerHeaderGroup, this.isPivot ? this.table.theme.cornerHeaderStyle.frameStyle : this.table.theme.headerStyle.frameStyle, this.cornerHeaderGroup.role, isListTableWithFrozen ? [ !0, !1, !0, !0 ] : void 0), 
+        createFrameBorder(this.tableGroup, this.table.theme.frameStyle, this.tableGroup.role);
+    }
+    getResizeColAt(abstractX, abstractY, cellGroup, offset = ResizeColumnHotSpotSize / 2) {
+        if (cellGroup) {
+            if (abstractX < cellGroup.globalAABBBounds.x1 + offset) return {
+                col: cellGroup.col - 1,
+                row: cellGroup.row,
+                x: cellGroup.globalAABBBounds.x1
+            };
+            if (cellGroup.globalAABBBounds.x2 - offset < abstractX) return {
+                col: cellGroup.col,
+                row: cellGroup.row,
+                x: cellGroup.globalAABBBounds.x2
+            };
+        } else ;
+        return {
+            col: -1,
+            row: -1
+        };
+    }
+    updateIcon(icon, iconConfig) {
+        dealWithIcon(iconConfig, icon), icon.name = iconConfig.name, this.updateNextFrame();
+    }
+    updateFrozen() {
+        this.clear || (this.resetFrozen(), this.dealFrozen(), this.component.updateScrollBar());
+    }
+    updateBorderSizeAndPosition() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        this.bodyGroup.border && (this.bodyGroup.appendChild(this.bodyGroup.border), null === (_a = this.bodyGroup.border) || void 0 === _a || _a.setAttribute("width", this.bodyGroup.attribute.width - (null !== (_b = this.bodyGroup.border.attribute.lineWidth) && void 0 !== _b ? _b : 0)), 
+        0 === this.rowHeaderGroup.attribute.width ? null === (_c = this.bodyGroup.border) || void 0 === _c || _c.setAttribute("stroke", [ !0, !0, !0, !0 ]) : null === (_d = this.bodyGroup.border) || void 0 === _d || _d.setAttribute("stroke", [ !0, !0, !0, !1 ])), 
+        this.colHeaderGroup.border && (this.colHeaderGroup.appendChild(this.colHeaderGroup.border), 
+        null === (_e = this.colHeaderGroup.border) || void 0 === _e || _e.setAttribute("width", this.colHeaderGroup.attribute.width - (null !== (_f = this.colHeaderGroup.border.attribute.lineWidth) && void 0 !== _f ? _f : 0)), 
+        0 === this.cornerHeaderGroup.attribute.width ? null === (_g = this.colHeaderGroup.border) || void 0 === _g || _g.setAttribute("stroke", [ !0, !0, !0, !0 ]) : null === (_h = this.colHeaderGroup.border) || void 0 === _h || _h.setAttribute("stroke", [ !0, !0, !0, !1 ])), 
+        this.rowHeaderGroup.border && (this.rowHeaderGroup.appendChild(this.rowHeaderGroup.border), 
+        null === (_j = this.rowHeaderGroup.border) || void 0 === _j || _j.setAttribute("width", this.rowHeaderGroup.attribute.width - (null !== (_k = this.rowHeaderGroup.border.attribute.lineWidth) && void 0 !== _k ? _k : 0))), 
+        this.cornerHeaderGroup.border && (this.cornerHeaderGroup.appendChild(this.cornerHeaderGroup.border), 
+        null === (_l = this.cornerHeaderGroup.border) || void 0 === _l || _l.setAttribute("width", this.cornerHeaderGroup.attribute.width - (null !== (_m = this.cornerHeaderGroup.border.attribute.lineWidth) && void 0 !== _m ? _m : 0)));
+    }
+    updateSortIcon(col, row, iconMark, order, oldSortCol, oldSortRow, oldIconMark) {
+        const icon = this.table.internalProps.headerHelper.getSortIcon(order, this.table, col, row);
+        if (iconMark && this.updateIcon(iconMark, icon), oldIconMark !== iconMark) {
+            const oldIcon = this.table.internalProps.headerHelper.getSortIcon(SortOrder.normal, this.table, oldSortCol, oldSortRow);
+            if (oldIconMark) this.updateIcon(oldIconMark, oldIcon); else {
+                let oldIconMark;
+                this.getCell(oldSortCol, oldSortRow).forEachChildren((mark => "sort" === mark.attribute.funcType && (oldIconMark = mark, 
+                !0))), oldIconMark && this.updateIcon(oldIconMark, oldIcon);
+            }
+        }
+    }
+    updateFrozenIcon(col, oldFrozenCol) {
+        const updateCol = Math.max(col, oldFrozenCol);
+        this.colHeaderGroup.forEachChildrenSkipChild((colGroup => !(colGroup.col <= updateCol) || (colGroup.forEachChildren((cellGroup => {
+            cellGroup.forEachChildren((icon => {
+                if ("pin" === icon.attribute.funcType) {
+                    const iconConfig = this.table.internalProps.headerHelper.getPinIcon(cellGroup.col, cellGroup.row);
+                    return this.updateIcon(icon, iconConfig), !0;
+                }
+                return !1;
+            }));
+        })), !1))), this.cornerHeaderGroup.forEachChildrenSkipChild((colGroup => !(colGroup.col <= updateCol) || (colGroup.forEachChildren((cellGroup => {
+            cellGroup.forEachChildren((icon => {
+                if ("pin" === icon.attribute.funcType) {
+                    const iconConfig = this.table.internalProps.headerHelper.getPinIcon(cellGroup.col, cellGroup.row);
+                    return this.updateIcon(icon, iconConfig), !0;
+                }
+                return !1;
+            }));
+        })), !1)));
+    }
+    sortCell() {
+        this.isPivot || (this.transpose ? setTimeout((() => {
+            this.clearCells(), this.createSceneGraph();
+        }), 10) : this.proxy.sortCell());
+    }
+    getCellOverflowText(col, row) {
+        const text = this.getCell(col, row).getChildByName("text", !0);
+        if (text) {
+            const textAttributeStr = text.attribute.text.join("");
+            let cacheStr = "";
+            if (text.cache.layoutData.lines.forEach((line => {
+                cacheStr += line.str;
+            })), cacheStr !== textAttributeStr) return textAttributeStr;
+        }
+        return null;
+    }
+    updateDrill(visible, x, y, drillDown, drillUp) {
+        this.component.drillIcon.update(visible, x, y, drillDown, drillUp, this);
+    }
+    updateCellContent(col, row) {
+        this.clear || updateCell(col, row, this.table);
+    }
+}
+
+function showIcon(scene, cellGroup, visibleTime) {
+    cellGroup.forEachChildren((child => {
+        "group" === child.type ? showIcon(scene, child, visibleTime) : child.attribute.visibleTime === visibleTime && (child.attribute.visible = !0, 
+        scene.updateNextFrame());
+    }));
+}
+
+function hideIcon(scene, cellGroup, visibleTime) {
+    cellGroup.forEachChildren((child => {
+        "group" === child.type ? hideIcon(scene, child, visibleTime) : child.attribute.visibleTime === visibleTime && (child.attribute.visible = !1, 
+        scene.updateNextFrame());
+    }));
+}
+//# sourceMappingURL=scenegraph.js.map