devexpress-richedit 24.2.7-build-25107-0104 → 24.2.8-build-25135-0103

package/lib/common/layout/main-structures/layout-page-area.js

@@ -1,6 +1,12 @@
 import { Rectangle } from '@devexpress/utils/lib/geometry/rectangle';
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
 export class LayoutPageArea extends Rectangle {
+    get grids() {
+        return this.columns.reduce((res, column) => {
+            column.tablesInfo.forEach(tableInfo => res.set(tableInfo.logicInfo.grid.table, tableInfo.logicInfo.grid));
+            return res;
+        }, new Map());
+    }
     constructor(subDocument) {
         super(0, 0, 0, 0);
         this.columns = [];

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

@@ -8,6 +8,8 @@ import { AnchorObjectsPositionInfo } from '../document-layout';
 import { LayoutAnchoredObjectBox } from './layout-boxes/layout-anchored-object-box';
 import { LayoutPageArea } from './layout-page-area';
 import { TableAnchoredObjectsHolder } from '../../layout-formatter/table/utils/table-anchored-objects-holder';
+import { Grid } from '../../layout-formatter/table/grid-engine/grid';
+import { Table } from '../../model/tables/main-structures/table';
 export declare enum LayoutPageFlags {
     MustBeRendered = 1,
     ContentRendered = 2,
@@ -42,6 +44,7 @@ export declare class LayoutPage extends Rectangle {
     tableAnchoredObjectsHolder: TableAnchoredObjectsHolder;
     renderLevelCalculator: RenderLevelCalculator;
     private contentIntervals;
+    get grids(): Map<Table, Grid>;
     constructor();
     setRenderLevelCalculator(anchorObjectsPositionInfo: AnchorObjectsPositionInfo, compatibilityMode: CompatibilityMode): void;
     setAbsolutePosition(pos: number): void;

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

@@ -38,6 +38,14 @@ export class LayoutOtherPageAreasInfo {
     }
 }
 export class LayoutPage extends Rectangle {
+    get grids() {
+        const result = new Map();
+        for (let pageArea of this.mainSubDocumentPageAreas)
+            pageArea.grids.forEach((grid, table) => result.set(table, grid));
+        for (let pageArea of Object.values(this.otherPageAreas))
+            pageArea.grids.forEach((grid, table) => result.set(table, grid));
+        return result;
+    }
     constructor() {
         super(0, 0, 0, 0);
         this.mainSubDocumentPageAreas = [];

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

@@ -2,7 +2,6 @@ import { Flag } from '@devexpress/utils/lib/class/flag';
 import { UnitConverter } from '@devexpress/utils/lib/class/unit-converter';
 import { Rectangle } from '@devexpress/utils/lib/geometry/rectangle';
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
-import { LayoutBoxType } from './layout-boxes/layout-box';
 export var LayoutRowStateFlags;
 (function (LayoutRowStateFlags) {
     LayoutRowStateFlags[LayoutRowStateFlags["NormallyEnd"] = 0] = "NormallyEnd";
@@ -129,7 +128,7 @@ export class LayoutRow extends Rectangle {
         return lastBoxIndexWhatCanStrikeoutAndUnderline;
     }
     containsSpacesOnly() {
-        return this.boxes.length > 0 && ListUtils.allOf(this.boxes, val => val.isWhitespace() || val.getType() === LayoutBoxType.ParagraphMark);
+        return this.boxes.length > 0 && ListUtils.allOf(this.boxes, val => val.isWhitespace());
     }
 }
 export class LayoutRowWithIndex extends LayoutRow {

package/lib/common/layout-formatter/floating/position-calculators/horizontal.d.ts

@@ -11,6 +11,7 @@ export declare class AnchorObjectHorizontalPositionCalculator extends AnchorObje
     private alignment;
     private getAlignPosition;
     private absolute;
+    private getAnchorXPosition;
     private bookLayout;
     private relative;
 }

package/lib/common/layout-formatter/floating/position-calculators/horizontal.js

@@ -41,7 +41,7 @@ export class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositi
     alignment(type, alignment) {
         switch (type) {
             case AnchorObjectHorizontalPositionType.Character:
-                return this.getAlignPosition(alignment, 0);
+                return this.getAnchorXPosition() + this.getAlignPosition(alignment, 0);
             case AnchorObjectHorizontalPositionType.Column:
                 return this.isRelativeCell ?
                     this.relativeColumnPos() + this.lp.row.tableCellInfo.x +
@@ -90,17 +90,8 @@ export class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositi
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x : 0;
             case AnchorObjectHorizontalPositionType.Column:
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x + this.leftCellMargin : this.relativeColumnPos();
-            case AnchorObjectHorizontalPositionType.Character: {
-                const rowAbsPos = this.lp.getLogPosition(DocumentLayoutDetailsLevel.Row);
-                const ancBoxAbsPos = this.obj.rowOffset;
-                const boxIndex = SearchUtils.normedInterpolationIndexOf(this.lp.row.boxes, (box) => rowAbsPos + box.rowOffset, ancBoxAbsPos);
-                const box = this.lp.row.boxes[boxIndex];
-                if (!box)
-                    return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row);
-                const symbolCount = Math.max(0, ancBoxAbsPos - rowAbsPos - box.rowOffset);
-                return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row) + box.x +
-                    box.getCharOffsetXInPixels(this.manager.measurer, symbolCount);
-            }
+            case AnchorObjectHorizontalPositionType.Character:
+                return this.getAnchorXPosition();
             case AnchorObjectHorizontalPositionType.Margin:
                 return this.isRelativeCell ? this.relativeColumnPos() + this.lp.row.tableCellInfo.x + this.leftCellMargin :
                     this.manager.boundsCalculator.marginLeft;
@@ -117,6 +108,19 @@ export class AnchorObjectHorizontalPositionCalculator extends AnchorObjectPositi
                 throw new Error(Errors.InternalException);
         }
     }
+    getAnchorXPosition() {
+        const rowAbsPos = this.lp.getLogPosition(DocumentLayoutDetailsLevel.Row);
+        const ancBoxAbsPos = this.obj.rowOffset;
+        let boxIndex = SearchUtils.normedInterpolationIndexOf(this.lp.row.boxes, (box) => rowAbsPos + box.rowOffset, ancBoxAbsPos);
+        if (boxIndex < 0)
+            boxIndex = 0;
+        const box = this.lp.row.boxes[boxIndex];
+        if (!box)
+            return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row);
+        const symbolCount = Math.max(0, ancBoxAbsPos - rowAbsPos - box.rowOffset);
+        return this.lp.getLayoutX(null, DocumentLayoutDetailsLevel.Row) + box.x +
+            box.getCharOffsetXInPixels(this.manager.measurer, symbolCount);
+    }
     bookLayout() {
         return this.alignment(this.anchorInfo.horizontalPositionType, AnchorObjectHorizontalPositionCalculator.mapBookLayoutALignmentType[this.anchorInfo.horizontalPositionAlignment]);
     }

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

@@ -25,7 +25,10 @@ export declare class RowFormattingInfo {
     get currInterval(): RowIntervalInfo;
     indexOfFreeInterval(width: number): number;
     indexOfIntervalContainsPositon(pos: number): number;
-    calculate(): void;
+    calculate(outerHorizontalRowContentBounds?: FixedInterval): void;
+    private calculateFreeIntervals;
+    recalculate(outerHorizontalRowContentBounds?: FixedInterval): void;
+    private findIntervalIndexByPosition;
     canIncrementHeightTo(newHeight: number): boolean;
     findNextYPos(): void;
     findNextYPosWhatHasNeededSpace(requiredWidth: number): void;

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

@@ -45,10 +45,10 @@ export class RowFormattingInfo {
         const ind = ListUtils.indexBy(this.intervals, (curr) => curr.start > pos || pos < curr.end, this.currIndex + 1);
         return ind < 0 ? this.intervals.length - 1 : ind;
     }
-    calculate() {
+    calculate(outerHorizontalRowContentBounds) {
         this.setIntersectObjects();
         this.busyIntervals = IntervalAlgorithms.getMergedIntervals(ListUtils.map(this.intersectsObjects, (objBnds) => new FixedInterval(objBnds.x, objBnds.width)), true);
-        const freeIntervals = IntervalAlgorithms.reflectIntervals(this.busyIntervals, this.outerHorizontalRowContentBounds);
+        const freeIntervals = this.calculateFreeIntervals(this.busyIntervals, outerHorizontalRowContentBounds !== null && outerHorizontalRowContentBounds !== void 0 ? outerHorizontalRowContentBounds : this.outerHorizontalRowContentBounds);
         if (freeIntervals.length) {
             this.intervals = ListUtils.map(freeIntervals, (curr) => new RowIntervalInfo(curr.start, curr.length));
             return;
@@ -56,6 +56,40 @@ export class RowFormattingInfo {
         this.resetMinY(ListUtils.min);
         Log.print(LogSource.RowFormatter, "RowFormattingInfo.calculate ", `minY:${this.minY}, height:${this.height}, currIndex: ${this.currIndex} intervals:\n${Log.join("\n", ListUtils.map(this.intervals, (curr) => LogObjToStr.fixedInterval(curr)))}`);
     }
+    calculateFreeIntervals(busyIntervals, outerHorizontalRowContentBounds) {
+        const intervals = ListUtils.reducedMap(busyIntervals, val => IntervalAlgorithms.getIntersectionNonNullLength(val, outerHorizontalRowContentBounds));
+        if (!intervals.length)
+            return [outerHorizontalRowContentBounds.clone()];
+        const lastIntervalEnd = ListUtils.last(intervals).end;
+        const result = ListUtils.reducedMap(intervals, (curr, i) => FixedInterval.fromPositions(busyIntervals[i - 1].end, curr.start), 1);
+        if (outerHorizontalRowContentBounds.start < busyIntervals[0].start)
+            result.unshift(FixedInterval.fromPositions(outerHorizontalRowContentBounds.start, busyIntervals[0].start));
+        if (outerHorizontalRowContentBounds.end > lastIntervalEnd)
+            result.push(FixedInterval.fromPositions(lastIntervalEnd, outerHorizontalRowContentBounds.end));
+        return result;
+    }
+    recalculate(outerHorizontalRowContentBounds) {
+        const currInterval = this.currInterval;
+        this.calculate(outerHorizontalRowContentBounds);
+        const pos = currInterval.start + currInterval.busyWidth;
+        const index = this.findIntervalIndexByPosition(pos);
+        const interval = this.intervals[index];
+        if (interval && interval.start < pos) {
+            const avaliableWidth = interval.length - (pos - interval.start);
+            interval.avaliableWidth = avaliableWidth;
+        }
+        this.currIndex = index;
+    }
+    findIntervalIndexByPosition(position) {
+        let index = 0;
+        while (index < this.intervals.length) {
+            const interval = this.intervals[index];
+            if (interval.start <= position && position < interval.end || position < interval.start)
+                break;
+            index++;
+        }
+        return index;
+    }
     canIncrementHeightTo(newHeight) {
         const contentBounds = ListUtils.map(this.intervals, (c) => new Rectangle(c.start, this.minY, c.busyWidth, newHeight));
         const intersectedObjects = this.calcIntersectObjects(newHeight);

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

@@ -21,8 +21,6 @@ export class RowBaseFormatterState {
             this.rowFormatter.finishRow();
     }
     addAnchorObject() {
-        if (!this.rowFormatter.wordHolder.pushBoxes())
-            return;
         this.rowFormatter.addAnchorObject();
     }
     addTextBox() {

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

@@ -39,7 +39,7 @@ export class RowTabInfo {
             const tab = this.tabPositions[ind];
             const oldTabPos = tab ? tab.position : Number.MAX_VALUE;
             if (oldTabPos != pos)
-                this.tabPositions.splice(pos > oldTabPos ? ind + 1 : ind, 0, new TabInfo(pos, TabAlign.Left, TabLeaderType.None, false, false));
+                this.tabPositions.splice(pos > oldTabPos ? ind + 1 : ind, 0, new TabInfo(pos, TabAlign.Left, TabLeaderType.None, false, false, true));
         }
         for (let pos of this.tabPositions)
             pos.position += this.paragraphHorizontalBoundsStart;
@@ -85,9 +85,10 @@ export class RowTabInfo {
         const lastInterval = ListUtils.last(this.rowFormatter.rowSizesManager.rowFormattingInfo.intervals);
         if (tabXPosRelativePage > lastInterval.end) {
             if (lastInterval.end < this.rowFormatter.paragraphHorizontalBounds.end) {
-                if (this.rowFormatter.manager.model.compatibilitySettings.compatibilityMode < CompatibilityMode.Word2013 && tabPosition !== null) {
-                    this.currInterval.avaliableWidth = Number.MAX_SAFE_INTEGER - this.currInterval.busyWidth;
-                    this.currInterval.length = Number.MAX_SAFE_INTEGER;
+                if (this.rowFormatter.manager.model.compatibilitySettings.compatibilityMode < CompatibilityMode.Word2013 && tabPosition && !tabPosition.isParagraphIndent) {
+                    const interval = this.rowFormatter.rowSizesManager.rowFormattingInfo.outerHorizontalRowContentBounds;
+                    interval.length = Number.MAX_SAFE_INTEGER - interval.start;
+                    this.rowFormatter.rowSizesManager.rowFormattingInfo.recalculate(interval);
                     this.row.width = Number.MAX_SAFE_INTEGER;
                     this.row.flags.set(LayoutRowStateFlags.InfinityWidth, true);
                     return this.addTabBox();

package/lib/common/layout-formatter/table/info/table-info.d.ts

@@ -53,7 +53,6 @@ export declare class TableInfo {
     constructor(rowFormatter: RowFormatter, table: Table, tableMaxWidth: number, xPosition: number, yOffset: number, pageIndexFromWhichTableWasMoved: number | null);
     static checkIsTableCannotBePlacedOnCurrentPage(rowFormatter: RowFormatter, table: Table, yOffset: number, maxWidth: number): boolean;
     private init;
-    private getShiftHorizontalPosition;
     private static getEstimatedTableWidth;
     private static getRelationByColumnY;
     private static getRelationByColumnX;

package/lib/common/layout-formatter/table/info/table-info.js

@@ -8,7 +8,7 @@ import { LayoutTableColumnInfo, LayoutTableInfo } from '../../../layout/table/la
 import { TablePosition, TablePositionIndexes } from '../../../model/tables/main-structures/table';
 import { TableCellPropertiesMergerMarginLeft, TableCellPropertiesMergerMarginRight } from '../../../model/tables/properties-mergers/table-cell-properties-merger';
 import { TablePropertiesMergerShadingInfo } from '../../../model/tables/properties-mergers/table-properties-merger';
-import { ConditionalTableStyleFormatting, TableLayoutType, TableRowAlignment } from '../../../model/tables/secondary-structures/table-base-structures';
+import { ConditionalTableStyleFormatting, TableLayoutType } from '../../../model/tables/secondary-structures/table-base-structures';
 import { TableWidthUnitType } from '../../../model/tables/secondary-structures/table-units';
 import { BorderHelper } from '../borders/border-helper';
 import { createGrid } from '../grid-engine/creator';
@@ -79,25 +79,9 @@ export class TableInfo {
             tableIndent.value = 0;
         }
         const tableIndentInPixels = tableIndent.asNumberNoPercentType(UnitConverter.twipsToPixels);
-        this.xPositionStart = xPosition + tableIndentInPixels + (diff.xDiff ? diff.xDiff : -firstCellLeftMargin) +
-            this.getShiftHorizontalPosition(xPosition);
+        this.xPositionStart = xPosition + tableIndentInPixels + (diff.xDiff ? diff.xDiff : -firstCellLeftMargin);
         this.yPositionStart = yOffset + diff.yDiff;
     }
-    getShiftHorizontalPosition(xPosition) {
-        const freeSpaceFromTable = this.columnWidth - this.grid.commonWidth;
-        if (freeSpaceFromTable >= 0)
-            return 0;
-        const tableAlignment = this.table.getActualTableAlignment();
-        if (tableAlignment == TableRowAlignment.Center) {
-            let result = freeSpaceFromTable / 2 - xPosition;
-            if (result < 0 && this.isSimpleView)
-                result = 0;
-            return result;
-        }
-        else if (tableAlignment == TableRowAlignment.Right)
-            return freeSpaceFromTable - xPosition;
-        return 0;
-    }
     static getEstimatedTableWidth(table, maxWidth) {
         const preferredWidth = table.preferredWidth;
         const minWidth = 3 * table.rows[0].getTotalCellsInRowConsiderGrid();

package/lib/common/layout-formatter/table/size-compressor.js

@@ -11,6 +11,12 @@ export class LayoutTableSizeCompressor {
             LayoutTableSizeCompressor.cellCompress(cell, cell.createRectangle());
     }
     static tableCompress(tableInfo, boundsRelativeColumn) {
+        const intersection = Rectangle.getIntersection(tableInfo, boundsRelativeColumn);
+        const headOffset = intersection.x - tableInfo.x;
+        if (headOffset > 0) {
+            tableInfo.verticalBorders.forEach(b => b.xPos -= headOffset);
+            tableInfo.verticalCursorBorders.forEach(b => b.xPos -= headOffset);
+        }
         LayoutTableSizeCompressor.compress(tableInfo, boundsRelativeColumn, true, false);
         const boundsRelativeTable = tableInfo.clone().moveRectangle(-tableInfo.x, -tableInfo.y);
         for (let row of tableInfo.tableRows)
@@ -79,8 +85,9 @@ export class LayoutTableSizeCompressor {
         }
         border.length = Math.min(border.yPos + border.length, bounds.bottom) - border.yPos;
         if (border.xPos < bounds.x)
-            return true;
-        border.xPos = bounds.right;
+            border.xPos = bounds.x;
+        else
+            border.xPos = bounds.right;
         border.borderInfo.width = 0;
         return false;
     }

package/lib/common/layout-formatter/table/table-alignment-applier.js

@@ -33,8 +33,6 @@ export class TableAlignmentApplier {
                 offset = 0;
                 break;
         }
-        if (offset <= 0)
-            return;
         TableAlignmentApplier.moveAllTable(currTableColumnInfo, (rect) => rect.x += offset);
     }
     static applyCellsVerticalAlignment(defaultTableCellProps, grid, currTableColumnInfo, rowInfo) {

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

@@ -48,7 +48,8 @@ export declare class TabInfo implements IEquatable<TabInfo>, ICloneable<TabInfo>
     position: number;
     isDefault: boolean;
     deleted: boolean;
-    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);
     clone(): TabInfo;
     equals(obj: TabInfo): boolean;
 }

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

@@ -107,15 +107,16 @@ export class TabProperties {
     }
 }
 export class TabInfo {
-    constructor(position, alignment, leader, deleted, isDefault) {
+    constructor(position, alignment, leader, deleted, isDefault, isParagraphIndent = false) {
         this.position = position;
         this.alignment = alignment;
         this.leader = leader;
         this.isDefault = isDefault;
         this.deleted = deleted;
+        this.isParagraphIndent = isParagraphIndent;
     }
     clone() {
-        return new TabInfo(this.position, this.alignment, this.leader, this.deleted, this.isDefault);
+        return new TabInfo(this.position, this.alignment, this.leader, this.deleted, this.isDefault, this.isParagraphIndent);
     }
     equals(obj) {
         if (!obj)
@@ -124,6 +125,7 @@ export class TabInfo {
             this.leader == obj.leader &&
             this.position == obj.position &&
             this.deleted == obj.deleted &&
-            this.isDefault == obj.isDefault;
+            this.isDefault == obj.isDefault &&
+            this.isParagraphIndent == obj.isParagraphIndent;
     }
 }

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/rich-edit-core.js

@@ -384,6 +384,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devexpress-richedit",
-  "version": "24.2.7-build-25107-0104",
+  "version": "24.2.8-build-25135-0103",
   "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": "24.2.7-build-25105-1935",
-    "devextreme-dist": "24.2.7-build-25105-1935"
+    "devextreme": "24.2.8-build-25133-1935",
+    "devextreme-dist": "24.2.8-build-25133-1935"
   },
   "dependencies": {
     "jszip": "~3.10.1",