@eclipse-glsp/client 2.4.0-next.409 → 2.4.0-next.413

package/src/features/accessibility/element-navigation/diagram-navigation-tool.ts

@@ -18,9 +18,7 @@ import {
     Action,
     GModelElement,
     GModelRoot,
-    IActionDispatcher,
     KeyListener,
-    KeyTool,
     SelectAction,
     Selectable,
     TYPES,
@@ -32,40 +30,41 @@ import {
     toArray
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { EnableDefaultToolsAction, EnableToolsAction, Tool } from '../../../base/tool-manager/tool';
+import { AvailableShortcutsTool } from '../../../base/shortcuts/available-shortcuts-tool';
+import type { IShortcutManager } from '../../../base/shortcuts/shortcuts-manager';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../../base/tool-manager/tool';
 import { GEdge } from '../../../model';
 import { SelectableBoundsAware } from '../../../utils/gmodel-util';
+import { BaseTool } from '../../tools/base-tools';
 import { RepositionAction } from '../../viewport/reposition';
-import { SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
-import { AccessibleKeyShortcutTool } from '../key-shortcut/accessible-key-shortcut-tool';
 import { SearchAutocompletePaletteTool } from '../search/search-tool';
 import * as messages from '../toast/messages.json';
 import { ShowToastMessageAction } from '../toast/toast-handler';
 import { ElementNavigator } from './element-navigator';
 
 @injectable()
-export class ElementNavigatorTool implements Tool {
+export class ElementNavigatorTool extends BaseTool {
     static ID = 'glsp.diagram-navigation';
+    static TOKEN = Symbol.for(ElementNavigatorTool.ID);
 
-    isEditTool = false;
+    get id(): string {
+        return ElementNavigatorTool.ID;
+    }
 
-    protected elementNavigatorKeyListener: ElementNavigatorKeyListener = new ElementNavigatorKeyListener(this);
-    @inject(KeyTool) protected readonly keytool: KeyTool;
+    @inject(TYPES.IShortcutManager) protected readonly shortcutManager: IShortcutManager;
     @inject(TYPES.IElementNavigator) readonly elementNavigator: ElementNavigator;
     @inject(TYPES.ILocalElementNavigator) readonly localElementNavigator: ElementNavigator;
-    @inject(TYPES.IActionDispatcher) readonly actionDispatcher: IActionDispatcher;
 
-    get id(): string {
-        return ElementNavigatorTool.ID;
-    }
+    protected elementNavigatorKeyListener: ElementNavigatorKeyListener = new ElementNavigatorKeyListener(this);
 
     enable(): void {
-        this.keytool.register(this.elementNavigatorKeyListener);
-        this.elementNavigatorKeyListener.registerShortcutKey();
-    }
-
-    disable(): void {
-        this.keytool.deregister(this.elementNavigatorKeyListener);
+        this.toDisposeOnDisable.push(
+            this.keyTool.registerListener(this.elementNavigatorKeyListener),
+            this.shortcutManager.register(ElementNavigatorTool.TOKEN, [
+                { shortcuts: ['ALT', 'N'], description: 'Activate local navigation mode', group: 'Navigation', position: 0 },
+                { shortcuts: ['N'], description: 'Activate global navigation mode', group: 'Navigation', position: 1 }
+            ])
+        );
     }
 }
 
@@ -85,29 +84,6 @@ export class ElementNavigatorKeyListener extends KeyListener {
         super();
     }
 
-    registerShortcutKey(): void {
-        this.tool.actionDispatcher.dispatchOnceModelInitialized(
-            SetAccessibleKeyShortcutAction.create({
-                token: this.token,
-                keys: [
-                    { shortcuts: ['N'], description: 'Activate default navigation', group: 'Navigation', position: 0 },
-                    {
-                        shortcuts: ['ALT', 'N'],
-                        description: 'Activate position based navigation',
-                        group: 'Navigation',
-                        position: 1
-                    },
-                    {
-                        shortcuts: ['⬅  ⬆  ➡  ⬇'],
-                        description: 'Navigate by relation or neighbors according to navigation mode',
-                        group: 'Navigation',
-                        position: 2
-                    }
-                ]
-            })
-        );
-    }
-
     override keyDown(element: GModelElement, event: KeyboardEvent): Action[] {
         this.resetOnEscape(event, element);
 
@@ -130,7 +106,7 @@ export class ElementNavigatorKeyListener extends KeyListener {
             this.clean();
 
             if (this.mode === NavigationMode.POSITION) {
-                this.tool.actionDispatcher.dispatchAll([
+                this.tool.dispatchActions([
                     EnableDefaultToolsAction.create(),
                     ShowToastMessageAction.createWithTimeout({
                         id: Symbol.for(ElementNavigatorKeyListener.name),
@@ -138,7 +114,7 @@ export class ElementNavigatorKeyListener extends KeyListener {
                     })
                 ]);
             } else if (this.mode === NavigationMode.DEFAULT) {
-                this.tool.actionDispatcher.dispatchAll([
+                this.tool.dispatchActions([
                     EnableDefaultToolsAction.create(),
                     ShowToastMessageAction.createWithTimeout({
                         id: Symbol.for(ElementNavigatorKeyListener.name),
@@ -155,8 +131,8 @@ export class ElementNavigatorKeyListener extends KeyListener {
         if (this.matchesActivatePositionNavigation(event)) {
             if (this.mode !== NavigationMode.POSITION) {
                 this.clean();
-                this.tool.actionDispatcher.dispatchAll([
-                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AccessibleKeyShortcutTool.ID]),
+                this.tool.dispatchActions([
+                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AvailableShortcutsTool.ID]),
                     ShowToastMessageAction.create({
                         id: Symbol.for(ElementNavigatorKeyListener.name),
                         message: messages.navigation.local_navigation_mode_activated
@@ -179,7 +155,7 @@ export class ElementNavigatorKeyListener extends KeyListener {
             this.navigator?.clean?.(element.root);
             this.clean();
             this.mode = NavigationMode.NONE;
-            this.tool.actionDispatcher.dispatchAll([
+            this.tool.dispatchActions([
                 EnableDefaultToolsAction.create(),
                 ShowToastMessageAction.createWithTimeout({
                     id: Symbol.for(ElementNavigatorKeyListener.name),
@@ -193,8 +169,8 @@ export class ElementNavigatorKeyListener extends KeyListener {
             if (this.mode !== NavigationMode.DEFAULT) {
                 this.clean();
 
-                this.tool.actionDispatcher.dispatchAll([
-                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AccessibleKeyShortcutTool.ID]),
+                this.tool.dispatchActions([
+                    EnableToolsAction.create([ElementNavigatorTool.ID, SearchAutocompletePaletteTool.ID, AvailableShortcutsTool.ID]),
                     ShowToastMessageAction.create({
                         id: Symbol.for(ElementNavigatorKeyListener.name),
                         message: messages.navigation.default_navigation_mode_activated
@@ -216,7 +192,7 @@ export class ElementNavigatorKeyListener extends KeyListener {
             this.navigator?.clean?.(element.root);
             this.clean();
             this.mode = NavigationMode.NONE;
-            this.tool.actionDispatcher.dispatchAll([
+            this.tool.dispatchActions([
                 EnableDefaultToolsAction.create(),
                 ShowToastMessageAction.createWithTimeout({
                     id: Symbol.for(ElementNavigatorKeyListener.name),

package/src/features/accessibility/global-keylistener-tool.ts

@@ -13,25 +13,24 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, IActionDispatcher, matchesKeystroke, SetUIExtensionVisibilityAction, TYPES } from '@eclipse-glsp/sprotty';
+import { Action, matchesKeystroke, SetUIExtensionVisibilityAction, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { Tool } from '../../base/tool-manager/tool';
+import type { IShortcutManager } from '../../base/shortcuts/shortcuts-manager';
 import { KeyboardGridMetadata, KeyboardNodeGridMetadata } from '../accessibility/keyboard-grid/constants';
 import { ToolPalette } from '../tool-palette/tool-palette';
+import { BaseEditTool } from '../tools/base-tools';
 import { FocusDomAction } from './actions';
-import { AccessibleKeyShortcutProvider, SetAccessibleKeyShortcutAction } from './key-shortcut/accessible-key-shortcut';
 import { KeyboardPointerMetadata } from './keyboard-pointer/constants';
-import { KeyboardToolPalette } from './keyboard-tool-palette/keyboard-tool-palette';
 
 @injectable()
-export class GlobalKeyListenerTool implements Tool, AccessibleKeyShortcutProvider {
+export class GlobalKeyListenerTool extends BaseEditTool {
     static ID = 'glsp.global-key-listener';
+    static TOKEN = Symbol.for(GlobalKeyListenerTool.name);
 
-    isEditTool = false;
     protected alreadyRegistered = false;
 
-    @inject(TYPES.IActionDispatcher)
-    protected actionDispatcher: IActionDispatcher;
+    @inject(TYPES.IShortcutManager)
+    protected readonly shortcutManager: IShortcutManager;
 
     get id(): string {
         return GlobalKeyListenerTool.ID;
@@ -41,28 +40,12 @@ export class GlobalKeyListenerTool implements Tool, AccessibleKeyShortcutProvide
         if (!this.alreadyRegistered) {
             this.alreadyRegistered = true;
             document.addEventListener('keyup', this.trigger.bind(this));
-            this.registerShortcutKey();
-        }
-    }
 
-    disable(): void {
-        // It is not possible to remove the handlers after registration
-        // The handlers need to be available all the time to work correctly
-    }
-
-    registerShortcutKey(): void {
-        this.actionDispatcher.onceModelInitialized().then(() => {
-            this.actionDispatcher.dispatchAll([
-                SetAccessibleKeyShortcutAction.create({
-                    token: KeyboardToolPalette.name,
-                    keys: [{ shortcuts: ['ALT', 'P'], description: 'Focus on tool palette', group: 'Tool-Palette', position: 0 }]
-                }),
-                SetAccessibleKeyShortcutAction.create({
-                    token: 'Graph',
-                    keys: [{ shortcuts: ['ALT', 'G'], description: 'Focus on graph', group: 'Graph', position: 0 }]
-                })
+            this.shortcutManager.register(GlobalKeyListenerTool.TOKEN, [
+                { shortcuts: ['ALT', 'P'], description: 'Focus on tool palette', group: 'Tool-Palette', position: 0 },
+                { shortcuts: ['ALT', 'G'], description: 'Focus on graph', group: 'Graph', position: 0 }
             ]);
-        });
+        }
     }
 
     trigger(event: KeyboardEvent): void {

package/src/features/accessibility/search/search-tool.ts

@@ -14,58 +14,40 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import {
-    Action,
-    GModelElement,
-    IActionDispatcher,
-    KeyListener,
-    KeyTool,
-    matchesKeystroke,
-    SetUIExtensionVisibilityAction,
-    TYPES
-} from '@eclipse-glsp/sprotty';
+import { Action, GModelElement, KeyListener, matchesKeystroke, SetUIExtensionVisibilityAction, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { Tool } from '../../../base/tool-manager/tool';
-import { AccessibleKeyShortcutProvider, SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
+import type { IShortcutManager } from '../../../base/shortcuts/shortcuts-manager';
+import { BaseTool } from '../../tools/base-tools';
 import { SearchAutocompletePalette } from './search-palette';
+
 @injectable()
-export class SearchAutocompletePaletteTool implements Tool {
+export class SearchAutocompletePaletteTool extends BaseTool {
     static readonly ID = 'glsp.search-autocomplete-palette-tool';
+    static readonly TOKEN = Symbol.for(SearchAutocompletePaletteTool.ID);
 
     protected readonly keyListener = new SearchAutocompletePaletteKeyListener(this);
-    @inject(TYPES.IActionDispatcher) readonly actionDispatcher: IActionDispatcher;
-    @inject(KeyTool) protected keyTool: KeyTool;
+    @inject(TYPES.IShortcutManager)
+    protected readonly shortcutManager: IShortcutManager;
 
     get id(): string {
         return SearchAutocompletePaletteTool.ID;
     }
 
     enable(): void {
-        this.keyTool.register(this.keyListener);
-        this.keyListener.registerShortcutKey();
-    }
-
-    disable(): void {
-        this.keyTool.deregister(this.keyListener);
+        this.toDisposeOnDisable.push(
+            this.keyTool.registerListener(this.keyListener),
+            this.shortcutManager.register(SearchAutocompletePaletteTool.TOKEN, [
+                { shortcuts: ['CTRL', 'F'], description: 'Activate search for elements', group: 'Search', position: 0 }
+            ])
+        );
     }
 }
 
-export class SearchAutocompletePaletteKeyListener extends KeyListener implements AccessibleKeyShortcutProvider {
-    protected readonly token = SearchAutocompletePalette.name;
-
+export class SearchAutocompletePaletteKeyListener extends KeyListener {
     constructor(protected tool: SearchAutocompletePaletteTool) {
         super();
     }
 
-    registerShortcutKey(): void {
-        this.tool.actionDispatcher.dispatchOnceModelInitialized(
-            SetAccessibleKeyShortcutAction.create({
-                token: this.token,
-                keys: [{ shortcuts: ['CTRL', 'F'], description: 'Activate search for elements', group: 'Search', position: 0 }]
-            })
-        );
-    }
-
     override keyDown(element: GModelElement, event: KeyboardEvent): Action[] {
         if (this.matchesSearchActivateKeystroke(event)) {
             return [

package/src/features/accessibility/view-key-tools/{zoom-key-tool.ts → grid-cell-zoom-key-tool.ts}

@@ -19,9 +19,7 @@ import {
     CenterAction,
     GModelElement,
     GModelRoot,
-    IActionDispatcher,
     KeyListener,
-    KeyTool,
     Point,
     SetViewportAction,
     TYPES,
@@ -30,14 +28,13 @@ import {
     matchesKeystroke
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { EditorContextService } from '../../../base/editor-context-service';
 import { SelectionService } from '../../../base/selection-service';
-import { Tool } from '../../../base/tool-manager/tool';
+import type { IShortcutManager } from '../../../base/shortcuts/shortcuts-manager';
 import { getAbsolutePositionByPoint } from '../../../utils/viewpoint-util';
+import { BaseTool } from '../../tools/base-tools';
+import type { ZoomFactors } from '../../viewport/zoom-viewport-action';
 import { ElementNavigatorKeyListener } from '../element-navigation/diagram-navigation-tool';
-import { SetAccessibleKeyShortcutAction } from '../key-shortcut/accessible-key-shortcut';
 import { EnableKeyboardGridAction, KeyboardGridCellSelectedAction, KeyboardGridKeyboardEventAction } from '../keyboard-grid/action';
-import { ZoomElementAction, ZoomViewportAction } from '../move-zoom/zoom-handler';
 import * as messages from '../toast/messages.json';
 import { HideToastAction, ShowToastMessageAction } from '../toast/toast-handler';
 
@@ -45,48 +42,42 @@ import { HideToastAction, ShowToastMessageAction } from '../toast/toast-handler'
  * Zoom viewport and elements when its focused and arrow keys are hit.
  */
 @injectable()
-export class ZoomKeyTool implements Tool {
-    static ID = 'glsp.zoom-key-tool';
+export class GridCellZoomTool extends BaseTool {
+    static ID = 'glsp.accessibility-grid-cell-zoom-tool';
+    static TOKEN = Symbol.for(GridCellZoomTool.name);
 
-    isEditTool = false;
+    protected readonly zoomKeyListener = new GridZoomKeyListener(this);
 
-    protected readonly zoomKeyListener = new ZoomKeyListener(this);
-
-    @inject(KeyTool) protected readonly keytool: KeyTool;
-    @inject(TYPES.IActionDispatcher) readonly actionDispatcher: IActionDispatcher;
+    @inject(TYPES.IShortcutManager) protected readonly shortcutManager: IShortcutManager;
+    @inject(TYPES.ZoomFactors) protected readonly zoomFactors: ZoomFactors;
     @inject(SelectionService) selectionService: SelectionService;
-    @inject(EditorContextService)
-    protected editorContextService: EditorContextService;
 
     get id(): string {
-        return ZoomKeyTool.ID;
+        return GridCellZoomTool.ID;
     }
 
     enable(): void {
-        this.keytool.register(this.zoomKeyListener);
-        this.zoomKeyListener.registerShortcutKey();
-    }
-
-    disable(): void {
-        this.keytool.deregister(this.zoomKeyListener);
+        this.toDisposeOnDisable.push(
+            this.keyTool.registerListener(this.zoomKeyListener),
+            this.shortcutManager.register(GridCellZoomTool.TOKEN, [
+                { shortcuts: ['CTRL', '+'], description: 'Zoom in via Grid', group: 'Zoom', position: 0 }
+            ])
+        );
     }
 
     handle(action: Action): Action | void {
-        if (isViewport(this.editorContextService.modelRoot)) {
+        if (isViewport(this.editorContext.modelRoot)) {
             let viewportAction: Action | undefined = undefined;
 
-            if (KeyboardGridCellSelectedAction.is(action) && action.options.originId === ZoomKeyTool.ID) {
+            if (KeyboardGridCellSelectedAction.is(action) && action.options.originId === GridCellZoomTool.ID) {
                 viewportAction = this.zoomKeyListener.setNewZoomFactor(
-                    this.editorContextService.modelRoot,
-                    ZoomKeyListener.defaultZoomInFactor,
-                    getAbsolutePositionByPoint(this.editorContextService.modelRoot, action.options.centerCellPosition)
+                    this.editorContext.modelRoot,
+                    this.zoomFactors.in,
+                    getAbsolutePositionByPoint(this.editorContext.modelRoot, action.options.centerCellPosition)
                 );
-            } else if (KeyboardGridKeyboardEventAction.is(action) && action.options.originId === ZoomKeyTool.ID) {
+            } else if (KeyboardGridKeyboardEventAction.is(action) && action.options.originId === GridCellZoomTool.ID) {
                 if (matchesKeystroke(action.options.event, 'Minus')) {
-                    viewportAction = this.zoomKeyListener.setNewZoomFactor(
-                        this.editorContextService.modelRoot,
-                        ZoomKeyListener.defaultZoomOutFactor
-                    );
+                    viewportAction = this.zoomKeyListener.setNewZoomFactor(this.editorContext.modelRoot, this.zoomFactors.out);
                 } else if (matchesKeystroke(action.options.event, 'Digit0', 'ctrl')) {
                     viewportAction = CenterAction.create([]);
                 }
@@ -102,29 +93,11 @@ export class ZoomKeyTool implements Tool {
     }
 }
 
-export class ZoomKeyListener extends KeyListener {
-    static readonly defaultZoomInFactor = 1.1;
-    static readonly defaultZoomOutFactor = 0.9;
-    protected readonly token = ZoomKeyListener.name;
-
-    constructor(protected tool: ZoomKeyTool) {
+export class GridZoomKeyListener extends KeyListener {
+    constructor(protected tool: GridCellZoomTool) {
         super();
     }
 
-    registerShortcutKey(): void {
-        this.tool.actionDispatcher.dispatchOnceModelInitialized(
-            SetAccessibleKeyShortcutAction.create({
-                token: this.token,
-                keys: [
-                    { shortcuts: ['+'], description: 'Zoom in to element or viewport', group: 'Zoom', position: 0 },
-                    { shortcuts: ['-'], description: 'Zoom out to element or viewport', group: 'Zoom', position: 1 },
-                    { shortcuts: ['CTRL', '0'], description: 'Reset zoom to default', group: 'Zoom', position: 2 },
-                    { shortcuts: ['CTRL', '+'], description: 'Zoom in via Grid', group: 'Zoom', position: 3 }
-                ]
-            })
-        );
-    }
-
     setNewZoomFactor(viewport: GModelElement & GModelRoot & Viewport, zoomFactor: number, point?: Point): SetViewportAction {
         let newViewport: Viewport;
         const newZoom = viewport.zoom * zoomFactor;
@@ -143,16 +116,14 @@ export class ZoomKeyListener extends KeyListener {
                 zoom: newZoom
             };
         }
-        return SetViewportAction.create(viewport.id, newViewport, { animate: true });
+        return SetViewportAction.create(viewport.id, newViewport, { animate: false });
     }
 
     override keyDown(element: GModelElement, event: KeyboardEvent): Action[] {
-        const selectedElementIds = this.tool.selectionService.getSelectedElementIDs();
-
         if (this.matchesZoomViaGrid(event)) {
             return [
                 EnableKeyboardGridAction.create({
-                    originId: ZoomKeyTool.ID,
+                    originId: GridCellZoomTool.ID,
                     triggerActions: []
                 }),
 
@@ -161,37 +132,11 @@ export class ZoomKeyListener extends KeyListener {
                     message: messages.grid.zoom_in_grid
                 })
             ];
-        } else if (this.matchesZoomOutKeystroke(event)) {
-            if (selectedElementIds.length > 0) {
-                return [ZoomElementAction.create(selectedElementIds, ZoomKeyListener.defaultZoomOutFactor)];
-            } else {
-                return [ZoomViewportAction.create(ZoomKeyListener.defaultZoomOutFactor)];
-            }
-        } else if (this.matchesZoomInKeystroke(event)) {
-            if (selectedElementIds.length > 0) {
-                return [ZoomElementAction.create(selectedElementIds, ZoomKeyListener.defaultZoomInFactor)];
-            } else {
-                return [ZoomViewportAction.create(ZoomKeyListener.defaultZoomInFactor)];
-            }
-        } else if (this.matchesMinZoomLevelKeystroke(event)) {
-            return [CenterAction.create(selectedElementIds)];
         }
         return [];
     }
 
-    protected matchesZoomInKeystroke(event: KeyboardEvent): boolean {
-        /** here event.key is used for '+', as keycode 187 is already declared for 'Equals' in {@link matchesKeystroke}.*/
-        return event.key === '+' || matchesKeystroke(event, 'NumpadAdd');
-    }
-
     protected matchesZoomViaGrid(event: KeyboardEvent): boolean {
         return event.key === '+' && event.ctrlKey;
     }
-    protected matchesMinZoomLevelKeystroke(event: KeyboardEvent): boolean {
-        return matchesKeystroke(event, 'Digit0', 'ctrl') || matchesKeystroke(event, 'Numpad0', 'ctrl');
-    }
-
-    protected matchesZoomOutKeystroke(event: KeyboardEvent): boolean {
-        return matchesKeystroke(event, 'Minus') || matchesKeystroke(event, 'NumpadSubtract');
-    }
 }

package/src/features/accessibility/view-key-tools/view-key-tools-module.ts

@@ -15,10 +15,10 @@
  ********************************************************************************/
 
 import { bindAsService, BindingContext, configureActionHandler, FeatureModule, TYPES } from '@eclipse-glsp/sprotty';
+import { viewportModule } from '../../viewport/viewport-modules';
 import { KeyboardGridCellSelectedAction, KeyboardGridKeyboardEventAction } from '../keyboard-grid/action';
 import { DeselectKeyTool } from './deselect-key-tool';
-import { MovementKeyTool } from './movement-key-tool';
-import { ZoomKeyTool } from './zoom-key-tool';
+import { GridCellZoomTool } from './grid-cell-zoom-key-tool';
 
 export const viewKeyToolsModule = new FeatureModule(
     (bind, _unbind, isBound, rebind) => {
@@ -26,14 +26,14 @@ export const viewKeyToolsModule = new FeatureModule(
         configureViewKeyTools(context);
     },
     {
-        featureId: Symbol('viewKeyTools')
+        featureId: Symbol('viewKeyTools'),
+        requires: viewportModule
     }
 );
 
 export function configureViewKeyTools(context: Pick<BindingContext, 'bind' | 'isBound'>): void {
-    bindAsService(context, TYPES.IDefaultTool, MovementKeyTool);
-    bindAsService(context, TYPES.IDefaultTool, ZoomKeyTool);
-    configureActionHandler(context, KeyboardGridCellSelectedAction.KIND, ZoomKeyTool);
-    configureActionHandler(context, KeyboardGridKeyboardEventAction.KIND, ZoomKeyTool);
+    bindAsService(context, TYPES.IDefaultTool, GridCellZoomTool);
+    configureActionHandler(context, KeyboardGridCellSelectedAction.KIND, GridCellZoomTool);
+    configureActionHandler(context, KeyboardGridKeyboardEventAction.KIND, GridCellZoomTool);
     bindAsService(context, TYPES.IDefaultTool, DeselectKeyTool);
 }

package/src/features/bounds/bounds-module.ts

@@ -23,9 +23,12 @@ import {
     TYPES,
     VBoxLayouter,
     bindAsService,
+    configureActionHandler,
     configureCommand,
     configureLayout
 } from '@eclipse-glsp/sprotty';
+import { MoveElementRelativeAction } from '../change-bounds/move-element-action';
+import { MoveElementHandler } from '../change-bounds/move-element-handler';
 import { PositionSnapper } from '../change-bounds/position-snapper';
 import { FreeFormLayouter } from './freeform-layout';
 import { GLSPHiddenBoundsUpdater } from './glsp-hidden-bounds-updater';
@@ -53,6 +56,9 @@ export const boundsModule = new FeatureModule(
         configureLayout(context, HBoxLayouter.KIND, HBoxLayouterExt);
         configureLayout(context, FreeFormLayouter.KIND, FreeFormLayouter);
 
+        bind(MoveElementHandler).toSelf().inSingletonScope();
+        configureActionHandler(context, MoveElementRelativeAction.KIND, MoveElementHandler);
+
         // backwards compatibility
         // eslint-disable-next-line deprecation/deprecation
         bind(PositionSnapper).toSelf();

package/src/features/change-bounds/move-element-action.ts

@@ -0,0 +1,55 @@
+/********************************************************************************
+ * Copyright (c) 2024 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Action } from '@eclipse-glsp/sprotty';
+
+/**
+ * Action for triggering moving of elements. It is similar to `MoveAction` but is used for moving elements relative
+ * to their current position.
+ * The corresponding namespace declares the action kind as constant and offers helper functions for type guard checks
+ * and creating new `MoveElementRelativeAction`.
+ */
+export interface MoveElementRelativeAction extends Action {
+    kind: typeof MoveElementRelativeAction.KIND;
+    /**
+     * Specifies the elements to be moved in/out
+     */
+    elementIds: string[];
+    /**
+     * Specifies the amount to be moved in the x-axis
+     */
+    moveX: number;
+    /**
+     * Specifies the amount to be moved in the y-axis
+     */
+    moveY: number;
+    /**
+     * Specifies whether we should snap to the grid
+     */
+    snap: boolean;
+}
+
+export namespace MoveElementRelativeAction {
+    export const KIND = 'moveElementRelative';
+
+    export function is(object: any): object is MoveElementRelativeAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(options: { elementIds: string[]; moveX: number; moveY: number; snap?: boolean }): MoveElementRelativeAction {
+        return { kind: KIND, snap: true, ...options };
+    }
+}