devexpress-richedit 24.1.12-build-25107-0103 → 24.1.13-build-25142-0103

package/lib/common/formats/rtf/export/exporters/table/states/rtf-table-exporter-state-base.js

@@ -4,6 +4,7 @@ import { TableCellMergingState, TableLookTypes } from '../../../../../../model/t
 import { TableWidthUnitType } from '../../../../../../model/tables/secondary-structures/table-units';
 import { Errors } from '@devexpress/utils/lib/errors';
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
+import { UnitConverter } from '@devexpress/utils/lib/class/unit-converter';
 import { RtfExportSR } from '../../../../translation-table/rtf-export-sr';
 import { RtfTableCellPropertiesMerger } from '../../../../utils/mergers/rtf-table-cell-properties-merger';
 import { RtfTablePropertiesMerger } from '../../../../utils/mergers/rtf-table-properties-merger';
@@ -14,10 +15,11 @@ import { RtfTableExporter } from '../rtf-table-exporter';
 import { RtfTablePropertiesExporter } from '../rtf-table-properties-exporter';
 import { RtfTableRowPropertiesExporter } from '../rtf-table-row-properties-exporter';
 export class RtfTableExporterStateBase {
-    constructor(rtfExporter, table, nestingLevel) {
+    constructor(rtfExporter, table, grid, nestingLevel) {
         this.rtfExporter = rtfExporter;
         this._nestingLevel = nestingLevel;
         this.table = table;
+        this.grid = grid;
         this.tableRowPropertiesExporter = new RtfTableRowPropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
         this.tableCellPropertiesExporter = new RtfTableCellPropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
         this.tablePropertiesExporter = new RtfTablePropertiesExporter(rtfExporter.documentModel, rtfExporter.rtfExportHelper, rtfExporter.rtfBuilder);
@@ -92,7 +94,7 @@ export class RtfTableExporterStateBase {
         while (parentCell !== nestedTable.parentCell) {
             nestedTable = nestedTable.parentCell.parentRow.parentTable;
         }
-        return RtfTableExporter.exportNestedTable(this.rtfExporter, nestedTable, this.nestingLevel + 1);
+        return RtfTableExporter.exportNestedTable(this.rtfExporter, nestedTable, this.grid, this.nestingLevel + 1);
     }
     exportRowProperties(row, rowIndex) {
         const rowLeft = this.calculateRowLeft(row, row.parentTable.getActualTableIndent(this.documentModel.defaultTableProperties));
@@ -100,20 +102,25 @@ export class RtfTableExporterStateBase {
         let cellRightVirtualColInd = row.gridBefore;
         for (const cell of row.cells) {
             cellRightVirtualColInd += cell.columnSpan;
-            const cellRight = rowLeft + this.getCellWidth(cellRightVirtualColInd);
+            const cellWidth = this.getCellWidth(row.gridBefore, cellRightVirtualColInd);
+            const cellRight = UnitConverter.pixelsToTwips(rowLeft + cellWidth);
             this.exportCellProperties(cell, cellRight);
         }
     }
-    getCellWidth(virtualColumnIndex) {
-        if (virtualColumnIndex < 0)
+    getCellWidth(leftSideIndex, columnSpan) {
+        if (leftSideIndex < 0 || columnSpan < 0)
             throw new Error(Errors.InternalException);
-        const minVirtualColumnWidth = 10;
-        return virtualColumnIndex * minVirtualColumnWidth;
+        let result = 0;
+        for (let i = 0; i < columnSpan; i++)
+            result += Math.max(this.grid.columns.width[i + leftSideIndex], 1);
+        return result;
     }
     calculateRowLeft(row, indent) {
-        const widthBefore = row.gridBefore > 0 ? this.getCellWidth(row.gridBefore) : 0;
+        var _a;
+        const widthBefore = row.gridBefore > 0 ? this.getCellWidth(0, row.gridBefore) : 0;
         const offset = this.getActualWidth(indent) + widthBefore;
-        return offset - (this.rowLeftOffset != null ? this.rowLeftOffset : this.calculateRowLeftOffset(row));
+        const rowLeftOffset = (_a = this.rowLeftOffset) !== null && _a !== void 0 ? _a : this.calculateRowLeftOffset(row);
+        return offset - rowLeftOffset;
     }
     calculateRowLeftOffset(row) {
         const borderWidth = row.cells[0].properties.borders.left.width;

package/lib/common/formats/rtf/export/exporters/table/states/rtf-table-exporter-state.d.ts

@@ -1,9 +1,10 @@
+import { Grid } from '../../../../../../layout-formatter/table/grid-engine/grid';
 import { Table } from '../../../../../../model/tables/main-structures/table';
 import { TableRow } from '../../../../../../model/tables/main-structures/table-row';
 import { RtfContentExporter } from '../../rtf-content-exporter';
 import { RtfTableExporterStateBase } from './rtf-table-exporter-state-base';
 export declare class RtfTableExporterState extends RtfTableExporterStateBase {
-    constructor(rtfExporter: RtfContentExporter, table: Table);
+    constructor(rtfExporter: RtfContentExporter, table: Table, grid: Grid);
     export(): void;
     protected writeParagraphEndMark(): void;
     protected exportRow(row: TableRow, rowIndex: number): void;

package/lib/common/formats/rtf/export/exporters/table/states/rtf-table-exporter-state.js

@@ -1,8 +1,8 @@
 import { RtfExportSR } from '../../../../translation-table/rtf-export-sr';
 import { RtfTableExporterStateBase } from './rtf-table-exporter-state-base';
 export class RtfTableExporterState extends RtfTableExporterStateBase {
-    constructor(rtfExporter, table) {
-        super(rtfExporter, table, 1);
+    constructor(rtfExporter, table, grid) {
+        super(rtfExporter, table, grid, 1);
     }
     export() {
         super.exportBase();

package/lib/common/formats/rtf/importer-in-subdocument.d.ts

@@ -1,6 +1,5 @@
 import { FixedInterval } from "@devexpress/utils/lib/intervals/fixed";
-import { RichOptions } from "../../model/options/rich-options";
 import { SubDocument } from "../../model/sub-document";
 import { IProcessor } from "../../processor";
-export declare function getRtfFromSubDocumentPublic(richOptions: RichOptions, subDocument: SubDocument, coreInterval: FixedInterval): string;
+export declare function getRtfFromSubDocumentPublic(processor: IProcessor, subDocument: SubDocument, coreInterval: FixedInterval): string;
 export declare function insertRtfInSubDocumentPublic(processor: IProcessor, subDocument: SubDocument, position: number, rtf: string, callback: (interval: FixedInterval, isRtfValid: boolean) => void): void;

package/lib/common/formats/rtf/importer-in-subdocument.js

@@ -7,10 +7,11 @@ import { RtfDocumentExporterOptions } from "./export/rtf-document-exporter-optio
 import { RtfImporterOptions } from "./import/importer-options";
 import { RtfImporter } from "./import/rtf-importer";
 import { getAfterInsertCallback, getAfterInsertReject } from "../callback-helpers";
-export function getRtfFromSubDocumentPublic(richOptions, subDocument, coreInterval) {
+export function getRtfFromSubDocumentPublic(processor, subDocument, coreInterval) {
     const rangeCopy = RangeCopy.create(new SubDocumentIntervals(subDocument, [coreInterval]));
-    const newModelManager = new ClientModelManager(rangeCopy.model, richOptions, new EmptyBatchUpdatableObject());
-    return new RtfExporter(newModelManager.modelManipulator, new RtfDocumentExporterOptions()).exportAsString();
+    const newModelManager = new ClientModelManager(rangeCopy.model, processor.modelManager.richOptions, new EmptyBatchUpdatableObject());
+    const exportModelOptions = processor.getExportModelOptions({ modelManager: newModelManager });
+    return new RtfExporter(exportModelOptions, new RtfDocumentExporterOptions()).exportAsString();
 }
 export function insertRtfInSubDocumentPublic(processor, subDocument, position, rtf, callback) {
     const options = new RtfImporterOptions(() => { });

package/lib/common/layout/document-layout.d.ts

@@ -2,6 +2,8 @@ import { DocumentModel } from '../model/document-model';
 import { PositionManager } from '../model/position/position-manager';
 import { LayoutAnchoredObjectBox } from './main-structures/layout-boxes/layout-anchored-object-box';
 import { LayoutPage } from './main-structures/layout-page';
+import { Grid } from '../layout-formatter/table/grid-engine/grid';
+import { Table } from '../model/tables/main-structures/table';
 export declare class ModelPositionHolder {
     private pos;
     private posManager;
@@ -25,6 +27,7 @@ export declare class DocumentLayout {
     isFullyFormatted: boolean;
     anchorObjectsPositionInfo: AnchorObjectsPositionInfo;
     pageColor: number;
+    get grids(): Map<Table, Grid>;
     constructor(anchorObjectsPositionInfo: AnchorObjectsPositionInfo);
     setEmptyLayout(pageColor: number): void;
     getLastValidPage(): LayoutPage;

package/lib/common/layout/document-layout.js

@@ -41,6 +41,12 @@ export class DocumentLayout {
         this.anchorObjectsPositionInfo = anchorObjectsPositionInfo;
         this.setEmptyLayout(ColorHelper.NO_COLOR);
     }
+    get grids() {
+        return this.pages.reduce((res, page) => {
+            page.grids.forEach((grid, table) => res.set(table, grid));
+            return res;
+        }, new Map());
+    }
     setEmptyLayout(pageColor) {
         this.pages = [];
         this.validPageCount = 0;

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

@@ -1,10 +1,13 @@
 import { Rectangle } from '@devexpress/utils/lib/geometry/rectangle';
 import { SubDocument } from '../../model/sub-document';
 import { LayoutColumn } from './layout-column';
+import { Grid } from '../../layout-formatter/table/grid-engine/grid';
+import { Table } from '../../model/tables/main-structures/table';
 export declare class LayoutPageArea extends Rectangle {
     subDocument: SubDocument;
     columns: LayoutColumn[];
     pageOffset: number;
+    get grids(): Map<Table, Grid>;
     constructor(subDocument: SubDocument);
     getEndPosition(): number;
     getLastColumn(): LayoutColumn;

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

@@ -6,6 +6,12 @@ export class LayoutPageArea extends Rectangle {
         this.columns = [];
         this.subDocument = subDocument;
     }
+    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());
+    }
     getEndPosition() {
         return this.pageOffset + ListUtils.last(this.columns).getEndPosition();
     }

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

@@ -46,6 +46,14 @@ export class LayoutPage extends Rectangle {
         this.anchoredObjectHolder = new PageAnchoredObjectHolder(this);
         this.tableAnchoredObjectsHolder = new TableAnchoredObjectsHolder();
     }
+    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;
+    }
     setRenderLevelCalculator(anchorObjectsPositionInfo, compatibilityMode) {
         this.renderLevelCalculator = new RenderLevelCalculator();
         this.renderLevelCalculator.calcLevels(this.anchoredObjectHolder, anchorObjectsPositionInfo, compatibilityMode);

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

@@ -31,7 +31,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/borders/border-info.js

@@ -5,7 +5,7 @@ import { BorderLineStyle } from './enums';
 import { LayoutBorder } from './layout-border';
 export class BorderInfo {
     constructor() {
-        this.style = BorderLineStyle.None;
+        this.style = BorderLineStyle.Nil;
         this.color = ColorModelInfoCache.defaultItem;
         this.width = 0;
         this.offset = 0;

package/lib/common/model/character/character-properties.d.ts

@@ -54,7 +54,7 @@ export declare class MaskedCharacterProperties extends CharacterProperties imple
     protected calculateHash(): number;
     getUseValue(value: CharacterPropertiesMask): boolean;
     setUseValue(mask: CharacterPropertiesMask, value: boolean): void;
-    setUseValueFull(value: number): void;
+    setUseValueFull(value: number, onlyForDefault?: boolean): void;
     getLowPartUseValue(value: number): number;
     getHighPartUseValue(value: number): number;
     getUseValueFull(): number;

package/lib/common/model/character/character-properties.js

@@ -5,6 +5,7 @@ import { ColorHelper } from '../color/color';
 import { ColorModelInfo } from '../color/color-model-info';
 import { ShadingInfo } from '../shadings/shading-info';
 import { ShadingPattern } from '../shadings/shading-pattern';
+import { CharacterPropertyDescriptor } from './character-property-descriptor';
 import { CompositeFontInfo } from './composite-font-info';
 import { CharacterFormattingScript, CharacterPropertiesMask, StrikeoutType, UnderlineType } from './enums';
 import { LangInfo } from './lang-info';
@@ -143,8 +144,19 @@ export class MaskedCharacterProperties extends CharacterProperties {
             this.useValueExt &= ~this.getHighPartUseValue(mask);
         }
     }
-    setUseValueFull(value) {
-        this.useValue = this.getLowPartUseValue(value);
+    setUseValueFull(value, onlyForDefault = false) {
+        const lowPartUseValue = this.getLowPartUseValue(value);
+        if (onlyForDefault) {
+            CharacterPropertyDescriptor.ALL_FIELDS.forEach((desc) => {
+                const prop = desc.getProp(this);
+                const mask = desc.maskValue();
+                if (desc.binaryEquals(prop, desc.defaultValue))
+                    this.setUseValue(mask, !!(mask & lowPartUseValue));
+            });
+        }
+        else {
+            this.useValue = lowPartUseValue;
+        }
         this.useValueExt = this.getHighPartUseValue(value);
     }
     getLowPartUseValue(value) {

package/lib/common/model/history/items/character-properties-history-items.d.ts

@@ -14,7 +14,8 @@ import { HistoryItemIntervalStateObject, HistoryItemIntervalUseStateObject } fro
 export declare class FontUseValueHistoryItem extends IntervalBasedHistoryItem {
     oldState: HistoryItemIntervalState<HistoryItemIntervalStateObject>;
     newValue: number;
-    constructor(modelManipulator: ModelManipulator, subDocInterval: SubDocumentInterval, newValue: number);
+    keepCustomFormatting: boolean;
+    constructor(modelManipulator: ModelManipulator, subDocInterval: SubDocumentInterval, newValue: number, keepCustomFormatting?: boolean);
     redo(): void;
     undo(): void;
 }

package/lib/common/model/history/items/character-properties-history-items.js

@@ -1,12 +1,13 @@
 import { Errors } from '@devexpress/utils/lib/errors';
 import { IntervalBasedHistoryItem } from '../base/interval-based-history-item';
 export class FontUseValueHistoryItem extends IntervalBasedHistoryItem {
-    constructor(modelManipulator, subDocInterval, newValue) {
+    constructor(modelManipulator, subDocInterval, newValue, keepCustomFormatting = false) {
         super(modelManipulator, subDocInterval);
         this.newValue = newValue;
+        this.keepCustomFormatting = keepCustomFormatting;
     }
     redo() {
-        this.oldState = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, this.newValue);
+        this.oldState = this.modelManipulator.characterProperties.useValue.setValue(this.boundSubDocument, this.interval, this.newValue, this.keepCustomFormatting);
     }
     undo() {
         this.modelManipulator.characterProperties.useValue.restoreValue(this.boundSubDocument, this.oldState);

package/lib/common/model/manipulators/character-properties-manipulator.js

@@ -74,7 +74,7 @@ class CharacterPropertiesUseValueManipulator {
     constructor(manipulator) {
         this.manipulator = manipulator;
     }
-    setValue(subDocument, interval, newValue) {
+    setValue(subDocument, interval, newValue, keepCustomFormatting = false) {
         var oldState = new HistoryItemIntervalState();
         if (!ControlOptions.isEnabled(subDocument.documentModel.options.characterFormatting))
             return oldState;
@@ -84,7 +84,7 @@ class CharacterPropertiesUseValueManipulator {
             var run = iterator.currentRun;
             oldState.register(new HistoryItemIntervalStateObject(iterator.currentInterval(), run.maskedCharacterProperties.getUseValueFull()));
             var properties = run.maskedCharacterProperties.clone();
-            properties.setUseValueFull(newValue);
+            properties.setUseValueFull(newValue, keepCustomFormatting);
             run.setCharacterProperties(properties);
             run.onCharacterPropertiesChanged();
         }

package/lib/common/model/manipulators/i-properties-manipulator.d.ts

@@ -8,7 +8,7 @@ export interface IIntervalPropertyWithUseValueManipulator<T> {
     restoreValue(subDocument: SubDocument, state: HistoryItemIntervalState<HistoryItemIntervalUseStateObject>): any;
 }
 export interface IIntervalPropertyManipulator<T> {
-    setValue(subDocument: SubDocument, interval: FixedInterval, newValue: T): HistoryItemIntervalState<HistoryItemIntervalStateObject>;
+    setValue(subDocument: SubDocument, interval: FixedInterval, newValue: T, keepCustomFormatting?: boolean): HistoryItemIntervalState<HistoryItemIntervalStateObject>;
     restoreValue(subDocument: SubDocument, state: HistoryItemIntervalState<HistoryItemIntervalStateObject>): any;
 }
 export interface IListLevelPropertyManipulator<T> {

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
 }