@theia/core 1.39.0-next.1 → 1.39.0-next.11

package/src/common/messaging/proxy-factory.ts

@@ -23,6 +23,7 @@ import { Emitter, Event } from '../event';
 import { Channel } from '../message-rpc/channel';
 import { RequestHandler, RpcProtocol } from '../message-rpc/rpc-protocol';
 import { ConnectionHandler } from './handler';
+import { Deferred } from '../promise-util';
 
 export type JsonRpcServer<Client> = Disposable & {
     /**
@@ -55,11 +56,11 @@ export class JsonRpcConnectionHandler<T extends object> implements ConnectionHan
     }
 }
 /**
- * Factory for creating a new {@link RpcConnection} for a given chanel and {@link RequestHandler}.
+ * Factory for creating a new {@link RpcProtocol} for a given chanel and {@link RequestHandler}.
  */
-export type RpcConnectionFactory = (channel: Channel, requestHandler: RequestHandler) => RpcProtocol;
+export type RpcProtocolFactory = (channel: Channel, requestHandler: RequestHandler) => RpcProtocol;
 
-const defaultRPCConnectionFactory: RpcConnectionFactory = (channel, requestHandler) => new RpcProtocol(channel, requestHandler);
+const defaultRpcProtocolFactory: RpcProtocolFactory = (channel, requestHandler) => new RpcProtocol(channel, requestHandler);
 
 /**
  * Factory for JSON-RPC proxy objects.
@@ -109,8 +110,7 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
     protected readonly onDidOpenConnectionEmitter = new Emitter<void>();
     protected readonly onDidCloseConnectionEmitter = new Emitter<void>();
 
-    protected connectionPromiseResolve: (connection: RpcProtocol) => void;
-    protected connectionPromise: Promise<RpcProtocol>;
+    protected rpcDeferred: Deferred<RpcProtocol>;
 
     /**
      * Build a new JsonRpcProxyFactory.
@@ -118,16 +118,14 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * @param target - The object to expose to JSON-RPC methods calls.  If this
      *   is omitted, the proxy won't be able to handle requests, only send them.
      */
-    constructor(public target?: any, protected rpcConnectionFactory = defaultRPCConnectionFactory) {
+    constructor(public target?: any, protected rpcProtocolFactory = defaultRpcProtocolFactory) {
         this.waitForConnection();
     }
 
     protected waitForConnection(): void {
-        this.connectionPromise = new Promise(resolve =>
-            this.connectionPromiseResolve = resolve
-        );
-        this.connectionPromise.then(connection => {
-            connection.channel.onClose(() => {
+        this.rpcDeferred = new Deferred<RpcProtocol>();
+        this.rpcDeferred.promise.then(protocol => {
+            protocol.channel.onClose(() => {
                 this.onDidCloseConnectionEmitter.fire(undefined);
                 // Wait for connection in case the backend reconnects
                 this.waitForConnection();
@@ -143,10 +141,10 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
      * response.
      */
     listen(channel: Channel): void {
-        const connection = this.rpcConnectionFactory(channel, (meth, args) => this.onRequest(meth, ...args));
-        connection.onNotification(event => this.onNotification(event.method, ...event.args));
+        const protocol = this.rpcProtocolFactory(channel, (meth, args) => this.onRequest(meth, ...args));
+        protocol.onNotification(event => this.onNotification(event.method, ...event.args));
 
-        this.connectionPromiseResolve(connection);
+        this.rpcDeferred.resolve(protocol);
     }
 
     /**
@@ -249,7 +247,7 @@ export class JsonRpcProxyFactory<T extends object> implements ProxyHandler<T> {
         return (...args: any[]) => {
             const method = p.toString();
             const capturedError = new Error(`Request '${method}' failed`);
-            return this.connectionPromise.then(connection =>
+            return this.rpcDeferred.promise.then(connection =>
                 new Promise<void>((resolve, reject) => {
                     try {
                         if (isNotify) {

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
@@ -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

@@ -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';
@@ -267,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.
      */