devexpress-richedit 26.1.2-beta → 26.1.3

package/lib/common/canvas/renderes/view-manager.js

@@ -29,9 +29,12 @@ import { RichEditClientCommand } from '../../commands/client-command';
 import { ZoomLevelChange } from '../../model/changes/model/zoom-level';
 import { ModelChangeType } from '../../model/changes/enums';
 import { MixedSize } from '../../../common/utils/mixed-size';
+import { IntervalAlgorithms } from '@devexpress/utils/lib/intervals/algorithms';
+import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 export class ViewManager {
     get renderer() { return this.renderers[this.innerClientProperties.viewsSettings.viewType]; }
     get printLayoutRenderer() { return this.renderers[ViewType.PrintLayout]; }
+    get isSimpleView() { return this.innerClientProperties.viewsSettings.isSimpleView; }
     get canvasListener() { return this.canvasListeners[this.innerClientProperties.viewsSettings.viewType]; }
     constructor(control, canvas, eventManager, stringResources, horizontalRuler, inputController, innerClientProperties, readOnlyPropertyHolder, layoutFormatterManagerHolder, internalApi, fieldOptions) {
         this.cache = [];
@@ -79,11 +82,11 @@ export class ViewManager {
     }
     adjust(force) {
         if ((force || !this.sizes.isInitialized()) && this.cache.length > 0) {
-            const firstRenderedPageIndex = Math.min(this.cache.length, Math.max(0, ListUtils.indexBy(this.layout.pages, (page) => page.flags.get(LayoutPageFlags.ContentRendered))));
+            const firstRenderedPageIndex = Math.min(this.cache.length - 1, Math.max(0, this.layout.pages.findIndex((page) => page.flags.get(LayoutPageFlags.ContentRendered))));
             this.sizes.initialize(this.cache[firstRenderedPageIndex].page, this.canvas);
             const oldPageIndo = this.innerClientProperties.viewsSettings.pageVerticalInfo.clone();
             this.innerClientProperties.viewsSettings.pageVerticalInfo.copyFrom(this.sizes.pageVerticalInfo);
-            if (this.innerClientProperties.viewsSettings.isSimpleView && !this.innerClientProperties.viewsSettings.pageVerticalInfo.equals(oldPageIndo)) {
+            if (this.isSimpleView && !this.innerClientProperties.viewsSettings.pageVerticalInfo.equals(oldPageIndo)) {
                 const page = this.layout.pages[firstRenderedPageIndex];
                 if (this.layoutFormatterManagerHolder.layoutFormatterManager && page)
                     this.layoutFormatterManagerHolder.layoutFormatterManager.invalidator.onChangedAllLayout();
@@ -104,11 +107,18 @@ export class ViewManager {
     NotifySelectionLayoutChanged() {
         const layoutSelection = this.selection.layoutSelection;
         this.changeActiveSubDocumentRenderer.update(layoutSelection);
-        Log.print(LogSource.CanvasManager, "onSelectionLayoutChanged\n", LogListHelper.level_1(Log.w(2, Log.flip(LogObjToStrLayout.pageSelectionChange, 0, 1))(""), this.selection.layoutSelection.selectionInfo.changes, "", "\n"));
-        if (this.innerClientProperties.viewsSettings.isSimpleView)
+        Log.print(LogSource.CanvasManager, "onSelectionLayoutChanged\n", LogListHelper.level_1(Log.w(2, Log.flip(LogObjToStrLayout.pageSelectionChange, 0, 1))(""), layoutSelection.selectionInfo.changes, "", "\n"));
+        const shouldUpdateSelectedContent = this.renderer.updateForcedColorsModeState();
+        if (shouldUpdateSelectedContent) {
+            const intervals = this.getSelectionIntervalsForPageChange();
+            this.updateSelectedContent(layoutSelection.selectionInfo, intervals, layoutSelection.subDocumentInfo.isMain);
+        }
+        if (this.isSimpleView) {
             this.selection.renderAllPageSelection(this.layout, 0, true);
-        else
+        }
+        else {
             this.selection.applySelectionChanges(this.layout);
+        }
         const pageIndex = ListUtils.reverseIndexBy(layoutSelection.selectionInfo.pageInfos, pageInfo => pageInfo.oldItems.length > 0);
         if (pageIndex > -1) {
             const pageInfo = layoutSelection.selectionInfo.pageInfos[pageIndex];
@@ -128,18 +138,35 @@ export class ViewManager {
     }
     NotifyMisspelledSelectionLayoutChanged() {
         Log.print(LogSource.CanvasManager, "onMisspelledSelectionLayoutChanged\n", LogListHelper.level_1(Log.w(2, Log.flip(LogObjToStrLayout.pageSelectionChange, 0, 1))(""), this.selection.layoutSelection.misspelledInfo.changes, "", "\n"));
-        if (this.innerClientProperties.viewsSettings.isSimpleView)
+        if (this.isSimpleView)
             this.misspelledSelection.renderAllPageSelection(this.layout, 0, true);
         else
             this.misspelledSelection.applySelectionChanges(this.layout);
     }
     NotifyRangePermissionLayoutChanged() {
         Log.print(LogSource.CanvasManager, "onRangePermissionsLayoutChanged\n", LogListHelper.level_1(Log.w(2, Log.flip(LogObjToStrLayout.pageSelectionChange, 0, 1))(""), this.selection.layoutSelection.rangePermissionInfo.changes, "", "\n"));
-        if (this.innerClientProperties.viewsSettings.isSimpleView)
+        if (this.isSimpleView)
             this.rangePermission.renderAllPageSelection(this.layout, 0, true);
         else
             this.rangePermission.applySelectionChanges(this.layout);
     }
+    updateSelectedContent(selectionInfo, intervals, isMain) {
+        const pageIndexes = this.isSimpleView ? [0] : selectionInfo.changes.map((pageChange) => pageChange.index);
+        pageIndexes.forEach((pageIndex) => this.renderer.updateSelectedIntervalsPageChanges(this.layout.pages[pageIndex], pageIndex, intervals, isMain));
+    }
+    getSelectionIntervalsForPageChange() {
+        const selection = this.control.selection;
+        if (!selection)
+            return [];
+        const affectedIntervals = [];
+        for (const state of [selection.prevState, selection.currState]) {
+            state.intervalsInfo.intervals.forEach((interval) => {
+                if (interval.length > 0)
+                    affectedIntervals.push(new FixedInterval(interval.start, interval.length));
+            });
+        }
+        return IntervalAlgorithms.getMergedIntervals(affectedIntervals, true);
+    }
     addTopLevelContainers() {
         this.pagesContainer = DocumentRenderer.renderContainer(RendererClassNames.PAGES);
         this.pagesContainer.style.zoom = this.zoomLevel.toString();

package/lib/common/commands/border-command-options.d.ts

@@ -0,0 +1,7 @@
+import { CommandSimpleOptions } from '../../common/commands/command-base';
+import { BorderInfo } from '../../common/model/borders/border-info';
+import { IRichEditControl } from '../../common/interfaces/i-rich-edit-core';
+export declare class BorderCommandOptions extends CommandSimpleOptions<BorderInfo> {
+    forceApply: boolean;
+    constructor(control: IRichEditControl, parameter: BorderInfo, forceApply: boolean);
+}

package/lib/common/commands/border-command-options.js

@@ -0,0 +1,8 @@
+import { CommandSimpleOptions } from '../../common/commands/command-base';
+export class BorderCommandOptions extends CommandSimpleOptions {
+    constructor(control, parameter, forceApply) {
+        super(control, parameter);
+        this.forceApply = false;
+        this.forceApply = forceApply;
+    }
+}

package/lib/common/commands/dialogs/dialog-border-shading-command.js

@@ -11,6 +11,7 @@ import { CommandSimpleOptions } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 import { ToggleTableCellInsideHorizontalBordersCommand, ToggleTableCellInsideVerticalBordersCommand, ToggleTableCellsBottomBorderCommand, ToggleTableCellsLeftBorderCommand, ToggleTableCellsRightBorderCommand, ToggleTableCellsTopBorderCommand } from '../tables/toggle-table-cells-border-command';
 import { DialogParametersBase, ShowDialogCommandBase } from './show-dialog-command-base';
+import { BorderCommandOptions } from '../../../common/commands/border-command-options';
 export class DialogBorderShadingCommandBase extends ShowDialogCommandBase {
     getState() {
         const visible = this.selection.tableInfo.extendedData.numRows > 0;
@@ -68,27 +69,33 @@ export class DialogBorderShadingCommandBase extends ShowDialogCommandBase {
             changed = true;
         }
         if (newParams.top && !newParams.top.equals(initParams.top)) {
-            this.topBorderCommand.execute(this.control.commandManager.isPublicApiCall, newParams.top.getBorderInfo());
+            const opts = new BorderCommandOptions(this.control, newParams.top.getBorderInfo(), true);
+            this.topBorderCommand.execute(this.control.commandManager.isPublicApiCall, opts);
             changed = true;
         }
         if (newParams.bottom && !newParams.bottom.equals(initParams.bottom)) {
-            this.bottomBorderCommand.execute(this.control.commandManager.isPublicApiCall, newParams.bottom.getBorderInfo());
+            const opts = new BorderCommandOptions(this.control, newParams.bottom.getBorderInfo(), true);
+            this.bottomBorderCommand.execute(this.control.commandManager.isPublicApiCall, opts);
             changed = true;
         }
         if (newParams.right && !newParams.right.equals(initParams.right)) {
-            this.rightBorderCommand.execute(this.control.commandManager.isPublicApiCall, newParams.right.getBorderInfo());
+            const opts = new BorderCommandOptions(this.control, newParams.right.getBorderInfo(), true);
+            this.rightBorderCommand.execute(this.control.commandManager.isPublicApiCall, opts);
             changed = true;
         }
         if (newParams.left && !newParams.left.equals(initParams.left)) {
-            this.leftBorderCommand.execute(this.control.commandManager.isPublicApiCall, newParams.left.getBorderInfo());
+            const opts = new BorderCommandOptions(this.control, newParams.left.getBorderInfo(), true);
+            this.leftBorderCommand.execute(this.control.commandManager.isPublicApiCall, opts);
             changed = true;
         }
         if (newParams.insideHorizontal && !newParams.insideHorizontal.equals(initParams.insideHorizontal)) {
-            this.insideHorizontalBordersCommand.execute(this.control.commandManager.isPublicApiCall, newParams.insideHorizontal.getBorderInfo());
+            const opts = new BorderCommandOptions(this.control, newParams.insideHorizontal.getBorderInfo(), true);
+            this.insideHorizontalBordersCommand.execute(this.control.commandManager.isPublicApiCall, opts);
             changed = true;
         }
         if (newParams.insideVertical && !newParams.insideVertical.equals(initParams.insideVertical)) {
-            this.insideVerticalBordersCommand.execute(this.control.commandManager.isPublicApiCall, newParams.insideVertical.getBorderInfo());
+            const opts = new BorderCommandOptions(this.control, newParams.insideVertical.getBorderInfo(), true);
+            this.insideVerticalBordersCommand.execute(this.control.commandManager.isPublicApiCall, opts);
             changed = true;
         }
         history.endTransaction();

package/lib/common/commands/dialogs/dialog-custom-numbering-list-command.js

@@ -280,7 +280,7 @@ export class NumberingListFormPreviewHelper {
         layoutRow.width = layoutNumberingListBox.textBox.width + layoutTextBox.width;
         layoutRow.x = isMultiLevel ? UnitConverter.twipsToPixels(paragraphProperties.leftIndent - paragraphProperties.firstLineIndent) + margin : margin;
         layoutRow.y = index * layoutRow.height + margin;
-        return this.richEdit.viewManager.renderer.renderRow(layoutRow, 0);
+        return this.richEdit.viewManager.renderer.renderRow(layoutRow, 0, 0);
     }
     getNumberingListBoxText(levelIndex, majorIndex) {
         const items = [];

package/lib/common/commands/tables/toggle-table-cells-border-command.d.ts

@@ -17,7 +17,7 @@ export declare abstract class ToggleTableCellsBorderCommandBase extends CommandB
     static isBorderVisible(border: BorderInfo): boolean;
     DEPRECATEDConvertOptionsParameter(parameter: any): BorderInfo;
     protected getRelatedCommands(): Record<number, boolean>;
-    getState(_options?: CommandSimpleOptions<BorderInfo>): SimpleCommandState;
+    getState(options?: CommandSimpleOptions<BorderInfo>): SimpleCommandState;
     isEnabled(): boolean;
     isChecked(tableInfo: SelectedTableInfo): boolean;
     executeCore(state: SimpleCommandState, options: CommandSimpleOptions<BorderInfo>): boolean;

package/lib/common/commands/tables/toggle-table-cells-border-command.js

@@ -10,6 +10,7 @@ import { TableCellMergingState } from '../../model/tables/secondary-structures/t
 import { RichEditClientCommand } from '../client-command';
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
+import { BorderCommandOptions } from '../../../common/commands/border-command-options';
 export class ToggleTableCellsBorderCommandBase extends CommandBase {
     constructor() {
         super(...arguments);
@@ -39,12 +40,18 @@ export class ToggleTableCellsBorderCommandBase extends CommandBase {
             [RichEditClientCommand.ToggleTableCellsTopBorder]: true,
         };
     }
-    getState(_options = this.convertToCommandOptions(null)) {
+    getState(options = this.convertToCommandOptions(null)) {
         const tableInfo = this.selection.tableInfo;
         let enabled = this.isEnabled() && this.selection.tableInfo.extendedData.areCellsSelectedInSeries;
         let state = new SimpleCommandState(enabled);
-        if (state.enabled)
-            state.value = this.isChecked(tableInfo);
+        if (state.enabled) {
+            if (options instanceof BorderCommandOptions && options.forceApply) {
+                state.value = !ToggleTableCellsBorderCommandBase.isBorderVisible(options.param);
+            }
+            else {
+                state.value = this.isChecked(tableInfo);
+            }
+        }
         return state;
     }
     isEnabled() {

package/lib/common/event-manager.js

@@ -207,6 +207,8 @@ export class EventManager {
         this.control.modelManager.modelManipulator.notifyModelChanged(new TextBufferChangedSubDocumentChange(subDocument.id, state));
     }
     insertFunc() {
+        if (this.accumulatedText.length === 0)
+            return;
         const insertCommand = this.control.commandManager.getCommand(RichEditClientCommand.InsertText);
         const textWasInserted = insertCommand.execute(this.control.commandManager.isPublicApiCall, this.accumulatedText);
         this.accumulatedText = "";

package/lib/common/layout/main-structures/layout-boxes/layout-box.js

@@ -42,7 +42,7 @@ export class LayoutBox extends Rectangle {
             this.colorInfo.equals(obj.colorInfo) &&
             this.rowOffset == obj.rowOffset &&
             this.hyperlinkTip == obj.hyperlinkTip &&
-            this.fieldLevel == this.fieldLevel;
+            this.fieldLevel == obj.fieldLevel;
     }
     copyFrom(obj) {
         super.copyFrom(obj);

package/lib/common/layout/main-structures/layout-column.d.ts

@@ -8,6 +8,7 @@ export declare class LayoutColumn extends Rectangle {
     paragraphFrames: ParagraphFrame[];
     tablesInfo: LayoutTableColumnInfo[];
     constructor();
+    getStartPosition(): number;
     getEndPosition(): number;
     getLastRow(): LayoutRow;
     static findSectionColumnWithMinimumWidth(columnBounds: Rectangle[]): number;

package/lib/common/layout/main-structures/layout-column.js

@@ -7,6 +7,9 @@ export class LayoutColumn extends Rectangle {
         this.paragraphFrames = [];
         this.tablesInfo = [];
     }
+    getStartPosition() {
+        return this.pageAreaOffset + this.rows[0].getStartPosition();
+    }
     getEndPosition() {
         return this.pageAreaOffset + ListUtils.last(this.rows).getEndPosition();
     }

package/lib/common/layout/selection/layout-selection-items.d.ts

@@ -36,3 +36,6 @@ export declare class LayoutSelectionFloatingObjectItem extends LayoutSelectionIt
     get zIndexClassType(): zIndexCssClassType;
     get baseClassName(): string;
 }
+export declare class LayoutSelectionPictureItem extends LayoutSelectionItem {
+    get baseClassName(): string;
+}

package/lib/common/layout/selection/layout-selection-items.js

@@ -73,3 +73,8 @@ export class LayoutSelectionFloatingObjectItem extends LayoutSelectionItem {
         return [RendererClassNames.SELECTION_ROW, RendererClassNames.SELECTION_FLOATING_OBJECTS].join(" ");
     }
 }
+export class LayoutSelectionPictureItem extends LayoutSelectionItem {
+    get baseClassName() {
+        return [RendererClassNames.SELECTION_ROW, RendererClassNames.SELECTION_PICTURE_ROW].join(" ");
+    }
+}

package/lib/common/layout-engine/selection/selection-formatter.js

@@ -7,7 +7,7 @@ import { LayoutChangeType } from '../../layout-formatter/changes/changes/layout-
 import { LayoutPageSelectionChange } from '../../layout-formatter/changes/changes/selection/layout-page-selection-change';
 import { DocumentLayoutDetailsLevel } from '../../layout/document-layout-details-level';
 import { LayoutBoxType } from '../../layout/main-structures/layout-boxes/layout-box';
-import { LayoutRangePermissionItem, LayoutSelectionCursorItem, LayoutSelectionFloatingObjectItem, LayoutSelectionItem, LayoutSelectionMisspelledItem, LayoutSelectionSearchItem } from '../../layout/selection/layout-selection-items';
+import { LayoutRangePermissionItem, LayoutSelectionCursorItem, LayoutSelectionFloatingObjectItem, LayoutSelectionItem, LayoutSelectionMisspelledItem, LayoutSelectionPictureItem, LayoutSelectionSearchItem } from '../../layout/selection/layout-selection-items';
 import { TableCellBoundFlags } from '../../layout/table/layout-table-cell-info';
 import { ModelChangeType } from '../../model/changes/enums';
 import { CharacterFormattingScript } from '../../model/character/enums';
@@ -285,6 +285,7 @@ export class SelectionFormatter extends BatchUpdatableObject {
             throw new Error(Errors.InternalException);
         let currentLayoutRow = null;
         let currSelectionItem = null;
+        let wasPreviousBoxPicture = false;
         const selectedCellsCollector = new SelectedCellsCollector();
         let currPageIndex = -1;
         for (let isFirstBox = true; iterator.moveNext(new LayoutPositionCreatorConflictFlags().setDefault(!isFirstBox), new LayoutPositionCreatorConflictFlags().setDefault(true)); isFirstBox = false) {
@@ -324,15 +325,18 @@ export class SelectionFormatter extends BatchUpdatableObject {
             const absRowOffsetX = currPosition.pageArea.x + currPosition.column.x + currPosition.row.x;
             const absBoxOffsetX = currPosition.box.x + currentBoxLeftOffsetX + absRowOffsetX;
             const thereIsGap = !!currSelectionItem && !MathUtils.numberCloseTo(absBoxOffsetX, currSelectionItem.x + currSelectionItem.width);
-            const isNeedCreateNewSelectionRow = row !== currentLayoutRow || thereIsGap;
+            const isPictureBox = currPosition.box.getType() === LayoutBoxType.Picture;
+            const isNeedCreateNewSelectionRow = row !== currentLayoutRow || thereIsGap || isPictureBox || wasPreviousBoxPicture;
             if (isNeedCreateNewSelectionRow) {
                 currentLayoutRow = row;
                 const floatingObjectId = SelectionFormatter.getFloatingObjId(activeSubDocument, currPosition.page);
-                currSelectionItem = LayoutSelectionItem.create(currPosition, new Size(0, row.height), floatingObjectId, LayoutSelectionItem);
+                const itemCtor = isPictureBox ? LayoutSelectionPictureItem : LayoutSelectionItem;
+                currSelectionItem = LayoutSelectionItem.create(currPosition, new Size(0, row.height), floatingObjectId, itemCtor);
                 currSelectionItem.x += currPosition.box.x + currentBoxLeftOffsetX;
                 layoutSelectionInfo.registerItem(currPosition.pageIndex, currSelectionItem);
             }
             currSelectionItem.width += currentBoxRightOffsetX - currentBoxLeftOffsetX;
+            wasPreviousBoxPicture = isPictureBox;
         }
     }
     static isCellFullySelected(cell, allIntervals) {

package/lib/common/layout-formatter/box/generator/box-infos-generator.js

@@ -405,10 +405,14 @@ export class BoxGenerator {
                 const word = this.modelIterator.getRunText(currRunTextStart, currBoxLength);
                 currRunTextStart += currBoxLength;
                 const charProps = this.getActualCharacterProperties();
-                if (this.currBoxInfoType == LayoutBoxType.Text)
-                    this.addNewBoxInfo(new LayoutTextBox(charProps, charProps.getLayoutColorInfo(this.colorProvider), word), currRunTextStart);
-                else
-                    this.addNewBoxInfo(new LayoutDashBox(charProps, charProps.getLayoutColorInfo(this.colorProvider), word), currRunTextStart);
+                if (this.currBoxInfoType == LayoutBoxType.Text) {
+                    const newBox = new LayoutTextBox(charProps, charProps.getLayoutColorInfo(this.colorProvider), word);
+                    this.addNewBoxInfo(newBox, currRunTextStart);
+                }
+                else {
+                    const newBox = new LayoutDashBox(charProps, charProps.getLayoutColorInfo(this.colorProvider), word);
+                    this.addNewBoxInfo(newBox, currRunTextStart);
+                }
             } while (currRunTextStart < this.modelIterator.charOffset);
         }
         this.currBoxInfoType = LayoutBoxType.Text;

package/lib/common/layout-formatter/row/result.d.ts

@@ -25,6 +25,7 @@ export declare class RowFormatterResult {
     finishLogicalRow(currLogicRowEndPos: number): void;
     private deleteSomeAnchorObjects;
     finishRow(): void;
+    private getLastVisibleBox;
     private addBracketBox;
     private addBrackets;
     private getBracketBox;

package/lib/common/layout-formatter/row/result.js

@@ -81,10 +81,20 @@ export class RowFormatterResult {
         this.row.columnOffset = rowStartPos -
             this.rowFormatter.manager.activeFormatter.layoutPosition.getLogPosition(DocumentLayoutDetailsLevel.Column);
         const firstBox = this.row.boxes[0];
-        this.row.width = Math.max(this.row.width, lastBox.right - firstBox.x);
+        const lastVisibleBox = this.getLastVisibleBox();
+        if (lastVisibleBox)
+            this.row.width = Math.max(this.row.width, lastVisibleBox.right - firstBox.x);
         const currState = this.rowFormatter.rowSizesManager.heightCalculator.currState;
         this.row.increaseRowHeightFromSpacingBeforeAndAfter(currState.maxAscent, currState.maxDescent);
     }
+    getLastVisibleBox() {
+        for (let i = this.row.boxes.length - 1; i >= 0; i--) {
+            const box = this.row.boxes[i];
+            if (box.isVisible() && !box.isWhitespace())
+                return box;
+        }
+        return null;
+    }
     addBracketBox(boxType, color, x, layoutBox) {
         const box = new BookmarkBox(boxType);
         box.x = x - (boxType == LayoutBookmarkBoxType.EndBox ? BookmarkBox.DEFAULT_BORDER_WIDTH : 0);

package/lib/common/layout-formatter/row/size-engine/row-formatting-info.d.ts

@@ -4,7 +4,8 @@ import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 export declare class RowIntervalInfo extends FixedInterval {
     avaliableWidth: number;
     constructor(start: number, length: number, avaliableWidth?: number);
-    get busyWidth(): number;
+    get rawUsedWidth(): number;
+    get usedWidth(): number;
     get startOfFreeSpace(): number;
     isConsiderBoxes(): boolean;
 }

package/lib/common/layout-formatter/row/size-engine/row-formatting-info.js

@@ -11,11 +11,14 @@ export class RowIntervalInfo extends FixedInterval {
         super(start, length);
         this.avaliableWidth = avaliableWidth;
     }
-    get busyWidth() {
+    get rawUsedWidth() {
         return this.length - this.avaliableWidth;
     }
+    get usedWidth() {
+        return Math.min(this.rawUsedWidth, this.length);
+    }
     get startOfFreeSpace() {
-        return this.start + this.busyWidth;
+        return this.start + this.rawUsedWidth;
     }
     isConsiderBoxes() {
         return this.avaliableWidth != this.length;
@@ -71,7 +74,7 @@ export class RowFormattingInfo {
     recalculate(outerHorizontalRowContentBounds) {
         const currInterval = this.currInterval;
         this.calculate(outerHorizontalRowContentBounds);
-        const pos = currInterval.start + currInterval.busyWidth;
+        const pos = currInterval.start + currInterval.rawUsedWidth;
         const index = this.findIntervalIndexByPosition(pos);
         const interval = this.intervals[index];
         if (interval && interval.start < pos) {
@@ -91,7 +94,7 @@ export class RowFormattingInfo {
         return index;
     }
     canIncrementHeightTo(newHeight) {
-        const contentBounds = ListUtils.map(this.intervals, (c) => new Rectangle(c.start, this.minY, c.busyWidth, newHeight));
+        const contentBounds = ListUtils.map(this.intervals, (c) => new Rectangle(c.start, this.minY, c.usedWidth, newHeight));
         const intersectedObjects = this.calcIntersectObjects(newHeight);
         return !ListUtils.unsafeAnyOf(intersectedObjects, (ancBound) => ListUtils.unsafeAnyOf(contentBounds, (contentBound) => RectangleUtils.getNonCollapsedIntersection(contentBound, ancBound)));
     }

package/lib/common/model/sub-document.d.ts

@@ -17,7 +17,6 @@ import { RunBase } from './runs/run-base';
 import { Section } from './section/section';
 import { SubDocumentInfoBase } from './sub-document-infos';
 import { Table } from './tables/main-structures/table';
-import { InlinePictureRun } from './runs/inline-picture-run';
 export declare class SubDocument {
     static AUTOGENERATE_ID: number;
     static MAIN_SUBDOCUMENT_ID: number;
@@ -46,6 +45,7 @@ export declare class SubDocument {
     getText(interval?: FixedInterval): string;
     getSimpleText(interval: ConstInterval): string;
     getVisibleText(interval: ConstInterval, options?: IGetTextOptions): string;
+    private resolveChar;
     private isPositionVisible;
     splitRun(position: number): void;
     getLastRun(): RunBase;
@@ -126,11 +126,18 @@ export declare class SubDocumentIntervals implements ISubDocumentIntervals {
     equals(obj: SubDocumentIntervals): boolean;
     static fromPosition(subDocument: SubDocument, pos: number): SubDocumentIntervals;
 }
+export declare enum TransformAction {
+    InsertBefore = 0,
+    Replace = 1,
+    InsertAfter = 2
+}
 export interface IGetTextOptions {
     charMap?: Record<string, string>;
     includeNumberedListMarks?: boolean;
-    useFieldResult?: boolean;
-    paragraphEndMark?: string;
-    inlinePictureAltText?: string | ((run: InlinePictureRun) => string);
-    resolveAdditionalText?: (fieldIndexes: number[], pos: number) => string | null;
+    forceFieldResultText?: boolean;
+    transform?: (info: FullChunkAndRunInfo, fieldIndexes: number[]) => ITransformResult | string | null;
+}
+export interface ITransformResult {
+    text?: string | null;
+    action: TransformAction;
 }

package/lib/common/model/sub-document.js

@@ -12,7 +12,6 @@ import { PositionManager } from './position/position-manager';
 import { RichUtils } from './rich-utils';
 import { RunType } from './runs/run-type';
 import { ParagraphIterator } from '../layout-formatter/box/generator/one-dimension-itertors';
-import { isDefined } from '@devexpress/utils/lib/utils/common';
 import { FieldIterator } from '../layout-formatter/box/generator/recursive-objects-iterators';
 export class SubDocument {
     static { this.AUTOGENERATE_ID = -1; }
@@ -66,7 +65,7 @@ export class SubDocument {
     }
     getSimpleText(interval) {
         return this.getVisibleText(interval, {
-            useFieldResult: true,
+            forceFieldResultText: true,
             charMap: {
                 [RichUtils.specialCharacters.LineBreak]: ' ',
                 [RichUtils.specialCharacters.SectionMark]: '\r\n',
@@ -77,7 +76,7 @@ export class SubDocument {
     getVisibleText(interval, options = {}) {
         let result = [];
         let pos = interval.start;
-        const { charMap = {}, useFieldResult = false, includeNumberedListMarks = false, inlinePictureAltText = null, resolveAdditionalText = undefined, } = options;
+        const { charMap = {}, forceFieldResultText = false, includeNumberedListMarks = false, transform } = options;
         const iterator = new ModelIterator(this, true);
         iterator.setPosition(pos);
         const fieldIterator = new FieldIterator(this.fields);
@@ -85,36 +84,24 @@ export class SubDocument {
         const paragraphIterator = new ParagraphIterator(this.paragraphs);
         paragraphIterator.init(pos);
         while (pos < interval.end) {
-            if (this.isPositionVisible(pos, fieldIterator.indexes, useFieldResult)) {
+            if (this.isPositionVisible(pos, fieldIterator.indexes, forceFieldResultText)) {
                 const paragraph = this.paragraphs[paragraphIterator.index];
                 if (includeNumberedListMarks && pos === paragraph.startLogPosition.value && paragraph.isInList())
                     result.push(paragraph.getNumberingListText() + paragraph.getNumberingListSeparatorChar());
-                if (resolveAdditionalText) {
-                    const resolved = resolveAdditionalText(fieldIterator.indexes, pos);
-                    if (resolved)
-                        result.push(resolved);
-                }
-                switch (iterator.run.getType()) {
-                    case RunType.InlinePictureRun:
-                        if (inlinePictureAltText != null) {
-                            let placeholder;
-                            if (typeof inlinePictureAltText === "function")
-                                placeholder = inlinePictureAltText(iterator.run);
-                            else
-                                placeholder = inlinePictureAltText;
-                            if (isDefined(placeholder))
-                                result.push(placeholder);
-                        }
-                        break;
-                    case RunType.SectionRun:
-                    case RunType.ParagraphRun:
-                    case RunType.FieldCodeStartRun:
-                    case RunType.FieldCodeEndRun:
-                    case RunType.TextRun:
-                        const char = iterator.getCurrentChar();
-                        result.push(charMap[char] ?? char);
-                        break;
+                const transformResult = transform?.(iterator, fieldIterator.indexes);
+                if (transformResult != null) {
+                    if (typeof transformResult === "string")
+                        result.push(transformResult);
+                    else if (transformResult.text != null) {
+                        if (transformResult.action === TransformAction.InsertAfter)
+                            this.resolveChar(iterator, result, charMap);
+                        result.push(transformResult.text);
+                        if (transformResult.action === TransformAction.InsertBefore)
+                            this.resolveChar(iterator, result, charMap);
+                    }
                 }
+                else
+                    this.resolveChar(iterator, result, charMap);
                 if (!iterator.moveToNextChar())
                     break;
             }
@@ -126,10 +113,22 @@ export class SubDocument {
         }
         return result.join("");
     }
-    isPositionVisible(pos, fieldIndexes, useFieldResult) {
+    resolveChar(iterator, result, charMap) {
+        switch (iterator.run.getType()) {
+            case RunType.SectionRun:
+            case RunType.ParagraphRun:
+            case RunType.FieldCodeStartRun:
+            case RunType.FieldCodeEndRun:
+            case RunType.TextRun:
+                const char = iterator.getCurrentChar();
+                result.push(charMap[char] ?? char);
+                break;
+        }
+    }
+    isPositionVisible(pos, fieldIndexes, forceFieldResultText) {
         for (const index of fieldIndexes) {
             const field = this.fields[index];
-            const isCodeView = !useFieldResult && field.showCode;
+            const isCodeView = !forceFieldResultText && field.showCode;
             const invisibleInterval = isCodeView
                 ? field.getResultIntervalWithBorders()
                 : field.getCodeIntervalWithBorders();
@@ -510,6 +509,12 @@ export class SubDocumentIntervals {
         return new SubDocumentIntervals(subDocument, [new FixedInterval(pos, 0)]);
     }
 }
+export var TransformAction;
+(function (TransformAction) {
+    TransformAction[TransformAction["InsertBefore"] = 0] = "InsertBefore";
+    TransformAction[TransformAction["Replace"] = 1] = "Replace";
+    TransformAction[TransformAction["InsertAfter"] = 2] = "InsertAfter";
+})(TransformAction || (TransformAction = {}));
 function internalValidateInterval(subDocument, interval) {
     const documentEndPosition = subDocument.getDocumentEndPosition();
     if (interval.start == 0 && interval.end == documentEndPosition)

package/lib/common/rich-edit-core.js

@@ -85,7 +85,7 @@ export class RichEditCore {
         this.commandManager = this.createCommandManager();
         this.shortcutManager = this.createShortcutManager();
         this.searchManager = new SearchManager(this);
-        this.screenReaderManager = new ScreenReaderManager(this, this.createAriaLiveElement(element));
+        this.screenReaderManager = new ScreenReaderManager(this, this.createAriaLiveElement(element), this.stringResources);
         this.boxVisualizerManager.initListeners(this.viewManager);
         this.autoCorrectService = new AutoCorrectService(this, this.modelManager.richOptions.autoCorrect);
         this.clientSideEvents = new ClientSideEvents(this.owner);

package/lib/common/screen-reader-manager.d.ts

@@ -3,21 +3,22 @@ import { IRichEditControl } from "./interfaces/i-rich-edit-core";
 import { LayoutPosition } from "./layout/layout-position";
 import { ISelectionChangesListener } from "./selection/i-selection-changes-listener";
 import { Selection } from "./selection/selection";
+import { StringResources } from "./string-resources";
 export declare class ScreenReaderManager implements ISelectionChangesListener {
     private static _maxAnnouncedTextLength;
     private static _spaceSeparatorRegex;
-    private static _specialCharSubstitutionTable;
     private _charNames;
     readonly _handlers: Map<RichEditClientCommand, (selection: Selection, lp: LayoutPosition) => string>;
     private _selectionIntervals;
     private _commandId;
     private _control;
     private _liveRegion;
+    private _announcements;
     private _announceTimeoutId;
     private _pageIndex;
     private _tableInfo;
     private _prevNavInHyperlink;
-    constructor(control: IRichEditControl, liveRegion: HTMLDivElement);
+    constructor(control: IRichEditControl, liveRegion: HTMLDivElement, resources: StringResources);
     private _announce;
     private _clearAnnouncement;
     beginExecute(commandId: RichEditClientCommand): void;
@@ -36,7 +37,9 @@ export declare class ScreenReaderManager implements ISelectionChangesListener {
     private _getHyperlinkField;
     private _onHyperlinkFieldStart;
     private _getVisibleText;
-    private static _getInlinePictureText;
+    private _tryResolveDocumentElements;
+    private _tryResolveSpecialCharacters;
+    private _getInlinePictureText;
     private _getPageChangePrefix;
     private _getCharName;
     private _resolveListMarker;