devexpress-richedit 25.2.8 → 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/command-manager.d.ts

@@ -22,6 +22,8 @@ export declare abstract class CommandManager implements ISelectionChangesListene
     dispose(): void;
     abortClipboardCommandExecution(): void;
     getCommand(key: RichEditClientCommand): ICommand;
+    getExecutingCommandsChainDebug(): string[];
+    getLastCommandsChainDebug(): string[];
     beforeExecuting(command: ICommand): void;
     afterExecuting(): void;
     assertLastExecutedCommandsChain(checkLength: boolean, ...types: Function[]): boolean;

package/lib/common/commands/command-manager.js

@@ -579,6 +579,12 @@ export class CommandManager {
     getCommand(key) {
         return this.commands[key];
     }
+    getExecutingCommandsChainDebug() {
+        return this.executingCommandsChain.map(command => command?.constructor?.name || 'UnknownCommand');
+    }
+    getLastCommandsChainDebug() {
+        return this.lastCommandsChain.map(command => command?.constructor?.name || 'UnknownCommand');
+    }
     beforeExecuting(command) {
         this.executingCommandsChain.push(command);
         this.executingCommandCounter++;

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/layout/switch-view-command.js

@@ -16,7 +16,8 @@ export class ChangeViewTypeCommand extends CommandBase {
         return true;
     }
     executeCore(_state, options) {
-        if (this.control.innerClientProperties.viewsSettings.viewType != options.param) {
+        const currentViewType = this.control.innerClientProperties.viewsSettings.viewType;
+        if (currentViewType != options.param) {
             if (this.selection.activeSubDocument.isHeaderFooter())
                 this.control.commandManager.getCommand(RichEditClientCommand.ChangeActiveSubDocumentToMain)
                     .execute(this.control.commandManager.isPublicApiCall, new CommandOptions(this.control));

package/lib/common/commands/selection/go-to-next-word-command.d.ts

@@ -1,9 +1,8 @@
-import { CommandBase, ICommandOptions } from '../command-base';
+import { ICommandOptions } from '../command-base';
 import { SimpleCommandState } from '../command-states';
-export declare class GoToNextWordCommandBase extends CommandBase<SimpleCommandState> {
-    getState(): SimpleCommandState;
+import { SelectionCommandBase } from './selection-command-base';
+export declare class GoToNextWordCommandBase extends SelectionCommandBase {
     getStartPosition(): number;
-    isEnabledInReadOnlyMode(): boolean;
 }
 export declare class GoToNextWordCommand extends GoToNextWordCommandBase {
     executeCore(_state: SimpleCommandState, _options: ICommandOptions): boolean;

package/lib/common/commands/selection/go-to-next-word-command.js

@@ -1,18 +1,11 @@
 import { LayoutWordBounds } from '../../word-bounds-engine/layout-word-bounds';
-import { CommandBase } from '../command-base';
-import { SimpleCommandState } from '../command-states';
 import { ExtendGoToNextCharacterCommand } from './go-to-next-character-command';
-export class GoToNextWordCommandBase extends CommandBase {
-    getState() {
-        return new SimpleCommandState(this.isEnabled());
-    }
+import { SelectionCommandBase } from './selection-command-base';
+export class GoToNextWordCommandBase extends SelectionCommandBase {
     getStartPosition() {
         var selection = this.selection;
         return selection.forwardDirection ? selection.lastSelectedInterval.end : selection.lastSelectedInterval.start;
     }
-    isEnabledInReadOnlyMode() {
-        return true;
-    }
 }
 export class GoToNextWordCommand extends GoToNextWordCommandBase {
     executeCore(_state, _options) {

package/lib/common/commands/selection/go-to-prev-word-command.d.ts

@@ -1,6 +1,7 @@
-import { CommandBase, ICommandOptions } from '../command-base';
+import { ICommandOptions } from '../command-base';
 import { SimpleCommandState } from '../command-states';
-export declare abstract class GoToPrevWordCommandBase extends CommandBase<SimpleCommandState> {
+import { SelectionCommandBase } from './selection-command-base';
+export declare abstract class GoToPrevWordCommandBase extends SelectionCommandBase {
     getState(): SimpleCommandState;
     getStartPosition(): number;
     isEnabledInReadOnlyMode(): boolean;

package/lib/common/commands/selection/go-to-prev-word-command.js

@@ -1,10 +1,10 @@
 import { LayoutPositionCreatorConflictFlags, LayoutPositionMainSubDocumentCreator, LayoutPositionOtherSubDocumentCreator } from '../../layout-engine/layout-position-creator';
 import { DocumentLayoutDetailsLevel } from '../../layout/document-layout-details-level';
 import { LayoutWordBounds } from '../../word-bounds-engine/layout-word-bounds';
-import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 import { ExtendGoToPrevCharacterCommand } from './go-to-prev-character-command';
-export class GoToPrevWordCommandBase extends CommandBase {
+import { SelectionCommandBase } from './selection-command-base';
+export class GoToPrevWordCommandBase extends SelectionCommandBase {
     getState() {
         return new SimpleCommandState(this.isEnabled());
     }

package/lib/common/commands/selection/select-all-document-command.d.ts

@@ -3,5 +3,7 @@ import { SimpleCommandState } from '../command-states';
 export declare class SelectAllDocumentCommand extends CommandBase<SimpleCommandState> {
     getState(): SimpleCommandState;
     executeCore(_state: SimpleCommandState, _options: ICommandOptions): boolean;
+    protected beforeExecute(): void;
+    protected afterExecute(): void;
     isEnabledInReadOnlyMode(): boolean;
 }

package/lib/common/commands/selection/select-all-document-command.js

@@ -12,6 +12,12 @@ export class SelectAllDocumentCommand extends CommandBase {
         this.control.focusManager.captureFocus();
         return true;
     }
+    beforeExecute() {
+        this.control.screenReaderManager.beginExecute(this.commandId);
+    }
+    afterExecute() {
+        this.control.screenReaderManager.endExecute();
+    }
     isEnabledInReadOnlyMode() {
         return true;
     }

package/lib/common/commands/selection/selection-command-base.d.ts

@@ -8,4 +8,6 @@ export declare class SelectionCommandBase extends CommandBase<SimpleCommandState
     protected shouldCollapseSingleCellTableSelection(entryDirection: TableNavDirection, shrinkDirection: TableNavDirection): boolean;
     protected collapseSingleCellTableSelectionToCaret(): boolean;
     protected collapseTableCellSelectionSpatialFocus(direction: TableNavDirection): boolean;
+    beforeExecute(): void;
+    afterExecute(): void;
 }

package/lib/common/commands/selection/selection-command-base.js

@@ -98,4 +98,12 @@ export class SelectionCommandBase extends CommandBase {
         selection.deprecatedSetSelection(pos, pos, false, -1, true);
         return true;
     }
+    beforeExecute() {
+        super.beforeExecute();
+        this.control.screenReaderManager.beginExecute(this.commandId);
+    }
+    afterExecute() {
+        super.afterExecute();
+        this.control.screenReaderManager.endExecute();
+    }
 }

package/lib/common/event-manager.js

@@ -54,18 +54,12 @@ export class EventManager {
         clearTimeout(this.onMouseUpTimerId);
     }
     onShortcut(shortcutCode) {
-        this.control.beginUpdate();
-        try {
-            if (this.accumulatedText.length)
-                this.insertFunc();
-            this.control.shortcutManager.processShortcut(shortcutCode);
-            this.mouseHandler.onShortcut(shortcutCode);
-            if (EnumUtils.isAnyOf(shortcutCode, KeyCode.Enter, KeyCode.Tab, KeyCode.Space) && this.control.selection.lastSelectedInterval.start > 0)
-                this.control.autoCorrectService.performAutoCorrect();
-        }
-        finally {
-            this.control.endUpdate();
-        }
+        if (this.accumulatedText.length)
+            this.insertFunc();
+        this.control.shortcutManager.processShortcut(shortcutCode);
+        this.mouseHandler.onShortcut(shortcutCode);
+        if (EnumUtils.isAnyOf(shortcutCode, KeyCode.Enter, KeyCode.Tab, KeyCode.Space) && this.control.selection.lastSelectedInterval.start > 0)
+            this.control.autoCorrectService.performAutoCorrect();
     }
     onMouseDown(evt) {
         Log.print(LogSource.EventManager, "onMouseDown", LogObjToStrCanvas.richMouseEvent(evt));

package/lib/common/formats/txt/txt-exporter.js

@@ -22,7 +22,7 @@ export class TxtExporter {
             this.model.mainSubDocument.paragraphs.forEach((p, index) => {
                 if (index > 0)
                     text += '\r\n';
-                text += this.model.mainSubDocument.getSimpleText(new FixedInterval(p.startLogPosition.value, p.length));
+                text += this.model.mainSubDocument.getSimpleText(new FixedInterval(p.startLogPosition.value, p.length - 1));
             });
             callback(new Blob([text], { type: PlainTextMimeType }));
         });

package/lib/common/input-controller.js

@@ -91,6 +91,7 @@ export class InputEditorBase {
     createHierarchy(parent) {
         this.inputElement = this.createInputElement();
         this.inputElement.classList.add(INPUT_CLASS_NAME);
+        this.inputElement.setAttribute('aria-hidden', 'true');
         parent.appendChild(this.inputElement);
         this.createHierarchyCore();
         this.inputElement.addEventListener("load", () => this.recreateIfNeeded(), true);
@@ -585,6 +586,7 @@ export class IFrameInputEditor extends InputEditorBase {
     }
     createInputElement() {
         const element = document.createElement("IFRAME");
+        element.setAttribute("aria-hidden", "true");
         element.src = "about:blank";
         if (Browser.Safari) {
             element.style.width = "100%";

package/lib/common/interfaces/i-rich-edit-core.d.ts

@@ -38,6 +38,7 @@ import { SearchManager } from '../ui/search-manager';
 import { IControlOwner } from './i-control-owner';
 import { IExportModelOptions } from '../formats/i-document-exporter';
 import { ModelScrollManager } from '../scroll/model-scroll-manager';
+import { ScreenReaderManager } from '../screen-reader-manager';
 export interface IBarListener extends IEventListener {
     NotifyBarCommandExecuted(commandID: RichEditClientCommand, parameter: any): any;
     NotifyBarUpdateRequested(): any;
@@ -86,6 +87,7 @@ export interface IRichEditControl extends IBatchUpdatableObject, IDisposable, IR
     owner: IControlOwner;
     selectionModelChangesListener: SelectionModelChangesListener;
     pdfHelperFrame: PdfHelperFrame;
+    screenReaderManager: ScreenReaderManager;
     getExportModelOptions(initOptions?: Partial<IExportModelOptions>): IExportModelOptions;
     isClientMode(): boolean;
     createFieldRequestManager(): FieldRequestManager;

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/model/sub-document.d.ts

@@ -44,6 +44,9 @@ export declare class SubDocument {
     getFirstParagraph(): Paragraph;
     getText(interval?: FixedInterval): string;
     getSimpleText(interval: ConstInterval): string;
+    getVisibleText(interval: ConstInterval, options?: IGetTextOptions): string;
+    private resolveChar;
+    private isPositionVisible;
     splitRun(position: number): void;
     getLastRun(): RunBase;
     getFirstRun(): RunBase;
@@ -123,3 +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;
+    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

@@ -5,13 +5,14 @@ import { SearchUtils } from '@devexpress/utils/lib/utils/search';
 import { SpellCheckerIntervalsManager } from '../spelling/intervals-manager';
 import { RunIterator } from './character/run-iterator';
 import { ResetFormattingCacheType } from './document-model';
-import { Field } from './fields/field';
 import { FullChunkAndRunInfo } from './full-chunk-and-run-info';
 import { BookmarksManipulator } from './manipulators/bookmarks-manipulator';
 import { ModelIterator } from './model-iterator';
 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 { FieldIterator } from '../layout-formatter/box/generator/recursive-objects-iterators';
 export class SubDocument {
     static { this.AUTOGENERATE_ID = -1; }
     static { this.MAIN_SUBDOCUMENT_ID = 0; }
@@ -63,36 +64,78 @@ export class SubDocument {
         return buffer;
     }
     getSimpleText(interval) {
-        let result = "";
+        return this.getVisibleText(interval, {
+            forceFieldResultText: true,
+            charMap: {
+                [RichUtils.specialCharacters.LineBreak]: ' ',
+                [RichUtils.specialCharacters.SectionMark]: '\r\n',
+                [RichUtils.specialCharacters.ParagraphMark]: '\r\n'
+            }
+        });
+    }
+    getVisibleText(interval, options = {}) {
+        let result = [];
         let pos = interval.start;
-        let nested = 0;
-        const fieldIndex = Field.normedBinaryIndexOf(this.fields, pos);
-        if (fieldIndex > -1) {
-            let field = this.fields[fieldIndex];
-            while (field.parent)
-                field = field.parent;
-            pos = field.getFieldStartPosition();
-        }
+        const { charMap = {}, forceFieldResultText = false, includeNumberedListMarks = false, transform } = options;
         const iterator = new ModelIterator(this, true);
         iterator.setPosition(pos);
+        const fieldIterator = new FieldIterator(this.fields);
+        fieldIterator.init(pos);
+        const paragraphIterator = new ParagraphIterator(this.paragraphs);
+        paragraphIterator.init(pos);
         while (pos < interval.end) {
-            switch (iterator.run.getType()) {
-                case RunType.FieldCodeStartRun:
-                    nested++;
-                    break;
-                case RunType.FieldCodeEndRun:
-                    nested--;
-                    break;
-                case RunType.TextRun:
-                    if (pos >= interval.start && nested == 0)
-                        result += iterator.getCurrentChar();
+            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());
+                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;
             }
-            if (!iterator.moveToNextChar())
+            else if (!iterator.moveToNextRun())
                 break;
             pos = iterator.getAbsolutePosition();
+            paragraphIterator.update(pos);
+            fieldIterator.update(pos);
+        }
+        return result.join("");
+    }
+    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 = !forceFieldResultText && field.showCode;
+            const invisibleInterval = isCodeView
+                ? field.getResultIntervalWithBorders()
+                : field.getCodeIntervalWithBorders();
+            if (invisibleInterval.contains(pos))
+                return false;
         }
-        return result.replace(RichUtils.specialCharacters.LineBreak, " ");
+        return true;
     }
     splitRun(position) {
         var info = this.getRunAndIndexesByPosition(position);
@@ -466,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.d.ts

@@ -38,6 +38,7 @@ import { RulerSettings } from './ui/ruler/settings';
 import { SearchManager } from './ui/search-manager';
 import { IExportModelOptions } from './formats/i-document-exporter';
 import { ModelScrollManager } from './scroll/model-scroll-manager';
+import { ScreenReaderManager } from './screen-reader-manager';
 export declare abstract class RichEditCore implements IRichEditControl {
     modelManager: IModelManager;
     barHolder: IBarHolder;
@@ -71,6 +72,7 @@ export declare abstract class RichEditCore implements IRichEditControl {
     owner: IControlOwner;
     selectionModelChangesListener: SelectionModelChangesListener;
     readonly pdfHelperFrame: PdfHelperFrame;
+    screenReaderManager: ScreenReaderManager;
     private closed;
     sessionGuid: string;
     private clientGuid;
@@ -119,6 +121,7 @@ export declare abstract class RichEditCore implements IRichEditControl {
     getExportModelOptions(initOptions?: Partial<IExportModelOptions>): IExportModelOptions;
     ensureDocumentIsFullyFormatted(): void;
     protected abstract createSpellChecker(): any;
+    protected createAriaLiveElement(element: HTMLElement): HTMLDivElement;
     protected createViewElement(id: string, element: HTMLElement): HTMLDivElement;
     private isUsedInnerClipboard;
     getExportDocumentFormat(): DocumentFormat;