devexpress-richedit 25.2.3 → 25.2.5

package/lib/common/commands/selection/go-to-prev-page-command.js

@@ -1,61 +1,40 @@
-import { LayoutPositionCreatorConflictFlags, LayoutPositionMainSubDocumentCreator } from '../../layout-engine/layout-position-creator';
-import { DocumentLayoutDetailsLevel } from '../../layout/document-layout-details-level';
-import { LayoutPoint } from '../../layout/layout-point';
-import { SelectionCommandBase } from './selection-command-base';
-export class GoToPrevPageCommandBase extends SelectionCommandBase {
-    getPosition() {
-        const selection = this.selection;
-        const initPosition = selection.forwardDirection ? selection.lastSelectedInterval.end : selection.lastSelectedInterval.start;
-        const layoutPosition = new LayoutPositionMainSubDocumentCreator(this.control.layout, this.selection.activeSubDocument, initPosition, DocumentLayoutDetailsLevel.Box)
-            .create(new LayoutPositionCreatorConflictFlags().setDefault(false), new LayoutPositionCreatorConflictFlags().setDefault(true));
-        if (!layoutPosition)
-            return -1;
-        const charOffset = initPosition - layoutPosition.getLogPosition(DocumentLayoutDetailsLevel.Box);
-        const x = layoutPosition.pageArea.x + layoutPosition.column.x + layoutPosition.row.x + layoutPosition.box.x + layoutPosition.box.getCharOffsetXInPixels(this.control.measurer, charOffset);
-        const y = layoutPosition.pageArea.y + layoutPosition.column.y + layoutPosition.row.y + layoutPosition.box.y;
-        const viewportHeight = Math.max(layoutPosition.row.height, this.control.viewManager.sizes.getVisibleAreaHeight(false));
-        let newY = y - viewportHeight;
+import { GoToPageCommandBase } from './go-to-page-command-base';
+import { MixedSize } from '../../../common/utils/mixed-size';
+export class GoToPrevPageCommandBase extends GoToPageCommandBase {
+    goToPage(layoutPosition, x, y) {
+        const visibleAreaHeight = MixedSize.fromUI(this.control.viewManager.sizes.getVisibleAreaHeight(false)).useScale(this.scale);
+        const viewportHeight = MixedSize.fromLayout(Math.max(layoutPosition.row.height, visibleAreaHeight.LayoutSize)).useScale(this.scale);
+        const viewportTop = MixedSize.fromUI(this.control.viewManager.canvas.scrollTop).useScale(this.scale);
         let page = layoutPosition.page;
-        const absoluteY = newY + page.y;
-        do {
-            if (absoluteY >= page.y) {
-                newY = absoluteY - page.y;
-                const point = new LayoutPoint(page.index, x, newY);
-                const htr = this.control.hitTestManager.calculate(point, DocumentLayoutDetailsLevel.Character, this.selection.activeSubDocument);
-                if (!this.extendSelection())
-                    htr.correctAsVisibleBox();
-                return htr.getPosition();
-            }
-            const siblingPageIndex = layoutPosition.pageIndex - 1;
-            page = this.control.layout.pages[siblingPageIndex];
-        } while (page);
-        return 0;
+        const newViewportTop = MixedSize.substract(viewportTop, viewportHeight);
+        let pageIndex = this.findPageIndexByOffsetY(newViewportTop.LayoutSize);
+        this.scrollToPosition(pageIndex, newViewportTop.LayoutSize);
+        const newY = MixedSize.substract(MixedSize.fromLayout(y).useScale(this.scale), viewportHeight);
+        const position = this.getPosition(page, MixedSize.fromLayout(x).useScale(this.scale), newY, newViewportTop, viewportHeight);
+        this.changeSelection(position);
     }
-    isEnabled() {
-        return super.isEnabled() && this.selection.activeSubDocument.isMain();
+    getPosition(currentPage, x, y, viewportTop, viewportHeight) {
+        const currentPageY = this.control.viewManager.sizes.getPageOffsetY(currentPage);
+        const viewportBottom = MixedSize.add(viewportTop, viewportHeight);
+        const newAbsoluteY = MixedSize.min(y.addLayoutSize(currentPageY), viewportBottom);
+        let pageIndex = this.findPageIndexByOffsetY(newAbsoluteY.LayoutSize);
+        const pageY = this.getPageOffsetY(pageIndex);
+        const htr = this.calculateHitTestResult(pageIndex, x.LayoutSize, newAbsoluteY.LayoutSize - pageY);
+        const rowY = htr.getLayoutY() + pageY + htr.row.height / 2;
+        if (rowY >= viewportTop.LayoutSize)
+            return htr.getPosition();
+        const position = this.tryFindVisiblePosition(x.LayoutSize, viewportTop.LayoutSize, viewportBottom.LayoutSize);
+        if (position !== null)
+            return position;
+        return htr.getPosition();
     }
 }
 export class GoToPrevPageCommand extends GoToPrevPageCommandBase {
-    executeCore(_state, _options) {
-        const selection = this.selection;
-        const position = this.getPosition();
-        if (position < 0)
-            return false;
-        selection.deprecatedSetSelection(position, position, selection.endOfLine, selection.keepX, true);
-        return true;
-    }
     extendSelection() {
         return false;
     }
 }
 export class ExtendGoToPrevPageCommand extends GoToPrevPageCommandBase {
-    executeCore(_state, _options) {
-        const position = this.getPosition();
-        if (position < 0)
-            return false;
-        this.selection.changeState((newState) => newState.extendLastInterval(position));
-        return true;
-    }
     extendSelection() {
         return true;
     }

package/lib/common/commands/selection/select-table-command.js

@@ -106,8 +106,6 @@ export class ExtendSelectTableColumnCommand extends SelectTableColumnCommand {
     }
 }
 export class SelectTableRowCommandOptions extends CommandOptions {
-    rows;
-    forwardDirection;
     constructor(control, table, rowIndices, forwardDirection) {
         super(control);
         if (table) {

package/lib/common/commands/shortcut-manager.js

@@ -5,11 +5,8 @@ import { ListUtils } from '@devexpress/utils/lib/utils/list';
 import { RichEditClientCommand } from './client-command';
 import { ClipboardCommand } from './text/clipboard-commands';
 export class ShortcutManager {
-    lastCommandExecutedByShortcut;
-    control;
-    shortcuts;
-    knownNonCommandShortcuts = {};
     constructor(commandManager, control) {
+        this.knownNonCommandShortcuts = {};
         this.control = control;
         this.init(commandManager);
     }
@@ -140,7 +137,6 @@ export class CommandHolderBase {
     }
 }
 export class CommandHolder extends CommandHolderBase {
-    command;
     constructor(command) {
         super();
         this.command = command;
@@ -153,7 +149,6 @@ export class CommandHolder extends CommandHolderBase {
     }
 }
 export class UserDefinedFunctionHolder extends CommandHolderBase {
-    userCommandCallback;
     constructor(userCommandCallback) {
         super();
         this.userCommandCallback = userCommandCallback;

package/lib/common/commands/shortcuts/assign-shortcut-command.js

@@ -1,8 +1,6 @@
 import { CommandBase, CommandOptions } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class AssignShortcutCommandOptions extends CommandOptions {
-    keyCode;
-    callback;
     constructor(control, keyCode, callback) {
         super(control);
         this.keyCode = keyCode;

package/lib/common/commands/sub-document/change-active-sub-document-command.js

@@ -48,8 +48,6 @@ class FindTextBoxPageIndexHelper extends FindPageIndexHelper {
     }
 }
 export class ChangeActiveSubDocumentToHeaderFooterByPageIndexCommandParameters extends CommandOptions {
-    pageIndex;
-    isHeader;
     constructor(control, pageIndex, isHeader) {
         super(control);
         this.pageIndex = pageIndex;
@@ -181,11 +179,11 @@ export class ChangeActiveSubDocumentToHeaderFooterByPageIndexCommand extends Cha
     }
 }
 export class ChangeActiveSubDocumentToHeaderFooterOrTextBoxBySubDocumentCommand extends ChangeActiveSubDocumentCommandBase {
-    static MapTypeToPageIndexHelper = new MapCreator()
+    static { this.MapTypeToPageIndexHelper = new MapCreator()
         .add(SubDocumentInfoType.Header, new FindHeaderPageIndexHelper())
         .add(SubDocumentInfoType.Footer, new FindFooterPageIndexHelper())
         .add(SubDocumentInfoType.TextBox, new FindTextBoxPageIndexHelper())
-        .get();
+        .get(); }
     executeCore(_state, options) {
         const newActiveSubDoc = options.param;
         let targetPageIndex;

package/lib/common/commands/tables/change-table-cell-alignment-command.js

@@ -11,8 +11,6 @@ import { RichEditClientCommand } from '../client-command';
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class ChangeTableCellAlignmentCommandBase extends CommandBase {
-    horizontalAlignment;
-    verticalAlignment;
     getRelatedCommands() {
         return {
             [RichEditClientCommand.TableCellAlignBottomCenter]: true,
@@ -61,38 +59,65 @@ export class ChangeTableCellAlignmentCommandBase extends CommandBase {
     }
 }
 export class ChangeTableCellTopLeftAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Left;
-    verticalAlignment = TableCellVerticalAlignment.Top;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Left;
+        this.verticalAlignment = TableCellVerticalAlignment.Top;
+    }
 }
 export class ChangeTableCellTopCenterAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Center;
-    verticalAlignment = TableCellVerticalAlignment.Top;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Center;
+        this.verticalAlignment = TableCellVerticalAlignment.Top;
+    }
 }
 export class ChangeTableCellTopRightAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Right;
-    verticalAlignment = TableCellVerticalAlignment.Top;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Right;
+        this.verticalAlignment = TableCellVerticalAlignment.Top;
+    }
 }
 export class ChangeTableCellMiddleLeftAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Left;
-    verticalAlignment = TableCellVerticalAlignment.Center;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Left;
+        this.verticalAlignment = TableCellVerticalAlignment.Center;
+    }
 }
 export class ChangeTableCellMiddleCenterAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Center;
-    verticalAlignment = TableCellVerticalAlignment.Center;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Center;
+        this.verticalAlignment = TableCellVerticalAlignment.Center;
+    }
 }
 export class ChangeTableCellMiddleRightAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Right;
-    verticalAlignment = TableCellVerticalAlignment.Center;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Right;
+        this.verticalAlignment = TableCellVerticalAlignment.Center;
+    }
 }
 export class ChangeTableCellBottomLeftAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Left;
-    verticalAlignment = TableCellVerticalAlignment.Bottom;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Left;
+        this.verticalAlignment = TableCellVerticalAlignment.Bottom;
+    }
 }
 export class ChangeTableCellBottomCenterAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Center;
