@theia/core 1.50.1 → 1.52.0

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

@@ -56,7 +56,11 @@ export interface TheiaCoreAPI {
     focusWindow(name?: string): void;
 
     showItemInFolder(fsPath: string): void;
-    openWithSystemApp(fsPath: string): void;
+
+    /**
+     * @param location The location to open with the system app. This can be a file path or a URL.
+     */
+    openWithSystemApp(location: string): void;
 
     getTitleBarStyleAtStartup(): Promise<string>;
     setTitleBarStyle(style: string): void;
@@ -80,7 +84,7 @@ export interface TheiaCoreAPI {
     isFullScreen(): boolean; // TODO: this should really be async, since it blocks the renderer process
     toggleFullScreen(): void;
 
-    requestReload(): void;
+    requestReload(newUrl?: string): void;
     restart(): void;
 
     applicationStateChanged(state: FrontendApplicationState): void;

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

@@ -15,7 +15,10 @@
 // *****************************************************************************
 
 import { inject, injectable, named } from 'inversify';
-import { screen, app, BrowserWindow, WebContents, Event as ElectronEvent, BrowserWindowConstructorOptions, nativeImage, nativeTheme } from '../../electron-shared/electron';
+import {
+    screen, app, BrowserWindow, WebContents, Event as ElectronEvent, BrowserWindowConstructorOptions, nativeImage,
+    nativeTheme, shell, dialog
+} from '../../electron-shared/electron';
 import * as path from 'path';
 import { Argv } from 'yargs';
 import { AddressInfo } from 'net';
@@ -31,7 +34,7 @@ import { ContributionProvider } from '../common/contribution-provider';
 import { ElectronSecurityTokenService } from './electron-security-token-service';
 import { ElectronSecurityToken } from '../electron-common/electron-token';
 import Storage = require('electron-store');
-import { CancellationTokenSource, Disposable, DisposableCollection, isOSX, isWindows } from '../common';
+import { CancellationTokenSource, Disposable, DisposableCollection, Path, isOSX, isWindows } from '../common';
 import { DEFAULT_WINDOW_HASH, WindowSearchParams } from '../common/window';
 import { TheiaBrowserWindowOptions, TheiaElectronWindow, TheiaElectronWindowFactory } from './theia-electron-window';
 import { ElectronMainApplicationGlobals } from './electron-main-constants';
@@ -349,6 +352,9 @@ export class ElectronMainApplication {
             alwaysOnTop: true,
             show: false,
             transparent: true,
+            webPreferences: {
+                backgroundThrottling: false
+            }
         });
 
         if (this.isShowWindowEarly()) {
@@ -410,7 +416,6 @@ export class ElectronMainApplication {
         electronWindow.window.on('unmaximize', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'unmaximize'));
         electronWindow.window.on('focus', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'focus'));
         this.attachSaveWindowState(electronWindow.window);
-        this.configureNativeSecondaryWindowCreation(electronWindow.window);
 
         return electronWindow.window;
     }
@@ -458,6 +463,7 @@ export class ElectronMainApplication {
                 // Setting the following option to `true` causes some features to break, somehow.
                 // Issue: https://github.com/eclipse-theia/theia/issues/8577
                 nodeIntegrationInWorker: false,
+                backgroundThrottling: false,
                 preload: path.resolve(this.globals.THEIA_APP_PROJECT_PATH, 'lib', 'frontend', 'preload.js').toString()
             },
             ...this.config.electron?.windowOptions || {},
@@ -488,31 +494,6 @@ export class ElectronMainApplication {
         return window;
     }
 
