@theia/core 1.37.0-next.9 → 1.37.1

package/src/electron-browser/menu/electron-main-menu-factory.ts

@@ -16,7 +16,6 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import * as electronRemote from '../../../electron-shared/@electron/remote';
 import { inject, injectable, postConstruct } from 'inversify';
 import { isOSX, MAIN_MENU_BAR, MenuPath, MenuNode, CommandMenuNode, CompoundMenuNode, CompoundMenuNodeRole } from '../../common';
 import { Keybinding } from '../../common/keybinding';
@@ -24,7 +23,8 @@ import { PreferenceService, CommonCommands } from '../../browser';
 import debounce = require('lodash.debounce');
 import { MAXIMIZED_CLASS } from '../../browser/shell/theia-dock-panel';
 import { BrowserMainMenuFactory } from '../../browser/menu/browser-menu-plugin';
-import { ContextMatcher } from 'src/browser/context-key-service';
+import { ContextMatcher } from '../../browser/context-key-service';
+import { MenuDto, MenuRole } from '../../electron-common/electron-api';
 
 /**
  * Representation of possible electron menu options.
@@ -68,7 +68,7 @@ export type ElectronMenuItemRole = ('undo' | 'redo' | 'cut' | 'copy' | 'paste' |
 @injectable()
 export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
 
-    protected _menu?: Electron.Menu;
+    protected _menu?: MenuDto[];
     protected _toggledCommands: Set<string> = new Set();
 
     @inject(PreferenceService)
@@ -82,13 +82,13 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
                     this.setMenuBar();
                 }
                 if (this._menu) {
-                    for (const item of this._toggledCommands) {
-                        const menuItem = this._menu.getMenuItemById(item);
+                    for (const cmd of this._toggledCommands) {
+                        const menuItem = this.findMenuById(this._menu, cmd);
                         if (menuItem) {
-                            menuItem.checked = this.commandRegistry.isToggled(item);
+                            menuItem.checked = this.commandRegistry.isToggled(cmd);
                         }
                     }
-                    electronRemote.getCurrentWindow().setMenu(this._menu);
+                    window.electronTheiaCore.setMenu(this._menu);
                 }
             }, 10)
         );
@@ -99,56 +99,49 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
 
     async setMenuBar(): Promise<void> {
         await this.preferencesService.ready;
-        if (isOSX) {
-            const createdMenuBar = this.createElectronMenuBar();
-            electronRemote.Menu.setApplicationMenu(createdMenuBar);
-        } else if (this.preferencesService.get('window.titleBarStyle') === 'native') {
-            const createdMenuBar = this.createElectronMenuBar();
-            electronRemote.getCurrentWindow().setMenu(createdMenuBar);
-        }
+        const createdMenuBar = this.createElectronMenuBar();
+        window.electronTheiaCore.setMenu(createdMenuBar);
     }
 
-    createElectronMenuBar(): Electron.Menu | null {
+    createElectronMenuBar(): MenuDto[] | undefined {
         const preference = this.preferencesService.get<string>('window.menuBarVisibility') || 'classic';
         const maxWidget = document.getElementsByClassName(MAXIMIZED_CLASS);
         if (preference === 'visible' || (preference === 'classic' && maxWidget.length === 0)) {
             const menuModel = this.menuProvider.getMenu(MAIN_MENU_BAR);
-            const template = this.fillMenuTemplate([], menuModel, [], { rootMenuPath: MAIN_MENU_BAR });
+            this._menu = this.fillMenuTemplate([], menuModel, [], { rootMenuPath: MAIN_MENU_BAR });
             if (isOSX) {
-                template.unshift(this.createOSXMenu());
-            }
-            const menu = electronRemote.Menu.buildFromTemplate(template);
-            if (!menu) {
-                throw new Error('menu is null');
+                this._menu.unshift(this.createOSXMenu());
             }
-            this._menu = menu;
             return this._menu;
         }
         this._menu = undefined;
         // eslint-disable-next-line no-null/no-null
-        return null;
+        return undefined;
     }
 
-    createElectronContextMenu(menuPath: MenuPath, args?: any[], context?: HTMLElement, contextKeyService?: ContextMatcher): Electron.Menu {
+    createElectronContextMenu(menuPath: MenuPath, args?: any[], context?: HTMLElement, contextKeyService?: ContextMatcher): MenuDto[] {
         const menuModel = this.menuProvider.getMenu(menuPath);
-        const template = this.fillMenuTemplate([], menuModel, args, { showDisabled: false, context, rootMenuPath: menuPath, contextKeyService });
-        return electronRemote.Menu.buildFromTemplate(template);
+        return this.fillMenuTemplate([], menuModel, args, { showDisabled: false, context, rootMenuPath: menuPath, contextKeyService });
     }
 
-    protected fillMenuTemplate(parentItems: Electron.MenuItemConstructorOptions[],
+    protected fillMenuTemplate(parentItems: MenuDto[],
         menu: MenuNode,
         args: unknown[] = [],
         options: ElectronMenuOptions
-    ): Electron.MenuItemConstructorOptions[] {
+    ): MenuDto[] {
         const showDisabled = options?.showDisabled !== false;
 
         if (CompoundMenuNode.is(menu) && menu.children.length && this.undefinedOrMatch(options.contextKeyService ?? this.contextKeyService, menu.when, options.context)) {
             const role = CompoundMenuNode.getRole(menu);
-            if (role === CompoundMenuNodeRole.Group && menu.id === 'inline') { return parentItems; }
+            if (role === CompoundMenuNodeRole.Group && menu.id === 'inline') {
+                return parentItems;
+            }
             const children = CompoundMenuNode.getFlatChildren(menu.children);
-            const myItems: Electron.MenuItemConstructorOptions[] = [];
+            const myItems: MenuDto[] = [];
             children.forEach(child => this.fillMenuTemplate(myItems, child, args, options));
-            if (myItems.length === 0) { return parentItems; }
+            if (myItems.length === 0) {
+                return parentItems;
+            }
             if (role === CompoundMenuNodeRole.Submenu) {
                 parentItems.push({ label: menu.label, submenu: myItems });
             } else if (role === CompoundMenuNodeRole.Group && menu.id !== 'inline') {
@@ -183,7 +176,7 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
 
             const accelerator = bindings[0] && this.acceleratorFor(bindings[0]);
 
-            const menuItem: Electron.MenuItemConstructorOptions = {
+            const menuItem: MenuDto = {
                 id: node.id,
                 label: node.label,
                 type: this.commandRegistry.getToggledHandler(commandId, ...args) ? 'checkbox' : 'normal',
@@ -191,14 +184,14 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
                 enabled: true, // https://github.com/eclipse-theia/theia/issues/446
                 visible: true,
                 accelerator,
-                click: () => this.execute(commandId, args, options.rootMenuPath)
+                execute: () => this.execute(commandId, args, options.rootMenuPath)
             };
 
             if (isOSX) {
                 const role = this.roleFor(node.id);
                 if (role) {
                     menuItem.role = role;
-                    delete menuItem.click;
+                    delete menuItem.execute;
                 }
             }
             parentItems.push(menuItem);
@@ -235,8 +228,8 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         return this.keybindingRegistry.acceleratorForKeyCode(keyCode, '+', true);
     }
 
-    protected roleFor(id: string): ElectronMenuItemRole | undefined {
-        let role: ElectronMenuItemRole | undefined;
+    protected roleFor(id: string): MenuRole | undefined {
+        let role: MenuRole | undefined;
         switch (id) {
             case CommonCommands.UNDO.id:
                 role = 'undo';
@@ -262,18 +255,18 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         return role;
     }
 
-    protected async execute(command: string, args: any[], menuPath: MenuPath): Promise<void> {
+    protected async execute(cmd: string, args: any[], menuPath: MenuPath): Promise<void> {
         try {
             // This is workaround for https://github.com/eclipse-theia/theia/issues/446.
             // Electron menus do not update based on the `isEnabled`, `isVisible` property of the command.
             // We need to check if we can execute it.
-            if (this.menuCommandExecutor.isEnabled(menuPath, command, ...args)) {
-                await this.menuCommandExecutor.executeCommand(menuPath, command, ...args);
-                if (this._menu && this.menuCommandExecutor.isVisible(menuPath, command, ...args)) {
-                    const item = this._menu.getMenuItemById(command);
+            if (this.menuCommandExecutor.isEnabled(menuPath, cmd, ...args)) {
+                await this.menuCommandExecutor.executeCommand(menuPath, cmd, ...args);
+                if (this._menu && this.menuCommandExecutor.isVisible(menuPath, cmd, ...args)) {
+                    const item = this.findMenuById(this._menu, cmd);
                     if (item) {
-                        item.checked = this.menuCommandExecutor.isToggled(menuPath, command, ...args);
-                        electronRemote.getCurrentWindow().setMenu(this._menu);
+                        item.checked = this.menuCommandExecutor.isToggled(menuPath, cmd, ...args);
+                        window.electronTheiaCore.setMenu(this._menu);
                     }
                 }
             }
@@ -281,8 +274,22 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
             // no-op
         }
     }
+    findMenuById(items: MenuDto[], id: string): MenuDto | undefined {
+        for (const item of items) {
+            if (item.id === id) {
+                return item;
+            }
+            if (item.submenu) {
+                const found = this.findMenuById(item.submenu, id);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
 
-    protected createOSXMenu(): Electron.MenuItemConstructorOptions {
+    protected createOSXMenu(): MenuDto {
         return {
             label: 'Theia',
             submenu: [

package/src/electron-browser/menu/electron-menu-contribution.ts

@@ -14,8 +14,6 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as electron from '../../../electron-shared/electron';
-import * as electronRemote from '../../../electron-shared/@electron/remote';
 import { inject, injectable, postConstruct } from 'inversify';
 import { Command, CommandContribution, CommandRegistry, isOSX, isWindows, MenuModelRegistry, MenuContribution, Disposable, nls } from '../../common';
 import {
@@ -25,13 +23,13 @@ import {
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { FrontendApplicationStateService, FrontendApplicationState } from '../../browser/frontend-application-state';
 import { FrontendApplicationConfigProvider } from '../../browser/frontend-application-config-provider';
-import { RequestTitleBarStyle, Restart, TitleBarStyleAtStartup, TitleBarStyleChanged } from '../../electron-common/messaging/electron-messages';
 import { ZoomLevel } from '../window/electron-window-preferences';
 import { BrowserMenuBarContribution } from '../../browser/menu/browser-menu-plugin';
 import { WindowService } from '../../browser/window/window-service';
 import { WindowTitleService } from '../../browser/window/window-title-service';
 
 import '../../../src/electron-browser/menu/electron-menu-style.css';
+import { MenuDto } from '../../electron-common/electron-api';
 
 export namespace ElectronCommands {
     export const TOGGLE_DEVELOPER_TOOLS = Command.toDefaultLocalizedCommand({
@@ -131,38 +129,38 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         // OSX: Recreate the menus when changing windows.
         // OSX only has one menu bar for all windows, so we need to swap
         // between them as the user switches windows.
-        const targetWindow = electronRemote.getCurrentWindow();
-        const callback = () => this.setMenu(app);
-        targetWindow.on('focus', callback);
-        window.addEventListener('unload', () => targetWindow.off('focus', callback));
+        const disposeHandler = window.electronTheiaCore.onWindowEvent('focus', () => {
+            this.setMenu(app);
+        });
+        window.addEventListener('unload', () => disposeHandler.dispose());
     }
 
     protected attachMenuBarVisibilityListener(): void {
         this.preferenceService.onPreferenceChanged(e => {
             if (e.preferenceName === 'window.menuBarVisibility') {
-                const targetWindow = electronRemote.getCurrentWindow();
-                this.handleFullScreen(targetWindow, e.newValue);
+                this.handleFullScreen(e.newValue);
             }
         });
     }
 
     handleTitleBarStyling(app: FrontendApplication): void {
         this.hideTopPanel(app);
-        electron.ipcRenderer.on(TitleBarStyleAtStartup, (_event, style: string) => {
+        window.electronTheiaCore.getTitleBarStyleAtStartup().then(style => {
             this.titleBarStyle = style;
             this.setMenu(app);
             this.preferenceService.ready.then(() => {
                 this.preferenceService.set('window.titleBarStyle', this.titleBarStyle, PreferenceScope.User);
             });
         });
-        electron.ipcRenderer.send(RequestTitleBarStyle);
+
         this.preferenceService.ready.then(() => {
-            electronRemote.getCurrentWindow().setMenuBarVisibility(['classic', 'visible'].includes(this.preferenceService.get('window.menuBarVisibility', 'classic')));
+            window.electronTheiaCore.setMenuBarVisible(['classic', 'visible'].includes(this.preferenceService.get('window.menuBarVisibility', 'classic')));
         });
+
         this.preferenceService.onPreferenceChanged(change => {
             if (change.preferenceName === 'window.titleBarStyle') {
-                if (this.titleBarStyleChangeFlag && this.titleBarStyle !== change.newValue && electronRemote.getCurrentWindow().isFocused()) {
-                    electron.ipcRenderer.send(TitleBarStyleChanged, change.newValue);
+                if (this.titleBarStyleChangeFlag && this.titleBarStyle !== change.newValue) {
+                    window.electronTheiaCore.setTitleBarStyle(change.newValue);
                     this.handleRequiredRestart();
                 }
                 this.titleBarStyleChangeFlag = true;
@@ -197,21 +195,18 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         }
     }
 
-    protected setMenu(app: FrontendApplication, electronMenu: electron.Menu | null = this.factory.createElectronMenuBar(),
-        electronWindow: electron.BrowserWindow = electronRemote.getCurrentWindow()): void {
-        if (isOSX) {
-            electronRemote.Menu.setApplicationMenu(electronMenu);
-        } else {
+    protected setMenu(app: FrontendApplication, electronMenu: MenuDto[] | undefined = this.factory.createElectronMenuBar()): void {
+        if (!isOSX) {
             this.hideTopPanel(app);
             if (this.titleBarStyle === 'custom' && !this.menuBar) {
-                this.createCustomTitleBar(app, electronWindow);
+                this.createCustomTitleBar(app);
+                return;
             }
-            // Unix/Windows: Set the per-window menus
-            electronWindow.setMenu(electronMenu);
         }
+        window.electronTheiaCore.setMenu(electronMenu);
     }
 
-    protected createCustomTitleBar(app: FrontendApplication, electronWindow: electron.BrowserWindow): void {
+    protected createCustomTitleBar(app: FrontendApplication): void {
         const dragPanel = new Widget();
         dragPanel.id = 'theia-drag-panel';
         app.shell.addWidget(dragPanel, { area: 'top' });
@@ -220,13 +215,13 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         const controls = document.createElement('div');
         controls.id = 'window-controls';
         controls.append(
-            this.createControlButton('minimize', () => electronWindow.minimize()),
-            this.createControlButton('maximize', () => electronWindow.maximize()),
-            this.createControlButton('restore', () => electronWindow.unmaximize()),
-            this.createControlButton('close', () => electronWindow.close())
+            this.createControlButton('minimize', () => window.electronTheiaCore.minimize()),
+            this.createControlButton('maximize', () => window.electronTheiaCore.maximize()),
+            this.createControlButton('restore', () => window.electronTheiaCore.unMaximize()),
+            this.createControlButton('close', () => window.electronTheiaCore.close())
         );
         app.shell.topPanel.node.append(controls);
-        this.handleWindowControls(electronWindow);
+        this.handleWindowControls();
     }
 
     protected createCustomTitleWidget(app: FrontendApplication): void {
@@ -236,13 +231,13 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         }
     }
 
-    protected handleWindowControls(electronWindow: electron.BrowserWindow): void {
+    protected handleWindowControls(): void {
         toggleControlButtons();
-        electronWindow.on('maximize', toggleControlButtons);
-        electronWindow.on('unmaximize', toggleControlButtons);
+        window.electronTheiaCore.onWindowEvent('maximize', toggleControlButtons);
+        window.electronTheiaCore.onWindowEvent('unmaximize', toggleControlButtons);
 
         function toggleControlButtons(): void {
-            if (electronWindow.isMaximized()) {
+            if (window.electronTheiaCore.isMaximized()) {
                 document.body.classList.add('maximized');
             } else {
                 document.body.classList.remove('maximized');
@@ -275,22 +270,15 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         });
         if (await dialog.open()) {
             this.windowService.setSafeToShutDown();
-            electron.ipcRenderer.send(Restart);
+            window.electronTheiaCore.restart();
         }
     }
 
     registerCommands(registry: CommandRegistry): void {
 
-        const currentWindow = electronRemote.getCurrentWindow();
-
         registry.registerCommand(ElectronCommands.TOGGLE_DEVELOPER_TOOLS, {
             execute: () => {
-                const webContent = electronRemote.getCurrentWebContents();
-                if (!webContent.isDevToolsOpened()) {
-                    webContent.openDevTools();
-                } else {
-                    webContent.closeDevTools();
-                }
+                window.electronTheiaCore.toggleDevTools();
             }
         });
 
@@ -298,14 +286,14 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
             execute: () => this.windowService.reload()
         });
         registry.registerCommand(ElectronCommands.CLOSE_WINDOW, {
-            execute: () => currentWindow.close()
+            execute: () => window.electronTheiaCore.close()
         });
 
         registry.registerCommand(ElectronCommands.ZOOM_IN, {
-            execute: () => {
-                const webContents = currentWindow.webContents;
+            execute: async () => {
+                const currentLevel = await window.electronTheiaCore.getZoomLevel();
                 // When starting at a level that is not a multiple of 0.5, increment by at most 0.5 to reach the next highest multiple of 0.5.
-                let zoomLevel = (Math.floor(webContents.zoomLevel / ZoomLevel.VARIATION) * ZoomLevel.VARIATION) + ZoomLevel.VARIATION;
+                let zoomLevel = (Math.floor(currentLevel / ZoomLevel.VARIATION) * ZoomLevel.VARIATION) + ZoomLevel.VARIATION;
                 if (zoomLevel > ZoomLevel.MAX) {
                     zoomLevel = ZoomLevel.MAX;
                     return;
@@ -314,10 +302,10 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
             }
         });
         registry.registerCommand(ElectronCommands.ZOOM_OUT, {
-            execute: () => {
-                const webContents = currentWindow.webContents;
+            execute: async () => {
+                const currentLevel = await window.electronTheiaCore.getZoomLevel();
                 // When starting at a level that is not a multiple of 0.5, decrement by at most 0.5 to reach the next lowest multiple of 0.5.
-                let zoomLevel = (Math.ceil(webContents.zoomLevel / ZoomLevel.VARIATION) * ZoomLevel.VARIATION) - ZoomLevel.VARIATION;
+                let zoomLevel = (Math.ceil(currentLevel / ZoomLevel.VARIATION) * ZoomLevel.VARIATION) - ZoomLevel.VARIATION;
                 if (zoomLevel < ZoomLevel.MIN) {
                     zoomLevel = ZoomLevel.MIN;
                     return;
@@ -328,10 +316,11 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         registry.registerCommand(ElectronCommands.RESET_ZOOM, {
             execute: () => this.preferenceService.set('window.zoomLevel', ZoomLevel.DEFAULT, PreferenceScope.User)
         });
+
         registry.registerCommand(ElectronCommands.TOGGLE_FULL_SCREEN, {
-            isEnabled: () => currentWindow.isFullScreenable(),
-            isVisible: () => currentWindow.isFullScreenable(),
-            execute: () => this.toggleFullScreen(currentWindow)
+            isEnabled: () => window.electronTheiaCore.isFullScreenable(),
+            isVisible: () => window.electronTheiaCore.isFullScreenable(),
+            execute: () => this.toggleFullScreen()
         });
     }
 
@@ -408,16 +397,16 @@ export class ElectronMenuContribution extends BrowserMenuBarContribution impleme
         });
     }
 
-    protected toggleFullScreen(currentWindow: electron.BrowserWindow): void {
-        currentWindow.setFullScreen(!currentWindow.isFullScreen());
+    protected toggleFullScreen(): void {
+        window.electronTheiaCore.toggleFullScreen();
         const menuBarVisibility = this.preferenceService.get('window.menuBarVisibility', 'classic');
-        this.handleFullScreen(currentWindow, menuBarVisibility);
+        this.handleFullScreen(menuBarVisibility);
     }
 
-    protected handleFullScreen(currentWindow: electron.BrowserWindow, menuBarVisibility: string): void {
-        const shouldShowTop = !currentWindow.isFullScreen() || menuBarVisibility === 'visible';
+    protected handleFullScreen(menuBarVisibility: string): void {
+        const shouldShowTop = !window.electronTheiaCore.isFullScreen() || menuBarVisibility === 'visible';
         if (this.titleBarStyle === 'native') {
-            currentWindow.menuBarVisible = shouldShowTop;
+            window.electronTheiaCore.setMenuBarVisible(shouldShowTop);
         } else if (shouldShowTop) {
             this.shell.topPanel.show();
         } else {

package/src/electron-browser/messaging/electron-ipc-connection-provider.ts

@@ -14,12 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Event as ElectronEvent, ipcRenderer } from '@theia/electron/shared/electron';
 import { injectable, interfaces } from 'inversify';
 import { JsonRpcProxy } from '../../common/messaging';
 import { AbstractConnectionProvider } from '../../common/messaging/abstract-connection-provider';
-import { THEIA_ELECTRON_IPC_CHANNEL_NAME } from '../../electron-common/messaging/electron-connection-handler';
-import { AbstractChannel, Channel, Disposable, WriteBuffer } from '../../common';
+import { AbstractChannel, Channel, WriteBuffer } from '../../common';
 import { Uint8ArrayReadBuffer, Uint8ArrayWriteBuffer } from '../../common/message-rpc/uint8-array-message-buffer';
 
 export interface ElectronIpcOptions {
@@ -50,16 +48,13 @@ export class ElectronIpcRendererChannel extends AbstractChannel {
 
     constructor() {
         super();
-        const ipcMessageHandler = (_event: ElectronEvent, data: Uint8Array) => this.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data));
-        ipcRenderer.on(THEIA_ELECTRON_IPC_CHANNEL_NAME, ipcMessageHandler);
-        this.toDispose.push(Disposable.create(() => ipcRenderer.removeListener(THEIA_ELECTRON_IPC_CHANNEL_NAME, ipcMessageHandler)));
+        this.toDispose.push(window.electronTheiaCore.onData(data => this.onMessageEmitter.fire(() => new Uint8ArrayReadBuffer(data))));
+
     }
 
     getWriteBuffer(): WriteBuffer {
         const writer = new Uint8ArrayWriteBuffer();
-        writer.onCommit(buffer =>
-            ipcRenderer.send(THEIA_ELECTRON_IPC_CHANNEL_NAME, buffer)
-        );
+        writer.onCommit(buffer => window.electronTheiaCore.sendData(buffer));
         return writer;
     }