-    verticalAlignment = TableCellVerticalAlignment.Bottom;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Center;
+        this.verticalAlignment = TableCellVerticalAlignment.Bottom;
+    }
 }
 export class ChangeTableCellBottomRightAlignmentCommand extends ChangeTableCellAlignmentCommandBase {
-    horizontalAlignment = ParagraphAlignment.Right;
-    verticalAlignment = TableCellVerticalAlignment.Bottom;
+    constructor() {
+        super(...arguments);
+        this.horizontalAlignment = ParagraphAlignment.Right;
+        this.verticalAlignment = TableCellVerticalAlignment.Bottom;
+    }
 }

package/lib/common/commands/tables/change-table-look-command.js

@@ -6,7 +6,6 @@ import { RichEditClientCommand } from '../client-command';
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class ChangeTableLookCommandBase extends CommandBase {
-    option;
     getState() {
         const tableInfo = this.selection.tableInfo;
         const state = new SimpleCommandState(this.isEnabled() && tableInfo.extendedData.numRows > 0, false);
@@ -64,25 +63,43 @@ export class ChangeTableLookCommand extends ChangeTableLookCommandBase {
     }
 }
 export class ToggleFirstRowCommand extends ChangeTableLookCommandBase {
-    option = TableLookTypes.ApplyFirstRow;
+    constructor() {
+        super(...arguments);
+        this.option = TableLookTypes.ApplyFirstRow;
+    }
 }
 export class ToggleLastRowCommand extends ChangeTableLookCommandBase {
-    option = TableLookTypes.ApplyLastRow;
+    constructor() {
+        super(...arguments);
+        this.option = TableLookTypes.ApplyLastRow;
+    }
 }
 export class ToggleFirstColumnCommand extends ChangeTableLookCommandBase {
-    option = TableLookTypes.ApplyFirstColumn;
+    constructor() {
+        super(...arguments);
+        this.option = TableLookTypes.ApplyFirstColumn;
+    }
 }
 export class ToggleLastColumnCommand extends ChangeTableLookCommandBase {
-    option = TableLookTypes.ApplyLastColumn;
+    constructor() {
+        super(...arguments);
+        this.option = TableLookTypes.ApplyLastColumn;
+    }
 }
 export class ToggleBandedRowsCommand extends ChangeTableLookCommandBase {
-    option = TableLookTypes.DoNotApplyRowBanding;
+    constructor() {
+        super(...arguments);
+        this.option = TableLookTypes.DoNotApplyRowBanding;
+    }
     isInvertedTableLookType() {
         return true;
     }
 }
 export class ToggleBandedColumnCommand extends ChangeTableLookCommandBase {
-    option = TableLookTypes.DoNotApplyColumnBanding;
+    constructor() {
+        super(...arguments);
+        this.option = TableLookTypes.DoNotApplyColumnBanding;
+    }
     isInvertedTableLookType() {
         return true;
     }

package/lib/common/commands/tables/insert-table-cells-with-shift-to-the-horizontally-command.d.ts

@@ -8,6 +8,7 @@ export declare abstract class InsertTableCellWithShiftToTheHorizontallyCommandBa
     isEnabled(): boolean;
     executeCore(_state: SimpleCommandState, options: ICommandOptions): boolean;
     abstract insertTableCell(subDocument: SubDocument, table: Table, rowIndex: number, cellIndex: number): TableCell;
+    private canModifySelectedRows;
 }
 export declare class InsertTableCellWithShiftToTheLeftCommand extends InsertTableCellWithShiftToTheHorizontallyCommandBase {
     insertTableCell(subDocument: SubDocument, table: Table, rowIndex: number, cellIndex: number): TableCell;

package/lib/common/commands/tables/insert-table-cells-with-shift-to-the-horizontally-command.js

@@ -1,6 +1,7 @@
 import { ControlOptions } from '../../model/options/control';
 import { TableCellMergingState } from '../../model/tables/secondary-structures/table-base-structures';
 import { TableConditionalFormattingCalculator } from '../../model/tables/table-utils';
+import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 import { SelectionHistoryItem } from '../../model/history/selection/selection-history-item';
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
@@ -9,7 +10,9 @@ export class InsertTableCellWithShiftToTheHorizontallyCommandBase extends Comman
         return new SimpleCommandState(this.isEnabled());
     }
     isEnabled() {
-        return super.isEnabled() && ControlOptions.isEnabled(this.control.modelManager.richOptions.control.tables) && this.selection.tableInfo.extendedData.numRows > 0;
+        const tableInfo = this.selection.tableInfo;
+        return super.isEnabled() && ControlOptions.isEnabled(this.control.modelManager.richOptions.control.tables) &&
+            tableInfo.extendedData.numRows > 0 && this.canModifySelectedRows(this.selection.activeSubDocument, tableInfo);
     }
     executeCore(_state, options) {
         this.history.beginTransaction();
@@ -30,6 +33,18 @@ export class InsertTableCellWithShiftToTheHorizontallyCommandBase extends Comman
         this.history.endTransaction();
         return true;
     }
+    canModifySelectedRows(subDocument, tableInfo) {
+        const table = tableInfo.table;
+        const rawRows = tableInfo.rawData.rows;
+        if (!table || !rawRows || rawRows.length === 0)
+            return false;
+        const intervals = [];
+        for (let i = 0; i < table.rows.length; i++) {
+            const row = table.rows[i];
+            intervals.push(FixedInterval.fromPositions(row.getStartPosition(), row.getEndPosition()));
+        }
+        return subDocument.isEditable(intervals);
+    }
 }
 export class InsertTableCellWithShiftToTheLeftCommand extends InsertTableCellWithShiftToTheHorizontallyCommandBase {
     insertTableCell(subDocument, table, rowIndex, cellIndex) {

package/lib/common/commands/tables/insert-table-cells-with-shift-to-the-vertically-command.d.ts

@@ -15,4 +15,5 @@ export declare class InsertTableCellsWithShiftToTheVerticallyCommand extends Com
     insertTableCells(subDocument: SubDocument, table: Table, patternRowIndex: number, patternCellIndex: number, insertedCellsCount: number, preferredWidth: TableWidthUnit): void;
     deleteTextInCell(subDocument: SubDocument, table: Table, rowIndex: number, rowsCount: number): void;
     deleteContentInCell(subDocument: SubDocument, table: Table, rowIndex: number, cellIndex: number): void;
+    private canModifyVerticalSelection;
 }

package/lib/common/commands/tables/insert-table-cells-with-shift-to-the-vertically-command.js

@@ -15,7 +15,9 @@ export class InsertTableCellsWithShiftToTheVerticallyCommand extends CommandBase
         return new SimpleCommandState(this.isEnabled());
     }
     isEnabled() {
-        return super.isEnabled() && ControlOptions.isEnabled(this.control.modelManager.richOptions.control.tables) && this.selection.tableInfo.extendedData.areCellsSelectedInSeries;
+        const tableInfo = this.selection.tableInfo;
+        return super.isEnabled() && ControlOptions.isEnabled(this.control.modelManager.richOptions.control.tables) &&
+            tableInfo.extendedData.areCellsSelectedInSeries && this.canModifyVerticalSelection(this.selection.activeSubDocument, tableInfo);
     }
     executeCore(_state, options) {
         this.history.beginTransaction();
@@ -100,4 +102,24 @@ export class InsertTableCellsWithShiftToTheVerticallyCommand extends CommandBase
         if (cell.endParagrapPosition.value - cell.startParagraphPosition.value > 1)
             this.modelManipulator.range.removeInterval(new SubDocumentInterval(subDocument, FixedInterval.fromPositions(cell.startParagraphPosition.value, cell.endParagrapPosition.value - 1)), true, false);
     }