-    /** Configures native window creation, i.e. using window.open or links with target "_blank" in the frontend. */
-    protected configureNativeSecondaryWindowCreation(electronWindow: BrowserWindow): void {
-        electronWindow.webContents.setWindowOpenHandler(() => {
-            const { minWidth, minHeight } = this.getDefaultOptions();
-            const options: BrowserWindowConstructorOptions = {
-                ...this.getDefaultTheiaSecondaryWindowBounds(),
-                // We always need the native window frame for now because the secondary window does not have Theia's title bar by default.
-                // In 'custom' title bar mode this would leave the window without any window controls (close, min, max)
-                // TODO set to this.useNativeWindowFrame when secondary windows support a custom title bar.
-                frame: true,
-                minWidth,
-                minHeight
-            };
-            if (!this.useNativeWindowFrame) {
-                // If the main window does not have a native window frame, do not show  an icon in the secondary window's native title bar.
-                // The data url is a 1x1 transparent png
-                options.icon = nativeImage.createFromDataURL('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQI12P4DwQACfsD/WMmxY8AAAAASUVORK5CYII=');
-            }
-            return {
-                action: 'allow',
-                overrideBrowserWindowOptions: options,
-            };
-        });
-    }
-
     /**
      * "Gently" close all windows, application will not stop if a `beforeunload` handler returns `false`.
      */
