@eclipse-glsp/client 1.1.0-next.383e4e9.264 → 1.1.0-next.3d1b3e6.280

package/src/features/hover/hover.ts

@@ -18,8 +18,6 @@ import {
     Action,
     Bounds,
     EMPTY_ROOT,
-    EnableDefaultToolsAction,
-    EnableToolsAction,
     HoverFeedbackAction,
     HoverMouseListener,
     IActionHandler,
@@ -32,6 +30,7 @@ import {
     SetPopupModelAction
 } from '~glsp-sprotty';
 import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool';
 import { EdgeCreationTool } from '../tools/edge-creation/edge-creation-tool';
 import { GIssueMarker, getSeverity } from '../validation/issue-marker';
 
@@ -75,7 +74,7 @@ export class GlspHoverMouseListener extends HoverMouseListener implements IActio
             this.state.mouseOverTimer = window.setTimeout(() => {
                 const popupBounds = this.computePopupBounds(target, { x: event.pageX, y: event.pageY });
                 if (target instanceof GIssueMarker) {
-                    resolve(SetPopupModelAction.create(this.createPopupModel(target as GIssueMarker, popupBounds)));
+                    resolve(SetPopupModelAction.create(this.createPopupModel(target, popupBounds)));
                 } else {
                     resolve(RequestPopupModelAction.create({ elementId: target.id, bounds: popupBounds }));
                 }

package/src/features/label-edit/edit-label-tool.ts

@@ -15,10 +15,10 @@
  ********************************************************************************/
 import { injectable } from 'inversify';
 import { EditLabelKeyListener, EditLabelMouseListener, KeyListener, MouseListener } from '~glsp-sprotty';
-import { BaseGLSPTool } from '../tools/base-glsp-tool';
+import { BaseEditTool } from '../tools/base-tools';
 
 @injectable()
-export class DirectLabelEditTool extends BaseGLSPTool {
+export class DirectLabelEditTool extends BaseEditTool {
     static readonly ID = 'glsp.direct-label-edit-tool';
 
     get id(): string {

package/src/features/label-edit/edit-label-validator.ts

@@ -34,11 +34,11 @@ export namespace LabelEditValidation {
 
     export function toEditLabelValidationResult(status: ValidationStatus): EditLabelValidationResult {
         const message = status.message;
-        let severity = 'ok' as Severity;
+        let severity: Severity = 'ok';
         if (ValidationStatus.isError(status)) {
-            severity = 'error' as Severity;
+            severity = 'error';
         } else if (ValidationStatus.isWarning(status)) {
-            severity = 'warning' as Severity;
+            severity = 'warning';
         }
         return { message, severity };
     }
@@ -52,16 +52,17 @@ export namespace LabelEditValidation {
 export class ServerEditLabelValidator implements IEditLabelValidator {
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
 
-    validate(value: string, label: EditableLabel & SModelElement): Promise<EditLabelValidationResult> {
+    async validate(value: string, label: EditableLabel & SModelElement): Promise<EditLabelValidationResult> {
         const action = LabelEditValidation.createValidationRequestAction(value, label.id);
-        return this.actionDispatcher.requestUntil(action).then(response => this.getValidationResultFromResponse(response));
+        const response = await this.actionDispatcher.requestUntil(action);
+        return response ? this.getValidationResultFromResponse(response) : { severity: 'ok' };
     }
 
     getValidationResultFromResponse(action: Action): EditLabelValidationResult {
         if (SetEditValidationResultAction.is(action)) {
             return LabelEditValidation.toEditLabelValidationResult(action.status);
         }
-        return { severity: 'ok' as Severity };
+        return { severity: 'ok' };
     }
 }
 

package/src/features/navigation/navigation-action-handler.ts

@@ -23,17 +23,17 @@ import {
     IActionHandler,
     ICommand,
     ILogger,
+    MessageAction,
     NavigateToExternalTargetAction,
     NavigateToTargetAction,
     NavigationTarget,
     RequestNavigationTargetsAction,
     SelectAction,
     SelectAllAction,
-    ServerMessageAction,
-    ServerSeverity,
-    ServerStatusAction,
     SetNavigationTargetsAction,
     SetResolvedNavigationTargetAction,
+    SeverityLevel,
+    StatusAction,
     TYPES,
     hasObjectProp,
     hasStringProp
@@ -264,11 +264,8 @@ export class NavigationActionHandler implements IActionHandler {
         this.notify('WARNING', message);
     }
 
-    private notify(severity: ServerSeverity, message: string): void {
+    private notify(severity: SeverityLevel, message: string): void {
         const timeout = this.notificationTimeout;
-        this.dispatcher.dispatchAll([
-            ServerStatusAction.create(message, { severity, timeout }),
-            ServerMessageAction.create(message, { severity })
-        ]);
+        this.dispatcher.dispatchAll([StatusAction.create(message, { severity, timeout }), MessageAction.create(message, { severity })]);
     }
 }

package/src/features/navigation/navigation-target-resolver.ts

@@ -23,7 +23,7 @@ import {
     SetResolvedNavigationTargetAction,
     TYPES
 } from '~glsp-sprotty';
-import { EditorContextServiceProvider } from '../../base/editor-context-service';
+import { IDiagramOptions } from '../../base/model/diagram-loader';
 
 /**
  * Resolves `NavigationTargets` to element ids.
@@ -33,14 +33,17 @@ import { EditorContextServiceProvider } from '../../base/editor-context-service'
  */
 @injectable()
 export class NavigationTargetResolver {
-    @inject(TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
-    @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
-    @inject(TYPES.ILogger) protected readonly logger: ILogger;
+    @inject(TYPES.IActionDispatcher)
+    protected dispatcher: IActionDispatcher;
+
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    @inject(TYPES.IDiagramOptions)
+    protected diagramOptions: IDiagramOptions;
 
     async resolve(navigationTarget: NavigationTarget): Promise<SetResolvedNavigationTargetAction | undefined> {
-        const contextService = await this.editorContextService();
-        const sourceUri = await contextService.getSourceUri();
-        return this.resolveWithSourceUri(sourceUri, navigationTarget);
+        return this.resolveWithSourceUri(this.diagramOptions.sourceUri, navigationTarget);
     }
 
     async resolveWithSourceUri(

package/src/features/select/select-mouse-listener.ts

@@ -13,22 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import {
-    Action,
-    BringToFrontAction,
-    SButton,
-    SModelElement,
-    SModelRoot,
-    SRoutableElement,
-    SRoutingHandle,
-    SelectAction,
-    SelectMouseListener,
-    SwitchEditModeAction,
-    findParentByFeature,
-    isCtrlOrCmd,
-    isSelectable,
-    toArray
-} from '~glsp-sprotty';
+import { Action, BringToFrontAction, SModelElement, SelectAction, SelectMouseListener, Selectable } from '~glsp-sprotty';
 import { Ranked } from '../../base/ranked';
 
 /**
@@ -36,71 +21,34 @@ import { Ranked } from '../../base/ranked';
  * This ensures that default mouse listeners are working on a model that has selection changes already applied.
  */
 export class RankedSelectMouseListener extends SelectMouseListener implements Ranked {
-    rank: number = Ranked.DEFAULT_RANK - 1; /* we want to be executed before all default mouse listeners */
+    rank: number = Ranked.DEFAULT_RANK - 100; /* we want to be executed before all default mouse listeners */
 
-    override mouseDown(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+    protected override handleSelectTarget(
+        selectableTarget: SModelElement & Selectable,
+        deselectedElements: SModelElement[],
+        event: MouseEvent
+    ): (Action | Promise<Action>)[] {
         const result: Action[] = [];
-        if (this.buttonHandlerRegistry !== undefined && target instanceof SButton && target.enabled) {
-            const buttonHandler = this.buttonHandlerRegistry.get(target.type);
-            if (buttonHandler !== undefined) {
-                return buttonHandler.buttonPressed(target);
-            }
-        }
-        const selectableTarget = findParentByFeature(target, isSelectable);
-        if (selectableTarget !== undefined || target instanceof SModelRoot) {
-            this.hasDragged = false;
-            let deselect: SModelElement[] = [];
-            // multi-selection?
-            if (!isCtrlOrCmd(event)) {
-                deselect = toArray(
-                    target.root.index
-                        .all()
-                        .filter(
-                            element =>
-                                isSelectable(element) &&
-                                element.selected &&
-                                !(selectableTarget instanceof SRoutingHandle && element === (selectableTarget.parent as SModelElement))
-                        )
-                );
-            }
-            if (selectableTarget !== undefined) {
-                if (!selectableTarget.selected) {
-                    this.wasSelected = false;
-                    result.push(
-                        SelectAction.create({
-                            selectedElementsIDs: [selectableTarget.id],
-                            deselectedElementsIDs: deselect.map(e => e.id)
-                        })
-                    );
-                    result.push(BringToFrontAction.create([selectableTarget.id]));
-                    const routableDeselect = deselect.filter(e => e instanceof SRoutableElement).map(e => e.id);
-                    if (selectableTarget instanceof SRoutableElement) {
-                        result.push(
-                            SwitchEditModeAction.create({
-                                elementsToActivate: [selectableTarget.id],
-                                elementsToDeactivate: routableDeselect
-                            })
-                        );
-                    } else if (routableDeselect.length > 0) {
-                        result.push(SwitchEditModeAction.create({ elementsToDeactivate: routableDeselect }));
-                    }
-                } else if (isCtrlOrCmd(event)) {
-                    this.wasSelected = false;
-                    result.push(SelectAction.create({ deselectedElementsIDs: [selectableTarget.id] }));
-                    if (selectableTarget instanceof SRoutableElement) {
-                        result.push(SwitchEditModeAction.create({ elementsToDeactivate: [selectableTarget.id] }));
-                    }
-                } else {
-                    this.wasSelected = true;
-                }
-            } else {
-                result.push(SelectAction.create({ deselectedElementsIDs: deselect.map(e => e.id) }));
-                const routableDeselect = deselect.filter(e => e instanceof SRoutableElement).map(e => e.id);
-                if (routableDeselect.length > 0) {
-                    result.push(SwitchEditModeAction.create({ elementsToDeactivate: routableDeselect }));
-                }
-            }
-        }
+        result.push(
+            SelectAction.create({
+                selectedElementsIDs: [selectableTarget.id],
+                deselectedElementsIDs: deselectedElements.map(e => e.id)
+            })
+        );
+        result.push(BringToFrontAction.create([selectableTarget.id]));
+
+        return result;
+    }
+
+    protected override handleDeselectTarget(selectableTarget: SModelElement & Selectable, event: MouseEvent): (Action | Promise<Action>)[] {
+        const result: Action[] = [];
+        result.push(SelectAction.create({ selectedElementsIDs: [], deselectedElementsIDs: [selectableTarget.id] }));
+        return result;
+    }
+
+    protected override handleDeselectAll(deselectedElements: SModelElement[], event: MouseEvent): (Action | Promise<Action>)[] {
+        const result: Action[] = [];
+        result.push(SelectAction.create({ selectedElementsIDs: [], deselectedElementsIDs: deselectedElements.map(e => e.id) }));
         return result;
     }
 }

package/src/features/source-model-watcher/source-model-changed-action-handler.ts

@@ -18,9 +18,9 @@ import {
     Action,
     IActionDispatcher,
     IActionHandler,
-    ServerMessageAction,
-    ServerStatusAction,
+    MessageAction,
     SourceModelChangedAction,
+    StatusAction,
     TYPES,
     ViewerOptions
 } from '~glsp-sprotty';
@@ -68,9 +68,6 @@ export class SourceModelChangedActionHandler implements IActionHandler {
         const message = `The source model ${action.sourceModelName} has changed. You might want to consider reloading.`;
         const timeout = 0;
         const severity = 'WARNING';
-        this.dispatcher.dispatchAll([
-            ServerStatusAction.create(message, { severity, timeout }),
-            ServerMessageAction.create(message, { severity })
-        ]);
+        this.dispatcher.dispatchAll([StatusAction.create(message, { severity, timeout }), MessageAction.create(message, { severity })]);
     }
 }

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

@@ -0,0 +1,26 @@
+/********************************************************************************
+ * Copyright (c) 2023 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 { FeatureModule, StatusAction, TYPES, bindAsService, configureActionHandler } from '~glsp-sprotty';
+import '../../../css/status-overlay.css';
+import { StatusOverlay } from './status-overlay';
+
+export const statusModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bindAsService(context, TYPES.IUIExtension, StatusOverlay);
+    bind(TYPES.IDiagramStartup).toService(StatusOverlay);
+    configureActionHandler(context, StatusAction.KIND, StatusOverlay);
+});

package/src/features/status/status-overlay.ts

@@ -0,0 +1,121 @@
+/********************************************************************************
+ * Copyright (c) 2023 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 { inject, injectable } from 'inversify';
+import { AbstractUIExtension, IActionHandler, StatusAction, codiconCSSClasses } from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { EditorContextService } from '../../base/editor-context-service';
+import { IDiagramStartup } from '../../base/model/diagram-loader';
+
+/**
+ * A reusable status overlay for rendering (icon + message) and handling of {@link StatusAction}'s.
+ */
+@injectable()
+export class StatusOverlay extends AbstractUIExtension implements IActionHandler, IDiagramStartup {
+    static readonly ID = 'glsp.server.status.overlay';
+
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
+
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
+    protected statusIconDiv?: HTMLDivElement;
+    protected statusMessageDiv?: HTMLDivElement;
+    protected pendingTimeout?: number;
+
+    override id(): string {
+        return StatusOverlay.ID;
+    }
+
+    override containerClass(): string {
+        return 'sprotty-status';
+    }
+    protected override initializeContents(containerElement: HTMLElement): void {
+        this.statusIconDiv = document.createElement('div');
+        containerElement.appendChild(this.statusIconDiv);
+
+        this.statusMessageDiv = document.createElement('div');
+        this.statusMessageDiv.classList.add('sprotty-status-message');
+        containerElement.appendChild(this.statusMessageDiv);
+    }
+
+    protected setStatus(status: StatusAction): void {
+        if (this.statusMessageDiv) {
+            this.statusMessageDiv.textContent = status.message;
+            this.removeClasses(this.statusMessageDiv, 1);
+            this.statusMessageDiv.classList.add(status.severity.toLowerCase());
+        }
+        if (this.statusIconDiv) {
+            this.removeClasses(this.statusIconDiv, 0);
+            const classes = this.statusIconDiv.classList;
+            classes.add(status.severity.toLowerCase());
+            switch (status.severity) {
+                case 'FATAL':
+                    classes.add(...codiconCSSClasses('error'));
+                    break;
+                case 'ERROR':
+                    classes.add(...codiconCSSClasses('warning'));
+                    break;
+                case 'WARNING':
+                    classes.add(...codiconCSSClasses('warning'));
+                    break;
+                case 'INFO':
+                    classes.add(...codiconCSSClasses('info'));
+                    break;
+            }
+        }
+    }
+
+    protected clearStatus(): void {
+        this.setStatus(StatusAction.create('', { severity: 'NONE' }));
+    }
+
+    protected clearTimeout(): void {
+        if (this.pendingTimeout) {
+            window.clearTimeout(this.pendingTimeout);
+            this.pendingTimeout = undefined;
+        }
+    }
+
+    protected removeClasses(element: Element, keep: number): void {
+        const classes = element.classList;
+        while (classes.length > keep) {
+            const item = classes.item(classes.length - 1);
+            if (item) {
+                classes.remove(item);
+            }
+        }
+    }
+
+    handle(action: StatusAction): void {
+        this.clearTimeout();
+        if (action.severity === 'NONE') {
+            this.clearStatus();
+            return;
+        }
+        this.setStatus(action);
+
+        // Check for timeout
+        const statusTimeout = action.timeout ?? -1;
+        if (statusTimeout > 0) {
+            this.pendingTimeout = window.setTimeout(() => this.clearStatus(), statusTimeout);
+        }
+    }
+
+    preInitialize(): void {
+        this.show(this.editorContext.modelRoot);
+    }
+}

package/src/features/tool-palette/tool-palette-module.ts

@@ -13,12 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { bindAsService, configureActionHandler, EnableDefaultToolsAction, FeatureModule, TYPES } from '~glsp-sprotty';
+import { bindAsService, configureActionHandler, FeatureModule, TYPES } from '~glsp-sprotty';
 import '../../../css/tool-palette.css';
-import { EnableToolPaletteAction, ToolPalette } from './tool-palette';
+import { EnableDefaultToolsAction } from '../../base/tool-manager/tool';
+import { ToolPalette } from './tool-palette';
 
 export const toolPaletteModule = new FeatureModule((bind, _unbind, isBound, _rebind) => {
     bindAsService(bind, TYPES.IUIExtension, ToolPalette);
-    configureActionHandler({ bind, isBound }, EnableToolPaletteAction.KIND, ToolPalette);
+    bind(TYPES.IDiagramStartup).toService(ToolPalette);
     configureActionHandler({ bind, isBound }, EnableDefaultToolsAction.KIND, ToolPalette);
 });

package/src/features/tool-palette/tool-palette.ts

@@ -17,11 +17,8 @@ import { inject, injectable, postConstruct } from 'inversify';
 import {
     AbstractUIExtension,
     Action,
-    EnableDefaultToolsAction,
-    EnableToolsAction,
     IActionHandler,
     ICommand,
-    IToolManager,
     MarkersReason,
     PaletteItem,
     RequestContextActions,
@@ -29,13 +26,14 @@ import {
     SModelRoot,
     SetContextActions,
     SetUIExtensionVisibilityAction,
-    TYPES,
     codiconCSSClasses,
     matchesKeystroke
 } from '~glsp-sprotty';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { EditorContextService, IEditModeListener } from '../../base/editor-context-service';
 import { FocusTracker } from '../../base/focus/focus-tracker';
+import { IDiagramStartup } from '../../base/model/diagram-loader';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool';
 import { MouseDeleteTool } from '../tools/deletion/delete-tool';
 import { MarqueeMouseTool } from '../tools/marquee-selection/marquee-mouse-tool';
 
@@ -61,13 +59,17 @@ export namespace EnableToolPaletteAction {
     }
 }
 @injectable()
-export class ToolPalette extends AbstractUIExtension implements IActionHandler, IEditModeListener {
+export class ToolPalette extends AbstractUIExtension implements IActionHandler, IEditModeListener, IDiagramStartup {
     static readonly ID = 'tool-palette';
 
-    @inject(TYPES.IActionDispatcher) protected readonly actionDispatcher: GLSPActionDispatcher;
-    @inject(TYPES.IToolManager) protected readonly toolManager: IToolManager;
-    @inject(EditorContextService) protected readonly editorContext: EditorContextService;
-    @inject(FocusTracker) protected readonly focusTracker: FocusTracker;
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
+
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
+    @inject(FocusTracker)
+    protected focusTracker: FocusTracker;
 
     protected paletteItems: PaletteItem[];
     protected paletteItemsCopy: PaletteItem[] = [];
@@ -96,10 +98,11 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         return super.initialize();
     }
 
-    protected initializeContents(_containerElement: HTMLElement): void {
+    protected initializeContents(containerElement: HTMLElement): void {
         this.createHeader();
         this.createBody();
         this.lastActiveButton = this.defaultToolsButton;
+        containerElement.setAttribute('aria-label', 'Tool-Palette');
     }
 
     protected override onBeforeShow(_containerElement: HTMLElement, root: Readonly<SModelRoot>): void {
@@ -206,7 +209,9 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         const button = createIcon('inspect');
         button.id = 'btn_default_tools';
         button.title = 'Enable selection tool';
-        button.onclick = this.onClickStaticToolButton(this.defaultToolsButton);
+        button.onclick = this.onClickStaticToolButton(button);
+        button.ariaLabel = button.title;
+        button.tabIndex = 1;
         return button;
     }
 
@@ -214,6 +219,8 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         const deleteToolButton = createIcon('chrome-close');
         deleteToolButton.title = 'Enable deletion tool';
         deleteToolButton.onclick = this.onClickStaticToolButton(deleteToolButton, MouseDeleteTool.ID);
+        deleteToolButton.ariaLabel = deleteToolButton.title;
+        deleteToolButton.tabIndex = 1;
         return deleteToolButton;
     }
 
@@ -221,6 +228,8 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         const marqueeToolButton = createIcon('screen-full');
         marqueeToolButton.title = 'Enable marquee tool';
         marqueeToolButton.onclick = this.onClickStaticToolButton(marqueeToolButton, MarqueeMouseTool.ID);
+        marqueeToolButton.ariaLabel = marqueeToolButton.title;
+        marqueeToolButton.tabIndex = 1;
         return marqueeToolButton;
     }
 
@@ -230,7 +239,10 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         validateActionButton.onclick = _event => {
             const modelIds: string[] = [this.modelRootId];
             this.actionDispatcher.dispatch(RequestMarkersAction.create(modelIds, { reason: MarkersReason.BATCH }));
+            validateActionButton.focus();
         };
+        validateActionButton.ariaLabel = validateActionButton.title;
+        validateActionButton.tabIndex = 1;
         return validateActionButton;
     }
 
@@ -249,6 +261,8 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         };
         searchIcon.classList.add('search-icon');
         searchIcon.title = 'Filter palette entries';
+        searchIcon.ariaLabel = searchIcon.title;
+        searchIcon.tabIndex = 1;
         return searchIcon;
     }
 
@@ -319,28 +333,11 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         }
     }
 
-    handle(action: Action): ICommand | Action | void {
-        if (action.kind === EnableToolPaletteAction.KIND) {
-            const requestAction = RequestContextActions.create({
-                contextId: ToolPalette.ID,
-                editorContext: {
-                    selectedElementIds: []
-                }
-            });
-            this.actionDispatcher.requestUntil(requestAction).then(response => {
-                if (SetContextActions.is(response)) {
-                    this.paletteItems = response.actions.map(e => e as PaletteItem);
-                    this.actionDispatcher.dispatch(
-                        SetUIExtensionVisibilityAction.create({ extensionId: ToolPalette.ID, visible: !this.editorContext.isReadonly })
-                    );
-                }
-            });
-        } else if (action.kind === EnableDefaultToolsAction.KIND) {
-            this.changeActiveButton();
-            if (this.focusTracker.hasFocus) {
-                // if focus was deliberately taken do not restore focus to the palette
-                this.restoreFocus();
-            }
+    handle(action: EnableDefaultToolsAction): ICommand | Action | void {
+        this.changeActiveButton();
+        if (this.focusTracker.hasFocus) {
+            // if focus was deliberately taken do not restore focus to the palette
+            this.focusTracker.diagramElement?.focus();
         }
     }
 
@@ -396,6 +393,20 @@ export class ToolPalette extends AbstractUIExtension implements IActionHandler,
         this.paletteItems = filteredPaletteItems;
         this.createBody();
     }
+
+    async preRequestModel(): Promise<void> {
+        const requestAction = RequestContextActions.create({
+            contextId: ToolPalette.ID,
+            editorContext: {
+                selectedElementIds: []
+            }
+        });
+        const response = await this.actionDispatcher.request<SetContextActions>(requestAction);
+        this.paletteItems = response.actions.map(e => e as PaletteItem);
+        if (!this.editorContext.isReadonly) {
+            this.show(this.editorContext.modelRoot);
+        }
+    }
 }
 
 export function compare(a: PaletteItem, b: PaletteItem): number {