@theia/core 1.38.0 → 1.39.0-next.11

package/src/electron-browser/preload.ts

@@ -13,6 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 //
+import { IpcRendererEvent } from '@theia/electron/shared/electron';
 import { Disposable } from '../common/disposable';
 import { StopReason } from '../common/frontend-application-state';
 import { NativeKeyboardLayout } from '../common/keyboard/keyboard-layout-provider';
@@ -24,7 +25,7 @@ import {
     CHANNEL_ON_WINDOW_EVENT, CHANNEL_GET_ZOOM_LEVEL, CHANNEL_SET_ZOOM_LEVEL, CHANNEL_IS_FULL_SCREENABLE, CHANNEL_TOGGLE_FULL_SCREEN,
     CHANNEL_IS_FULL_SCREEN, CHANNEL_SET_MENU_BAR_VISIBLE, CHANNEL_REQUEST_CLOSE, CHANNEL_SET_TITLE_STYLE, CHANNEL_RESTART,
     CHANNEL_REQUEST_RELOAD, CHANNEL_APP_STATE_CHANGED, CHANNEL_SHOW_ITEM_IN_FOLDER, CHANNEL_READ_CLIPBOARD, CHANNEL_WRITE_CLIPBOARD,
-    CHANNEL_KEYBOARD_LAYOUT_CHANGED, CHANNEL_IPC_CONNECTION, InternalMenuDto
+    CHANNEL_KEYBOARD_LAYOUT_CHANGED, CHANNEL_IPC_CONNECTION, InternalMenuDto, CHANNEL_REQUEST_SECONDARY_CLOSE
 } from '../electron-common/electron-api';
 
 // eslint-disable-next-line import/no-extraneous-dependencies
@@ -71,7 +72,7 @@ const api: TheiaCoreAPI = {
         commandHandlers.set(mainMenuId, handlers);
         ipcRenderer.send(CHANNEL_SET_MENU, mainMenuId, convertMenu(menu, handlers));
     },
-    getSecurityToken: () => ipcRenderer.invoke(CHANNEL_GET_SECURITY_TOKEN),
+    getSecurityToken: () => ipcRenderer.sendSync(CHANNEL_GET_SECURITY_TOKEN),
     focusWindow: (name: string) => ipcRenderer.send(CHANNEL_FOCUS_WINDOW, name),
     showItemInFolder: fsPath => {
         ipcRenderer.send(CHANNEL_SHOW_ITEM_IN_FOLDER, fsPath);
@@ -138,6 +139,25 @@ const api: TheiaCoreAPI = {
         });
     },
 
+    setSecondaryWindowCloseRequestHandler(windowName: string, handler: () => Promise<boolean>): void {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const listener: (event: IpcRendererEvent, ...args: any[]) => void = async (event, name, confirmChannel, cancelChannel) => {
+            if (name === windowName) {
+                try {
+                    if (await handler()) {
+                        event.sender.send(confirmChannel);
+                        ipcRenderer.removeListener(CHANNEL_REQUEST_SECONDARY_CLOSE, listener);
+                        return;
+                    };
+                } catch (e) {
+                    console.warn('exception in close handler ', e);
+                }
+                event.sender.send(cancelChannel);
+            }
+        };
+        ipcRenderer.on(CHANNEL_REQUEST_SECONDARY_CLOSE, listener);
+    },
+
     toggleDevTools: function (): void {
         ipcRenderer.send(CHANNEL_TOGGLE_DEVTOOLS);
     },

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

@@ -16,6 +16,7 @@
 
 import { injectable } from 'inversify';
 import { DefaultSecondaryWindowService } from '../../browser/window/default-secondary-window-service';
+import { ApplicationShell, ExtractableWidget } from 'src/browser';
 
 @injectable()
 export class ElectronSecondaryWindowService extends DefaultSecondaryWindowService {
@@ -23,11 +24,16 @@ export class ElectronSecondaryWindowService extends DefaultSecondaryWindowServic
         window.electronTheiaCore.focusWindow(win.name);
     }
 
-    protected override doCreateSecondaryWindow(onClose?: (closedWin: Window) => void): Window | undefined {
-        const w = super.doCreateSecondaryWindow(onClose);
+    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;
     }
+    private async canClose(widget: ExtractableWidget, shell: ApplicationShell): Promise<boolean> {
+        await shell.closeWidget(widget.id, undefined);
+        return widget.isDisposed;
+    }
 }

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