@@ -714,6 +695,7 @@ export class ElectronMainApplication {
         app.on('will-quit', this.onWillQuit.bind(this));
         app.on('second-instance', this.onSecondInstance.bind(this));
         app.on('window-all-closed', this.onWindowAllClosed.bind(this));
+        app.on('web-contents-created', this.onWebContentsCreated.bind(this));
     }
 
     protected onWillQuit(event: ElectronEvent): void {
@@ -721,14 +703,73 @@ export class ElectronMainApplication {
     }
 
     protected async onSecondInstance(event: ElectronEvent, argv: string[], cwd: string): Promise<void> {
-        const electronWindows = BrowserWindow.getAllWindows();
-        if (electronWindows.length > 0) {
-            const electronWindow = electronWindows[0];
-            if (electronWindow.isMinimized()) {
-                electronWindow.restore();
+        createYargs(this.processArgv.getProcessArgvWithoutBin(argv), process.cwd())
+            .help(false)
+            .command('$0 [file]', false,
+                cmd => cmd
+                    .positional('file', { type: 'string' }),
+                async args => {
+                    this.handleMainCommand({
+                        file: args.file,
+                        cwd: process.cwd(),
+                        secondInstance: true
+                    });
+                },
+            ).parse();
+    }
+
+    protected onWebContentsCreated(event: ElectronEvent, webContents: WebContents): void {
+        // Block any in-page navigation except loading the secondary window contents
+        webContents.on('will-navigate', evt => {
+            if (new URI(evt.url).path.fsPath() !== new Path(this.globals.THEIA_SECONDARY_WINDOW_HTML_PATH).fsPath()) {
+                evt.preventDefault();
             }
-            electronWindow.focus();
-        }
+        });
+
+        webContents.setWindowOpenHandler(details => {
+            // if it's a secondary window, allow it to open
+            if (new URI(details.url).path.fsPath() === new Path(this.globals.THEIA_SECONDARY_WINDOW_HTML_PATH).fsPath()) {
+                const { minWidth, minHeight } = this.getDefaultOptions();
+                const options: BrowserWindowConstructorOptions = {
+                    ...this.getDefaultTheiaSecondaryWindowBounds(),
+                    // We always need the native window frame for now because the secondary window does not have Theia's title bar by default.
+                    // In 'custom' title bar mode this would leave the window without any window controls (close, min, max)
+                    // TODO set to this.useNativeWindowFrame when secondary windows support a custom title bar.
+                    frame: true,
+                    minWidth,
+                    minHeight
+                };
+                if (!this.useNativeWindowFrame) {
+                    // If the main window does not have a native window frame, do not show  an icon in the secondary window's native title bar.
+                    // The data url is a 1x1 transparent png
+                    options.icon = nativeImage.createFromDataURL(
+                        'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQI12P4DwQACfsD/WMmxY8AAAAASUVORK5CYII=');
+                }
+                return {
+                    action: 'allow',
+                    overrideBrowserWindowOptions: options,
+                };
+            } else {
+                const uri: URI = new URI(details.url);
+                let okToOpen = uri.scheme === 'https' || uri.scheme === 'http';
+                if (!okToOpen) {
+                    const button = dialog.showMessageBoxSync(BrowserWindow.fromWebContents(webContents)!, {
+                        message: `Open link\n\n${details.url}\n\nin the system handler?`,
+                        type: 'question',
+                        title: 'Open Link',
+                        buttons: ['OK', 'Cancel'],
+                        defaultId: 1,
+                        cancelId: 1
+                    });
+                    okToOpen = button === 0;
+                }
+                if (okToOpen) {
+                    shell.openExternal(details.url, {});
+                }
+
+                return { action: 'deny' };
+            }
+        });
     }
 
     protected onWindowAllClosed(event: ElectronEvent): void {

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

@@ -16,7 +16,8 @@
 
 export const ElectronMainApplicationGlobals = Symbol('ElectronMainApplicationGlobals');
 export interface ElectronMainApplicationGlobals {
-    readonly THEIA_APP_PROJECT_PATH: string
-    readonly THEIA_BACKEND_MAIN_PATH: string
-    readonly THEIA_FRONTEND_HTML_PATH: string
+    readonly THEIA_APP_PROJECT_PATH: string;
+    readonly THEIA_BACKEND_MAIN_PATH: string;
+    readonly THEIA_FRONTEND_HTML_PATH: string;
+    readonly THEIA_SECONDARY_WINDOW_HTML_PATH: string
 }

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

@@ -147,10 +147,14 @@ export class TheiaElectronWindow {
         return this.handleStopRequest(() => this.doCloseWindow(), reason);
     }
 
-    protected reload(): void {
+    protected reload(newUrl?: string): void {
         this.handleStopRequest(async () => {
             this.applicationState = 'init';
-            this._window.reload();
+            if (newUrl) {
+                this._window.loadURL(newUrl);
+            } else {
+                this._window.reload();
+            }
         }, StopReason.Reload);
     }
 
@@ -195,7 +199,7 @@ export class TheiaElectronWindow {
     }
 
     protected attachReloadListener(): void {
-        this.toDispose.push(TheiaRendererAPI.onRequestReload(this.window.webContents, () => this.reload()));
+        this.toDispose.push(TheiaRendererAPI.onRequestReload(this.window.webContents, (newUrl?: string) => this.reload(newUrl)));
     }
 
     dispose(): void {

package/src/node/application-server.ts

@@ -49,6 +49,10 @@ export class ApplicationServerImpl implements ApplicationServer {
         return Promise.resolve(this.applicationPackage.projectPath);
     }
 
+    getApplicationPlatform(): Promise<string> {
+        return Promise.resolve(`${process.platform}-${process.arch}`);
+    }
+
     async getBackendOS(): Promise<OS.Type> {
         return OS.type();
     }

package/src/node/messaging/websocket-frontend-connection-service.ts

@@ -105,7 +105,8 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
         socket.on('disconnect', evt => {
             console.info('socked closed');
             channel.disconnect();
-            const timeout = BackendApplicationConfigProvider.get().frontendConnectionTimeout;
+
+            const timeout = this.frontendConnectionTimeout();
             const isMarkedForClose = this.channelsMarkedForClose.delete(frontEndId);
             if (timeout === 0 || isMarkedForClose) {
                 this.closeConnection(frontEndId, evt);
@@ -124,6 +125,15 @@ export class WebsocketFrontendConnectionService implements FrontendConnectionSer
     markForClose(channelId: string): void {
         this.channelsMarkedForClose.add(channelId);
     }
+
+    private frontendConnectionTimeout(): number {
+        const envValue = Number(process.env['FRONTEND_CONNECTION_TIMEOUT']);
+        if (!isNaN(envValue)) {
+            return envValue;
+        }
+
+        return BackendApplicationConfigProvider.get().frontendConnectionTimeout;
+    }
 }
 
 class ReconnectableSocketChannel extends AbstractChannel {