@theia/core 1.47.1 → 1.48.0

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

@@ -18,6 +18,11 @@ import { StopReason } from '../../common/frontend-application-state';
 import { Event } from '../../common/event';
 import { NewWindowOptions, WindowSearchParams } from '../../common/window';
 
+export interface WindowReloadOptions {
+    search?: WindowSearchParams,
+    hash?: string
+}
+
 /**
  * Service for opening new browser windows.
  */
@@ -35,7 +40,12 @@ export interface WindowService {
      * Opens a new default window.
      * - In electron and in the browser it will open the default window without a pre-defined content.
      */
-    openNewDefaultWindow(params?: WindowSearchParams): void;
+    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.
@@ -64,5 +74,5 @@ export interface WindowService {
     /**
      * Reloads the window according to platform.
      */
-    reload(params?: WindowSearchParams): void;
+    reload(params?: WindowReloadOptions): void;
 }

package/src/common/nls.ts

@@ -83,7 +83,9 @@ class LocalizationKeyProvider {
 
     private preferredKeys = new Set([
         // We only want the `File` translation used in the menu
-        'vscode/fileActions.contribution/filesCategory'
+        'vscode/fileActions.contribution/filesCategory',
+        // Needed for `Close Editor` translation
+        'vscode/editor.contribution/closeEditor'
     ]);
     private data = this.buildData();
 

package/src/common/quick-pick-service.ts

@@ -161,6 +161,7 @@ export interface QuickPick<T extends QuickPickItemOrSeparator> extends QuickInpu
     matchOnDescription: boolean;
     matchOnDetail: boolean;
     keepScrollPosition: boolean;
+    buttons: ReadonlyArray<QuickInputButton>;
     readonly onDidAccept: Event<{ inBackground: boolean } | undefined>;
     readonly onDidChangeValue: Event<string>;
     readonly onDidTriggerButton: Event<QuickInputButton>;

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

@@ -81,11 +81,11 @@ const api: TheiaCoreAPI = {
     },
     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

@@ -21,6 +21,7 @@ import { ElectronMainWindowService } from '../../electron-common/electron-main-w
 import { ElectronWindowPreferences } from './electron-window-preferences';
 import { ConnectionCloseService } from '../../common/messaging/connection-management';
 import { FrontendIdProvider } from '../../browser/messaging/frontend-id-provider';
+import { WindowReloadOptions } from '../../browser/window/window-service';
 
 @injectable()
 export class ElectronWindowService extends DefaultWindowService {
@@ -56,6 +57,9 @@ export class ElectronWindowService extends DefaultWindowService {
         this.delegate.openNewDefaultWindow(params);
     }
 
+    override focus(): void {
+        window.electronTheiaCore.focusWindow(window.name);
+    }
     @postConstruct()
     protected init(): void {
         // Update the default zoom level on startup when the preferences event is fired.
@@ -86,12 +90,20 @@ export class ElectronWindowService extends DefaultWindowService {
         }
     }
 
-    override reload(params?: WindowSearchParams): void {
+    override reload(params?: WindowReloadOptions): void {
         if (params) {
-            const query = Object.entries(params).map(([name, value]) => `${name}=${value}`).join('&');
-            location.search = query;
+            const newLocation = new URL(location.href);
+            if (params.search) {
+                const query = Object.entries(params.search).map(([name, value]) => `${name}=${value}`).join('&');
+                newLocation.search = query;
+            }
+            if (params.hash) {
+                newLocation.hash = '#' + params.hash;
+            }
+            location.assign(newLocation);
         } else {
             window.electronTheiaCore.requestReload();
         }
     }
 }
+

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

@@ -50,7 +50,7 @@ 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;

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);