@eclipse-glsp/client 1.1.0-next.698b9de.254 → 1.1.0-next.69a77b0.259

package/src/base/di.config.ts

@@ -17,27 +17,35 @@ import '@vscode/codicons/dist/codicon.css';
 import { Container, ContainerModule } from 'inversify';
 import {
     ActionHandlerRegistry,
-    bindAsService,
-    bindOrRebind,
-    configureActionHandler,
-    configureCommand,
     InitializeResult,
+    KeyTool,
+    LocationPostprocessor,
     ModelSource,
+    MouseTool,
+    MoveCommand,
     SetEditModeAction,
-    SetModelCommand,
-    TYPES
+    TYPES,
+    bindAsService,
+    bindOrRebind,
+    configureActionHandler,
+    configureCommand
 } from '~glsp-sprotty';
 import '../../css/glsp-sprotty.css';
 import { GLSPActionDispatcher } from './action-dispatcher';
 import { FocusStateChangedAction } from './actions/focus-change-action';
 import { GLSPCommandStack } from './command-stack';
 import { EditorContextService } from './editor-context-service';
+import { ModifyCssFeedbackCommand } from './feedback/css-feedback';
+import { FeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
+import { FeedbackAwareUpdateModelCommand } from './feedback/update-model-command';
 import { FocusTracker } from './focus-tracker';
 import { DefaultModelInitializationConstraint, ModelInitializationConstraint } from './model-initialization-constraint';
 import { GLSPModelRegistry } from './model/model-registry';
-import { FeedbackAwareUpdateModelCommand, SetModelActionHandler } from './model/update-model-command';
 import { SelectionClearingMouseListener } from './selection-clearing-mouse-listener';
+import { SelectionService } from './selection-service';
 import { GLSPToolManager } from './tool-manager/glsp-tool-manager';
+import { GLSPKeyTool } from './view/key-tool';
+import { GLSPMouseTool } from './view/mouse-tool';
 import { GLSPViewRegistry } from './view/view-registry';
 
 const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
@@ -60,12 +68,17 @@ const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) =
     configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
 
     // Model update initialization ------------------------------------
+    bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
     configureCommand(context, FeedbackAwareUpdateModelCommand);
-    configureActionHandler(context, SetModelCommand.KIND, SetModelActionHandler);
+
+    bind(GLSPMouseTool).toSelf().inSingletonScope();
+    bindOrRebind(context, MouseTool).toService(GLSPMouseTool);
+    bind(GLSPKeyTool).toSelf().inSingletonScope();
+    bindOrRebind(context, KeyTool).toService(GLSPKeyTool);
 
     bindAsService(context, TYPES.MouseListener, SelectionClearingMouseListener);
 
-    bindOrRebind(context, TYPES.ICommandStack).to(GLSPCommandStack);
+    bindOrRebind(context, TYPES.ICommandStack).to(GLSPCommandStack).inSingletonScope();
     bind(GLSPToolManager).toSelf().inSingletonScope();
     bindOrRebind(context, TYPES.IToolManager).toService(GLSPToolManager);
     bind(GLSPActionDispatcher).toSelf().inSingletonScope();
@@ -76,6 +89,18 @@ const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) =
     // support re-registration of model elements and views
     bindOrRebind(context, TYPES.SModelRegistry).to(GLSPModelRegistry).inSingletonScope();
     bindOrRebind(context, TYPES.ViewRegistry).to(GLSPViewRegistry).inSingletonScope();
+
+    bind(SelectionService).toSelf().inSingletonScope();
+    bind(TYPES.ISModelRootListener).toService(SelectionService);
+
+    // Feedback Support ------------------------------------
+    // Generic re-usable feedback modifying css classes
+    configureCommand(context, ModifyCssFeedbackCommand);
+    // We support using sprotty's MoveCommand as client-side visual feedback
+    configureCommand(context, MoveCommand);
+
+    bindAsService(context, TYPES.IVNodePostprocessor, LocationPostprocessor);
+    bind(TYPES.HiddenVNodePostprocessor).toService(LocationPostprocessor);
 });
 
 export default defaultGLSPModule;

package/src/base/drag-aware-mouse-listener.ts

