@theia/core 1.18.0 → 1.21.0-next.12

package/src/browser/menu/browser-menu-plugin.ts

@@ -18,7 +18,7 @@ import { injectable, inject } from 'inversify';
 import { MenuBar, Menu as MenuWidget, Widget } from '@phosphor/widgets';
 import { CommandRegistry as PhosphorCommandRegistry } from '@phosphor/commands';
 import {
-    CommandRegistry, ActionMenuNode, CompositeMenuNode,
+    CommandRegistry, ActionMenuNode, CompositeMenuNode, environment,
     MenuModelRegistry, MAIN_MENU_BAR, MenuPath, DisposableCollection, Disposable, MenuNode
 } from '../../common';
 import { KeybindingRegistry } from '../keybinding';
@@ -28,6 +28,7 @@ import { ContextMenuContext } from './context-menu-context';
 import { waitForRevealed } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { CorePreferences } from '../core-preferences';
+import { PreferenceService } from '../preferences/preference-service';
 
 export abstract class MenuBarWidget extends MenuBar {
     abstract activateMenu(label: string, ...labels: string[]): Promise<MenuWidget>;
@@ -371,21 +372,40 @@ export class BrowserMenuBarContribution implements FrontendApplicationContributi
     @inject(ApplicationShell)
     protected readonly shell: ApplicationShell;
 
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
     constructor(
         @inject(BrowserMainMenuFactory) protected readonly factory: BrowserMainMenuFactory
     ) { }
 
     onStart(app: FrontendApplication): void {
-        const logo = this.createLogo();
-        app.shell.addWidget(logo, { area: 'top' });
-        const menu = this.factory.createMenuBar();
-        app.shell.addWidget(menu, { area: 'top' });
+        this.appendMenu(app.shell);
     }
 
     get menuBar(): MenuBarWidget | undefined {
         return this.shell.topPanel.widgets.find(w => w instanceof MenuBarWidget) as MenuBarWidget | undefined;
     }
 
+    protected appendMenu(shell: ApplicationShell): void {
+        const logo = this.createLogo();
+        shell.addWidget(logo, { area: 'top' });
+        const menu = this.factory.createMenuBar();
+        shell.addWidget(menu, { area: 'top' });
+        // Hiding the menu is only necessary in electron
+        // In the browser we hide the whole top panel
+        if (environment.electron.is()) {
+            this.preferenceService.ready.then(() => {
+                menu.setHidden(['compact', 'hidden'].includes(this.preferenceService.get('window.menuBarVisibility', '')));
+            });
+            this.preferenceService.onPreferenceChanged(change => {
+                if (change.preferenceName === 'window.menuBarVisibility') {
+                    menu.setHidden(['compact', 'hidden'].includes(change.newValue));
+                }
+            });
+        }
+    }
+
     protected createLogo(): Widget {
         const logo = new Widget();
         logo.id = 'theia:icon';

package/src/browser/messaging/ws-connection-provider.ts

@@ -59,13 +59,19 @@ export const DEFAULT_HTTP_FALLBACK_OPTIONS: HttpFallbackOptions = {
 export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebSocketOptions> {
 
     protected readonly onSocketDidOpenEmitter: Emitter<void> = new Emitter();
-    readonly onSocketDidOpen: Event<void> = this.onSocketDidOpenEmitter.event;
+    get onSocketDidOpen(): Event<void> {
+        return this.onSocketDidOpenEmitter.event;
+    }
 
     protected readonly onSocketDidCloseEmitter: Emitter<void> = new Emitter();
-    readonly onSocketDidClose: Event<void> = this.onSocketDidCloseEmitter.event;
+    get onSocketDidClose(): Event<void> {
+        return this.onSocketDidCloseEmitter.event;
+    }
 
     protected readonly onHttpFallbackDidActivateEmitter: Emitter<void> = new Emitter();
-    readonly onHttpFallbackDidActivate: Event<void> = this.onHttpFallbackDidActivateEmitter.event;
+    get onHttpFallbackDidActivate(): Event<void> {
+        return this.onHttpFallbackDidActivateEmitter.event;
+    }
 
     static createProxy<T extends object>(container: interfaces.Container, path: string, arg?: object): JsonRpcProxy<T> {
         return container.get(WebSocketConnectionProvider).createProxy<T>(path, arg);
@@ -98,7 +104,6 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
             this.fireSocketDidClose();
         };
         socket.onmessage = ({ data }) => {
-            this.websocketErrorCounter = 0;
             this.handleIncomingRawMessage(data);
         };
         this.socket = socket;
@@ -218,6 +223,10 @@ export class WebSocketConnectionProvider extends AbstractConnectionProvider<WebS
     }
 
     protected fireSocketDidOpen(): void {
+        // Once a websocket connection has opened, disable the http fallback
+        if (this.httpFallbackOptions?.allowed) {
+            this.httpFallbackOptions.allowed = false;
+        }
         this.onSocketDidOpenEmitter.fire(undefined);
     }
 

package/src/browser/nls-loader.ts

@@ -0,0 +1,26 @@
+/********************************************************************************
+ * Copyright (C) 2021 TypeFox 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 { nls } from '../common/nls';
+import { Endpoint } from './endpoint';
+
+export async function loadTranslations(): Promise<void> {
+    if (nls.locale) {
+        const endpoint = new Endpoint({ path: '/i18n/' + nls.locale }).getRestUrl().toString();
+        const response = await fetch(endpoint);
+        nls.localization = await response.json();
+    }
+}

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/progress-status-bar-item.ts

@@ -16,8 +16,7 @@
 
 import { injectable, inject } from 'inversify';
 import { CancellationToken } from 'vscode-ws-jsonrpc';
-import { ProgressClient } from '../common';
-import { ProgressMessage, ProgressUpdate } from '../common';
+import { ProgressClient, ProgressMessage, ProgressUpdate } from '../common';
 import { StatusBar, StatusBarAlignment } from './status-bar';
 import { Deferred } from '../common/promise-util';
 import throttle = require('lodash.throttle');

package/src/browser/quick-input/quick-command-frontend-contribution.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { injectable, inject, optional } from 'inversify';
-import { CommandRegistry, CommandContribution, MenuContribution, MenuModelRegistry } from '../../common';
+import { CommandRegistry, CommandContribution, MenuContribution, MenuModelRegistry, nls } from '../../common';
 import { KeybindingRegistry, KeybindingContribution } from '../keybinding';
 import { CommonMenus } from '../common-frontend-contribution';
 import { CLEAR_COMMAND_HISTORY, quickCommand, QuickCommandService } from './quick-command-service';
@@ -43,7 +43,7 @@ export class QuickCommandFrontendContribution implements CommandContribution, Ke
     registerMenus(menus: MenuModelRegistry): void {
         menus.registerMenuAction(CommonMenus.VIEW_PRIMARY, {
             commandId: quickCommand.id,
-            label: 'Find Command...'
+            label: nls.localizeByDefault('Command Palette...')
         });
     }
 

package/src/browser/quick-input/quick-command-service.ts

@@ -28,10 +28,10 @@ export const quickCommand: Command = {
     id: 'workbench.action.showCommands'
 };
 
-export const CLEAR_COMMAND_HISTORY: Command = {
+export const CLEAR_COMMAND_HISTORY = Command.toDefaultLocalizedCommand({
     id: 'clear.command.history',
     label: 'Clear Command History'
-};
+});
 
 @injectable()
 export class QuickCommandService implements QuickAccessContribution, QuickAccessProvider {

package/src/browser/quick-input/quick-input-service.ts

@@ -14,281 +14,4 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { CancellationToken, Event } from '../../common';
-import URI from '../../common/uri';
-import { KeySequence } from '../keyboard';
-import * as fuzzy from 'fuzzy';
-
-export interface Match {
-    start: number;
-    end: number;
-}
-export interface QuickPickItemHighlights {
-    label?: Match[];
-    description?: Match[];
-    detail?: Match[];
-}
-
-export interface QuickPickItem {
-    type?: 'item' | 'separator';
-    id?: string;
-    label: string;
-    meta?: string;
-    ariaLabel?: string;
-    description?: string;
-    detail?: string;
-    keySequence?: KeySequence;
-    iconClasses?: string[];
-    alwaysShow?: boolean;
-    highlights?: QuickPickItemHighlights;
-    buttons?: QuickInputButton[];
-    execute?: () => void;
-}
-
-export namespace QuickPickItem {
-    export function is(item: QuickPickSeparator | QuickPickItem): item is QuickPickItem {
-        // if it's not a separator, it's an item
-        return item.type !== 'separator';
-    }
-}
-
-export interface QuickPickSeparator {
-    type: 'separator';
-    label?: string;
-}
-
-export namespace QuickPickSeparator {
-    export function is(item: QuickPickSeparator | QuickPickItem): item is QuickPickSeparator {
-        return item.type === 'separator';
-    }
-}
-
-export type QuickPicks = (QuickPickSeparator | QuickPickItem)[];
-
-export interface QuickPickValue<V> extends QuickPickItem {
-    value: V
-}
-
-export interface QuickInputButton {
-    iconPath?: URI | { light: URI; dark: URI } | { id: string };
-    iconClass?: string;
-    tooltip?: string;
-}
-
-export interface QuickInputButtonHandle extends QuickInputButton {
-    index: number; // index of where they are in buttons array if QuickInputButton or -1 if QuickInputButtons.Back
-}
-
-export interface QuickInput {
-    readonly onDidHide: Event<void>;
-    readonly onDispose: Event<void>;
-    title: string | undefined;
-    description: string | undefined;
-    step: number | undefined;
-    totalSteps: number | undefined;
-    enabled: boolean;
-    contextKey: string | undefined;
-    busy: boolean;
-    ignoreFocusOut: boolean;
-    show(): void;
-    hide(): void;
-    dispose(): void;
-}
-
-export interface InputBox extends QuickInput {
-    value: string | undefined;
-    valueSelection: Readonly<[number, number]> | undefined;
-    placeholder: string | undefined;
-    password: boolean;
-    readonly onDidChangeValue: Event<string>;
-    readonly onDidAccept: Event<void>;
-    buttons: ReadonlyArray<QuickInputButton>;
-    readonly onDidTriggerButton: Event<QuickInputButton>;
-    prompt: string | undefined;
-    validationMessage: string | undefined;
-}
-
-export interface QuickPick<T extends QuickPickItem> extends QuickInput {
-    value: string;
-    placeholder: string | undefined;
-    items: ReadonlyArray<T | QuickPickSeparator>;
-    activeItems: ReadonlyArray<T>;
-    selectedItems: ReadonlyArray<T>;
-    canSelectMany: boolean;
-    matchOnDescription: boolean;
-    matchOnDetail: boolean;
-    readonly onDidAccept: Event<void>;
-    readonly onDidChangeValue: Event<string>;
-    readonly onDidTriggerButton: Event<QuickInputButton>;
-    readonly onDidTriggerItemButton: Event<QuickPickItemButtonEvent<T>>;
-    readonly onDidChangeActive: Event<T[]>;
-    readonly onDidChangeSelection: Event<T[]>;
-}
-
-export interface PickOptions<T extends QuickPickItem> {
-    placeHolder?: string;
-    matchOnDescription?: boolean;
-    matchOnDetail?: boolean;
-    matchOnLabel?: boolean;
-    autoFocusOnList?: boolean;
-    ignoreFocusLost?: boolean;
-    canPickMany?: boolean;
-    contextKey?: string;
-    activeItem?: Promise<T> | T;
-    onDidFocus?: (entry: T) => void;
-}
-
-export interface InputOptions {
-    value?: string;
-    valueSelection?: [number, number];
-    prompt?: string;
-    placeHolder?: string;
-    password?: boolean;
-    ignoreFocusLost?: boolean;
-    validateInput?(input: string): Promise<string | null | undefined> | undefined;
-}
-
-export interface QuickPickItemButtonEvent<T extends QuickPickItem> {
-    button: QuickInputButton;
-    item: T;
-}
-
-export interface QuickPickOptions<T extends QuickPickItem> {
-    busy?: boolean;
-    enabled?: boolean;
-    title?: string;
-    description?: string;
-    value?: string;
-    filterValue?: (value: string) => string;
-    ariaLabel?: string;
-    buttons?: Array<QuickInputButton>;
-    placeholder?: string;
-    canAcceptInBackground?: boolean;
-    customButton?: boolean;
-    customLabel?: string;
-    customHover?: string;
-    canSelectMany?: boolean;
-    matchOnDescription?: boolean;
-    matchOnDetail?: boolean;
-    matchOnLabel?: boolean;
-    sortByLabel?: boolean;
-    autoFocusOnList?: boolean;
-    ignoreFocusOut?: boolean;
-    valueSelection?: Readonly<[number, number]>;
-    validationMessage?: string;
-    hideInput?: boolean;
-    hideCheckAll?: boolean;
-    runIfSingle?: boolean
-    contextKey?: string;
-    activeItem?: T,
-    step?: number;
-    totalSteps?: number;
-
-    onDidAccept?: () => void,
-    onDidChangeActive?: (quickPick: QuickPick<T>, activeItems: Array<T>) => void,
-    onDidChangeSelection?: (quickPick: QuickPick<T>, selectedItems: Array<T>) => void,
-    onDidChangeValue?: (quickPick: QuickPick<T>, filter: string) => void,
-    onDidCustom?: () => void,
-    onDidHide?: () => void;
-    onDidTriggerButton?: (button: QuickInputButton) => void,
-    onDidTriggerItemButton?: (ItemButtonEvent: QuickPickItemButtonEvent<T>) => void
-}
-
-export const QuickInputService = Symbol('QuickInputService');
-export interface QuickInputService {
-    readonly backButton: QuickInputButton;
-    readonly onShow: Event<void>;
-    readonly onHide: Event<void>;
-    open(filter: string): void;
-    createInputBox(): InputBox;
-    input(options?: InputOptions, token?: CancellationToken): Promise<string | undefined>;
-    pick<T extends QuickPickItem, O extends PickOptions<T>>(picks: Promise<T[]> | T[], options?: O, token?: CancellationToken):
-        Promise<(O extends { canPickMany: true } ? T[] : T) | undefined>;
-    showQuickPick<T extends QuickPickItem>(items: Array<T>, options?: QuickPickOptions<T>): Promise<T>;
-    hide(): void;
-    /**
-     * Provides raw access to the quick pick controller.
-     */
-    createQuickPick<T extends QuickPickItem>(): QuickPick<T>;
-}
-
-/**
- * Filter the list of quick pick items based on the provided filter.
- * Items are filtered based on if:
- * - their `label` satisfies the filter using `fuzzy`.
- * - their `description` satisfies the filter using `fuzzy`.
- * - their `detail` satisfies the filter using `fuzzy`.
- * Filtered items are also updated to display proper highlights based on how they were filtered.
- * @param items the list of quick pick items.
- * @param filter the filter to search for.
- * @returns the list of quick pick items that satisfy the filter.
- */
-export function filterItems(items: QuickPickItem[], filter: string): QuickPickItem[] {
-    filter = filter.trim().toLowerCase();
-
-    if (filter.length === 0) {
-        for (const item of items) {
-            item.highlights = undefined; // reset highlights from previous filtering.
-        }
-        return items;
-    }
-
-    const filteredItems: QuickPickItem[] = [];
-    for (const item of items) {
-        if (
-            fuzzy.test(filter, item.label) ||
-            (item.description && fuzzy.test(filter, item.description)) ||
-            (item.detail && fuzzy.test(filter, item.detail))
-        ) {
-            item.highlights = {
-                label: findMatches(item.label, filter),
-                description: item.description ? findMatches(item.description, filter) : undefined,
-                detail: item.detail ? findMatches(item.detail, filter) : undefined
-            };
-            filteredItems.push(item);
-        }
-    }
-    return filteredItems;
-}
-
-/**
- * Find match highlights when testing a word against a pattern.
- * @param word the word to test.
- * @param pattern the word to match against.
- * @returns the list of highlights if present.
- */
-export function findMatches(word: string, pattern: string): Array<{ start: number, end: number }> | undefined {
-    word = word.toLocaleLowerCase();
-    pattern = pattern.toLocaleLowerCase();
-
-    if (pattern.trim().length === 0) {
-        return undefined;
-    }
-
-    const delimiter = '\u0000'; // null byte that shouldn't appear in the input and is used to denote matches.
-    const matchResult = fuzzy.match(pattern.replace(/\u0000/gu, ''), word, { pre: delimiter, post: delimiter });
-    if (!matchResult) {
-        return undefined;
-    }
-
-    const match = matchResult.rendered;
-    const highlights: { start: number, end: number }[] = [];
-
-    let lastIndex = 0;
-    /** We need to account for the extra markers by removing them from the range */
-    let offset = 0;
-
-    while (true) {
-        const start = match.indexOf(delimiter, lastIndex);
-        if (start === -1) { break; }
-        const end = match.indexOf(delimiter, start + 1);
-        if (end === -1) { break; }
-        highlights.push({
-            start: start - offset++,
-            end: end - offset++
-        });
-        lastIndex = end + 1;
-    }
-
-    return highlights.length > 0 ? highlights : undefined;
-}
+export * from '../../common/quick-pick-service';

package/src/browser/quick-input/quick-view-service.ts

@@ -18,8 +18,7 @@ import { inject, injectable } from 'inversify';
 import { filterItems, QuickPickItem, QuickPicks } from '..';
 import { CancellationToken, Disposable } from '../../common';
 import { ContextKeyService } from '../context-key-service';
-import { QuickAccessProvider, QuickAccessRegistry } from './quick-access';
-import { QuickAccessContribution } from './quick-access';
+import { QuickAccessContribution, QuickAccessProvider, QuickAccessRegistry } from './quick-access';
 
 export interface QuickViewItem {
     readonly label: string;

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

@@ -23,21 +23,20 @@ import {
 } from '@phosphor/widgets';
 import { Message } from '@phosphor/messaging';
 import { IDragEvent } from '@phosphor/dragdrop';
-import { RecursivePartial, Event as CommonEvent, DisposableCollection, Disposable } from '../../common';
+import { RecursivePartial, Event as CommonEvent, DisposableCollection, Disposable, environment } from '../../common';
 import { animationFrame } from '../browser';
 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';
 import { CorePreferences } from '../core-preferences';
-import { environment } from '../../common';
 import { BreadcrumbsRendererFactory } from '../breadcrumbs/breadcrumbs-renderer';
 
 /** The class name added to ApplicationShell instances. */
@@ -59,7 +58,9 @@ export type ApplicationShellLayoutVersion =
     /** git history view is replaced by a more generic scm history view, backward compatible to 3.0 */
     4.0 |
     /** Replace custom/font-awesome icons with codicons */
-    5.0;
+    5.0 |
+    /** added the ability to drag and drop view parts between view containers */
+    6.0;
 
 /**
  * When a version is increased, make sure to introduce a migration (ApplicationShellLayoutMigration) to this version.
@@ -81,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,
     ) { }
 
@@ -846,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;
     }
@@ -1831,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];
+    }
+}