@theia/core 1.46.0-next.106 → 1.46.0-next.144

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

@@ -44,6 +44,7 @@ import { SecondaryWindowHandler } from '../secondary-window-handler';
 import URI from '../../common/uri';
 import { OpenerService } from '../opener-service';
 import { PreviewableWidget } from '../widgets/previewable-widget';
+import { WindowService } from '../window/window-service';
 
 /** The class name added to ApplicationShell instances. */
 const APPLICATION_SHELL_CLASS = 'theia-ApplicationShell';
@@ -273,6 +274,7 @@ export class ApplicationShell extends Widget {
         @inject(CorePreferences) protected readonly corePreferences: CorePreferences,
         @inject(SaveResourceService) protected readonly saveResourceService: SaveResourceService,
         @inject(SecondaryWindowHandler) protected readonly secondaryWindowHandler: SecondaryWindowHandler,
+        @inject(WindowService) protected readonly windowService: WindowService
     ) {
         super(options as Widget.IOptions);
 
@@ -338,8 +340,8 @@ export class ApplicationShell extends Widget {
         this.rightPanelHandler.dockPanel.widgetRemoved.connect((_, widget) => this.fireDidRemoveWidget(widget));
 
         this.secondaryWindowHandler.init(this);
-        this.secondaryWindowHandler.onDidAddWidget(widget => this.fireDidAddWidget(widget));
-        this.secondaryWindowHandler.onDidRemoveWidget(widget => this.fireDidRemoveWidget(widget));
+        this.secondaryWindowHandler.onDidAddWidget(([widget, window]) => this.fireDidAddWidget(widget));
+        this.secondaryWindowHandler.onDidRemoveWidget(([widget, window]) => this.fireDidRemoveWidget(widget));
 
         this.layout = this.createLayout();
 
@@ -1323,20 +1325,23 @@ export class ApplicationShell extends Widget {
         let widget = find(this.mainPanel.widgets(), w => w.id === id);
         if (widget) {
             this.mainPanel.activateWidget(widget);
-            return widget;
         }
-        widget = find(this.bottomPanel.widgets(), w => w.id === id);
-        if (widget) {
-            this.expandBottomPanel();
-            this.bottomPanel.activateWidget(widget);
-            return widget;
+        if (!widget) {
+            widget = find(this.bottomPanel.widgets(), w => w.id === id);
+            if (widget) {
+                this.expandBottomPanel();
+                this.bottomPanel.activateWidget(widget);
+            }
         }
-        widget = this.leftPanelHandler.activate(id);
-        if (widget) {
-            return widget;
+        if (!widget) {
+            widget = this.leftPanelHandler.activate(id);
+        }
+
+        if (!widget) {
+            widget = this.rightPanelHandler.activate(id);
         }
-        widget = this.rightPanelHandler.activate(id);
         if (widget) {
+            this.windowService.focus();
             return widget;
         }
         return this.secondaryWindowHandler.activateWidget(id);
@@ -1433,17 +1438,19 @@ export class ApplicationShell extends Widget {
             if (tabBar) {
                 tabBar.currentTitle = widget.title;
             }
-            return widget;
         }
-        widget = this.leftPanelHandler.expand(id);
-        if (widget) {
-            return widget;
+        if (!widget) {
+            widget = this.leftPanelHandler.expand(id);
+        }
+        if (!widget) {
+            widget = this.rightPanelHandler.expand(id);
         }
-        widget = this.rightPanelHandler.expand(id);
         if (widget) {
+            this.windowService.focus();
             return widget;
+        } else {
+            return this.secondaryWindowHandler.revealWidget(id);
         }
-        return this.secondaryWindowHandler.revealWidget(id);
     }
 
     /**

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.tsx

@@ -70,11 +70,11 @@ export class TabBarToolbar extends ReactWidget {
 
     @postConstruct()
     protected init(): void {
-        this.toDispose.push(this.keybindings.onKeybindingsChanged(() => this.update()));
+        this.toDispose.push(this.keybindings.onKeybindingsChanged(() => this.maybeUpdate()));
 
         this.toDispose.push(this.contextKeyService.onDidChange(e => {
             if (e.affects(this.keybindingContextKeys)) {
-                this.update();
+                this.maybeUpdate();
             }
         }));
     }
@@ -90,7 +90,7 @@ export class TabBarToolbar extends ReactWidget {
             if ('command' in item) {
                 this.commands.getAllHandlers(item.command).forEach(handler => {
                     if (handler.onDidChangeEnabled) {
-                        this.toDisposeOnUpdateItems.push(handler.onDidChangeEnabled(() => this.update()));
+                        this.toDisposeOnUpdateItems.push(handler.onDidChangeEnabled(() => this.maybeUpdate()));
                     }
                 });
             }
@@ -113,7 +113,7 @@ export class TabBarToolbar extends ReactWidget {
         } else {
             this.hide();
         }
-        this.update();
+        this.maybeUpdate();
     }
 
     updateTarget(current?: Widget): void {
@@ -130,7 +130,7 @@ export class TabBarToolbar extends ReactWidget {
         if (current) {
             const resetCurrent = () => {
                 this.setCurrent(undefined);
-                this.update();
+                this.maybeUpdate();
             };
             current.disposed.connect(resetCurrent);
             this.toDisposeOnSetCurrent.push(Disposable.create(() =>
@@ -144,7 +144,7 @@ export class TabBarToolbar extends ReactWidget {
         if (contextKeys.size > 0) {
             this.contextKeyListener = this.contextKeyService.onDidChange(event => {
                 if (event.affects(contextKeys)) {
-                    this.update();
+                    this.maybeUpdate();
                 }
             });
         }
@@ -321,8 +321,8 @@ export class TabBarToolbar extends ReactWidget {
     protected renderMenuItem(item: TabBarToolbarItem & MenuToolbarItem): React.ReactNode {
         const icon = typeof item.icon === 'function' ? item.icon() : item.icon ?? 'ellipsis';
         return <div key={item.id}
-                    className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}
-                    onClick={this.showPopupMenu.bind(this, item.menuPath)}>
+            className={TabBarToolbar.Styles.TAB_BAR_TOOLBAR_ITEM + ' enabled menu'}
+            onClick={this.showPopupMenu.bind(this, item.menuPath)}>
             <div id={item.id} className={codicon(icon, true)}
                 title={item.text} />
             <div className={codicon('chevron-down') + ' chevron'} />
@@ -397,9 +397,15 @@ export class TabBarToolbar extends ReactWidget {
         } else if (item.menuPath) {
             this.renderMoreContextMenu(this.toAnchor(e), item.menuPath);
         }
-        this.update();
+        this.maybeUpdate();
     };
 
+    protected maybeUpdate(): void {
+        if (!this.isDisposed) {
+            this.update();
+        }
+    }
+
     protected onMouseDownEvent = (e: React.MouseEvent<HTMLElement>) => {
         if (e.button === 0) {
             e.currentTarget.classList.add('active');
@@ -419,5 +425,4 @@ export namespace TabBarToolbar {
         export const TAB_BAR_TOOLBAR_ITEM = 'item';
 
     }
-
 }

package/src/browser/shell/view-contribution.ts

@@ -18,7 +18,7 @@ import { injectable, inject, interfaces, optional } from 'inversify';
 import { Widget } from '@phosphor/widgets';
 import {
     MenuModelRegistry, Command, CommandContribution,
-    MenuContribution, CommandRegistry
+    MenuContribution, CommandRegistry, nls
 } from '../../common';
 import { KeybindingContribution, KeybindingRegistry } from '../keybinding';
 import { WidgetManager } from '../widget-manager';
@@ -69,7 +69,8 @@ export abstract class AbstractViewContribution<T extends Widget> implements Comm
         if (options.toggleCommandId) {
             this.toggleCommand = {
                 id: options.toggleCommandId,
-                label: 'Toggle ' + this.viewLabel + ' View'
+                category: nls.localizeByDefault('View'),
+                label: nls.localizeByDefault('Toggle {0}', this.viewLabel)
             };
         }
     }

package/src/browser/styling-service.ts

@@ -21,7 +21,7 @@ import { ColorRegistry } from './color-registry';
 import { DecorationStyle } from './decoration-style';
 import { FrontendApplicationContribution } from './frontend-application-contribution';
 import { ThemeService } from './theming';
-import { Disposable } from '../common';
+import { SecondaryWindowHandler } from './secondary-window-handler';
 
 export const StylingParticipant = Symbol('StylingParticipant');
 
@@ -52,16 +52,25 @@ export class StylingService implements FrontendApplicationContribution {
     @inject(ContributionProvider) @named(StylingParticipant)
     protected readonly themingParticipants: ContributionProvider<StylingParticipant>;
 
+    @inject(SecondaryWindowHandler)
+    protected readonly secondaryWindowHandler: SecondaryWindowHandler;
+
     onStart(): void {
         this.registerWindow(window);
+        this.secondaryWindowHandler.onWillAddWidget(([widget, window]) => {
+            this.registerWindow(window);
+        });
+        this.secondaryWindowHandler.onWillRemoveWidget(([widget, window]) => {
+            this.cssElements.delete(window);
+        });
+
         this.themeService.onDidColorThemeChange(e => this.applyStylingToWindows(e.newTheme));
     }
 
-    registerWindow(win: Window): Disposable {
+    registerWindow(win: Window): void {
         const cssElement = DecorationStyle.createStyleElement('contributedColorTheme', win.document.head);
         this.cssElements.set(win, cssElement);
         this.applyStyling(this.themeService.getCurrentTheme(), cssElement);
-        return Disposable.create(() => this.cssElements.delete(win));
     }
 
     protected applyStylingToWindows(theme: Theme): void {

package/src/browser/window/default-secondary-window-service.ts

@@ -82,37 +82,14 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     }
 
     createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined {
-        const win = this.doCreateSecondaryWindow(widget, shell);
-        if (win) {
-            this.secondaryWindows.push(win);
-            win.addEventListener('close', () => {
-                const extIndex = this.secondaryWindows.indexOf(win);
-                if (extIndex > -1) {
-                    this.secondaryWindows.splice(extIndex, 1);
-                };
-            });
-        }
-        return win;
-    }
-
-    protected findWindow<T>(windowName: string): Window | undefined {
-        for (const w of this.secondaryWindows) {
-            if (w.name === windowName) {
-                return w;
-            }
-        }
-        return undefined;
-    }
-
-    protected doCreateSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined {
-        let options;
         const [height, width, left, top] = this.findSecondaryWindowCoordinates(widget);
-        options = `popup=1,width=${width},height=${height},left=${left},top=${top}`;
+        let options = `popup=1,width=${width},height=${height},left=${left},top=${top}`;
         if (this.preferenceService.get('window.secondaryWindowAlwaysOnTop')) {
             options += ',alwaysOnTop=true';
         }
         const newWindow = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, this.nextWindowId(), options) ?? undefined;
         if (newWindow) {
+            this.secondaryWindows.push(newWindow);
             newWindow.addEventListener('DOMContentLoaded', () => {
                 newWindow.addEventListener('beforeunload', evt => {
                     const saveable = Saveable.get(widget);
@@ -124,17 +101,38 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
                     }
                 }, { capture: true });
 
-                newWindow.addEventListener('close', () => {
+                newWindow.addEventListener('unload', () => {
                     const saveable = Saveable.get(widget);
                     shell.closeWidget(widget.id, {
                         save: !!saveable && saveable.dirty && saveable.autoSave !== 'off'
                     });
+
+                    const extIndex = this.secondaryWindows.indexOf(newWindow);
+                    if (extIndex > -1) {
+                        this.secondaryWindows.splice(extIndex, 1);
+                    };
                 });
+                this.windowCreated(newWindow, widget, shell);
             });
         }
         return newWindow;
     }
 
+    protected windowCreated(newWindow: Window, widget: ExtractableWidget, shell: ApplicationShell): void {
+        newWindow.addEventListener('unload', () => {
+            shell.closeWidget(widget.id);
+        });
+    }
+
+    protected findWindow<T>(windowName: string): Window | undefined {
+        for (const w of this.secondaryWindows) {
+            if (w.name === windowName) {
+                return w;
+            }
+        }
+        return undefined;
+    }
+
     protected findSecondaryWindowCoordinates(widget: ExtractableWidget): (number | undefined)[] {
         const clientBounds = widget.node.getBoundingClientRect();
         const preference = this.preferenceService.get('window.secondaryWindowPlacement');

package/src/browser/window/default-window-service.ts

@@ -57,6 +57,10 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         this.openNewWindow(`#${DEFAULT_WINDOW_HASH}`);
     }
 
+    focus(): void {
+        window.focus();
+    }
+
     /**
      * Returns a list of actions that {@link FrontendApplicationContribution}s would like to take before shutdown
      * It is expected that this will succeed - i.e. return an empty array - at most once per session. If no vetoes are received

package/src/browser/window/test/mock-window-service.ts

@@ -21,6 +21,7 @@ import { WindowService } from '../window-service';
 export class MockWindowService implements WindowService {
     openNewWindow(): undefined { return undefined; }
     openNewDefaultWindow(): void { }
+    focus(): void { }
     reload(): void { }
     isSafeToShutDown(): Promise<boolean> { return Promise.resolve(true); }
     setSafeToShutDown(): void { }

package/src/browser/window/window-service.ts

@@ -42,6 +42,11 @@ export interface WindowService {
      */
     openNewDefaultWindow(params?: WindowReloadOptions): void;
 
+    /**
+     * Reveal and focuses the current window
+     */
+    focus(): void;
+
     /**
      * Fires when the `window` unloads. The unload event is inevitable. On this event, the frontend application can save its state and release resource.
      * Saving the state and releasing any resources must be a synchronous call. Any asynchronous calls invoked after emitting this event might be ignored.

package/src/common/event.ts

@@ -467,3 +467,21 @@ export class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
     }
 
 }
+
+export class QueueableEmitter<T> extends Emitter<T[]> {
+
+    currentQueue?: T[];
+
+    queue(...arg: T[]): void {
+        if (!this.currentQueue) {
+            this.currentQueue = [];
+        }
+        this.currentQueue.push(...arg);
+    }
+
+    override fire(): void {
+        super.fire(this.currentQueue || []);
+        this.currentQueue = undefined;
+    }
+
+}

package/src/electron-browser/menu/electron-context-menu-renderer.ts

@@ -104,11 +104,13 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
             const menu = this.electronMenuFactory.createElectronContextMenu(menuPath, args, context, contextKeyService, skipSingleRootNode);
             const { x, y } = coordinateFromAnchor(anchor);
 
+            const windowName = options.context?.ownerDocument.defaultView?.Window.name;
+
             const menuHandle = window.electronTheiaCore.popup(menu, x, y, () => {
                 if (onHide) {
                     onHide();
                 }
-            });
+            }, windowName);
             // native context menu stops the event loop, so there is no keyboard events
             this.context.resetAltPressed();
             return new ElectronContextMenuAccess(menuHandle);

package/src/electron-browser/preload.ts

@@ -75,17 +75,17 @@ const api: TheiaCoreAPI = {
         ipcRenderer.send(CHANNEL_SET_MENU, mainMenuId, convertMenu(menu, handlers));
     },
     getSecurityToken: () => ipcRenderer.sendSync(CHANNEL_GET_SECURITY_TOKEN),
-    focusWindow: (name: string) => ipcRenderer.send(CHANNEL_FOCUS_WINDOW, name),
+    focusWindow: (name?: string) => ipcRenderer.send(CHANNEL_FOCUS_WINDOW, name),
     showItemInFolder: fsPath => {
         ipcRenderer.send(CHANNEL_SHOW_ITEM_IN_FOLDER, fsPath);
     },
     attachSecurityToken: (endpoint: string) => ipcRenderer.invoke(CHANNEL_ATTACH_SECURITY_TOKEN, endpoint),
 
-    popup: async function (menu: MenuDto[], x: number, y: number, onClosed: () => void): Promise<number> {
+    popup: async function (menu: MenuDto[], x: number, y: number, onClosed: () => void, windowName?: string): Promise<number> {
         const menuId = nextMenuId++;
         const handlers = new Map<number, () => void>();
         commandHandlers.set(menuId, handlers);
-        const handle = await ipcRenderer.invoke(CHANNEL_OPEN_POPUP, menuId, convertMenu(menu, handlers), x, y);
+        const handle = await ipcRenderer.invoke(CHANNEL_OPEN_POPUP, menuId, convertMenu(menu, handlers), x, y, windowName);
         const closeListener = () => {
             ipcRenderer.removeListener(CHANNEL_ON_CLOSE_POPUP, closeListener);
             commandHandlers.delete(menuId);

package/src/electron-browser/window/electron-secondary-window-service.ts

@@ -24,16 +24,12 @@ export class ElectronSecondaryWindowService extends DefaultSecondaryWindowServic
         window.electronTheiaCore.focusWindow(win.name);
     }
 
-    protected override doCreateSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined {
-        const w = super.doCreateSecondaryWindow(widget, shell);
-        if (w) {
-            window.electronTheiaCore.setMenuBarVisible(false, w.name);
-            window.electronTheiaCore.setSecondaryWindowCloseRequestHandler(w.name, () => this.canClose(widget, shell));
-        }
-        return w;
+    protected override windowCreated(newWindow: Window, widget: ExtractableWidget, shell: ApplicationShell): void {
+        window.electronTheiaCore.setMenuBarVisible(false, newWindow.name);
+        window.electronTheiaCore.setSecondaryWindowCloseRequestHandler(newWindow.name, () => this.canClose(widget, shell));
     }
     private async canClose(widget: ExtractableWidget, shell: ApplicationShell): Promise<boolean> {
-        await shell.closeWidget(widget.id, undefined);
+        await shell.closeWidget(widget.id);
         return widget.isDisposed;
     }
 }

package/src/electron-browser/window/electron-window-service.ts

@@ -57,6 +57,9 @@ export class ElectronWindowService extends DefaultWindowService {
         this.delegate.openNewDefaultWindow(params);
     }
 
+    override focus(): void {
+        window.electronTheiaCore.focusWindow();
+    }
     @postConstruct()
     protected init(): void {
         // Update the default zoom level on startup when the preferences event is fired.

package/src/electron-common/electron-api.ts

@@ -50,10 +50,10 @@ export interface TheiaCoreAPI {
     setMenuBarVisible(visible: boolean, windowName?: string): void;
     setMenu(menu: MenuDto[] | undefined): void;
 
-    popup(menu: MenuDto[], x: number, y: number, onClosed: () => void): Promise<number>;
+    popup(menu: MenuDto[], x: number, y: number, onClosed: () => void, windowName?: string): Promise<number>;
     closePopup(handle: number): void;
 
-    focusWindow(name: string): void;
+    focusWindow(name?: string): void;
 
     showItemInFolder(fsPath: string): void;
 

package/src/electron-main/electron-api-main.ts

@@ -115,7 +115,7 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
         });
 
         // popup menu
-        ipcMain.handle(CHANNEL_OPEN_POPUP, (event, menuId, menu, x, y) => {
+        ipcMain.handle(CHANNEL_OPEN_POPUP, (event, menuId, menu, x, y, windowName?: string) => {
             const zoom = event.sender.getZoomFactor();
             // TODO: Remove the offset once Electron fixes https://github.com/electron/electron/issues/31641
             const offset = process.platform === 'win32' ? 0 : 2;
@@ -124,7 +124,14 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
             y = Math.round(y * zoom) + offset;
             const popup = Menu.buildFromTemplate(this.fromMenuDto(event.sender, menuId, menu));
             this.openPopups.set(menuId, popup);
+            let electronWindow: BrowserWindow | undefined;
+            if (windowName) {
+                electronWindow = BrowserWindow.getAllWindows().find(win => win.webContents.mainFrame.name === windowName);
+            } else {
+                electronWindow = BrowserWindow.fromWebContents(event.sender) || undefined;
+            }
             popup.popup({
+                window: electronWindow,
                 callback: () => {
                     this.openPopups.delete(menuId);
                     event.sender.send(CHANNEL_ON_CLOSE_POPUP, menuId);
@@ -140,7 +147,9 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
 
         // focus windows for secondary window support
         ipcMain.on(CHANNEL_FOCUS_WINDOW, (event, windowName) => {
-            const electronWindow = BrowserWindow.getAllWindows().find(win => win.webContents.mainFrame.name === windowName);
+            const electronWindow = windowName
+                ? BrowserWindow.getAllWindows().find(win => win.webContents.mainFrame.name === windowName)
+                : BrowserWindow.fromWebContents(event.sender);
             if (electronWindow) {
                 if (electronWindow.isMinimized()) {
                     electronWindow.restore();