@hailin-zheng/editor-core 1.0.3 → 1.0.6

package/src/med_editor/framework/element-util.ts

@@ -1,1565 +0,0 @@
-import { nanoid } from "nanoid";
-import { EditorContext } from "./document-context";
-import {
-    BlockContainerElement,
-    BranchElement,
-    Element,
-    LeafElement,
-    Position,
-    Rect,
-    SelectionContentRange,
-    ViewOptions
-} from "./element-define";
-import { HitRegion } from "./element-event-define";
-import { DataEleBaseProps, TextProps } from "./element-props";
-import { CommsContainerElement } from "./impl/comments/comments-container-impl";
-import { DataDecorateElement } from "./impl/data-element/data-decorate-impl";
-import { DataElementInlineGroup, IsInSideDataElement } from "./impl/data-element/data-element-base-impl";
-import { DocumentBodyElement } from "./impl/document/doc-body-impl";
-import { DocumentFooterElement } from "./impl/document/doc-footer-impl";
-import { DocumentHeaderElement } from "./impl/document/doc-header-impl";
-import { DocumentRenderObject } from "./impl/document/doc-impl";
-import { ParagraphElement, ParagraphLineRectRenderObject, ParagraphRenderObject } from "./impl/paragraph/p-impl";
-import { PSymbolElement } from "./impl/symbol/p-symbol-impl";
-import { TableCellElement, TableCellRenderObject } from "./impl/table/table-cell-impl";
-import { TableElement, TableRenderObject } from "./impl/table/table-impl";
-import { TableRowElement, TableRowRenderObject } from "./impl/table/table-row-impl";
-import { TextGroupElement, TextGroupRenderObject } from "./impl/text/text-impl";
-import { TrackRunElement, TrackRunTypeEnum } from "./impl/text/track-run-impl";
-import {
-    BlockContainerRenderObject,
-    BlockContentRenderObject,
-    BorderType,
-    BranchRenderObject,
-    CursorType,
-    InlineGroupRenderObject,
-    LeafRenderObject,
-    RenderObject
-} from "./render-define";
-
-
-type PAIR = { x: number, y: number };
-
-export class ElementUtil {
-
-
-    static setCanvasProps(canvas: HTMLCanvasElement, ctx: CanvasRenderingContext2D, viewOptions: { width: number, height: number }, scale: number = 1): void {
-        // if (canvas instanceof OffscreenCanvas) {
-        //     this.setOffscreenCanvas(canvas, ctx as OffscreenCanvasRenderingContext2D, viewOptions, scale);
-        //     return
-        // }
-        const { width, height } = viewOptions;
-        let dpr = window.devicePixelRatio || 1;
-        if (scale > 1) {
-            dpr *= scale;
-        }
-        dpr = Math.ceil(dpr);
-        const scaleWidth = Math.floor(width * dpr) / dpr;
-        const scaleHeight = Math.floor(height * dpr) / dpr;
-        canvas.style.width = scaleWidth + 'px';
-        canvas.style.height = scaleHeight + 'px';
-        canvas.width = scaleWidth * dpr;
-        canvas.height = scaleHeight * dpr;
-        ctx.scale(dpr, dpr);
-    }
-
-    // static setOffscreenCanvas(canvas: OffscreenCanvas, ctx: OffscreenCanvasRenderingContext2D, viewOptions: { width: number, height: number }, scale: number = 1): void {
-
-    //     const { width, height } = viewOptions;
-    //     let dpr = window.devicePixelRatio || 1;
-    //     if (scale > 1) {
-    //         dpr *= scale;
-    //     }
-    //     dpr = Math.ceil(dpr);
-    //     const scaleWidth = Math.floor(width * dpr) / dpr;
-    //     const scaleHeight = Math.floor(height * dpr) / dpr;
-    //     canvas.width = scaleWidth * dpr;
-    //     canvas.height = scaleHeight * dpr;
-    //     ctx.scale(dpr, dpr);
-    // }
-
-    static getDprNumber(val: number, scale: number = 1): number {
-        let dpr = window.devicePixelRatio || 1;
-        if (scale > 1) {
-            dpr *= scale;
-        }
-        dpr = Math.ceil(dpr);
-        return Math.floor(val * dpr) / dpr
-    }
-
-    static readTextProps(dest: TextProps | null, props: TextProps | undefined, options: ViewOptions): TextProps {
-        if (!props) {
-            return this.createTextProps(dest, options);
-        }
-        const textProps = dest ?? new TextProps();
-        textProps.color = props.color || options.defaultColor;
-        textProps.fontName = props.fontName || options.defaultFontName;
-        textProps.fontSize = props.fontSize || options.defaultFontSize;
-        textProps.border = props.border;
-        if (props.fontWeight) {
-            textProps.fontWeight = props.fontWeight;
-        }
-        if (props.fontStyle) {
-            textProps.fontStyle = props.fontStyle;
-        }
-        if (props.underline) {
-            textProps.underline = props.underline;
-        }
-        if (props.linethrough) {
-            textProps.linethrough = props.linethrough;
-        }
-        if (props.overline) {
-            textProps.overline = props.overline;
-        }
-        if (props.background) {
-            textProps.background = props.background;
-        }
-        if (props.letterSpace) {
-            textProps.letterSpace = props.letterSpace;
-        }
-        if (props.vertAlign) {
-            textProps.vertAlign = props.vertAlign;
-        }
-        return textProps;
-    }
-
-    static readEleBaseProps(dest: DataEleBaseProps, props: DataEleBaseProps): DataEleBaseProps {
-        dest.id = props.id ?? nanoid(5);
-        dest.name = props.name;
-        dest.caption = props.caption;
-        dest.editable = props.editable ?? true;
-        dest.fieldName = props.fieldName;
-        dest.minLength = props.minLength;
-        dest.printable = props.printable ?? true;
-        dest.required = props.required;
-        dest.secretBrowse = props.secretBrowse;
-        dest.deleteable = props.deleteable;
-        dest.underline = props.underline;
-        dest.type = props.type;
-        return dest;
-    }
-
-    /**
-     * 获取内容区域最大高度
-     * @param render
-     * @param renderHeight
-     * @returns
-     */
-    static innerRectMaxHeight(render: RenderObject, renderHeight: number): number {
-        const { padding } = render;
-        return renderHeight - padding.top - padding.bottom;
-    }
-
-    /**
-     * 根据内框内容高度，更新外框框体高度
-     * @param render
-     * @param innerRect
-     */
-    static updateRenderHeightByInnerRect(render: RenderObject, innerRect: Rect): void {
-        const { padding, margin } = render;
-        //外层容器高度等于内容高度+外边距+内边距
-        render.rect.height = innerRect.height + margin.top + margin.bottom + padding.top + padding.bottom;
-    }
-
-    /**
-     * 设置块级元素限制尺寸
-     * @param render
-     * @param parentLimitRect
-     */
-    static setBlockElementLimitSize(render: BlockContainerRenderObject | BlockContentRenderObject, parentLimitRect: Rect): void {
-        render.rect.x = parentLimitRect.x;
-        render.rect.y = parentLimitRect.y + parentLimitRect.height;
-        render.rect.width = parentLimitRect.maxWidth ?? 0;
-        render.rect.maxWidth = parentLimitRect.maxWidth;
-        if (parentLimitRect.maxHeight) {
-            render.rect.maxHeight = parentLimitRect.maxHeight - parentLimitRect.height;
-        }
-    }
-
-    /**
-     * 克隆框体
-     * @param rect
-     * @returns
-     */
-    static cloneRect(rect: Rect): Rect {
-        const cloneRect = new Rect();
-        cloneRect.x = rect.x;
-        cloneRect.y = rect.y;
-        cloneRect.width = rect.width;
-        cloneRect.height = rect.height;
-        cloneRect.maxHeight = rect.maxHeight;
-        cloneRect.maxWidth = rect.maxWidth;
-        return cloneRect;
-    }
-
-    /**
-     * 重新限定子元素以及当前高度值,并返回内边框内容高度
-     * @param render
-     * @param resetX 测量段落外框时，内框不需要重置x，因为内框已经存在对齐
-     * @returns
-     */
-    static remeasure(render: BlockContainerRenderObject | BlockContentRenderObject, resetX = true): number {
-        if (render.rect.width === 0) {
-            return -1;
-        }
-        if (render instanceof TableRowRenderObject) {
-            return this.remeasureTableRow(render);
-        }
-        if (render instanceof TableRenderObject) {
-            this.remeasureTableMerge(render);
-        }
-        const innerRect = render.getInnnerRect();
-        for (let i = 0; i < render.length; i++) {
-            const line = render.getChild(i);
-            if (resetX) {
-                line.rect.x = innerRect.x;
-            }
-            line.rect.y = innerRect.height + innerRect.y + line.margin.top;
-            line.rect.maxWidth = innerRect.maxWidth;
-            innerRect.height += line.rect.height + line.margin.top + line.margin.bottom;
-        }
-        render.updateRenderHeight(innerRect);
-        return innerRect.height;
-    }
-
-    static remeasureTableRow(rowRender: TableRowRenderObject, foreceColIndex = -1): number {
-        const rowEle = rowRender.element as TableRowElement;
-        const rowMinHeight = rowEle.props.minHeight > 19 ? rowEle.props.minHeight : 19;
-        let maxCellheight = rowMinHeight;
-        //限制行最小高度
-        maxCellheight = maxCellheight < 19 ? 19 : maxCellheight;
-        //获取行内非纵向合并单元格的最高单元格高度
-        for (let i = 0; i < rowRender.length; i++) {
-            const cellRender = rowRender.getChild(i);
-            const { vMerge } = (<TableCellElement>cellRender.element).props;
-            if (cellRender.rect.height > maxCellheight && (vMerge !== 'restart' || i === foreceColIndex)) {
-                maxCellheight = cellRender.rect.height;
-            }
-        }
-        //循环设置单元格高度为行内最大单元格高度
-        for (let i = 0; i < rowRender.length; i++) {
-            const cellRender = rowRender.getChild(i) as TableCellRenderObject;
-            const cellElement = <TableCellElement>cellRender.element;
-            const { vMerge } = cellElement.props;
-            if ((vMerge !== 'restart' || i === foreceColIndex) || cellRender.rect.height < maxCellheight) {
-                cellRender.rect.height = maxCellheight;
-            }
-            //处理单元格内容纵向居中
-            this.measureCellVAlign(cellRender);
-        }
-        //设置行高
-        rowRender.updateRenderHeight(maxCellheight);
-        return maxCellheight;
-    }
-
-    /**
-     * 获取表格行绘制元素的内容高度，用于缩放行高度时，获取最小内容高度，缩放的高度不能小于内容最小高度
-     */
-    static getTableRowRenderContentHeight(rowRender: TableRowRenderObject): number {
-        const rowEle = rowRender.element as TableRowElement;
-        let maxCellheight = 19;
-        //限制行最小高度
-        //获取行内非纵向合并单元格的最高单元格高度
-        for (let i = 0; i < rowRender.length; i++) {
-            const cellRender = rowRender.getChild(i) as TableCellRenderObject;
-            const cellContentHeight = this.getTableCellRenderContentHeight(cellRender);
-            const { vMerge } = (<TableCellElement>cellRender.element).props;
-            if (cellContentHeight > maxCellheight && vMerge !== 'restart') {
-                maxCellheight = cellContentHeight;
-            }
-        }
-        return maxCellheight;
-    }
-
-    /**
-     * 获取单元格内容高度
-     * 单元格暂不处理上下margin、padding
-     * @param cellRender
-     * @returns
-     */
-    static getTableCellRenderContentHeight(cellRender: TableCellRenderObject): number {
-        let contentHeight = 0;
-        for (let i = 0; i < cellRender.length; i++) {
-            contentHeight += cellRender.getChild(i).rect.height;
-        }
-        return contentHeight;
-    }
-
-    /**
-     * 处理单元格内容纵向对齐
-     * @param render
-     */
-    private static measureCellVAlign(render: TableCellRenderObject): void {
-        const tcElement = render.element as TableCellElement;
-        const { vAlign } = tcElement.props;
-        if (!vAlign || vAlign === 'top') {
-            return;
-        }
-        let sumHeight = 0;
-        for (let i = 0; i < render.length; i++) {
-            sumHeight += render.getChild(i).rect.height;
-        }
-        let spaceHeight = 0;
-        spaceHeight = vAlign === 'middle' ? Math.floor((render.rect.height - sumHeight) / 2) : vAlign === 'bottom' ? render.rect.height - sumHeight : 0
-        if (spaceHeight <= 0) {
-            return;
-        }
-        let y = spaceHeight;
-        for (let i = 0; i < render.length; i++) {
-            render.getChild(i).rect.y = y;
-            y += render.getChild(i).rect.height;
-        }
-    }
-
-    /**
-     * 重新测量合并单元格高度
-     * @param tbRender
-     * @returns
-     */
-    static remeasureTableMerge(tbRender: TableRenderObject): void {
-        //是否需要重新计算,主要解决：之前合并计算的列，可能会被后面合并计算的列所影响，需要再次重新计算测量
-        let needReCalc = false;
-        for (let i = 0; i < tbRender.length; i++) {
-            const row = tbRender.getChild(i) as TableRowRenderObject;
-            for (let j = 0; j < row.length; j++) {
-                const cellRender = row.getChild(j) as TableCellRenderObject;
-                const ele = cellRender.element as TableCellElement;
-                const { vMerge } = ele.props;
-                if (vMerge === 'restart') {
-                    const eleIndex = ele.getIndex();
-                    const continueRows = this.getContinueVMergeRenderRows(tbRender, i, eleIndex);
-                    if (!continueRows.length) {
-                        //向下不存在合并的单元格，当前合并的单元格是被cut过来的，并且当前单元格高度高于行内高度需要remeasure当前行
-                        if (cellRender.rect.height > row.rect.height) {
-                            this.remeasureTableRow(row, j);
-                            needReCalc = true;
-                        }
-                        continue;
-                    }
-                    const continueCellHeight = continueRows.reduce((prev, curr) => prev + curr.rect.height, 0)
-                    const overflowHeight = cellRender.rect.height - row.rect.height - continueCellHeight;
-                    //溢出的高度加到最后一个合并单元格中
-                    if (overflowHeight > 0) {
-                        const lastRow = continueRows[continueRows.length - 1];
-                        lastRow.rect.height += overflowHeight;
-                        this.resizeCellToFillRow(lastRow);
-                        needReCalc = true;
-                    } else {
-                        cellRender.rect.height = row.rect.height + continueCellHeight;
-                    }
-                }
-            }
-        }
-        if (needReCalc) {
-            this.remeasureTableMerge(tbRender);
-            return;
-        }
-    }
-
-    /**
-     * 获取向下纵向合并的行
-     * @param render
-     * @param rowIndex
-     * @param colIndex
-     * @returns
-     */
-    private static getContinueVMergeRenderRows(render: TableRenderObject, rowIndex: number, colIndex: number): TableRowRenderObject[] {
-        const rows: Array<TableRowRenderObject> = [];
-        for (let i = rowIndex + 1; i < render.length; i++) {
-            const rowRender = render.getChild(i) as TableRowRenderObject;
-            const rowEle = rowRender.element as TableRowElement;
-            const ele = rowEle.getChild(colIndex) as TableCellElement;
-            const { vMerge } = ele.props;
-            if (vMerge !== 'continue') {
-                break;
-            }
-            rows.push(rowRender);
-        }
-        return rows;
-    }
-
-    /**
-     * 根据横向当前被合并的单元格
-     * @param tb
-     * @param rowIndex
-     * @param colIndex
-     */
-    static getHorizontalRestartCellIndex(tb: TableElement, rowIndex: number, colIndex: number): number {
-        const row = tb.getChild(rowIndex) as TableRowElement;
-        for (let i = colIndex - 1; i >= 0; i--) {
-            const cell = row.getChild(i) as TableCellElement;
-            if (cell.props.hMerge === 'restart') {
-                return i;
-            }
-        }
-        throw new Error('未找到主合并单元格');
-    }
-
-    /**
-     * 根据横向当前被合并的单元格
-     * @param tb
-     * @param rowIndex
-     * @param colIndex
-     */
-    static getVerticalRestartCellIndex(tb: TableElement, rowIndex: number, colIndex: number): number {
-        for (let i = rowIndex - 1; i >= 0; i--) {
-            const row = tb.getChild(i) as TableRowElement;
-            const cell = row.getChild(colIndex) as TableCellElement;
-            if (cell.props.vMerge === 'restart') {
-                return i;
-            }
-        }
-        throw new Error('未找到横向当前被合并的单元格')
-    }
-
-    /**
-     * 获取合并单元格主单元格
-     * @param tb
-     * @param rowIndex
-     * @param colIndex
-     * @returns
-     */
-    static getRestartCellPosition(tb: TableElement, rowIndex: number, colIndex: number): { rowIndex: number, colIndex: number } {
-        const row = tb.getChild(rowIndex) as TableRowElement;
-        const cell = row.getChild(colIndex) as TableCellElement;
-        if (cell.props.hMerge === 'continue') {
-            const restartCellIndex = this.getHorizontalRestartCellIndex(tb, rowIndex, colIndex);
-            return this.getRestartCellPosition(tb, rowIndex, restartCellIndex);
-        }
-        if (cell.props.vMerge === 'continue') {
-            const restartRowIndex = this.getVerticalRestartCellIndex(tb, rowIndex, colIndex);
-            return this.getRestartCellPosition(tb, restartRowIndex, colIndex);
-        }
-        return { rowIndex, colIndex }
-    }
-
-    /**
-     * 调整单元格高度填满整个行的高度
-     */
-    private static resizeCellToFillRow(row: TableRowRenderObject): void {
-        for (let i = 0; i < row.length; i++) {
-            const cell = row.getChild(i);
-            cell.rect.height = row.rect.height;
-        }
-    }
-
-
-    /**
-     * 获取元素的全局索引位置
-     * @param control
-     * @returns
-     */
-    static getControlIndex(control: Element): number {
-        const parent = control.parent;
-        if (parent) {
-            const index = control.getIndex();
-            let counter = 1;
-            for (let i = 0; i < index; i++) {
-                const child = parent.getChild(i);
-                counter += child.getSelfLength();
-            }
-            return counter + this.getControlIndex(parent);
-        } else {
-            return 0;
-        }
-    }
-
-    /**
-     * 根据全局索引位置获取元素
-     * @param control
-     * @param counter
-     * @returns
-     */
-    static getControlByIndex(control: Element, counter: { currIndex: number, index: number }): Element | null {
-        counter.currIndex++;
-        if (counter.currIndex === counter.index) {
-            return control;
-        }
-        if (control instanceof LeafElement) {
-            return null;
-        } else if (control instanceof BranchElement) {
-            for (let i = 0; i < control.length; i++) {
-                const res = this.getControlByIndex(control.getChild(i), counter);
-                if (res) {
-                    return res;
-                }
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 获取同级紧挨前方的兄弟元素
-     * @param element
-     * @returns
-     */
-    static getPrevSiblingElement(element: Element): Element | null {
-        const parent = element.parent;
-        if (!parent) {
-            return null;
-        }
-        if (parent) {
-            const index = parent.getChildIndex(element);
-            if (index > 0) {
-                return parent.getChild(index - 1);
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 获取同级紧挨下方的元素
-     * @param element
-     * @returns
-     */
-    static getNextSiblingElement(element: Element): Element | null {
-        const parent = element.parent;
-        if (!parent) {
-            return null;
-        }
-        if (parent) {
-            const index = parent.getChildIndex(element);
-            if (index < parent.length - 1) {
-                return parent.getChild(index + 1)
-            }
-        }
-        return null;
-    }
-
-    static getNextSiblingTrackElement(element: Element, type: TrackRunTypeEnum, userId: string): TrackRunElement | null {
-        const nextSiblingEle = this.getNextSiblingElement(element);
-        if (nextSiblingEle instanceof TrackRunElement) {
-            if (nextSiblingEle.type === type && nextSiblingEle.props.userId === userId) {
-                return nextSiblingEle;
-            }
-        }
-        return null;
-    }
-
-    static getPrevSiblingTrackElement(element: Element, type: TrackRunTypeEnum, userId: string): TrackRunElement | null {
-        const prevSiblingEle = this.getPrevSiblingElement(element);
-        if (prevSiblingEle instanceof TrackRunElement) {
-            if (prevSiblingEle.type === type && prevSiblingEle.props.userId === userId) {
-                return prevSiblingEle;
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 根据默认配置创建长文本
-     * @param viewOptions
-     * @returns
-     */
-    static getNewTextGroup(textProps: TextProps): TextGroupElement {
-        const text = new TextGroupElement()
-        textProps.clone(text.props);
-        return text;
-    }
-
-    static createTextProps(dest: TextProps | null, viewOptions: ViewOptions): TextProps {
-        const textProps = dest ?? new TextProps();
-        textProps.fontSize = viewOptions.defaultFontSize;
-        textProps.fontName = viewOptions.defaultFontName;
-        textProps.color = viewOptions.defaultColor;
-        return textProps;
-    }
-
-    /**
-     * 获取容器内的最小渲染元素集合
-     * @param parPos
-     * @param array
-     */
-    static getAvailHitLeafRenderObjects(render: RenderObject, parPos: Position): Array<{ render: LeafRenderObject, rect: Rect }> {
-        if (!this.checkAvailHitRender(render)) {
-            return [];
-        }
-        const renderObjectRect: Rect = {
-            x: parPos.x + render.rect.x,
-            y: parPos.y + render.rect.y,
-            width: render.rect.width,
-            height: render.rect.height,
-            maxWidth: 0,
-            maxHeight: 0
-        };
-        const array: Array<{ render: LeafRenderObject, rect: Rect }> = [];
-        if (render instanceof BranchRenderObject) {
-            for (let i = 0; i < render.length; i++) {
-                const child = render.getChild(i);
-                array.push(...this.getAvailHitLeafRenderObjects(child, { x: renderObjectRect.x, y: renderObjectRect.y }));
-            }
-        } else if (render instanceof LeafRenderObject) {
-            array.push({ render: render, rect: renderObjectRect });
-        } else {
-            throw new Error('未实现');
-        }
-        return array;
-    }
-
-    /**
-     * 获取容器内的最小渲染元素集合
-     * @param parPos
-     * @param array
-     */
-    static getAvailHitRenderObjects(render: RenderObject, parPos: Position): Array<{ render: RenderObject, rect: Rect }> {
-        if (!this.checkAvailHitRender(render)) {
-            return [];
-        }
-        const renderObjectRect: Rect = this.getRenderObjectAbsoluteRect(render, parPos);
-        const array: Array<{ render: RenderObject, rect: Rect }> = [];
-        if (render instanceof BranchRenderObject) {
-            for (let i = 0; i < render.length; i++) {
-                const child = render.getChild(i);
-                if (this.checkAvailHitRender(child)) {
-                    array.push({ render: child, rect: this.getRenderObjectAbsoluteRect(child, renderObjectRect) })
-
-                }
-            }
-        } else if (render instanceof LeafRenderObject) {
-            array.push({ render: render, rect: renderObjectRect });
-        } else {
-            throw new Error('未实现');
-        }
-        return array;
-    }
-
-    /**
-     * 获取绘制元素的绝对位置框
-     */
-    static getRenderObjectAbsoluteRect(render: RenderObject, parPos: Position): Rect {
-        const renderObjectRect: Rect = {
-            x: parPos.x + render.rect.x,
-            y: parPos.y + render.rect.y,
-            width: render.rect.width,
-            height: render.rect.height,
-            maxWidth: 0,
-            maxHeight: 0
-        };
-        return renderObjectRect;
-    }
-
-
-    /**
-     * 检查当前绘制元素是否属于有效点击元素
-     */
-    static checkAvailHitRender(render: RenderObject): boolean {
-        if (render.element && render.element.disableClick) {
-            return false;
-        }
-        if (render instanceof TableRowRenderObject) {
-            const rowEle = render.element as TableRowElement;
-            if (rowEle.props.headerRow) {
-                return rowEle.paintRenders.indexOf(render) === 0;
-            }
-        }
-        return !render.disableClick;
-    }
-
-    /**
-     * 验证点击可操作性
-     * 主要限制页眉页脚的编辑模式
-     */
-    static verifyHitable(sourceElement: LeafElement | null | undefined): boolean {
-        if (!sourceElement) {
-            return false;
-        }
-        const parents = ElementUtil.getParentElements(sourceElement);
-        for (let i = parents.length - 1; i >= 0; i--) {
-            const child = parents[i];
-            if (child.disableClick) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * 获取一个点到一个矩形最短的距离
-     * @param rect
-     * @param p
-     * @returns
-     */
-    static getDistanceToRect(rect: Rect, p: Position) {
-        const lines: Array<{ f: PAIR, s: PAIR }> = [];
-        lines.push({
-            f: {
-                x: rect.x,
-                y: rect.y
-            },
-            s: {
-                x: rect.x + rect.width,
-                y: rect.y
-            }
-        }, {
-            f: {
-                x: rect.x,
-                y: rect.y
-            },
-            s: {
-                x: rect.x,
-                y: rect.y + rect.height
-            }
-        }, {
-            f: {
-                x: rect.x,
-                y: rect.y + rect.height
-            },
-            s: {
-                x: rect.x + rect.width,
-                y: rect.y + rect.height
-            }
-        }, {
-            f: {
-                x: rect.x + rect.width,
-                y: rect.y
-            },
-            s: {
-                x: rect.x + rect.width,
-                y: rect.y + rect.height
-            }
-        })
-        const distances = lines.map(item => this.minDistance(item.f, item.s, p))
-        return Math.min(...distances);
-    }
-
-    static minDistance(A: PAIR, B: PAIR, E: PAIR) {
-
-        const AB: PAIR = { x: B.x - A.x, y: B.y - A.y }
-
-        const BE: PAIR = { x: E.x - B.x, y: E.y - B.y };
-
-        const AE: PAIR = { x: E.x - A.x, y: E.y - A.y }
-
-        const AB_BE = (AB.x * BE.x + AB.y * BE.y);
-        const AB_AE = (AB.x * AE.x + AB.y * AE.y);
-
-        let reqAns = 0;
-
-        if (AB_BE > 0) {
-            const y = E.y - B.y;
-            const x = E.x - B.x;
-            reqAns = Math.sqrt(x * x + y * y);
-        } else if (AB_AE < 0) {
-            const y = E.y - A.y;
-            const x = E.x - A.x;
-            reqAns = Math.sqrt(x * x + y * y);
-        } else {
-            const x1 = AB.x;
-            const y1 = AB.y;
-            const x2 = AE.x;
-            const y2 = AE.y;
-            const mod = Math.sqrt(x1 * x1 + y1 * y1);
-            reqAns = Math.abs(x1 * y2 - y1 * x2) / mod;
-        }
-        return reqAns;
-    }
-
-    /**
-     * 获取父级层级渲染对象
-     * @param render
-     * @returns
-     */
-    static getParentRenders(render: RenderObject): Array<RenderObject> {
-        if (render) {
-            return [render, ...this.getParentRenders(render.parent)];
-        } else {
-            return [];
-        }
-    }
-
-    static getRenderMapElements(render: RenderObject): Array<Element> {
-        const renders = this.getParentRenders(render);
-        return renders.map(render => render.element).filter(ele => ele);
-    }
-
-    static getParentRender<T extends BranchRenderObject>(child: RenderObject, parentType: { new(...args: any): T }): T | null {
-        if (!child) {
-            return null;
-        }
-        if (child instanceof parentType) {
-            return child;
-        } else {
-            return this.getParentRender(child.parent, parentType);
-        }
-    }
-
-    static getParentRenderByPredicate(child: RenderObject, predicate: (item: RenderObject) => boolean): RenderObject | null {
-        if (!child) {
-            return null;
-        }
-        if (predicate(child)) {
-            return child;
-        } else {
-            return this.getParentRenderByPredicate(child.parent, predicate);
-        }
-    }
-
-    /**
-     * 获取父级层级元素对象
-     * @param element
-     * @returns
-     */
-    static getParentElements(element: Element | null | undefined): Array<Element> {
-        if (element) {
-            return [element, ...this.getParentElements(element.parent)];
-        } else {
-            return [];
-        }
-    }
-
-    /**
-     * 获取最后一个子元素
-     * @param element
-     * @returns
-     */
-    static getLastLeafElement(element: Element, predicate: null | ((item: Element) => boolean) = null): LeafElement | null {
-        if (element instanceof LeafElement && (!predicate || predicate(element))) {
-            return element;
-        } else if (element instanceof BranchElement) {
-            for (let i = element.length - 1; i >= 0; i--) {
-                const res = this.getLastLeafElement(element.getChild(i), predicate)
-                if (res) {
-                    return res;
-                }
-            }
-            return null;
-        }
-        return null;
-    }
-
-
-    /**
-     * 获取第一个子元素
-     * @param element
-     * @returns
-     */
-    static getFirstLeafElement(element: Element): LeafElement | null {
-        if (element instanceof LeafElement) {
-            return element;
-        } else if (element instanceof BranchElement) {
-            for (let i = 0; i < element.length; i++) {
-                const res = this.getFirstLeafElement(element.getChild(i));
-                if (res) {
-                    return res;
-                }
-            }
-            return null;
-        }
-        return null;
-    }
-
-    /**
-     * 校验两个元素是否在同一个段落中
-     * @param element1
-     * @param element2
-     */
-    static isInSameParagraph(element1: Element, element2: Element): boolean {
-        const par1 = this.getParentByType(element1, ParagraphElement);
-        const par2 = this.getParentByType(element2, ParagraphElement);
-        return par1 === par2;
-    }
-
-    static getBorderCursor(borderType: BorderType): CursorType {
-        switch (borderType) {
-            case 'none':
-                return 'text';
-            case 'top':
-                return 'row-resize';
-            case 'left':
-                return 'col-resize';
-            case 'right':
-                return 'col-resize';
-            case 'bottom':
-                return 'row-resize'
-            case 'left-middle':
-            case 'right-middle':
-                return 'w-resize';
-            case 'top-middle':
-            case 'bottom-middle':
-                return 's-resize';
-            case 'left-top':
-            case 'right-bottom':
-                return 'se-resize';
-            case 'right-top':
-            case 'left-bottom':
-                return 'ne-resize';
-            default:
-                return 'text';
-        }
-    }
-
-    static getParentByType<P extends Element, T>(child: P | null, parentType: { new(...args: any): T }): T | null {
-        if (!child) {
-            return null;
-        }
-        if (child instanceof parentType) {
-            return child;
-        } else {
-            return this.getParentByType(child.parent, parentType);
-        }
-    }
-
-    static getParent(child: Element | null, predicate: (item: Element) => boolean): Element | null {
-        if (!child) {
-            return null;
-        }
-        if (predicate(child)) {
-            return child;
-        } else {
-            return this.getParent(child.parent, predicate);
-        }
-    }
-
-
-    /**
-     * 修正段落内容
-     * @returns
-     */
-    static fixParagraphContent(control: ParagraphElement): void {
-        //如果最后一个元素不是段落符号，则补足
-        if (!(control.getChild(control.length - 1) instanceof PSymbolElement)) {
-            control.addChild(new PSymbolElement());
-        }
-        const items: Array<PSymbolElement> = [];
-        for (let i = 0; i < control.length - 1; i++) {
-            const child = control.getChild(i);
-            if (child instanceof PSymbolElement) {
-                items.push(child);
-            }
-        }
-        items.forEach(item => {
-            control.removeChild(item)
-        });
-    }
-
-    /**
-     * 修正块级容器内容
-     * @param control
-     */
-    static fixBlockContainer(control: BlockContainerElement): void {
-        if (control.length === 0) {
-            if (control instanceof TableCellElement && (control.props.vMerge === 'continue' || control.props.hMerge === 'continue')) {
-                return;
-            }
-            if (control.noFillEmpty) {
-                return;
-            }
-            control.addChild(new ParagraphElement());
-        }
-    }
-
-
-    /**
-     * 获取绘制元素相对于整个画布的绝对位置
-     * 整个画布绘制的时候不一定从x=0,y=0时绘制的，下拉滚动时，上面从负y坐标开始绘制
-     * 如果计算某个元素相对画布的左上角的绝对坐标位置，需要childPos的y值减去translateY
-     * @param render
-     * @param refPos 参照位置
-     * @returns
-     */
-    static getRenderAbsolutePaintPos(render: RenderObject, refPos: Position | null = null): Position {
-        refPos = refPos ?? { x: 0, y: 0 };
-        const currPos: Position = { x: render.rect.x + refPos.x, y: render.rect.y + refPos.y };
-        if (!render.parent) {
-            return currPos;
-        }
-        return this.getRenderAbsolutePaintPos(render.parent, currPos);
-    }
-
-    static getRenderAbsolutePaintRect(render: RenderObject, childPos: Position | null = null): Rect {
-        const pos = this.getRenderAbsolutePaintPos(render, childPos);
-        return { ...pos, width: render.rect.width, height: render.rect.height, maxWidth: 0, maxHeight: 0 };
-    }
-
-
-
-
-
-    /**
-     * 获取选中区域的开始区域
-     * @param range
-     * @returns
-     */
-    static getFirstSelectedRange(range: SelectionContentRange): SelectionContentRange {
-        if (range.selectedChildren.length === 0 || range.target instanceof TextGroupElement) {
-            return range;
-        } else {
-            return this.getFirstSelectedRange(range.selectedChildren[0]);
-        }
-    }
-
-    /**
-     * 获取选中区域的开始区域
-     * @param range \
-     * @returns
-     */
-    static getLastSelectedRange(range: SelectionContentRange): SelectionContentRange {
-        if (range.selectedChildren.length === 0 || range.target instanceof TextGroupElement) {
-            return range;
-        } else {
-            return this.getLastSelectedRange(range.selectedChildren[range.selectedChildren.length - 1]);
-        }
-    }
-
-
-    /**
-     * 克隆选区内容
-     * @param range
-     * @param isDelete
-     * @returns
-     */
-    static cloneRange(range: SelectionContentRange, isDelete: boolean, cloneMode: 'clone' | 'source' | 'copy' = 'clone'): Element | null {
-        const { target, isFullSelected, startOffset, endOffset, selectedChildren } = range;
-        if (isFullSelected) {
-            //修饰元素不能复制 审阅标记、数据元NullText
-            if (cloneMode === 'copy' && target.isDecorate) {
-                return null;
-            }
-            const clone = cloneMode === 'source' ? target : target.clone(true);
-            if (isDelete) {
-                target.remove();
-            }
-            return clone;
-        } else {
-            if (target instanceof LeafElement) {
-                if (target instanceof TextGroupElement && startOffset !== endOffset) {
-                    if (isDelete) {
-                        const copyTarget = target.spliceText(startOffset, endOffset, true);
-                        if (target.text.length === 0) {
-                            target.remove();
-                        }
-                        return copyTarget;
-                    } else {
-                        const copyTarget = target.spliceText(startOffset, endOffset, false);
-                        return copyTarget;
-                    }
-                }
-                return null;
-            } else if (target instanceof BranchElement) {
-                const array: Array<Element> = [];
-                for (let i = 0; i < selectedChildren.length; i++) {
-                    const copyChild = this.cloneRange(selectedChildren[i], isDelete, cloneMode);
-                    if (copyChild) {
-                        array.push(copyChild);
-                    }
-                }
-                if (!array.length) {
-                    return null;
-                } else {
-                    const copyTarget = target.clone(false) as BranchElement;
-                    array.forEach(item => {
-                        copyTarget.addChild(item)
-                    });
-                    return copyTarget;
-                }
-            }
-        }
-        return null;
-    }
-
-    /**
-     * 获取所有的子级元素
-     * @param branchEle
-     * @returns
-     */
-    static getChildrenElements(branchEle: BranchElement): Array<Element> {
-        const array = [];
-        for (let i = 0; i < branchEle.length; i++) {
-            array.push(branchEle.getChild(i));
-        }
-        return array;
-    }
-
-    /**
-     * 递归向前寻找最近的元素
-     * @param currElement
-     * @param inPara  是否在同一段落中寻找
-     * @param forCursor 查找结果是否用于光标定位
-     * @returns
-     */
-    static getRecursionPrevSiblingElement(currElement: Element | null, inPara: boolean = false, forCursor: boolean = false): LeafElement | null {
-        const parent = currElement?.parent;
-        //删除留痕块的measureRender在不显示留痕模式下，不生成render
-        if (!currElement || !parent || (!currElement.measureRender && !(currElement instanceof TrackRunElement))) {
-            return null;
-        }
-        //如果当前数据元不可编辑，则直接跳过
-        if (parent instanceof DataElementInlineGroup && !parent.props.editable) {
-            return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
-        }
-        if (forCursor && parent.disableClick) {
-            return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
-        }
-        const index = parent.getChildIndex(currElement);
-        if (!index) {
-            if (inPara && parent.type === 'p') {
-                return null;
-            }
-            return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
-        } else {
-            let prevElement: Element | null = null;
-            for (let i = index - 1; i >= 0; i--) {
-                prevElement = parent.getChild(i);
-                if (prevElement && !prevElement.disableClick) {
-                    break;
-                }
-            }
-            if (!prevElement || prevElement.disableClick) {
-                return this.getRecursionPrevSiblingElement(parent, inPara, forCursor);
-            }
-            const lastLeafElement = ElementUtil.getLastLeafElement(prevElement);
-            //用于光标定位
-            if (forCursor && lastLeafElement && lastLeafElement.disableClick) {
-                return this.getRecursionPrevSiblingElement(lastLeafElement, inPara, forCursor);
-            }
-            if (lastLeafElement) {
-                return lastLeafElement;
-            } else {
-                return this.getRecursionPrevSiblingElement(prevElement.parent, inPara, forCursor);
-            }
-        }
-    }
-
-
-    /**
-     * 循环向前寻找可定位的数据元
-     * @param currElement 
-     */
-    static getPrevDataElement(ctx: EditorContext, currElement: DataElementInlineGroup): DataElementInlineGroup | null {
-        const dataEle = ctx.getCurrentCtx(currElement).getControlInstanceList().filter(item => item instanceof DataElementInlineGroup) as Array<DataElementInlineGroup>;
-        const index = dataEle.indexOf(currElement);
-        if (index > 0) {
-            for (let i = index - 1; i >= 0; i--) {
-                if (!dataEle[i].disableClick && dataEle[i].props.editable) {
-                    return dataEle[i];
-                }
-            }
-        }
-        return null;
-    }
-
-    // /**
-    // * 递归向前寻找最近的可点击元素
-    // */
-    // static getRecursionPrevSiblingElementForHit(currElement: Element | null): LeafElement | null {
-    //     let ele: LeafElement | null = null;
-    //     do {
-    //         ele = this.getRecursionPrevSiblingElement(currElement);
-    //     } while (ele && ele.disableClick)
-    //     return ele;
-    // }
-
-    // /**
-    // * 在同一段落中，递归向前寻找最近的元素
-    // */
-    // static getRecursionPrevSiblingElementInPara(currElement: Element | null): LeafElement | null {
-    //     const parent = currElement?.parent;
-    //     if (!currElement || !parent) {
-    //         return null;
-    //     }
-    //     const index = parent.getChildIndex(currElement);
-    //     if (!index) {
-    //         if (parent.type === 'p') {
-    //             return null;
-    //         }
-    //         return this.getRecursionPrevSiblingElementInPara(parent);
-    //     } else {
-    //         const prevElement = parent.getChild(index - 1);
-    //         const lastLeafElement = ElementUtil.getLastLeafElement(prevElement);
-    //         if (lastLeafElement) {
-    //             return lastLeafElement;
-    //         } else {
-    //             return this.getRecursionPrevSiblingElementInPara(prevElement?.parent);
-    //         }
-    //     }
-    // }
-
-    // /**
-    // * 在同一段落中，递归向前寻找最近的可点击元素
-    // */
-    // static getRecursionPrevSiblingElementInParaForHit(currElement: Element | null): LeafElement | null {
-    //     let ele: LeafElement | null = null;
-    //     do {
-    //         ele = this.getRecursionPrevSiblingElementInPara(currElement);
-    //     } while (ele && ele.disableClick)
-    //     return ele;
-    // }
-
-
-    /**
-     * 递归向后寻找最近的元素
-     */
-    static getRecursionNextSiblingElement(currElement: Element | null, inPara: boolean = false, forCursor: boolean = false): LeafElement | null {
-        const parent = currElement?.parent;
-        if (!currElement || !parent || !currElement.measureRender) {
-            return null;
-        }
-        //如果当前数据元不可编辑，则直接跳过
-        if (parent instanceof DataElementInlineGroup && !parent.props.editable) {
-            return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
-        }
-        if (forCursor && parent.disableClick) {
-            return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
-        }
-        const index = parent.getChildIndex(currElement);
-        if (index === parent.length - 1) {
-            if (inPara && parent.type === 'p') {
-                return null;
-            }
-            return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
-        } else {
-            let nextElement: Element | null = null;
-            for (let i = index + 1; i < parent.length; i++) {
-                nextElement = parent.getChild(i);
-                if (nextElement && !nextElement.disableClick) {
-                    break;
-                }
-            }
-            if (!nextElement || nextElement.disableClick) {
-                return this.getRecursionNextSiblingElement(parent, inPara, forCursor);
-            }
-            const lastLeafElement = ElementUtil.getFirstLeafElement(nextElement);
-            //用于光标定位
-            if (forCursor && lastLeafElement && lastLeafElement.disableClick) {
-                return this.getRecursionNextSiblingElement(lastLeafElement, inPara, forCursor);
-            }
-            if (lastLeafElement) {
-                return lastLeafElement;
-            } else {
-                return this.getRecursionNextSiblingElement(nextElement.parent, inPara, forCursor);
-            }
-        }
-    }
-
-
-    // /**
-    // * 在同一段落中，递归向后寻找最近的元素
-    // */
-    // static getRecursionNextSiblingElementInPara(currElement: Element | null): LeafElement | null {
-    //     const parent = currElement?.parent;
-    //     if (!currElement || !parent) {
-    //         return null;
-    //     }
-    //     const index = parent.getChildIndex(currElement);
-    //     if (index === parent.length - 1) {
-    //         if (parent.type === 'p') {
-    //             return null;
-    //         }
-    //         return this.getRecursionNextSiblingElementInPara(parent);
-    //     } else {
-    //         const nextElement = parent.getChild(index + 1);
-    //         const lastLeafElement = ElementUtil.getFirstLeafElement(nextElement);
-    //         if (lastLeafElement) {
-    //             return lastLeafElement;
-    //         } else {
-    //             return this.getRecursionNextSiblingElementInPara(nextElement.parent);
-    //         }
-    //     }
-    // }
-
-    // /**
-    // * 在同一段落中，递归向后寻找最近的可点击元素
-    // */
-    // static getRecursionNextSiblingElementInParaForHit(currElement: Element | null): LeafElement | null {
-    //     let ele: LeafElement | null = null;
-    //     do {
-    //         ele = this.getRecursionNextSiblingElementInPara(currElement);
-    //     } while (ele && ele.disableClick)
-    //     return ele;
-    // }
-
-    // /**
-    // * 在同一段落中，递归向后寻找最近的可点击元素
-    // */
-    // static getRecursionNextSiblingElementForHit(currElement: Element | null): LeafElement | null {
-    //     let ele: LeafElement | null = null;
-    //     do {
-    //         ele = this.getRecursionNextSiblingElement(currElement);
-    //     } while (ele && ele.disableClick)
-    //     return ele;
-    // }
-
-    /**
-     * 获取行内最大渲染单元格高度，主要处理纵向合并单元格问题
-     * @param row
-     * @returns
-     */
-    static getRowMaxCellHeight(row: TableRowRenderObject): number {
-        let maxHeight = 0;
-        for (let i = 0; i < row.length; i++) {
-            if (row.getChild(i).rect.height > maxHeight) {
-                maxHeight = row.getChild(i).rect.height;
-            }
-        }
-        return maxHeight;
-    }
-
-
-    /**
-     * 校验是否为空内容
-     * @param ele
-     */
-    static checkEmptyContent(ele: BranchRenderObject): boolean {
-        if (ele.length === 1) {
-            const firstRender = ele.getChild(0);
-            if (firstRender instanceof ParagraphRenderObject) {
-                if ((<ParagraphElement>(firstRender.element)).length === 1) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     * 测量行内编组元素
-     * @param render
-     */
-    static remeasureInlineGroupRender(render: InlineGroupRenderObject): void {
-        let x = 0;
-        let maxHeight = 0;
-        for (let i = 0; i < render.length; i++) {
-            const item = render.getChild(i);
-            item.rect.x = x;
-            if (item.rect.height > maxHeight) {
-                maxHeight = item.rect.height;
-            }
-            x += item.rect.width;
-        }
-        for (let i = 0; i < render.length; i++) {
-            const item = render.getChild(i);
-            item.rect.y = maxHeight - item.rect.height;
-        }
-        render.rect.width = x;
-        render.rect.height = maxHeight;
-    }
-
-    static getParaLinePos(childRender: RenderObject, childRenderPos: Position): Rect {
-        const parent = childRender.parent;
-        const rect = ElementUtil.cloneRect(parent.rect);
-        rect.x = childRenderPos.x - childRender.rect.x;
-        rect.y = childRenderPos.y - childRender.rect.y;
-        if (parent instanceof ParagraphLineRectRenderObject) {
-            return rect;
-        } else {
-            return this.getParaLinePos(parent, rect);
-        }
-    }
-
-
-    static getParentRenderPos(parentRender: RenderObject, childRender: RenderObject, childRenderPos: Position): Rect {
-        const parent = childRender.parent;
-        const rect = ElementUtil.cloneRect(parent.rect);
-        rect.x = childRenderPos.x - childRender.rect.x;
-        rect.y = childRenderPos.y - childRender.rect.y;
-        if (parent === parentRender) {
-            return rect;
-        } else {
-            return this.getParentRenderPos(parentRender, parent, rect);
-        }
-    }
-
-
-    /**
-     * 获取绘制元素所在的区域
-     */
-    static getRenderObjectRegion(render: RenderObject): HitRegion | undefined {
-        if (!render) {
-            return undefined;
-        }
-        if (render.element) {
-            return this.getElementRegion(render.element);
-        }
-        return this.getRenderObjectRegion(render.parent);
-    }
-
-    /**
-     * 获取文档元素所在的区域
-     * @param element
-     * @returns
-     */
-    static getElementRegion(element: Element): HitRegion | undefined {
-        const regionTarget = this.getElementRegionTarget(element);
-        return regionTarget?.type;
-    }
-
-    static getElementRegionTarget(element: Element | null): { type: HitRegion, target: BranchElement } | null {
-        if (!element) {
-            return null;
-        }
-        if (element instanceof DocumentBodyElement) {
-            return { type: 'body', target: element };
-        }
-        if (element instanceof DocumentFooterElement) {
-            return { type: 'footer', target: element };
-        }
-        if (element instanceof DocumentHeaderElement) {
-            return { type: 'header', target: element };
-        }
-        if (element instanceof CommsContainerElement) {
-            return { type: 'review', target: element }
-        }
-        return this.getElementRegionTarget(element.parent);
-    }
-
-    /**
-     * 根据坐标系统偏移位获取所在的文本偏移位置
-     * @param textRender
-     * @param x
-     * @returns
-     */
-    static getTextRenderOffset(textRender: TextGroupRenderObject, x: number): number {
-        const ele = textRender.element as TextGroupElement;
-        const docRender = ElementUtil.getParentRender(textRender, DocumentRenderObject);
-        if (!docRender) {
-            throw new Error('docRender is null')
-        }
-        const elePaintRenders = ele.paintRenders.filter(item => ElementUtil.getParentRender(item, DocumentRenderObject) === docRender);
-        let count = 0;
-        for (let i = 0; i < elePaintRenders.length; i++) {
-            const render = elePaintRenders[i] as TextGroupRenderObject;
-            if (render !== textRender) {
-                count += render.textMeasures.length;
-            } else {
-                let horX = 0;
-                for (let j = 0; j < render.textMeasures.length; j++) {
-                    if (horX + render.textMeasures[j].actualSize >= x) {
-                        if (horX + Math.floor(render.textMeasures[j].actualSize / 2) > x) {
-                            if (j === 0 && i > 0) {
-                                j += 0.5;
-                            }
-                        } else {
-                            j += 1;
-                        }
-                        return j + count;
-                    }
-                    horX += render.textMeasures[j].actualSize;
-                }
-                return count + render.textMeasures.length;
-            }
-        }
-        throw new Error('未找到当前文本元素的光标偏移量');
-    }
-
-    static getHitRenderOffset(render: LeafRenderObject, x: number): number {
-        if (render instanceof TextGroupRenderObject) {
-            return this.getTextRenderOffset(render, x);
-        } else {
-            if (render.element && render.element.type === 'psym') {
-                return 0;
-            }
-            return (render.rect.width / 2) >= x ? 0 : 1;
-        }
-    }
-
-    static getTextRenderHorX(currRender: TextGroupRenderObject, startOffset: number, endOffset: number): { startX: number, endX: number } {
-        const textEle = currRender.element as TextGroupElement;
-        let endX = 0;
-        let startX = 0;
-        let count = 0;
-        for (let i = 0; i < textEle.paintRenders.length; i++) {
-            const paintRender = textEle.paintRenders[i] as TextGroupRenderObject;
-            if (paintRender !== currRender) {
-                count += paintRender.textMeasures.length;
-            } else {
-                if (count + paintRender.textMeasures.length < startOffset) {
-                    continue;
-                }
-                if (count > endOffset) {
-                    continue;
-                }
-                for (let j = 0; j < paintRender.textMeasures.length; j++) {
-                    if (endOffset === count + j) {
-                        break;
-                    }
-                    if (count + j === startOffset) {
-                        startX = endX;
-                    }
-                    endX += paintRender.textMeasures[j].actualSize;
-                }
-            }
-        }
-        return { startX, endX };
-    }
-
-    /**
-     * 获取一个元素结尾偏移量
-     * 文本以字符长度进行确定
-     * @param ele
-     * @returns
-     */
-    static getElementEndOffset(ele: LeafElement): number {
-        if (ele instanceof TextGroupElement) {
-            return ele.textMeasures.length;
-        }
-        return 1;
-    }
-
-    /**
-     * 判断当前偏移量是否是最终偏移量
-     * @param ele
-     * @param offset
-     */
-    static isElementEndOffset(ele: LeafElement, offset: number): boolean {
-        return this.getElementEndOffset(ele) === offset;
-    }
-
-    /**
-     * 获取直接子节点的所有渲染元素
-     * @param ele
-     * @returns
-     */
-    static getChildRenders<T extends RenderObject>(ele: BranchRenderObject): Array<T> {
-        const items: Array<T> = [];
-        for (let i = 0; i < ele.length; i++) {
-            items.push(ele.getChild(i) as T);
-        }
-        return items;
-    }
-
-    /**
-     * 获取当前单元格内所有的段落行
-     * @param cell
-     * @returns
-     */
-    static getCellParaLines(cell: TableCellRenderObject): Array<ParagraphLineRectRenderObject> {
-        const items: Array<ParagraphLineRectRenderObject> = [];
-        for (let i = 0; i < cell.length; i++) {
-            const para = cell.getChild(i) as ParagraphRenderObject;
-            for (let j = 0; j < para.length; j++) {
-                items.push(para.getChild(j) as ParagraphLineRectRenderObject)
-            }
-        }
-        return items;
-    }
-
-    static getRandomColor(seed: number) {
-        let letters = '0123456789ABCDEF';
-        let color = '#';
-        for (let i = 0; i < 6; i++) {
-            color += letters[Math.floor(this.getSeedRandom(seed) * 16)];
-        }
-        return color;
-    }
-
-
-    static getSeedRandom(seed: number): number {
-        return Number("0." + Math.sin(seed * Math.random()).toString().substr(6));
-    }
-
-
-    static findChildRender(render: BranchRenderObject, predicate: (child: RenderObject) => boolean): RenderObject | null {
-        for (let i = 0; i < render.length; i++) {
-            if (predicate(render.getChild(i))) {
-                return render.getChild(i);
-            }
-        }
-        return null;
-    }
-
-
-    static getDataElement(ele: Element): DataElementInlineGroup {
-        return this.getParent(ele, item => item instanceof DataElementInlineGroup) as DataElementInlineGroup;
-    }
-}
-