@theia/core 1.50.1 → 1.52.0

package/src/browser/shell/tab-bars.ts

@@ -619,7 +619,7 @@ export class TabBarRenderer extends TabBar.Renderer {
                         cssClasses: ['extended-tab-preview'],
                         visualPreview: this.corePreferences?.['window.tabbar.enhancedPreview'] === 'visual' ? width => this.renderVisualPreview(width, title) : undefined
                     });
-                } else {
+                } else if (title.caption) {
                     this.hoverService.requestHover({
                         content: title.caption,
                         target: event.currentTarget,
@@ -1084,8 +1084,6 @@ export class SideTabBar extends ScrollableTabBar {
         startIndex: number
     };
 
-    protected _rowGap: number;
-
     constructor(options?: TabBar.IOptions<Widget> & PerfectScrollbar.Options) {
         super(options);
 
@@ -1142,31 +1140,6 @@ export class SideTabBar extends ScrollableTabBar {
         }
     }
 
-    // Queries the tabRowGap value of the content node. Needed to properly compute overflowing
-    // tabs that should be hidden
-    protected get tabRowGap(): number {
-        // We assume that the tab row gap is static i.e. we compute it once an then cache it
-        if (!this._rowGap) {
-            this._rowGap = this.computeTabRowGap();
-        }
-        return this._rowGap;
-
-    }
-
-    protected computeTabRowGap(): number {
-        const style = window.getComputedStyle(this.contentNode);
-        const rowGapStyle = style.getPropertyValue('row-gap');
-        const numericValue = parseFloat(rowGapStyle);
-        const unit = rowGapStyle.match(/[a-zA-Z]+/)?.[0];
-
-        const tempDiv = document.createElement('div');
-        tempDiv.style.height = '1' + unit;
-        document.body.appendChild(tempDiv);
-        const rowGapValue = numericValue * tempDiv.offsetHeight;
-        document.body.removeChild(tempDiv);
-        return rowGapValue;
-    }
-
     /**
      * Reveal the tab with the given index by moving it into the non-overflowing tabBar section
      * if necessary.
@@ -1207,18 +1180,13 @@ export class SideTabBar extends ScrollableTabBar {
                 const hiddenContent = this.hiddenContentNode;
                 const n = hiddenContent.children.length;
                 const renderData = new Array<Partial<SideBarRenderData>>(n);
-                const availableWidth = this.node.clientHeight - this.tabRowGap;
-                let actualWidth = 0;
-                let overflowStartIndex = -1;
                 for (let i = 0; i < n; i++) {
                     const hiddenTab = hiddenContent.children[i];
-                    // Extract tab padding from the computed style
+                    // Extract tab padding, and margin from the computed style
                     const tabStyle = window.getComputedStyle(hiddenTab);
-                    const paddingTop = parseFloat(tabStyle.paddingTop!);
-                    const paddingBottom = parseFloat(tabStyle.paddingBottom!);
                     const rd: Partial<SideBarRenderData> = {
-                        paddingTop,
-                        paddingBottom
+                        paddingTop: parseFloat(tabStyle.paddingTop!),
+                        paddingBottom: parseFloat(tabStyle.paddingBottom!)
                     };
                     // Extract label size from the DOM
                     const labelElements = hiddenTab.getElementsByClassName('p-TabBar-tabLabel');
@@ -1231,38 +1199,21 @@ export class SideTabBar extends ScrollableTabBar {
                     if (iconElements.length === 1) {
                         const icon = iconElements[0];
                         rd.iconSize = { width: icon.clientWidth, height: icon.clientHeight };
-                        actualWidth += icon.clientHeight + paddingTop + paddingBottom + this.tabRowGap;
-
-                        if (actualWidth > availableWidth && i !== 0) {
-                            rd.visible = false;
-                            if (overflowStartIndex === -1) {
-                                overflowStartIndex = i;
-                            }
-                        }
-                        renderData[i] = rd;
                     }
-                }
 
-                // Special handling if only one element is overflowing.
-                if (overflowStartIndex === n - 1 && renderData[overflowStartIndex]) {
-                    if (!this.tabsOverflowData) {
-                        overflowStartIndex--;
-                        renderData[overflowStartIndex].visible = false;
-                    } else {
-                        renderData[overflowStartIndex].visible = true;
-                        overflowStartIndex = -1;
-                    }
+                    renderData[i] = rd;
                 }
                 // Render into the visible node
                 this.renderTabs(this.contentNode, renderData);
-                this.computeOverflowingTabsData(overflowStartIndex);
+                this.computeOverflowingTabsData();
             });
         }
     }
 
-    protected computeOverflowingTabsData(startIndex: number): void {
+    protected computeOverflowingTabsData(): void {
         // ensure that render tabs has completed
         window.requestAnimationFrame(() => {
+            const startIndex = this.hideOverflowingTabs();
             if (startIndex === -1) {
                 if (this.tabsOverflowData) {
                     this.tabsOverflowData = undefined;
@@ -1286,6 +1237,38 @@ export class SideTabBar extends ScrollableTabBar {
         });
     }
 
+    /**
+     * Hide overflowing tabs and return the index of the first hidden tab.
+     */
+    protected hideOverflowingTabs(): number {
+        const availableHeight = this.node.clientHeight;
+        const invisibleClass = 'p-mod-invisible';
+        let startIndex = -1;
+        const n = this.contentNode.children.length;
+        for (let i = 0; i < n; i++) {
+            const tab = this.contentNode.children[i] as HTMLLIElement;
+            if (tab.offsetTop + tab.offsetHeight >= availableHeight) {
+                tab.classList.add(invisibleClass);
+                if (startIndex === -1) {
+                    startIndex = i;
+                    /* If only one element is overflowing and the additional menu widget is visible (i.e. this.tabsOverflowData is set)
+                     * there might already be enough space to show the last tab. In this case, we need to include the size of the
+                     * additional menu widget and recheck if the last tab is visible */
+                    if (startIndex === n - 1 && this.tabsOverflowData) {
+                        const additionalViewsMenu = this.node.parentElement?.querySelector('.theia-additional-views-menu') as HTMLDivElement;
+                        if (tab.offsetTop + tab.offsetHeight < availableHeight + additionalViewsMenu.offsetHeight) {
+                            tab.classList.remove(invisibleClass);
+                            startIndex = -1;
+                        }
+                    }
+                }
+            } else {
+                tab.classList.remove(invisibleClass);
+            }
+        }
+        return startIndex;
+    }
+
     /**
      * Render the tab bar using the given DOM element as host. The optional `renderData` is forwarded
      * to the TabBarRenderer.

package/src/browser/shell/theia-dock-panel.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { find, toArray, ArrayExt } from '@phosphor/algorithm';
+import { find, toArray } from '@phosphor/algorithm';
 import { TabBar, Widget, DockPanel, Title, DockLayout } from '@phosphor/widgets';
 import { Signal } from '@phosphor/signaling';
 import { Disposable, DisposableCollection } from '../../common/disposable';
@@ -103,7 +103,7 @@ export class TheiaDockPanel extends DockPanel {
     }
 
     findTabBar(title: Title<Widget>): TabBar<Widget> | undefined {
-        return find(this.tabBars(), bar => ArrayExt.firstIndexOf(bar.titles, title) > -1);
+        return find(this.tabBars(), bar => bar.titles.includes(title));
     }
 
     protected readonly toDisposeOnMarkAsCurrent = new DisposableCollection();
@@ -133,11 +133,14 @@ export class TheiaDockPanel extends DockPanel {
         }
     }
 
-    override addWidget(widget: Widget, options?: DockPanel.IAddOptions): void {
+    override addWidget(widget: Widget, options?: TheiaDockPanel.AddOptions): void {
         if (this.mode === 'single-document' && widget.parent === this) {
             return;
         }
         super.addWidget(widget, options);
+        if (options?.closeRef) {
+            options.ref?.close();
+        }
         this.widgetAdded.emit(widget);
         this.markActiveTabBar(widget.title);
     }
@@ -252,4 +255,11 @@ export namespace TheiaDockPanel {
     export interface Factory {
         (options?: DockPanel.IOptions): TheiaDockPanel;
     }
+
+    export interface AddOptions extends DockPanel.IAddOptions {
+        /**
+         * Whether to also close the widget referenced by `ref`.
+         */
+        closeRef?: boolean
+    }
 }

package/src/browser/style/sidepanel.css

@@ -186,23 +186,26 @@
   flex-direction: column-reverse;
 }
 