@@ -24,8 +24,8 @@ import { Action, MouseListener, SModelElement } from '~glsp-sprotty';
  * of mouse up events.
  */
 export class DragAwareMouseListener extends MouseListener {
-    private _isMouseDown = false;
-    private _isMouseDrag = false;
+    protected _isMouseDown = false;
+    protected _isMouseDrag = false;
 
     override mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         this._isMouseDown = true;

package/src/base/editor-context-service.ts

@@ -13,12 +13,16 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, multiInject, optional } from 'inversify';
+import { inject, injectable, multiInject, optional, postConstruct, preDestroy } from 'inversify';
 import {
     Action,
     Args,
+    Disposable,
+    DisposableCollection,
     EditMode,
     EditorContext,
+    Emitter,
+    Event,
     IActionHandler,
     ModelSource,
     MousePositionTracker,
@@ -26,13 +30,12 @@ import {
     SModelRoot,
     SetEditModeAction,
     TYPES,
-    distinctAdd,
-    remove
+    ValueChange
 } from '~glsp-sprotty';
-import { SelectionService } from '../features/select/selection-service';
+import { SelectionService } from './selection-service';
 import { isSourceUriAware } from './source-uri-aware';
 
-export interface EditModeListener {
+export interface IEditModeListener {
     editModeChanged(newValue: string, oldValue: string): void;
 }
 
@@ -49,8 +52,8 @@ export interface EditModeListener {
  *    position, etc.).
  */
 @injectable()
-export class EditorContextService implements IActionHandler {
-    @inject(TYPES.SelectionService)
+export class EditorContextService implements IActionHandler, Disposable {
+    @inject(SelectionService)
     protected selectionService: SelectionService;
 
     @inject(MousePositionTracker)
@@ -58,19 +61,31 @@ export class EditorContextService implements IActionHandler {
 
     @multiInject(TYPES.IEditModeListener)
     @optional()
-    protected editModeListeners: EditModeListener[] = [];
+    protected editModeListeners: IEditModeListener[] = [];
 
     @inject(TYPES.ModelSourceProvider)
     protected modelSourceProvider: () => Promise<ModelSource>;
 
     protected _editMode: string;
 
-    register(editModeListener: EditModeListener): void {
-        distinctAdd(this.editModeListeners, editModeListener);
+    protected onEditModeChangedEmitter = new Emitter<ValueChange<string>>();
+    get onEditModeChanged(): Event<ValueChange<string>> {
+        return this.onEditModeChangedEmitter.event;
     }
 
-    deregister(editModeListener: EditModeListener): void {
-        remove(this.editModeListeners, editModeListener);
+    protected toDispose = new DisposableCollection();
+
+    @postConstruct()
+    protected initialize(): void {
+        this.toDispose.push(this.onEditModeChangedEmitter);
+        this.editModeListeners.forEach(listener =>
+            this.onEditModeChanged(change => listener.editModeChanged(change.newValue, change.oldValue))
+        );
+    }
+
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
     }
 
     get(args?: Args): EditorContext {
@@ -98,7 +113,7 @@ export class EditorContextService implements IActionHandler {
     }
 
     protected notifyEditModeListeners(oldValue: string): void {
-        this.editModeListeners.forEach(listener => listener.editModeChanged(oldValue, this.editMode));
+        this.onEditModeChangedEmitter.fire({ newValue: this.editMode, oldValue });
     }
 
     async getSourceUri(): Promise<string | undefined> {

package/src/{features/tool-feedback → base/feedback}/css-feedback.ts

@@ -16,7 +16,7 @@
 import { inject, injectable } from 'inversify';
 import { Action, CommandExecutionContext, SModelElement, SModelRoot, TYPES, hasArrayProp } from '~glsp-sprotty';
 import { addCssClasses, getElements, removeCssClasses } from '../../utils/smodel-util';
-import { FeedbackCommand } from './model';
+import { FeedbackCommand } from './feedback-command';
 
 export interface ModifyCSSFeedbackAction extends Action {
     kind: typeof ModifyCSSFeedbackAction.KIND;

package/src/{features/tool-feedback → base/feedback}/feedback-action-dispatcher.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { inject, injectable } from 'inversify';
-import { Action, IActionDispatcher, ILogger, TYPES } from '~glsp-sprotty';
+import { Action, Disposable, IActionDispatcher, ILogger, TYPES } from '~glsp-sprotty';
 
 export interface IFeedbackEmitter {}
 
@@ -35,21 +35,23 @@ export interface IFeedbackActionDispatcher {
     /**
      * Registers `actions` to be sent out by a `feedbackEmitter`.
      * @param feedbackEmitter the emitter sending out feedback actions.
-     * @param actions the actions to be sent out.
+     * @param feedbackActions the actions to be sent out.
+     * @param cleanupActions the actions to be sent out when the feedback is de-registered through the returned Disposable.
+     * @returns A 'Disposable' that de-registers the feedback and cleans up any pending feedback with the given `cleanupActions`.
      */
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void;
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[]): Disposable;
 
     /**
      * Deregisters a `feedbackEmitter` from this dispatcher and thereafter
      * dispatches the provided `actions`.
      * @param feedbackEmitter the emitter to be deregistered.
-     * @param actions the actions to be dispatched right after the deregistration.
+     * @param cleanupActions the actions to be dispatched right after the deregistration.
      * These actions do not have to be related to the actions sent out by the
      * deregistered `feedbackEmitter`. The purpose of these actions typically is
      * to reset the normal state of the diagram without the feedback (e.g., reset a
      * CSS class that was set by a feedbackEmitter).
      */
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void;
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[]): void;
 
     /**
      * Retrieve all `actions` sent out by currently registered `feedbackEmitter`.
@@ -59,41 +61,47 @@ export interface IFeedbackActionDispatcher {
 
 @injectable()
 export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
-    protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
+    protected registeredFeedback: Map<IFeedbackEmitter, Action[]> = new Map();
 
     @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
     @inject(TYPES.ILogger) protected logger: ILogger;
 
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
-        this.feedbackEmitters.set(feedbackEmitter, actions);
-        this.dispatch(actions, feedbackEmitter);
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[] | undefined): Disposable {
+        this.registeredFeedback.set(feedbackEmitter, feedbackActions);
+        this.dispatchFeedback(feedbackActions, feedbackEmitter);
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
     }
 
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
-        this.feedbackEmitters.delete(feedbackEmitter);
-        this.dispatch(actions, feedbackEmitter);
-    }
-
-    private dispatch(actions: Action[], feedbackEmitter: IFeedbackEmitter): void {
-        this.actionDispatcher()
-            .then(dispatcher => dispatcher.dispatchAll(actions))
-            .then(() => this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`))
-            .catch(reason => this.logger.error(this, 'Failed to dispatch feedback actions', reason));
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[] | undefined): void {
+        this.registeredFeedback.delete(feedbackEmitter);
+        if (cleanupActions) {
+            this.dispatchFeedback(cleanupActions, feedbackEmitter);
+        }
     }
 
     getRegisteredFeedback(): Action[] {
         const result: Action[] = [];
-        this.feedbackEmitters.forEach((value, key) => result.push(...value));
+        this.registeredFeedback.forEach(actions => result.push(...actions));
         return result;
     }
 
     getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[] {
         const result: IFeedbackEmitter[] = [];
-        this.feedbackEmitters.forEach((value, key) => {
-            if (value.find(a => a === action)) {
-                result.push(key);
+        this.registeredFeedback.forEach((actions, emitter) => {
+            if (actions.includes(action)) {
+                result.push(emitter);
             }
         });
         return result;
     }
+
+    protected async dispatchFeedback(actions: Action[], feedbackEmitter: IFeedbackEmitter): Promise<void> {
+        try {
+            const actionDispatcher = await this.actionDispatcher();
+            await actionDispatcher.dispatchAll(actions);
+            this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`);
+        } catch (reason) {
+            this.logger.error(this, 'Failed to dispatch feedback actions', reason);
+        }
+    }
 }

package/src/base/{model → feedback}/update-model-command.ts

@@ -13,46 +13,25 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, multiInject, optional } from 'inversify';
+import { inject, injectable, optional } from 'inversify';
 import {
-    Action,
     ActionHandlerRegistry,
     Animation,
     Command,
     CommandActionHandler,
     CommandExecutionContext,
     CommandReturn,
-    IActionHandler,
     ILogger,
     MorphEdgesAnimation,
     SModelRoot,
-    SetModelAction,
     TYPES,
     UpdateAnimationData,
     UpdateModelAction,
     UpdateModelCommand,
     toTypeGuard
 } from '~glsp-sprotty';
-import { IFeedbackActionDispatcher } from '../../features/tool-feedback/feedback-action-dispatcher';
-import { FeedbackCommand } from '../../features/tool-feedback/model';
-
-/**
- * ActionHandler that transforms a {@link SetModelAction} into an {@link UpdateModelAction} that can be handled
- * by the {@link FeedbackAwareUpdateModelCommand}. This can be done because in sprotty an {@link UpdateModelCommand} and
- * a {@link SetModelCommand} have the same behavior of no model is present yet.
- */
-@injectable()
-export class SetModelActionHandler implements IActionHandler {
-    handle(action: Action): Action | void {
-        if (SetModelAction.is(action)) {
-            return UpdateModelAction.create(action.newRoot, { animate: false });
-        }
-    }
-}
-
-export interface SModelRootListener {
-    modelRootChanged(root: Readonly<SModelRoot>): void;
-}
+import { IFeedbackActionDispatcher } from './feedback-action-dispatcher';
+import { FeedbackCommand } from './feedback-command';
 
 /**
  * A special {@link UpdateModelCommand} that retrieves all registered {@link Action}s from the {@link IFeedbackActionDispatcher}
@@ -68,10 +47,6 @@ export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
     @optional()
     protected feedbackActionDispatcher: IFeedbackActionDispatcher;
 
-    @multiInject(TYPES.SModelRootListener)
-    @optional()
-    protected modelRootListeners: SModelRootListener[] = [];
-
     protected actionHandlerRegistry?: ActionHandlerRegistry;
 
     constructor(
@@ -96,7 +71,6 @@ export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
             feedbackCommands.forEach(command => command.execute(tempContext));
         }
 
-        this.modelRootListeners.forEach(listener => listener.modelRootChanged(newRoot));
         return super.performUpdate(oldRoot, newRoot, context);
     }
 

package/src/base/ranked.ts

@@ -0,0 +1,42 @@
+/********************************************************************************
+ * Copyright (c) 2019-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 { AnyObject, hasNumberProp } from '~glsp-sprotty';
+
+/**
+ * A common interface for services/listeners that should be
+ * orderable by a type or rank/priority.
+ */
+export interface Ranked {
+    rank: number;
+}
+
+export namespace Ranked {
+    export const DEFAULT_RANK = 0;
+    export function is(object: unknown): object is Ranked {
+        return AnyObject.is(object) && hasNumberProp(object, 'rank');
+    }
+
+    /**
+     * Tries to retrieve the rank form the given object. If the object
+     * implements the {@link Ranked} interface the corresponding rank is returned
+     * otherwise the {@link DEFAULT_RANK} is returned.
+     * @param object
+     */
+    export function getRank(object: unknown): number {
+        return is(object) ? object.rank : DEFAULT_RANK;
+    }
+}

package/src/{features/select → base}/selection-service.spec.ts

@@ -15,20 +15,30 @@
  ********************************************************************************/
 import { AssertionError, expect } from 'chai';
 import { Container, injectable } from 'inversify';
-import { Action, SGraphFactory, SModelElementSchema, SModelRoot, TYPES, defaultModule, initializeContainer } from '~glsp-sprotty';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
-import { SelectFeedbackAction } from './select-feedback-action';
-import { SelectionListener, SelectionService } from './selection-service';
+import * as sinon from 'sinon';
+import {
+    Action,
+    Disposable,
+    SGraphFactory,
+    SModelElementSchema,
+    SModelRoot,
+    TYPES,
+    defaultModule,
+    initializeContainer
+} from '~glsp-sprotty';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback/feedback-action-dispatcher';
+import { ISelectionListener, SelectFeedbackAction, SelectionService } from './selection-service';
 
 @injectable()
 class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
     protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
 
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): Disposable {
         this.feedbackEmitters.set(feedbackEmitter, actions);
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter));
     }
 
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, _actions?: Action[]): void {
         this.feedbackEmitters.delete(feedbackEmitter);
     }
 
@@ -44,27 +54,9 @@ class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
     }
 }
 
-class MockSelectionListener implements SelectionListener {
-    private called = 0;
-    private root: SModelRoot;
-    private selectedElements: string[] = [];
-
-    selectionChanged(newRoot: Readonly<SModelRoot>, selectedElements: string[]): void {
-        this.called++;
-        this.root = newRoot;
-        this.selectedElements = selectedElements;
-    }
-
-    getRoot(): SModelRoot {
-        return this.root;
-    }
-
-    getSelectedElements(): string[] {
-        return this.selectedElements;
-    }
-
-    getCalled(): number {
-        return this.called;
+class MockSelectionListener implements ISelectionListener {
+    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[], deselectedElements: string[] | undefined): void {
+        // no.op
     }
 }
 
@@ -74,7 +66,6 @@ function createContainer(): Container {
     container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
     container.bind(TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
     container.bind(SelectionService).toSelf().inSingletonScope();
-    container.bind(TYPES.SelectionService).toService(SelectionService);
     return container;
 }
 
@@ -90,7 +81,7 @@ describe('SelectionService', () => {
         // eslint-disable-next-line deprecation/deprecation
         graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
         root = createRoot('node1', 'node2', 'node3', 'node4', 'node5');
-        selectionService = container.get<SelectionService>(TYPES.SelectionService);
+        selectionService = container.get<SelectionService>(SelectionService);
         feedbackDispatcher = container.get<MockFeedbackActionDispatcher>(TYPES.IFeedbackActionDispatcher);
     });
 
@@ -207,118 +198,56 @@ describe('SelectionService', () => {
         });
     });
     describe('Listeners', () => {
+        const sandbox = sinon.createSandbox();
+        const listener = sandbox.createStubInstance(MockSelectionListener);
+
+        beforeEach(() => {
+            selectionService.onSelectionChanged(change =>
+                listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
+            );
+        });
+
+        afterEach(() => {
+            selectionService.dispose();
+            sandbox.reset();
+        });
         it('A registered listener should be notified of a single selection change.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1', 'node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
         it('A registered listener should be notified of a multi-selection change.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
-            assertListener(listener, root, ['node1', 'node2', 'node3'], 1);
+            assertListener(listener, root, ['node1', 'node2', 'node3'], [], 1);
         });
         it('A registered listener should be notified of series of selection changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node2'], 2);
+            assertListener(listener, root, ['node2'], ['node1'], 2);
             selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node2', 'node3', 'node4'], 3);
+            assertListener(listener, root, ['node2', 'node3', 'node4'], [], 3);
             selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node2', 'node3'], 4);
-        });
-        it('A registered listener should receive the selected elements in the right order.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node2', 'node1'], []);
-            expect(() => assertListener(listener, root, ['node1', 'node2'], 1)).to.throw(AssertionError, 'ordered members');
+            assertListener(listener, root, ['node2', 'node3'], ['node4'], 4);
         });
         it('A registered listener should be notified of root changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, [], []);
-            assertListener(listener, root, [], 1);
+            assertListener(listener, root, [], [], 1);
 
             const newRoot = createRoot('node1', 'newNode2', 'newNode3');
             selectionService.updateSelection(newRoot, [], []);
-            assertListener(listener, newRoot, [], 2);
-        });
-        it('Registering an already registered listener should have no effect.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            selectionService.register(listener);
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
-            assertListener(listener, root, ['node1', 'node2', 'node3'], 1);
-            selectionService.register(listener);
-            selectionService.updateSelection(root, [], ['node2']);
-            assertListener(listener, root, ['node1', 'node3'], 2);
+            assertListener(listener, newRoot, [], [], 2);
         });
         it('Selecting the same elements consecutively should not trigger a listener update.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
         it('Selecting a not-existing elements should not trigger a listener update.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['not-existing'], []);
-            assertListener(listener, root, ['node1'], 1);
-        });
-        it('All registered listeners should be called on selection changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            const listener2: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            selectionService.register(listener2);
-            assertListener(listener, undefined, [], 0);
-            assertListener(listener2, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
-            assertListener(listener2, root, ['node1'], 1);
-            selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node2'], 2);
-            assertListener(listener2, root, ['node2'], 2);
-            selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node2', 'node3', 'node4'], 3);
-            assertListener(listener2, root, ['node2', 'node3', 'node4'], 3);
-            selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node2', 'node3'], 4);
-            assertListener(listener2, root, ['node2', 'node3'], 4);
-        });
-        it('A deregistered listener should not receive further updates.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.deregister(listener);
-            selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node1'], 1);
-
-            const newRoot = createRoot('node1', 'newNode2', 'newNode3');
-            selectionService.updateSelection(newRoot, [], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
     });
 
@@ -363,14 +292,15 @@ describe('SelectionService', () => {
     }
 
     function assertListener(
-        listener: MockSelectionListener,
+        listener: sinon.SinonStubbedInstance<MockSelectionListener>,
         expectedRoot: SModelRoot | undefined,
         expectedSelection: string[],
+        expectedDeselection: string[],
         expectedCalled: number
     ): void {
-        expect(listener.getRoot()).to.equal(expectedRoot);
-        expect(listener.getSelectedElements()).to.have.lengthOf(expectedSelection.length);
-        expect(listener.getSelectedElements()).to.have.ordered.members(expectedSelection);
-        expect(listener.getCalled()).to.equal(expectedCalled);
+        expect(listener.selectionChanged.callCount).to.be.equal(expectedCalled);
+        expect(listener.selectionChanged.lastCall.args[0]).to.be.deep.equals(expectedRoot);
+        expect(listener.selectionChanged.lastCall.args[1]).to.be.deep.equals(expectedSelection);
+        expect(listener.selectionChanged.lastCall.args[2]).to.be.deep.equals(expectedDeselection);
     }
 });