devexpress-richedit 25.2.3 → 25.2.5

package/lib/common/commands/fields/update-field-command.js

@@ -8,11 +8,8 @@ import { SimpleCommandState } from '../command-states';
 import { FieldCommandHelper } from './field-command-helper';
 import { UpdateFieldCommandBase } from './update-field-command-base';
 export class UpdateFieldCommandParameters {
-    callbackFunc;
-    subDocument;
-    intervals;
-    options = new UpdateFieldsOptions();
     constructor(subDocument, intervals, callbackFunc) {
+        this.options = new UpdateFieldsOptions();
         this.subDocument = subDocument;
         this.intervals = intervals;
         this.callbackFunc = callbackFunc;

package/lib/common/commands/find-replace/find-all-command.js

@@ -3,10 +3,6 @@ import { SelectionHistoryItem } from '../../model/history/selection/selection-hi
 import { CommandBase, CommandOptions } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class FindAllCommandOptions extends CommandOptions {
-    text;
-    matchCase;
-    highlightResults;
-    results;
     constructor(control, text, matchCase, highlightResults, results) {
         super(control);
         this.text = text;

package/lib/common/commands/find-replace/replace-all-command.js

@@ -3,9 +3,6 @@ import { SelectionHistoryItem } from '../../model/history/selection/selection-hi
 import { CommandBase, CommandOptions } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class ReplaceAllCommandOptions extends CommandOptions {
-    text;
-    replaceText;
-    matchCase;
     constructor(control, text, replaceText, matchCase) {
         super(control);
         this.text = text;

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

@@ -17,12 +17,6 @@ import { SimpleCommandState } from '../command-states';
 import { ChangeActiveSubDocumentToHeaderFooterByPageIndexCommandParameters } from '../sub-document/change-active-sub-document-command';
 import { SwitchTextBoxSubDocumentsStateHistoryItem } from '../../model/history/items/switch-text-box-sub-documents-state-history-item';
 export class FloatingObjectMovedArgumentInner {
-    subDocumentId;
-    newPosition;
-    pageIntervals;
-    pageIndex;
-    objectX;
-    objectY;
     constructor(subDocumentId, newPosition, pageIntervals, pageIndex, objectX, objectY) {
         this.newPosition = newPosition;
         this.subDocumentId = subDocumentId;
@@ -35,7 +29,6 @@ export class FloatingObjectMovedArgumentInner {
     }
 }
 export class FloatingObjectDragDropChangePositionCommand extends CommandBase {
-    rangeCopy;
     get activeSubDocument() {
         return this.selection.activeSubDocument;
     }
@@ -245,10 +238,6 @@ export class FloatingObjectDragDropChangePositionCommand extends CommandBase {
     }
 }
 export class FloatingObjectDragDropChangePositionCommandParameters extends CommandOptions {
-    startPageIndex;
-    endPageIndex;
-    finalPoint;
-    finalClickPoint;
     constructor(control, startPageIndex, endPageIndex, finalPoint, finalClickPoint) {
         super(control);
         this.startPageIndex = startPageIndex;

package/lib/common/commands/floating-objects/set-floating-object-alignment-command.js

@@ -7,10 +7,11 @@ import { RichEditClientCommand } from '../client-command';
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class SetFloatingObjectAlignmentCommandBase extends CommandBase {
-    anchorObjectHorizontalAlignment;
-    anchorObjectVerticalAlignment;
-    anchorObjectHorizontalPositionType = AnchorObjectHorizontalPositionType.Margin;
-    anchorObjectVerticalPositionType = AnchorObjectVerticalPositionType.Margin;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalPositionType = AnchorObjectHorizontalPositionType.Margin;
+        this.anchorObjectVerticalPositionType = AnchorObjectVerticalPositionType.Margin;
+    }
     getRelatedCommands() {
         return {
             [RichEditClientCommand.SetFloatingObjectTopLeftAlignment]: true,
@@ -67,38 +68,65 @@ export class SetFloatingObjectAlignmentCommandBase extends CommandBase {
     }
 }
 export class SetFloatingObjectTopLeftAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Left;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Top;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Left;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Top;
+    }
 }
 export class SetFloatingObjectTopCenterAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Center;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Top;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Center;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Top;
+    }
 }
 export class SetFloatingObjectTopRightAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Right;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Top;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Right;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Top;
+    }
 }
 export class SetFloatingObjectMiddleLeftAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Left;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Center;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Left;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Center;
+    }
 }
 export class SetFloatingObjectMiddleCenterAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Center;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Center;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Center;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Center;
+    }
 }
 export class SetFloatingObjectMiddleRightAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Right;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Center;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Right;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Center;
