@theia/core 1.46.1 → 1.47.0

package/src/browser/icon-registry.ts

@@ -19,6 +19,7 @@
  *--------------------------------------------------------------------------------------------*/
 // code copied and modified from https://github.com/Microsoft/vscode/blob/main/src/vs/platform/theme/common/iconRegistry.ts
 
+import { ThemeIcon } from '../common/theme';
 import { URI } from 'vscode-uri';
 
 export interface IconDefinition {
@@ -48,16 +49,6 @@ export interface IconFontSource {
     readonly location: URI;
     readonly format: string;
 }
-
-export interface ThemeIcon {
-    readonly id: string;
-    readonly color?: ThemeColor;
-}
-
-export interface ThemeColor {
-    id: string;
-}
-
 export const IconRegistry = Symbol('IconRegistry');
 export interface IconRegistry {
     /**

package/src/browser/markdown-rendering/markdown-renderer.ts

@@ -24,7 +24,7 @@ import { codicon } from '../widgets';
 
 // #region Copied from Copied from https://github.com/microsoft/vscode/blob/7d9b1c37f8e5ae3772782ba3b09d827eb3fdd833/src/vs/base/browser/formattedTextRenderer.ts
 export interface ContentActionHandler {
-    callback: (content: string, event?: MouseEvent) => void;
+    callback: (content: string, event?: MouseEvent | KeyboardEvent) => void;
     readonly disposables: DisposableGroup;
 }
 

package/src/browser/save-resource-service.ts

@@ -15,7 +15,7 @@
  ********************************************************************************/
 
 import { inject, injectable } from 'inversify';
-import { MessageService, UNTITLED_SCHEME } from '../common';
+import { MessageService, UNTITLED_SCHEME, URI } from '../common';
 import { Navigatable, NavigatableWidget } from './navigatable-types';
 import { Saveable, SaveableSource, SaveOptions } from './saveable';
 import { Widget } from './widgets';
@@ -41,11 +41,12 @@ export class SaveResourceService {
      *
      * No op if the widget is not saveable.
      */
-    async save(widget: Widget | undefined, options?: SaveOptions): Promise<void> {
+    async save(widget: Widget | undefined, options?: SaveOptions): Promise<URI | undefined> {
         if (this.canSaveNotSaveAs(widget)) {
             await Saveable.save(widget, options);
+            return NavigatableWidget.getUri(widget);
         } else if (this.canSaveAs(widget)) {
-            await this.saveAs(widget, options);
+            return this.saveAs(widget, options);
         }
     }
 
@@ -53,7 +54,7 @@ export class SaveResourceService {
         return false;
     }
 
-    saveAs(sourceWidget: Widget & SaveableSource & Navigatable, options?: SaveOptions): Promise<void> {
+    saveAs(sourceWidget: Widget & SaveableSource & Navigatable, options?: SaveOptions): Promise<URI | undefined> {
         return Promise.reject('Unsupported: The base SaveResourceService does not support saveAs action.');
     }
 }

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

@@ -132,16 +132,19 @@ export class DockPanelRenderer implements DockLayout.IRenderer {
             getDynamicTabOptions());
         this.tabBarClasses.forEach(c => tabBar.addClass(c));
         renderer.tabBar = tabBar;
-        tabBar.disposed.connect(() => renderer.dispose());
         renderer.contextMenuPath = SHELL_TABBAR_CONTEXT_MENU;
         tabBar.currentChanged.connect(this.onCurrentTabChanged, this);
-        this.corePreferences.onPreferenceChanged(change => {
+        const prefChangeDisposable = this.corePreferences.onPreferenceChanged(change => {
             if (change.preferenceName === 'workbench.tab.shrinkToFit.enabled' ||
                 change.preferenceName === 'workbench.tab.shrinkToFit.minimumSize' ||
                 change.preferenceName === 'workbench.tab.shrinkToFit.defaultSize') {
                 tabBar.dynamicTabOptions = getDynamicTabOptions();
             }
         });
+        tabBar.disposed.connect(() => {
+            prefChangeDisposable.dispose();
+            renderer.dispose();
+        });
         this.onDidCreateTabBarEmitter.fire(tabBar);
         return tabBar;
     }
@@ -1229,7 +1232,9 @@ export class ApplicationShell extends Widget {
         Saveable.apply(
             widget,
             () => this.widgets.filter((maybeSaveable): maybeSaveable is Widget & SaveableSource => !!Saveable.get(maybeSaveable)),
-            (toSave, options) => this.saveResourceService.save(toSave, options),
+            async (toSave, options) => {
+                await this.saveResourceService.save(toSave, options);
+            },
         );
         if (ApplicationShell.TrackableWidgetProvider.is(widget)) {
             for (const toTrack of widget.getTrackableWidgets()) {

package/src/browser/shell/tab-bar-decorator.ts

@@ -17,9 +17,12 @@
 import debounce = require('lodash.debounce');
 import { Title, Widget } from '@phosphor/widgets';
 import { inject, injectable, named } from 'inversify';
-import { Event, Emitter, ContributionProvider } from '../../common';
-import { WidgetDecoration } from '../widget-decoration';
+import { ContributionProvider, Emitter, Event } from '../../common';
+import { ColorRegistry } from '../color-registry';
+import { Decoration, DecorationsService, DecorationsServiceImpl } from '../decorations-service';
 import { FrontendApplicationContribution } from '../frontend-application-contribution';
+import { Navigatable } from '../navigatable-types';
+import { WidgetDecoration } from '../widget-decoration';
 
 export const TabBarDecorator = Symbol('TabBarDecorator');
 
@@ -53,6 +56,12 @@ export class TabBarDecoratorService implements FrontendApplicationContribution {
     @inject(ContributionProvider) @named(TabBarDecorator)
     protected readonly contributions: ContributionProvider<TabBarDecorator>;
 
+    @inject(DecorationsService)
+    protected readonly decorationsService: DecorationsServiceImpl;
+
+    @inject(ColorRegistry)
+    protected readonly colors: ColorRegistry;
+
     initialize(): void {
         this.contributions.getContributions().map(decorator => decorator.onDidChangeDecorations(this.fireDidChangeDecorations));
     }
@@ -66,11 +75,32 @@ export class TabBarDecoratorService implements FrontendApplicationContribution {
      */
     getDecorations(title: Title<Widget>): WidgetDecoration.Data[] {
         const decorators = this.contributions.getContributions();
-        let all: WidgetDecoration.Data[] = [];
+        const decorations: WidgetDecoration.Data[] = [];
         for (const decorator of decorators) {
-            const decorations = decorator.decorate(title);
-            all = all.concat(decorations);
+            decorations.push(...decorator.decorate(title));
         }
-        return all;
+        if (Navigatable.is(title.owner)) {
+            const resourceUri = title.owner.getResourceUri();
+            if (resourceUri) {
+                const serviceDecorations = this.decorationsService.getDecoration(resourceUri, false);
+                decorations.push(...serviceDecorations.map(d => this.fromDecoration(d)));
+            }
+        }
+        return decorations;
+    }
+
+    protected fromDecoration(decoration: Decoration): WidgetDecoration.Data {
+        const colorVariable = decoration.colorId && this.colors.toCssVariableName(decoration.colorId);
+        return {
+            tailDecorations: [
+                {
+                    data: decoration.letter ? decoration.letter : '',
+                    fontData: {
+                        color: colorVariable && `var(${colorVariable})`
+                    },
+                    tooltip: decoration.tooltip ? decoration.tooltip : ''
+                }
+            ]
+        };
     }
 }

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

@@ -17,7 +17,7 @@
 import PerfectScrollbar from 'perfect-scrollbar';
 import { TabBar, Title, Widget } from '@phosphor/widgets';
 import { VirtualElement, h, VirtualDOM, ElementInlineStyle } from '@phosphor/virtualdom';
-import { Disposable, DisposableCollection, MenuPath, notEmpty, SelectionService, CommandService, nls } from '../../common';
+import { Disposable, DisposableCollection, MenuPath, notEmpty, SelectionService, CommandService, nls, ArrayUtils } from '../../common';
 import { ContextMenuRenderer } from '../context-menu-renderer';
 import { Signal, Slot } from '@phosphor/signaling';
 import { Message, MessageLoop } from '@phosphor/messaging';
@@ -39,6 +39,7 @@ import { SelectComponent } from '../widgets/select-component';
 import { createElement } from 'react';
 import { PreviewableWidget } from '../widgets/previewable-widget';
 import { EnhancedPreviewWidget } from '../widgets/enhanced-preview-widget';
+import { ContextKeyService } from '../context-key-service';
 
 /** The class name added to hidden content nodes, which are required to render vertical side bars. */
 const HIDDEN_CONTENT_CLASS = 'theia-TabBar-hidden-content';
@@ -102,7 +103,8 @@ export class TabBarRenderer extends TabBar.Renderer {
         protected readonly selectionService?: SelectionService,
         protected readonly commandService?: CommandService,
         protected readonly corePreferences?: CorePreferences,
-        protected readonly hoverService?: HoverService
+        protected readonly hoverService?: HoverService,
+        protected readonly contextKeyService?: ContextKeyService,
     ) {
         super();
         if (this.decoratorService) {
@@ -170,8 +172,8 @@ export class TabBarRenderer extends TabBar.Renderer {
         const hover = this.tabBar && (this.tabBar.orientation === 'horizontal' && this.corePreferences?.['window.tabbar.enhancedPreview'] === 'classic')
             ? { title: title.caption }
             : {
-            onmouseenter: this.handleMouseEnterEvent
-        };
+                onmouseenter: this.handleMouseEnterEvent
+            };
 
         return h.li(
             {
@@ -188,6 +190,7 @@ export class TabBarRenderer extends TabBar.Renderer {
                 { 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)
             ),
@@ -289,6 +292,37 @@ export class TabBarRenderer extends TabBar.Renderer {
         return h.div({ className: 'p-TabBar-tabLabel', style }, data.title.label);
     }
 
+    protected renderTailDecorations(renderData: SideBarRenderData, isInSidePanel?: boolean): VirtualElement[] {
+        if (!this.corePreferences?.get('workbench.editor.decorations.badges')) {
+            return [];
+        }
+        const tailDecorations = ArrayUtils.coalesce(this.getDecorationData(renderData.title, 'tailDecorations')).flat();
+        if (tailDecorations === undefined || tailDecorations.length === 0) {
+            return [];
+        }
+        let dotDecoration: WidgetDecoration.TailDecoration.AnyPartial | undefined;
+        const otherDecorations: WidgetDecoration.TailDecoration.AnyPartial[] = [];
+        tailDecorations.reverse().forEach(decoration => {
+            const partial = decoration as WidgetDecoration.TailDecoration.AnyPartial;
+            if (WidgetDecoration.TailDecoration.isDotDecoration(partial)) {
+                dotDecoration ||= partial;
+            } else if (partial.data || partial.icon || partial.iconClass) {
+                otherDecorations.push(partial);
+            }
+        });
+        const decorationsToRender = dotDecoration ? [dotDecoration, ...otherDecorations] : otherDecorations;
+        return decorationsToRender.map((decoration, index) => {
+            const { tooltip, data, fontData, color, icon, iconClass } = decoration;
+            const iconToRender = icon ?? iconClass;
+            const className = ['p-TabBar-tail', 'flex'].join(' ');
+            const style = fontData ? fontData : color ? { color } : undefined;
+            const content = (data ? data : iconToRender
+                ? h.span({ className: this.getIconClass(iconToRender, iconToRender === 'circle' ? [WidgetDecoration.Styles.DECORATOR_SIZE_CLASS] : []) })
+                : '') + (index !== decorationsToRender.length - 1 ? ',' : '');
+            return h.span({ key: ('tailDecoration_' + index), className, style, title: tooltip ?? content }, content);
+        });
+    }
+
     renderBadge(data: SideBarRenderData, isInSidePanel?: boolean): VirtualElement {
         const totalBadge = this.getDecorationData(data.title, 'badge').reduce((sum, badge) => sum! + badge!, 0);
         if (!totalBadge) {
@@ -614,10 +648,12 @@ export class TabBarRenderer extends TabBar.Renderer {
                 this.selectionService.selection = NavigatableWidget.is(widget) ? { uri: widget.getResourceUri() } : widget;
             }
 
+            const contextKeyServiceOverlay = this.contextKeyService?.createOverlay([['isTerminalTab', widget && 'terminalId' in widget]]);
             this.contextMenuRenderer.render({
                 menuPath: this.contextMenuPath!,
                 anchor: event,
                 args: [event],
+                contextKeyService: contextKeyServiceOverlay,
                 // We'd like to wait until the command triggered by the context menu has been run, but this should let it get through the preamble, at least.
                 onHide: () => setTimeout(() => { if (this.selectionService) { this.selectionService.selection = oldSelection; } })
             });
@@ -967,7 +1003,7 @@ export class ToolbarAwareTabBar extends ScrollableTabBar {
 
     protected override onBeforeDetach(msg: Message): void {
         if (this.toolbar && this.toolbar.isAttached) {
-            Widget.detach(this.toolbar);
+            this.toolbar.dispose();
         }
         super.onBeforeDetach(msg);
     }