+    canModifyVerticalSelection(subDocument, tableInfo) {
+        const table = tableInfo.table;
+        const rawRows = tableInfo.rawData.rows;
+        if (!table || !rawRows || rawRows.length === 0)
+            return false;
+        const wholeTableInterval = FixedInterval.fromPositions(table.getStartPosition(), table.getEndPosition());
+        if (subDocument.isEditable([wholeTableInterval]))
+            return true;
+        const rowIntervals = [];
+        for (let rowIndex = 0; rowIndex < table.rows.length; rowIndex++) {
+            const row = table.rows[rowIndex];
+            rowIntervals.push(FixedInterval.fromPositions(row.getStartPosition(), row.getEndPosition()));
+        }
+        if (!subDocument.isEditable(rowIntervals))
+            return false;
+        let maxSelectedRowIndex = -1;
+        for (let i = 0; i < rawRows.length; i++)
+            maxSelectedRowIndex = Math.max(maxSelectedRowIndex, rawRows[i].rowIndex);
+        return maxSelectedRowIndex === table.rows.length - 1;
+    }
 }

package/lib/common/commands/tables/insert-table-column-commands.d.ts

@@ -8,6 +8,7 @@ import { TableCommandBase } from './table-command-base';
 export declare abstract class InsertTableColumnCommandBase extends TableCommandBase<SimpleCommandState> {
     getState(): SimpleCommandState;
     isEnabled(): boolean;
+    protected canModifyTable(table: Table): boolean;
     executeCore(_state: SimpleCommandState, options: ICommandOptions): boolean;
     private getInsertedColumnCount;
     private getColumnCellIndices;

package/lib/common/commands/tables/insert-table-column-commands.js

@@ -6,6 +6,7 @@ import { ControlOptions } from '../../model/options/control';
 import { SubDocumentPosition } from '../../model/sub-document';
 import { TableCellUtils, TableConditionalFormattingCalculator } from '../../model/tables/table-utils';
 import { Constants } from '@devexpress/utils/lib/constants';
+import { FixedInterval } from '@devexpress/utils/lib/intervals/fixed';
 import { ListUtils } from '@devexpress/utils/lib/utils/list';
 import { SimpleCommandState } from '../command-states';
 import { TableCommandBase } from './table-command-base';
@@ -16,6 +17,13 @@ export class InsertTableColumnCommandBase extends TableCommandBase {
     isEnabled() {
         return super.isEnabled() && ControlOptions.isEnabled(this.control.modelManager.richOptions.control.tables) && this.selection.tableInfo.extendedData.isSquare;
     }
+    canModifyTable(table) {
+        const subDocument = this.selection.activeSubDocument;
+        if (super.canModifyTable(table))
+            return true;
+        const rowIntervals = table.rows.map(row => FixedInterval.fromPositions(row.getStartPosition(), row.getEndPosition()));
+        return rowIntervals.length > 0 && subDocument.isEditable(rowIntervals);
+    }
     executeCore(_state, options) {
         this.history.beginTransaction();
         let patternCell = this.getPatternCell();

package/lib/common/commands/tables/insert-table-core-command.js

@@ -7,6 +7,9 @@ import { UnitConverter } from '@devexpress/utils/lib/class/unit-converter';
 import { SelectionHistoryItem } from '../../model/history/selection/selection-history-item';
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
+import { ApplyTableStyleHistoryItem } from '../../../common/model/history/items/apply-style-history-items';
+import { TableStyle } from '../../../common/model/tables/styles/table-style';
+import { StylesManager } from '../../../common/model/styles-manager';
 export class InsertTableCoreCommand extends CommandBase {
     getState() {
         return new SimpleCommandState(this.isEnabled());
@@ -16,16 +19,18 @@ export class InsertTableCoreCommand extends CommandBase {
     }
     executeCore(_state, options) {
         const parameter = options.param;
+        const model = this.control.modelManager.model;
+        const gridTableStyle = model.getTableStyleByName(TableStyle.GRID_STYLENAME) || model.stylesManager.addTableStyle(StylesManager.getPresetTableStyleByName(TableStyle.GRID_STYLENAME)?.clone());
         const subDocument = this.selection.activeSubDocument;
         const position = this.selection.intervals[0].start;
         const lp = LayoutPosition.ensure(this.control.layoutFormatterManager, subDocument, position);
         let currentTable = Table.getTableByPosition(subDocument.tables, position, true);
-        let availableWidth = currentTable ? lp.row.tableCellInfo.avaliableContentWidth :
-            LayoutColumn.findSectionColumnWithMinimumWidth(lp.pageArea.columns);
+        let availableWidth = currentTable ? lp.row.tableCellInfo.avaliableContentWidth : LayoutColumn.findSectionColumnWithMinimumWidth(lp.pageArea.columns);
         this.history.beginTransaction();
-        const table = this.modelManipulator.table.insertTable(subDocument, parameter.rowCount, parameter.cellCount, position, UnitConverter.pixelsToTwipsF(availableWidth), this.inputPosition, true);
+        const table = this.modelManipulator.table.insertTable(subDocument, parameter.rowCount, parameter.cellCount, position, UnitConverter.pixelsToTwipsF(availableWidth), this.inputPosition, false);
         this.history.addAndRedo(new SelectionHistoryItem(this.modelManipulator, this.selection, this.selection.getState(), this.selection.getState().setPosition(table.getStartPosition()).setEndOfLine(false)));
         TableConditionalFormattingCalculator.updateTable(this.control.modelManager, table, subDocument);
+        this.history.addAndRedo(new ApplyTableStyleHistoryItem(this.modelManipulator, subDocument, table.index, gridTableStyle));
         this.history.endTransaction();
         return true;
     }

package/lib/common/commands/tables/table-command-base.d.ts

@@ -1,5 +1,7 @@
+import { Table } from '../../model/tables/main-structures/table';
 import { CommandBase } from '../command-base';
 import { ICommandState } from '../i-command';
 export declare abstract class TableCommandBase<T extends ICommandState> extends CommandBase<T> {
     isEnabled(): boolean;
+    protected canModifyTable(table: Table): boolean;
 }

package/lib/common/commands/tables/table-command-base.js

@@ -4,6 +4,9 @@ export class TableCommandBase extends CommandBase {
     isEnabled() {
         const table = this.control.selection.tableInfo.table;
         return super.isEnabled() && table != null &&
-            this.control.selection.activeSubDocument.isEditable([FixedInterval.fromPositions(table.getStartPosition(), table.getEndPosition())]);
+            this.canModifyTable(table);
+    }
+    canModifyTable(table) {
+        return this.control.selection.activeSubDocument.isEditable([FixedInterval.fromPositions(table.getStartPosition(), table.getEndPosition())]);
     }
 }

package/lib/common/commands/tables/toggle-table-cells-border-command.js

@@ -11,11 +11,13 @@ import { RichEditClientCommand } from '../client-command';
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class ToggleTableCellsBorderCommandBase extends CommandBase {
-    affectNeighbours = true;
-    affectInner = true;
-    affectOuter = true;
-    affectOnStateFlags = TableBorderGridCellInfo.All;
-    patternBorder;
+    constructor() {
+        super(...arguments);
+        this.affectNeighbours = true;
+        this.affectInner = true;
+        this.affectOuter = true;
+        this.affectOnStateFlags = TableBorderGridCellInfo.All;
+    }
     get colorProvider() { return this.control.modelManager.model.colorProvider; }
     DEPRECATEDConvertOptionsParameter(parameter) {
         return parameter instanceof BorderInfo ? parameter : this.control.modelManager.model.repositoryBorderItem;
@@ -309,8 +311,11 @@ export class ToggleSingleTableCellsBorderCommand extends ToggleTableCellsBorderC
     }
 }
 export class ToggleTableCellsTopBorderCommand extends ToggleSingleTableCellsBorderCommand {
-    affectOnStateFlags = TableBorderGridCellInfo.TopOuter;
-    affectInner = false;
+    constructor() {
+        super(...arguments);
+        this.affectOnStateFlags = TableBorderGridCellInfo.TopOuter;
+        this.affectInner = false;
+    }
     getActualCellBorder(table, grid, currentCell, rowIndex, columnIndex, tableBordersInfo) {
         return this.getActualTopBorder(grid, currentCell, tableBordersInfo, table, rowIndex, columnIndex);
     }
@@ -347,8 +352,11 @@ export class ToggleTableCellsTopBorderCommand extends ToggleSingleTableCellsBord
     }
 }
 export class ToggleTableCellsRightBorderCommand extends ToggleSingleTableCellsBorderCommand {
-    affectInner = false;
-    affectOnStateFlags = TableBorderGridCellInfo.RightOuter;
+    constructor() {
+        super(...arguments);
+        this.affectInner = false;
+        this.affectOnStateFlags = TableBorderGridCellInfo.RightOuter;
+    }
     getActualCellBorder(table, _grid, _currentCell, rowIndex, columnIndex, tableBordersInfo) {
         return this.getActualRightBorder(tableBordersInfo, table, rowIndex, columnIndex);
     }
@@ -385,8 +393,11 @@ export class ToggleTableCellsRightBorderCommand extends ToggleSingleTableCellsBo
     }
 }
 export class ToggleTableCellsBottomBorderCommand extends ToggleSingleTableCellsBorderCommand {
-    affectInner = false;
-    affectOnStateFlags = TableBorderGridCellInfo.BottomOuter;
+    constructor() {
+        super(...arguments);
+        this.affectInner = false;
+        this.affectOnStateFlags = TableBorderGridCellInfo.BottomOuter;
+    }
     getActualCellBorder(table, grid, currentCell, rowIndex, columnIndex, tableBordersInfo) {
         return this.getActualBottomBorder(grid, currentCell, tableBordersInfo, table, rowIndex, columnIndex);
     }
@@ -423,8 +434,11 @@ export class ToggleTableCellsBottomBorderCommand extends ToggleSingleTableCellsB
     }
 }
 export class ToggleTableCellsLeftBorderCommand extends ToggleSingleTableCellsBorderCommand {
-    affectInner = false;
-    affectOnStateFlags = TableBorderGridCellInfo.LeftOuter;
+    constructor() {
+        super(...arguments);
+        this.affectInner = false;
+        this.affectOnStateFlags = TableBorderGridCellInfo.LeftOuter;
+    }
     getActualCellBorder(table, _grid, _currentCell, rowIndex, columnIndex, tableBordersInfo) {
         return this.getActualLeftBorder(tableBordersInfo, table, rowIndex, columnIndex);
     }
@@ -461,9 +475,12 @@ export class ToggleTableCellsLeftBorderCommand extends ToggleSingleTableCellsBor
     }
 }
 export class ToggleTableCellAllBordersCommand extends ToggleTableCellsBorderCommandBase {
-    affectOnStateFlags = TableBorderGridCellInfo.BottomInner | TableBorderGridCellInfo.BottomOuter | TableBorderGridCellInfo.LeftInner |
-        TableBorderGridCellInfo.LeftOuter | TableBorderGridCellInfo.RightInner | TableBorderGridCellInfo.RightOuter |
-        TableBorderGridCellInfo.TopInner | TableBorderGridCellInfo.TopOuter;
+    constructor() {
+        super(...arguments);
+        this.affectOnStateFlags = TableBorderGridCellInfo.BottomInner | TableBorderGridCellInfo.BottomOuter | TableBorderGridCellInfo.LeftInner |
+            TableBorderGridCellInfo.LeftOuter | TableBorderGridCellInfo.RightInner | TableBorderGridCellInfo.RightOuter |
+            TableBorderGridCellInfo.TopInner | TableBorderGridCellInfo.TopOuter;
+    }
     checkBorderInParticallyTableSelection(patternBorder, table, grid, currentCell, rowIndex, columnIndex, tableBordersInfo) {
         return patternBorder.equals(this.getActualTopBorder(grid, currentCell, tableBordersInfo, table, rowIndex, columnIndex)) &&
             patternBorder.equals(this.getActualBottomBorder(grid, currentCell, tableBordersInfo, table, rowIndex, columnIndex)) &&
@@ -512,9 +529,12 @@ export class ToggleTableCellNoBorderCommand extends ToggleTableCellAllBordersCom
     }
 }
 export class ToggleTableCellInsideBordersCommand extends ToggleTableCellsBorderCommandBase {
-    affectOuter = false;
-    affectNeighbours = false;
-    affectOnStateFlags = TableBorderGridCellInfo.BottomInner | TableBorderGridCellInfo.LeftInner | TableBorderGridCellInfo.RightInner | TableBorderGridCellInfo.TopInner;
+    constructor() {
+        super(...arguments);
+        this.affectOuter = false;
+        this.affectNeighbours = false;
+        this.affectOnStateFlags = TableBorderGridCellInfo.BottomInner | TableBorderGridCellInfo.LeftInner | TableBorderGridCellInfo.RightInner | TableBorderGridCellInfo.TopInner;
+    }
     checkBorderInParticallyTableSelection(patternBorder, table, grid, currentCell, rowIndex, columnIndex, tableBordersInfo) {
         if (currentCell.info & TableBorderGridCellInfo.TopInner)
             return patternBorder.equals(this.getActualTopBorder(grid, currentCell, tableBordersInfo, table, rowIndex, columnIndex));
@@ -552,9 +572,12 @@ export class ToggleTableCellInsideBordersCommand extends ToggleTableCellsBorderC
     }
 }
 export class ToggleTableCellInsideHorizontalBordersCommand extends ToggleSingleTableCellsBorderCommand {
-    affectOuter = false;
-    affectNeighbours = false;
-    affectOnStateFlags = TableBorderGridCellInfo.BottomInner | TableBorderGridCellInfo.TopInner;
+    constructor() {
+        super(...arguments);
+        this.affectOuter = false;
+        this.affectNeighbours = false;
+        this.affectOnStateFlags = TableBorderGridCellInfo.BottomInner | TableBorderGridCellInfo.TopInner;
+    }
     getActualCellBorder(table, grid, currentCell, rowIndex, columnIndex, tableBordersInfo) {
         let border1, border2;
         if (currentCell.info & TableBorderGridCellInfo.TopInner)
@@ -590,9 +613,12 @@ export class ToggleTableCellInsideHorizontalBordersCommand extends ToggleSingleT
     }
 }
 export class ToggleTableCellInsideVerticalBordersCommand extends ToggleSingleTableCellsBorderCommand {
-    affectOuter = false;
-    affectNeighbours = false;
-    affectOnStateFlags = TableBorderGridCellInfo.LeftInner | TableBorderGridCellInfo.RightInner;
+    constructor() {
+        super(...arguments);
+        this.affectOuter = false;
+        this.affectNeighbours = false;
+        this.affectOnStateFlags = TableBorderGridCellInfo.LeftInner | TableBorderGridCellInfo.RightInner;
+    }
     getActualCellBorder(table, _grid, currentCell, rowIndex, columnIndex, tableBordersInfo) {
         let border1, border2;
         if (currentCell.info & TableBorderGridCellInfo.LeftInner)
@@ -628,8 +654,11 @@ export class ToggleTableCellInsideVerticalBordersCommand extends ToggleSingleTab
     }
 }
 export class ToggleTableCellOutsideBordersCommand extends ToggleTableCellsBorderCommandBase {
-    affectInner = false;
-    affectOnStateFlags = TableBorderGridCellInfo.LeftOuter | TableBorderGridCellInfo.RightOuter | TableBorderGridCellInfo.TopOuter | TableBorderGridCellInfo.BottomOuter;
+    constructor() {
+        super(...arguments);
+        this.affectInner = false;
+        this.affectOnStateFlags = TableBorderGridCellInfo.LeftOuter | TableBorderGridCellInfo.RightOuter | TableBorderGridCellInfo.TopOuter | TableBorderGridCellInfo.BottomOuter;
+    }
     checkBorderInParticallyTableSelection(patternBorder, table, grid, currentCell, rowIndex, columnIndex, tableBordersInfo) {
         if (currentCell.info & TableBorderGridCellInfo.TopOuter && !patternBorder.equals(this.getActualTopBorder(grid, currentCell, tableBordersInfo, table, rowIndex, columnIndex)))
             return false;