devexpress-richedit 25.1.1-alpha → 25.1.3

package/lib/common/model/paragraph/paragraph-style.d.ts

@@ -53,7 +53,8 @@ export declare abstract class TabInfoBase<T extends TabInfoBase<T>> implements I
 }
 export declare class TabInfo extends TabInfoBase<TabInfo> {
     position: number;
-    constructor(position: number, alignment: TabAlign, leader: TabLeaderType, deleted: boolean, isDefault: boolean);
+    readonly isParagraphIndent: boolean;
+    constructor(position: number, alignment: TabAlign, leader: TabLeaderType, deleted: boolean, isDefault: boolean, isParagraphIndent?: boolean);
     equals(obj: TabInfo): boolean;
     clone(): TabInfo;
 }

package/lib/common/model/paragraph/paragraph-style.js

@@ -123,9 +123,10 @@ export class TabInfoBase {
     }
 }
 export class TabInfo extends TabInfoBase {
-    constructor(position, alignment, leader, deleted, isDefault) {
+    constructor(position, alignment, leader, deleted, isDefault, isParagraphIndent = false) {
         super(alignment, leader, deleted, isDefault);
         this.position = position;
+        this.isParagraphIndent = isParagraphIndent;
     }
     equals(obj) {
         return super.equals(obj) && this.position == obj.position;

package/lib/common/model/tables/secondary-structures/table-base-structures.d.ts

@@ -94,5 +94,6 @@ export declare enum ConditionalTableStyleFormatting {
     TopRightCell = 8,
     TopLeftCell = 4,
     BottomRightCell = 2,
-    BottomLeftCell = 1
+    BottomLeftCell = 1,
+    None = 0
 }

package/lib/common/model/tables/secondary-structures/table-base-structures.js

@@ -124,4 +124,5 @@ export var ConditionalTableStyleFormatting;
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["TopLeftCell"] = 4] = "TopLeftCell";
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["BottomRightCell"] = 2] = "BottomRightCell";
     ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["BottomLeftCell"] = 1] = "BottomLeftCell";
+    ConditionalTableStyleFormatting[ConditionalTableStyleFormatting["None"] = 0] = "None";
 })(ConditionalTableStyleFormatting || (ConditionalTableStyleFormatting = {}));

package/lib/common/mouse-handler/mouse-handler/mouse-handler-default-state.d.ts