+    }
 }
 export class SetFloatingObjectBottomLeftAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Left;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Bottom;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Left;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Bottom;
+    }
 }
 export class SetFloatingObjectBottomCenterAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Center;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Bottom;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Center;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Bottom;
+    }
 }
 export class SetFloatingObjectBottomRightAlignmentCommand extends SetFloatingObjectAlignmentCommandBase {
-    anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Right;
-    anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Bottom;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectHorizontalAlignment = AnchorObjectHorizontalPositionAlignment.Right;
+        this.anchorObjectVerticalAlignment = AnchorObjectVerticalPositionAlignment.Bottom;
+    }
 }

package/lib/common/commands/floating-objects/set-floating-object-text-wrap-type-command.js

@@ -5,8 +5,10 @@ import { RichEditClientCommand } from '../client-command';
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class SetFloatingObjectTextWrapTypeCommandBase extends CommandBase {
-    anchorObjectTextWrapType;
-    isBehindDoc = false;
+    constructor() {
+        super(...arguments);
+        this.isBehindDoc = false;
+    }
     getRelatedCommands() {
         return {
             [RichEditClientCommand.SetFloatingObjectSquareTextWrapType]: true,
@@ -52,23 +54,41 @@ export class SetFloatingObjectTextWrapTypeCommandBase extends CommandBase {
     }
 }
 export class SetFloatingObjectSquareTextWrapTypeCommand extends SetFloatingObjectTextWrapTypeCommandBase {
-    anchorObjectTextWrapType = AnchorObjectTextWrapType.Square;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectTextWrapType = AnchorObjectTextWrapType.Square;
+    }
 }
 export class SetFloatingObjectTightTextWrapTypeCommand extends SetFloatingObjectTextWrapTypeCommandBase {
-    anchorObjectTextWrapType = AnchorObjectTextWrapType.Tight;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectTextWrapType = AnchorObjectTextWrapType.Tight;
+    }
 }
 export class SetFloatingObjectThroughTextWrapTypeCommand extends SetFloatingObjectTextWrapTypeCommandBase {
-    anchorObjectTextWrapType = AnchorObjectTextWrapType.Through;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectTextWrapType = AnchorObjectTextWrapType.Through;
+    }
 }
 export class SetFloatingObjectTopAndBottomTextWrapTypeCommand extends SetFloatingObjectTextWrapTypeCommandBase {
-    anchorObjectTextWrapType = AnchorObjectTextWrapType.TopAndBottom;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectTextWrapType = AnchorObjectTextWrapType.TopAndBottom;
+    }
 }
 export class SetFloatingObjectInFrontOfTextWrapTypeCommand extends SetFloatingObjectTextWrapTypeCommandBase {
-    anchorObjectTextWrapType = AnchorObjectTextWrapType.None;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectTextWrapType = AnchorObjectTextWrapType.None;
+    }
 }
 export class SetFloatingObjectBehindTextWrapTypeCommand extends SetFloatingObjectTextWrapTypeCommandBase {
-    anchorObjectTextWrapType = AnchorObjectTextWrapType.None;
-    isBehindDoc = true;
+    constructor() {
+        super(...arguments);
+        this.anchorObjectTextWrapType = AnchorObjectTextWrapType.None;
+        this.isBehindDoc = true;
+    }
 }
 export class SetFloatingObjectInlineTextWrapTypeCommand extends SetFloatingObjectTextWrapTypeCommandBase {
     getStateValue() {

package/lib/common/commands/header-footer/link-header-footer-commands.js

@@ -10,7 +10,6 @@ import { RichEditClientCommand } from '../client-command';
 import { ChangeActiveSubDocumentToHeaderFooterByPageIndexCommandParameters } from '../sub-document/change-active-sub-document-command';
 import { HeaderFooterCommandBase } from './header-footer-command-base';
 export class LinkHeaderFooterToPreviousCommand extends HeaderFooterCommandBase {
-    isHeader;
     isEnabled() {
         if (!super.isEnabled())
             return false;

package/lib/common/commands/numbering/insert-numeration-to-paragraphs-command.js

@@ -3,7 +3,6 @@ import { ListUtils } from '@devexpress/utils/lib/utils/list';
 import { IntervalCommandStateEx } from '../command-states';
 import { NumberingListCommandBaseBase } from './numbering-list-command-base';
 export class InsertNumerationToParagraphsCommand extends NumberingListCommandBaseBase {
-    abstractNumberingList;
     getState(options = this.convertToCommandOptions(undefined)) {
         return new IntervalCommandStateEx(this.isEnabled(), ListUtils.deepCopy(options.intervalsInfo.intervals));
     }

package/lib/common/commands/ruler/ruler-paragraph-indents-command.js

@@ -6,8 +6,6 @@ import { UnitConverter } from '@devexpress/utils/lib/class/unit-converter';
 import { CommandBase, CommandOptions } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class RulerParagraphLeftIndentsCommandValue extends CommandOptions {
-    hanging;
-    firstLine;
     constructor(control, hanging, firstLine) {
         super(control);
         this.hanging = hanging;

package/lib/common/commands/ruler/ruler-table-column-separators-command.js

@@ -10,13 +10,6 @@ import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 import { RulerValue } from '../../ui/ruler/controls/zoomable-value';
 export class TableColumnSeparatorStruct {
-    zoomLevelHolder;
-    index = 0;
-    tableIndex = 0;
-    cellSpacing = 0;
-    minValue = -1;
-    maxValue = -1;
-    items = [];
     get currItem() {
         return this.items[this.index];
     }
@@ -25,6 +18,12 @@ export class TableColumnSeparatorStruct {
     }
     constructor(zoomLevelHolder) {
         this.zoomLevelHolder = zoomLevelHolder;
+        this.index = 0;
+        this.tableIndex = 0;
+        this.cellSpacing = 0;
+        this.minValue = -1;
+        this.maxValue = -1;
+        this.items = [];
     }
     createItem(position, marginLeft, marginRight) {
         this.items.push(new TableColumnSeparatorItem(position, marginLeft, marginRight, this.zoomLevelHolder));
@@ -40,16 +39,12 @@ export class TableColumnSeparatorStruct {
     }
 }
 export class TableColumnSeparatorItem {
-    zoomLevelHolder;
-    zoomablePosition;
     get position() { return this.zoomablePosition.value; }
     ;
     get originalPosition() { return this.zoomablePosition.originalValue; }
     ;
     set position(value) { this.zoomablePosition.value = value; }
     ;
-    leftMargin;
-    rightMargin;
     constructor(position, leftMargin, rightMargin, zoomLevelHolder) {
         this.zoomLevelHolder = zoomLevelHolder;
         this.zoomablePosition = new RulerValue(position, this.zoomLevelHolder);

package/lib/common/commands/ruler/ruler-table-commands.js

@@ -12,9 +12,6 @@ import { ResizeColumnTableHelper } from '../../mouse-handler/resize-table-helper
 import { CommandBase } from '../command-base';
 import { SimpleCommandState } from '../command-states';
 export class RulerChangeTableSizeCommandParametersBase {
-    modelTableIndex;
-    offset;
-    layoutTable;
     constructor(modelTableIndex, offset, layoutTable) {
         this.modelTableIndex = modelTableIndex;
         this.offset = offset;
@@ -22,15 +19,12 @@ export class RulerChangeTableSizeCommandParametersBase {
     }
 }
 export class RulerChangeTableRowHeightCommandParameters extends RulerChangeTableSizeCommandParametersBase {
-    layoutRowIndex;
     constructor(modelTableIndex, offset, layoutTable, layoutRowIndex) {
         super(modelTableIndex, offset, layoutTable);
         this.layoutRowIndex = layoutRowIndex;
     }
 }
 export class RulerChangeTableColumnWidthCommandParameters extends RulerChangeTableSizeCommandParametersBase {
-    oldBorderPosition;
-    callFromRuler;
     constructor(modelTableIndex, offset, layoutTable, oldBorderPosition, callFromRuler) {
         super(modelTableIndex, offset, layoutTable);
         this.oldBorderPosition = oldBorderPosition;
@@ -132,8 +126,6 @@ export class RulerChangeTableColumnWidthCommand extends RulerChangeTableSizeComm
     }
 }
 class NewTableSizes {
-    newColumnsXPositions;
-    tableIndentOffset;
     constructor(newColumnsXPositions, tableIndentOffset) {
         this.newColumnsXPositions = newColumnsXPositions;
         this.tableIndentOffset = tableIndentOffset;

package/lib/common/commands/selection/go-to-line-end-command.js

@@ -2,7 +2,6 @@ import { LayoutPositionCreatorConflictFlags, LayoutPositionMainSubDocumentCreato
 import { DocumentLayoutDetailsLevel } from '../../layout/document-layout-details-level';
 import { SelectionCommandBase } from './selection-command-base';
 export class GoToLineEndCommandBase extends SelectionCommandBase {
-    endOfLine;
     executeCore(_state, _options) {
         var endSelection = this.getEndPosition();
         if (endSelection < 0)

package/lib/common/commands/selection/go-to-next-page-command.d.ts

@@ -1,15 +1,12 @@
-import { ICommandState } from '../i-command';
-import { SelectionCommandBase } from './selection-command-base';
-export declare abstract class GoToNextPageCommandBase extends SelectionCommandBase {
-    getPosition(): number;
-    abstract extendSelection(): boolean;
-    isEnabled(): boolean;
+import { LayoutPosition } from '../../layout/layout-position';
+import { GoToPageCommandBase } from './go-to-page-command-base';
+export declare abstract class GoToNextPageCommandBase extends GoToPageCommandBase {
+    goToPage(layoutPosition: LayoutPosition, x: number, y: number): void;
+    private getPosition;
 }
 export declare class GoToNextPageCommand extends GoToNextPageCommandBase {
-    executeCore(_state: ICommandState, _parameter: any): boolean;
     extendSelection(): boolean;
 }
 export declare class ExtendGoToNextPageCommand extends GoToNextPageCommandBase {
-    executeCore(_state: ICommandState, _parameter: any): boolean;
     extendSelection(): boolean;
 }

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

@@ -1,63 +1,39 @@
-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 GoToNextPageCommandBase 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.Character)
-            .create(new LayoutPositionCreatorConflictFlags().setDefault(selection.endOfLine), new LayoutPositionCreatorConflictFlags().setDefault(false));
-        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 { MixedSize } from '../../../common/utils/mixed-size';
+import { GoToPageCommandBase } from './go-to-page-command-base';
+export class GoToNextPageCommandBase 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 viewportBottom = MixedSize.fromUI(this.control.viewManager.canvas.scrollTop).useScale(this.scale).addSize(viewportHeight);
         let page = layoutPosition.page;
-        const absoluteY = newY + page.y;
-        do {
-            if (absoluteY < page.bottom) {
-                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();
-                const position = htr.getPosition();
-                if (position !== initPosition)
-                    return position;
-            }
-            const siblingPageIndex = layoutPosition.pageIndex + 1;
-            page = this.control.layoutFormatterManager.forceFormatPage(siblingPageIndex);
-        } while (page);
-        return this.selection.activeSubDocument.getDocumentEndPosition() - 1;
+        const pageIndex = this.findPageIndexByOffsetY(viewportBottom.LayoutSize);
+        this.scrollToPosition(pageIndex, viewportBottom.LayoutSize);
+        const newY = MixedSize.add(MixedSize.fromLayout(y).useScale(this.scale), viewportHeight);
+        const position = this.getPosition(page, MixedSize.fromLayout(x).useScale(this.scale), newY, viewportBottom, 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 newAbsoluteY = MixedSize.max(y.addLayoutSize(currentPageY), viewportTop);
+        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 viewportBottom = MixedSize.add(viewportTop, viewportHeight);
+        const position = this.tryFindVisiblePosition(x.LayoutSize, newAbsoluteY.LayoutSize, viewportBottom.LayoutSize);
+        if (position !== null)
+            return position;
+        return htr.getPosition();
     }
 }
 export class GoToNextPageCommand extends GoToNextPageCommandBase {
-    executeCore(_state, _parameter) {
-        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 ExtendGoToNextPageCommand extends GoToNextPageCommandBase {
-    executeCore(_state, _parameter) {
-        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/go-to-page-command-base.d.ts

@@ -0,0 +1,18 @@
+import { HitTestResult } from "../../../common/layout-engine/hit-test-manager/hit-test-result";
+import { SelectionCommandBase } from "./selection-command-base";
+import { LayoutPosition } from "../../../common/layout/layout-position";
+import { ICommandOptions } from "../command-base";
+import { ICommandState } from "../i-command";
+export declare abstract class GoToPageCommandBase extends SelectionCommandBase {
+    protected get scale(): number;
+    executeCore(_state: ICommandState, _options: ICommandOptions): boolean;
+    protected getPageOffsetY(pageIndex: number): number;
+    protected findPageIndexByOffsetY(offsetY: number): number;
+    protected tryFindVisiblePosition(x: number, top: number, bottom: number): number | null;
+    protected calculateHitTestResult(pageIndex: number, x: number, y: number): HitTestResult;
+    protected changeSelection(position: number): void;
+    protected scrollToPosition(pageIndex: number, offsetY: number): void;
+    isEnabled(): boolean;
+    protected abstract goToPage(layoutPosition: LayoutPosition, x: number, y: number): void;
+    protected abstract extendSelection(): boolean;
+}

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

@@ -0,0 +1,91 @@
+import { DocumentLayoutDetailsLevel } from "../../../common/layout/document-layout-details-level";
+import { LayoutPoint } from "../../../common/layout/layout-point";
+import { SetSelectionStateOptions } from "../../../common/selection/selection";
+import { SelectionCommandBase } from "./selection-command-base";
+import { ScrollTopInfo } from "../../../common/canvas/canvas-manager";
+import { ScrollState } from "../../../common/scroll/model-states";
+import { LayoutPositionMainSubDocumentCreator, LayoutPositionCreatorConflictFlags } from "../../../common/layout-engine/layout-position-creator";
+import { FixedInterval } from "@devexpress/utils/lib/intervals/fixed";
+export class GoToPageCommandBase extends SelectionCommandBase {
+    get scale() {
+        return this.control.viewManager.zoomLevel;
+    }
+    executeCore(_state, _options) {
+        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 false;
+        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;
+        this.goToPage(layoutPosition, x, y);
+        return true;
+    }
+    getPageOffsetY(pageIndex) {
+        const page = this.control.layout.pages[pageIndex];
+        return this.control.viewManager.sizes.getPageOffsetY(page);
+    }
+    findPageIndexByOffsetY(offsetY) {
+        return this.control.layout.findPageIndexByOffsetY(offsetY, this.control.viewManager.sizes);
+    }
+    tryFindVisiblePosition(x, top, bottom) {
+        let prevResult;
+        while (true) {
+            const mid = (top + bottom) / 2;
+            const pageIndex = this.findPageIndexByOffsetY(mid);
+            const pageY = this.getPageOffsetY(pageIndex);
+            const htr = this.calculateHitTestResult(pageIndex, x, mid - pageY);
+            const rowHeight = htr.row.height;
+            if (bottom - top < rowHeight)
+                break;
+            const halfOfRowHeight = rowHeight / 2;
+            const y = htr.getLayoutY() + this.getPageOffsetY(htr.page.index) + halfOfRowHeight;
+            if (htr.detailsLevel >= DocumentLayoutDetailsLevel.Row && y > top && y < bottom) {
+                if (prevResult?.getPosition() === htr.getPosition())
+                    return htr.getPosition();
+                prevResult = htr;
+            }
+            if (y < mid)
+                top = mid;
+            else
+                bottom = mid;
+        }
+        return prevResult ? prevResult.getPosition() : null;
+    }
+    calculateHitTestResult(pageIndex, x, y) {
+        const point = new LayoutPoint(pageIndex, x, y);
+        const htr = this.control.hitTestManager.calculate(point, DocumentLayoutDetailsLevel.Character, this.selection.activeSubDocument);
+        if (!this.extendSelection())
+            htr.correctAsVisibleBox();
+        return htr;
+    }
+    changeSelection(position) {
+        const selection = this.selection;
+        if (this.extendSelection())
+            selection.changeState((newState) => newState.extendLastInterval(position));
+        else {
+            const options = new SetSelectionStateOptions();
+            options.useFieldUiChecks = true;
+            options.correctIntervalDueToTables = true;
+            options.correctIntervalDueToFields = true;
+            selection.changeState((newState) => {
+                newState.setInterval(new FixedInterval(position, 0))
+                    .setKeepX(selection.keepX)
+                    .setEndOfLine(selection.endOfLine)
+                    .setForwardDirection(true);
+            }, options);
+        }
+    }
+    scrollToPosition(pageIndex, offsetY) {
+        const page = this.control.layout.pages[pageIndex];
+        const pageY = this.control.viewManager.sizes.getPageOffsetY(page);
+        const scrollInfo = new ScrollTopInfo(pageIndex, offsetY - pageY);
+        const state = new ScrollState().byScrollInfo.setPageInfo(scrollInfo);
+        this.control.scrollManager.setScroll(state);
+    }
+    isEnabled() {
+        return super.isEnabled() && this.selection.activeSubDocument.isMain();
+    }
+}

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

@@ -1,16 +1,12 @@
-import { ICommandOptions } from '../command-base';
-import { ICommandState } from '../i-command';
-import { SelectionCommandBase } from './selection-command-base';
-export declare abstract class GoToPrevPageCommandBase extends SelectionCommandBase {
-    getPosition(): number;
-    abstract extendSelection(): boolean;
-    isEnabled(): boolean;
+import { LayoutPosition } from '../../layout/layout-position';
+import { GoToPageCommandBase } from './go-to-page-command-base';
+export declare abstract class GoToPrevPageCommandBase extends GoToPageCommandBase {
+    goToPage(layoutPosition: LayoutPosition, x: number, y: number): void;
+    private getPosition;
 }
 export declare class GoToPrevPageCommand extends GoToPrevPageCommandBase {
-    executeCore(_state: ICommandState, _options: ICommandOptions): boolean;
     extendSelection(): boolean;
 }
 export declare class ExtendGoToPrevPageCommand extends GoToPrevPageCommandBase {
-    executeCore(_state: ICommandState, _options: ICommandOptions): boolean;
     extendSelection(): boolean;
 }