devexpress-richedit 25.1.12 → 25.1.13

package/index.d.ts

@@ -1,6 +1,6 @@
 /**
 * DevExpress WebRichEdit (index.d.ts)
-* Version: 25.1.12
+* Version: 25.1.13
 * Copyright (c) 2012 - 2026 Developer Express Inc. ALL RIGHTS RESERVED
 * License: https://www.devexpress.com/Support/EULAs",
 */

package/index.js

@@ -1,6 +1,6 @@
 /**
 * DevExpress WebRichEdit (index.js)
-* Version: 25.1.12
+* Version: 25.1.13
 * Copyright (c) 2012 - 2026 Developer Express Inc. ALL RIGHTS RESERVED
 * License: https://www.devexpress.com/Support/EULAs",
 */

package/lib/client/client-rich-edit.js

@@ -62,8 +62,8 @@ export class ClientRichEdit {
         this.rawDataSource = settings.rawDataSource;
         this.contextMenuSettings = settings.contextMenuSettings;
         this.fullScreenHelper = new FullScreenHelper(element);
-        if ("eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaWFFVTFORFkxU3pSUlpYaFNVWGxFWjIxTldtaHRVeUlLZlE9PS5hc1crYVJtdENhb2ZiRVJBTERDVkNmVTlCOGgxS3Y5SHBRRFhCQWphWUIxNHRmUEx6a09xdkhRbnlieFNVdEdKbmZ0dnkxNDQ5UE9QL1pmd1pzRThBTG4zWnpIaWEvWlVmTWNNUytOL2liNEM3VEhOS2tZYnZyL3AxaEVzTnVnRDgzZnhxdz09In0=")
-            config(JSON.parse(atob("eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaWFFVTFORFkxU3pSUlpYaFNVWGxFWjIxTldtaHRVeUlLZlE9PS5hc1crYVJtdENhb2ZiRVJBTERDVkNmVTlCOGgxS3Y5SHBRRFhCQWphWUIxNHRmUEx6a09xdkhRbnlieFNVdEdKbmZ0dnkxNDQ5UE9QL1pmd1pzRThBTG4zWnpIaWEvWlVmTWNNUytOL2liNEM3VEhOS2tZYnZyL3AxaEVzTnVnRDgzZnhxdz09In0=")));
+        if ("eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaWRVSmhTVkoxT1hFNFoxTkpiemx6ZHpKd01GbElNQ0lLZlE9PS5NZW93UmpFY0N3YjVSZ0REdCtQRmNaTnZmUklyZERYRUp3Z3llYi9hd1BnTHVUWGxSMTRlTjdPNFVIelZDNzZxOEd0MDc4ZDJTYThRUktlVXVSVDh0TVVoVC9sV1VSOW52a1ZjcHhOWEN5V1BYV0dTWkM3SGhnVnlseTFacVUxeXAralhGUT09In0=")
+            config(JSON.parse(atob("eyJsaWNlbnNlS2V5IjoiZXdvZ0lDSm1iM0p0WVhRaU9pQXhMQW9nSUNKcGJuUmxjbTVoYkZWellXZGxTV1FpT2lBaWRVSmhTVkoxT1hFNFoxTkpiemx6ZHpKd01GbElNQ0lLZlE9PS5NZW93UmpFY0N3YjVSZ0REdCtQRmNaTnZmUklyZERYRUp3Z3llYi9hd1BnTHVUWGxSMTRlTjdPNFVIelZDNzZxOEd0MDc4ZDJTYThRUktlVXVSVDh0TVVoVC9sV1VSOW52a1ZjcHhOWEN5V1BYV0dTWkM3SGhnVnlseTFacVUxeXAralhGUT09In0=")));
         this.prepareElement(element, settings);
         this.initDefaultFontsAndStyles();
         this.initBars(settings.ribbon, settings.fonts);

package/lib/client/document-processor/processor.d.ts

@@ -39,5 +39,6 @@ export declare abstract class DocumentProcessorBase implements IProcessor {
     beginUpdate(): void;
     endUpdate(): void;
     invalidateLayoutAfterFontsLoaded(): void;
+    protected ensureDocumentIsFullyFormatted(): void;
     getExportModelOptions(initOptions?: Partial<IExportModelOptions>): IExportModelOptions;
 }

package/lib/client/document-processor/processor.js

@@ -92,11 +92,22 @@ export class DocumentProcessorBase {
             this.layoutFormatterManager.invalidator.onChangedAllLayout();
         }
     }
