@hailin-zheng/editor-core 1.0.4 → 1.0.7

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

@@ -1,573 +0,0 @@
-import { runTextLineRender } from "./document-textline-mode";
-import {
-    BlockContainerElement,
-    BlockContentElement,
-    BranchElement,
-    Element,
-    InlineGroupElement,
-    LeafElement,
-    ModifyFlag,
-    ViewOptions
-} from "./element-define";
-import { DataEleBaseProps, DataEleBaseTextProps, TextProps } from "./element-props";
-import { ElementUtil } from "./element-util";
-import { DataElementInlineGroup } from "./impl/data-element/data-element-base-impl";
-import { FillNullSpaceRenderObject } from "./impl/decorate/fill-null-space-imple";
-import { DocumentElement, DocumentRenderObject } from "./impl/document/doc-impl";
-import { ParagraphElement, ParagraphLineRectRenderObject, ParagraphRenderObject } from "./impl/paragraph/p-impl";
-import { TextGroupElement, TextGroupRenderObject } from "./impl/text/text-impl";
-import { RenderContenxtType } from "./render-context";
-import {
-    BlockContainerRenderObject,
-    BlockContentRenderObject,
-    BranchRenderObject,
-    InlineGroupRenderObject,
-    LeafRenderObject,
-    RenderObject
-} from "./render-define";
-interface ICutLineData { firstItem: RenderObject | null, lastItem: RenderObject | null, br?: boolean }
-/**
- * 测量阶段，生成Render-UI
- */
-export class ElementMeasure {
-    constructor(private options: ViewOptions, private renderCtx: RenderContenxtType) { }
-
-    measureDocument(document: DocumentElement): DocumentRenderObject {
-        this.clearPaintCache(document);
-        const docRender = this.measureControl(document, this.options.docPageSettings.width) as DocumentRenderObject;
-        this.setMeasureCompletedModifyFlag(document);
-        runTextLineRender(document, this.options, this.renderCtx);
-        return docRender;
-    }
-
-    measureControl(element: Element, maxWidth: number): RenderObject | null {
-        if (element.modifyFlag === ModifyFlag.None) {
-            return element.measureRender;
-        }
-        if (element instanceof BlockContentElement) {
-            const render = element.createRenderObject(this.options, this.renderCtx) as BlockContentRenderObject;
-            element.measureRender = render;
-            //测量阶段，只限制最大宽度即可
-            render.setRenderWidth(maxWidth);
-            if (element instanceof ParagraphElement) {
-                this.measureParagraph(element, render as ParagraphRenderObject);
-            } else {
-                throw new Error('未实现');
-            }
-            return render;
-
-        } else if (element instanceof BlockContainerElement) {
-            ElementUtil.fixBlockContainer(element);
-            let render: BlockContainerRenderObject | null = null;
-            if (element.modifyFlag === ModifyFlag.Modify || element.modifyFlag === ModifyFlag.Track) {
-                ElementUtil.fixBlockContainer(element);
-                element.measureRender = null;
-                render = element.createRenderObject(this.options, this.renderCtx) as BlockContainerRenderObject;
-                if (!render) {
-                    element.measureRender = null;
-                    return null;
-                }
-                if (render.rect.maxWidth === 0) {
-                    render.setRenderWidth(maxWidth);
-                }
-            }
-            if (!render) {
-                throw new Error('render is null')
-            }
-            element.measureRender = render;
-            const innerMaxWidth = render.getInnerMaxWidth();
-            for (let i = 0; i < element.length; i++) {
-                const child = element.getChild(i);
-                const blockContentELement = child as BlockContentElement;
-                const childRender = this.measureControl(blockContentELement, innerMaxWidth) as BlockContentRenderObject;
-                if (!childRender) {
-                    continue;
-                }
-                render.addChild(childRender);
-            }
-            ElementUtil.remeasure(render);
-            return render;
-        } else {
-            throw new Error('未实现');
-        }
-    }
-
-    /**
-     * 生成段落 UI 树
-     * @param para 
-     * @param render 
-     */
-    measureParagraph(para: ParagraphElement, render: ParagraphRenderObject): void {
-        ElementUtil.fixParagraphContent(para);
-        this.setParagraphDefaultTextProps(para);
-        const renderObjects: Array<RenderObject> = [];
-        for (let i = 0; i < para.length; i++) {
-            const child = para.getChild(i);
-            if (child instanceof InlineGroupElement) {
-                child.measureRender = this.getInlineGroupRenderItem(child);
-                if (child.measureRender) {
-                    renderObjects.push(child.measureRender);
-                }
-            }
-            else if (child instanceof LeafElement) {
-                child.measureRender = child.createRenderObject(this.options, this.renderCtx);
-                if (child.measureRender) {
-                    renderObjects.push(child.measureRender);
-                }
-            }
-        }
-        this.measureInnerParagraph(render, para, renderObjects);
-    }
-
-
-    /**
-     * 设置段落默认文本属性
-     * 当前段落属于空段落时，键入文本时，文本的默认属性
-     */
-    setParagraphDefaultTextProps(para: ParagraphElement): void {
-        const lastTextGroup = ElementUtil.getLastLeafElement(para, (item) => item instanceof TextGroupElement) as TextGroupElement;
-        const defaultTextProps = lastTextGroup ? lastTextGroup.props.clone(new TextProps()) : ElementUtil.createTextProps(null, this.options);
-        if (para.props.textProps && para.props.textProps.equals(defaultTextProps)) {
-            return;
-        }
-        para.props.textProps = defaultTextProps;
-    }
-
-    /**
-     * 根据段落UI元素，进行排列
-     * @param render 
-     * @param paragraph 
-     * @param renderObjects 
-     */
-    measureInnerParagraph(render: ParagraphRenderObject, paragraph: ParagraphElement, renderObjects: Array<RenderObject>) {
-        let lineRect = render.createLineRect();
-        //行内框
-        const innerLineRects: Array<ParagraphLineRectRenderObject> = [];
-        const addInnerLineFunc = (lineRect: ParagraphLineRectRenderObject): void => {
-            innerLineRects.push(lineRect);
-            if (lineRect.rect.maxWidth <= 0) {
-                throw new Error('lineRect.rect.maxWidth is ' + lineRect.rect.maxWidth)
-            }
-            if (innerLineRects.indexOf(lineRect) === 0) {
-                if (paragraph.props.indent > 0) {
-                    lineRect.rect.maxWidth -= paragraph.props.indent;
-                }
-            } else {
-                lineRect.rect.maxWidth -= paragraph.props.hanging;
-            }
-        };
-        addInnerLineFunc(lineRect);
-        let i = 0;
-        let currItem = renderObjects[i++];
-        const inCloseBody = paragraph.parent.type === 'body';
-        while (currItem) {
-            const maxWidth = lineRect.rect.maxWidth as number;
-            const nextItem = renderObjects[i];
-            const { firstItem, lastItem, br } = this.cutRenderItem(currItem, nextItem, maxWidth - lineRect.rect.width, lineRect.length === 0, inCloseBody);
-            if (firstItem) {
-                if (lastItem) {
-                    renderObjects.splice(i, 0, lastItem);
-                }
-                currItem = firstItem;
-            } else {
-                lineRect = render.createLineRect();
-                addInnerLineFunc(lineRect);
-                continue;
-            }
-            lineRect.addChild(currItem);
-            currItem.rect.x = lineRect.rect.width;
-            if (currItem.rect.height > lineRect.rect.height) {
-                lineRect.rect.height = currItem.rect.height;
-            }
-            lineRect.rect.width += currItem.rect.width;
-            if (br) {
-                //lineRect.rect.maxWidth = lineRect.rect.width;
-                lineRect = render.createLineRect();
-                addInnerLineFunc(lineRect);
-            }
-            currItem = renderObjects[i++];
-        }
-        for (let i = 0; i < innerLineRects.length; i++) {
-            const innerLineRect = innerLineRects[i] as ParagraphLineRectRenderObject;
-            innerLineRect.rect.x = this.getParaLineRectStartX(innerLineRects.length, i, paragraph, render, innerLineRect);
-            //限制最大行高
-            const maxLineHeight = Math.floor(14 * 1.3);
-            //fillLineHeight填充行高
-            let fillLineHeight = Math.ceil(innerLineRect.rect.height * (paragraph.props.lineHeight - 1));
-            fillLineHeight = fillLineHeight > maxLineHeight ? maxLineHeight : fillLineHeight;
-            const lineHeight = innerLineRect.rect.height + fillLineHeight;
-            const paddingBottom = Math.ceil(fillLineHeight / 2);
-            innerLineRect.rect.height = lineHeight;
-            for (let j = 0; j < innerLineRect.length; j++) {
-                const leaf = innerLineRect.getChild(j);
-                leaf.rect.y = innerLineRect.rect.height - paddingBottom - leaf.rect.height;
-            }
-            //render.rect.height += lineRect.rect.height;
-            const outterLineRect = render.createLineRect();
-            outterLineRect.rect.width = outterLineRect.rect.maxWidth as number;
-            outterLineRect.addChild(innerLineRect);
-            ElementUtil.remeasure(outterLineRect, false);
-            render.addChild(outterLineRect);
-        }
-        ElementUtil.remeasure(render);
-    }
-
-    /**
-     * 获取段落行布局横向坐标起始位置，被段落text-align影响
-     */
-    getParaLineRectStartX(counter: number, paraLineIndex: number, paraElement: ParagraphElement, paraRenderObject: ParagraphRenderObject, paraLineRender: ParagraphLineRectRenderObject): number {
-        //左对齐，首行缩进
-        let indent = paraElement.props.indent;
-        //存在项目符号
-        if (paraLineIndex > 0) {
-            indent = paraElement.props.hanging;
-        }
-        if (paraElement.props.textAlign === 'center') {
-            const remainSpace = paraRenderObject.rect.width - paraLineRender.rect.width;
-            return Math.ceil(remainSpace / 2) + indent;
-        } else if (paraElement.props.textAlign === 'right') {
-            const remainSpace = paraRenderObject.rect.width - paraLineRender.rect.width;
-            return remainSpace + indent;
-        } else if (paraElement.props.textAlign === 'justify') {
-            const renderUnitCount = this.getRenderUnitLength(paraLineRender);
-            if (paraLineIndex === counter - 1 || renderUnitCount === 1) {
-                return indent;
-            }
-            const spaceWidth = (<number>paraLineRender.rect.maxWidth - paraLineRender.rect.width) / (renderUnitCount - 1);
-            this.setAlignJustify(paraLineRender, 0, spaceWidth);
-            return indent;
-        } else {
-            return indent;
-        }
-    }
-
-    /**
-     * 设置两端对齐
-     * @param render 
-     * @param count 
-     * @param spaceWidth 
-     */
-    private setAlignJustify(render: RenderObject, count: number, spaceWidth: number): number {
-        if (render instanceof BranchRenderObject) {
-            let width = 0;
-            for (let i = 0; i < render.length; i++) {
-                const currRender = render.getChild(i);
-                count += this.setAlignJustify(currRender, count, spaceWidth);
-                currRender.rect.x = width;
-                width += currRender.rect.width;
-            }
-            render.rect.width = width;
-        } else if (render instanceof LeafRenderObject) {
-            if (render instanceof TextGroupRenderObject) {
-                let i = count === 0 ? 1 : 0;
-                for (; i < render.textMeasures.length; i++) {
-                    render.textMeasures[i].actualSize = render.textMeasures[i].actualSize + spaceWidth;
-                }
-                render.measure();
-                count += render.textMeasures.length;
-            } else {
-                if (count !== 0) {
-                    render.rect.width += spaceWidth;
-                }
-                count += 1;
-            }
-        }
-        return count;
-    }
-
-    /**
-     * 获取段落行渲染单位个数,字符需要计算为字符长度
-     */
-    private getRenderUnitLength(paraLine: RenderObject): number {
-        if (paraLine instanceof LeafRenderObject) {
-            if (paraLine instanceof TextGroupRenderObject) {
-                return paraLine.textMeasures.length;
-            } else {
-                return 1;
-            }
-        } else if (paraLine instanceof BranchRenderObject) {
-            let count = 0;
-            for (let i = 0; i < paraLine.length; i++) {
-                count += this.getRenderUnitLength(paraLine.getChild(i));
-            }
-            return count;
-        }
-        throw new Error('未到达计算位置')
-    }
-
-
-    getInlineGroupRenderItem(item: InlineGroupElement): RenderObject | null {
-        const inlineGroupRender = item.createRenderObject(this.options, this.renderCtx) as InlineGroupRenderObject;
-        if (!inlineGroupRender) {
-            return null;
-        }
-        for (let i = 0; i < item.length; i++) {
-            const child = item.getChild(i);
-            child.beginMeasure();
-            if (child instanceof LeafElement) {
-                child.measureRender = child.createRenderObject(this.options, this.renderCtx);
-                if (child.measureRender) {
-                    inlineGroupRender.addChild(child.measureRender);
-                }
-            } else if (child instanceof InlineGroupElement) {
-                item.measureRender = this.getInlineGroupRenderItem(child);
-                if (item.measureRender) {
-                    inlineGroupRender.addChild(item.measureRender);
-                }
-            } else {
-                throw new Error('未实现')
-            }
-        }
-
-        ElementUtil.remeasureInlineGroupRender(inlineGroupRender);
-        //限制最小长度
-        if (item instanceof DataElementInlineGroup) {
-            //需要填充null-text
-            if (item.length === 2) {
-                const nullText = new TextGroupElement();
-                nullText.isDecorate = true;
-                nullText.disableClick = true;
-                const baseTextProps = (<any>item).props as DataEleBaseTextProps;
-                nullText.text = baseTextProps.nullText as string;
-                baseTextProps.nullTextProps.clone(nullText.props);
-                const nullTextRender = nullText.createRenderObject(this.options, this.renderCtx);
-                inlineGroupRender.insertChild(nullTextRender, 1);
-                ElementUtil.remeasureInlineGroupRender(inlineGroupRender);
-            }
-            const props = (<any>item).props as DataEleBaseProps;
-            let minLength = props.minLength ?? 14;
-            minLength = minLength < 14 ? 14 : minLength;
-            if (item instanceof DataElementInlineGroup && inlineGroupRender.rect.width < minLength) {
-                const fillNullSpace = new FillNullSpaceRenderObject();
-                fillNullSpace.rect.width = minLength - inlineGroupRender.rect.width;
-                fillNullSpace.rect.height = inlineGroupRender.rect.height;
-                inlineGroupRender.insertChild(fillNullSpace, inlineGroupRender.length - 1);
-            }
-            ElementUtil.remeasureInlineGroupRender(inlineGroupRender);
-        }
-        return inlineGroupRender;
-    }
-
-
-    cutRenderItem(render: RenderObject, nextRender: RenderObject, limitWidth: number, lineEmpty: boolean, inCloseBody: boolean): ICutLineData {
-        if (render instanceof LeafRenderObject) {
-            if (render.rect.width > limitWidth && render instanceof TextGroupRenderObject) {
-                return this.cutTextRender(render, nextRender, limitWidth, lineEmpty, inCloseBody);
-            }
-            if (render instanceof FillNullSpaceRenderObject) {
-                return this.cutFillNullRender(render, limitWidth);
-            }
-            if (render.rect.width < limitWidth || lineEmpty || render.element.type === 'br' || render.element.type === 'psym') {
-                return { firstItem: render, lastItem: null, br: render.element.type === 'br' };
-            }
-            return { firstItem: null, lastItem: null };
-        } else if (render instanceof InlineGroupRenderObject) {
-            return this.cutInlineGroupRenderItem(render, limitWidth, lineEmpty, inCloseBody);
-        }
-        throw new Error('到达计算边界')
-    }
-
-    cutTextRender(render: TextGroupRenderObject, nextRender: RenderObject, limitWidth: number, lineEmpty: boolean, inCloseBody: boolean): ICutLineData {
-        let sumWidth = 0;
-        const cutRender = render.clone() as TextGroupRenderObject;
-        cutRender.textMeasures.length = 0;
-        let i = 0;
-        for (; i < render.textMeasures.length; i++) {
-            sumWidth += render.textMeasures[i].actualSize;
-            if (sumWidth > limitWidth) {
-                if (lineEmpty && i === 0) {
-                    i = 1;
-                }
-                break;
-            }
-        }
-        //后置标点处理
-        i = this.patchHandlePostPunctuation(render, nextRender, i, inCloseBody, lineEmpty);
-        //前置标点处理
-        i = this.patchHandleLeadingPunctuation(render, i, lineEmpty);
-        if (i <= 0) {
-            return { firstItem: null, lastItem: null };
-        }
-
-        cutRender.textMeasures = render.textMeasures.splice(0, i);
-        render.measure();
-        cutRender.measure();
-        return { firstItem: cutRender, lastItem: render, br: true };
-    }
-
-    /**
-     * 处理前置标点,前置标点不能出现在末尾
-     * @param render 
-     * @param i 
-     */
-    private patchHandleLeadingPunctuation(render: TextGroupRenderObject, i: number, lineEmpty: boolean): number {
-        if (i === 1 && lineEmpty) {
-            return i;
-        }
-        if (this.containLeadingPunctuation(render.textMeasures[i]?.char)) {
-            return i--;
-        }
-        return i;
-    }
-
-    /**
-     * 处理后置标点，后置标点不能出现在行首
-     * @param render 
-     * @param i 
-     * @param lineEmpty 
-     */
-    private patchHandlePostPunctuation(render: TextGroupRenderObject, nextRender: RenderObject, i: number, inCloseBody: boolean, lineEmpty: boolean): number {
-        if (i === render.textMeasures.length - 1) {
-            //紧跟着的字符包含后置标点
-            if (this.containerStartSymbolInTextStart(nextRender)) {
-                i--;
-            }
-        }
-        if (inCloseBody && this.containPostPunctuation(render.textMeasures[i]?.char)) {
-            if (this.containPostPunctuation(render.textMeasures[i + 1]?.char)) {
-                i--;
-            } else {
-                i++;
-            }
-        } else {
-            if (i <= 1) {
-                //debugger;
-            }
-            if (i > 1 && this.containPostPunctuation(render.textMeasures[i]?.char)) {
-                i--;
-            }
-        }
-        return i;
-    }
-
-    /**
-     * 是否包含后置标点
-     * @param str 
-     * @returns 
-     */
-    private containPostPunctuation(str: string): boolean {
-        return '!),.:;?]}¨·ˇˉ―‖’”…∶、。〃々〉》」』】〕〗！＂＇），．：；？］｀｜｝～￠'.indexOf(str) > -1;
-    }
-
-    //是否包含前置标点
-    private containLeadingPunctuation(str: string): boolean {
-        return '‘“〈《「『【〔〖（［｛￡'.indexOf(str) > -1;
-    }
-
-    /**
-     * 文本开头是否包含后置标点
-     * @param render 
-     * @returns 
-     */
-    private containerStartSymbolInTextStart(render: RenderObject): boolean {
-        //return false;
-        if (render instanceof TextGroupRenderObject) {
-            if (render.textMeasures.length > 0) {
-                return this.containPostPunctuation(render.textMeasures[0].char);
-            }
-        }
-        return false;
-    }
-
-    cutFillNullRender(render: FillNullSpaceRenderObject, limitWidth: number): ICutLineData {
-        if (limitWidth === 0) {
-            return { firstItem: null, lastItem: null }
-        }
-        if (render.rect.width > limitWidth) {
-            const cutRender = new FillNullSpaceRenderObject();
-            cutRender.rect.width = limitWidth;
-            cutRender.rect.height = render.rect.height;
-            render.rect.width = render.rect.width - limitWidth;
-            return { firstItem: cutRender, lastItem: render }
-        } else {
-            return { firstItem: render, lastItem: null }
-        }
-    }
-
-    /**
-     * 行内编组元素超出行内可用空间，需要根据剩余空间长度进行截断
-     */
-    cutInlineGroupRenderItem(render: InlineGroupRenderObject, limitWidth: number, emptyLine: boolean, inCloseBody: boolean): ICutLineData {
-        const cutRender = render.element.createRenderObject(this.options, this.renderCtx) as InlineGroupRenderObject;
-        let x = 0;
-        let br = false;
-        const items = [...render.getItems()];
-        for (let i = 0; i < items.length; i++) {
-            const child = items[i];
-            if (child instanceof LeafRenderObject) {
-                if (x + child.rect.width > limitWidth) {
-                    const { firstItem, lastItem, br: childBr } = this.cutRenderItem(child, items[i + 1], limitWidth - x, emptyLine && cutRender.length === 0, inCloseBody);
-                    if (firstItem) {
-                        cutRender.addChild(firstItem);
-                        if (lastItem) {
-                            //items.push(lastItem);
-                            //items.splice(i + 1, 0, lastItem)
-                        }
-                    }
-                    br = childBr || br;
-                    break;
-                } else {
-                    render.removeChild(child);
-                    cutRender.addChild(child);
-                }
-                //软换行符
-                if (child.element && child.element.type === 'br') {
-                    br = true;
-                    break;
-                }
-            } else if (child instanceof InlineGroupRenderObject) {
-                if (x + child.rect.width > limitWidth) {
-                    const { firstItem, br: childBr } = this.cutInlineGroupRenderItem(child, limitWidth - x, emptyLine && cutRender.length === 0, inCloseBody);
-                    if (firstItem) {
-                        cutRender.addChild(firstItem);
-                    }
-                    br = childBr || br;
-                    break;
-                } else {
-                    render.removeChild(child);
-                    cutRender.addChild(child);
-                }
-            }
-            x += child.rect.width;
-        }
-        if (!cutRender.length) {
-            return { firstItem: null, lastItem: null };
-        }
-        ElementUtil.remeasureInlineGroupRender(cutRender);
-        ElementUtil.remeasureInlineGroupRender(render);
-        return { firstItem: cutRender, lastItem: render.length ? render : null, br };
-    }
-
-    /**
-     * 修改测量完毕后的元素状态
-     * @param ele 
-     */
-    setMeasureCompletedModifyFlag(ele: Element): void {
-        if (ele instanceof BranchElement) {
-            for (let i = 0; i < ele.length; i++) {
-                this.setMeasureCompletedModifyFlag(ele.getChild(i));
-            }
-        }
-        ele.modifyFlag = ModifyFlag.None;
-    }
-
-    clearPaintCache(ele: Element): void {
-        ele.beginMeasure();
-        if (ele instanceof BranchElement) {
-            for (let i = 0; i < ele.length; i++) {
-                this.clearPaintCache(ele.getChild(i));
-            }
-        }
-    }
-
-    endMeasures(ele: Element): void {
-        if (ele instanceof BranchElement) {
-            for (let i = 0; i < ele.length; i++) {
-                this.endMeasures(ele.getChild(i));
-            }
-        }
-    }
-
-
-
-}