@theia/core 1.53.0-next.6 → 1.53.0

package/src/browser/widgets/split-widget.ts

@@ -0,0 +1,163 @@
+// *****************************************************************************
+// Copyright (C) 2024 1C-Soft LLC 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Emitter } from 'vscode-languageserver-protocol';
+import { ApplicationShell, StatefulWidget } from '../shell';
+import { BaseWidget, Message, PanelLayout, SplitPanel, Widget } from './widget';
+import { CompositeSaveable, Saveable, SaveableSource } from '../saveable';
+import { Navigatable } from '../navigatable-types';
+import { URI } from '../../common';
+
+/**
+ * A widget containing a number of panes in a split layout.
+ */
+export class SplitWidget extends BaseWidget implements ApplicationShell.TrackableWidgetProvider, SaveableSource, Navigatable, StatefulWidget {
+
+    protected readonly splitPanel: SplitPanel;
+
+    protected readonly onDidChangeTrackableWidgetsEmitter = new Emitter<Widget[]>();
+    readonly onDidChangeTrackableWidgets = this.onDidChangeTrackableWidgetsEmitter.event;
+
+    protected readonly compositeSaveable = new CompositeSaveable();
+
+    protected navigatable?: Navigatable;
+
+    constructor(options?: SplitPanel.IOptions & { navigatable?: Navigatable }) {
+        super();
+
+        this.toDispose.pushAll([this.onDidChangeTrackableWidgetsEmitter]);
+
+        this.addClass('theia-split-widget');
+
+        const layout = new PanelLayout();
+        this.layout = layout;
+        const that = this;
+        this.splitPanel = new class extends SplitPanel {
+
+            protected override onChildAdded(msg: Widget.ChildMessage): void {
+                super.onChildAdded(msg);
+                that.onPaneAdded(msg.child);
+            }
+
+            protected override onChildRemoved(msg: Widget.ChildMessage): void {
+                super.onChildRemoved(msg);
+                that.onPaneRemoved(msg.child);
+            }
+        }({
+            spacing: 1, // --theia-border-width
+            ...options
+        });
+        this.splitPanel.node.tabIndex = -1;
+        layout.addWidget(this.splitPanel);
+
+        this.navigatable = options?.navigatable;
+    }
+
+    get orientation(): SplitPanel.Orientation {
+        return this.splitPanel.orientation;
+    }
+
+    set orientation(value: SplitPanel.Orientation) {
+        this.splitPanel.orientation = value;
+    }
+
+    relativeSizes(): number[] {
+        return this.splitPanel.relativeSizes();
+    }
+
+    setRelativeSizes(sizes: number[]): void {
+        this.splitPanel.setRelativeSizes(sizes);
+    }
+
+    get handles(): readonly HTMLDivElement[] {
+        return this.splitPanel.handles;
+    }
+
+    get saveable(): Saveable {
+        return this.compositeSaveable;
+    }
+
+    getResourceUri(): URI | undefined {
+        return this.navigatable?.getResourceUri();
+    }
+
+    createMoveToUri(resourceUri: URI): URI | undefined {
+        return this.navigatable?.createMoveToUri(resourceUri);
+    }
+
+    storeState(): SplitWidget.State {
+        return { orientation: this.orientation, widgets: this.panes, relativeSizes: this.relativeSizes() };
+    }
+
+    restoreState(oldState: SplitWidget.State): void {
+        const { orientation, widgets, relativeSizes } = oldState;
+        if (orientation) {
+            this.orientation = orientation;
+        }
+        for (const widget of widgets) {
+            this.addPane(widget);
+        }
+        if (relativeSizes) {
+            this.setRelativeSizes(relativeSizes);
+        }
+    }
+
+    get panes(): readonly Widget[] {
+        return this.splitPanel.widgets;
+    }
+
+    getTrackableWidgets(): Widget[] {
+        return [...this.panes];
+    }
+
+    protected fireDidChangeTrackableWidgets(): void {
+        this.onDidChangeTrackableWidgetsEmitter.fire(this.getTrackableWidgets());
+    }
+
+    addPane(pane: Widget): void {
+        this.splitPanel.addWidget(pane);
+    }
+
+    insertPane(index: number, pane: Widget): void {
+        this.splitPanel.insertWidget(index, pane);
+    }
+
+    protected onPaneAdded(pane: Widget): void {
+        if (Saveable.isSource(pane)) {
+            this.compositeSaveable.add(pane.saveable);
+        }
+        this.fireDidChangeTrackableWidgets();
+    }
+
+    protected onPaneRemoved(pane: Widget): void {
+        if (Saveable.isSource(pane)) {
+            this.compositeSaveable.remove(pane.saveable);
+        }
+        this.fireDidChangeTrackableWidgets();
+    }
+
+    protected override onActivateRequest(msg: Message): void {
+        this.splitPanel.node.focus();
+    }
+}
+
+export namespace SplitWidget {
+    export interface State {
+        orientation?: SplitPanel.Orientation;
+        widgets: readonly Widget[]; // note: don't rename this property; it has special meaning for `ShellLayoutRestorer`
+        relativeSizes?: number[];
+    }
+}

