@theia/core 1.63.0-next.52 → 1.63.1

package/src/browser/core-preferences.ts

@@ -121,6 +121,18 @@ export const corePreferenceSchema: PreferenceSchema = {
             scope: 'application',
             markdownDescription: nls.localizeByDefault('Separator used by {0}.', '`#window.title#`')
         },
+        'window.tabCloseIconPlacement': {
+            type: 'string',
+            enum: ['end', 'start'],
+            enumDescriptions: [
+                nls.localize('theia/core/window/tabCloseIconPlacement/end', 'Place the close icon at the end of the label. In left-to-right languages, this is the right side of the tab.'),
+                nls.localize('theia/core/window/tabCloseIconPlacement/start', 'Place the close icon at the start of the label. In left-to-right languages, this is the left side of the tab.'),
+            ],
+            default: 'end',
+            scope: 'application',
+            description: nls.localize('theia/core/window/tabCloseIconPlacement/description', 'Place the close icons on tab titles at the start or end of the tab. The default is end on all platforms.'),
+            included: isOSX
+        },
         'window.secondaryWindowPlacement': {
             type: 'string',
             enum: ['originalSize', 'halfWidth', 'fullSize'],
@@ -305,6 +317,7 @@ export interface CoreConfiguration {
     'window.menuBarVisibility': 'classic' | 'visible' | 'hidden' | 'compact';
     'window.title': string;
     'window.titleSeparator': string;
+    'window.tabCloseIconPlacement': 'end' | 'start';
     'workbench.list.openMode': 'singleClick' | 'doubleClick';
     'workbench.commandPalette.history': number;
     'workbench.editor.highlightModifiedTabs': boolean;

package/src/browser/hover-service.ts

@@ -107,6 +107,7 @@ export class HoverService {
             this.pendingTimeout = disposableTimeout(() => this.renderHover(request), this.getHoverDelay());
             this.hoverTarget = request.target;
             this.listenForMouseOut();
+            this.listenForMouseClick();
         }
     }
 
@@ -222,6 +223,18 @@ export class HoverService {
         this.hoverTarget = undefined;
     }
 
+    /**
+     * Listen for any mouse click (mousedown) event and cancel the hover if detected.
+     * This ensures the hover is dismissed when the user clicks anywhere (including on the target or elsewhere).
+     */
+    protected listenForMouseClick(): void {
+        const handleMouseDown = (e: MouseEvent) => {
+            this.cancelHover();
+        };
+        document.addEventListener('mousedown', handleMouseDown, true);
+        this.disposeOnHide.push({ dispose: () => document.removeEventListener('mousedown', handleMouseDown, true) });
+    }
+
     protected unRenderHover(): void {
         if (this.hoverHost.matches(':popover-open')) {
             this.hoverHost.hidePopover();

package/src/browser/menu/browser-menu-plugin.ts

@@ -329,18 +329,17 @@ export class DynamicMenuWidget extends MenuWidget {
                         if (submenu.items.length > 0) {
                             result.push({ type: 'submenu', submenu });
                         }
-                    } else {
+                    } else if (node.id !== 'inline') {
                         const items = this.createItems(nodePath, node.children, phCommandRegistry, contextMatcher, context);
                         if (items.length > 0) {
-                            if (node.id !== 'inline') {
+                            if (result[result.length - 1]?.type !== 'separator') {
                                 result.push({ type: 'separator' });
                             }
                             result.push(...items);
-                            if (node.id !== 'inline') {
-                                result.push({ type: 'separator' });
-                            }
+                            result.push({ type: 'separator' });
                         }
                     }
+
                 } else if (CommandMenu.is(node)) {
                     const id = !phCommandRegistry.hasCommand(node.id) ? node.id : `${node.id}:${DynamicMenuWidget.nextCommmandId++}`;
                     phCommandRegistry.addCommand(id, {

package/src/browser/menu/menu.spec.ts

@@ -50,7 +50,6 @@ class TestMenuNodeFactory implements MenuNodeFactory {
 }
 
 describe('menu-model-registry', () => {
-
     describe('01 #register', () => {
         it('Should allow to register menu actions.', () => {
             const fileMenu = ['main', 'File'];
@@ -86,6 +85,9 @@ describe('menu-model-registry', () => {
             const openGroup = file.children[0] as Submenu;
             expect(openGroup.children.length).equals(2);
             expect(openGroup.label).undefined;
+
+            expect(service.getMenuNode([...fileOpenMenu, 'open'])).exist;
+            expect(service.getMenuNode([...fileOpenMenu, 'Gurkensalat'])).undefined;
         });
 
         it('Should not allow to register cyclic menus.', () => {

package/src/browser/shell/application-shell.ts

@@ -601,8 +601,9 @@ export class ApplicationShell extends Widget {
                     // the files were dragged from the outside the workspace
                     Array.from(event.dataTransfer.files).forEach(async file => {
                         if (environment.electron.is()) {
-                            if (file.path) {
-                                const fileUri = URI.fromFilePath(file.path);
+                            const path = window.electronTheiaCore.getPathForFile(file);
+                            if (path) {
+                                const fileUri = URI.fromFilePath(path);
                                 openUri(fileUri);
                             }
                         } else {

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters.tsx

@@ -38,7 +38,7 @@ abstract class AbstractToolbarMenuWrapper {
     }
 
     protected abstract menuPath?: MenuPath;
-    protected abstract menuNode: MenuNode;
+    protected abstract menuNode?: MenuNode;
     protected abstract id: string;
     protected abstract icon: string | undefined;
     protected abstract tooltip: string | undefined;
@@ -61,7 +61,7 @@ abstract class AbstractToolbarMenuWrapper {
         return this.renderMenuItem(widget);
     }
 
-    toMenuNode?(): MenuNode {
+    toMenuNode?(): MenuNode | undefined {
         return this.menuNode;
     }
 
@@ -194,7 +194,7 @@ export class ToolbarSubmenuWrapper extends AbstractToolbarMenuWrapper implements
         if (this.toolbarItem.isVisible && !this.toolbarItem.isVisible(widget)) {
             return false;
         }
-        if (!menuNode.isVisible(this.effectiveMenuPath, this.contextKeyService, widget.node, widget)) {
+        if (!menuNode?.isVisible(this.effectiveMenuPath, this.contextKeyService, widget.node, widget)) {
             return false;
         }
         if (this.toolbarItem.command) {
@@ -225,14 +225,14 @@ export class ToolbarSubmenuWrapper extends AbstractToolbarMenuWrapper implements
     get tooltip(): string | undefined { return this.toolbarItem.tooltip; }
     get text(): string | undefined { return (this.toolbarItem.group === NAVIGATION || this.toolbarItem.group === undefined) ? undefined : this.toolbarItem.text; }
     get onDidChange(): Event<void> | undefined {
-        return this.menuNode.onDidChange;
+        return this.menuNode?.onDidChange;
     }
 
     get menuPath(): MenuPath {
         return this.toolbarItem.menuPath!;
     }
 
-    get menuNode(): MenuNode {
+    get menuNode(): MenuNode | undefined {
         return this.menuRegistry.getMenu(this.menuPath);
     }
 }

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-registry.ts

@@ -138,19 +138,22 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
 
         for (const delegate of this.menuDelegates.values()) {
             if (delegate.isVisible(widget)) {
-                const menu = this.menuRegistry.getMenu(delegate.menuPath)!;
-                for (const child of menu.children) {
-                    if (child.isVisible([...delegate.menuPath, child.id], this.contextKeyService, widget.node)) {
-                        if (CompoundMenuNode.is(child)) {
-                            for (const grandchild of child.children) {
-                                if (grandchild.isVisible([...delegate.menuPath, child.id, grandchild.id], this.contextKeyService, widget.node) && RenderedMenuNode.is(grandchild)) {
-                                    result.push(new ToolbarMenuNodeWrapper([...delegate.menuPath, child.id, grandchild.id], this.commandRegistry, this.menuRegistry,
-                                        this.contextKeyService, this.contextMenuRenderer, grandchild, child.id, delegate.menuPath));
+                const menu = this.menuRegistry.getMenu(delegate.menuPath);
+                if (menu) {
+                    for (const child of menu.children) {
+                        if (child.isVisible([...delegate.menuPath, child.id], this.contextKeyService, widget.node)) {
+                            if (CompoundMenuNode.is(child)) {
+                                for (const grandchild of child.children) {
+                                    if (grandchild.isVisible([...delegate.menuPath, child.id, grandchild.id],
+                                        this.contextKeyService, widget.node) && RenderedMenuNode.is(grandchild)) {
+                                        result.push(new ToolbarMenuNodeWrapper([...delegate.menuPath, child.id, grandchild.id], this.commandRegistry, this.menuRegistry,
+                                            this.contextKeyService, this.contextMenuRenderer, grandchild, child.id, delegate.menuPath));
+                                    }
                                 }
+                            } else if (CommandMenu.is(child)) {
+                                result.push(new ToolbarMenuNodeWrapper([...delegate.menuPath, child.id], this.commandRegistry, this.menuRegistry,
+                                    this.contextKeyService, this.contextMenuRenderer, child, undefined, delegate.menuPath));
                             }
-                        } else if (CommandMenu.is(child)) {
-                            result.push(new ToolbarMenuNodeWrapper([...delegate.menuPath, child.id], this.commandRegistry, this.menuRegistry,
-                                this.contextKeyService, this.contextMenuRenderer, child, undefined, delegate.menuPath));
                         }
                     }
                 }

package/src/browser/shell/tab-bar-toolbar/tab-toolbar-item.tsx

@@ -34,7 +34,7 @@ export interface TabBarToolbarItem {
     onDidChange?: Event<void>;
     group?: string;
     priority?: number;
-    toMenuNode?(): MenuNode;
+    toMenuNode?(): MenuNode | undefined;
 }
 
 /**

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

@@ -119,6 +119,15 @@ export class TabBarRenderer extends TabBar.Renderer {
                 }
             }));
         }
+        if (this.corePreferences) {
+            this.toDispose.push(
+                this.corePreferences.onPreferenceChanged(event => {
+                    if (event.preferenceName === 'window.tabCloseIconPlacement' && this._tabBar) {
+                        this._tabBar.update();
+                    }
+                })
+            );
+        }
     }
 
     dispose(): void {
@@ -160,22 +169,42 @@ export class TabBarRenderer extends TabBar.Renderer {
      * @returns {VirtualElement} The virtual element of the rendered tab.
      */
     override renderTab(data: SideBarRenderData, isInSidePanel?: boolean, isPartOfHiddenTabBar?: boolean): VirtualElement {
+        // Putting the close icon at the start is only pertinent to the horizontal orientation
+        const isHorizontal = this.tabBar?.orientation === 'horizontal';
+        const tabCloseIconStart = isHorizontal && this.corePreferences?.['window.tabCloseIconPlacement'] === 'start';
+
         const title = data.title;
         const id = this.createTabId(title, isPartOfHiddenTabBar);
         const key = this.createTabKey(data);
         const style = this.createTabStyle(data);
-        const className = this.createTabClass(data);
+        const className = `${this.createTabClass(data)}${tabCloseIconStart ? ' closeIcon-start' : ''}`;
         const dataset = this.createTabDataset(data);
         const closeIconTitle = data.title.className.includes(PINNED_CLASS)
             ? nls.localizeByDefault('Unpin')
             : nls.localizeByDefault('Close');
 
-        const hover = this.tabBar && (this.tabBar.orientation === 'horizontal' && this.corePreferences?.['window.tabbar.enhancedPreview'] === 'classic')
+        const hover = isHorizontal && this.corePreferences?.['window.tabbar.enhancedPreview'] === 'classic'
             ? { title: title.caption }
             : {
                 onmouseenter: this.handleMouseEnterEvent
             };
 
+        const tabLabel = h.div(
+            { className: 'theia-tab-icon-label' },
+            this.renderIcon(data, isInSidePanel),
+            this.renderLabel(data, isInSidePanel),
+            this.renderTailDecorations(data, isInSidePanel),
+            this.renderBadge(data, isInSidePanel),
+            this.renderLock(data, isInSidePanel)
+        );
+        const tabCloseIcon = h.div({
+            className: 'lm-TabBar-tabCloseIcon action-label',
+            title: closeIconTitle,
+            onclick: this.handleCloseClickEvent,
+        });
+
+        const tabContents = tabCloseIconStart ? [tabCloseIcon, tabLabel] : [tabLabel, tabCloseIcon];
+
         return h.li(
             {
                 ...hover,
@@ -187,19 +216,7 @@ export class TabBarRenderer extends TabBar.Renderer {
                     e.preventDefault();
                 }
             },
-            h.div(
-                { className: 'theia-tab-icon-label' },
-                this.renderIcon(data, isInSidePanel),
-                this.renderLabel(data, isInSidePanel),
-                this.renderTailDecorations(data, isInSidePanel),
-                this.renderBadge(data, isInSidePanel),
-                this.renderLock(data, isInSidePanel)
-            ),
-            h.div({
-                className: 'lm-TabBar-tabCloseIcon action-label',
-                title: closeIconTitle,
-                onclick: this.handleCloseClickEvent
-            })
+            ...tabContents
         );
     }
 

package/src/browser/style/tabs.css

@@ -237,6 +237,12 @@
   -ms-user-select: none;
 }
 
+.lm-TabBar.theia-app-centers .lm-TabBar-tab.lm-mod-closable.closeIcon-start > .lm-TabBar-tabCloseIcon,
+.lm-TabBar.theia-app-centers .lm-TabBar-tab.theia-mod-pinned.closeIcon-start > .lm-TabBar-tabCloseIcon {
+  margin-left: inherit;
+  margin-right: 4px;
+}
+
 .lm-TabBar.theia-app-centers.dynamic-tabs .lm-TabBar-tab.lm-mod-closable>.lm-TabBar-tabCloseIcon,
 .lm-TabBar.theia-app-centers.dynamic-tabs .lm-TabBar-tab.theia-mod-pinned>.lm-TabBar-tabCloseIcon {
   /* hide close icon for dynamic tabs strategy*/
@@ -254,11 +260,16 @@
   background-color: rgba(50%, 50%, 50%, 0.2);
 }
 
-.lm-TabBar.theia-app-centers .lm-TabBar-tab.lm-mod-closable,
-.lm-TabBar.theia-app-centers .lm-TabBar-tab.theia-mod-pinned {
+.lm-TabBar.theia-app-centers .lm-TabBar-tab.lm-mod-closable:not(.closeIcon-start),
+.lm-TabBar.theia-app-centers .lm-TabBar-tab.theia-mod-pinned:not(.closeIcon-start) {
   padding-right: 4px;
 }
 
+.lm-TabBar.theia-app-centers .lm-TabBar-tab.lm-mod-closable.closeIcon-start,
+.lm-TabBar.theia-app-centers .lm-TabBar-tab.theia-mod-pinned.closeIcon-start {
+  padding-left: 4px;
+}
+
 .lm-TabBar.theia-app-centers .lm-TabBar-tab.lm-mod-closable:not(.theia-mod-dirty):hover>.lm-TabBar-tabCloseIcon:before,
 .lm-TabBar.theia-app-centers .lm-TabBar-tab.lm-mod-closable:not(.theia-mod-dirty).lm-TabBar-tab.lm-mod-current>.lm-TabBar-tabCloseIcon:before,
 .lm-TabBar.theia-app-centers .lm-TabBar-tab.lm-mod-closable.theia-mod-dirty>.lm-TabBar-tabCloseIcon:hover:before {

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

@@ -61,12 +61,7 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
 
     constructor(props: SelectComponentProps) {
         super(props);
-        let selected = 0;
-        if (typeof props.defaultValue === 'number') {
-            selected = props.defaultValue;
-        } else if (typeof props.defaultValue === 'string') {
-            selected = Math.max(props.options.findIndex(e => e.value === props.defaultValue), 0);
-        }
+        const selected = this.getInitialSelectedIndex(props);
         this.state = {
             selected,
             original: selected,
@@ -83,6 +78,27 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         this.dropdownElement = list;
     }
 
+    protected getInitialSelectedIndex(props: SelectComponentProps): number {
+        let selected = 0;
+        if (typeof props.defaultValue === 'number') {
+            selected = props.defaultValue;
+        } else if (typeof props.defaultValue === 'string') {
+            selected = Math.max(props.options.findIndex(e => e.value === props.defaultValue), 0);
+        }
+        return selected;
+    }
+
+    override componentDidUpdate(prevProps: SelectComponentProps): void {
+        if (prevProps.defaultValue !== this.props.defaultValue || prevProps.options !== this.props.options) {
+            const selected = this.getInitialSelectedIndex(this.props);
+            this.setState({
+                selected,
+                original: selected,
+                hover: selected
+            });
+        }
+    }
+
     get options(): readonly SelectOption[] {
         return this.props.options;
     }

package/src/common/index.ts

@@ -22,6 +22,7 @@ export * from './contribution-filter';
 export * from './contribution-provider';
 export * from './disposable';
 export * from './event';
+export * from './listener';
 export * from './logger';
 export * from './lsp-types';
 export * from './menu';

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

@@ -132,21 +132,15 @@ export class MenuModelRegistry {
      */
     registerCommandMenu(menuPath: MenuPath, item: CommandMenu): Disposable {
         const parent = this.root.getOrCreate(menuPath, 0, menuPath.length);
-        const existing = parent.children.find(node => node.id === menuPath[menuPath.length - 1]);
-        if (existing) {
-            throw new Error(`A menu node with path ${JSON.stringify(menuPath)} already exists`);
-        } else {
-            parent.addNode(item);
-            return Disposable.create(() => {
-                parent.removeNode(item);
-                this.fireChangeEvent({
-                    kind: ChangeKind.REMOVED,
-                    path: menuPath.slice(0, menuPath.length - 1),
-                    affectedChildId: item.id
-                });
+        parent.addNode(item);
+        return Disposable.create(() => {
+            parent.removeNode(item);
+            this.fireChangeEvent({
+                kind: ChangeKind.REMOVED,
+                path: menuPath.slice(0, menuPath.length - 1),
+                affectedChildId: item.id
             });
-        }
-
+        });
     }
 
     /**
@@ -156,21 +150,16 @@ export class MenuModelRegistry {
      */
     registerMenuAction(menuPath: MenuPath, item: MenuAction): Disposable {
         const parent = this.root.getOrCreate(menuPath, 0, menuPath.length);
-        const existing = parent.children.find(node => node.id === item.commandId);
-        if (existing) {
-            throw new Error(`A menu node with id ${item.commandId} in path ${JSON.stringify(menuPath)} already exists`);
-        } else {
-            const node = this.menuNodeFactory.createCommandMenu(item);
-            parent.addNode(node);
-            return Disposable.create(() => {
-                parent.removeNode(node);
-                this.fireChangeEvent({
-                    kind: ChangeKind.REMOVED,
-                    path: menuPath.slice(0, menuPath.length - 1),
-                    affectedChildId: node.id
-                });
+        const node = this.menuNodeFactory.createCommandMenu(item);
+        parent.addNode(node);
+        return Disposable.create(() => {
+            parent.removeNode(node);
+            this.fireChangeEvent({
+                kind: ChangeKind.REMOVED,
+                path: menuPath.slice(0, menuPath.length - 1),
+                affectedChildId: node.id
             });
-        }
+        });
 
     }
 
@@ -311,13 +300,15 @@ export class MenuModelRegistry {
         }
     }
 
-    protected findInNode(root: CompoundMenuNode, menuPath: MenuPath, pathIndex: number): MenuNode | undefined {
+    protected findInNode(root: MenuNode, menuPath: MenuPath, pathIndex: number): MenuNode | undefined {
         if (pathIndex === menuPath.length) {
             return root;
         }
-        const child = root.children.find(c => c.id === menuPath[pathIndex]);
-        if (CompoundMenuNode.is(child)) {
-            return this.findInNode(child, menuPath, pathIndex + 1);
+        if (CompoundMenuNode.is(root)) {
+            const child = root.children.find(c => c.id === menuPath[pathIndex]);
+            if (child) {
+                return this.findInNode(child, menuPath, pathIndex + 1);
+            }
         }
         return undefined;
     }
@@ -326,8 +317,11 @@ export class MenuModelRegistry {
         return this.findInNode(this.root, menuPath, 0);
     }
 
-    getMenu(menuPath: MenuPath): CompoundMenuNode {
+    getMenu(menuPath: MenuPath): CompoundMenuNode | undefined {
         const node = this.getMenuNode(menuPath);
+        if (!node) {
+            return undefined;
+        }
         if (!CompoundMenuNode.is(node)) {
             throw new Error(`not a compound menu node: ${JSON.stringify(menuPath)}`);
         }

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

@@ -97,7 +97,7 @@ export interface RenderedMenuNode extends MenuNode {
 }
 
 export namespace RenderedMenuNode {
-    export function is(node: object): node is RenderedMenuNode {
+    export function is(node: unknown): node is RenderedMenuNode {
         return isObject<RenderedMenuNode>(node) && typeof node.label === 'string';
     }
 }
@@ -105,7 +105,7 @@ export namespace RenderedMenuNode {
 export type CommandMenu = MenuNode & RenderedMenuNode & Action;
 
 export namespace CommandMenu {
-    export function is(node: MenuNode): node is CommandMenu {
+    export function is(node: MenuNode | undefined): node is CommandMenu {
         return RenderedMenuNode.is(node) && Action.is(node);
     }
 }

package/src/common/resource.ts

@@ -367,11 +367,11 @@ export class UntitledResourceResolver implements ResourceResolver {
         }
     }
 
-    async createUntitledResource(content?: string, extension?: string, uri?: URI): Promise<UntitledResource> {
+    async createUntitledResource(content?: string, extension?: string, uri?: URI, encoding?: string): Promise<UntitledResource> {
         if (!uri) {
             uri = this.createUntitledURI(extension);
         }
-        return new UntitledResource(this.resources, uri, content);
+        return new UntitledResource(this.resources, uri, content, encoding);
     }
 
     createUntitledURI(extension?: string, parent?: URI): URI {
@@ -394,13 +394,15 @@ export class UntitledResource implements Resource {
     protected readonly onDidChangeContentsEmitter = new Emitter<void>();
     readonly initiallyDirty: boolean;
     readonly autosaveable = false;
+    readonly encoding: string | undefined;
     get onDidChangeContents(): Event<void> {
         return this.onDidChangeContentsEmitter.event;
     }
 
-    constructor(private resources: Map<string, UntitledResource>, public uri: URI, private content?: string) {
+    constructor(private resources: Map<string, UntitledResource>, public uri: URI, private content?: string, encoding?: string) {
         this.initiallyDirty = (content !== undefined && content.length > 0);
         this.resources.set(this.uri.toString(), this);
+        this.encoding = encoding;
     }
 
     dispose(): void {
@@ -429,10 +431,6 @@ export class UntitledResource implements Resource {
     get version(): ResourceVersion | undefined {
         return undefined;
     }
-
-    get encoding(): string | undefined {
-        return undefined;
-    }
 }
 
 /**

package/src/electron-browser/preload.ts

@@ -13,7 +13,7 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 //
-import { IpcRendererEvent } from '@theia/electron/shared/electron';
+import { IpcRendererEvent, webUtils } from '@theia/electron/shared/electron';
 import { Disposable } from '../common/disposable';
 import { StopReason } from '../common/frontend-application-state';
 import { NativeKeyboardLayout } from '../common/keyboard/keyboard-layout-provider';
@@ -90,6 +90,8 @@ const api: TheiaCoreAPI = {
     showItemInFolder: fsPath => {
         ipcRenderer.send(CHANNEL_SHOW_ITEM_IN_FOLDER, fsPath);
     },
+
+    getPathForFile: (file: File) => webUtils.getPathForFile(file),
     openWithSystemApp: location => {
         ipcRenderer.send(CHANNEL_OPEN_WITH_SYSTEM_APP, location);
     },

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

@@ -58,6 +58,8 @@ export interface TheiaCoreAPI {
 
     showItemInFolder(fsPath: string): void;
 
+    getPathForFile(file: File): string;
+
     /**
      * @param location The location to open with the system app. This can be a file path or a URL.
      */

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

@@ -450,11 +450,17 @@ export class ElectronMainApplication {
         const windowState = previousWindowState?.screenLayout === this.getCurrentScreenLayout()
             ? previousWindowState
             : this.getDefaultTheiaWindowOptions();
-        return {
+        const result = {
             frame: this.useNativeWindowFrame,
             ...this.getDefaultOptions(),
             ...windowState
         };
+
+        result.webPreferences = {
+            ...result.webPreferences,
+            preload: path.resolve(this.globals.THEIA_APP_PROJECT_PATH, 'lib', 'frontend', 'preload.js').toString()
+        };
+        return result;
     }
 
     protected avoidOverlap(options: TheiaBrowserWindowOptions): TheiaBrowserWindowOptions {
@@ -489,7 +495,7 @@ export class ElectronMainApplication {
                 // 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()
+                enableDeprecatedPaste: true
             },
             ...this.config.electron?.windowOptions || {},
         };
@@ -565,13 +571,18 @@ export class ElectronMainApplication {
     }
 
     protected getDefaultTheiaWindowOptions(): TheiaBrowserWindowOptions {
-        return {
+        const result = {
             frame: this.useNativeWindowFrame,
             isFullScreen: false,
             isMaximized: false,
             ...this.getDefaultTheiaWindowBounds(),
-            ...this.getDefaultOptions()
+            ...this.getDefaultOptions(),
+        };
+        result.webPreferences = {
+            ...result.webPreferences || {},
+            preload: path.resolve(this.globals.THEIA_APP_PROJECT_PATH, 'lib', 'frontend', 'preload.js').toString()
         };
+        return result;
     }
 
     protected getDefaultTheiaSecondaryWindowBounds(): TheiaBrowserWindowOptions {
@@ -780,16 +791,20 @@ export class ElectronMainApplication {
         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 defaultOptions = 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
+                    minWidth: defaultOptions.minWidth,
+                    minHeight: defaultOptions.minHeight,
+                    webPreferences: {
+                        enableDeprecatedPaste: defaultOptions.webPreferences?.enableDeprecatedPaste
+                    }
                 };
+
                 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