@theia/terminal-manager 1.68.0-next.9 → 1.68.1

package/src/browser/terminal-manager-frontend-view-contribution.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable } from '@theia/core/shared/inversify';
+import { injectable, inject } from '@theia/core/shared/inversify';
 import {
     AbstractViewContribution,
     codicon,
@@ -23,18 +23,24 @@ import {
     MAXIMIZED_CLASS,
     Widget,
 } from '@theia/core/lib/browser';
-import { CommandRegistry, Event, MenuModelRegistry, nls } from '@theia/core';
+import { CommandRegistry, Disposable, Event, MenuModelRegistry, nls } from '@theia/core';
 import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
 import { BOTTOM_AREA_ID } from '@theia/core/lib/browser/shell/theia-dock-panel';
 import { TerminalManagerCommands, TerminalManagerTreeTypes, TERMINAL_MANAGER_TREE_CONTEXT_MENU } from './terminal-manager-types';
 import { TerminalManagerWidget } from './terminal-manager-widget';
 import { TerminalManagerTreeWidget } from './terminal-manager-tree-widget';
 import { ConfirmDialog, Dialog } from '@theia/core/lib/browser/dialogs';
+import { TerminalManagerPreferences } from './terminal-manager-preferences';
 
 @injectable()
 export class TerminalManagerFrontendViewContribution extends AbstractViewContribution<TerminalManagerWidget>
     implements TabBarToolbarContribution, KeybindingContribution {
 
+    @inject(TerminalManagerPreferences)
+    protected readonly preferences: TerminalManagerPreferences;
+
+    protected quickViewDisposable: Disposable | undefined;
+
     constructor() {
         super({
             widgetId: TerminalManagerWidget.ID,
@@ -46,7 +52,17 @@ export class TerminalManagerFrontendViewContribution extends AbstractViewContrib
     }
 
     override registerCommands(commands: CommandRegistry): void {
-        super.registerCommands(commands);
+        // Don't call super.registerCommands() - we manage quick view registration manually
+        // based on the terminal.grouping.mode preference
+
+        this.preferences.ready.then(() => {
+            this.updateQuickViewRegistration();
+            this.preferences.onPreferenceChanged(change => {
+                if (change.preferenceName === 'terminal.grouping.mode') {
+                    this.updateQuickViewRegistration();
+                }
+            });
+        });
 
         commands.registerCommand(TerminalManagerCommands.MANAGER_NEW_TERMINAL_GROUP, {
             execute: (
@@ -152,15 +168,15 @@ export class TerminalManagerFrontendViewContribution extends AbstractViewContrib
                         primaryButtonText: PRIMARY_BUTTON,
                     });
                     if (dialogResponse === PRIMARY_BUTTON) {
-                        for (const id of widget.pagePanels.keys()) {
-                            widget.deletePage(id);
-                        }
+                        widget.resetView();
                     }
                 }
             },
         });
         commands.registerCommand(TerminalManagerCommands.MANAGER_OPEN_VIEW, {
             execute: () => this.openView({ activate: true }),
+            isEnabled: () => this.isTreeMode(),
+            isVisible: () => this.isTreeMode(),
         });
         commands.registerCommand(TerminalManagerCommands.MANAGER_CLOSE_VIEW, {
             isVisible: () => Boolean(this.tryGetWidget()),
@@ -169,6 +185,24 @@ export class TerminalManagerFrontendViewContribution extends AbstractViewContrib
         });
     }
 
+    protected isTreeMode(): boolean {
+        return this.preferences.get('terminal.grouping.mode') === 'tree';
+    }
+
+    protected updateQuickViewRegistration(): void {
+        if (this.isTreeMode()) {
+            if (!this.quickViewDisposable) {
+                this.quickViewDisposable = this.quickView?.registerItem({
+                    label: this.viewLabel,
+                    open: () => this.openView({ activate: true })
+                });
+            }
+        } else {
+            this.quickViewDisposable?.dispose();
+            this.quickViewDisposable = undefined;
+        }
+    }
+
     protected async confirmUserAction(options: { title: string, message: string, primaryButtonText: string }): Promise<string | undefined> {
         const dialog = new ConfirmDialog({
             title: options.title,

package/src/browser/terminal-manager-tree-model.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { injectable, postConstruct } from '@theia/core/shared/inversify';
-import { TreeModelImpl, CompositeTreeNode, SelectableTreeNode, DepthFirstTreeIterator } from '@theia/core/lib/browser';
+import { TreeModelImpl, CompositeTreeNode, SelectableTreeNode, DepthFirstTreeIterator, TreeNode } from '@theia/core/lib/browser';
 import { Emitter, nls } from '@theia/core';
 import { TerminalManagerTreeTypes } from './terminal-manager-types';
 
@@ -112,14 +112,10 @@ export class TerminalManagerTreeModel extends TreeModelImpl {
     deleteTerminalPage(pageId: TerminalManagerTreeTypes.PageId): void {
         const pageNode = this.getNode(pageId);
         if (TerminalManagerTreeTypes.isPageNode(pageNode) && CompositeTreeNode.is(this.root)) {
-            while (pageNode.children.length > 0) {
-                const groupNode = pageNode.children[pageNode.children.length - 1];
-                this.doDeleteTerminalGroup(groupNode, pageNode);
-            }
+            const isActive = this.activePageNode === pageNode;
             this.onDidDeletePageEmitter.fire(pageNode.id);
             CompositeTreeNode.removeChild(this.root, pageNode);
-            setTimeout(() => this.selectPrevNode());
-            this.refresh();
+            this.refreshWithSelection(this.root, undefined, isActive ? pageNode : undefined);
         }
     }
 
@@ -135,10 +131,7 @@ export class TerminalManagerTreeModel extends TreeModelImpl {
             this.onDidAddTerminalGroupEmitter.fire({ groupId: groupNode.id, pageId, terminalKey });
             CompositeTreeNode.addChild(groupNode, terminalNode);
             CompositeTreeNode.addChild(pageNode, groupNode);
-            this.refresh();
-            setTimeout(() => {
-                this.selectionService.addSelection(terminalNode);
-            });
+            this.refreshWithSelection(pageNode, terminalNode);
         }
     }
 
@@ -176,17 +169,14 @@ export class TerminalManagerTreeModel extends TreeModelImpl {
             if (parentPageNode.children.length === 1) {
                 this.deleteTerminalPage(parentPageNode.id);
             } else {
+                const isActive = this.activeGroupNode === groupNode;
                 this.doDeleteTerminalGroup(groupNode, parentPageNode);
-                this.refresh();
+                this.refreshWithSelection(parentPageNode, undefined, isActive ? groupNode : undefined);
             }
         }
     }
 
     protected doDeleteTerminalGroup(group: TerminalManagerTreeTypes.TerminalGroupNode, page: TerminalManagerTreeTypes.PageNode): void {
-        while (group.children.length > 0) {
-            const terminalNode = group.children[group.children.length - 1];
-            this.doDeleteTerminalNode(terminalNode, group);
-        }
         this.onDidDeleteTerminalGroupEmitter.fire(group.id);
         CompositeTreeNode.removeChild(page, group);
     }
@@ -197,12 +187,7 @@ export class TerminalManagerTreeModel extends TreeModelImpl {
             const terminalNode = this.createTerminalNode(newTerminalId, groupId);
             CompositeTreeNode.addChild(groupNode, terminalNode);
             this.onDidAddTerminalToGroupEmitter.fire({ terminalId: newTerminalId, groupId });
-            this.refresh();
-            setTimeout(() => {
-                if (SelectableTreeNode.is(terminalNode)) {
-                    this.selectionService.addSelection(terminalNode);
-                }
-            });
+            this.refreshWithSelection(undefined, terminalNode);
         }
     }
 
@@ -229,20 +214,19 @@ export class TerminalManagerTreeModel extends TreeModelImpl {
             if (parentGroupNode.children.length === 1) {
                 this.deleteTerminalGroup(parentGroupNode.id);
             } else {
+                const isActive = this.activeTerminalNode === terminalNode;
                 this.doDeleteTerminalNode(terminalNode, parentGroupNode);
-                this.refresh();
+                this.refreshWithSelection(parentGroupNode, undefined, isActive ? terminalNode : undefined);
             }
         }
     }
 
     protected doDeleteTerminalNode(node: TerminalManagerTreeTypes.TerminalNode, parent: TerminalManagerTreeTypes.TerminalGroupNode): void {
-        if (TerminalManagerTreeTypes.isGroupNode(parent)) {
-            this.onDidDeleteTerminalFromGroupEmitter.fire({
-                terminalId: node.id,
-                groupId: parent.id,
-            });
-            CompositeTreeNode.removeChild(parent, node);
-        }
+        this.onDidDeleteTerminalFromGroupEmitter.fire({
+            terminalId: node.id,
+            groupId: parent.id,
+        });
+        CompositeTreeNode.removeChild(parent, node);
     }
 
     toggleRenameTerminal(entityId: TerminalManagerTreeTypes.TerminalManagerValidId): void {
@@ -268,7 +252,6 @@ export class TerminalManagerTreeModel extends TreeModelImpl {
         let activeTerminal: TerminalManagerTreeTypes.TerminalNode | undefined = undefined;
         let activeGroup: TerminalManagerTreeTypes.TerminalGroupNode | undefined = undefined;
         let activePage: TerminalManagerTreeTypes.PageNode | undefined = undefined;
-
         if (TerminalManagerTreeTypes.isTerminalNode(selectedNode)) {
             activeTerminal = selectedNode;
             const { parent } = activeTerminal;
@@ -333,4 +316,25 @@ export class TerminalManagerTreeModel extends TreeModelImpl {
             this.selectNode(node);
         }
     }
+
+    protected async refreshWithSelection(refreshTarget?: CompositeTreeNode, selectionTarget?: SelectableTreeNode, selectionReferent?: TreeNode): Promise<void> {
+        await this.refresh(refreshTarget);
+        if (selectionTarget) {
+            return this.selectNode(selectionTarget);
+        }
+        if (selectionReferent) {
+            const { previousSibling, nextSibling } = selectionReferent;
+            const toSelect = this.findSelection(previousSibling) ?? this.findSelection(nextSibling);
+            if (toSelect) {
+                this.selectNode(toSelect);
+            }
+        }
+    }
+
+    protected findSelection(start?: TreeNode): SelectableTreeNode | undefined {
+        if (!start) { return undefined; }
+        if (TerminalManagerTreeTypes.isTerminalNode(start)) { return start; }
+        if (TerminalManagerTreeTypes.isGroupNode(start)) { return start.children.at(0); }
+        if (TerminalManagerTreeTypes.isPageNode(start)) { return start.children.at(0)?.children.at(0); }
+    }
 }

package/src/browser/terminal-manager-types.ts

@@ -122,6 +122,7 @@ export namespace TerminalManagerTreeTypes {
     export const isGroupId = (obj: unknown): obj is GroupId => typeof obj === 'string' && obj.startsWith('group-');
     export interface GroupSplitPanel extends SplitPanel {
         id: GroupId;
+        widgets: readonly TerminalWidgetImpl[];
     }
     export interface TerminalGroupNode extends SelectableTreeNode, ExpandableTreeNode {
         terminalGroup: true;
@@ -137,6 +138,7 @@ export namespace TerminalManagerTreeTypes {
     export const isPageId = (obj: unknown): obj is PageId => typeof obj === 'string' && obj.startsWith('page-');
     export interface PageSplitPanel extends SplitPanel {
         id: PageId;
+        widgets: readonly GroupSplitPanel[];
     }
     export interface PageNode extends SelectableTreeNode, ExpandableTreeNode {
         page: true;

package/src/browser/terminal-manager-widget.ts

@@ -83,13 +83,15 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
     static LABEL = nls.localize('theia/terminal-manager/label', 'Terminals');
 
     protected panel: SplitPanel;
-
     protected pageAndTreeLayout: SplitLayout | undefined;
     protected stateIsSet = false;
 
     pagePanels = new Map<TerminalManagerTreeTypes.PageId, TerminalManagerTreeTypes.PageSplitPanel>();
     groupPanels = new Map<TerminalManagerTreeTypes.GroupId, TerminalManagerTreeTypes.GroupSplitPanel>();
+    /** By node ID: safer for state restoration. */
     terminalWidgets = new Map<TerminalManagerTreeTypes.TerminalKey, TerminalWidget>();
+    /** By terminal ID to work from widget to internal metadata. */
+    terminalWidgetIdsToNodeIds = new Map<string, TerminalManagerTreeTypes.TerminalKey>();
 
     protected readonly onDidChangeTrackableWidgetsEmitter = new Emitter<Widget[]>();
     readonly onDidChangeTrackableWidgets = this.onDidChangeTrackableWidgetsEmitter.event;
@@ -133,13 +135,23 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
         this.id = TerminalManagerWidget.ID;
         this.title.closable = true;
         this.title.label = TerminalManagerWidget.LABEL;
+        this.title.caption = TerminalManagerWidget.LABEL;
         this.node.tabIndex = 0;
         this.registerListeners();
         this.createPageAndTreeLayout();
     }
 
+    /** Yields all terminal widgets owned by this widget and then closes this widget. */
+    *drainWidgets(): IterableIterator<TerminalWidget> {
+        for (const [key, widget] of this.terminalWidgets) {
+            this.removeTerminalReferenceByNodeId(key);
+            yield widget;
+        }
+        this.close();
+    }
+
     async populateLayout(force?: boolean): Promise<void> {
-        if (!this.stateIsSet || force) {
+        if ((!this.stateIsSet && this.terminalWidgets.size === 0) || force) {
             const terminalWidget = await this.createTerminalWidget();
             this.addTerminalPage(terminalWidget);
             this.onDidChangeTrackableWidgetsEmitter.fire(this.getTrackableWidgets());
@@ -243,7 +255,7 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
     }
 
     protected override onCloseRequest(msg: Message): void {
-        if (this.interceptCloseRequest) {
+        if (this.interceptCloseRequest && this.terminalWidgets.size > 0) {
             this.interceptCloseRequest = false;
             this.confirmClose()
                 .then(confirmed => {
@@ -275,19 +287,42 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
     }
 
     addTerminalPage(widget: Widget): void {
+        this.doAddTerminalPage(widget);
+    }
+
+    protected doAddTerminalPage(widget: Widget): TerminalManagerTreeTypes.PageSplitPanel | undefined {
         if (widget instanceof TerminalWidgetImpl) {
             const terminalKey = TerminalManagerTreeTypes.generateTerminalKey(widget);
-            this.registerTerminalCloseListener(widget, terminalKey);
-            this.terminalWidgets.set(terminalKey, widget);
+            this.addTerminalReference(widget, terminalKey);
             this.onDidChangeTrackableWidgetsEmitter.fire(this.getTrackableWidgets());
             const groupPanel = this.createTerminalGroupPanel();
             groupPanel.addWidget(widget);
             const pagePanel = this.createPagePanel();
             pagePanel.addWidget(groupPanel);
             this.treeWidget.model.addTerminalPage(terminalKey, groupPanel.id, pagePanel.id);
+            return pagePanel;
         }
     }
 
+    protected addTerminalReference(widget: TerminalWidget, nodeId: TerminalManagerTreeTypes.TerminalKey): void {
+        this.terminalWidgets.set(nodeId, widget);
+        this.terminalWidgetIdsToNodeIds.set(widget.id, nodeId);
+    }
+
+    protected removeTerminalReferenceByWidgetId(widgetId: string): boolean {
+        const nodeId = this.terminalWidgetIdsToNodeIds.get(widgetId);
+        if (nodeId === undefined) {return false; }
+        return this.terminalWidgets.delete(nodeId);
+    }
+
+    protected removeTerminalReferenceByNodeId(nodeId: TerminalManagerTreeTypes.TerminalKey): boolean {
+        const widget = this.terminalWidgets.get(nodeId);
+        if (!widget) {return false; }
+        this.terminalWidgets.delete(nodeId);
+        this.terminalWidgetIdsToNodeIds.delete(widget.id);
+        return true;
+    }
+
     protected createPagePanel(pageId?: TerminalManagerTreeTypes.PageId): TerminalManagerTreeTypes.PageSplitPanel {
         const newPageLayout = new ViewContainerLayout({
             renderer: SplitPanel.defaultRenderer,
@@ -332,10 +367,25 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
     }
 
     protected handlePageDeleted(pagePanelId: TerminalManagerTreeTypes.PageId): void {
-        this.pagePanels.get(pagePanelId)?.dispose();
+        const panel = this.pagePanels.get(pagePanelId);
+        if (!panel) {
+            return;
+        }
+        const isLastPanel = this.pagePanels.size === 1;
+        if (isLastPanel) {
+            this.interceptCloseRequest = false;
+            this.close();
+            return;
+        }
+        this.clearGroupReferences(panel);
+        panel.dispose();
         this.pagePanels.delete(pagePanelId);
-        if (this.pagePanels.size === 0) {
-            this.populateLayout(true);
+    }
+
+    protected clearGroupReferences(panel: TerminalManagerTreeTypes.PageSplitPanel): void {
+        for (const group of panel.widgets) {
+            this.clearTerminalReferences(group);
+            this.groupPanels.delete(group.id);
         }
     }
 
@@ -345,8 +395,7 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
         }
         if (widget instanceof TerminalWidgetImpl) {
             const terminalId = TerminalManagerTreeTypes.generateTerminalKey(widget);
-            this.registerTerminalCloseListener(widget, terminalId);
-            this.terminalWidgets.set(terminalId, widget);
+            this.addTerminalReference(widget, terminalId);
             this.onDidChangeTrackableWidgetsEmitter.fire(this.getTrackableWidgets());
             const groupPanel = this.createTerminalGroupPanel();
             groupPanel.addWidget(widget);
@@ -403,22 +452,28 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
 
     activateWidget(id: string): Widget | undefined {
         const widget = Array.from(this.terminalWidgets.values()).find(terminalWidget => terminalWidget.id === id);
-        if (widget instanceof TerminalWidgetImpl) {
-            widget.activate();
-        }
+        widget?.activate();
         return widget;
     }
 
     protected handleTerminalGroupDeleted(groupPanelId: TerminalManagerTreeTypes.GroupId): void {
-        this.groupPanels.get(groupPanelId)?.dispose();
+        const panel = this.groupPanels.get(groupPanelId);
         this.groupPanels.delete(groupPanelId);
+        if (!panel) { return; }
+        this.clearTerminalReferences(panel);
+        panel.dispose();
+    }
+
+    protected clearTerminalReferences(panel: TerminalManagerTreeTypes.GroupSplitPanel): void {
+        for (const terminal of panel.widgets) {
+                this.removeTerminalReferenceByWidgetId(terminal.id);
+        }
     }
 
     addWidgetToTerminalGroup(widget: Widget, groupId: TerminalManagerTreeTypes.GroupId): void {
         if (widget instanceof TerminalWidgetImpl) {
             const newTerminalId = TerminalManagerTreeTypes.generateTerminalKey(widget);
-            this.registerTerminalCloseListener(widget, newTerminalId);
-            this.terminalWidgets.set(newTerminalId, widget);
+            this.addTerminalReference(widget, newTerminalId);
             this.onDidChangeTrackableWidgetsEmitter.fire(this.getTrackableWidgets());
             this.treeWidget.model.addTerminal(newTerminalId, groupId);
         }
@@ -449,14 +504,10 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
 
     protected handleTerminalDeleted(terminalId: TerminalManagerTreeTypes.TerminalKey): void {
         const terminalWidget = this.terminalWidgets.get(terminalId);
-        const wasActiveWidget = this.shell.activeWidget === terminalWidget;
-        if (!this.terminalsDeletingFromClose.has(terminalId)) {
+        if (!terminalWidget?.isDisposed) {
             terminalWidget?.dispose();
         }
-        this.terminalWidgets.delete(terminalId);
-        if (wasActiveWidget) {
-            this.activateNextAvailableTerminal(terminalId);
-        }
+        this.removeTerminalReferenceByNodeId(terminalId);
     }
 
     protected handleOnDidChangeActiveWidget(widget: Widget | null): void {
@@ -535,6 +586,16 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
         this.terminalWidgets = new Map();
     }
 
+    async resetView(): Promise<void> {
+        const terminalWidget = await this.createTerminalWidget();
+        const page = this.doAddTerminalPage(terminalWidget);
+        for (const id of this.pagePanels.keys()) {
+            if (id !== page?.id) {
+                this.deletePage(id);
+            }
+        }
+    }
+
     protected iterateAndRestoreLayoutTree(pageLayouts: TerminalManagerWidgetState.PageLayoutData[], treeWidget: TerminalManagerTreeWidget): void {
         for (const pageLayout of pageLayouts) {
             const pageId = pageLayout.id;
@@ -565,8 +626,7 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
                         if (!TerminalManagerTreeTypes.isTerminalNode(widgetNode)) {
                             throw TerminalManagerWidget.createRestoreError(widgetId);
                         }
-                        this.terminalWidgets.set(widgetId, widget);
-                        this.registerTerminalCloseListener(widget, widgetId);
+                        this.addTerminalReference(widget, widgetId);
                         this.onDidChangeTrackableWidgetsEmitter.fire(this.getTrackableWidgets());
                         groupPanel.addWidget(widget);
                     }
@@ -646,26 +706,6 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
         return fullLayoutData;
     }
 
-    protected registerTerminalCloseListener(widget: TerminalWidget, terminalKey: TerminalManagerTreeTypes.TerminalKey): void {
-        const originalOnCloseRequest = widget['onCloseRequest'].bind(widget);
-        widget['onCloseRequest'] = (msg: Message) => {
-            const wasActiveWidget = this.shell.activeWidget === widget;
-            if (wasActiveWidget) {
-                this.activateNextAvailableTerminal(terminalKey);
-            }
-            originalOnCloseRequest(msg);
-        };
-        const disposable = widget.onTerminalDidClose(() => {
-            this.terminalsDeletingFromClose.add(terminalKey);
-            try {
-                this.treeWidget.model.deleteTerminalNode(terminalKey);
-            } finally {
-                this.terminalsDeletingFromClose.delete(terminalKey);
-            }
-        });
-        this.toDispose.push(disposable);
-    }
-
     protected activateNextAvailableTerminal(excludeTerminalKey: TerminalManagerTreeTypes.TerminalKey): void {
         const remainingTerminals = Array.from(this.terminalWidgets.entries()).filter(([key]) => key !== excludeTerminalKey);
         if (remainingTerminals.length > 0) {
@@ -683,4 +723,10 @@ export class TerminalManagerWidget extends BaseWidget implements StatefulWidget,
             this.shell.activateWidget(this.id);
         }
     }
+
+    override dispose(): void {
+        this.toDispose.dispose();
+        super.dispose();
+        this.terminalWidgets.clear();
+    }
 }