package/src/common/event.ts

@@ -89,6 +89,12 @@ export namespace Event {
         return new Promise(resolve => once(event)(resolve));
     }
 
+    export function filter<T>(event: Event<T>, predicate: (e: T) => unknown): Event<T>;
+    export function filter<T, S extends T>(event: Event<T>, predicate: (e: T) => e is S): Event<S>;
+    export function filter<T>(event: Event<T>, predicate: (e: T) => unknown): Event<T> {
+        return (listener, thisArg, disposables) => event(e => predicate(e) && listener.call(thisArg, e), undefined, disposables);
+    }
+
     /**
      * Given an event and a `map` function, returns another event which maps each element
      * through the mapping function.

package/src/common/json-schema.ts

@@ -36,6 +36,8 @@ export interface IJSONSchema {
     $id?: string;
     $schema?: string;
     type?: JsonType | JsonType[];
+    owner?: string;
+    group?: string;
     title?: string;
     default?: JSONValue;
     definitions?: IJSONSchemaMap;

package/src/common/menu/menu-types.ts

@@ -68,6 +68,7 @@ export interface MenuNodeBase extends MenuNodeMetadata, MenuNodeRenderingData {
  * A menu entry representing an action, e.g. "New File".
  */
 export interface MenuAction extends MenuNodeRenderingData, Pick<MenuNodeMetadata, 'when'> {
+
     /**
      * The command to execute.
      */

package/src/electron-browser/electron-uri-handler.ts

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// Copyright (C) 2024 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { FrontendApplicationContribution, OpenerService } from '../browser';
+
+import { injectable, inject } from 'inversify';
+import { URI } from '../common';
+
+@injectable()
+export class ElectronUriHandlerContribution implements FrontendApplicationContribution {
+    @inject(OpenerService)
+    protected readonly openenerService: OpenerService;
+
+    initialize(): void {
+        window.electronTheiaCore.setOpenUrlHandler(async url => {
+            const uri = new URI(url);
+            try {
+                const handler = await this.openenerService.getOpener(uri);
+                if (handler) {
+                    await handler.open(uri);
+                    return true;
+                }
+            } catch (e) {
+                // no handler
+            }
+            return false;
+        });
+    }
+}

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

@@ -117,7 +117,7 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         const maxWidget = document.getElementsByClassName(MAXIMIZED_CLASS);
         if (preference === 'visible' || (preference === 'classic' && maxWidget.length === 0)) {
             const menuModel = this.menuProvider.getMenu(MAIN_MENU_BAR);
-            this._menu = this.fillMenuTemplate([], menuModel, [], { honorDisabled: false, rootMenuPath: MAIN_MENU_BAR });
+            this._menu = this.fillMenuTemplate([], menuModel, [], { honorDisabled: false, rootMenuPath: MAIN_MENU_BAR }, false);
             if (isOSX) {
                 this._menu.unshift(this.createOSXMenu());
             }
@@ -130,13 +130,14 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
 
     createElectronContextMenu(menuPath: MenuPath, args?: any[], context?: HTMLElement, contextKeyService?: ContextMatcher, skipSingleRootNode?: boolean): MenuDto[] {
         const menuModel = skipSingleRootNode ? this.menuProvider.removeSingleRootNode(this.menuProvider.getMenu(menuPath), menuPath) : this.menuProvider.getMenu(menuPath);
-        return this.fillMenuTemplate([], menuModel, args, { showDisabled: true, context, rootMenuPath: menuPath, contextKeyService });
+        return this.fillMenuTemplate([], menuModel, args, { showDisabled: true, context, rootMenuPath: menuPath, contextKeyService }, true);
     }
 
     protected fillMenuTemplate(parentItems: MenuDto[],
         menu: MenuNode,
         args: unknown[] = [],
-        options: ElectronMenuOptions
+        options: ElectronMenuOptions,
+        skipRoot: boolean
     ): MenuDto[] {
         const showDisabled = options?.showDisabled !== false;
         const honorDisabled = options?.honorDisabled !== false;
@@ -148,13 +149,13 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
             }
             const children = CompoundMenuNode.getFlatChildren(menu.children);
             const myItems: MenuDto[] = [];
-            children.forEach(child => this.fillMenuTemplate(myItems, child, args, options));
+            children.forEach(child => this.fillMenuTemplate(myItems, child, args, options, false));
             if (myItems.length === 0) {
                 return parentItems;
             }
-            if (role === CompoundMenuNodeRole.Submenu) {
+            if (!skipRoot && role === CompoundMenuNodeRole.Submenu) {
                 parentItems.push({ label: menu.label, submenu: myItems });
-            } else if (role === CompoundMenuNodeRole.Group && menu.id !== 'inline') {
+            } else {
                 if (parentItems.length && parentItems[parentItems.length - 1].type !== 'separator') {
                     parentItems.push({ type: 'separator' });
                 }

package/src/electron-browser/preload.ts

@@ -26,7 +26,8 @@ import {
     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_REQUEST_SECONDARY_CLOSE, CHANNEL_SET_BACKGROUND_COLOR,
-    CHANNEL_WC_METADATA, CHANNEL_ABOUT_TO_CLOSE, CHANNEL_OPEN_WITH_SYSTEM_APP
+    CHANNEL_WC_METADATA, CHANNEL_ABOUT_TO_CLOSE, CHANNEL_OPEN_WITH_SYSTEM_APP,
+    CHANNEL_OPEN_URL
 } from '../electron-common/electron-api';
 
 // eslint-disable-next-line import/no-extraneous-dependencies
@@ -38,6 +39,16 @@ let nextHandlerId = 0;
 const mainMenuId = 0;
 let nextMenuId = mainMenuId + 1;
 
+let openUrlHandler: ((url: string) => Promise<boolean>) | undefined;
+
+ipcRenderer.on(CHANNEL_OPEN_URL, async (event: Electron.IpcRendererEvent, url: string, replyChannel: string) => {
+    if (openUrlHandler) {
+        event.sender.send(replyChannel, await openUrlHandler(url));
+    } else {
+        event.sender.send(replyChannel, false);
+    }
+});
+
 function convertMenu(menu: MenuDto[] | undefined, handlerMap: Map<number, () => void>): InternalMenuDto[] | undefined {
     if (!menu) {
         return undefined;
@@ -135,6 +146,10 @@ const api: TheiaCoreAPI = {
         return Disposable.create(() => ipcRenderer.off(CHANNEL_ABOUT_TO_CLOSE, h));
     },
 
+    setOpenUrlHandler(handler: (url: string) => Promise<boolean>): void {
+        openUrlHandler = handler;
+    },
+
     onWindowEvent: function (event: WindowEvent, handler: () => void): Disposable {
         const h = (_event: unknown, evt: WindowEvent) => {
             if (event === evt) {

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

@@ -29,6 +29,7 @@ import { ElectronSecondaryWindowService } from './electron-secondary-window-serv
 import { bindWindowPreferences } from './electron-window-preferences';
 import { ElectronWindowService } from './electron-window-service';
 import { ExternalAppOpenHandler } from './external-app-open-handler';
+import { ElectronUriHandlerContribution } from '../electron-uri-handler';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ElectronMainWindowService).toDynamicValue(context =>
@@ -37,6 +38,8 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bindWindowPreferences(bind);
     bind(WindowService).to(ElectronWindowService).inSingletonScope();
     bind(FrontendApplicationContribution).toService(WindowService);
+    bind(ElectronUriHandlerContribution).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(ElectronUriHandlerContribution);
     bind(ClipboardService).to(ElectronClipboardService).inSingletonScope();
     rebind(FrontendApplicationStateService).to(ElectronFrontendApplicationStateService).inSingletonScope();
     bind(SecondaryWindowService).to(ElectronSecondaryWindowService).inSingletonScope();

package/src/electron-browser/window/external-app-open-handler.ts

@@ -36,7 +36,7 @@ export class ExternalAppOpenHandler implements OpenHandler {
     async open(uri: URI): Promise<undefined> {
         // For files 'file:' scheme, system accepts only the path.
         // For other protocols e.g. 'vscode:' we use the full URI to propagate target app information.
-        window.electronTheiaCore.openWithSystemApp(uri.scheme === 'file' ? uri.path.fsPath() : uri.toString(true));
+        window.electronTheiaCore.openWithSystemApp(uri.toString(true));
         return undefined;
     }
 }

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

@@ -74,6 +74,8 @@ export interface TheiaCoreAPI {
     onAboutToClose(handler: () => void): Disposable;
     setCloseRequestHandler(handler: (reason: StopReason) => Promise<boolean>): void;
 
+    setOpenUrlHandler(handler: (url: string) => Promise<boolean>): void;
+
     setSecondaryWindowCloseRequestHandler(windowName: string, handler: () => Promise<boolean>): void;
 
     toggleDevTools(): void;
@@ -129,6 +131,7 @@ export const CHANNEL_MAXIMIZE = 'Maximize';
 export const CHANNEL_IS_MAXIMIZED = 'IsMaximized';
 
 export const CHANNEL_ABOUT_TO_CLOSE = 'AboutToClose';
+export const CHANNEL_OPEN_URL = 'OpenUrl';
 
 export const CHANNEL_UNMAXIMIZE = 'UnMaximize';
 export const CHANNEL_ON_WINDOW_EVENT = 'OnWindowEvent';

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

@@ -54,7 +54,8 @@ import {
     CHANNEL_SET_BACKGROUND_COLOR,
     CHANNEL_WC_METADATA,
     CHANNEL_ABOUT_TO_CLOSE,
-    CHANNEL_OPEN_WITH_SYSTEM_APP
+    CHANNEL_OPEN_WITH_SYSTEM_APP,
+    CHANNEL_OPEN_URL
 } from '../electron-common/electron-api';
 import { ElectronMainApplication, ElectronMainApplicationContribution } from './electron-main-application';
 import { Disposable, DisposableCollection, isOSX, MaybePromise } from '../common';
@@ -165,8 +166,8 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
             shell.showItemInFolder(fsPath);
         });
 
-        ipcMain.on(CHANNEL_OPEN_WITH_SYSTEM_APP, (event, fsPath) => {
-            shell.openPath(fsPath);
+        ipcMain.on(CHANNEL_OPEN_WITH_SYSTEM_APP, (event, uri) => {
+            shell.openExternal(uri);
         });
 
         ipcMain.handle(CHANNEL_GET_TITLE_STYLE_AT_STARTUP, event => application.getTitleBarStyleAtStartup(event.sender));
@@ -241,9 +242,20 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
         });
     }
 
+    private isASCI(accelerator: string | undefined): boolean {
+        if (typeof accelerator !== 'string') {
+            return false;
+        }
+        for (let i = 0; i < accelerator.length; i++) {
+            if (accelerator.charCodeAt(i) > 127) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     fromMenuDto(sender: WebContents, menuId: number, menuDto: InternalMenuDto[]): MenuItemConstructorOptions[] {
         return menuDto.map(dto => {
-
             const result: MenuItemConstructorOptions = {
                 id: dto.id,
                 label: dto.label,
@@ -252,7 +264,7 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
                 enabled: dto.enabled,
                 visible: dto.visible,
                 role: dto.role,
-                accelerator: dto.accelerator
+                accelerator: this.isASCI(dto.accelerator) ? dto.accelerator : undefined
             };
             if (dto.submenu) {
                 result.submenu = this.fromMenuDto(sender, menuId, dto.submenu);
@@ -274,6 +286,20 @@ export namespace TheiaRendererAPI {
         wc.send(CHANNEL_ON_WINDOW_EVENT, event);
     }
 
+    export function openUrl(wc: WebContents, url: string): Promise<boolean> {
+        return new Promise<boolean>(resolve => {
+            const channelNr = nextReplyChannel++;
+            const replyChannel = `openUrl${channelNr}`;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const l = createDisposableListener(ipcMain, replyChannel, (e, args: any[]) => {
+                l.dispose();
+                resolve(args[0]);
+            });
+
+            wc.send(CHANNEL_OPEN_URL, url, replyChannel);
+        });
+    }
+
     export function sendAboutToClose(wc: WebContents): Promise<void> {
         return new Promise<void>(resolve => {
             const channelNr = nextReplyChannel++;

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

@@ -117,13 +117,13 @@ export class ElectronMainProcessArgv {
         return 1;
     }
 
-    protected get isBundledElectronApp(): boolean {
+    get isBundledElectronApp(): boolean {
         // process.defaultApp is either set by electron in an electron unbundled app, or undefined
         // see https://github.com/electron/electron/blob/master/docs/api/process.md#processdefaultapp-readonly
         return this.isElectronApp && !(process as ElectronMainProcessArgv.ElectronMainProcess).defaultApp;
     }
 
-    protected get isElectronApp(): boolean {
+    get isElectronApp(): boolean {
         // process.versions.electron is either set by electron, or undefined
         // see https://github.com/electron/electron/blob/master/docs/api/process.md#processversionselectron-readonly
         return !!(process as ElectronMainProcessArgv.ElectronMainProcess).versions.electron;
@@ -183,6 +183,7 @@ export class ElectronMainApplication {
     protected customBackgroundColor?: string;
     protected didUseNativeWindowFrameOnStart = new Map<number, boolean>();
     protected windows = new Map<number, TheiaElectronWindow>();
+    protected activeWindowStack: number[] = [];
     protected restarting = false;
 
     /** Used to temporarily store the reference to an early created main window */
@@ -229,7 +230,7 @@ export class ElectronMainApplication {
                     this.useNativeWindowFrame = this.getTitleBarStyle(config) === 'native';
                     this._config = config;
                     this.hookApplicationEvents();
-                    this.showInitialWindow();
+                    this.showInitialWindow(argv.includes('--open-url') ? argv[argv.length - 1] : undefined);
                     const port = await this.startBackend();
                     this._backendPort.resolve(port);
                     await app.whenReady();
@@ -317,7 +318,7 @@ export class ElectronMainApplication {
             !('THEIA_ELECTRON_NO_EARLY_WINDOW' in process.env && process.env.THEIA_ELECTRON_NO_EARLY_WINDOW === '1');
     }
 
-    protected showInitialWindow(): void {
+    protected showInitialWindow(urlToOpen: string | undefined): void {
         if (this.isShowWindowEarly() || this.isShowSplashScreen()) {
             app.whenReady().then(async () => {
                 const options = await this.getLastWindowOptions();
@@ -326,7 +327,11 @@ export class ElectronMainApplication {
                     options.preventAutomaticShow = true;
                 }
                 this.initialWindow = await this.createWindow({ ...options });
-
+                TheiaRendererAPI.onApplicationStateChanged(this.initialWindow.webContents, state => {
+                    if (state === 'ready' && urlToOpen) {
+                        this.openUrl(urlToOpen);
+                    }
+                });
                 if (this.isShowSplashScreen()) {
                     console.log('Showing splash screen');
                     this.configureAndShowSplashScreen(this.initialWindow);
@@ -410,11 +415,25 @@ export class ElectronMainApplication {
         options = this.avoidOverlap(options);
         const electronWindow = this.windowFactory(options, this.config);
         const id = electronWindow.window.webContents.id;
+        this.activeWindowStack.push(id);
         this.windows.set(id, electronWindow);
-        electronWindow.onDidClose(() => this.windows.delete(id));
+        electronWindow.onDidClose(() => {
+            const stackIndex = this.activeWindowStack.indexOf(id);
+            if (stackIndex >= 0) {
+                this.activeWindowStack.splice(stackIndex, 1);
+            }
+            this.windows.delete(id);
+        });
         electronWindow.window.on('maximize', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'maximize'));
         electronWindow.window.on('unmaximize', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'unmaximize'));
-        electronWindow.window.on('focus', () => TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'focus'));
+        electronWindow.window.on('focus', () => {
+            const stackIndex = this.activeWindowStack.indexOf(id);
+            if (stackIndex >= 0) {
+                this.activeWindowStack.splice(stackIndex, 1);
+            }
+            this.activeWindowStack.unshift(id);
+            TheiaRendererAPI.sendWindowEvent(electronWindow.window.webContents, 'focus');
+        });
         this.attachSaveWindowState(electronWindow.window);
 
         return electronWindow.window;
@@ -521,6 +540,15 @@ export class ElectronMainApplication {
         }
     }
 
+    async openUrl(url: string): Promise<void> {
+        for (const id of this.activeWindowStack) {
+            const window = this.windows.get(id);
+            if (window && await window.openUrl(url)) {
+                break;
+            }
+        }
+    }
+
     protected async createWindowUri(params: WindowSearchParams = {}): Promise<URI> {
         if (!('port' in params)) {
             params.port = (await this.backendPort).toString();
@@ -696,6 +724,16 @@ export class ElectronMainApplication {
         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));
+
+        if (isWindows) {
+            const args = this.processArgv.isBundledElectronApp ? [] : [app.getAppPath()];
+            args.push('--open-url');
+            app.setAsDefaultProtocolClient(this.config.electron.uriScheme, process.execPath, args);
+        } else {
+            app.on('open-url', (evt, url) => {
+                this.openUrl(url);
+            });
+        }
     }
 
     protected onWillQuit(event: ElectronEvent): void {
@@ -703,19 +741,23 @@ export class ElectronMainApplication {
     }
 
     protected async onSecondInstance(event: ElectronEvent, argv: string[], cwd: string): Promise<void> {
-        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();
+        if (argv.includes('--open-url')) {
+            this.openUrl(argv[argv.length - 1]);
+        } else {
+            createYargs(this.processArgv.getProcessArgvWithoutBin(argv), process.cwd())
+                .help(false)
+                .command('$0 [file]', false,
+                    cmd => cmd
+                        .positional('file', { type: 'string' }),
+                    async args => {
+                        await this.handleMainCommand({
+                            file: args.file,
+                            cwd: process.cwd(),
+                            secondInstance: true
+                        });
+                    },
+                ).parse();
+        }
     }
 
     protected onWebContentsCreated(event: ElectronEvent, webContents: WebContents): void {

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

@@ -58,6 +58,7 @@ enum ClosingState {
 
 @injectable()
 export class TheiaElectronWindow {
+
     @inject(TheiaBrowserWindowOptions) protected readonly options: TheiaBrowserWindowOptions;
     @inject(WindowApplicationConfig) protected readonly config: WindowApplicationConfig;
     @inject(ElectronMainApplicationGlobals) protected readonly globals: ElectronMainApplicationGlobals;
@@ -202,6 +203,10 @@ export class TheiaElectronWindow {
         this.toDispose.push(TheiaRendererAPI.onRequestReload(this.window.webContents, (newUrl?: string) => this.reload(newUrl)));
     }
 
+    openUrl(url: string): Promise<boolean> {
+        return TheiaRendererAPI.openUrl(this.window.webContents, url);
+    }
+
     dispose(): void {
         this.toDispose.dispose();
     }

package/src/node/i18n/theia-localization-contribution.ts

@@ -20,17 +20,21 @@ import { LocalizationContribution, LocalizationRegistry } from './localization-c
 @injectable()
 export class TheiaLocalizationContribution implements LocalizationContribution {
     async registerLocalizations(registry: LocalizationRegistry): Promise<void> {
-        registry.registerLocalizationFromRequire('cs', require('../../../i18n/nls.cs.json'));
-        registry.registerLocalizationFromRequire('de', require('../../../i18n/nls.de.json'));
-        registry.registerLocalizationFromRequire('es', require('../../../i18n/nls.es.json'));
+        // Attempt to use the same languages as VS Code
+        // See https://code.visualstudio.com/docs/getstarted/locales#_available-locales
+        registry.registerLocalizationFromRequire('zh-cn', require('../../../i18n/nls.zh-cn.json'));
+        registry.registerLocalizationFromRequire('zh-tw', require('../../../i18n/nls.zh-tw.json'));
         registry.registerLocalizationFromRequire('fr', require('../../../i18n/nls.fr.json'));
-        registry.registerLocalizationFromRequire('hu', require('../../../i18n/nls.hu.json'));
+        registry.registerLocalizationFromRequire('de', require('../../../i18n/nls.de.json'));
         registry.registerLocalizationFromRequire('it', require('../../../i18n/nls.it.json'));
+        registry.registerLocalizationFromRequire('es', require('../../../i18n/nls.es.json'));
         registry.registerLocalizationFromRequire('ja', require('../../../i18n/nls.ja.json'));
-        registry.registerLocalizationFromRequire('pl', require('../../../i18n/nls.pl.json'));
-        registry.registerLocalizationFromRequire('pt-br', require('../../../i18n/nls.pt-br.json'));
-        registry.registerLocalizationFromRequire('pt-pt', require('../../../i18n/nls.pt-pt.json'));
+        registry.registerLocalizationFromRequire('ko', require('../../../i18n/nls.ko.json'));
         registry.registerLocalizationFromRequire('ru', require('../../../i18n/nls.ru.json'));
-        registry.registerLocalizationFromRequire('zh-cn', require('../../../i18n/nls.zh-cn.json'));
+        registry.registerLocalizationFromRequire('pt-br', require('../../../i18n/nls.pt-br.json'));
+        registry.registerLocalizationFromRequire('tr', require('../../../i18n/nls.tr.json'));
+        registry.registerLocalizationFromRequire('pl', require('../../../i18n/nls.pl.json'));
+        registry.registerLocalizationFromRequire('cs', require('../../../i18n/nls.cs.json'));
+        registry.registerLocalizationFromRequire('hu', require('../../../i18n/nls.hu.json'));
     }
 }