@theia/plugin-ext 1.50.0 → 1.51.0

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

@@ -20,10 +20,10 @@ import { DisposableCollection, Disposable, UntitledResourceResolver } from '@the
 import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { EditorModelService } from './text-editor-model-service';
-import { EditorManager, EditorOpenerOptions } from '@theia/editor/lib/browser';
+import { EditorOpenerOptions } from '@theia/editor/lib/browser';
 import URI from '@theia/core/lib/common/uri';
 import { URI as CodeURI } from '@theia/core/shared/vscode-uri';
-import { ApplicationShell, Saveable } from '@theia/core/lib/browser';
+import { ApplicationShell } from '@theia/core/lib/browser';
 import { TextDocumentShowOptions } from '../../common/plugin-api-rpc-model';
 import { Range } from '@theia/core/shared/vscode-languageserver-protocol';
 import { OpenerService } from '@theia/core/lib/browser/opener-service';
@@ -94,7 +94,6 @@ export class DocumentsMainImpl implements DocumentsMain, Disposable {
         notebookDocuments: NotebookDocumentsMainImpl,
         private readonly modelService: EditorModelService,
         rpc: RPCProtocol,
-        private editorManager: EditorManager,
         private openerService: OpenerService,
         private shell: ApplicationShell,
         private untitledResourceResolver: UntitledResourceResolver,
@@ -206,13 +205,7 @@ export class DocumentsMainImpl implements DocumentsMain, Disposable {
     }
 
     async $trySaveDocument(uri: UriComponents): Promise<boolean> {
-        const widget = await this.editorManager.getByUri(new URI(CodeURI.revive(uri)));
-        if (widget) {
-            await Saveable.save(widget);
-            return true;
-        }
-
-        return false;
+        return this.modelService.save(new URI(CodeURI.revive(uri)));
     }
 
     async $tryOpenDocument(uri: UriComponents): Promise<boolean> {
@@ -226,17 +219,6 @@ export class DocumentsMainImpl implements DocumentsMain, Disposable {
         }
     }
 
-    async $tryCloseDocument(uri: UriComponents): Promise<boolean> {
-        const widget = await this.editorManager.getByUri(new URI(CodeURI.revive(uri)));
-        if (widget) {
-            await Saveable.save(widget);
-            widget.close();
-            return true;
-        }
-
-        return false;
-    }
-
     static toEditorOpenerOptions(shell: ApplicationShell, options?: TextDocumentShowOptions): EditorOpenerOptions | undefined {
         if (!options) {
             return undefined;

package/src/main/browser/editors-and-documents-main.ts

@@ -33,6 +33,7 @@ import { TextEditorMain } from './text-editor-main';
 import { DisposableCollection, Emitter, URI } from '@theia/core';
 import { EditorManager, EditorWidget } from '@theia/editor/lib/browser';
 import { SaveableService } from '@theia/core/lib/browser/saveable-service';
+import { TabsMainImpl } from './tabs/tabs-main';
 
 export class EditorsAndDocumentsMain implements Disposable {
 
@@ -59,14 +60,14 @@ export class EditorsAndDocumentsMain implements Disposable {
         Disposable.create(() => this.textEditors.clear())
     );
 
-    constructor(rpc: RPCProtocol, container: interfaces.Container) {
+    constructor(rpc: RPCProtocol, container: interfaces.Container, tabsMain: TabsMainImpl) {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.EDITORS_AND_DOCUMENTS_EXT);
 
         this.editorManager = container.get(EditorManager);
         this.modelService = container.get(EditorModelService);
         this.saveResourceService = container.get(SaveableService);
 
-        this.stateComputer = new EditorAndDocumentStateComputer(d => this.onDelta(d), this.editorManager, this.modelService);
+        this.stateComputer = new EditorAndDocumentStateComputer(d => this.onDelta(d), this.editorManager, this.modelService, tabsMain);
         this.toDispose.push(this.stateComputer);
         this.toDispose.push(this.onTextEditorAddEmitter);
         this.toDispose.push(this.onTextEditorRemoveEmitter);
@@ -217,18 +218,25 @@ class EditorAndDocumentStateComputer implements Disposable {
     constructor(
         private callback: (delta: EditorAndDocumentStateDelta) => void,
         private readonly editorService: EditorManager,
-        private readonly modelService: EditorModelService
+        private readonly modelService: EditorModelService,
+        private readonly tabsMain: TabsMainImpl
     ) { }
 
     listen(): void {
         if (this.toDispose.disposed) {
             return;
         }
-        this.toDispose.push(this.editorService.onCreated(widget => {
+        this.toDispose.push(this.editorService.onCreated(async widget => {
+            await this.tabsMain.waitForWidget(widget);
             this.onTextEditorAdd(widget);
             this.update();
         }));
-        this.toDispose.push(this.editorService.onCurrentEditorChanged(() => this.update()));
+        this.toDispose.push(this.editorService.onCurrentEditorChanged(async widget => {
+            if (widget) {
+                await this.tabsMain.waitForWidget(widget);
+            }
+            this.update();
+        }));
         this.toDispose.push(this.modelService.onModelAdded(this.onModelAdded, this));
         this.toDispose.push(this.modelService.onModelRemoved(() => this.update()));
 

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

@@ -40,7 +40,6 @@ import { DecorationsMainImpl } from './decorations/decorations-main';
 import { ClipboardMainImpl } from './clipboard-main';
 import { DocumentsMainImpl } from './documents-main';
 import { TextEditorsMainImpl } from './text-editors-main';
-import { EditorManager } from '@theia/editor/lib/browser';
 import { EditorModelService } from './text-editor-model-service';
 import { OpenerService } from '@theia/core/lib/browser/opener-service';
 import { ApplicationShell } from '@theia/core/lib/browser/shell/application-shell';
@@ -88,19 +87,21 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const preferenceRegistryMain = new PreferenceRegistryMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.PREFERENCE_REGISTRY_MAIN, preferenceRegistryMain);
 
-    const editorsAndDocuments = new EditorsAndDocumentsMain(rpc, container);
+    const tabsMain = new TabsMainImpl(rpc, container);
+    rpc.set(PLUGIN_RPC_CONTEXT.TABS_MAIN, tabsMain);
+
+    const editorsAndDocuments = new EditorsAndDocumentsMain(rpc, container, tabsMain);
 
     const notebookDocumentsMain = new NotebookDocumentsMainImpl(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOK_DOCUMENTS_MAIN, notebookDocumentsMain);
 
     const modelService = container.get(EditorModelService);
-    const editorManager = container.get(EditorManager);
     const openerService = container.get<OpenerService>(OpenerService);
     const shell = container.get(ApplicationShell);
     const untitledResourceResolver = container.get(UntitledResourceResolver);
     const languageService = container.get(MonacoLanguages);
     const documentsMain = new DocumentsMainImpl(editorsAndDocuments, notebookDocumentsMain, modelService, rpc,
-        editorManager, openerService, shell, untitledResourceResolver, languageService);
+        openerService, shell, untitledResourceResolver, languageService);
     rpc.set(PLUGIN_RPC_CONTEXT.DOCUMENTS_MAIN, documentsMain);
 
     rpc.set(PLUGIN_RPC_CONTEXT.NOTEBOOKS_MAIN, new NotebooksMainImpl(rpc, container, commandRegistryMain));
@@ -200,9 +201,6 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const commentsMain = new CommentsMainImp(rpc, container);
     rpc.set(PLUGIN_RPC_CONTEXT.COMMENTS_MAIN, commentsMain);
 
-    const tabsMain = new TabsMainImpl(rpc, container);
-    rpc.set(PLUGIN_RPC_CONTEXT.TABS_MAIN, tabsMain);
-
     const localizationMain = new LocalizationMainImpl(container);
     rpc.set(PLUGIN_RPC_CONTEXT.LOCALIZATION_MAIN, localizationMain);
 }

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/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/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;