devexpress-richedit 25.1.1-alpha → 25.1.2-beta

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

@@ -28,6 +28,7 @@ import { CanvasUtils } from '../../utils';
 import { ScrollState } from '../../../scroll/model-states';
 import { isDefined } from '@devexpress/utils/lib/utils/common';
 import { StringUtils } from '@devexpress/utils/lib/utils/string';
+import { ModelChangeType } from '../../../model/changes/enums';
 export class SimpleViewCanvasSizeManager {
     constructor(canvasManager, control) {
         this.size = new Size(0, 0);
@@ -52,6 +53,10 @@ export class SimpleViewCanvasSizeManager {
         this.resizeFrameId = null;
         this.resizeObserver.disconnect();
     }
+    modelChanged(change) {
+        if (change.type == ModelChangeType.ZoomLevelChanged && this.control.innerClientProperties.viewsSettings.isSimpleView)
+            this.changeSize(true);
+    }
     changeSize(force) {
         const curr = new Size(this.canvasManager.getCanvasWidth(), this.canvasManager.controlHeightProvider.getVisibleAreaHeight(false));
         if (force || !curr.equals(this.size)) {
@@ -77,18 +82,16 @@ export class SimpleViewCanvasSizeManager {
         this.sizeUpdated = true;
     }
     changeSizeCore() {
-        {
-            ListUtils.forEach(this.control.viewManager.cache, (_val) => this.control.viewManager.renderer.removePage(1), 1);
-            this.control.viewManager.ensureFirstPageIsRendered();
-            this.control.innerClientProperties.viewsSettings.widthOfPage = this.canvasManager.getCanvasWidth();
-            if (this.control.layoutFormatterManager) {
-                this.control.layoutFormatterManager.invalidator.onChangedAllLayout();
-                this.control.selection.scrollManager.setScroll(new ScrollState().byModelPosition(this.control.selection)
-                    .setModelPosition(this.control.selection.lastSelectedInterval.start).useStdRelativePosition().useStdOffset());
-            }
-            this.control.owner.adjustControl();
-            this.control.horizontalRulerControl.update();
+        ListUtils.forEach(this.control.viewManager.cache, (_val) => this.control.viewManager.renderer.removePage(1), 1);
+        this.control.viewManager.ensureFirstPageIsRendered();
+        this.control.innerClientProperties.viewsSettings.widthOfPage = this.canvasManager.getCanvasWidth();
+        if (this.control.layoutFormatterManager) {
+            this.control.layoutFormatterManager.invalidator.onChangedAllLayout();
+            this.control.selection.scrollManager.setScroll(new ScrollState().byModelPosition(this.control.selection)
+                .setModelPosition(this.control.selection.lastSelectedInterval.start).useStdRelativePosition().useStdOffset());
         }
+        this.control.owner.adjustControl();
+        this.control.horizontalRulerControl.update();
     }
 }
 export class DocumentRenderer {
@@ -272,7 +275,7 @@ export class DocumentRenderer {
         }
     }
     updatePageSize(page, pageElement) {
-        if (pageElement.offsetHeight != page.height || pageElement.offsetWidth != page.width)
+        if (pageElement.offsetHeight != Math.round(page.height) || pageElement.offsetWidth != Math.round(page.width))
             DomUtils.setStyleSize(pageElement.style, page);
     }
     updatePageClasses(pageElement) {

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

@@ -24,7 +24,10 @@ import { MisspelledSelectionRenderer } from './selection-renderers/misspelled-se
 import { RangePermissionRenderer } from './selection-renderers/range-permission-renderer';
 import { SearchSelectionRenderer } from './selection-renderers/search-selection-renderer';
 import { SelectionRenderer } from './selection-renderers/selection-renderer';
-export declare class ViewManager implements ILayoutChangesListener {
+import { IZoomLevelHolder } from '../../interfaces/i-zoom-level-holder';
+import { IModelChangesListener } from '../../interfaces/model-changes-listener';
+import { ModelChange } from '../../model/changes/change';
+export declare class ViewManager implements ILayoutChangesListener, IZoomLevelHolder, IModelChangesListener {
     private renderers;
     get renderer(): DocumentRenderer;
     get printLayoutRenderer(): DocumentRenderer;
@@ -56,6 +59,7 @@ export declare class ViewManager implements ILayoutChangesListener {
     readonly control: IRichEditControl;
     constructor(control: IRichEditControl, canvas: HTMLDivElement, eventManager: IEventManager, stringResources: StringResources, horizontalRuler: IRulerControl, inputController: InputController, innerClientProperties: InnerClientProperties, readOnlyPropertyHolder: IReadOnlyPropertyHolder, layoutFormatterManagerHolder: ILayoutFormatterManagerHolder, internalApi: IInternalApi, fieldOptions: FieldsSettings);
     dispose(): void;
+    modelChanged(change: ModelChange): void;
     adjust(force: boolean): void;
     NotifyPagesReady(pageChanges: PageChange[]): void;
     NotifyFullyFormatted(_pageCount: number): void;

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

@@ -26,13 +26,15 @@ import { SearchSelectionRenderer } from './selection-renderers/search-selection-
 import { SelectionRenderer } from './selection-renderers/selection-renderer';
 import { ControlOptions, DocumentCapability } from '../../model/options/control';
 import { RichEditClientCommand } from '../../commands/client-command';
+import { ZoomLevelChange } from '../../model/changes/model/zoom-level';
+import { ModelChangeType } from '../../model/changes/enums';
 export class ViewManager {
     get renderer() { return this.renderers[this.innerClientProperties.viewsSettings.viewType]; }
     get printLayoutRenderer() { return this.renderers[ViewType.PrintLayout]; }
     get canvasListener() { return this.canvasListeners[this.innerClientProperties.viewsSettings.viewType]; }
     constructor(control, canvas, eventManager, stringResources, horizontalRuler, inputController, innerClientProperties, readOnlyPropertyHolder, layoutFormatterManagerHolder, internalApi, fieldOptions) {
         this.cache = [];
-        this.sizes = new CanvasSizeInfo();
+        this.sizes = new CanvasSizeInfo(this);
         this.control = control;
         this.readOnlyPropertyHolder = readOnlyPropertyHolder;
         this.layoutFormatterManagerHolder = layoutFormatterManagerHolder;
@@ -67,6 +69,13 @@ export class ViewManager {
         this.selection.dispose();
         this.pagesContainer = null;
     }
+    modelChanged(change) {
+        if (change.type == ModelChangeType.ZoomLevelChanged) {
+            this.canvas.scrollTop = this.canvas.scrollTop / change.prevZoomLevel * change.zoomLevel;
+            this.pagesContainer.style.zoom = change.zoomLevel.toString();
+            this.sizes.updateSize(this.canvas);
+        }
+    }
     adjust(force) {
         if ((force || !this.sizes.isInitialized()) && this.cache.length > 0) {
             const firstRenderedPageIndex = Math.min(this.cache.length, Math.max(0, ListUtils.indexBy(this.layout.pages, (page) => page.flags.get(LayoutPageFlags.ContentRendered))));
@@ -104,7 +113,9 @@ export class ViewManager {
             const pageInfo = layoutSelection.selectionInfo.pageInfos[pageIndex];
             const item = pageInfo.oldItems[0];
             const layoutPage = this.layout.pages[pageIndex];
-            this.inputController.setPosition(layoutPage.x + this.cache[pageIndex].page.offsetLeft + item.x, this.sizes.getPageOffsetY(layoutPage) + item.y);
+            const x = layoutPage.x + this.cache[pageIndex].page.offsetLeft + item.x;
+            const y = this.sizes.getPageOffsetY(layoutPage) + item.y;
+            this.inputController.setPosition(x, y);
         }
     }
     NotifySearchSelectionLayoutChanged() {
@@ -169,12 +180,9 @@ export class ViewManager {
     }
     get zoomLevel() { return this.innerClientProperties.viewsSettings.zoomLevel; }
     set zoomLevel(value) {
-        this.pagesContainer.style.zoom = value.toString();
+        const prevZoomLevel = this.zoomLevel;
         this.innerClientProperties.viewsSettings.zoomLevel = value;
-        if (this.control.innerClientProperties.viewsSettings.isSimpleView) {
-            this.canvasManager.simpleViewCanvasSizeManager.changeSize(true);
-        }
-        this.control.horizontalRulerControl.update();
+        this.control.modelManager.modelManipulator.notifyModelChanged(new ZoomLevelChange(this.zoomLevel, prevZoomLevel));
     }
     get allowZoom() { return ControlOptions.isEnabled(this.control.modelManager.richOptions.control.allowZoom); }
     set allowZoom(value) {

package/lib/common/formats/i-document-exporter.d.ts

@@ -1,6 +1,8 @@
 import { IPictureRenderer } from "../canvas/picture-renderer";
 import { DocumentFormat } from "../document-format";
+import { Grid } from "../layout-formatter/table/grid-engine/grid";
 import { IModelManager } from "../model-manager";
+import { Table } from "../model/tables/main-structures/table";
 import { IRichEditUnitConverter } from "../utils/unit-converter";
 export interface IDocumentExporter {
     exportToBlob(callback: (blob: Blob) => void): any;
@@ -14,5 +16,6 @@ export interface IExportModelOptions {
     sessionGuid: string;
     clientGuid: string;
     lastMaxNumPages?: number;
+    grids?: Map<Table, Grid>;
     pageIndex?: number;
 }

package/lib/common/formats/rtf/export/exporter.d.ts

@@ -1,7 +1,6 @@
-import { IDocumentExporter } from '../../i-document-exporter';
+import { IDocumentExporter, IExportModelOptions } from '../../i-document-exporter';
 import { ColorModelInfo } from '../../../model/color/color-model-info';
 import { DocumentModel } from '../../../model/document-model';
-import { ModelManipulator } from '../../../model/manipulators/model-manipulator';
 import { RtfContentExporter } from './exporters/rtf-content-exporter';
 import { RtfExportHelper } from './helpers/rtf-export-helper';
 import { RtfBuilder } from './rtf-builder';
@@ -13,7 +12,7 @@ export declare class RtfExporter implements IDocumentExporter {
     contentExporter: RtfContentExporter;
     private modelManipulator;
     get documentModel(): DocumentModel;
-    constructor(modelManipulator: ModelManipulator, options: RtfDocumentExporterOptions);
+    constructor(exportModelOptions: IExportModelOptions, options: RtfDocumentExporterOptions);
     exportToBlob(callback: (blob: Blob) => void): void;
     exportToBase64(callback: (base64: string) => void): void;
     exportAsString(): string;

package/lib/common/formats/rtf/export/exporter.js

@@ -11,11 +11,11 @@ import { RtfContentExporter } from './exporters/rtf-content-exporter';
 import { RtfExportHelper } from './helpers/rtf-export-helper';
 export class RtfExporter {
     get documentModel() { return this.modelManipulator.model; }
-    constructor(modelManipulator, options) {
-        this.modelManipulator = modelManipulator;
+    constructor(exportModelOptions, options) {
+        this.modelManipulator = exportModelOptions.modelManager.modelManipulator;
         this.options = options;
         this.rtfExportHelper = new RtfExportHelper();
-        this.contentExporter = new RtfContentExporter(this.documentModel, options, this.rtfExportHelper);
+        this.contentExporter = new RtfContentExporter(exportModelOptions, options, this.rtfExportHelper);
         this.rtfBuilder = this.contentExporter.createRtfBuilder();
     }
     exportToBlob(callback) {

package/lib/common/formats/rtf/export/exporters/rtf-content-exporter.d.ts

@@ -8,6 +8,7 @@ import { Section } from '../../../../model/section/section';
 import { SubDocument } from '../../../../model/sub-document';
 import { FooterSubDocumentInfo, HeaderSubDocumentInfo } from '../../../../model/sub-document-infos';
 import { ConditionalTableStyleFormatting } from '../../../../model/tables/secondary-structures/table-base-structures';
+import { IExportModelOptions } from '../../../../formats/i-document-exporter';
 import { RtfExportHelper } from '../helpers/rtf-export-helper';
 import { PieceTableNumberingListCountersManager } from '../piece-table-numbering-list-counters-manager';
 import { RtfBuilder } from '../rtf-builder';
@@ -17,7 +18,7 @@ import { RtfParagraphPropertiesExporter } from './rtf-paragraph-properties-expor
 import { RtfSectionPropertiesExporter } from './rtf-section-properties-exporter';
 export type RunHandler = (run: RunBase, runText: string, absolutePosition: number) => void;
 export declare class RtfContentExporter {
-    documentModel: DocumentModel;
+    exportModelOptions: IExportModelOptions;
     subDocument: SubDocument;
     currentSection: Section;
     static readonly verticalAlignmentTypes: Record<number, string>;
@@ -44,9 +45,10 @@ export declare class RtfContentExporter {
     private bookmarksIterator;
     private permissionsIterator;
     tableIterator: TableIterator;
+    get documentModel(): DocumentModel;
     private startSectionParagraphIndex;
     private shouldFourceUpdateIterators;
-    constructor(documentModel: DocumentModel, options: RtfDocumentExporterOptions, rtfExportHelper: RtfExportHelper);
+    constructor(exportModelOptions: IExportModelOptions, options: RtfDocumentExporterOptions, rtfExportHelper: RtfExportHelper);
     createRtfBuilder(): RtfBuilder;
     export(): void;
     shouldSplitRuns(): boolean;

package/lib/common/formats/rtf/export/exporters/rtf-content-exporter.js

@@ -37,17 +37,18 @@ import { RtfTableExporter } from './table/rtf-table-exporter';
 export class RtfContentExporter {
     get shouldExportHiddenText() { return true; }
     ;
-    constructor(documentModel, options, rtfExportHelper) {
+    get documentModel() { return this.exportModelOptions.modelManager.modelManipulator.model; }
+    constructor(exportModelOptions, options, rtfExportHelper) {
         this.shouldFourceUpdateIterators = false;
-        this.documentModel = documentModel;
+        this.exportModelOptions = exportModelOptions;
         this.subDocument = this.documentModel.mainSubDocument;
         this.pieceTableNumberingListCounters = new PieceTableNumberingListCountersManager();
         this.rtfExportHelper = rtfExportHelper;
         this.options = options;
         this.rtfBuilder = this.createRtfBuilder();
-        this.paragraphPropertiesExporter = new RtfParagraphPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder);
-        this.characterPropertiesExporter = new RtfCharacterPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder, options);
-        this.sectionPropertiesExporter = new RtfSectionPropertiesExporter(documentModel, rtfExportHelper, this.rtfBuilder);
+        this.paragraphPropertiesExporter = new RtfParagraphPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder);
+        this.characterPropertiesExporter = new RtfCharacterPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder, options);
+        this.sectionPropertiesExporter = new RtfSectionPropertiesExporter(this.documentModel, rtfExportHelper, this.rtfBuilder);
         this.runHandlerMap = new MapCreator()
             .add(RunType.TextRun, this.exportTextRun)
             .add(RunType.FieldCodeStartRun, this.fieldCodeStartRunHandler)
@@ -257,7 +258,7 @@ export class RtfContentExporter {
             value = "00000000";
         }
         else {
-            const view = new DataView(hash, 0);
+            const view = new DataView(hash.buffer, 0);
             const hashValue = view.getInt32(0);
             value = this.documentModel.simpleFormattersManager.formatString("{0:x8}", hashValue);
         }
@@ -433,11 +434,14 @@ export class RtfContentExporter {
             this.exportSingleParagraph(paragraph);
             return paragraphIndex;
         }
-        else
-            return RtfTableExporter.exportTable(this, tablesInfo[0].table.getTopLevelParent()) - this.startSectionParagraphIndex;
+        else {
+            const table = tablesInfo[0].table.getTopLevelParent();
+            const grid = this.exportModelOptions.grids.get(table);
+            return RtfTableExporter.exportTable(this, table, grid) - this.startSectionParagraphIndex;
+        }
     }
     exportSingleParagraph(paragraph) {
-        this.exportParagraphCore(paragraph, 0, 0, -1);
+        this.exportParagraphCore(paragraph, 0, ConditionalTableStyleFormatting.None, -1);
         this.finishParagraph(paragraph);
     }
     finishParagraph(paragraph) {

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

@@ -1,6 +1,7 @@
+import { Grid } from '../../../../../layout-formatter/table/grid-engine/grid';
 import { Table } from '../../../../../model/tables/main-structures/table';
 import { RtfContentExporter } from '../rtf-content-exporter';
 export declare class RtfTableExporter {
-    static exportTable(rtfContentExporter: RtfContentExporter, table: Table): number;
-    static exportNestedTable(rtfContentExporter: RtfContentExporter, table: Table, nestingLevel: number): number;
+    static exportTable(rtfContentExporter: RtfContentExporter, table: Table, grid: Grid): number;
+    static exportNestedTable(rtfContentExporter: RtfContentExporter, table: Table, grid: Grid, nestingLevel: number): number;
 }

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

@@ -1,13 +1,13 @@
 import { RtfNestedTableExporterState } from './states/rtf-nested-table-exporter-state';
 import { RtfTableExporterState } from './states/rtf-table-exporter-state';
 export class RtfTableExporter {
-    static exportTable(rtfContentExporter, table) {
-        new RtfTableExporterState(rtfContentExporter, table).export();
+    static exportTable(rtfContentExporter, table, grid) {
+        new RtfTableExporterState(rtfContentExporter, table, grid).export();
         rtfContentExporter.tableIterator.update(table.getEndPosition());
         return rtfContentExporter.subDocument.getParagraphIndexByPosition(table.getEndPosition() - 1);
     }
-    static exportNestedTable(rtfContentExporter, table, nestingLevel) {
-        new RtfNestedTableExporterState(rtfContentExporter, table, nestingLevel).export();
+    static exportNestedTable(rtfContentExporter, table, grid, nestingLevel) {
+        new RtfNestedTableExporterState(rtfContentExporter, table, grid, nestingLevel).export();
         rtfContentExporter.tableIterator.update(table.getEndPosition());
         return rtfContentExporter.subDocument.getParagraphIndexByPosition(table.getEndPosition() - 1);
     }

package/lib/common/formats/rtf/export/exporters/table/states/rtf-nested-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 RtfNestedTableExporterState extends RtfTableExporterStateBase {
-    constructor(rtfExporter: RtfContentExporter, table: Table, nestingLevel: number);
+    constructor(rtfExporter: RtfContentExporter, table: Table, grid: Grid, nestingLevel: number);
     export(): void;
     protected writeParagraphEndMark(): void;
     protected exportRow(row: TableRow, rowIndex: number): void;

package/lib/common/formats/rtf/export/exporters/table/states/rtf-nested-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 RtfNestedTableExporterState extends RtfTableExporterStateBase {
-    constructor(rtfExporter, table, nestingLevel) {
-        super(rtfExporter, table, nestingLevel);
+    constructor(rtfExporter, table, grid, nestingLevel) {
+        super(rtfExporter, table, grid, nestingLevel);
     }
     export() {
         super.exportBase();

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

@@ -6,6 +6,7 @@ import { TableCell } from '../../../../../../model/tables/main-structures/table-
 import { TableRow } from '../../../../../../model/tables/main-structures/table-row';
 import { ConditionalTableStyleFormatting } from '../../../../../../model/tables/secondary-structures/table-base-structures';
 import { TableWidthUnit } from '../../../../../../model/tables/secondary-structures/table-units';
+import { Grid } from '../../../../../../layout-formatter/table/grid-engine/grid';
 import { RtfBuilder } from '../../../rtf-builder';
 import { RtfContentExporter } from '../../rtf-content-exporter';
 import { RtfTableCellPropertiesExporter } from '../rtf-table-cell-properties-exporter';
@@ -17,10 +18,11 @@ export declare abstract class RtfTableExporterStateBase {
     tableStyleIndex: number;
     rowLeftOffset: number;
     readonly table: Table;
+    readonly grid: Grid;
     readonly tableRowPropertiesExporter: RtfTableRowPropertiesExporter;
     readonly tableCellPropertiesExporter: RtfTableCellPropertiesExporter;
     readonly tablePropertiesExporter: RtfTablePropertiesExporter;
-    protected constructor(rtfExporter: RtfContentExporter, table: Table, nestingLevel: number);
+    protected constructor(rtfExporter: RtfContentExporter, table: Table, grid: Grid, nestingLevel: number);
     protected get rtfBuilder(): RtfBuilder;
     protected get documentModel(): DocumentModel;
     protected get subDocument(): SubDocument;
@@ -36,7 +38,7 @@ export declare abstract class RtfTableExporterStateBase {
     protected abstract exportRow(row: TableRow, rowIndex: number): void;
     protected abstract writeParagraphEndMark(): void;
     exportRowProperties(row: TableRow, rowIndex: number): void;
-    getCellWidth(virtualColumnIndex: number): number;
+    getCellWidth(leftSideIndex: number, columnSpan: number): number;
     calculateRowLeft(row: TableRow, indent: TableWidthUnit): number;
     protected calculateRowLeftOffset(row: TableRow): number;
     getActualWidth(unit: TableWidthUnit): number;

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/import/table/normalization/apply-use-values.d.ts

@@ -0,0 +1,6 @@
+import { TableCellProperties } from '../../../../../model/tables/properties/table-cell-properties';
+import { TableProperties } from '../../../../../model/tables/properties/table-properties';
+import { TableRowProperties } from '../../../../../model/tables/properties/table-row-properties';
+export declare function applyTablePropertiesUseValues(props: TableProperties, styleProps: TableProperties): void;
+export declare function applyTableRowPropertiesUseValues(props: TableRowProperties, styleProps: TableRowProperties): void;
+export declare function applyTableCellPropertiesUseValues(props: TableCellProperties, styleProps: TableCellProperties): void;

package/lib/common/formats/rtf/import/table/normalization/apply-use-values.js

@@ -0,0 +1,90 @@
+import { TableCellPropertiesMask } from '../../../../../model/tables/properties/table-cell-properties';
+import { TablePropertiesMask } from '../../../../../model/tables/properties/table-properties';
+import { TableRowPropertiesMask } from '../../../../../model/tables/properties/table-row-properties';
+export function applyTablePropertiesUseValues(props, styleProps) {
+    props.mask = TablePropertiesMask.UseNone;
+    if (!props.borders.left.equals(styleProps.borders.left))
+        props.setUseValue(TablePropertiesMask.UseLeftBorder, true);
+    if (!props.borders.top.equals(styleProps.borders.top))
+        props.setUseValue(TablePropertiesMask.UseTopBorder, true);
+    if (!props.borders.right.equals(styleProps.borders.right))
+        props.setUseValue(TablePropertiesMask.UseRightBorder, true);
+    if (!props.borders.bottom.equals(styleProps.borders.bottom))
+        props.setUseValue(TablePropertiesMask.UseBottomBorder, true);
+    if (!props.borders.insideHorizontal.equals(styleProps.borders.insideHorizontal))
+        props.setUseValue(TablePropertiesMask.UseInsideHorizontalBorder, true);
+    if (!props.borders.insideVertical.equals(styleProps.borders.insideVertical))
+        props.setUseValue(TablePropertiesMask.UseInsideVerticalBorder, true);
+    if (!props.cellMargins.left.equals(styleProps.cellMargins.left))
+        props.setUseValue(TablePropertiesMask.UseLeftMargin, true);
+    if (!props.cellMargins.top.equals(styleProps.cellMargins.top))
+        props.setUseValue(TablePropertiesMask.UseTopMargin, true);
+    if (!props.cellMargins.right.equals(styleProps.cellMargins.right))
+        props.setUseValue(TablePropertiesMask.UseRightMargin, true);
+    if (!props.cellMargins.bottom.equals(styleProps.cellMargins.bottom))
+        props.setUseValue(TablePropertiesMask.UseBottomMargin, true);
+    if (!props.cellSpacing.equals(styleProps.cellSpacing))
+        props.setUseValue(TablePropertiesMask.UseCellSpacing, true);
+    if (!props.indent.equals(styleProps.indent))
+        props.setUseValue(TablePropertiesMask.UseTableIndent, true);
+    if (props.tableStyleColumnBandSize != styleProps.tableStyleColumnBandSize)
+        props.setUseValue(TablePropertiesMask.UseTableStyleColBandSize, true);
+    if (props.tableStyleRowBandSize != styleProps.tableStyleRowBandSize)
+        props.setUseValue(TablePropertiesMask.UseTableStyleRowBandSize, true);
+    if (props.avoidDoubleBorders != styleProps.avoidDoubleBorders)
+        props.setUseValue(TablePropertiesMask.UseAvoidDoubleBorders, true);
+    if (props.layoutType != styleProps.layoutType)
+        props.setUseValue(TablePropertiesMask.UseTableLayout, true);
+    if (!props.shadingInfo.equals(styleProps.shadingInfo))
+        props.setUseValue(TablePropertiesMask.UseShadingInfoIndex, true);
+    if (props.tableRowAlignment != styleProps.tableRowAlignment)
+        props.setUseValue(TablePropertiesMask.UseTableAlignment, true);
+    if (props.isTableOverlap != styleProps.isTableOverlap)
+        props.setUseValue(TablePropertiesMask.UseIsTableOverlap, true);
+}
+export function applyTableRowPropertiesUseValues(props, styleProps) {
+    props.mask = TableRowPropertiesMask.UseNone;
+    if (!props.cellSpacing.equals(styleProps.cellSpacing))
+        props.setUseValue(TableRowPropertiesMask.UseCellSpacing, true);
+    if (props.cantSplit != styleProps.cantSplit)
+        props.setUseValue(TableRowPropertiesMask.UseCantSplit, true);
+    if (props.hideCellMark != styleProps.hideCellMark)
+        props.setUseValue(TableRowPropertiesMask.UseHideCellMark, true);
+    if (props.tableRowAlignment != styleProps.tableRowAlignment)
+        props.setUseValue(TableRowPropertiesMask.UseTableRowAlignment, true);
+    if (props.header != styleProps.header)
+        props.setUseValue(TableRowPropertiesMask.UseHeader, true);
+    if (props.divId != styleProps.divId)
+        props.setUseValue(TableRowPropertiesMask.UseDivId, true);
+}
+export function applyTableCellPropertiesUseValues(props, styleProps) {
+    props.mask = TableCellPropertiesMask.UseNone;
+    if (!props.cellMargins.left.equals(styleProps.cellMargins.left))
+        props.setUseValue(TableCellPropertiesMask.UseLeftMargin, true);
+    if (!props.cellMargins.top.equals(styleProps.cellMargins.top))
+        props.setUseValue(TableCellPropertiesMask.UseTopMargin, true);
+    if (!props.cellMargins.bottom.equals(styleProps.cellMargins.bottom))
+        props.setUseValue(TableCellPropertiesMask.UseBottomMargin, true);
+    if (!props.cellMargins.right.equals(styleProps.cellMargins.right))
+        props.setUseValue(TableCellPropertiesMask.UseRightMargin, true);
+    if (!props.borders.left.equals(styleProps.borders.left))
+        props.setUseValue(TableCellPropertiesMask.UseLeftBorder, true);
+    if (!props.borders.top.equals(styleProps.borders.top))
+        props.setUseValue(TableCellPropertiesMask.UseTopBorder, true);
+    if (!props.borders.bottom.equals(styleProps.borders.bottom))
+        props.setUseValue(TableCellPropertiesMask.UseBottomBorder, true);
+    if (!props.borders.right.equals(styleProps.borders.right))
+        props.setUseValue(TableCellPropertiesMask.UseRightBorder, true);
+    if (props.hideCellMark != styleProps.hideCellMark)
+        props.setUseValue(TableCellPropertiesMask.UseHideCellMark, true);
+    if (props.noWrap != styleProps.noWrap)
+        props.setUseValue(TableCellPropertiesMask.UseNoWrap, true);
+    if (props.fitText != styleProps.fitText)
+        props.setUseValue(TableCellPropertiesMask.UseFitText, true);
+    if (props.textDirection != styleProps.textDirection)
+        props.setUseValue(TableCellPropertiesMask.UseTextDirection, true);
+    if (props.verticalAlignment != styleProps.verticalAlignment)
+        props.setUseValue(TableCellPropertiesMask.UseVerticalAlignment, true);
+    if (!props.shadingInfo.equals(styleProps.shadingInfo))
+        props.setUseValue(TableCellPropertiesMask.UseShadingInfoIndex, true);
+}

package/lib/common/formats/rtf/import/table/table-converter.js

@@ -7,6 +7,7 @@ import { ListUtils } from '@devexpress/utils/lib/utils/list';
 import { NumberMapUtils } from '@devexpress/utils/lib/utils/map/number';
 import { RtfTableColumnsCalculator } from './rtf-table-columns-calculator';
 import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
+import { applyTableCellPropertiesUseValues, applyTablePropertiesUseValues, applyTableRowPropertiesUseValues } from './normalization/apply-use-values';
 export class RtfTableConverter {
     constructor(tableReader) {
         this.rtfCellMap = {};
@@ -54,8 +55,9 @@ export class RtfTableConverter {
             tablePreferredWidth.type = TableWidthUnitType.Auto;
             tablePreferredWidth.value = 0;
         }
-        if (!table.properties.coreProperties.getUseValue(TablePropertiesMask.UseRightMargin) &&
-            !table.properties.coreProperties.getUseValue(TablePropertiesMask.UseLeftMargin) && table.properties.useHalfSpace) {
+        const useMargins = table.properties.coreProperties.getUseValue(TablePropertiesMask.UseLeftMargin) &&
+            table.properties.coreProperties.getUseValue(TablePropertiesMask.UseRightMargin);
+        if (!useMargins && table.properties.useHalfSpace) {
             const margin = table.properties.halfSpace;
             table.properties.coreProperties.cellMargins.left.type = TableWidthUnitType.ModelUnits;
             table.properties.coreProperties.cellMargins.left.value = margin;
@@ -99,6 +101,7 @@ export class RtfTableConverter {
         return 0;
     }
     convertTableCore(table, rtfTable) {
+        applyTablePropertiesUseValues(table.properties, table.style.baseConditionalStyle.tableProperties);
         const tableGrid = this.calculateTableGrid(rtfTable);
         const rows = table.rows;
         const tableLayoutType = table.properties.layoutType;
@@ -201,6 +204,7 @@ export class RtfTableConverter {
         return result;
     }
     convertRow(row, rtfRow) {
+        applyTableRowPropertiesUseValues(row.properties, row.parentTable.style.baseConditionalStyle.tableRowProperties);
         const rtfCells = rtfRow.cells;
         for (let i = 0; i < rtfCells.length; i++)
             this.convertCell(row, rtfCells[i]);
@@ -209,6 +213,7 @@ export class RtfTableConverter {
         if (rtfCell.properties.horizontalMerging == TableCellMergingState.Restart)
             this.mergeCells(rtfCell);
         const cell = rtfCell.createCell(row, this.subDocument);
+        applyTableCellPropertiesUseValues(cell.properties, cell.parentRow.parentTable.style.baseConditionalStyle.tableCellProperties);
         row.cells.push(cell);
         this.rtfCellMap[rtfCell.idForParentCellMap] = cell;
     }

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(() => { });