@theia/core 1.37.0-next.9 → 1.38.0-next.0

package/src/electron-browser/preload.ts

@@ -0,0 +1,208 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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 { Disposable } from '../common/disposable';
+import { StopReason } from '../common/frontend-application-state';
+import { NativeKeyboardLayout } from '../common/keyboard/keyboard-layout-provider';
+import {
+    CHANNEL_ATTACH_SECURITY_TOKEN,
+    CHANNEL_FOCUS_WINDOW, CHANNEL_GET_SECURITY_TOKEN, CHANNEL_INVOKE_MENU, CHANNEL_SET_MENU, CHANNEL_OPEN_POPUP, CHANNEL_CLOSE_POPUP,
+    MenuDto, TheiaCoreAPI, CHANNEL_ON_CLOSE_POPUP, CHANNEL_GET_TITLE_STYLE_AT_STARTUP, WindowEvent,
+    CHANNEL_MINIMIZE, CHANNEL_IS_MAXIMIZED, CHANNEL_MAXIMIZE, CHANNEL_UNMAXIMIZE, CHANNEL_CLOSE, CHANNEL_TOGGLE_DEVTOOLS,
+    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
+} from '../electron-common/electron-api';
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+const { ipcRenderer, contextBridge } = require('electron');
+
+// a map of menuId => map<handler id => handler>
+const commandHandlers = new Map<number, Map<number, () => void>>();
+let nextHandlerId = 0;
+const mainMenuId = 0;
+let nextMenuId = mainMenuId + 1;
+
+function convertMenu(menu: MenuDto[] | undefined, handlerMap: Map<number, () => void>): InternalMenuDto[] | undefined {
+    if (!menu) {
+        return undefined;
+    }
+
+    return menu.map(item => {
+        let handlerId = undefined;
+        if (item.execute) {
+            handlerId = nextHandlerId++;
+            handlerMap.set(handlerId, item.execute);
+        }
+
+        return {
+            id: item.id,
+            submenu: convertMenu(item.submenu, handlerMap),
+            accelerator: item.accelerator,
+            label: item.label,
+            handlerId: handlerId,
+            checked: item.checked,
+            enabled: item.enabled,
+            role: item.role,
+            type: item.type,
+            visible: item.visible
+        };
+    });
+}
+
+const api: TheiaCoreAPI = {
+    setMenuBarVisible: (visible: boolean, windowName?: string) => ipcRenderer.send(CHANNEL_SET_MENU_BAR_VISIBLE, visible, windowName),
+    setMenu: (menu: MenuDto[] | undefined) => {
+        commandHandlers.delete(mainMenuId);
+        const handlers = new Map<number, () => void>();
+        commandHandlers.set(mainMenuId, handlers);
+        ipcRenderer.send(CHANNEL_SET_MENU, mainMenuId, convertMenu(menu, handlers));
+    },
+    getSecurityToken: () => ipcRenderer.invoke(CHANNEL_GET_SECURITY_TOKEN),
+    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> {
+        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 closeListener = () => {
+            ipcRenderer.removeListener(CHANNEL_ON_CLOSE_POPUP, closeListener);
+            commandHandlers.delete(menuId);
+            onClosed();
+        };
+        ipcRenderer.on(CHANNEL_ON_CLOSE_POPUP, closeListener);
+        return handle;
+    },
+    closePopup: function (handle: number): void {
+        ipcRenderer.send(CHANNEL_CLOSE_POPUP, handle);
+    },
+    getTitleBarStyleAtStartup: function (): Promise<string> {
+        return ipcRenderer.invoke(CHANNEL_GET_TITLE_STYLE_AT_STARTUP);
+    },
+    setTitleBarStyle: function (style): void {
+        ipcRenderer.send(CHANNEL_SET_TITLE_STYLE, style);
+    },
+    minimize: function (): void {
+        ipcRenderer.send(CHANNEL_MINIMIZE);
+    },
+    isMaximized: function (): boolean {
+        return ipcRenderer.sendSync(CHANNEL_IS_MAXIMIZED);
+    },
+    maximize: function (): void {
+        ipcRenderer.send(CHANNEL_MAXIMIZE);
+    },
+    unMaximize: function (): void {
+        ipcRenderer.send(CHANNEL_UNMAXIMIZE);
+    },
+    close: function (): void {
+        ipcRenderer.send(CHANNEL_CLOSE);
+    },
+    onWindowEvent: function (event: WindowEvent, handler: () => void): Disposable {
+        const h = (_event: unknown, evt: WindowEvent) => {
+            if (event === evt) {
+                handler();
+            }
+        };
+        ipcRenderer.on(CHANNEL_ON_WINDOW_EVENT, h);
+        return Disposable.create(() => ipcRenderer.off(CHANNEL_ON_WINDOW_EVENT, h));
+    },
+    setCloseRequestHandler: function (handler: (stopReason: StopReason) => Promise<boolean>): void {
+        ipcRenderer.on(CHANNEL_REQUEST_CLOSE, async (event, stopReason, confirmChannel, cancelChannel) => {
+            try {
+                if (await handler(stopReason)) {
+                    event.sender.send(confirmChannel);
+                    return;
+                };
+            } catch (e) {
+                console.warn('exception in close handler ', e);
+            }
+            event.sender.send(cancelChannel);
+        });
+    },
+
+    toggleDevTools: function (): void {
+        ipcRenderer.send(CHANNEL_TOGGLE_DEVTOOLS);
+    },
+    getZoomLevel: function (): Promise<number> {
+        return ipcRenderer.invoke(CHANNEL_GET_ZOOM_LEVEL);
+    },
+
+    setZoomLevel: function (desired: number): void {
+        ipcRenderer.send(CHANNEL_SET_ZOOM_LEVEL, desired);
+    },
+    isFullScreenable: function (): boolean {
+        return ipcRenderer.sendSync(CHANNEL_IS_FULL_SCREENABLE);
+    },
+
+    isFullScreen: function (): boolean {
+        return ipcRenderer.sendSync(CHANNEL_IS_FULL_SCREEN);
+
+    },
+    toggleFullScreen: function (): void {
+        ipcRenderer.send(CHANNEL_TOGGLE_FULL_SCREEN);
+    },
+
+    requestReload: () => ipcRenderer.send(CHANNEL_REQUEST_RELOAD),
+    restart: () => ipcRenderer.send(CHANNEL_RESTART),
+
+    applicationStateChanged: state => {
+        ipcRenderer.send(CHANNEL_APP_STATE_CHANGED, state);
+    },
+
+    readClipboard(): string {
+        return ipcRenderer.sendSync(CHANNEL_READ_CLIPBOARD);
+    },
+
+    writeClipboard(text): void {
+        ipcRenderer.send(CHANNEL_WRITE_CLIPBOARD, text);
+    },
+
+    onKeyboardLayoutChanged(handler): Disposable {
+        return createDisposableListener(CHANNEL_KEYBOARD_LAYOUT_CHANGED, (event, layout) => { handler(layout as NativeKeyboardLayout); });
+    },
+
+    onData: handler => createDisposableListener(CHANNEL_IPC_CONNECTION, (event, data) => { handler(data as Uint8Array); }),
+
+    sendData: data => {
+        ipcRenderer.send(CHANNEL_IPC_CONNECTION, data);
+    },
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createDisposableListener(channel: string, handler: (event: any, ...args: unknown[]) => any): Disposable {
+    ipcRenderer.on(channel, handler);
+    return Disposable.create(() => ipcRenderer.off(channel, handler));
+}
+
+export function preload(): void {
+    console.log('exposing theia core electron api');
+    ipcRenderer.on(CHANNEL_INVOKE_MENU, (_, menuId: number, handlerId: number) => {
+        const map = commandHandlers.get(menuId);
+        if (map) {
+            const handler = map.get(handlerId);
+            if (handler) {
+                handler();
+            }
+        }
+    });
+
+    contextBridge.exposeInMainWorld('electronTheiaCore', api);
+}

package/src/electron-browser/token/electron-token-frontend-module.ts

@@ -14,10 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as electronRemote from '../../../electron-shared/@electron/remote';
 import { ContainerModule } from 'inversify';
 import { ElectronSecurityToken } from '../../electron-common/electron-token';
 
 export default new ContainerModule(bind => {
-    bind(ElectronSecurityToken).toConstantValue(electronRemote.getGlobal(ElectronSecurityToken));
+    bind(ElectronSecurityToken).toConstantValue(window.electronTheiaCore.getSecurityToken());
 });

package/src/electron-browser/window/electron-frontend-application-state.ts

@@ -14,15 +14,13 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { ipcRenderer } from '../../../electron-shared/electron';
 import { injectable } from 'inversify';
-import { APPLICATION_STATE_CHANGE_SIGNAL } from '../../electron-common/messaging/electron-messages';
 import { FrontendApplicationState, FrontendApplicationStateService } from '../../browser/frontend-application-state';
 
 @injectable()
 export class ElectronFrontendApplicationStateService extends FrontendApplicationStateService {
     protected override doSetState(state: FrontendApplicationState): void {
         super.doSetState(state);
-        ipcRenderer.send(APPLICATION_STATE_CHANGE_SIGNAL, state);
+        window.electronTheiaCore.applicationStateChanged(state);
     }
 }

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

@@ -14,44 +14,20 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { BrowserWindow } from '../../../electron-shared/electron';
-import * as electronRemote from '../../../electron-shared/@electron/remote';
 import { injectable } from 'inversify';
 import { DefaultSecondaryWindowService } from '../../browser/window/default-secondary-window-service';
 
 @injectable()
 export class ElectronSecondaryWindowService extends DefaultSecondaryWindowService {
-    protected electronWindows: Map<string, BrowserWindow> = new Map();
-
-    protected override doCreateSecondaryWindow(onClose?: (closedWin: Window) => void): Window | undefined {
-        const id = this.nextWindowId();
-        electronRemote.getCurrentWindow().webContents.once('did-create-window', newElectronWindow => {
-            newElectronWindow.setMenuBarVisibility(false);
-            this.electronWindows.set(id, newElectronWindow);
-            newElectronWindow.on('closed', () => {
-                this.electronWindows.delete(id);
-                const browserWin = this.secondaryWindows.find(w => w.name === id);
-                if (browserWin) {
-                    this.handleWindowClosed(browserWin, onClose);
-                } else {
-                    console.warn(`Could not execute proper close handling for secondary window '${id}' because its frontend window could not be found.`);
-                };
-            });
-        });
-        const win = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, id);
-        return win ?? undefined;
+    override focus(win: Window): void {
+        window.electronTheiaCore.focusWindow(win.name);
     }
 
-    override focus(win: Window): void {
-        // window.name is the target name given to the window.open call as the second parameter.
-        const electronWindow = this.electronWindows.get(win.name);
-        if (electronWindow) {
-            if (electronWindow.isMinimized()) {
-                electronWindow.restore();
-            }
-            electronWindow.focus();
-        } else {
-            console.warn(`There is no known secondary window '${win.name}'. Thus, the window could not be focussed.`);
+    protected override doCreateSecondaryWindow(onClose?: (closedWin: Window) => void): Window | undefined {
+        const w = super.doCreateSecondaryWindow(onClose);
+        if (w) {
+            window.electronTheiaCore.setMenuBarVisible(false, w.name);
         }
+        return w;
     }
 }

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

@@ -14,14 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as electronRemote from '../../../electron-shared/@electron/remote';
 import { injectable, inject, postConstruct } from 'inversify';
-import * as electron from '../../../electron-shared/electron';
 import { NewWindowOptions } from '../../common/window';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
 import { ElectronMainWindowService } from '../../electron-common/electron-main-window-service';
 import { ElectronWindowPreferences } from './electron-window-preferences';
-import { CloseRequestArguments, CLOSE_REQUESTED_SIGNAL, RELOAD_REQUESTED_SIGNAL, StopReason } from '../../electron-common/messaging/electron-messages';
 
 @injectable()
 export class ElectronWindowService extends DefaultWindowService {
@@ -62,37 +59,23 @@ export class ElectronWindowService extends DefaultWindowService {
     }
 
     protected override registerUnloadListeners(): void {
-        electron.ipcRenderer.on(CLOSE_REQUESTED_SIGNAL, (_event, closeRequestEvent: CloseRequestArguments) => this.handleCloseRequestedEvent(closeRequestEvent));
-        window.addEventListener('unload', () => this.onUnloadEmitter.fire());
-    }
-
-    /**
-     * Run when ElectronMain detects a `close` event and emits a `close-requested` event.
-     * Should send an event to `electron.ipcRenderer` on the event's `confirmChannel` if it is safe to exit
-     * after running FrontendApplication `onWillStop` handlers or on the `cancelChannel` if it is not safe to exit.
-     */
-    protected async handleCloseRequestedEvent(event: CloseRequestArguments): Promise<void> {
-        const safeToClose = await this.isSafeToShutDown(event.reason);
-        if (safeToClose) {
-            console.debug(`Shutting down because of ${StopReason[event.reason]} request.`);
-            electron.ipcRenderer.send(event.confirmChannel);
-        } else {
-            electron.ipcRenderer.send(event.cancelChannel);
-        }
+        window.electronTheiaCore.setCloseRequestHandler(reason => this.isSafeToShutDown(reason));
+        window.addEventListener('unload', () => {
+            this.onUnloadEmitter.fire();
+        });
     }
 
     /**
      * Updates the window zoom level based on the preference value.
      */
-    protected updateWindowZoomLevel(): void {
+    protected async updateWindowZoomLevel(): Promise<void> {
         const preferredZoomLevel = this.electronWindowPreferences['window.zoomLevel'];
-        const webContents = electronRemote.getCurrentWindow().webContents;
-        if (webContents.getZoomLevel() !== preferredZoomLevel) {
-            webContents.setZoomLevel(preferredZoomLevel);
+        if (await window.electronTheiaCore.getZoomLevel() !== preferredZoomLevel) {
+            window.electronTheiaCore.setZoomLevel(preferredZoomLevel);
         }
     }
 
     override reload(): void {
-        electron.ipcRenderer.send(RELOAD_REQUESTED_SIGNAL);
+        window.electronTheiaCore.requestReload();
     }
 }

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

@@ -0,0 +1,134 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics 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 { NativeKeyboardLayout } from '../common/keyboard/keyboard-layout-provider';
+import { Disposable } from '../common';
+import { FrontendApplicationState, StopReason } from '../common/frontend-application-state';
+
+export type MenuRole = ('undo' | 'redo' | 'cut' | 'copy' | 'paste' | 'selectAll' | 'about' | 'services' | 'hide' | 'hideOthers' | 'unhide' | 'quit');
+
+export interface MenuDto {
+    id?: string,
+    label?: string,
+    submenu?: MenuDto[],
+    type?: ('normal' | 'separator' | 'submenu' | 'checkbox' | 'radio');
+    checked?: boolean,
+    enabled?: boolean,
+    visible?: boolean;
+    role?: MenuRole;
+    accelerator?: string,
+    execute?: () => void
+}
+
+export type InternalMenuDto = Omit<MenuDto, 'execute' | 'submenu'> & {
+    submenu?: InternalMenuDto[],
+    handlerId?: number
+};
+
+export type WindowEvent = 'maximize' | 'unmaximize' | 'focus';
+
+export interface TheiaCoreAPI {
+    getSecurityToken: () => Promise<string>;
+    attachSecurityToken: (endpoint: string) => Promise<void>;
+
+    setMenuBarVisible(visible: boolean, windowName?: string): void;
+    setMenu(menu: MenuDto[] | undefined): void;
+
+    popup(menu: MenuDto[], x: number, y: number, onClosed: () => void): Promise<number>;
+    closePopup(handle: number): void;
+
+    focusWindow(name: string): void;
+
+    showItemInFolder(fsPath: string): void;
+
+    getTitleBarStyleAtStartup(): Promise<string>;
+    setTitleBarStyle(style: string): void;
+    minimize(): void;
+    isMaximized(): boolean; // TODO: this should really be async, since it blocks the renderer process
+    maximize(): void;
+    unMaximize(): void;
+    close(): void;
+    onWindowEvent(event: WindowEvent, handler: () => void): Disposable;
+    setCloseRequestHandler(handler: (reason: StopReason) => Promise<boolean>): void;
+
+    toggleDevTools(): void;
+    getZoomLevel(): Promise<number>;
+    setZoomLevel(desired: number): void;
+
+    isFullScreenable(): boolean; // TODO: this should really be async, since it blocks the renderer process
+    isFullScreen(): boolean; // TODO: this should really be async, since it blocks the renderer process
+    toggleFullScreen(): void;
+
+    requestReload(): void;
+    restart(): void;
+
+    applicationStateChanged(state: FrontendApplicationState): void;
+
+    readClipboard(): string;
+    writeClipboard(text: string): void;
+
+    onKeyboardLayoutChanged(handler: (newLayout: NativeKeyboardLayout) => void): Disposable;
+
+    sendData(data: Uint8Array): void;
+    onData(handler: (data: Uint8Array) => void): Disposable;
+}
+
+declare global {
+    interface Window {
+        electronTheiaCore: TheiaCoreAPI
+    }
+}
+
+export const CHANNEL_SET_MENU = 'SetMenu';
+export const CHANNEL_SET_MENU_BAR_VISIBLE = 'SetMenuBarVisible';
+export const CHANNEL_INVOKE_MENU = 'InvokeMenu';
+export const CHANNEL_OPEN_POPUP = 'OpenPopup';
+export const CHANNEL_ON_CLOSE_POPUP = 'OnClosePopup';
+export const CHANNEL_CLOSE_POPUP = 'ClosePopup';
+export const CHANNEL_GET_SECURITY_TOKEN = 'GetSecurityToken';
+export const CHANNEL_FOCUS_WINDOW = 'FocusWindow';
+export const CHANNEL_SHOW_OPEN = 'ShowOpenDialog';
+export const CHANNEL_SHOW_SAVE = 'ShowSaveDialog';
+export const CHANNEL_SHOW_ITEM_IN_FOLDER = 'ShowItemInFolder';
+export const CHANNEL_ATTACH_SECURITY_TOKEN = 'AttachSecurityToken';
+
+export const CHANNEL_GET_TITLE_STYLE_AT_STARTUP = 'GetTitleStyleAtStartup';
+export const CHANNEL_SET_TITLE_STYLE = 'SetTitleStyle';
+export const CHANNEL_CLOSE = 'Close';
+export const CHANNEL_MINIMIZE = 'Minimize';
+export const CHANNEL_MAXIMIZE = 'Maximize';
+export const CHANNEL_IS_MAXIMIZED = 'IsMaximized';
+
+export const CHANNEL_UNMAXIMIZE = 'UnMaximize';
+export const CHANNEL_ON_WINDOW_EVENT = 'OnWindowEvent';
+export const CHANNEL_TOGGLE_DEVTOOLS = 'ToggleDevtools';
+export const CHANNEL_GET_ZOOM_LEVEL = 'GetZoomLevel';
+export const CHANNEL_SET_ZOOM_LEVEL = 'SetZoomLevel';
+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_CLOSE = 'RequestClose';
+export const CHANNEL_REQUEST_RELOAD = 'RequestReload';
+export const CHANNEL_RESTART = 'Restart';
+
+export const CHANNEL_APP_STATE_CHANGED = 'ApplicationStateChanged';
+
+export const CHANNEL_READ_CLIPBOARD = 'ReadClipboard';
+export const CHANNEL_WRITE_CLIPBOARD = 'WriteClipboard';
+
+export const CHANNEL_KEYBOARD_LAYOUT_CHANGED = 'KeyboardLayoutChanged';
+export const CHANNEL_IPC_CONNECTION = 'IpcConnection';

package/src/electron-common/messaging/electron-connection-handler.ts

@@ -14,17 +14,8 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { ConnectionHandler } from '../../common/messaging/handler';
-
-/**
- * Name of the channel used with `ipcMain.on/emit`.
- */
-export const THEIA_ELECTRON_IPC_CHANNEL_NAME = 'theia-electron-ipc';
-
 /**
  * Electron-IPC-specific connection handler.
  * Use this if you want to establish communication between the frontend and the electron-main process.
  */
 export const ElectronConnectionHandler = Symbol('ElectronConnectionHandler');
-export interface ElectronConnectionHandler extends ConnectionHandler {
-}