@@ -41,7 +41,7 @@ export type InternalMenuDto = Omit<MenuDto, 'execute' | 'submenu'> & {
 export type WindowEvent = 'maximize' | 'unmaximize' | 'focus';
 
 export interface TheiaCoreAPI {
-    getSecurityToken: () => Promise<string>;
+    getSecurityToken: () => string;
     attachSecurityToken: (endpoint: string) => Promise<void>;
 
     setMenuBarVisible(visible: boolean, windowName?: string): void;
@@ -64,6 +64,8 @@ export interface TheiaCoreAPI {
     onWindowEvent(event: WindowEvent, handler: () => void): Disposable;
     setCloseRequestHandler(handler: (reason: StopReason) => Promise<boolean>): void;
 
+    setSecondaryWindowCloseRequestHandler(windowName: string, handler: () => Promise<boolean>): void;
+
     toggleDevTools(): void;
     getZoomLevel(): Promise<number>;
     setZoomLevel(desired: number): void;
@@ -121,6 +123,8 @@ export const CHANNEL_IS_FULL_SCREENABLE = 'IsFullScreenable';
 export const CHANNEL_IS_FULL_SCREEN = 'IsFullScreen';
 export const CHANNEL_TOGGLE_FULL_SCREEN = 'ToggleFullScreen';
 
+export const CHANNEL_REQUEST_SECONDARY_CLOSE = 'RequestSecondaryClose';
+
 export const CHANNEL_REQUEST_CLOSE = 'RequestClose';
 export const CHANNEL_REQUEST_RELOAD = 'RequestReload';
 export const CHANNEL_RESTART = 'Restart';

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

@@ -49,7 +49,8 @@ import {
     InternalMenuDto,
     CHANNEL_SET_MENU_BAR_VISIBLE,
     CHANNEL_TOGGLE_FULL_SCREEN,
-    CHANNEL_IS_MAXIMIZED
+    CHANNEL_IS_MAXIMIZED,
+    CHANNEL_REQUEST_SECONDARY_CLOSE
 } from '../electron-common/electron-api';
 import { ElectronMainApplication, ElectronMainApplicationContribution } from './electron-main-application';
 import { Disposable, DisposableCollection, isOSX, MaybePromise } from '../common';
@@ -64,7 +65,9 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
 
     onStart(application: ElectronMainApplication): MaybePromise<void> {
         // electron security token
-        ipcMain.handle(CHANNEL_GET_SECURITY_TOKEN, () => this.electronSecurityToken.value);
+        ipcMain.on(CHANNEL_GET_SECURITY_TOKEN, event => {
+            event.returnValue = this.electronSecurityToken.value;
+        });
 
         ipcMain.handle(CHANNEL_ATTACH_SECURITY_TOKEN, (event, endpoint) => session.defaultSession.cookies.set({
             url: endpoint,
@@ -265,6 +268,23 @@ export namespace TheiaRendererAPI {
         }).finally(() => disposables.dispose());
     }
 
+    export function requestSecondaryClose(mainWindow: WebContents, secondaryWindow: WebContents): Promise<boolean> {
+        const channelNr = nextReplyChannel++;
+        const confirmChannel = `confirm-${channelNr}`;
+        const cancelChannel = `cancel-${channelNr}`;
+        const disposables = new DisposableCollection();
+
+        return new Promise<boolean>(resolve => {
+            mainWindow.send(CHANNEL_REQUEST_SECONDARY_CLOSE, secondaryWindow.mainFrame.name, confirmChannel, cancelChannel);
+            createDisposableListener(ipcMain, confirmChannel, e => {
+                resolve(true);
+            }, disposables);
+            createDisposableListener(ipcMain, cancelChannel, e => {
+                resolve(false);
+            }, disposables);
+        }).finally(() => disposables.dispose());
+    }
+
     export function onRequestReload(wc: WebContents, handler: () => void): Disposable {
         return createWindowListener(wc, CHANNEL_REQUEST_RELOAD, handler);
     }

package/src/electron-main/theia-electron-window.ts

@@ -44,6 +44,12 @@ export const TheiaBrowserWindowOptions = Symbol('TheiaBrowserWindowOptions');
 export const WindowApplicationConfig = Symbol('WindowApplicationConfig');
 export type WindowApplicationConfig = FrontendApplicationConfig;
 
+enum ClosingState {
+    initial,
+    inProgress,
+    readyToClose
+}
+
 @injectable()
 export class TheiaElectronWindow {
     @inject(TheiaBrowserWindowOptions) protected readonly options: TheiaBrowserWindowOptions;
@@ -75,8 +81,32 @@ export class TheiaElectronWindow {
         this.attachCloseListeners();
         this.trackApplicationState();
         this.attachReloadListener();
+        this.attachSecondaryWindowListener();
     }
 
+    protected attachSecondaryWindowListener(): void {
+        createDisposableListener(this._window.webContents, 'did-create-window', (newWindow: BrowserWindow) => {
+            let closingState = ClosingState.initial;
+            newWindow.on('close', event => {
+                if (closingState === ClosingState.initial) {
+                    closingState = ClosingState.inProgress;
+                    event.preventDefault();
+                    TheiaRendererAPI.requestSecondaryClose(this._window.webContents, newWindow.webContents).then(shouldClose => {
+                        if (shouldClose) {
+                            closingState = ClosingState.readyToClose;
+                            newWindow.close();
+                        } else {
+                            closingState = ClosingState.initial;
+                        }
+                    });
+                } else if (closingState === ClosingState.inProgress) {
+                    // When the extracted widget is disposed programmatically, a dispose listener on it will try to close the window.
+                    // if we dispose the widget because of closing the window, we'll get a recursive call to window.close()
+                    event.preventDefault();
+                }
+            });
+        });
+    }
     /**
      * Only show the window when the content is ready.
      */

package/src/electron-node/token/electron-token-validator.ts

@@ -31,7 +31,7 @@ export class ElectronTokenValidator implements WsRequestValidatorContribution {
     protected electronSecurityToken: ElectronSecurityToken;
 
     @postConstruct()
-    protected postConstruct(): void {
+    protected init(): void {
         this.electronSecurityToken = this.getToken();
     }
 

package/src/node/backend-application.ts

@@ -196,6 +196,10 @@ export class BackendApplication {
     }
 
     @postConstruct()
+    protected init(): void {
+        this.configure();
+    }
+
     protected async configure(): Promise<void> {
         // Do not await the initialization because contributions are expected to handle
         // concurrent initialize/configure in undefined order if they provide both

package/src/node/hosting/backend-application-hosts.ts

@@ -39,7 +39,7 @@ export class BackendApplicationHosts {
     }
 
     @postConstruct()
-    protected postConstruct(): void {
+    protected init(): void {
         const theiaHostsEnv = process.env['THEIA_HOSTS'];
         if (theiaHostsEnv) {
             theiaHostsEnv.split(',').forEach(host => {