@@ -32,7 +32,7 @@ export declare class MouseHandlerDefaultState extends MouseHandlerStateBase {
     private shouldBeginDragExistingSelection;
     private selectImage;
     private beginDragExistingSelection;
-    selectFloatingObject(box: LayoutAnchoredObjectBox): void;
+    selectFloatingObject(box: LayoutAnchoredObjectBox): boolean;
 }
 export declare class MouseHandlerHelper {
     static selectParentsTextBox(control: IRichEditControl): void;

package/lib/common/mouse-handler/mouse-handler/mouse-handler-default-state.js

@@ -168,40 +168,31 @@ export class MouseHandlerDefaultState extends MouseHandlerStateBase {
         this.processMouseDownOnMaxDetailsLevel(evt, htr, activeSubDocument);
     }
     processMouseDownOnMaxDetailsLevel(evt, htr, activeSubDocument) {
+        const selection = this.handler.control.selection;
         if (htr.floatingObject) {
-            if (htr.floatingObject.belongsToSubDocId != this.handler.control.selection.activeSubDocument.id)
-                MouseHandlerHelper.changeActiveSubDocumentToParent(this.handler.control);
             const box = htr.floatingObject;
-            this.selectFloatingObject(box);
-            const specRunInfo = this.handler.control.selection.specialRunInfo;
-            if (specRunInfo.isSelectedAnchorObject) {
-                if (box.getType() == LayoutBoxType.AnchorTextBox &&
-                    HitTestManager.isPointInTexBoxArea(evt.layoutPoint, box, activeSubDocument.isTextBox() ? 0 : box.rotationInRadians)) {
+            const rotationAngle = activeSubDocument.isTextBox() ? 0 : box.rotationInRadians;
+            if (box.getType() == LayoutBoxType.AnchorTextBox && HitTestManager.isPointInTexBoxArea(evt.layoutPoint, box, rotationAngle)) {
+                const textbox = box;
+                if (textbox.internalSubDocId !== selection.activeSubDocument.id && this.selectFloatingObject(box)) {
                     this.handler.control.commandManager.getCommand(RichEditClientCommand.ChangeActiveSubDocumentToTextBox).execute(this.handler.control.commandManager.isPublicApiCall);
                     this.handler.boxVisualizerManager.resizeBoxVisualizer.show(htr.pageIndex, null, null, null, box);
-                    htr = this.handler.control.hitTestManager.calculate(evt.layoutPoint, DocumentLayoutDetailsLevel.Max, this.handler.control.selection.activeSubDocument);
-                }
-                else {
-                    if (this.resizeRotationChecker(() => {
-                        const dragFloatingObjectState = new MouseHandlerDragFloatingObjectState(this.handler, evt);
-                        this.handler.switchState(new MouseHandlerBeginDragHelperState(evt.layoutPoint, this.handler, dragFloatingObjectState));
-                    }))
-                        return;
-                    else {
-                        if (specRunInfo.isPictureSelected()) {
-                            this.handler.control.selection.setSelection(new SetSelectionParams()
-                                .setInterval(new FixedInterval(specRunInfo.getPicturePosition(), 1)));
-                            return;
-                        }
-                    }
+                    htr = this.handler.control.hitTestManager.calculate(evt.layoutPoint, DocumentLayoutDetailsLevel.Max, selection.activeSubDocument);
                 }
             }
+            else {
+                if (this.selectFloatingObject(box) && this.resizeRotationChecker(() => {
+                    const dragFloatingObjectState = new MouseHandlerDragFloatingObjectState(this.handler, evt);
+                    this.handler.switchState(new MouseHandlerBeginDragHelperState(evt.layoutPoint, this.handler, dragFloatingObjectState));
+                }))
+                    return;
+            }
         }
         if (Browser.TouchUI && htr.subDocument.isMain() && htr.exactlyDetailLevel < DocumentLayoutDetailsLevel.PageArea) {
             if (htr.deviations[DocumentLayoutDetailsLevel.PageArea] & HitTestDeviation.Top || htr.deviations[DocumentLayoutDetailsLevel.PageArea] & HitTestDeviation.Bottom)
                 this.handler.control.viewManager.canvasScrollManager.waitForDblClick();
         }
-        if (evt.button === MouseButton.Right && this.handler.control.selection.lastSelectedInterval.contains(htr.getPosition()))
+        if (evt.button === MouseButton.Right && selection.lastSelectedInterval.contains(htr.getPosition()))
             return;
         if (this.shouldSelectEntireTableColumn(htr))
             this.beginSelectEntireTableColumn(htr, evt);
@@ -216,7 +207,7 @@ export class MouseHandlerDefaultState extends MouseHandlerStateBase {
                 this.beginSelectEntireTableCell(htr, evt);
         }
         else if (this.isLeftArea(htr, evt)) {
-            if (evt.modifiers & ModifierKey.Ctrl && this.handler.control.selection.isCollapsed())
+            if (evt.modifiers & ModifierKey.Ctrl && selection.isCollapsed())
                 this.handler.control.commandManager.getCommand(RichEditClientCommand.SelectAll).execute(this.handler.control.commandManager.isPublicApiCall, htr.getPosition());
             else if (this.isLeftAreaOffset(htr, evt))
                 this.beginLineSelection(htr, evt);
@@ -424,8 +415,14 @@ export class MouseHandlerDefaultState extends MouseHandlerStateBase {
         this.handler.switchState(state);
     }
     selectFloatingObject(box) {
+        const selection = this.handler.control.selection;
+        if (box.belongsToSubDocId !== selection.activeSubDocument.id)
+            MouseHandlerHelper.changeActiveSubDocumentToParent(this.handler.control);
+        if (box.belongsToSubDocId !== selection.activeSubDocument.id)
+            return false;
         const pos = this.handler.control.layout.anchorObjectsPositionInfo.getPosition(box.objectId);
-        this.handler.control.selection.setSelection(new SetSelectionParams().setInterval(new FixedInterval(pos, 1)));
+        selection.setSelection(new SetSelectionParams().setInterval(new FixedInterval(pos, 1)));
+        return selection.specialRunInfo.isSelectedAnchorObject;
     }
 }
 export class MouseHandlerHelper {

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

@@ -44,7 +44,7 @@ import { HorizontalRulerControl } from './ui/ruler/ruler';
 import { SearchManager } from './ui/search-manager';
 import { isDefined } from '@devexpress/utils/lib/utils/common';
 export class RichEditCore {
-    get isReadOnlyPersistent() { return this.readOnly == ReadOnlyMode.Persistent; }
+    get isReadOnlyPersistent() { return this.readOnly === ReadOnlyMode.Persistent; }
     get model() { return this.modelManager.model; }
     get isDisposed() {
         return this._isDisposed;
@@ -139,15 +139,19 @@ export class RichEditCore {
         ]);
         this.modelManager.modelManipulator.clearListeners();
         this.modelManager.history.clear();
-        this.modelManager.modelManipulator.modelListeners.push(this.inputPositionModelChangesListener);
-        this.modelManager.modelManipulator.modelListeners.push(this.layoutFormatterManager.modelChangesListener);
-        this.modelManager.modelManipulator.modelListeners.push(this.selectionModelChangesListener);
-        this.modelManager.modelManipulator.modelListeners.push(new SpellCheckerModelChangesListener(this.spellChecker));
+        this.modelManager.modelManipulator.addModelListener(this.inputPositionModelChangesListener);
+        this.modelManager.modelManipulator.addModelListener(this.layoutFormatterManager.modelChangesListener);
+        this.modelManager.modelManipulator.addModelListener(this.selectionModelChangesListener);
+        this.modelManager.modelManipulator.addModelListener(new SpellCheckerModelChangesListener(this.spellChecker));
         if (this.barHolder.ribbon)
-            this.modelManager.modelManipulator.modelListeners.push(this.barHolder.ribbon);
-        this.modelManager.modelManipulator.modelListeners.push(this.barHolder.contextMenu);
-        this.modelManager.modelManipulator.modelListeners.push(this.horizontalRulerControl);
-        this.modelManager.modelManipulator.modelListeners.push(this.selectionFormatter);
+            this.modelManager.modelManipulator.addModelListener(this.barHolder.ribbon);
+        this.modelManager.modelManipulator.addModelListener(this.barHolder.contextMenu);
+        this.modelManager.modelManipulator.addModelListener(this.horizontalRulerControl);
+        this.modelManager.modelManipulator.addModelListener(this.selectionFormatter);
+        this.modelManager.modelManipulator.addModelListener(this.viewManager);
+        this.modelManager.modelManipulator.addModelListener(this.viewManager.canvasManager.simpleViewCanvasSizeManager);
+        this.modelManager.modelManipulator.addModelListener(this.viewManager.canvasScrollManager);
+        this.modelManager.modelManipulator.addModelListener(this.viewManager.scroll);
         this.registerFontChangesListeners();
         this.selection.onChanged.add(this.searchManager);
         this.selection.onChanged.add(this.boxVisualizerManager.resizeBoxVisualizer);
@@ -164,8 +168,8 @@ export class RichEditCore {
         this.selection.onChanged.add(this.globalEventDispatcher);
         this.selection.onChanged.add(this.barHolder.publicUiChangesListener);
         this.registerActiveContextTabManager();
-        this.modelManager.modelManipulator.modelListeners.push(this.globalEventDispatcher);
-        this.modelManager.modelManipulator.modelListeners.push(this.barHolder.publicUiChangesListener);
+        this.modelManager.modelManipulator.addModelListener(this.globalEventDispatcher);
+        this.modelManager.modelManipulator.addModelListener(this.barHolder.publicUiChangesListener);
         this.inputController.initExporter();
     }
     dispose() {
@@ -253,8 +257,8 @@ export class RichEditCore {
             this.readOnly = ReadOnlyMode.Persistent;
         else if (!readOnly && this.readOnly === ReadOnlyMode.Persistent) {
             this.readOnly = ReadOnlyMode.None;
-            this.inputController.inputEditor.initializeIfNotReadOnly();
         }
+        this.inputController.inputEditor.initializeEditableStateCore();
     }
     setWorkSession(sessionGuid, documentInfo) {
         this.sessionGuid = sessionGuid;
@@ -288,12 +292,7 @@ export class RichEditCore {
     }
     closeDocument() {
         this.selection.onChanged.remove(this.globalEventDispatcher);
-        for (let ind = 0; ind < this.modelManager.modelManipulator.modelListeners.length; ind++) {
-            if (this.modelManager.modelManipulator.modelListeners[ind] == this.globalEventDispatcher) {
-                this.modelManager.modelManipulator.modelListeners.splice(ind, 1);
-                break;
-            }
-        }
+        this.modelManager.modelManipulator.removeModelListener(this.globalEventDispatcher);
         this.barHolder.setEnabled(false);
         if (this.horizontalRulerControl)
             this.horizontalRulerControl.setEnable(false);
@@ -380,6 +379,7 @@ export class RichEditCore {
             pictureRenderer: this.viewManager.renderer,
             uiUnitConverter: this.uiUnitConverter,
             lastMaxNumPages: this.layout.lastMaxNumPages,
+            grids: this.layout.grids,
             pageIndex: this.selection.pageIndex,
             sessionGuid: this.sessionGuid,
             clientGuid: this.clientGuid,

package/lib/common/ui/ruler/controls/ruler.js

@@ -41,13 +41,9 @@ export class RulerControl extends RulerBase {
     }
     adjust() {
         const viewWidth = this.controls.canvas.clientWidth;
-        if (viewWidth > this.pageWidth)
-            this.initialMarginLeftElement = (viewWidth - this.pageWidth - RULLER_NUMBER_CORRECTION * 2) / 2;
-        else {
-            const paddingLeft = DomUtils.pxToInt(DomUtils.getCurrentStyle(this.controls.canvas).paddingLeft);
-            const pageAreaBorderWidth = (this.controls.canvas.scrollWidth - paddingLeft - this.pageWidth) / 2;
-            this.initialMarginLeftElement = paddingLeft + pageAreaBorderWidth - RULLER_NUMBER_CORRECTION;
-        }
+        const paddingLeft = DomUtils.pxToInt(DomUtils.getCurrentStyle(this.controls.canvas).paddingLeft);
+        const minValue = paddingLeft - RULLER_NUMBER_CORRECTION;
+        this.initialMarginLeftElement = Math.max((viewWidth - this.pageWidth - RULLER_NUMBER_CORRECTION * 2) / 2, minValue);
         this.rootElement.style.left = this.calculateLeftOffset();
         this.setPaddings();
         this.canHandleScroll = this.controls.canvas.scrollWidth > this.controls.canvas.offsetWidth;

package/lib/common/ui/ruler/controls/vertical-line.js

@@ -1,6 +1,7 @@
 import { DomUtils } from '@devexpress/utils/lib/utils/dom';
 import { DocumentRenderer } from '../../../canvas/renderes/common/document-renderer';
 import { RULLER_NUMBER_CORRECTION } from '../settings';
+import { SizeUtils } from '../../../../common/utils/size-utils';
 export const TABLE_COLUMN_SEPARATOR_RULER_LINE_CLASS_NAME = " table";
 export var SnapTo;
 (function (SnapTo) {
@@ -33,7 +34,7 @@ export class RulerVerticalLineControl {
             DomUtils.addClassName(this.rootElement, TABLE_COLUMN_SEPARATOR_RULER_LINE_CLASS_NAME);
         else
             DomUtils.removeClassName(this.rootElement, TABLE_COLUMN_SEPARATOR_RULER_LINE_CLASS_NAME);
-        this.rootElement.style.height = this.canvas.clientHeight + "px";
+        this.rootElement.style.height = SizeUtils.getClientHeight(this.canvas) + "px";
         this.rootElement.style.top = this.canvas.offsetTop + "px";
         this.rulerControlLeft = this.rulerControlElement.offsetLeft;
         this.rulerControlWidth = this.rulerControlElement.offsetWidth;

package/lib/common/ui/ruler/ruler.js

@@ -146,6 +146,8 @@ export class HorizontalRulerControl extends BatchUpdatableObject {
             case ModelChangeType.TableCellRemoved:
             case ModelChangeType.TableCellInserted:
                 return HorizontalRulerEventType.FullReset;
+            case ModelChangeType.ZoomLevelChanged:
+                return HorizontalRulerEventType.FullReset;
             default:
                 return HorizontalRulerEventType.None;
         }

package/lib/common/utils/mixed-size.d.ts

@@ -0,0 +1,27 @@
+export declare class MixedSize {
+    static fromLayout(value: number): MixedSize;
+    static fromUI(value: number): MixedSize;
+    private _UISizePart;
+    private _UISize;
+    private _layoutSizePart;
+    private _layoutSize;
+    private _scale;
+    private _scaleIsSpecified;
+    get UISize(): number;
+    get LayoutSize(): number;
+    private get UISizePart();
+    private set UISizePart(value);
+    private get LayoutSizePart();
+    private set LayoutSizePart(value);
+    private onSizeChanged;
+    addUISize(value: number): this;
+    addLayoutSize(value: number): this;
+    addSize(value: MixedSize): this;
+    subtractUISize(value: number): this;
+    subtractLayoutSize(value: number): this;
+    subtractSize(value: MixedSize): this;
+    private checkSizeHasSameScale;
+    private checkScaleIsSpecified;
+    useScale(value: number): this;
+    clear(): this;
+}

package/lib/common/utils/mixed-size.js

@@ -0,0 +1,91 @@
+import { isDefined } from "@devexpress/utils/lib/utils/common";
+export class MixedSize {
+    constructor() {
+        this._UISizePart = 0;
+        this._layoutSizePart = 0;
+        this._scale = 1;
+        this._scaleIsSpecified = false;
+    }
+    static fromLayout(value) {
+        return new MixedSize().addLayoutSize(value);
+    }
+    static fromUI(value) {
+        return new MixedSize().addUISize(value);
+    }
+    get UISize() {
+        this.checkScaleIsSpecified();
+        if (!isDefined(this._UISize))
+            this._UISize = this._layoutSizePart * this._scale + this._UISizePart;
+        return this._UISize;
+    }
+    get LayoutSize() {
+        this.checkScaleIsSpecified();
+        if (!isDefined(this._layoutSize))
+            this._layoutSize = this._layoutSizePart + this._UISizePart / this._scale;
+        return this._layoutSize;
+    }
+    get UISizePart() {
+        return this._UISizePart;
+    }
+    set UISizePart(value) {
+        this._UISizePart = value;
+        this.onSizeChanged();
+    }
+    get LayoutSizePart() {
+        return this._layoutSizePart;
+    }
+    set LayoutSizePart(value) {
+        this._layoutSizePart = value;
+        this.onSizeChanged();
+    }
+    onSizeChanged() {
+        this._UISize = null;
+        this._layoutSize = null;
+    }
+    addUISize(value) {
+        this.UISizePart += value;
+        return this;
+    }
+    addLayoutSize(value) {
+        this.LayoutSizePart += value;
+        return this;
+    }
+    addSize(value) {
+        this.checkSizeHasSameScale(value);
+        this.addLayoutSize(value._layoutSizePart);
+        this.addUISize(value._UISizePart);
+        return this;
+    }
+    subtractUISize(value) {
+        this.UISizePart -= value;
+        return this;
+    }
+    subtractLayoutSize(value) {
+        this.LayoutSizePart -= value;
+        return this;
+    }
+    subtractSize(value) {
+        this.checkSizeHasSameScale(value);
+        this.subtractLayoutSize(value._layoutSizePart);
+        this.subtractUISize(value._UISizePart);
+        return this;
+    }
+    checkSizeHasSameScale(size) {
+        if (size._scaleIsSpecified && size._scale !== this._scale)
+            throw new Error("The size has a different scale and cannot be added.");
+    }
+    checkScaleIsSpecified() {
+        if (!this._scaleIsSpecified)
+            console.warn("MixedSize is used without specifying the scale.");
+    }
+    useScale(value) {
+        this._scale = value;
+        this._scaleIsSpecified = true;
+        return this;
+    }
+    clear() {
+        this.UISizePart = 0;
+        this.LayoutSizePart = 0;
+        return this;
+    }
+}

package/lib/common/utils/size-utils.d.ts

@@ -1,11 +1,17 @@
+type ScrollbarsWidth = {
+    horizontal: number;
+    vertical: number;
+};
 export declare class SizeUtils {
-    static getWidthInfo(element: Element): DimensionInfo;
-    static getClientWidth(element: Element): number;
-    static getHeightInfo(element: Element): DimensionInfo;
-    static getClientHeight(element: Element): number;
-    static getOffsetSize(element: Element): DOMRect;
-    static getOffsetWidth(element: Element): number;
-    static getOffsetHeight(element: Element): number;
+    private static _scrollbarsWidth;
+    static getScrollbarsWidth(): ScrollbarsWidth;
+    static getWidthInfo(element: HTMLElement): DimensionInfo;
+    static getClientWidth(element: HTMLElement): number;
+    static getHeightInfo(element: HTMLElement): DimensionInfo;
+    static getClientHeight(element: HTMLElement): number;
+    static getOffsetSize(element: HTMLElement): DOMRect;
+    static getOffsetWidth(element: HTMLElement): number;
+    static getOffsetHeight(element: HTMLElement): number;
 }
 export declare class DimensionInfo {
     readonly offsetSize: number;
@@ -13,3 +19,4 @@ export declare class DimensionInfo {
     readonly scrollbarSize: number;
     constructor(offsetSize: number, clientSize: number, scrollbarSize: number);
 }
+export {};

package/lib/common/utils/size-utils.js

@@ -1,28 +1,53 @@
+import { isDefined } from "@devexpress/utils/lib/utils/common";
 export class SizeUtils {
+    static getScrollbarsWidth() {
+        if (!isDefined(this._scrollbarsWidth)) {
+            const scrollDiv = document.createElement('div');
+            scrollDiv.style.visibility = 'hidden';
+            scrollDiv.style.overflow = 'scroll';
+            scrollDiv.style.position = 'absolute';
+            scrollDiv.style.top = '-9999px';
+            scrollDiv.style.width = '100px';
+            scrollDiv.style.height = '100px';
+            document.body.appendChild(scrollDiv);
+            const innerDiv = document.createElement('div');
+            innerDiv.style.width = '100%';
+            innerDiv.style.height = '100%';
+            scrollDiv.appendChild(innerDiv);
+            this._scrollbarsWidth = {
+                horizontal: SizeUtils.getOffsetHeight(scrollDiv) - SizeUtils.getOffsetHeight(innerDiv),
+                vertical: SizeUtils.getOffsetWidth(scrollDiv) - SizeUtils.getOffsetWidth(innerDiv)
+            };
+            scrollDiv.remove();
+        }
+        return this._scrollbarsWidth;
+    }
     static getWidthInfo(element) {
-        const offsetSize = SizeUtils.getOffsetWidth(element);
-        const style = getComputedStyle(element);
-        const inset = parseCssValue(style.borderLeftWidth)
-            + parseCssValue(style.borderRightWidth)
-            + parseCssValue(style.paddingLeft)
-            + parseCssValue(style.paddingRight);
-        const sizeWithScrollBar = offsetSize - inset;
-        const scrollBarSize = Math.round(sizeWithScrollBar) - element.clientWidth;
-        return new DimensionInfo(offsetSize, sizeWithScrollBar - scrollBarSize, scrollBarSize);
+        const computedStyle = getComputedStyle(element);
+        const offsetWidth = this.getOffsetWidth(element);
+        const offsetWidthWithoutBorder = offsetWidth
+            - parseCssValue(computedStyle.borderLeftWidth)
+            - parseCssValue(computedStyle.borderRightWidth);
+        let scrollbarWidth = 0;
+        if (Math.round(offsetWidthWithoutBorder) > element.clientWidth)
+            scrollbarWidth = SizeUtils.getScrollbarsWidth().vertical;
+        const clientWidth = offsetWidthWithoutBorder - scrollbarWidth;
+        return new DimensionInfo(offsetWidth, clientWidth, scrollbarWidth);
     }
     static getClientWidth(element) {
         return this.getWidthInfo(element).clientSize;
     }
     static getHeightInfo(element) {
-        const offsetSize = SizeUtils.getOffsetHeight(element);
-        const style = getComputedStyle(element);
-        const inset = parseCssValue(style.borderTopWidth)
-            + parseCssValue(style.borderBottomWidth)
-            + parseCssValue(style.paddingTop)
-            + parseCssValue(style.paddingBottom);
-        const sizeWithScrollBar = offsetSize - inset;
-        const scrollBarSize = Math.round(sizeWithScrollBar) - element.clientHeight;
-        return new DimensionInfo(offsetSize, sizeWithScrollBar - scrollBarSize, scrollBarSize);
+        const computedStyle = getComputedStyle(element);
+        const offsetHeight = this.getOffsetHeight(element);
+        const offsetHeightWithoutBorder = offsetHeight
+            - parseCssValue(computedStyle.borderTopWidth)
+            - parseCssValue(computedStyle.borderBottomWidth);
+        let scrollbarWidth = 0;
+        if (Math.round(offsetHeightWithoutBorder) > element.clientHeight)
+            scrollbarWidth = SizeUtils.getScrollbarsWidth().horizontal;
+        const clientHeight = offsetHeightWithoutBorder - scrollbarWidth;
+        return new DimensionInfo(offsetHeight, clientHeight, scrollbarWidth);
     }
     static getClientHeight(element) {
         return this.getHeightInfo(element).clientSize;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devexpress-richedit",
-  "version": "25.1.1-alpha",
+  "version": "25.1.3",
   "homepage": "https://www.devexpress.com/",
   "bugs": "https://www.devexpress.com/support/",
   "author": "Developer Express Inc.",
@@ -14,8 +14,8 @@
     "build-nspell": "webpack --mode production --config=bin/nspell.webpack.config.js"
   },
   "peerDependencies": {
-    "devextreme": "25.1.1-alpha",
-    "devextreme-dist": "25.1.1-alpha"
+    "devextreme": "25.1.3",
+    "devextreme-dist": "25.1.3"
   },
   "dependencies": {
     "jszip": "~3.10.1",

package/lib/common/commands/layout/toggle-allow-zoom-command.d.ts

@@ -1,7 +0,0 @@
-import { CommandBase, CommandSimpleOptions } from '../command-base';
-import { SimpleCommandState } from '../command-states';
-export declare class ToggleAllowZoomCommand extends CommandBase<SimpleCommandState> {
-    getState(): SimpleCommandState;
-    executeCore(_state: SimpleCommandState, options: CommandSimpleOptions<boolean>): boolean;
-    isEnabledInReadOnlyMode(): boolean;
-}

package/lib/common/commands/layout/toggle-allow-zoom-command.js

@@ -1,17 +0,0 @@
-import { CommandBase } from '../command-base';
-import { SimpleCommandState } from '../command-states';
-export class ToggleAllowZoomCommand extends CommandBase {
-    getState() {
-        return new SimpleCommandState(this.isEnabled(), this.control.viewManager.allowZoom);
-    }
-    executeCore(_state, options) {
-        const allowZoom = this.control.viewManager.allowZoom;
-        if (options.param === allowZoom)
-            return false;
-        this.control.viewManager.allowZoom = !allowZoom;
-        return true;
-    }
-    isEnabledInReadOnlyMode() {
-        return true;
-    }
-}