+    ensureDocumentIsFullyFormatted() {
+        if (this.layoutFormatterManager.isDocumentOpened) {
+            while (!this.layoutFormatterManager.layout.isFullyFormatted)
+                this.layoutFormatterManager.forceFormatPage(this.layoutFormatterManager.layout.validPageCount + 1);
+        }
+    }
     getExportModelOptions(initOptions = {}) {
+        let grids;
         return {
             modelManager: isDefined(initOptions.modelManager) ? initOptions.modelManager : this.modelManager,
             pictureRenderer: this.documentRenderer,
             uiUnitConverter: this.uiUnitConverter,
+            getGrids: () => {
+                this.ensureDocumentIsFullyFormatted();
+                return grids !== null && grids !== void 0 ? grids : (grids = this.layoutFormatterManager.layout.grids);
+            },
             sessionGuid: this.sessionGuid,
             clientGuid: this.clientGuid,
             documentFormat: isDefined(initOptions.documentFormat) ? initOptions.documentFormat : DocumentFormat.OpenXml,

package/lib/common/canvas/canvas-manager.d.ts

@@ -12,7 +12,7 @@ export declare class CanvasManager extends BatchUpdatableObject {
     private scrollIntervalID;
     private lastMousePosition;
     private canvasPosition;
-    private doubleTapStartDate;
+    private doubleTapDetector;
     private pointer;
     private blockNotPointerEvents;
     private lastPointerPosition;

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

@@ -10,6 +10,7 @@ import { PopupUtils } from '@devexpress/utils/lib/utils/popup';
 import { RichMouseEvent } from '../event-manager';
 import { MouseEventSource } from '../mouse-handler/mouse-event-source';
 import { CursorPointer } from '../mouse-handler/mouse-handler/mouse-handler';
+import { DoubleTapDetector } from './double-tap-detector';
 import { ResizeBoxListener } from './listeners/resize-box-listener';
 import { SimpleViewCanvasSizeManager } from './renderes/common/document-renderer';
 import { SizeUtils } from '../utils/size-utils';
@@ -19,6 +20,8 @@ const CSSCLASS_FOCUSED = "dxreInFocus";
 const AUTOSCROLL_AREA_SIZE = 10;
 const AUTOSCROLL_STEP = 10;
 const MSTOUCH_MOVE_SENSITIVITY = 5;
+const DOUBLE_TAP_MAX_DISTANCE = 20;
+const DOUBLE_TAP_MAX_INTERVAL = 600;
 export class CanvasManager extends BatchUpdatableObject {
     get sizes() { return this.viewManager.sizes; }
     get scroll() { return this.viewManager.scroll; }
@@ -27,6 +30,7 @@ export class CanvasManager extends BatchUpdatableObject {
         super();
         this.lastMousePosition = { x: -1, y: -1 };
         this.canvasPosition = { x: -1, y: -1 };
+        this.doubleTapDetector = new DoubleTapDetector(DOUBLE_TAP_MAX_DISTANCE, DOUBLE_TAP_MAX_INTERVAL);
         this.pointer = CursorPointer.Auto;
         this.blockNotPointerEvents = false;
         this.lastPointerPosition = { x: -1, y: -1 };
@@ -137,12 +141,12 @@ export class CanvasManager extends BatchUpdatableObject {
     onCanvasTouchStartInternal(evt) {
         this.saveMousePosition(evt);
         let richMouseEvent = new RichMouseEvent(evt, this.getLayoutPoint(evt, true), CanvasManager.getMouseEventSource(EvtUtils.getEventSource(evt)), this.scroll.lastScrollTop, this.scroll.lastScrollLeft);
-        if (this.doubleTapStartDate && ((new Date()) - this.doubleTapStartDate) < 600) {
-            this.doubleTapStartDate = null;
+        const evtX = EvtUtils.getEventX(evt);
+        const evtY = EvtUtils.getEventY(evt);
+        if (this.doubleTapDetector.isDoubleTap(evtX, evtY)) {
             this.onCanvasDoubleTap(richMouseEvent);
         }
         else {
-            this.doubleTapStartDate = new Date();
             this.eventManager.onTouchStart(richMouseEvent);
         }
     }

package/lib/common/canvas/double-tap-detector.d.ts

@@ -0,0 +1,10 @@
+export declare class DoubleTapDetector {
+    private readonly maxDistance;
+    private readonly maxInterval;
+    private lastTime;
+    private lastX;
+    private lastY;
+    constructor(maxDistance: number, maxInterval: number);
+    isDoubleTap(x: number, y: number): boolean;
+    reset(): void;
+}

package/lib/common/canvas/double-tap-detector.js

@@ -0,0 +1,28 @@
+export class DoubleTapDetector {
+    constructor(maxDistance, maxInterval) {
+        this.maxDistance = maxDistance;
+        this.maxInterval = maxInterval;
+        this.lastTime = null;
+        this.lastX = -1;
+        this.lastY = -1;
+    }
+    isDoubleTap(x, y) {
+        const now = Date.now();
+        const result = this.lastTime !== null &&
+            (now - this.lastTime) < this.maxInterval &&
+            Math.abs(x - this.lastX) <= this.maxDistance &&
+            Math.abs(y - this.lastY) <= this.maxDistance;
+        if (result) {
+            this.reset();
+        }
+        else {
+            this.lastTime = now;
+            this.lastX = x;
+            this.lastY = y;
+        }
+        return result;
+    }
+    reset() {
+        this.lastTime = null;
+    }
+}

package/lib/common/canvas/renderes/common/document-renderer.js

@@ -869,7 +869,7 @@ export class DocumentRenderer {
         }
         if (isDefined(altText) && !StringUtils.isNullOrEmpty(altText))
             img.alt = altText;
-        img.style.cssText = `height: ${MathUtils.round(size.height, 3)}px; width: ${MathUtils.round(size.width, 3)}px; vertical-align: baseline`;
+        img.style.cssText = `height: ${MathUtils.round(size.height, 3)}px; width: ${MathUtils.round(size.width, 3)}px`;
         img.setAttribute('class', RendererClassNames.PICTURE);
         return img;
     }

package/lib/common/commands/floating-objects/floating-object-drag-drop-change-position-command.js

@@ -155,7 +155,11 @@ export class FloatingObjectDragDropChangePositionCommand extends CommandBase {
     moveOutsideTable(oldRun, oldRunPos, endPageIndex, pagePosition) {
         this.removeOldRun(oldRun, oldRunPos);
         this.control.layoutFormatterManager.forceFormatPage(endPageIndex);
-        const layoutPoint = new LayoutPoint(Math.min(endPageIndex, this.control.layout.pages.length), pagePosition.x, pagePosition.y);
+        if (endPageIndex >= this.control.layout.pages.length) {
+            this.addRun(oldRun, oldRunPos, oldRun.anchorInfo);
+            return;
+        }
+        const layoutPoint = new LayoutPoint(endPageIndex, pagePosition.x, pagePosition.y);
         const htr = this.control.hitTestManager.calculate(layoutPoint, DocumentLayoutDetailsLevel.Row, this.activeSubDocument);
         const paragraphStartHTR = this.findParagraphStartOnThisPage(htr);
         const newLogPos = this.getNewLogPosition(this.activeSubDocument, paragraphStartHTR);

package/lib/common/commands/text/clipboard-commands.d.ts

@@ -44,7 +44,6 @@ export declare class CutSelectionCommand extends ClipboardCommand {
 }
 export declare class PasteSelectionCommand extends ClipboardCommand {
     constructor(control: IRichEditControl);
-    protected getTimeout(): number;
     pasteEventRaised(): void;
     changeModel(): void;
     isEnabled(): boolean;

package/lib/common/commands/text/clipboard-commands.js

@@ -138,8 +138,7 @@ export class ClipboardCommand extends CommandBase {
     }
 }
 ClipboardCommand.additionalWaitingTimeForMac = 10;
-ClipboardCommand.timeout = Browser.Firefox ? 10 :
-    (Browser.MacOSPlatform && (Browser.WebKitFamily || Browser.Opera) ? 10 : 0);
+ClipboardCommand.timeout = 0;
 export class CopySelectionCommand extends ClipboardCommand {
     constructor(control) {
         super(control, "copy");
@@ -207,9 +206,6 @@ export class PasteSelectionCommand extends ClipboardCommand {
     constructor(control) {
         super(control, "paste");
     }
-    getTimeout() {
-        return Browser.MacOSPlatform ? 300 : super.getTimeout();
-    }
     pasteEventRaised() {
         if (Browser.MacOSPlatform && this.control.commandManager.clipboardTimerId !== null) {
             setTimeout(() => {

package/lib/common/commands/text/drag-drop-commands.js

@@ -119,6 +119,8 @@ export class DragMoveContentCommand extends CommandBase {
     tryMoveIntervalInsideTable(intervalsInfo, positionTo) {
         if (!intervalsInfo.tableInfo.extendedData.numRows)
             return false;
+        if (ListUtils.unsafeAnyOf(intervalsInfo.intervals, (interval) => interval.start <= positionTo && interval.end >= positionTo))
+            return true;
         const subDocument = intervalsInfo.subDocument;
         const linkedIntervals = ListUtils.map(intervalsInfo.intervals, (curr) => new LinkedInterval(intervalsInfo.subDocument.positionManager, curr));
         this.history.addTransaction(() => {

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

@@ -13,7 +13,8 @@ export declare enum LayoutRowStateFlags {
     SectionEnd = 8,
     DocumentEnd = 16,
     CellTableEnd = 64,
-    PageBreakBefore = 128
+    PageBreakBefore = 128,
+    ContainsText = 256
 }
 export declare class LayoutRow extends Rectangle {
     boxes: LayoutBox[];

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

@@ -12,6 +12,7 @@ export var LayoutRowStateFlags;
     LayoutRowStateFlags[LayoutRowStateFlags["DocumentEnd"] = 16] = "DocumentEnd";
     LayoutRowStateFlags[LayoutRowStateFlags["CellTableEnd"] = 64] = "CellTableEnd";
     LayoutRowStateFlags[LayoutRowStateFlags["PageBreakBefore"] = 128] = "PageBreakBefore";
+    LayoutRowStateFlags[LayoutRowStateFlags["ContainsText"] = 256] = "ContainsText";
 })(LayoutRowStateFlags || (LayoutRowStateFlags = {}));
 export class LayoutRow extends Rectangle {
     get hasEffectToPageHeight() { return this.boxes.length != 1 || !this.boxes[0].isSectionBreakBox; }

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

@@ -67,9 +67,12 @@ export class RowFormatter {
         const prevRow = this.manager.activeFormatter.lastRowInfo.row;
         const isFirstRowInParagraph = !prevRow || prevRow.flags.get(LayoutRowStateFlags.ParagraphEnd) ||
             this.manager.activeFormatter.lastRowInfo.paragraphIndex != this.currWrapInfo.paragraphIndex;
-        const rowParagraphLeftIndent = isFirstRowInParagraph ?
+        let rowParagraphLeftIndent = isFirstRowInParagraph ?
             UnitConverter.twipsToPixelsF(this.paragraphProps.getLeftIndentForFirstRow()) :
             UnitConverter.twipsToPixelsF(this.paragraphProps.getLeftIndentForOtherRow());
+        if (this.manager.innerClientProperties.viewsSettings.isSimpleView) {
+            rowParagraphLeftIndent = Math.max(0, rowParagraphLeftIndent);
+        }
         const rowContentHorizontalBounds = FixedInterval.fromPositions(paragraphHorizontalBounds.start + rowParagraphLeftIndent, paragraphHorizontalBounds.end - UnitConverter.twipsToPixelsF(this.paragraphProps.rightIndent));
         this.rowSizesManager = new RowSizesManager(this, rowContentHorizontalBounds, minY, rowSpacingBeforeApplier, this.manager.activeFormatter.layoutRowBoundsCalculator.getRectangleBounds(this.manager), isFirstRowInParagraph);
         this.tabInfo = new RowTabInfo(this, paragraphHorizontalBounds.start);

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

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

package/lib/common/layout-formatter/row/size-engine/row-height-calculator.js

@@ -1,6 +1,7 @@
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
 import { AnchoredObjectLevelType } from '../../../layout/main-structures/layout-boxes/layout-anchored-object-box';
 import { LayoutBoxType } from '../../../layout/main-structures/layout-boxes/layout-box';
+import { LayoutRowStateFlags } from '../../../layout/main-structures/layout-row';
 import { ParagraphLineSpacingType } from '../../../model/paragraph/paragraph-properties';
 import { LineSpacingCalculator } from '../utils/line-spacing-calculator';
 import { RowHeightState } from './row-height-state';
@@ -12,7 +13,7 @@ export class RowHeightCalculator {
         this.rowFormatter = rowFormatter;
         this.rowSpacingBeforeApplier = rowSpacingBeforeApplier;
         this.lineSpacingCalculator = LineSpacingCalculator.create(this.rowFormatter.paragraphProps.lineSpacing, this.rowFormatter.paragraphProps.lineSpacingType);
-        this.currState = new RowHeightState(0, 0, 0, 0);
+        this.currState = new RowHeightState(0, 0, 0, 0, false);
         this.currState.height = 0;
         this.currState.baseLine = 0;
         this.currState.spacingBefore = 0;
@@ -25,11 +26,11 @@ export class RowHeightCalculator {
             case LayoutBoxType.FieldCodeStart:
             case LayoutBoxType.FieldCodeEnd:
             case LayoutBoxType.Dash: {
-                info = new RowHeightState(Math.max(box.height, this.currState.maxBoxHeight), Math.max(box.getAscent(), this.currState.maxAscent), Math.max(box.getDescent(), this.currState.maxDescent), this.currState.maxPictureBoxHeight);
+                info = new RowHeightState(Math.max(box.height, this.currState.maxBoxHeight), Math.max(box.getAscent(), this.currState.maxAscent), Math.max(box.getDescent(), this.currState.maxDescent), this.currState.maxPictureBoxHeight, this.currState.containsText || true);
                 break;
             }
             case LayoutBoxType.Picture: {
-                info = new RowHeightState(Math.max(box.height, this.currState.maxBoxHeight), this.currState.maxAscent, this.currState.maxDescent, Math.max(box.height, this.currState.maxPictureBoxHeight));
+                info = new RowHeightState(Math.max(box.height, this.currState.maxBoxHeight), this.currState.maxAscent, this.currState.maxDescent, Math.max(box.height, this.currState.maxPictureBoxHeight), this.currState.containsText || false);
                 break;
             }
             default:
@@ -40,7 +41,7 @@ export class RowHeightCalculator {
     calcNewState(newInfo) {
         if (this.currState.equalHeights(newInfo) || newInfo.maxBoxHeight == 0)
             return this.currState;
-        this.calcRowParams(newInfo.maxBoxHeight, newInfo.maxAscent, newInfo.maxDescent, newInfo.maxPictureBoxHeight);
+        this.calcRowParams(newInfo.maxBoxHeight, newInfo.maxAscent, newInfo.maxDescent, newInfo.maxPictureBoxHeight, newInfo.containsText);
         newInfo.initFromRow(this.row);
         return newInfo;
     }
@@ -71,7 +72,7 @@ export class RowHeightCalculator {
         }
     }
     applyT584234Height(b) {
-        const info = new RowHeightState(Math.max(b.height, this.currState.maxBoxHeight), Math.max(b.getAscent(), this.currState.maxAscent), Math.max(b.getDescent(), this.currState.maxDescent), this.currState.maxPictureBoxHeight);
+        const info = new RowHeightState(Math.max(b.height, this.currState.maxBoxHeight), Math.max(b.getAscent(), this.currState.maxAscent), Math.max(b.getDescent(), this.currState.maxDescent), this.currState.maxPictureBoxHeight, this.currState.containsText);
         this.applyState(this.calcNewState(info));
     }
     setFinalRowParams() {
@@ -84,23 +85,31 @@ export class RowHeightCalculator {
         const lastBox = ListUtils.last(row.boxes);
         if (!lastBox && ListUtils.unsafeAnyOf(this.rowFormatter.result.newAnchoredObjects, (obj) => obj.levelType == AnchoredObjectLevelType.InText))
             return true;
-        this.calcRowParams(lastBox.height, lastBox.getAscent(), lastBox.getDescent(), this.currState.maxPictureBoxHeight);
+        this.calcRowParams(lastBox.height, lastBox.getAscent(), lastBox.getDescent(), this.currState.maxPictureBoxHeight, this.currState.containsText);
         this.currState.initFromRow(this.row);
         return false;
     }
-    calcRowParams(maxBoxHeight, maxAscent, maxDescent, maxPictureBoxHeight) {
+    calcRowParams(maxBoxHeight, maxAscent, maxDescent, maxPictureBoxHeight, containsText) {
         const row = this.row;
         row.rollbackSpacingBefore();
-        row.height = this.lineSpacingCalculator.calculate(maxBoxHeight, maxAscent, maxDescent, maxPictureBoxHeight);
+        row.flags.set(LayoutRowStateFlags.ContainsText, containsText);
+        row.height = this.lineSpacingCalculator.calculate(maxBoxHeight, maxAscent, maxDescent, maxPictureBoxHeight, containsText);
+        const descent = this.lineSpacingCalculator.calculateDescent(maxAscent, maxDescent, maxPictureBoxHeight, containsText);
         switch (this.rowFormatter.paragraphProps.lineSpacingType) {
             case ParagraphLineSpacingType.AtLeast:
             case ParagraphLineSpacingType.Exactly:
-                row.baseLine = Math.max(0, row.height - maxDescent);
+                row.baseLine = Math.max(0, row.height - descent);
                 row.lineHeight = row.height;
                 break;
             default:
-                row.baseLine = Math.max(maxAscent, maxPictureBoxHeight);
-                row.lineHeight = Math.max(maxAscent + maxDescent, maxPictureBoxHeight);
+                const textHeight = maxAscent + descent;
+                if (textHeight < maxPictureBoxHeight)
+                    row.baseLine = maxPictureBoxHeight;
+                else if (!containsText && maxPictureBoxHeight > 0)
+                    row.baseLine = textHeight;
+                else
+                    row.baseLine = maxAscent;
+                row.lineHeight = Math.max(textHeight, maxPictureBoxHeight);
         }
         this.rowSpacingBeforeApplier.apply(this.row, this.rowFormatter.result.paragraphIndex);
     }

package/lib/common/layout-formatter/row/size-engine/row-height-state.d.ts

@@ -7,7 +7,8 @@ export declare class RowHeightState {
     height: number;
     baseLine: number;
     spacingBefore: number;
-    constructor(maxBoxHeight: number, maxAscent: number, maxDescent: number, maxPictureBoxHeight: number);
+    containsText: boolean;
+    constructor(maxBoxHeight: number, maxAscent: number, maxDescent: number, maxPictureBoxHeight: number, containsText: boolean);
     initFromRow(row: LayoutRow): void;
     applyToRow(row: LayoutRow): void;
     getFullRowHeight(): number;

package/lib/common/layout-formatter/row/size-engine/row-height-state.js

@@ -1,20 +1,24 @@
+import { LayoutRowStateFlags } from '../../../layout/main-structures/layout-row';
 export class RowHeightState {
-    constructor(maxBoxHeight, maxAscent, maxDescent, maxPictureBoxHeight) {
+    constructor(maxBoxHeight, maxAscent, maxDescent, maxPictureBoxHeight, containsText) {
         this.maxBoxHeight = maxBoxHeight;
         this.maxAscent = maxAscent;
         this.maxDescent = maxDescent;
         this.maxPictureBoxHeight = maxPictureBoxHeight;
+        this.containsText = containsText;
     }
     initFromRow(row) {
         this.height = row.height;
         this.baseLine = row.baseLine;
         this.spacingBefore = row.getSpacingBefore();
+        this.containsText = row.flags.get(LayoutRowStateFlags.ContainsText);
     }
     applyToRow(row) {
         row.rollbackSpacingBefore();
         row.applySpacingBefore(this.spacingBefore);
         row.height = this.height;
         row.baseLine = this.baseLine;
+        row.flags.set(LayoutRowStateFlags.ContainsText, this.containsText);
     }
     getFullRowHeight() {
         return this.height + this.spacingBefore;
@@ -23,6 +27,7 @@ export class RowHeightState {
         return this.maxBoxHeight == obj.maxBoxHeight &&
             this.maxAscent == obj.maxAscent &&
             this.maxDescent == obj.maxDescent &&
-            this.maxPictureBoxHeight == obj.maxPictureBoxHeight;
+            this.maxPictureBoxHeight == obj.maxPictureBoxHeight &&
+            this.containsText == obj.containsText;
     }
 }

package/lib/common/layout-formatter/row/utils/line-spacing-calculator.d.ts

@@ -1,7 +1,8 @@
 import { ParagraphLineSpacingType } from '../../../model/paragraph/paragraph-properties';
 export declare abstract class LineSpacingCalculator {
     static create(lineSpacing: number, lineSpacingType: ParagraphLineSpacingType): LineSpacingCalculator;
-    calculate(rowHeight: number, maxAscent: number, maxDescent: number, maxPictureHeight: number): number;
+    calculate(rowHeight: number, maxAscent: number, maxDescent: number, maxPictureHeight: number, containsText: boolean): number;
+    calculateDescent(maxAscent: number, maxDescent: number, maxPictureHeight: number, containsText: boolean): number;
     abstract calculateSpacing(maxTextHeight: number): number;
     abstract calculateSpacingInlineObjectCase(maxTextHeight: number, rowTextSpacing: number, maxPictureHeight: number, maxDescent: number): number;
 }
@@ -28,10 +29,10 @@ export declare class ExactlySpacingCalculator extends LineSpacingCalculator {
     constructor(lineSpacing: number);
     calculateSpacing(_maxTextHeight: number): number;
     calculateSpacingInlineObjectCase(_maxTextHeight: number, _rowTextSpacing: number, _maxPictureHeight: number, _maxDescent: number): number;
-    calculate(_rowHeight: number, _maxAscent: number, _maxDescent: number, _maxPictureHeight: number): number;
+    calculate(_rowHeight: number, _maxAscent: number, _maxDescent: number, _maxPictureHeight: number, _containsText: boolean): number;
 }
 export declare class AtLeastSpacingCalculator extends SingleSpacingCalculator {
     lineSpacing: number;
     constructor(lineSpacing: number);
-    calculate(rowHeight: number, maxAscent: number, maxDescent: number, maxPictureHeight: number): number;
+    calculate(rowHeight: number, maxAscent: number, maxDescent: number, maxPictureHeight: number, containsText: boolean): number;
 }

package/lib/common/layout-formatter/row/utils/line-spacing-calculator.js

@@ -19,19 +19,21 @@ export class LineSpacingCalculator {
                 return new SingleSpacingCalculator();
         }
     }
-    calculate(rowHeight, maxAscent, maxDescent, maxPictureHeight) {
-        const maxTextHeight = maxAscent + maxDescent;
-        if (maxTextHeight == 0)
+    calculate(rowHeight, maxAscent, maxDescent, maxPictureHeight, containsText) {
+        if (maxAscent == 0 && maxDescent == 0)
             return rowHeight;
-        const rowTextSpacing = this.calculateSpacing(maxTextHeight);
-        if (!maxPictureHeight || maxAscent > maxPictureHeight)
+        const descent = this.calculateDescent(maxAscent, maxDescent, maxPictureHeight, containsText);
+        const textHeight = maxAscent + descent;
+        const rowTextSpacing = this.calculateSpacing(textHeight);
+        if (!maxPictureHeight || textHeight > maxPictureHeight)
             return rowTextSpacing;
-        else {
-            if (maxDescent == 0)
-                return rowHeight;
-            else
-                return this.calculateSpacingInlineObjectCase(maxTextHeight, rowTextSpacing, maxPictureHeight, maxDescent);
-        }
+        else
+            return this.calculateSpacingInlineObjectCase(textHeight, rowTextSpacing, maxPictureHeight, descent);
+    }
+    calculateDescent(maxAscent, maxDescent, maxPictureHeight, containsText) {
+        if (!containsText && maxPictureHeight !== 0)
+            return (maxPictureHeight >= maxAscent + maxDescent) ? 0 : maxDescent;
+        return maxDescent;
     }
 }
 export class MultipleSpacingCalculator extends LineSpacingCalculator {
@@ -83,7 +85,7 @@ export class ExactlySpacingCalculator extends LineSpacingCalculator {
     calculateSpacingInlineObjectCase(_maxTextHeight, _rowTextSpacing, _maxPictureHeight, _maxDescent) {
         throw new Error(Errors.NotImplemented);
     }
-    calculate(_rowHeight, _maxAscent, _maxDescent, _maxPictureHeight) {
+    calculate(_rowHeight, _maxAscent, _maxDescent, _maxPictureHeight, _containsText) {
         return this.lineSpacing;
     }
 }
@@ -94,8 +96,8 @@ export class AtLeastSpacingCalculator extends SingleSpacingCalculator {
             throw new Error(argumentException("lineSpacing", lineSpacing));
         this.lineSpacing = lineSpacing;
     }
-    calculate(rowHeight, maxAscent, maxDescent, maxPictureHeight) {
-        var result = super.calculate(rowHeight, maxAscent, maxDescent, maxPictureHeight);
+    calculate(rowHeight, maxAscent, maxDescent, maxPictureHeight, containsText) {
+        var result = super.calculate(rowHeight, maxAscent, maxDescent, maxPictureHeight, containsText);
         return Math.max(result, this.lineSpacing);
     }
 }

package/lib/common/layout-formatter/table/borders/border-helper.js

@@ -46,7 +46,7 @@ export class BorderHelper {
     constructor(tableInfo, model) {
         this.colorProvider = model.colorProvider;
         this.tableInfo = tableInfo;
-        this.tblbrdProvider = new TableBorderInfoProvider(model, tableInfo.table, UnitConverter.twipsToPixels);
+        this.tblbrdProvider = new TableBorderInfoProvider(model, tableInfo.table, UnitConverter.twipsToPixelsF);
     }
     getVerticalBorders() {
         const verticalBorders = [];
@@ -134,7 +134,7 @@ export class BorderHelper {
         return new LayoutCursorVerticalTableBorder(Math.floor(modelXPos - size / 2), 0, 0, new BorderInfo().getLayoutBorder(this.colorProvider));
     }
     mergeVerticalBorders(cellA, mergerCellA, cellB, mergerCellB, isOutsideCellBorders, tableBorderInfo, getX) {
-        const brd = BorderHelper.mergeThreeBorders(this.colorProvider, cellA, mergerCellA, cellB, mergerCellB, isOutsideCellBorders, tableBorderInfo, this.tblStyle, UnitConverter.twipsToPixels);
+        const brd = BorderHelper.mergeThreeBorders(this.colorProvider, cellA, mergerCellA, cellB, mergerCellB, isOutsideCellBorders, tableBorderInfo, this.tblStyle, UnitConverter.twipsToPixelsF);
         const tableVerticalBorder = new LayoutTableBorder(0, 0, 0, brd ? brd.getLayoutBorder(this.colorProvider) : null);
         if (tableVerticalBorder.borderInfo)
             tableVerticalBorder.xPos = getX(tableVerticalBorder.borderInfo.width);
@@ -192,7 +192,7 @@ export class BorderHelper {
             const currCellEndGridColumn = Math.ceil(this.grid.columns.positions[currCellGridStartIndex + cell.columnSpan] - rowCellSpacing * (cellIndex == cells.length - 1 ? 2 : 1));
             const currCellBorder = getCurrCellBorderMerger ?
                 TableBorderInfoProvider.borderConvertToPixels((new getCurrCellBorderMerger(cell.parentRow.tablePropertiesException, !isTableBorderRowIndexValid))
-                    .getProperty(cell.properties, this.tblStyle, cell.conditionalFormatting, null), UnitConverter.twipsToPixels) :
+                    .getProperty(cell.properties, this.tblStyle, cell.conditionalFormatting, null), UnitConverter.twipsToPixelsF) :
                 null;
             const horizBorder = new LayoutTableHorizontalBorder();
             horizBorder.xPosition = currCellXPosition;
@@ -223,7 +223,7 @@ export class BorderHelper {
             const horizBorder = new LayoutTableHorizontalBorder();
             horizBorder.xPosition = Math.floor(this.grid.columns.positions[cellGridIndex]);
             horizBorder.length = Math.ceil(this.grid.columns.width[cellGridIndex]);
-            const brd = BorderHelper.mergeThreeBorders(this.colorProvider, currCell, getCurrCellBorderMerger, prevCell, getTopCellBorderMerger, false, tableBorderInfo, this.tblStyle, UnitConverter.twipsToPixels);
+            const brd = BorderHelper.mergeThreeBorders(this.colorProvider, currCell, getCurrCellBorderMerger, prevCell, getTopCellBorderMerger, false, tableBorderInfo, this.tblStyle, UnitConverter.twipsToPixelsF);
             horizBorder.borderInfo = brd ? brd.getLayoutBorder(this.colorProvider) : null;
             horizBordersInfo.updateWidth(horizBorder.borderInfo ? horizBorder.borderInfo.width : 0);
             horizBordersInfo.borders.push(horizBorder);

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

@@ -21,6 +21,7 @@ export declare class MouseHandlerDefaultState extends MouseHandlerStateBase {
     private beginCharacterMultiSelection;
     private isLeftArea;
     private isLeftAreaOffset;
+    private getLeftAreaOffset;
     private shouldProcessResizeBoxVisualizer;
     private beginResizeBoxMouseHandler;
     private beginRotate;

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

@@ -316,12 +316,9 @@ export class MouseHandlerDefaultState extends MouseHandlerStateBase {
     }
     isLeftAreaOffset(htr, evt) {
         if (htr) {
-            const columnX = htr.pageArea.x + htr.column.x;
-            const rowX = columnX + htr.row.x;
-            const leftAreaX = Math.min(columnX - MouseHandler.LEFT_AREA_COMMANDS_OFFSET, rowX);
             if (htr.exactlyDetailLevel >= DocumentLayoutDetailsLevel.Page &&
                 htr.deviations[DocumentLayoutDetailsLevel.Column] & HitTestDeviation.Left &&
-                evt.layoutPoint.x <= leftAreaX)
+                evt.layoutPoint.x <= this.getLeftAreaOffset(htr))
                 return true;
             if (htr.detailsLevel >= DocumentLayoutDetailsLevel.Box &&
                 htr.exactlyDetailLevel >= DocumentLayoutDetailsLevel.Row &&
@@ -335,6 +332,11 @@ export class MouseHandlerDefaultState extends MouseHandlerStateBase {
         }
         return false;
     }
+    getLeftAreaOffset(htr) {
+        const columnX = htr.pageArea.x + htr.column.x;
+        const rowX = columnX + htr.row.x;
+        return Math.min(columnX - MouseHandler.LEFT_AREA_COMMANDS_OFFSET, rowX);
+    }
     shouldProcessResizeBoxVisualizer(evt) {
         return this.handler.boxVisualizerManager.resizeBoxVisualizer.shouldCapture(evt) &&
             this.handler.control.selection.activeSubDocument.isEditable([new FixedInterval(this.handler.control.selection.specialRunInfo.getPosition(), 1)]);

package/lib/common/ui/ruler/controls/divisions.d.ts

@@ -22,6 +22,7 @@ export declare class RulerDivisionsControl extends RulerBase {
     get height(): number;
     protected getRootClassName(): string;
     constructor(modelData: RulerModelData, controls: RulerControls, divisionInfo: DivisionInfo, maxPageWidth: number);
+    recalculateLayout(): void;
     render(): void;
     update(): void;
     updateModelState(): void;

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

@@ -28,6 +28,10 @@ export class RulerDivisionsControl extends RulerBase {
             this.rootElement.offsetParent;
         this.render();
     }
+    recalculateLayout() {
+        this._height = SizeUtils.getOffsetHeight(this.rootElement);
+        this.render();
+    }
     render() {
         const unitCount = Math.ceil(this.maxPageWidth / this.divisionInfo.unitSize);
         this.rootElement.style.width = this.divisionInfo.unitSize * (unitCount * 2 + 1) + "px";

package/lib/common/ui/ruler/controls/indent/first-line.d.ts

@@ -3,11 +3,13 @@ import { RulerModelData } from '../../model-data';
 import { RulerModelState } from '../base';
 import { RulerBaseIndentControl } from './base';
 export declare class RulerFirstLineIndentDragHandle extends RulerBaseIndentControl {
-    private readonly _heightOfProtrudingPart;
-    private readonly leftCorrection;
+    private _heightOfProtrudingPart;
+    private leftCorrection;
     get heightOfProtrudingPart(): number;
     protected getRootClassName(): string;
     constructor(modelData: RulerModelData, controls: RulerControls);
+    recalculateLayout(): void;
+    private applyLayout;
     private adjustByTop;
     protected getModelState(): RulerModelState;
     updateView(): void;

package/lib/common/ui/ruler/controls/indent/first-line.js

@@ -19,6 +19,14 @@ export class RulerFirstLineIndentDragHandle extends RulerBaseIndentControl {
             this.rootElement.innerHTML = template;
         this.rootElement.title = this.modelData.titles.firstLineIndent;
         this.controls.ruler.rootElement.appendChild(this.rootElement);
+        this.applyLayout();
+    }
+    recalculateLayout() {
+        this.applyLayout();
+        if (this.modelData.showLeftIndent)
+            this.rootElement.style.left = this.viewState + RULLER_NUMBER_CORRECTION - this.leftCorrection + "px";
+    }
+    applyLayout() {
         this.adjustByTop();
         this.leftCorrection = Math.round(SizeUtils.getOffsetWidth(this.rootElement) / 2);
         this._heightOfProtrudingPart = SizeUtils.getOffsetHeight(this.rootElement) - this.controls.divisions.height / 2;