@theia/core 1.20.0 → 1.21.0-next.14

package/src/browser/common-frontend-contribution.ts

@@ -18,7 +18,6 @@
 
 import debounce = require('lodash.debounce');
 import { injectable, inject, optional } from 'inversify';
-import { TabBar, Widget } from '@phosphor/widgets';
 import { MAIN_MENU_BAR, SETTINGS_MENU, MenuContribution, MenuModelRegistry, ACCOUNTS_MENU } from '../common/menu';
 import { KeybindingContribution, KeybindingRegistry } from './keybinding';
 import { FrontendApplication, FrontendApplicationContribution } from './frontend-application';
@@ -28,7 +27,7 @@ import { SelectionService } from '../common/selection-service';
 import { MessageService } from '../common/message-service';
 import { OpenerService, open } from '../browser/opener-service';
 import { ApplicationShell } from './shell/application-shell';
-import { SHELL_TABBAR_CONTEXT_MENU } from './shell/tab-bars';
+import { SHELL_TABBAR_CONTEXT_CLOSE, SHELL_TABBAR_CONTEXT_COPY, SHELL_TABBAR_CONTEXT_SPLIT } from './shell/tab-bars';
 import { AboutDialog } from './about-dialog';
 import * as browser from './browser';
 import URI from '../common/uri';
@@ -51,10 +50,11 @@ import { EncodingRegistry } from './encoding-registry';
 import { UTF8 } from '../common/encodings';
 import { EnvVariablesServer } from '../common/env-variables';
 import { AuthenticationService } from './authentication-service';
-import { FormatType } from './saveable';
+import { FormatType, Saveable } from './saveable';
 import { QuickInputService, QuickPick, QuickPickItem } from './quick-input';
 import { AsyncLocalizationProvider } from '../common/i18n/localization';
 import { nls } from '../common/nls';
+import { CurrentWidgetCommandAdapter } from './shell/current-widget-command-adapter';
 
 export namespace CommonMenus {
 
@@ -181,6 +181,11 @@ export namespace CommonCommands {
         category: VIEW_CATEGORY,
         label: 'Close Other Tabs'
     }, 'theia/core/common/closeOthers', VIEW_CATEGORY_KEY);
+    export const CLOSE_SAVED_TABS = Command.toDefaultLocalizedCommand({
+        id: 'workbench.action.closeUnmodifiedEditors',
+        category: VIEW_CATEGORY,
+        label: 'Close Saved Editors in Group',
+    });
     export const CLOSE_RIGHT_TABS = Command.toLocalizedCommand({
         id: 'core.close.right.tabs',
         category: VIEW_CATEGORY,
@@ -546,35 +551,45 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             order: '2'
         });
 
-        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_MENU, {
+        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_CLOSE, {
             commandId: CommonCommands.CLOSE_TAB.id,
             label: nls.localizeByDefault('Close'),
             order: '0'
         });
-        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_MENU, {
+        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_CLOSE, {
             commandId: CommonCommands.CLOSE_OTHER_TABS.id,
             label: nls.localizeByDefault('Close Others'),
             order: '1'
         });
-        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_MENU, {
+        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_CLOSE, {
             commandId: CommonCommands.CLOSE_RIGHT_TABS.id,
             label: nls.localizeByDefault('Close to the Right'),
             order: '2'
         });
-        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_MENU, {
+        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_CLOSE, {
+            commandId: CommonCommands.CLOSE_SAVED_TABS.id,
+            label: nls.localizeByDefault('Close Saved'),
+            order: '3',
+        });
+        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_CLOSE, {
             commandId: CommonCommands.CLOSE_ALL_TABS.id,
             label: nls.localizeByDefault('Close All'),
-            order: '3'
+            order: '4'
         });
-        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_MENU, {
+        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_SPLIT, {
             commandId: CommonCommands.COLLAPSE_PANEL.id,
             label: CommonCommands.COLLAPSE_PANEL.label,
-            order: '4'
+            order: '5'
         });
