@theia/plugin-ext 1.50.1 → 1.52.0

package/src/main/browser/notebooks/renderers/cell-output-webview.tsx

@@ -35,6 +35,7 @@ import { CellUri } from '@theia/notebook/lib/common';
 import { Disposable, DisposableCollection, nls, QuickPickService } from '@theia/core';
 import { NotebookCellOutputModel } from '@theia/notebook/lib/browser/view-model/notebook-cell-output-model';
 import { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
+import { NotebookOptionsService, NotebookOutputOptions } from '@theia/notebook/lib/browser/service/notebook-options';
 
 const CellModel = Symbol('CellModel');
 const Notebook = Symbol('NotebookModel');
@@ -147,6 +148,11 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
     @inject(AdditionalNotebookCellOutputCss)
     protected readonly additionalOutputCss: string;
 
+    @inject(NotebookOptionsService)
+    protected readonly notebookOptionsService: NotebookOptionsService;
+
+    protected options: NotebookOutputOptions;
+
     readonly id = generateUuid();
 
     protected editor: NotebookEditorWidget | undefined;
@@ -161,6 +167,11 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
     @postConstruct()
     protected async init(): Promise<void> {
         this.editor = this.notebookEditorWidgetService.getNotebookEditor(NOTEBOOK_EDITOR_ID_PREFIX + CellUri.parse(this.cell.uri)?.notebook);
+        this.options = this.notebookOptionsService.computeOutputOptions();
+        this.toDispose.push(this.notebookOptionsService.onDidChangeOutputOptions(options => {
+            this.options = options;
+            this.updateStyles();
+        }));
 
         this.toDispose.push(this.cell.onDidChangeOutputs(outputChange => this.updateOutput(outputChange)));
         this.toDispose.push(this.cell.onDidChangeOutputItems(output => {
@@ -187,6 +198,7 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
         }
 
         this.webviewWidget = await this.widgetManager.getOrCreateWidget(WebviewWidget.FACTORY_ID, { id: this.id });
+        this.webviewWidget.parent = this.editor ?? null;
         this.webviewWidget.setContentOptions({
             allowScripts: true,
             // eslint-disable-next-line max-len
@@ -271,6 +283,7 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
         switch (message.type) {
             case 'initialized':
                 this.updateOutput({ newOutputs: this.cell.outputs, start: 0, deleteCount: 0 });
+                this.updateStyles();
                 break;
             case 'customRendererMessage':
                 // console.log('from webview customRendererMessage ', message.rendererId, '', JSON.stringify(message.message));
@@ -301,6 +314,22 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
         return kernelPreloads.concat(staticPreloads);
     }
 
+    protected updateStyles(): void {
+        this.webviewWidget.sendMessage({
+            type: 'notebookStyles',
+            styles: this.generateStyles()
+        });
+    }
+
+    protected generateStyles(): { [key: string]: string } {
+        return {
+            'notebook-cell-output-font-size': `${this.options.outputFontSize || this.options.fontSize}px`,
+            'notebook-cell-output-line-height': `${this.options.outputLineHeight}px`,
+            'notebook-cell-output-max-height': `${this.options.outputLineHeight * this.options.outputLineLimit}px`,
+            'notebook-cell-output-font-family': this.options.outputFontFamily || this.options.fontFamily,
+        };
+    }
+
     private async createWebviewContent(): Promise<string> {
         const isWorkspaceTrusted = await this.workspaceTrustService.getWorkspaceTrust();
         const preloads = this.preloadsScriptString(isWorkspaceTrusted);
@@ -324,10 +353,10 @@ export class CellOutputWebviewImpl implements CellOutputWebview, Disposable {
         const ctx: PreloadContext = {
             isWorkspaceTrusted,
             rendererData: this.notebookRendererRegistry.notebookRenderers,
-            renderOptions: { // TODO these should be changeable in the settings
-                lineLimit: 30,
-                outputScrolling: false,
-                outputWordWrap: false,
+            renderOptions: {
+                lineLimit: this.options.outputLineLimit,
+                outputScrolling: this.options.outputScrolling,
+                outputWordWrap: this.options.outputWordWrap,
             },
             staticPreloadsData: this.getPreloads()
         };

package/src/main/browser/notebooks/renderers/output-webview-internal.ts

@@ -569,6 +569,24 @@ export async function outputWebviewPreload(ctx: PreloadContext): Promise<void> {
                 }
                 break;
             }
+            case 'notebookStyles': {
+                const documentStyle = window.document.documentElement.style;
+
+                for (let i = documentStyle.length - 1; i >= 0; i--) {
+                    const property = documentStyle[i];
+
+                    // Don't remove properties that the webview might have added separately
+                    if (property && property.startsWith('--notebook-')) {
+                        documentStyle.removeProperty(property);
+                    }
+                }
+
+                // Re-add new properties
+                for (const [name, value] of Object.entries(event.data.styles)) {
+                    documentStyle.setProperty(`--${name}`, value);
+                }
+                break;
+            }
         }
     });
     window.addEventListener('wheel', handleWheel);

package/src/main/browser/notebooks/renderers/webview-communication.ts

@@ -59,7 +59,18 @@ export interface PreloadMessage {
     readonly resources: string[];
 }
 
-export type ToWebviewMessage = UpdateRenderersMessage | OutputChangedMessage | ChangePreferredMimetypeMessage | CustomRendererMessage | KernelMessage | PreloadMessage;
+export interface notebookStylesMessage {
+    readonly type: 'notebookStyles';
+    styles: Record<string, string>;
+}
+
+export type ToWebviewMessage = UpdateRenderersMessage
+    | OutputChangedMessage
+    | ChangePreferredMimetypeMessage
+    | CustomRendererMessage
+    | KernelMessage
+    | PreloadMessage
+    | notebookStylesMessage;
 
 export interface WebviewInitialized {
     readonly type: 'initialized';

package/src/main/browser/quick-open-main.ts

@@ -42,11 +42,8 @@ import { DisposableCollection, Disposable } from '@theia/core/lib/common/disposa
 import { CancellationToken } from '@theia/core/lib/common/cancellation';
 import { MonacoQuickInputService } from '@theia/monaco/lib/browser/monaco-quick-input-service';
 import { QuickInputButtons } from '../../plugin/types-impl';
-import * as monaco from '@theia/monaco-editor-core';
-import { UriComponents } from '../../common/uri-components';
-import { URI } from '@theia/core/shared/vscode-uri';
 import { ThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
-import { isUriComponents } from '@theia/monaco-editor-core/esm/vs/base/common/uri';
+import { PluginSharedStyle } from './plugin-shared-style';
 import { QuickPickSeparator } from '@theia/core';
 
 export interface QuickInputSession {
@@ -54,16 +51,12 @@ export interface QuickInputSession {
     handlesToItems: Map<number, QuickPickItemOrSeparator>;
 }
 
-interface IconPath {
-    dark: URI,
-    light?: URI
-};
-
 export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
 
     private quickInputService: QuickInputService;
     private proxy: QuickOpenExt;
     private delegate: MonacoQuickInputService;
+    private sharedStyle: PluginSharedStyle;
     private readonly items: Record<number, {
         resolve(items: QuickPickItemOrSeparator[]): void;
         reject(error: Error): void;
@@ -75,6 +68,7 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.QUICK_OPEN_EXT);
         this.delegate = container.get(MonacoQuickInputService);
         this.quickInputService = container.get(QuickInputService);
+        this.sharedStyle = container.get(PluginSharedStyle);
     }
 
     dispose(): void {
@@ -111,25 +105,21 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
         return item?.kind === 'item';
     }
 
-    private normalizeIconPath(path: UriComponents | { light: UriComponents; dark: UriComponents } | ThemeIcon | undefined): {
-        iconPath?: IconPath
-        iconClasses?: string[]
-    } {
-        let iconClasses;
+    private toIconClasses(path: { light: string; dark: string } | ThemeIcon | string | undefined): string[] {
+        const iconClasses: string[] = [];
         if (ThemeIcon.isThemeIcon(path)) {
             const codicon = codiconArray(path.id);
-            iconClasses = codicon;
-        }
-        let iconPath;
-        if (isUriComponents(path)) {
-            iconPath = { dark: URI.from(path) };
-        } else if (path && 'dark' in path) {
-            iconPath = { dark: URI.from(path.dark), light: URI.from(path.light) };
+            iconClasses.push(...codicon);
+        } else if (path) {
+            const iconReference = this.sharedStyle.toIconClass(path);
+            this.toDispose.push(iconReference);
+            iconClasses.push(iconReference.object.iconClass);
         }
-        return {
-            iconPath,
-            iconClasses
-        };
+        return iconClasses;
+    }
+
+    private toIconClass(path: { light: string; dark: string } | ThemeIcon | string | undefined): string {
+        return this.toIconClasses(path).join(' ');
     }
 
     private toQuickPickItem(item: undefined): undefined;
@@ -146,13 +136,13 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
             };
         }
         return {
-            ...this.normalizeIconPath(item.iconPath),
             type: 'item',
             id: item.handle.toString(),
             label: item.label,
             description: item.description,
             detail: item.detail,
             alwaysShow: item.alwaysShow,
+            iconClasses: this.toIconClasses(item.iconUrl),
             buttons: item.buttons ? this.convertToQuickInputButtons(item.buttons) : undefined
         };
     }
@@ -338,24 +328,12 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
                         if (button.handle === -1) {
                             return this.quickInputService.backButton;
                         }
-                        const { iconPath, tooltip, handle } = button;
-                        if ('id' in iconPath) {
-                            return {
-                                iconClass: ThemeIcon.asClassName(iconPath),
-                                tooltip,
-                                handle
-                            };
-                        } else {
-                            const monacoIconPath = (iconPath as unknown as { light: monaco.Uri, dark: monaco.Uri });
-                            return {
-                                iconPath: {
-                                    dark: monaco.Uri.revive(monacoIconPath.dark),
-                                    light: monacoIconPath.light && monaco.Uri.revive(monacoIconPath.light)
-                                },
-                                tooltip,
-                                handle
-                            };
-                        }
+                        const { iconUrl, tooltip, handle } = button;
+                        return {
+                            tooltip,
+                            handle,
+                            iconClass: this.toIconClass(iconUrl)
+                        };
                     });
                 } else {
                     (input as any)[param] = params[param];
@@ -381,7 +359,7 @@ export class QuickOpenMainImpl implements QuickOpenMain, Disposable {
 
     private convertToQuickInputButtons(buttons: readonly TransferQuickInputButton[]): QuickInputButton[] {
         return buttons.map((button, i) => ({
-            ...this.normalizeIconPath(button.iconPath),
+            iconClass: this.toIconClass(button.iconUrl),
             tooltip: button.tooltip,
             handle: button === QuickInputButtons.Back ? -1 : i,
         } as QuickInputButton));

package/src/main/browser/tabs/tabs-main.ts

@@ -25,7 +25,7 @@ import { toUriComponents } from '../hierarchy/hierarchy-types-converters';
 import { TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
 import { DisposableCollection } from '@theia/core';
 import { NotebookEditorWidget } from '@theia/notebook/lib/browser';
-import { ViewColumnService } from '@theia/core/lib/browser/shell/view-column-service';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 
 interface TabInfo {
     tab: TabDto;
@@ -38,17 +38,17 @@ export class TabsMainImpl implements TabsMain, Disposable {
     private readonly proxy: TabsExt;
     private tabGroupModel = new Map<TabBar<Widget>, TabGroupDto>();
     private tabInfoLookup = new Map<Title<Widget>, TabInfo>();
+    private waitQueue = new Map<Widget, Deferred>();
 
     private applicationShell: ApplicationShell;
 
     private disposableTabBarListeners: DisposableCollection = new DisposableCollection();
     private toDisposeOnDestroy: DisposableCollection = new DisposableCollection();
 
-    private groupIdCounter = 0;
+    private groupIdCounter = 1;
     private currentActiveGroup: TabGroupDto;
 
     private tabGroupChanged: boolean = false;
-    private viewColumnService: ViewColumnService;
 
     private readonly defaultTabGroup: TabGroupDto = {
         groupId: 0,
@@ -64,11 +64,10 @@ export class TabsMainImpl implements TabsMain, Disposable {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.TABS_EXT);
 
         this.applicationShell = container.get(ApplicationShell);
-        this.viewColumnService = container.get(ViewColumnService);
         this.createTabsModel();
 
         const tabBars = this.applicationShell.mainPanel.tabBars();
-        for (let tabBar; tabBar = tabBars.next();) {
+        for (let tabBar: TabBar<Widget> | undefined; tabBar = tabBars.next();) {
             this.attachListenersToTabBar(tabBar);
         }
 
@@ -110,6 +109,21 @@ export class TabsMainImpl implements TabsMain, Disposable {
         });
     }
 
+    waitForWidget(widget: Widget): Promise<void> {
+        const deferred = new Deferred<void>();
+        this.waitQueue.set(widget, deferred);
+
+        const timeout = setTimeout(() => {
+            deferred.resolve(); // resolve to unblock the event
+        }, 1000);
+
+        deferred.promise.then(() => {
+            clearTimeout(timeout);
+        });
+
+        return deferred.promise;
+    }
+
     protected createTabsModel(): void {
         if (this.applicationShell.mainAreaTabBars.length === 0) {
             this.proxy.$acceptEditorTabModel([this.defaultTabGroup]);
@@ -119,9 +133,9 @@ export class TabsMainImpl implements TabsMain, Disposable {
         this.tabInfoLookup.clear();
         this.disposableTabBarListeners.dispose();
         this.applicationShell.mainAreaTabBars
-            .forEach((tabBar, i) => {
+            .forEach(tabBar => {
                 this.attachListenersToTabBar(tabBar);
-                const groupDto = this.createTabGroupDto(tabBar, i);
+                const groupDto = this.createTabGroupDto(tabBar);
                 tabBar.titles.forEach((title, index) => this.tabInfoLookup.set(title, { group: groupDto, tab: groupDto.tabs[index], tabIndex: index }));
                 newTabGroupModel.set(tabBar, groupDto);
             });
@@ -131,31 +145,38 @@ export class TabsMainImpl implements TabsMain, Disposable {
         }
         this.tabGroupModel = newTabGroupModel;
         this.proxy.$acceptEditorTabModel(Array.from(this.tabGroupModel.values()));
+        // Resolve all waiting widget promises
+        this.waitQueue.forEach(deferred => deferred.resolve());
+        this.waitQueue.clear();
     }
 
-    protected createTabDto(tabTitle: Title<Widget>, groupId: number): TabDto {
+    protected createTabDto(tabTitle: Title<Widget>, groupId: number, newTab = false): TabDto {
         const widget = tabTitle.owner;
+        const active = newTab || this.getTabBar(tabTitle)?.currentTitle === tabTitle;
         return {
             id: this.createTabId(tabTitle, groupId),
             label: tabTitle.label,
             input: this.evaluateTabDtoInput(widget),
-            isActive: tabTitle.owner.isVisible,
+            isActive: active,
             isPinned: tabTitle.className.includes(PINNED_CLASS),
             isDirty: Saveable.isDirty(widget),
             isPreview: widget instanceof EditorPreviewWidget && widget.isPreview
         };
     }
 
+    protected getTabBar(tabTitle: Title<Widget>): TabBar<Widget> | undefined {
+        return this.applicationShell.mainPanel.findTabBar(tabTitle);
+    }
+
     protected createTabId(tabTitle: Title<Widget>, groupId: number): string {
         return `${groupId}~${tabTitle.owner.id}`;
     }
 
-    protected createTabGroupDto(tabBar: TabBar<Widget>, index: number): TabGroupDto {
-        const oldDto = index === 0 ? this.defaultTabGroup : this.tabGroupModel.get(tabBar);
+    protected createTabGroupDto(tabBar: TabBar<Widget>): TabGroupDto {
+        const oldDto = this.tabGroupModel.get(tabBar);
         const groupId = oldDto?.groupId ?? this.groupIdCounter++;
         const tabs = tabBar.titles.map(title => this.createTabDto(title, groupId));
-        const viewColumn = this.viewColumnService.getViewColumn(tabBar.id)
-            ?? this.applicationShell.allTabBars.indexOf(tabBar);
+        const viewColumn = 0; // TODO: Implement correct viewColumn handling
         return {
             groupId,
             tabs,
@@ -190,7 +211,6 @@ export class TabsMainImpl implements TabsMain, Disposable {
                     uri: toUriComponents(widget.editor.uri.toString())
                 };
             }
-            // TODO notebook support when implemented
         } else if (widget instanceof ViewContainer) {
             return {
                 kind: TabInputKind.WebviewEditorInput,
@@ -238,7 +258,7 @@ export class TabsMainImpl implements TabsMain, Disposable {
     private onTabCreated(tabBar: TabBar<Widget>, args: TabBar.ITabActivateRequestedArgs<Widget>): void {
         const group = this.getOrRebuildModel(this.tabGroupModel, tabBar);
         this.connectToSignal(this.disposableTabBarListeners, args.title.changed, this.onTabTitleChanged);
-        const tabDto = this.createTabDto(args.title, group.groupId);
+        const tabDto = this.createTabDto(args.title, group.groupId, true);
         this.tabInfoLookup.set(args.title, { group, tab: tabDto, tabIndex: args.index });
         group.tabs.splice(args.index, 0, tabDto);
         this.proxy.$acceptTabOperation({
@@ -247,6 +267,8 @@ export class TabsMainImpl implements TabsMain, Disposable {
             tabDto,
             groupId: group.groupId
         });
+        this.waitQueue.get(args.title.owner)?.resolve();
+        this.waitQueue.delete(args.title.owner);
     }
 
     private onTabTitleChanged(title: Title<Widget>): void {
@@ -275,6 +297,8 @@ export class TabsMainImpl implements TabsMain, Disposable {
                 groupId: tabInfo.group.groupId
             });
         }
+        this.waitQueue.get(title.owner)?.resolve();
+        this.waitQueue.delete(title.owner);
     }
 
     private onTabClosed(tabInfo: TabInfo, title: Title<Widget>): void {

package/src/main/browser/terminal-main.ts

@@ -15,21 +15,22 @@
 // *****************************************************************************
 
 import { interfaces } from '@theia/core/shared/inversify';
-import { ApplicationShell, WidgetOpenerOptions } from '@theia/core/lib/browser';
-import { TerminalEditorLocationOptions, TerminalOptions } from '@theia/plugin';
+import { ApplicationShell, WidgetOpenerOptions, codicon } from '@theia/core/lib/browser';
+import { TerminalEditorLocationOptions } from '@theia/plugin';
 import { TerminalLocation, TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
 import { TerminalProfileService } from '@theia/terminal/lib/browser/terminal-profile-service';
 import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
-import { TerminalServiceMain, TerminalServiceExt, MAIN_RPC_CONTEXT } from '../../common/plugin-api-rpc';
+import { TerminalServiceMain, TerminalServiceExt, MAIN_RPC_CONTEXT, TerminalOptions } from '../../common/plugin-api-rpc';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { SerializableEnvironmentVariableCollection, ShellTerminalServerProxy } from '@theia/terminal/lib/common/shell-terminal-protocol';
 import { TerminalLink, TerminalLinkProvider } from '@theia/terminal/lib/browser/terminal-link-provider';
 import { URI } from '@theia/core/lib/common/uri';
-import { getIconClass } from '../../plugin/terminal-ext';
 import { PluginTerminalRegistry } from './plugin-terminal-registry';
-import { CancellationToken } from '@theia/core';
+import { CancellationToken, isObject } from '@theia/core';
 import { HostedPluginSupport } from '../../hosted/browser/hosted-plugin';
+import { PluginSharedStyle } from './plugin-shared-style';
+import { ThemeIcon } from '@theia/core/lib/common/theme';
 import debounce = require('@theia/core/shared/lodash.debounce');
 
 interface TerminalObserverData {
@@ -49,6 +50,7 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
     private readonly hostedPluginSupport: HostedPluginSupport;
     private readonly shell: ApplicationShell;
     private readonly extProxy: TerminalServiceExt;
+    private readonly sharedStyle: PluginSharedStyle;
     private readonly shellTerminalServer: ShellTerminalServerProxy;
     private readonly terminalLinkProviders: string[] = [];
 
@@ -60,6 +62,7 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
         this.terminalProfileService = container.get(TerminalProfileService);
         this.pluginTerminalRegistry = container.get(PluginTerminalRegistry);
         this.hostedPluginSupport = container.get(HostedPluginSupport);
+        this.sharedStyle = container.get(PluginSharedStyle);
         this.shell = container.get(ApplicationShell);
         this.shellTerminalServer = container.get(ShellTerminalServerProxy);
         this.extProxy = rpc.getProxy(MAIN_RPC_CONTEXT.TERMINAL_EXT);
@@ -153,7 +156,7 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
         const terminal = await this.terminals.newTerminal({
             id,
             title: options.name,
-            iconClass: getIconClass(options),
+            iconClass: this.toIconClass(options),
             shellPath: options.shellPath,
             shellArgs: options.shellArgs,
             cwd: options.cwd ? new URI(options.cwd) : undefined,
@@ -329,6 +332,23 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
         }));
     }
 
+    protected toIconClass(options: TerminalOptions): string | ThemeIcon | undefined {
+        const iconColor = isObject<{ id: string }>(options.color) && typeof options.color.id === 'string' ? options.color.id : undefined;
+        let iconClass: string;
+        if (options.iconUrl) {
+            if (typeof options.iconUrl === 'object' && 'id' in options.iconUrl) {
+                iconClass = codicon(options.iconUrl.id);
+            } else {
+                const iconReference = this.sharedStyle.toIconClass(options.iconUrl);
+                this.toDispose.push(iconReference);
+                iconClass = iconReference.object.iconClass;
+            }
+        } else {
+            iconClass = codicon('terminal');
+        }
+        return iconColor ? { id: iconClass, color: { id: iconColor } } : iconClass;
+    }
+
     $unregisterTerminalObserver(id: string): void {
         const observer = this.observers.get(id);
         if (observer) {

package/src/main/browser/test-main.ts

@@ -18,6 +18,7 @@ import { SimpleObservableCollection, TreeCollection, observableProperty } from '
 import {
     TestController, TestItem, TestOutputItem, TestRun, TestRunProfile, TestService, TestState, TestStateChangedEvent
 } from '@theia/test/lib/browser/test-service';
+import { TestExecutionProgressService } from '@theia/test/lib/browser/test-execution-progress-service';
 import { AccumulatingTreeDeltaEmitter, CollectionDelta, DeltaKind, TreeDelta, TreeDeltaBuilder } from '@theia/test/lib/common/tree-delta';
 import { Emitter, Location, Range } from '@theia/core/shared/vscode-languageserver-protocol';
 import { Range as PluginRange, Location as PluginLocation } from '../../common/plugin-api-rpc-model';
@@ -245,13 +246,14 @@ class TestRunProfileImpl implements TestRunProfile {
         this.proxy.$onConfigureRunProfile(this.controllerId, this.id);
     }
 
-    run(name: string, included: TestItem[], excluded: TestItem[]): void {
+    run(name: string, included: TestItem[], excluded: TestItem[], preserveFocus: boolean): void {
         this.proxy.$onRunControllerTests([{
             controllerId: this.controllerId,
             name,
             profileId: this.id,
             includedTests: included.map(item => itemToPath(item)),
-            excludedTests: excluded.map(item => itemToPath(item))
+            excludedTests: excluded.map(item => itemToPath(item)),
+            preserveFocus
         }]);
     }
 }
@@ -551,12 +553,14 @@ class TestControllerImpl implements TestController {
 
 export class TestingMainImpl implements TestingMain {
     private testService: TestService;
+    private testExecutionProgressService: TestExecutionProgressService;
     private controllerRegistrations = new Map<string, [TestControllerImpl, Disposable]>();
     private proxy: TestingExt;
     canRefresh: boolean;
 
     constructor(rpc: RPCProtocol, container: interfaces.Container, commandRegistry: CommandRegistryMainImpl) {
         this.testService = container.get(TestService);
+        this.testExecutionProgressService = container.get(TestExecutionProgressService);
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.TESTING_EXT);
         commandRegistry.registerArgumentProcessor({
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -614,7 +618,8 @@ export class TestingMainImpl implements TestingMain {
     $removeTestRunProfile(controllerId: string, profileId: string): void {
         this.withController(controllerId).removeProfile(profileId);
     }
-    $notifyTestRunCreated(controllerId: string, run: TestRunDTO): void {
+    $notifyTestRunCreated(controllerId: string, run: TestRunDTO, preserveFocus: boolean): void {
+        this.testExecutionProgressService.onTestRunRequested(preserveFocus);
         this.withController(controllerId).addRun(run.id, run.name, run.isRunning);
     }
     $notifyTestStateChanged(controllerId: string, runId: string, stateChanges: TestStateChangeDTO[], outputChanges: TestOutputDTO[]): void {

package/src/main/browser/text-editor-model-service.ts

@@ -76,6 +76,15 @@ export class EditorModelService {
         return this.monacoModelService.models;
     }
 
+    async save(uri: URI): Promise<boolean> {
+        const model = this.monacoModelService.get(uri.toString());
+        if (model) {
+            await model.save();
+            return true;
+        }
+        return false;
+    }
+
     async saveAll(includeUntitled?: boolean): Promise<boolean> {
         const saves = [];
         for (const model of this.monacoModelService.models) {

package/src/main/browser/view/tree-views-main.ts

@@ -24,7 +24,6 @@ import {
     CompositeTreeNode,
     WidgetManager
 } from '@theia/core/lib/browser';
-import { ViewContextKeyService } from './view-context-key-service';
 import { Disposable, DisposableCollection } from '@theia/core';
 import { TreeViewWidget, TreeViewNode, PluginTreeModel, TreeViewWidgetOptions } from './tree-view-widget';
 import { PluginViewWidget } from './plugin-view-widget';
@@ -36,7 +35,6 @@ export class TreeViewsMainImpl implements TreeViewsMain, Disposable {
 
     private readonly proxy: TreeViewsExt;
     private readonly viewRegistry: PluginViewRegistry;
-    private readonly contextKeys: ViewContextKeyService;
     private readonly widgetManager: WidgetManager;
     private readonly fileContentStore: DnDFileContentStore;
 
@@ -50,7 +48,6 @@ export class TreeViewsMainImpl implements TreeViewsMain, Disposable {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.TREE_VIEWS_EXT);
         this.viewRegistry = container.get(PluginViewRegistry);
 
-        this.contextKeys = this.container.get(ViewContextKeyService);
         this.widgetManager = this.container.get(WidgetManager);
         this.fileContentStore = this.container.get(DnDFileContentStore);
     }
@@ -197,7 +194,6 @@ export class TreeViewsMainImpl implements TreeViewsMain, Disposable {
         }));
 
         this.toDispose.push(treeViewWidget.model.onSelectionChanged(event => {
-            this.contextKeys.view.set(treeViewId);
             this.proxy.$setSelection(treeViewId, event.map((node: TreeViewNode) => node.id));
         }));
 

package/src/main/browser/view/view-context-key-service.ts

@@ -19,11 +19,6 @@ import { ContextKey, ContextKeyService } from '@theia/core/lib/browser/context-k
 
 @injectable()
 export class ViewContextKeyService {
-    protected _view: ContextKey<string>;
-    get view(): ContextKey<string> {
-        return this._view;
-    }
-
     protected _viewItem: ContextKey<string>;
     get viewItem(): ContextKey<string> {
         return this._viewItem;
@@ -56,7 +51,6 @@ export class ViewContextKeyService {
 
     @postConstruct()
     protected init(): void {
-        this._view = this.contextKeyService.createKey('view', '');
         this._viewItem = this.contextKeyService.createKey('viewItem', '');
         this._activeViewlet = this.contextKeyService.createKey('activeViewlet', '');
         this._activePanel = this.contextKeyService.createKey('activePanel', '');

package/src/main/browser/window-state-main.ts

@@ -69,7 +69,7 @@ export class WindowStateMain implements WindowMain, Disposable {
         const uri = URI.revive(uriComponent);
         const url = new CoreURI(encodeURI(uri.toString(true)));
         try {
-            await open(this.openerService, url);
+            await open(this.openerService, url, { openExternalApp: true });
             return true;
         } catch (e) {
             return false;