@theia/core 1.65.0-next.47 → 1.65.0-next.55

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

@@ -47,6 +47,8 @@ export class TheiaDockPanel extends DockPanel {
     readonly widgetRemoved = new Signal<this, Widget>(this);
 
     protected readonly onDidChangeCurrentEmitter = new Emitter<Title<Widget> | undefined>();
+    protected disableDND: boolean | undefined = false;
+    protected tabWithDNDDisabledStyling?: HTMLElement = undefined;
 
     get onDidChangeCurrent(): Event<Title<Widget> | undefined> {
         return this.onDidChangeCurrentEmitter.event;
@@ -57,6 +59,7 @@ export class TheiaDockPanel extends DockPanel {
         protected readonly maximizeCallback?: (area: TheiaDockPanel) => void
     ) {
         super(options);
+        this.disableDND = TheiaDockPanel.isTheiaDockPanelIOptions(options) && options.disableDragAndDrop;
         this['_onCurrentChanged'] = (sender: TabBar<Widget>, args: TabBar.ICurrentChangedArgs<Widget>) => {
             this.markAsCurrent(args.currentTitle || undefined);
             super['_onCurrentChanged'](sender, args);
@@ -68,12 +71,72 @@ export class TheiaDockPanel extends DockPanel {
             if (tabBar instanceof ToolbarAwareTabBar) {
                 tabBar.setDockPanel(this);
             }
+            if (this.disableDND) {
+                tabBar['tabDetachRequested'].disconnect(this['_onTabDetachRequested'], this);
+                tabBar['tabDetachRequested'].connect(this.onTabDetachRequestedWithDisabledDND, this);
+
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any, no-null/no-null
+                let dragDataValue: any = null;
+                Object.defineProperty(tabBar, '_dragData', {
+                    get: () => dragDataValue,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    set: (value: any) => {
+                        dragDataValue = value;
+                        // eslint-disable-next-line no-null/no-null
+                        if (value === null) {
+                            this.onNullTabDragDataWithDisabledDND();
+                        }
+                    },
+                    configurable: true
+                });
+            }
             return tabBar;
         };
         this['_onTabActivateRequested'] = (sender: TabBar<Widget>, args: TabBar.ITabActivateRequestedArgs<Widget>) => {
             this.markAsCurrent(args.title);
             super['_onTabActivateRequested'](sender, args);
         };
+        this['_onTabCloseRequested'] = (sender: TabBar<Widget>, args: TabBar.ITabCloseRequestedArgs<Widget>) => {
+            if (TheiaDockPanel.isTheiaDockPanelIOptions(options) && options.closeHandler !== undefined) {
+                if (options.closeHandler(sender, args)) {
+                    return;
+                }
+            }
+            super['_onTabCloseRequested'](sender, args);
+        };
+    }
+
+    protected onTabDetachRequestedWithDisabledDND(sender: TabBar<Widget>, args: TabBar.ITabDetachRequestedArgs<Widget>): void {
+        // don't process the detach request at all. We still want to support other drag starts, e.g. tab reorder
+        // provide visual feedback that DnD is disabled by adding not-allowed class
+        const tab = sender.contentNode.children[args.index] as HTMLElement;
+        if (tab) {
+            tab.classList.add('theia-drag-not-allowed');
+            this.tabWithDNDDisabledStyling = tab;
+        }
+    }
+
+    protected onNullTabDragDataWithDisabledDND(): void {
+        if (this.tabWithDNDDisabledStyling) {
+            this.tabWithDNDDisabledStyling.classList.remove('theia-drag-not-allowed');
+            this.tabWithDNDDisabledStyling = undefined;
+        }
+    }
+
+    override handleEvent(event: globalThis.Event): void {
+        if (this.disableDND) {
+            switch (event.type) {
+                case 'lm-dragenter':
+                case 'lm-dragleave':
+                case 'lm-dragover':
+                case 'lm-drop':
+                    /* no-op */
+                    break;
+                default:
+                    super.handleEvent(event);
+            }
+        }
+        super.handleEvent(event);
     }
 
     toggleMaximized(): void {
@@ -182,7 +245,36 @@ export class TheiaDockPanel extends DockPanel {
 export namespace TheiaDockPanel {
     export const Factory = Symbol('TheiaDockPanel#Factory');
     export interface Factory {
-        (options?: DockPanel.IOptions, maximizeCallback?: (area: TheiaDockPanel) => void): TheiaDockPanel;
+        (options?: DockPanel.IOptions | TheiaDockPanel.IOptions, maximizeCallback?: (area: TheiaDockPanel) => void): TheiaDockPanel;
+    }
+
+    export interface IOptions extends DockPanel.IOptions {
+        /** whether drag and drop for tabs should be disabled */
+        disableDragAndDrop?: boolean;
+
+        /**
+         * @param sender the tab bar
+         * @param args the widget (title)
+         * @returns true if the request was handled by this handler, false if the tabbar should handle the request
+         */
+        closeHandler?: (sender: TabBar<Widget>, args: TabBar.ITabCloseRequestedArgs<Widget>) => boolean;
+    }
+
+    export function isTheiaDockPanelIOptions(options: DockPanel.IOptions | undefined): options is IOptions {
+        if (options === undefined) {
+            return false;
+        }
+        if ('disableDragAndDrop' in options) {
+            if (options.disableDragAndDrop !== undefined && typeof options.disableDragAndDrop !== 'boolean') {
+                return false;
+            }
+        }
+        if ('closeHandler' in options) {
+            if (options.closeHandler !== undefined && typeof options.closeHandler !== 'function') {
+                return false;
+            }
+        }
+        return true;
     }
 
     export interface AddOptions extends DockPanel.IAddOptions {

package/src/browser/style/dockpanel.css

@@ -84,3 +84,10 @@
 .lm-DockPanel-overlay.lm-mod-root-bottom {
   background: var(--theia-panel-dropBackground);
 }
+
+.lm-TabBar-tab.theia-drag-not-allowed {
+  cursor: not-allowed !important;
+  background-color: var(--theia-errorBackground) !important;
+  opacity: 0.8;
+  transition: background-color 0.3s ease;
+}

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

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { ApplicationShell } from '../shell';
 import { Widget } from './widget';
 
 /**
@@ -24,6 +25,8 @@ export interface ExtractableWidget extends Widget {
     isExtractable: boolean;
     /** The secondary window that the window was extracted to or `undefined` if it is not yet extracted. */
     secondaryWindow: Window | undefined;
+    /** Stores the area which contained the widget before being extracted. This is undefined if the widget wasn't extracted or if the area could not be determined */
+    previousArea?: ApplicationShell.Area;
 }
 
 export namespace ExtractableWidget {

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

@@ -14,13 +14,14 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { inject, injectable, postConstruct } from 'inversify';
-import { SecondaryWindowService } from './secondary-window-service';
+import { SecondaryWindow, SecondaryWindowService } from './secondary-window-service';
 import { WindowService } from './window-service';
-import { ExtractableWidget } from '../widgets';
+import { ExtractableWidget, Widget } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { Saveable } from '../saveable';
 import { Emitter, environment, Event, PreferenceService } from '../../common';
 import { SaveableService } from '../saveable-service';
+import { getAllWidgetsFromSecondaryWindow, getDefaultRestoreArea } from '../secondary-window-handler';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
@@ -28,6 +29,8 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     readonly onWindowOpened: Event<Window> = this.onWindowOpenedEmitter.event;
     protected readonly onWindowClosedEmitter = new Emitter<Window>;
     readonly onWindowClosed: Event<Window> = this.onWindowClosedEmitter.event;
+    protected readonly beforeWidgetRestoreEmitter = new Emitter<[Widget, Window]>;
+    readonly beforeWidgetRestore: Event<[Widget, Window]> = this.beforeWidgetRestoreEmitter.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';
 
@@ -92,7 +95,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
         });
     }
 
-    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined {
+    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | SecondaryWindow | undefined {
         const [height, width, left, top] = this.findSecondaryWindowCoordinates(widget);
         let options = `popup=1,width=${width},height=${height},left=${left},top=${top}`;
         if (this.preferenceService.get('window.secondaryWindowAlwaysOnTop')) {
@@ -104,21 +107,19 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
             this.onWindowOpenedEmitter.fire(newWindow);
             newWindow.addEventListener('DOMContentLoaded', () => {
                 newWindow.addEventListener('beforeunload', evt => {
-                    const saveable = Saveable.get(widget);
-                    const wouldLoseState = !!saveable && saveable.dirty && this.saveResourceService.autoSave === 'off';
-                    if (wouldLoseState) {
-                        evt.returnValue = '';
-                        evt.preventDefault();
-                        return 'non-empty';
+                    const widgets = getAllWidgetsFromSecondaryWindow(newWindow) ?? [widget];
+                    for (const w of widgets) {
+                        const saveable = Saveable.get(w);
+                        const wouldLoseState = !!saveable && saveable.dirty && this.saveResourceService.autoSave === 'off';
+                        if (wouldLoseState) {
+                            evt.returnValue = '';
+                            evt.preventDefault();
+                            return 'non-empty';
+                        }
                     }
                 }, { capture: true });
 
                 newWindow.addEventListener('unload', () => {
-                    const saveable = Saveable.get(widget);
-                    shell.closeWidget(widget.id, {
-                        save: !!saveable && saveable.dirty && this.saveResourceService.autoSave !== 'off'
-                    });
-
                     const extIndex = this.secondaryWindows.indexOf(newWindow);
                     if (extIndex > -1) {
                         this.onWindowClosedEmitter.fire(newWindow);
@@ -128,12 +129,13 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
                 this.windowCreated(newWindow, widget, shell);
             });
         }
+        (newWindow as SecondaryWindow).rootWidget = undefined;
         return newWindow;
     }
 
     protected windowCreated(newWindow: Window, widget: ExtractableWidget, shell: ApplicationShell): void {
         newWindow.addEventListener('unload', () => {
-            shell.closeWidget(widget.id);
+            this.restoreWidgets(newWindow, widget, shell);
         });
     }
 
@@ -199,4 +201,40 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     protected nextWindowId(): string {
         return `${this.prefix}-secondaryWindow-${this.nextId++}`;
     }
+
+    /**
+     * Restore the widgets back to the main window. SecondaryWindowHandler needs to get informated about this.
+     */
+    protected async restoreWidgets(newWindow: Window, extractableWidget: ExtractableWidget, shell: ApplicationShell): Promise<boolean> {
+        const widgets = getAllWidgetsFromSecondaryWindow(newWindow) ?? new Set([extractableWidget]);
+        const defaultRestoreArea = getDefaultRestoreArea(newWindow);
+
+        let allMovedOrDisposed = true;
+        for (const widget of widgets) {
+            if (widget.isDisposed) {
+                continue;
+            }
+            try {
+                const preferredRestoreArea = ExtractableWidget.is(widget) ? widget.previousArea : defaultRestoreArea;
+                const area = (preferredRestoreArea === undefined || preferredRestoreArea === 'top' || preferredRestoreArea === 'secondaryWindow') ? 'main' : preferredRestoreArea;
+                // fire removed event before adding it to shell
+                this.beforeWidgetRestoreEmitter.fire([widget, newWindow]);
+                // reset ExtractableWidget properties before moving back so that handler evaluation is correct immediately
+                if (ExtractableWidget.is(widget)) {
+                    widget.secondaryWindow = undefined;
+                    widget.previousArea = undefined;
+                }
+                await shell.addWidget(widget, { area });
+                await shell.activateWidget(widget.id);
+            } catch (e) {
+                // we can't move back, close instead
+                // otherwise the window will just stay open with no way to close it
+                await shell.closeWidget(widget.id);
+                if (!widget.isDisposed) {
+                    allMovedOrDisposed = false;
+                }
+            }
+        }
+        return allMovedOrDisposed;
+    }
 }

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

@@ -16,7 +16,27 @@
 
 import { Event } from '../../common';
 import { ApplicationShell } from '../shell';
-import { ExtractableWidget } from '../widgets';
+import { TheiaDockPanel } from '../shell/theia-dock-panel';
+import { ExtractableWidget, TabBar, Widget } from '../widgets';
+
+export abstract class SecondaryWindowRootWidget extends Widget {
+    secondaryWindow: Window | SecondaryWindow;
+    defaultRestoreArea?: ApplicationShell.Area;
+    abstract widgets: ReadonlyArray<Widget>;
+    abstract addWidget(widget: Widget, disposeCallback: () => void, options?: TheiaDockPanel.AddOptions): void;
+    getTabBar?(widget: Widget): TabBar<Widget> | undefined;
+}
+
+export interface SecondaryWindow extends Window {
+    rootWidget: SecondaryWindowRootWidget | undefined;
+}
+
+export function isSecondaryWindow(window: unknown): window is SecondaryWindow {
+    if (!window) {
+        return false;
+    }
+    return typeof window === 'object' && 'rootWidget' in window;
+}
 
 export const SecondaryWindowService = Symbol('SecondaryWindowService');
 
@@ -33,9 +53,10 @@ export interface SecondaryWindowService {
      * @param onClose optional callback that is invoked when the secondary window is closed
      * @returns the created window or `undefined` if it could not be created
      */
-    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined;
+    createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): SecondaryWindow | Window | undefined;
     readonly onWindowOpened: Event<Window>;
     readonly onWindowClosed: Event<Window>;
+    readonly beforeWidgetRestore: Event<[Widget, Window]>;
 
     /** Handles focussing the given secondary window in the browser and on Electron. */
     focus(win: Window): void;

package/src/electron-browser/preload.ts

@@ -27,7 +27,7 @@ import {
     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_OPEN_URL, CHANNEL_SET_THEME
+    CHANNEL_OPEN_URL, CHANNEL_SET_THEME, CHANNEL_OPEN_DEVTOOLS_FOR_WINDOW
 } from '../electron-common/electron-api';
 
 // eslint-disable-next-line import/no-extraneous-dependencies
@@ -200,6 +200,9 @@ const api: TheiaCoreAPI = {
     toggleDevTools: function (): void {
         ipcRenderer.send(CHANNEL_TOGGLE_DEVTOOLS);
     },
+    openDevToolsForWindow: function (windowName: string): void {
+        ipcRenderer.send(CHANNEL_OPEN_DEVTOOLS_FOR_WINDOW, windowName);
+    },
     getZoomLevel: function (): Promise<number> {
         return ipcRenderer.invoke(CHANNEL_GET_ZOOM_LEVEL);
     },

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

@@ -48,10 +48,13 @@ export class ElectronSecondaryWindowService extends DefaultSecondaryWindowServic
 
     protected override windowCreated(newWindow: Window, widget: ExtractableWidget, shell: ApplicationShell): void {
         window.electronTheiaCore.setMenuBarVisible(false, newWindow.name);
-        window.electronTheiaCore.setSecondaryWindowCloseRequestHandler(newWindow.name, () => this.canClose(widget, shell));
+        window.electronTheiaCore.setSecondaryWindowCloseRequestHandler(newWindow.name, () => this.canClose(widget, shell, newWindow));
+
+        // Below code may be used to debug contents of secondary window
+        // window.electronTheiaCore.openDevToolsForWindow(newWindow.name);
     }
-    private async canClose(widget: ExtractableWidget, shell: ApplicationShell): Promise<boolean> {
-        await shell.closeWidget(widget.id);
-        return widget.isDisposed;
+    private async canClose(extractableWidget: ExtractableWidget, shell: ApplicationShell, newWindow: Window): Promise<boolean> {
+        return this.restoreWidgets(newWindow, extractableWidget, shell);
     }
+
 }

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

@@ -83,6 +83,7 @@ export interface TheiaCoreAPI {
     setSecondaryWindowCloseRequestHandler(windowName: string, handler: () => Promise<boolean>): void;
 
     toggleDevTools(): void;
+    openDevToolsForWindow(windowName: string): void;
     getZoomLevel(): Promise<number>;
     setZoomLevel(desired: number): void;
 
@@ -141,6 +142,7 @@ export const CHANNEL_OPEN_URL = 'OpenUrl';
 export const CHANNEL_UNMAXIMIZE = 'UnMaximize';
 export const CHANNEL_ON_WINDOW_EVENT = 'OnWindowEvent';
 export const CHANNEL_TOGGLE_DEVTOOLS = 'ToggleDevtools';
+export const CHANNEL_OPEN_DEVTOOLS_FOR_WINDOW = 'OpenDevtoolsForWindow';
 export const CHANNEL_GET_ZOOM_LEVEL = 'GetZoomLevel';
 export const CHANNEL_SET_ZOOM_LEVEL = 'SetZoomLevel';
 export const CHANNEL_IS_FULL_SCREENABLE = 'IsFullScreenable';

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

@@ -56,7 +56,8 @@ import {
     CHANNEL_ABOUT_TO_CLOSE,
     CHANNEL_OPEN_WITH_SYSTEM_APP,
     CHANNEL_OPEN_URL,
-    CHANNEL_SET_THEME
+    CHANNEL_SET_THEME,
+    CHANNEL_OPEN_DEVTOOLS_FOR_WINDOW
 } from '../electron-common/electron-api';
 import { ElectronMainApplication, ElectronMainApplicationContribution } from './electron-main-application';
 import { Disposable, DisposableCollection, isOSX, MaybePromise } from '../common';
@@ -207,6 +208,15 @@ export class TheiaMainApi implements ElectronMainApplicationContribution {
             event.sender.toggleDevTools();
         });
 
+        ipcMain.on(CHANNEL_OPEN_DEVTOOLS_FOR_WINDOW, (event, windowName: string) => {
+            const electronWindow = BrowserWindow.getAllWindows().find(win => win.webContents.mainFrame.name === windowName);
+            if (electronWindow) {
+                electronWindow.webContents.openDevTools();
+            } else {
+                console.warn(`There is no known window '${windowName}'. Thus, the devtools could not be opened.`);
+            }
+        });
+
         ipcMain.on(CHANNEL_SET_ZOOM_LEVEL, (event, zoomLevel: number) => {
             event.sender.setZoomLevel(zoomLevel);
         });

package/src/node/logger-cli-contribution.spec.ts

@@ -22,17 +22,30 @@ import { ContainerModule, Container } from 'inversify';
 import { LogLevel } from '../common/logger';
 import { LogLevelCliContribution } from './logger-cli-contribution';
 import * as sinon from 'sinon';
+import { Disposable, DisposableCollection } from '../common';
 
 // Allow creating temporary files, but remove them when we are done.
 const track = temp.track();
 
 let cli: LogLevelCliContribution;
 let consoleErrorSpy: sinon.SinonSpy;
+let container: Container;
+let toDisposeAfter: DisposableCollection;
 
 describe('log-level-cli-contribution', () => {
 
+    before(() => {
+        toDisposeAfter = new DisposableCollection(
+            Disposable.create(() => track.cleanupSync())
+        );
+    });
+
+    after(() => {
+        toDisposeAfter.dispose();
+    });
+
     beforeEach(() => {
-        const container = new Container();
+        container = new Container();
 
         const module = new ContainerModule(bind => {
             bind(LogLevelCliContribution).toSelf().inSingletonScope();
@@ -47,8 +60,10 @@ describe('log-level-cli-contribution', () => {
         consoleErrorSpy = sinon.spy(console, 'error');
     });
 
-    afterEach(() => {
+    afterEach(async () => {
         consoleErrorSpy.restore();
+        await cli.dispose();
+        container.unload();
     });
 
     it('should use --log-level flag', async () => {

package/src/node/logger-cli-contribution.ts

@@ -19,9 +19,10 @@ import { injectable } from 'inversify';
 import { LogLevel } from '../common/logger';
 import { CliContribution } from './cli';
 import * as fs from 'fs-extra';
-import { subscribe } from '@parcel/watcher';
+import { AsyncSubscription, subscribe } from '@parcel/watcher';
 import { Event, Emitter } from '../common/event';
 import * as path from 'path';
+import { Disposable, DisposableCollection } from '../common';
 
 /** Maps logger names to log levels.  */
 export interface LogLevels {
@@ -34,9 +35,11 @@ export interface LogLevels {
  * what the log level per logger should be.
  */
 @injectable()
-export class LogLevelCliContribution implements CliContribution {
+export class LogLevelCliContribution implements CliContribution, Disposable {
 
     protected _logLevels: LogLevels = {};
+    protected asyncSubscriptions: AsyncSubscription[] = [];
+    protected toDispose = new DisposableCollection();
 
     /**
      * Log level to use for loggers not specified in `logLevels`.
@@ -59,6 +62,10 @@ export class LogLevelCliContribution implements CliContribution {
         return this._logFile;
     }
 
+    constructor() {
+        this.toDispose.push(this.logConfigChangedEvent);
+    }
+
     configure(conf: yargs.Argv): void {
         conf.option('log-level', {
             description: 'Sets the default log level',
@@ -129,7 +136,7 @@ export class LogLevelCliContribution implements CliContribution {
 
     protected async watchLogConfigFile(filename: string): Promise<void> {
         const dir = path.dirname(filename);
-        await subscribe(dir, async (err, events) => {
+        const subscription = await subscribe(dir, async (err, events) => {
             if (err) {
                 console.log(`Error during log file watching ${filename}: ${err}`);
                 return;
@@ -150,6 +157,14 @@ export class LogLevelCliContribution implements CliContribution {
                 console.error(`Error reading log config file ${filename}: ${e}`);
             }
         });
+        this.asyncSubscriptions.push(subscription);
+    }
+
+    async dispose(): Promise<void> {
+        for (const sub of this.asyncSubscriptions) {
+            sub.unsubscribe();
+        }
+        this.toDispose.dispose();
     }
 
     protected async slurpLogConfigFile(filename: string): Promise<void> {