@theia/core 1.55.1 → 1.57.0-next.112

package/src/browser/test/jsdom.ts

@@ -43,7 +43,12 @@ export function enableJSDOM(): () => void {
     });
     (global as any)['document'] = dom.window.document;
     (global as any)['window'] = dom.window;
-    (global as any)['navigator'] = { userAgent: 'node.js', platform: 'Mac' };
+    try {
+        (global as any)['navigator'] = { userAgent: 'node.js', platform: 'Mac' };
+
+    } catch (e) {
+        // node 21+ already has a navigator object
+    }
 
     const toCleanup: string[] = [];
     Object.getOwnPropertyNames((dom.window as any)).forEach(property => {

package/src/browser/tree/tree-decorator.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from 'inversify';
+import { injectable, unmanaged } from 'inversify';
 import { Tree, TreeNode } from './tree';
 import { Event, Emitter, Disposable, DisposableCollection, MaybePromise } from '../../common';
 import { WidgetDecoration } from '../widget-decoration';
@@ -170,7 +170,7 @@ export abstract class AbstractTreeDecoratorService implements TreeDecoratorServi
 
     protected readonly toDispose = new DisposableCollection();
 
-    constructor(protected readonly decorators: ReadonlyArray<TreeDecorator>) {
+    constructor(@unmanaged() protected readonly decorators: ReadonlyArray<TreeDecorator>) {
         this.toDispose.push(this.onDidChangeDecorationsEmitter);
         this.toDispose.pushAll(this.decorators.map(decorator =>
             decorator.onDidChangeDecorations(data =>

package/src/browser/tree/tree-view-welcome-widget.tsx

@@ -19,28 +19,35 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 // some code is copied and modified from: https://github.com/microsoft/vscode/blob/573e5145ae3b50523925a6f6315d373e649d1b06/src/vs/base/common/linkedText.ts
+// aligned the API and enablement behavior to https://github.com/microsoft/vscode/blob/c711bc9333ba339fde1a530de0094b3fa32f09de/src/vs/base/common/linkedText.ts
 
 import React = require('react');
 import { inject, injectable } from 'inversify';
-import { CommandRegistry } from '../../common';
+import { URI as CodeUri } from 'vscode-uri';
+import { CommandRegistry, DisposableCollection } from '../../common';
+import URI from '../../common/uri';
 import { ContextKeyService } from '../context-key-service';
+import { LabelIcon, LabelParser } from '../label-parser';
+import { OpenerService, open } from '../opener-service';
+import { codicon } from '../widgets';
+import { WindowService } from '../window/window-service';
 import { TreeModel } from './tree-model';
 import { TreeWidget } from './tree-widget';
-import { WindowService } from '../window/window-service';
 
-interface ViewWelcome {
+export interface ViewWelcome {
     readonly view: string;
     readonly content: string;
     readonly when?: string;
+    readonly enablement?: string;
     readonly order: number;
 }
 
-interface IItem {
+export interface IItem {
     readonly welcomeInfo: ViewWelcome;
     visible: boolean;
 }
 
-interface ILink {
+export interface ILink {
     readonly label: string;
     readonly href: string;
     readonly title?: string;
@@ -60,6 +67,14 @@ export class TreeViewWelcomeWidget extends TreeWidget {
     @inject(WindowService)
     protected readonly windowService: WindowService;
 
+    @inject(LabelParser)
+    protected readonly labelParser: LabelParser;
+
+    @inject(OpenerService)
+    protected readonly openerService: OpenerService;
+
+    protected readonly toDisposeBeforeUpdateViewWelcomeNodes = new DisposableCollection();
+
     protected viewWelcomeNodes: React.ReactNode[] = [];
     protected defaultItem: IItem | undefined;
     protected items: IItem[] = [];
@@ -130,13 +145,31 @@ export class TreeViewWelcomeWidget extends TreeWidget {
 
     protected updateViewWelcomeNodes(): void {
         this.viewWelcomeNodes = [];
+        this.toDisposeBeforeUpdateViewWelcomeNodes.dispose();
         const items = this.visibleItems.sort((a, b) => a.order - b.order);
 
-        for (const [iIndex, { content }] of items.entries()) {
+        const enablementKeys: Set<string>[] = [];
+        // the plugin-view-registry will push the changes when there is a change in the `when` prop  which controls the visibility
+        // this listener is to update the enablement of the components in the view welcome
+        this.toDisposeBeforeUpdateViewWelcomeNodes.push(
+            this.contextService.onDidChange(event => {
+                if (enablementKeys.some(keys => event.affects(keys))) {
+                    this.updateViewWelcomeNodes();
+                    this.update();
+                }
+            })
+        );
+        // Note: VS Code does not support the `renderSecondaryButtons` prop in welcome content either.
+        for (const { content, enablement } of items) {
+            const itemEnablementKeys = enablement
+                ? this.contextService.parseKeys(enablement)
+                : undefined;
+            if (itemEnablementKeys) {
+                enablementKeys.push(itemEnablementKeys);
+            }
             const lines = content.split('\n');
 
-            for (let [lIndex, line] of lines.entries()) {
-                const lineKey = `${iIndex}-${lIndex}`;
+            for (let line of lines) {
                 line = line.trim();
 
                 if (!line) {
@@ -146,42 +179,35 @@ export class TreeViewWelcomeWidget extends TreeWidget {
                 const linkedTextItems = this.parseLinkedText(line);
 
                 if (linkedTextItems.length === 1 && typeof linkedTextItems[0] !== 'string') {
+                    const node = linkedTextItems[0];
                     this.viewWelcomeNodes.push(
-                        this.renderButtonNode(linkedTextItems[0], lineKey)
+                        this.renderButtonNode(
+                            node,
+                            this.viewWelcomeNodes.length,
+                            enablement
+                        )
                     );
                 } else {
-                    const linkedTextNodes: React.ReactNode[] = [];
-
-                    for (const [nIndex, node] of linkedTextItems.entries()) {
-                        const linkedTextKey = `${lineKey}-${nIndex}`;
-
-                        if (typeof node === 'string') {
-                            linkedTextNodes.push(
-                                this.renderTextNode(node, linkedTextKey)
-                            );
-                        } else {
-                            linkedTextNodes.push(
-                                this.renderCommandLinkNode(node, linkedTextKey)
-                            );
-                        }
-                    }
+                    const renderNode = (item: LinkedTextItem, index: number) => typeof item == 'string'
+                        ? this.renderTextNode(item, index)
+                        : this.renderLinkNode(item, index, enablement);
 
                     this.viewWelcomeNodes.push(
-                        <div key={`line-${lineKey}`}>
-                            {...linkedTextNodes}
-                        </div>
+                        <p key={`p-${this.viewWelcomeNodes.length}`}>
+                            {...linkedTextItems.flatMap(renderNode)}
+                        </p>
                     );
                 }
             }
         }
     }
 
-    protected renderButtonNode(node: ILink, lineKey: string): React.ReactNode {
+    protected renderButtonNode(node: ILink, lineKey: string | number, enablement: string | undefined): React.ReactNode {
         return (
             <div key={`line-${lineKey}`} className='theia-WelcomeViewButtonWrapper'>
                 <button title={node.title}
                     className='theia-button theia-WelcomeViewButton'
-                    disabled={!this.isEnabledClick(node.href)}
+                    disabled={!this.isEnabledClick(enablement)}
                     onClick={e => this.openLinkOrCommand(e, node.href)}>
                     {node.label}
                 </button>
@@ -189,14 +215,22 @@ export class TreeViewWelcomeWidget extends TreeWidget {
         );
     }
 
-    protected renderTextNode(node: string, textKey: string): React.ReactNode {
-        return <span key={`text-${textKey}`}>{node}</span>;
+    protected renderTextNode(node: string, textKey: string | number): React.ReactNode {
+        return <span key={`text-${textKey}`}>
+            {this.labelParser.parse(node)
+                .map((segment, index) =>
+                    LabelIcon.is(segment)
+                        ? <span
+                            key={index}
+                            className={codicon(segment.name)}
+                        />
+                        : <span key={index}>{segment}</span>)}</span>;
     }
 
-    protected renderCommandLinkNode(node: ILink, linkKey: string): React.ReactNode {
+    protected renderLinkNode(node: ILink, linkKey: string | number, enablement: string | undefined): React.ReactNode {
         return (
             <a key={`link-${linkKey}`}
-                className={this.getLinkClassName(node.href)}
+                className={this.getLinkClassName(node.href, enablement)}
                 title={node.title || ''}
                 onClick={e => this.openLinkOrCommand(e, node.href)}>
                 {node.label}
@@ -204,37 +238,39 @@ export class TreeViewWelcomeWidget extends TreeWidget {
         );
     }
 
-    protected getLinkClassName(href: string): string {
+    protected getLinkClassName(href: string, enablement: string | undefined): string {
         const classNames = ['theia-WelcomeViewCommandLink'];
-        if (!this.isEnabledClick(href)) {
+        // Only command-backed links can be disabled. All other, https:, file: remain enabled
+        if (href.startsWith('command:') && !this.isEnabledClick(enablement)) {
             classNames.push('disabled');
         }
         return classNames.join(' ');
     }
 
-    protected isEnabledClick(href: string): boolean {
-        if (href.startsWith('command:')) {
-            const command = href.replace('command:', '');
-            return this.commands.isEnabled(command);
-        }
-        return true;
+    protected isEnabledClick(enablement: string | undefined): boolean {
+        return typeof enablement === 'string'
+            ? this.contextService.match(enablement)
+            : true;
     }
 
-    protected openLinkOrCommand = (event: React.MouseEvent, href: string): void => {
+    protected openLinkOrCommand = (event: React.MouseEvent, value: string): void => {
         event.stopPropagation();
 
-        if (href.startsWith('command:')) {
-            const command = href.replace('command:', '');
+        if (value.startsWith('command:')) {
+            const command = value.replace('command:', '');
             this.commands.executeCommand(command);
+        } else if (value.startsWith('file:')) {
+            const uri = value.replace('file:', '');
+            open(this.openerService, new URI(CodeUri.file(uri).toString()));
         } else {
-            this.windowService.openNewWindow(href, { external: true });
+            this.windowService.openNewWindow(value, { external: true });
         }
     };
 
     protected parseLinkedText(text: string): LinkedTextItem[] {
         const result: LinkedTextItem[] = [];
 
-        const linkRegex = /\[([^\]]+)\]\(((?:https?:\/\/|command:)[^\)\s]+)(?: ("|')([^\3]+)(\3))?\)/gi;
+        const linkRegex = /\[([^\]]+)\]\(((?:https?:\/\/|command:|file:)[^\)\s]+)(?: (["'])(.+?)(\3))?\)/gi;
         let index = 0;
         let match: RegExpExecArray | null;
 

package/src/browser/tree/tree-widget.tsx

@@ -32,7 +32,7 @@ import { notEmpty } from '../../common/objects';
 import { isOSX } from '../../common/os';
 import { ReactWidget } from '../widgets/react-widget';
 import * as React from 'react';
-import { Virtuoso, VirtuosoHandle } from 'react-virtuoso';
+import { Virtuoso, VirtuosoHandle, VirtuosoProps } from 'react-virtuoso';
 import { TopDownTreeIterator } from './tree-iterator';
 import { SearchBox, SearchBoxFactory, SearchBoxProps } from './search-box';
 import { TreeSearch } from './tree-search';
@@ -111,6 +111,10 @@ export interface TreeProps {
      */
     readonly expandOnlyOnExpansionToggleClick?: boolean;
 
+    /**
+     * Props that are forwarded to the virtuoso list rendered. Defaults to `{}`.
+     */
+    readonly viewProps?: VirtuosoProps<unknown, unknown>;
 }
 
 /**
@@ -498,6 +502,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 rows={rows}
                 renderNodeRow={this.renderNodeRow}
                 scrollToRow={this.scrollToRow}
+                {...this.props.viewProps}
             />;
         }
         // eslint-disable-next-line no-null/no-null
@@ -1546,7 +1551,7 @@ export namespace TreeWidget {
     /**
      * Representation of the tree view properties.
      */
-    export interface ViewProps {
+    export interface ViewProps extends VirtuosoProps<unknown, unknown> {
         /**
          * The width property.
          */
@@ -1568,7 +1573,7 @@ export namespace TreeWidget {
     export class View extends React.Component<ViewProps> {
         list: VirtuosoHandle | undefined;
         override render(): React.ReactNode {
-            const { rows, width, height, scrollToRow } = this.props;
+            const { rows, width, height, scrollToRow, renderNodeRow, ...other } = this.props;
             return <Virtuoso
                 ref={list => {
                     this.list = (list || undefined);
@@ -1580,11 +1585,12 @@ export namespace TreeWidget {
                     }
                 }}
                 totalCount={rows.length}
-                itemContent={index => this.props.renderNodeRow(rows[index])}
+                itemContent={index => renderNodeRow(rows[index])}
                 width={width}
                 height={height}
                 // This is a pixel value, it will scan 200px to the top and bottom of the current view
                 overscan={500}
+                {...other}
             />;
         }
     }

package/src/browser/widgets/select-component.tsx

@@ -325,7 +325,7 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
 
         return <div key="dropdown" className="theia-select-component-dropdown" style={{
             top: invert ? 'none' : this.state.dimensions.bottom,
-            bottom: invert ? shellArea.top + shellArea.height - this.state.dimensions.top : 'none',
+            bottom: invert ? shellArea.top - this.state.dimensions.top : 'none',
             left: this.alignLeft ? this.state.dimensions.left : 'none',
             right: this.alignLeft ? 'none' : shellArea.width - this.state.dimensions.right,
             width: Math.min(Math.max(this.state.dimensions.width, this.optimalWidth), maxWidth),

package/src/browser/widgets/widget.ts

@@ -24,6 +24,7 @@ import { KeyCode, KeysOrKeyCodes } from '../keyboard/keys';
 
 import PerfectScrollbar from 'perfect-scrollbar';
 import { PreviewableWidget } from '../widgets/previewable-widget';
+import { Slot } from '@phosphor/signaling';
 
 decorate(injectable(), Widget);
 decorate(unmanaged(), Widget, 0);
@@ -116,7 +117,7 @@ export class BaseWidget extends Widget implements PreviewableWidget {
     protected scrollBar?: PerfectScrollbar;
     protected scrollOptions?: PerfectScrollbar.Options;
 
-    constructor(options?: Widget.IOptions) {
+    constructor(@unmanaged() options?: Widget.IOptions) {
         super(options);
     }
 
@@ -364,23 +365,37 @@ function waitForVisible(widget: Widget, visible: boolean, attached?: boolean): P
     });
 }
 
+const pinnedTitles = new Map<Title<Widget>, [boolean, Slot<Widget, void>]>();
+
 export function isPinned(title: Title<Widget>): boolean {
     const pinnedState = !title.closable && title.className.includes(PINNED_CLASS);
     return pinnedState;
 }
 
-export function unpin(title: Title<Widget>): void {
-    title.closable = true;
-    title.className = title.className.replace(PINNED_CLASS, '').trim();
-}
-
 export function pin(title: Title<Widget>): void {
+    const l = () => {
+        pinnedTitles.delete(title);
+    };
+    pinnedTitles.set(title, [title.closable, l]);
+    title.owner.disposed.connect(l);
     title.closable = false;
     if (!title.className.includes(PINNED_CLASS)) {
         title.className += ` ${PINNED_CLASS}`;
     }
 }
 
+export function unpin(title: Title<Widget>): void {
+    const entry = pinnedTitles.get(title);
+    if (entry) {
+        title.owner.disposed.disconnect(entry[1]);
+        title.closable = entry[0];
+        pinnedTitles.delete(title);
+    } else {
+        title.closable = true;
+    }
+    title.className = title.className.replace(PINNED_CLASS, '').trim();
+}
+
 export function isLocked(title: Title<Widget>): boolean {
     return title.className.includes(LOCKED_CLASS);
 }

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

@@ -22,6 +22,8 @@ import { ClipboardService } from '../clipboard-service';
 import { BrowserClipboardService } from '../browser-clipboard-service';
 import { SecondaryWindowService } from './secondary-window-service';
 import { DefaultSecondaryWindowService } from './default-secondary-window-service';
+import { bindContributionProvider } from '../../common';
+import { WindowTitleContribution } from './window-title-service';
 
 export default new ContainerModule(bind => {
     bind(DefaultWindowService).toSelf().inSingletonScope();
@@ -29,4 +31,5 @@ export default new ContainerModule(bind => {
     bind(FrontendApplicationContribution).toService(DefaultWindowService);
     bind(ClipboardService).to(BrowserClipboardService).inSingletonScope();
     bind(SecondaryWindowService).to(DefaultSecondaryWindowService).inSingletonScope();
+    bindContributionProvider(bind, WindowTitleContribution);
 });

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

@@ -20,11 +20,15 @@ import { ExtractableWidget } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { Saveable } from '../saveable';
 import { PreferenceService } from '../preferences';
-import { environment } from '../../common';
+import { Emitter, environment, Event } from '../../common';
 import { SaveableService } from '../saveable-service';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
+    protected readonly onWindowOpenedEmitter = new Emitter<Window>;
+    readonly onWindowOpened: Event<Window> = this.onWindowOpenedEmitter.event;
+    protected readonly onWindowClosedEmitter = new Emitter<Window>;
+    readonly onWindowClosed: Event<Window> = this.onWindowClosedEmitter.event;
     // secondary-window.html is part of Theia's generated code. It is generated by dev-packages/application-manager/src/generator/frontend-generator.ts
     protected static SECONDARY_WINDOW_URL = 'secondary-window.html';
 
@@ -94,6 +98,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
         const newWindow = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, this.nextWindowId(), options) ?? undefined;
         if (newWindow) {
             this.secondaryWindows.push(newWindow);
+            this.onWindowOpenedEmitter.fire(newWindow);
             newWindow.addEventListener('DOMContentLoaded', () => {
                 newWindow.addEventListener('beforeunload', evt => {
                     const saveable = Saveable.get(widget);
@@ -113,6 +118,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
 
                     const extIndex = this.secondaryWindows.indexOf(newWindow);
                     if (extIndex > -1) {
+                        this.onWindowClosedEmitter.fire(newWindow);
                         this.secondaryWindows.splice(extIndex, 1);
                     };
                 });

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

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { Event } from '../../common';
 import { ApplicationShell } from '../shell';
 import { ExtractableWidget } from '../widgets';
 
@@ -33,6 +34,8 @@ export interface SecondaryWindowService {
      * @returns the created window or `undefined` if it could not be created
      */
     createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined;
+    readonly onWindowOpened: Event<Window>;
+    readonly onWindowClosed: Event<Window>;
 
     /** Handles focussing the given secondary window in the browser and on Electron. */
     focus(win: Window): void;

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

@@ -14,11 +14,17 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, named, postConstruct } from 'inversify';
 import { escapeRegExpCharacters } from '../../common/strings';
 import { Emitter, Event } from '../../common/event';
 import { CorePreferences } from '../core-preferences';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+import { ContributionProvider } from '../../common';
+
+export const WindowTitleContribution = Symbol('WindowTitleAddOnContribution');
+export interface WindowTitleContribution {
+    enhanceTitle(title: string, parts: Map<string, string | undefined>): string;
+}
 
 export const InitialWindowTitleParts = {
     activeEditorShort: undefined,
@@ -43,6 +49,9 @@ export class WindowTitleService {
     @inject(CorePreferences)
     protected readonly preferences: CorePreferences;
 
+    @inject(ContributionProvider) @named(WindowTitleContribution)
+    protected readonly titleContributions: ContributionProvider<WindowTitleContribution>;
+
     protected _title = '';
     protected titleTemplate?: string;
 
@@ -95,6 +104,10 @@ export class WindowTitleService {
             }
             const separatedTitle = title.split('${separator}').filter(e => e.trim().length > 0);
             this._title = separatedTitle.join(this.separator);
+            const contributions = this.titleContributions.getContributions();
+            for (const contribution of contributions) {
+                this._title = contribution.enhanceTitle(this.title, this.titleParts);
+            }
         }
         const developmentHost = this.titleParts.get('developmentHost');
         if (developmentHost) {

package/src/common/performance/stopwatch.ts

@@ -16,7 +16,7 @@
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { inject, injectable } from 'inversify';
+import { inject, injectable, unmanaged } from 'inversify';
 import { ILogger, LogLevel } from '../logger';
 import { MaybePromise } from '../types';
 import { Measurement, MeasurementOptions, MeasurementResult } from './measurement';
@@ -58,7 +58,7 @@ export abstract class Stopwatch {
         return this.onDidAddMeasurementResultEmitter.event;
     }
 
-    constructor(protected readonly defaultLogOptions: LogOptions) {
+    constructor(@unmanaged() protected readonly defaultLogOptions: LogOptions) {
         if (!defaultLogOptions.defaultLogLevel) {
             defaultLogOptions.defaultLogLevel = DEFAULT_LOG_LEVEL;
         }

package/src/common/resource.ts

@@ -60,6 +60,8 @@ export interface Resource extends Disposable {
     readonly onDidChangeReadOnly?: Event<boolean | MarkdownString>;
 
     readonly readOnly?: boolean | MarkdownString;
+
+    readonly initiallyDirty?: boolean;
     /**
      * Reads latest content of this resource.
      *
@@ -378,11 +380,13 @@ export class UntitledResourceResolver implements ResourceResolver {
 export class UntitledResource implements Resource {
 
     protected readonly onDidChangeContentsEmitter = new Emitter<void>();
+    initiallyDirty: boolean;
     get onDidChangeContents(): Event<void> {
         return this.onDidChangeContentsEmitter.event;
     }
 
     constructor(private resources: Map<string, UntitledResource>, public uri: URI, private content?: string) {
+        this.initiallyDirty = (content !== undefined && content.length > 0);
         this.resources.set(this.uri.toString(), this);
     }
 

package/src/common/theme.ts

@@ -38,7 +38,7 @@ export interface ThemeChangeEvent {
 }
 
 export interface ThemeColor {
-    id: string;
+    readonly id: string;
 }
 
 export interface ThemeIcon {

package/src/electron-browser/menu/electron-context-menu-renderer.ts

@@ -23,7 +23,7 @@ import {
 import { ElectronMainMenuFactory } from './electron-main-menu-factory';
 import { ContextMenuContext } from '../../browser/menu/context-menu-context';
 import { MenuPath, MenuContribution, MenuModelRegistry } from '../../common';
-import { BrowserContextMenuRenderer } from '../../browser/menu/browser-context-menu-renderer';
+import { BrowserContextMenuAccess, BrowserContextMenuRenderer } from '../../browser/menu/browser-context-menu-renderer';
 
 export class ElectronContextMenuAccess extends ContextMenuAccess {
     constructor(readonly menuHandle: Promise<number>) {
@@ -115,7 +115,15 @@ export class ElectronContextMenuRenderer extends BrowserContextMenuRenderer {
             this.context.resetAltPressed();
             return new ElectronContextMenuAccess(menuHandle);
         } else {
-            return super.doRender(options);
+            const menuAccess = super.doRender(options);
+            const node = (menuAccess as BrowserContextMenuAccess).menu.node;
+            const topPanelHeight = document.getElementById('theia-top-panel')?.clientHeight ?? 0;
+            // ensure the context menu is not displayed outside of the main area
+            if (node.style.top && parseInt(node.style.top.substring(0, node.style.top.length - 2)) < topPanelHeight) {
+                node.style.top = `${topPanelHeight}px`;
+                node.style.maxHeight = `calc(${node.style.maxHeight} - ${topPanelHeight}px)`;
+            }
+            return menuAccess;
         }
     }
 

package/src/electron-browser/messaging/electron-local-ws-connection-source.ts

@@ -23,6 +23,11 @@ export function getLocalPort(): string | undefined {
     return params.get('localPort') ?? undefined;
 }
 
+export function getCurrentPort(): string | undefined {
+    const params = new URLSearchParams(location.search);
+    return params.get('port') ?? undefined;
+}
+
 @injectable()
 export class ElectronLocalWebSocketConnectionSource extends WebSocketConnectionSource {
 

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

@@ -30,6 +30,8 @@ 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';
+import { bindContributionProvider } from '../../common';
+import { WindowTitleContribution } from '../../browser/window/window-title-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ElectronMainWindowService).toDynamicValue(context =>
@@ -45,4 +47,5 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(SecondaryWindowService).to(ElectronSecondaryWindowService).inSingletonScope();
     bind(ExternalAppOpenHandler).toSelf().inSingletonScope();
     bind(OpenHandler).toService(ExternalAppOpenHandler);
+    bindContributionProvider(bind, WindowTitleContribution);
 });