-        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_MENU, {
+        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_SPLIT, {
             commandId: CommonCommands.TOGGLE_MAXIMIZED.id,
             label: CommonCommands.TOGGLE_MAXIMIZED.label,
-            order: '5'
+            order: '6'
+        });
+        registry.registerMenuAction(SHELL_TABBAR_CONTEXT_COPY, {
+            commandId: CommonCommands.COPY_PATH.id,
+            label: CommonCommands.COPY_PATH.label,
+            order: '1',
         });
         registry.registerMenuAction(CommonMenus.HELP, {
             commandId: CommonCommands.ABOUT_COMMAND.id,
@@ -633,6 +648,8 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             }
         });
         commandRegistry.registerCommand(CommonCommands.COPY_PATH, UriAwareCommandHandler.MultiSelect(this.selectionService, {
+            isVisible: uris => Array.isArray(uris) && uris.some(uri => uri instanceof URI),
+            isEnabled: uris => Array.isArray(uris) && uris.some(uri => uri instanceof URI),
             execute: async uris => {
                 if (uris.length) {
                     const lineDelimiter = isWindows ? '\r\n' : '\n';
@@ -685,62 +702,45 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             isEnabled: () => this.shell.previousTabBar() !== undefined,
             execute: () => this.shell.activatePreviousTabBar()
         });
-        commandRegistry.registerCommand(CommonCommands.CLOSE_TAB, {
-            isEnabled: (event?: Event) => {
-                const tabBar = this.shell.findTabBar(event);
-                if (!tabBar) {
-                    return false;
-                }
-                const currentTitle = this.shell.findTitle(tabBar, event);
-                return currentTitle !== undefined && currentTitle.closable;
-            },
-            execute: (event?: Event) => {
-                const tabBar = this.shell.findTabBar(event)!;
-                const currentTitle = this.shell.findTitle(tabBar, event);
-                this.shell.closeTabs(tabBar, title => title === currentTitle);
-            }
-        });
-        commandRegistry.registerCommand(CommonCommands.CLOSE_OTHER_TABS, {
-            isEnabled: (event?: Event) => {
-                const tabBar = this.shell.findTabBar(event);
-                if (!tabBar) {
-                    return false;
-                }
-                const currentTitle = this.shell.findTitle(tabBar, event);
-                return tabBar.titles.some(title => title !== currentTitle && title.closable);
-            },
-            execute: (event?: Event) => {
-                const tabBar = this.shell.findTabBar(event)!;
-                const currentTitle = this.shell.findTitle(tabBar, event);
-                this.shell.closeTabs(tabBar, title => title !== currentTitle && title.closable);
-            }
-        });
-        commandRegistry.registerCommand(CommonCommands.CLOSE_RIGHT_TABS, {
-            isEnabled: (event?: Event) => {
-                const tabBar = this.shell.findTabBar(event);
-                if (!tabBar) {
-                    return false;
-                }
-                const currentIndex = this.findTitleIndex(tabBar, event);
-                return tabBar.titles.some((title, index) => index > currentIndex && title.closable);
-            },
-            isVisible: (event?: Event) => {
-                const area = this.findTabArea(event);
+        commandRegistry.registerCommand(CommonCommands.CLOSE_TAB, new CurrentWidgetCommandAdapter(this.shell, {
+            isEnabled: title => Boolean(title?.closable),
+            execute: (title, tabBar) => tabBar && this.shell.closeTabs(tabBar, candidate => candidate === title),
+        }));
+        commandRegistry.registerCommand(CommonCommands.CLOSE_OTHER_TABS, new CurrentWidgetCommandAdapter(this.shell, {
+            isEnabled: (title, tabbar) => Boolean(tabbar?.titles.some(candidate => candidate !== title && candidate.closable)),
+            execute: (title, tabbar) => tabbar && this.shell.closeTabs(tabbar, candidate => candidate !== title && candidate.closable),
+        }));
+        commandRegistry.registerCommand(CommonCommands.CLOSE_SAVED_TABS, new CurrentWidgetCommandAdapter(this.shell, {
+            isEnabled: (_title, tabbar) => Boolean(tabbar?.titles.some(candidate => candidate.closable && !Saveable.isDirty(candidate.owner))),
+            execute: (_title, tabbar) => tabbar && this.shell.closeTabs(tabbar, candidate => candidate.closable && !Saveable.isDirty(candidate.owner)),
+        }));
+        commandRegistry.registerCommand(CommonCommands.CLOSE_RIGHT_TABS, new CurrentWidgetCommandAdapter(this.shell, {
+            isEnabled: (title, tabbar) => {
+                let targetSeen = false;
+                return Boolean(tabbar?.titles.some(candidate => {
+                    if (targetSeen && candidate.closable) { return true; };
+                    if (candidate === title) { targetSeen = true; };
+                }));
+            },
+            isVisible: (_title, tabbar) => {
+                const area = (tabbar && this.shell.getAreaFor(tabbar)) ?? this.shell.currentTabArea;
                 return area !== undefined && area !== 'left' && area !== 'right';
             },
-            execute: (event?: Event) => {
-                const tabBar = this.shell.findTabBar(event)!;
-                const currentIndex = this.findTitleIndex(tabBar, event);
-                this.shell.closeTabs(tabBar, (title, index) => index > currentIndex && title.closable);
+            execute: (title, tabbar) => {
+                if (tabbar) {
+                    let targetSeen = false;
+                    this.shell.closeTabs(tabbar, candidate => {
+                        if (targetSeen && candidate.closable) { return true; };
+                        if (candidate === title) { targetSeen = true; };
+                        return false;
+                    });
+                }
             }
-        });
-        commandRegistry.registerCommand(CommonCommands.CLOSE_ALL_TABS, {
-            isEnabled: (event?: Event) => {
-                const tabBar = this.shell.findTabBar(event);
-                return tabBar !== undefined && tabBar.titles.some(title => title.closable);
-            },
-            execute: (event?: Event) => this.shell.closeTabs(this.shell.findTabBar(event)!, title => title.closable)
-        });
+        }));
+        commandRegistry.registerCommand(CommonCommands.CLOSE_ALL_TABS, new CurrentWidgetCommandAdapter(this.shell, {
+            isEnabled: (_title, tabbar) => Boolean(tabbar?.titles.some(title => title.closable)),
+            execute: (_title, tabbar) => tabbar && this.shell.closeTabs(tabbar, candidate => candidate.closable),
+        }));
         commandRegistry.registerCommand(CommonCommands.CLOSE_MAIN_TAB, {
             isEnabled: () => {
                 const currentWidget = this.shell.getCurrentWidget('main');
@@ -763,11 +763,11 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             isEnabled: () => this.shell.mainAreaTabBars.some(tb => tb.titles.some(title => title.closable)),
             execute: () => this.shell.closeTabs('main', title => title.closable)
         });
-        commandRegistry.registerCommand(CommonCommands.COLLAPSE_PANEL, {
-            isEnabled: (event?: Event) => ApplicationShell.isSideArea(this.findTabArea(event)),
-            isVisible: (event?: Event) => ApplicationShell.isSideArea(this.findTabArea(event)),
-            execute: (event?: Event) => this.shell.collapsePanel(this.findTabArea(event)!)
-        });
+        commandRegistry.registerCommand(CommonCommands.COLLAPSE_PANEL, new CurrentWidgetCommandAdapter(this.shell, {
+            isEnabled: (_title, tabbar) => Boolean(tabbar && ApplicationShell.isSideArea(this.shell.getAreaFor(tabbar))),
+            isVisible: (_title, tabbar) => Boolean(tabbar && ApplicationShell.isSideArea(this.shell.getAreaFor(tabbar))),
+            execute: (_title, tabbar) => tabbar && this.shell.collapsePanel(this.shell.getAreaFor(tabbar)!)
+        }));
         commandRegistry.registerCommand(CommonCommands.COLLAPSE_ALL_PANELS, {
             execute: () => {
                 this.shell.collapsePanel('left');
@@ -788,11 +788,11 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         commandRegistry.registerCommand(CommonCommands.TOGGLE_STATUS_BAR, {
             execute: () => this.preferenceService.updateValue('workbench.statusBar.visible', !this.preferences['workbench.statusBar.visible'])
         });
-        commandRegistry.registerCommand(CommonCommands.TOGGLE_MAXIMIZED, {
-            isEnabled: (event?: Event) => this.canToggleMaximized(event),
-            isVisible: (event?: Event) => this.canToggleMaximized(event),
-            execute: (event?: Event) => this.toggleMaximized(event)
-        });
+        commandRegistry.registerCommand(CommonCommands.TOGGLE_MAXIMIZED, new CurrentWidgetCommandAdapter(this.shell, {
+            isEnabled: title => Boolean(title?.owner && this.shell.canToggleMaximized(title?.owner)),
+            isVisible: title => Boolean(title?.owner && this.shell.canToggleMaximized(title?.owner)),
+            execute: title => title?.owner && this.shell.toggleMaximized(title?.owner),
+        }));
 
         commandRegistry.registerCommand(CommonCommands.SAVE, {
             execute: () => this.shell.save({ formatType: FormatType.ON })
@@ -823,63 +823,6 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         });
     }
 
-    private findTabArea(event?: Event): ApplicationShell.Area | undefined {
-        const tabBar = this.shell.findTabBar(event);
-        if (tabBar) {
-            return this.shell.getAreaFor(tabBar);
-        }
-        return this.shell.currentTabArea;
-    }
-
-    /**
-     * Finds the index of the selected title from the tab-bar.
-     * @param tabBar: used for providing an array of titles.
-     * @returns the index of the selected title if it is available in the tab-bar, else returns the index of currently-selected title.
-     */
-    private findTitleIndex(tabBar: TabBar<Widget>, event?: Event): number {
-        if (event) {
-            const targetTitle = this.shell.findTitle(tabBar, event);
-            return targetTitle ? tabBar.titles.indexOf(targetTitle) : tabBar.currentIndex;
-        }
-        return tabBar.currentIndex;
-    }
-
-    private canToggleMaximized(event?: Event): boolean {
-        if (event?.target instanceof HTMLElement) {
-            const widget = this.shell.findWidgetForElement(event.target);
-            if (widget) {
-                return this.shell.mainPanel.contains(widget) || this.shell.bottomPanel.contains(widget);
-            }
-        }
-        return this.shell.canToggleMaximized();
-    }
-
-    /**
-     * Maximize the bottom or the main dockpanel based on the widget.
-     * @param event used to find the selected widget.
-     */
-    private toggleMaximized(event?: Event): void {
-        if (event?.target instanceof HTMLElement) {
-            const widget = this.shell.findWidgetForElement(event.target);
-            if (widget) {
-                if (this.shell.mainPanel.contains(widget)) {
-                    this.shell.mainPanel.toggleMaximized();
-                } else if (this.shell.bottomPanel.contains(widget)) {
-                    this.shell.bottomPanel.toggleMaximized();
-                }
-                if (widget instanceof TabBar) {
-                    // reveals the widget when maximized.
-                    const title = this.shell.findTitle(widget, event);
-                    if (title) {
-                        this.shell.revealWidget(title.owner.id);
-                    }
-                }
-            }
-        } else {
-            this.shell.toggleMaximized();
-        }
-    }
-
     private isElectron(): boolean {
         return environment.electron.is();
     }

package/src/browser/frontend-application-module.ts

@@ -165,11 +165,12 @@ export const frontendApplicationModule = new ContainerModule((bind, unbind, isBo
 
     bind(DockPanelRendererFactory).toFactory(context => () => context.container.get(DockPanelRenderer));
     bind(DockPanelRenderer).toSelf();
-    bind(TabBarRendererFactory).toFactory(context => () => {
-        const contextMenuRenderer = context.container.get<ContextMenuRenderer>(ContextMenuRenderer);
-        const decoratorService = context.container.get<TabBarDecoratorService>(TabBarDecoratorService);
-        const iconThemeService = context.container.get<IconThemeService>(IconThemeService);
-        return new TabBarRenderer(contextMenuRenderer, decoratorService, iconThemeService);
+    bind(TabBarRendererFactory).toFactory(({ container }) => () => {
+        const contextMenuRenderer = container.get(ContextMenuRenderer);
+        const tabBarDecoratorService = container.get(TabBarDecoratorService);
+        const iconThemeService = container.get(IconThemeService);
+        const selectionService = container.get(SelectionService);
+        return new TabBarRenderer(contextMenuRenderer, tabBarDecoratorService, iconThemeService, selectionService);
     });
 
     bindContributionProvider(bind, TabBarDecorator);

package/src/browser/preferences/preference-provider.ts

@@ -75,10 +75,6 @@ export abstract class PreferenceProvider implements Disposable {
     }
 
     protected deferredChanges: PreferenceProviderDataChanges | undefined;
-    protected _pendingChanges: Promise<boolean> = Promise.resolve(false);
-    get pendingChanges(): Promise<boolean> {
-        return this._pendingChanges;
-    }
 
     /**
      * Informs the listeners that one or more preferences of this provider are changed.
@@ -94,7 +90,7 @@ export abstract class PreferenceProvider implements Disposable {
                 this.mergePreferenceProviderDataChange(changes[preferenceName]);
             }
         }
-        return this._pendingChanges = this.fireDidPreferencesChanged();
+        return this.fireDidPreferencesChanged();
     }
 
     protected mergePreferenceProviderDataChange(change: PreferenceProviderDataChange): void {

package/src/browser/preferences/preference-service.spec.ts

@@ -193,7 +193,6 @@ describe('Preference Service', () => {
         assert.strictEqual(prefService.get('editor.insertSpaces'), undefined, 'get after');
         assert.strictEqual(prefService.get('[go].editor.insertSpaces'), undefined, 'get after overridden');
 
-        assert.strictEqual(await prefSchema.pendingChanges, false);
         assert.deepStrictEqual([], events.map(e => ({
             preferenceName: e.preferenceName,
             newValue: e.newValue,
@@ -488,7 +487,6 @@ describe('Preference Service', () => {
 
         it('onPreferenceChanged #0', async () => {
             const { preferences, schema } = prepareServices();
-            await schema.pendingChanges;
 
             const events: PreferenceChange[] = [];
             preferences.onPreferenceChanged(event => events.push(event));
@@ -511,7 +509,6 @@ describe('Preference Service', () => {
 
         it('onPreferenceChanged #1', async () => {
             const { preferences, schema } = prepareServices();
-            await schema.pendingChanges;
 
             const events: PreferenceChange[] = [];
             preferences.onPreferenceChanged(event => events.push(event));

package/src/browser/shell/application-shell.ts

@@ -29,10 +29,10 @@ import { Saveable, SaveableWidget, SaveOptions } from '../saveable';
 import { StatusBarImpl, StatusBarEntry, StatusBarAlignment } from '../status-bar/status-bar';
 import { TheiaDockPanel, BOTTOM_AREA_ID, MAIN_AREA_ID } from './theia-dock-panel';
 import { SidePanelHandler, SidePanel, SidePanelHandlerFactory } from './side-panel-handler';
-import { TabBarRendererFactory, TabBarRenderer, SHELL_TABBAR_CONTEXT_MENU, ScrollableTabBar, ToolbarAwareTabBar } from './tab-bars';
+import { TabBarRendererFactory, SHELL_TABBAR_CONTEXT_MENU, ScrollableTabBar, ToolbarAwareTabBar } from './tab-bars';
 import { SplitPositionHandler, SplitPositionOptions } from './split-panels';
 import { FrontendApplicationStateService } from '../frontend-application-state';
-import { TabBarToolbarRegistry, TabBarToolbarFactory, TabBarToolbar } from './tab-bar-toolbar';
+import { TabBarToolbarRegistry, TabBarToolbarFactory } from './tab-bar-toolbar';
 import { ContextKeyService } from '../context-key-service';
 import { Emitter } from '../../common/event';
 import { waitForRevealed, waitForClosed } from '../widgets';
@@ -82,9 +82,9 @@ export class DockPanelRenderer implements DockLayout.IRenderer {
     readonly tabBarClasses: string[] = [];
 
     constructor(
-        @inject(TabBarRendererFactory) protected readonly tabBarRendererFactory: () => TabBarRenderer,
+        @inject(TabBarRendererFactory) protected readonly tabBarRendererFactory: TabBarRendererFactory,
         @inject(TabBarToolbarRegistry) protected readonly tabBarToolbarRegistry: TabBarToolbarRegistry,
-        @inject(TabBarToolbarFactory) protected readonly tabBarToolbarFactory: () => TabBarToolbar,
+        @inject(TabBarToolbarFactory) protected readonly tabBarToolbarFactory: TabBarToolbarFactory,
         @inject(BreadcrumbsRendererFactory) protected readonly breadcrumbsRendererFactory: BreadcrumbsRendererFactory,
     ) { }
 
@@ -847,20 +847,15 @@ export class ApplicationShell extends Widget {
      */
     findTitle(tabBar: TabBar<Widget>, event?: Event): Title<Widget> | undefined {
         if (event?.target instanceof HTMLElement) {
-            let tabNode: HTMLElement | null = event.target;
-            while (tabNode && !tabNode.classList.contains('p-TabBar-tab')) {
-                tabNode = tabNode.parentElement;
-            }
-            if (tabNode && tabNode.title) {
-                let title = tabBar.titles.find(t => t.caption === tabNode!.title);
-                if (title) {
-                    return title;
-                }
-                title = tabBar.titles.find(t => t.label === tabNode!.title);
-                if (title) {
-                    return title;
-                }
+            const tabNode = event.target;
+
+            const titleIndex = Array.from(tabBar.contentNode.getElementsByClassName('p-TabBar-tab'))
+                .findIndex(node => node.contains(tabNode));
+
+            if (titleIndex !== -1) {
+                return tabBar.titles[titleIndex];
             }
+
         }
         return tabBar.currentTitle || undefined;
     }
@@ -1832,18 +1827,18 @@ export class ApplicationShell extends Widget {
         return undefined;
     }
 
-    canToggleMaximized(): boolean {
-        const area = this.currentWidget && this.getAreaFor(this.currentWidget);
+    canToggleMaximized(widget: Widget | undefined = this.currentWidget): boolean {
+        const area = widget && this.getAreaFor(widget);
         return area === 'main' || area === 'bottom';
     }
 
-    toggleMaximized(): void {
-        const area = this.currentWidget && this.getAreaPanelFor(this.currentWidget);
+    toggleMaximized(widget: Widget | undefined = this.currentWidget): void {
+        const area = widget && this.getAreaPanelFor(widget);
         if (area instanceof TheiaDockPanel && (area === this.mainPanel || area === this.bottomPanel)) {
             area.toggleMaximized();
+            this.revealWidget(widget!.id);
         }
     }
-
 }
 
 /**

package/src/browser/shell/current-widget-command-adapter.ts

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * Copyright (C) 2021 Ericsson 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 { CommandHandler } from '../../common';
+import { TabBar, Title, Widget } from '../widgets';
+import { ApplicationShell } from './application-shell';
+
+type CurrentWidgetCommandAdapterBooleanCheck = (event: Event) => boolean;
+type CurrentWidgetCommandHandlerBooleanCheck = (title: Title<Widget> | undefined, tabbar: TabBar<Widget> | undefined, event: Event) => boolean;
+
+export interface TabBarContextMenuCommandHandler extends CommandHandler {
+    execute(title: Title<Widget> | undefined, tabbar: TabBar<Widget> | undefined, event: Event): unknown;
+    isEnabled?: CurrentWidgetCommandHandlerBooleanCheck;
+    isVisible?: CurrentWidgetCommandHandlerBooleanCheck;
+    isToggled?: CurrentWidgetCommandHandlerBooleanCheck;
+}
+
+/**
+ * Creates a command handler that acts on either the widget targeted by a DOM event or the current widget.
+ */
+export class CurrentWidgetCommandAdapter implements CommandHandler {
+    execute: (event: Event) => unknown;
+    isEnabled?: CurrentWidgetCommandAdapterBooleanCheck;
+    isVisible?: CurrentWidgetCommandAdapterBooleanCheck;
+    isToggled?: CurrentWidgetCommandAdapterBooleanCheck;
+    constructor(shell: ApplicationShell, handler: TabBarContextMenuCommandHandler) {
+        this.execute = (event: Event) => handler.execute(...this.transformArguments(shell, event));
+        if (handler.isEnabled) {
+            this.isEnabled = (event: Event) => !!handler.isEnabled?.(...this.transformArguments(shell, event));
+        }
+        if (handler.isVisible) {
+            this.isVisible = (event: Event) => !!handler.isVisible?.(...this.transformArguments(shell, event));
+        }
+        if (handler.isToggled) {
+            this.isToggled = (event: Event) => !!handler.isToggled?.(...this.transformArguments(shell, event));
+        }
+    }
+
+    protected transformArguments(shell: ApplicationShell, event: Event): [Title<Widget> | undefined, TabBar<Widget> | undefined, Event] {
+        const tabBar = shell.findTabBar(event);
+        const title = tabBar && shell.findTitle(tabBar, event);
+        return [title, tabBar, event];
+    }
+}

package/src/browser/shell/tab-bars.ts

@@ -17,7 +17,7 @@
 import PerfectScrollbar from 'perfect-scrollbar';
 import { TabBar, Title, Widget } from '@phosphor/widgets';
 import { VirtualElement, h, VirtualDOM, ElementInlineStyle } from '@phosphor/virtualdom';
-import { Disposable, DisposableCollection, MenuPath, notEmpty } from '../../common';
+import { Disposable, DisposableCollection, MenuPath, notEmpty, SelectionService } from '../../common';
 import { ContextMenuRenderer } from '../context-menu-renderer';
 import { Signal, Slot } from '@phosphor/signaling';
 import { Message, MessageLoop } from '@phosphor/messaging';
@@ -37,8 +37,14 @@ const HIDDEN_CONTENT_CLASS = 'theia-TabBar-hidden-content';
 
 /** Menu path for tab bars used throughout the application shell. */
 export const SHELL_TABBAR_CONTEXT_MENU: MenuPath = ['shell-tabbar-context-menu'];
+export const SHELL_TABBAR_CONTEXT_CLOSE: MenuPath = [...SHELL_TABBAR_CONTEXT_MENU, '0_close'];
+export const SHELL_TABBAR_CONTEXT_COPY: MenuPath = [...SHELL_TABBAR_CONTEXT_MENU, '1_copy'];
+// Kept here in anticipation of tab pinning behavior implemented in tab-bars.ts
+export const SHELL_TABBAR_CONTEXT_PIN: MenuPath = [...SHELL_TABBAR_CONTEXT_MENU, '4_pin'];
+export const SHELL_TABBAR_CONTEXT_SPLIT: MenuPath = [...SHELL_TABBAR_CONTEXT_MENU, '5_split'];
 
 export const TabBarRendererFactory = Symbol('TabBarRendererFactory');
+export type TabBarRendererFactory = () => TabBarRenderer;
 
 /**
  * Size information of DOM elements used for rendering tabs in side bars.
@@ -66,7 +72,6 @@ export interface SideBarRenderData extends TabBar.IRenderData<Widget> {
  * automatically.
  */
 export class TabBarRenderer extends TabBar.Renderer {
-
     /**
      * The menu path used to render the context menu.
      */
@@ -80,7 +85,8 @@ export class TabBarRenderer extends TabBar.Renderer {
     constructor(
         protected readonly contextMenuRenderer?: ContextMenuRenderer,
         protected readonly decoratorService?: TabBarDecoratorService,
-        protected readonly iconThemeService?: IconThemeService
+        protected readonly iconThemeService?: IconThemeService,
+        protected readonly selectionService?: SelectionService,
     ) {
         super();
         if (this.decoratorService) {
@@ -437,7 +443,27 @@ export class TabBarRenderer extends TabBar.Renderer {
         if (this.contextMenuRenderer && this.contextMenuPath && event.currentTarget instanceof HTMLElement) {
             event.stopPropagation();
             event.preventDefault();
-            this.contextMenuRenderer.render(this.contextMenuPath, event);
+            let widget: Widget | undefined = undefined;
+            if (this.tabBar) {
+                const titleIndex = Array.from(this.tabBar.contentNode.getElementsByClassName('p-TabBar-tab'))
+                    .findIndex(node => node.contains(event.currentTarget as HTMLElement));
+                if (titleIndex !== -1) {
+                    widget = this.tabBar.titles[titleIndex].owner;
+                }
+            }
+
+            const oldSelection = this.selectionService?.selection;
+            if (widget && this.selectionService) {
+                this.selectionService.selection = NavigatableWidget.is(widget) ? { uri: widget.getResourceUri() } : widget;
+            }
+
+            this.contextMenuRenderer.render({
+                menuPath: this.contextMenuPath!,
+                anchor: event,
+                args: [event],
+                // We'd like to wait until the command triggered by the context menu has been run, but this should let it get through the preamble, at least.
+                onHide: () => setTimeout(() => { if (this.selectionService) { this.selectionService.selection = oldSelection; } })
+            });
         }
     };
 
@@ -452,7 +478,6 @@ export class TabBarRenderer extends TabBar.Renderer {
             }
         }
     };
-
 }
 
 /**

package/src/common/promise-util.spec.ts

@@ -0,0 +1,41 @@
+/********************************************************************************
+ * Copyright (C) 2021 Red Hat 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 * as assert from 'assert';
+import { waitForEvent } from './promise-util';
+import { Emitter } from './event';
+
+describe('promise-util', () => {
+    it('should time out', async () => {
+        const emitter = new Emitter<string>();
+        try {
+            await waitForEvent(emitter.event, 1000);
+            assert.fail('did not time out');
+        } catch (e) {
+            // OK
+        }
+    });
+
+    describe('promise-util', () => {
+        it('should get event', async () => {
+            const emitter = new Emitter<string>();
+            setTimeout(() => {
+                emitter.fire('abcd');
+            }, 500);
+            assert.strictEqual(await waitForEvent(emitter.event, 1000), 'abcd');
+        });
+    });
+
+});

package/src/common/promise-util.ts

@@ -14,7 +14,9 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { CancellationToken, cancelled } from './cancellation';
+import { Disposable } from './disposable';
+import { Event } from './event';
+import { CancellationToken, CancellationError, cancelled } from './cancellation';
 
 /**
  * Simple implementation of the deferred pattern.
@@ -90,3 +92,20 @@ export function delay<T>(ms: number): (value: T) => Promise<T> {
 export async function wait(ms: number): Promise<void> {
     await delay(ms)(undefined);
 }
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function waitForEvent<T>(event: Event<T>, ms: number, thisArg?: any, disposables?: Disposable[]): Promise<T> {
+    return new Promise<T>((resolve, reject) => {
+        const registration = setTimeout(() => {
+            listener.dispose();
+            reject(new CancellationError());
+        }, ms);
+
+        const listener = event((evt: T) => {
+            clearTimeout(registration);
+            listener.dispose();
+            resolve(evt);
+        }, thisArg, disposables);
+
+    });
+}