+.p-Widget .theia-sidebar-menu-item {
+    cursor: pointer;
+}
+
 .p-Widget.theia-sidebar-menu i {
   padding: var(--theia-private-sidebar-tab-padding-top-and-bottom)
     var(--theia-private-sidebar-tab-padding-left-and-right);
   display: flex;
   justify-content: center;
   align-items: center;
-  cursor: pointer;
   color: var(--theia-activityBar-inactiveForeground);
   background-color: var(--theia-activityBar-background);
   font-size: var(--theia-private-sidebar-icon-size);
 }
 
-.theia-sidebar-menu i:hover {
+.theia-sidebar-menu .theia-sidebar-menu-item:hover i {
   color: var(--theia-activityBar-foreground);
 }
 
-.theia-sidebar-menu > i.codicon-menu {
+.theia-sidebar-menu i.theia-compact-menu {
   font-size: 16px;
 }
 

package/src/browser/style/tabs.css

@@ -177,6 +177,17 @@
   padding-right: 8px;
 }
 
+.p-TabBar.theia-app-centers .p-TabBar-tabIcon[class*="plugin-icon-"],
+.p-TabBar-tab.p-mod-drag-image .p-TabBar-tabIcon[class*="plugin-icon-"] {
+  background: none;
+  height: var(--theia-icon-size);
+}
+
+.p-TabBar.theia-app-centers .p-TabBar-tabIcon[class*="plugin-icon-"]::before,
+.p-TabBar-tab.p-mod-drag-image .p-TabBar-tabIcon[class*="plugin-icon-"]::before {
+  display: inline-block;
+}
+
 /* codicons */
 .p-TabBar.theia-app-centers .p-TabBar-tabIcon.codicon,
 .p-TabBar-tab.p-mod-drag-image .p-TabBar-tabIcon.codicon {
@@ -305,7 +316,7 @@
   display: none !important;
 }
 
-.p-TabBar .theia-badge-decorator-sidebar {
+.theia-badge-decorator-sidebar {
   background-color: var(--theia-activityBarBadge-background);
   border-radius: 20px;
   color: var(--theia-activityBarBadge-foreground);

package/src/browser/widget-manager.ts

@@ -114,7 +114,7 @@ export class WidgetManager {
 
     protected _cachedFactories: Map<string, WidgetFactory>;
     protected readonly widgets = new Map<string, Widget>();
-    protected readonly pendingWidgetPromises = new Map<string, MaybePromise<Widget>>();
+    protected readonly pendingWidgetPromises = new Map<string, Promise<Widget>>();
 
     @inject(ContributionProvider) @named(WidgetFactory)
     protected readonly factoryProvider: ContributionProvider<WidgetFactory>;
@@ -207,9 +207,9 @@ export class WidgetManager {
                 return widget as T;
             }
         }
-        for (const [key, widget] of this.pendingWidgetPromises.entries()) {
+        for (const [key, widgetPromise] of this.pendingWidgetPromises.entries()) {
             if (this.testPredicate(key, factoryId, predicate)) {
-                return widget as T;
+                return widgetPromise as Promise<T>;
             }
         }
     }
@@ -244,18 +244,26 @@ export class WidgetManager {
         if (!factory) {
             throw Error("No widget factory '" + factoryId + "' has been registered.");
         }
-        try {
-            const widgetPromise = factory.createWidget(options);
-            this.pendingWidgetPromises.set(key, widgetPromise);
-            const widget = await widgetPromise;
-            await WaitUntilEvent.fire(this.onWillCreateWidgetEmitter, { factoryId, widget });
+        const widgetPromise = this.doCreateWidget<T>(factory, options).then(widget => {
             this.widgets.set(key, widget);
             widget.disposed.connect(() => this.widgets.delete(key));
             this.onDidCreateWidgetEmitter.fire({ factoryId, widget });
-            return widget as T;
-        } finally {
-            this.pendingWidgetPromises.delete(key);
+            return widget;
+        }).finally(() => this.pendingWidgetPromises.delete(key));
+        this.pendingWidgetPromises.set(key, widgetPromise);
+        return widgetPromise;
+    }
+
+    protected async doCreateWidget<T extends Widget>(factory: WidgetFactory, options?: any): Promise<T> {
+        const widget = await factory.createWidget(options);
+        // Note: the widget creation process also includes the 'onWillCreateWidget' part, which can potentially fail
+        try {
+            await WaitUntilEvent.fire(this.onWillCreateWidgetEmitter, { factoryId: factory.id, widget });
+        } catch (e) {
+            widget.dispose();
+            throw e;
         }
+        return widget as T;
     }
 
     /**

package/src/browser/widget-open-handler.ts

@@ -96,7 +96,7 @@ export abstract class WidgetOpenHandler<W extends BaseWidget> implements OpenHan
             ...options
         };
         if (!widget.isAttached) {
-            this.shell.addWidget(widget, op.widgetOptions || { area: 'main' });
+            await this.shell.addWidget(widget, op.widgetOptions || { area: 'main' });
         }
         if (op.mode === 'activate') {
             await this.shell.activateWidget(widget.id);
@@ -143,12 +143,12 @@ export abstract class WidgetOpenHandler<W extends BaseWidget> implements OpenHan
 
     protected getWidget(uri: URI, options?: WidgetOpenerOptions): Promise<W | undefined> {
         const widgetOptions = this.createWidgetOptions(uri, options);
-        return this.widgetManager.getWidget<W>(this.id, widgetOptions);
+        return this.widgetManager.getWidget(this.id, widgetOptions);
     }
 
     protected getOrCreateWidget(uri: URI, options?: WidgetOpenerOptions): Promise<W> {
         const widgetOptions = this.createWidgetOptions(uri, options);
-        return this.widgetManager.getOrCreateWidget<W>(this.id, widgetOptions);
+        return this.widgetManager.getOrCreateWidget(this.id, widgetOptions);
     }
 
     protected abstract createWidgetOptions(uri: URI, options?: WidgetOpenerOptions): Object;

package/src/browser/widgets/react-renderer.tsx

@@ -41,7 +41,10 @@ export class ReactRenderer implements Disposable {
     }
 
     render(): void {
-        this.hostRoot.render(<React.Fragment>{this.doRender()}</React.Fragment>);
+        // Ignore all render calls after the host element has unmounted
+        if (!this.toDispose.disposed) {
+            this.hostRoot.render(<React.Fragment>{this.doRender()}</React.Fragment>);
+        }
     }
 
     protected doRender(): React.ReactNode {

package/src/browser-only/frontend-only-application-module.ts

@@ -56,6 +56,7 @@ export const frontendOnlyApplicationModule = new ContainerModule((bind, unbind,
         getExtensionsInfos: async (): Promise<ExtensionInfo[]> => [],
         getApplicationInfo: async (): Promise<ApplicationInfo | undefined> => undefined,
         getApplicationRoot: async (): Promise<string> => '',
+        getApplicationPlatform: () => Promise.resolve('web'),
         getBackendOS: async (): Promise<OS.Type> => OS.Type.Linux
     };
     if (isBound(ApplicationServer)) {

package/src/common/application-protocol.ts

@@ -24,6 +24,7 @@ export interface ApplicationServer {
     getExtensionsInfos(): Promise<ExtensionInfo[]>;
     getApplicationInfo(): Promise<ApplicationInfo | undefined>;
     getApplicationRoot(): Promise<string>;
+    getApplicationPlatform(): Promise<string>;
     /**
      * @deprecated since 1.25.0. Use `OS.backend.type()` instead.
      */

package/src/common/menu/menu-model-registry.ts

@@ -18,6 +18,7 @@ import { inject, injectable, named } from 'inversify';
 import { Command, CommandRegistry } from '../command';
 import { ContributionProvider } from '../contribution-provider';
 import { Disposable } from '../disposable';
+import { Emitter, Event } from '../event';
 import { ActionMenuNode } from './action-menu-node';
 import { CompositeMenuNode, CompositeMenuNodeWrapper } from './composite-menu-node';
 import { CompoundMenuNode, MenuAction, MenuNode, MenuNodeMetadata, MenuPath, MutableCompoundMenuNode, SubMenuOptions } from './menu-types';
@@ -68,6 +69,14 @@ export class MenuModelRegistry {
     protected readonly root = new CompositeMenuNode('');
     protected readonly independentSubmenus = new Map<string, MutableCompoundMenuNode>();
 
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+
+    get onDidChange(): Event<void> {
+        return this.onDidChangeEmitter.event;
+    }
+
+    protected isReady = false;
+
     constructor(
         @inject(ContributionProvider) @named(MenuContribution)
         protected readonly contributions: ContributionProvider<MenuContribution>,
@@ -78,6 +87,7 @@ export class MenuModelRegistry {
         for (const contrib of this.contributions.getContributions()) {
             contrib.registerMenus(this);
         }
+        this.isReady = true;
     }
 
     /**
@@ -97,7 +107,9 @@ export class MenuModelRegistry {
      */
     registerMenuNode(menuPath: MenuPath | string, menuNode: MenuNode, group?: string): Disposable {
         const parent = this.getMenuNode(menuPath, group);
-        return parent.addNode(menuNode);
+        const disposable = parent.addNode(menuNode);
+        this.fireChangeEvent();
+        return this.changeEventOnDispose(disposable);
     }
 
     getMenuNode(menuPath: MenuPath | string, group?: string): MutableCompoundMenuNode {
@@ -137,13 +149,15 @@ export class MenuModelRegistry {
         const groupPath = index === 0 ? [] : menuPath.slice(0, index);
         const parent = this.findGroup(groupPath, options);
         let groupNode = this.findSubMenu(parent, menuId, options);
+        let disposable = Disposable.NULL;
         if (!groupNode) {
             groupNode = new CompositeMenuNode(menuId, label, options, parent);
-            return parent.addNode(groupNode);
+            disposable = this.changeEventOnDispose(parent.addNode(groupNode));
         } else {
             groupNode.updateOptions({ ...options, label });
-            return Disposable.NULL;
         }
+        this.fireChangeEvent();
+        return disposable;
     }
 
     registerIndependentSubmenu(id: string, label: string, options?: SubMenuOptions): Disposable {
@@ -151,7 +165,7 @@ export class MenuModelRegistry {
             console.debug(`Independent submenu with path ${id} registered, but given ID already exists.`);
         }
         this.independentSubmenus.set(id, new CompositeMenuNode(id, label, options));
-        return { dispose: () => this.independentSubmenus.delete(id) };
+        return this.changeEventOnDispose(Disposable.create(() => this.independentSubmenus.delete(id)));
     }
 
     linkSubmenu(parentPath: MenuPath | string, childId: string | MenuPath, options?: SubMenuOptions, group?: string): Disposable {
@@ -175,7 +189,9 @@ export class MenuModelRegistry {
         }
 
         const wrapper = new CompositeMenuNodeWrapper(child, parent, options);
-        return parent.addNode(wrapper);
+        const disposable = parent.addNode(wrapper);
+        this.fireChangeEvent();
+        return this.changeEventOnDispose(disposable);
     }
 
     /**
@@ -207,6 +223,7 @@ export class MenuModelRegistry {
         if (menuPath) {
             const parent = this.findGroup(menuPath);
             parent.removeNode(id);
+            this.fireChangeEvent();
             return;
         }
 
@@ -228,6 +245,7 @@ export class MenuModelRegistry {
             });
         };
         recurse(this.root);
+        this.fireChangeEvent();
     }
 
     /**
@@ -321,6 +339,19 @@ export class MenuModelRegistry {
         return true;
     }
 
+    protected changeEventOnDispose(disposable: Disposable): Disposable {
+        return Disposable.create(() => {
+            disposable.dispose();
+            this.fireChangeEvent();
+        });
+    }
+
+    protected fireChangeEvent(): void {
+        if (this.isReady) {
+            this.onDidChangeEmitter.fire();
+        }
+    }
+
     /**
      * Returns the {@link MenuPath path} at which a given menu node can be accessed from this registry, if it can be determined.
      * Returns `undefined` if the `parent` of any node in the chain is unknown.

package/src/common/preferences/preference-schema.ts

@@ -25,6 +25,11 @@ export interface PreferenceSchema {
     [name: string]: any,
     scope?: 'application' | 'window' | 'resource' | PreferenceScope,
     overridable?: boolean;
+    /**
+     * The title of the preference schema.
+     * It is used in the preference UI to associate a localized group of preferences.
+     */
+    title?: string;
     properties: PreferenceSchemaProperties
 }
 export namespace PreferenceSchema {
@@ -75,6 +80,7 @@ export interface PreferenceSchemaProperty extends PreferenceItem {
     description?: string;
     markdownDescription?: string;
     scope?: 'application' | 'machine' | 'window' | 'resource' | 'language-overridable' | 'machine-overridable' | PreferenceScope;
+    tags?: string[];
 }
 
 export interface PreferenceDataProperty extends PreferenceItem {

package/src/common/quick-pick-service.ts

@@ -18,7 +18,6 @@ import * as fuzzy from 'fuzzy';
 import { Event } from './event';
 import { KeySequence } from './keys';
 import { CancellationToken } from './cancellation';
-import { URI as Uri } from 'vscode-uri';
 
 export const quickPickServicePath = '/services/quickPick';
 export const QuickPickService = Symbol('QuickPickService');
@@ -53,7 +52,6 @@ export interface QuickPickItem {
     description?: string;
     detail?: string;
     keySequence?: KeySequence;
-    iconPath?: { light?: Uri; dark: Uri };
     iconClasses?: string[];
     alwaysShow?: boolean;
     highlights?: QuickPickItemHighlights;
@@ -94,7 +92,6 @@ export interface QuickPickValue<V> extends QuickPickItem {
 }
 
 export interface QuickInputButton {
-    iconPath?: { light?: Uri; dark: Uri };
     iconClass?: string;
     tooltip?: string;
     /**

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

@@ -101,6 +101,9 @@ export class ElectronMainMenuFactory extends BrowserMainMenuFactory {
         this.keybindingRegistry.onKeybindingsChanged(() => {
             this.setMenuBar();
         });
+        this.menuProvider.onDidChange(() => {
+            this.setMenuBar();
+        });
     }
 
     async setMenuBar(): Promise<void> {

package/src/electron-browser/preload.ts

@@ -79,8 +79,8 @@ const api: TheiaCoreAPI = {
     showItemInFolder: fsPath => {
         ipcRenderer.send(CHANNEL_SHOW_ITEM_IN_FOLDER, fsPath);
     },
-    openWithSystemApp: fsPath => {
-        ipcRenderer.send(CHANNEL_OPEN_WITH_SYSTEM_APP, fsPath);
+    openWithSystemApp: location => {
+        ipcRenderer.send(CHANNEL_OPEN_WITH_SYSTEM_APP, location);
     },
     attachSecurityToken: (endpoint: string) => ipcRenderer.invoke(CHANNEL_ATTACH_SECURITY_TOKEN, endpoint),
 
@@ -199,7 +199,7 @@ const api: TheiaCoreAPI = {
         ipcRenderer.send(CHANNEL_TOGGLE_FULL_SCREEN);
     },
 
-    requestReload: () => ipcRenderer.send(CHANNEL_REQUEST_RELOAD),
+    requestReload: (newUrl?: string) => ipcRenderer.send(CHANNEL_REQUEST_RELOAD, newUrl),
     restart: () => ipcRenderer.send(CHANNEL_RESTART),
 
     applicationStateChanged: state => {

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

@@ -15,18 +15,20 @@
 // *****************************************************************************
 
 import { ContainerModule } from 'inversify';
-import { WindowService } from '../../browser/window/window-service';
-import { ElectronWindowService } from './electron-window-service';
-import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
-import { ElectronClipboardService } from '../electron-clipboard-service';
+import { OpenHandler } from '../../browser';
 import { ClipboardService } from '../../browser/clipboard-service';
+import { FrontendApplicationContribution } from '../../browser/frontend-application-contribution';
+import { FrontendApplicationStateService } from '../../browser/frontend-application-state';
+import { SecondaryWindowService } from '../../browser/window/secondary-window-service';
+import { WindowService } from '../../browser/window/window-service';
 import { ElectronMainWindowService, electronMainWindowServicePath } from '../../electron-common/electron-main-window-service';
+import { ElectronClipboardService } from '../electron-clipboard-service';
 import { ElectronIpcConnectionProvider } from '../messaging/electron-ipc-connection-source';
-import { bindWindowPreferences } from './electron-window-preferences';
-import { FrontendApplicationStateService } from '../../browser/frontend-application-state';
 import { ElectronFrontendApplicationStateService } from './electron-frontend-application-state';
 import { ElectronSecondaryWindowService } from './electron-secondary-window-service';
-import { SecondaryWindowService } from '../../browser/window/secondary-window-service';
+import { bindWindowPreferences } from './electron-window-preferences';
+import { ElectronWindowService } from './electron-window-service';
+import { ExternalAppOpenHandler } from './external-app-open-handler';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ElectronMainWindowService).toDynamicValue(context =>
@@ -38,4 +40,6 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ClipboardService).to(ElectronClipboardService).inSingletonScope();
     rebind(FrontendApplicationStateService).to(ElectronFrontendApplicationStateService).inSingletonScope();
     bind(SecondaryWindowService).to(ElectronSecondaryWindowService).inSingletonScope();
+    bind(ExternalAppOpenHandler).toSelf().inSingletonScope();
+    bind(OpenHandler).toService(ExternalAppOpenHandler);
 });

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

@@ -100,7 +100,7 @@ export class ElectronWindowService extends DefaultWindowService {
             if (params.hash) {
                 newLocation.hash = '#' + params.hash;
             }
-            location.assign(newLocation);
+            window.electronTheiaCore.requestReload(newLocation.toString());
         } else {
             window.electronTheiaCore.requestReload();
         }

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

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox 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 { injectable } from 'inversify';
+import { OpenHandler } from '../../browser/opener-service';
+import URI from '../../common/uri';
+import { HttpOpenHandler } from '../../browser/http-open-handler';
+
+export interface ExternalAppOpenHandlerOptions {
+    openExternalApp?: boolean
+}
+
+@injectable()
+export class ExternalAppOpenHandler implements OpenHandler {
+
+    static readonly PRIORITY: number = HttpOpenHandler.PRIORITY + 100;
+    readonly id = 'external-app';
+
+    canHandle(uri: URI, options?: ExternalAppOpenHandlerOptions): number {
+        return (options && options.openExternalApp) ? ExternalAppOpenHandler.PRIORITY : -1;
+    }
+
+    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));
+        return undefined;
+    }
+}