Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2026-04-24 18:49:00 +01:00
Code Issues Packages Projects Releases Wiki Activity

Remove children on ExtHost side and refactor

Browse Source
This commit is contained in:
Pine Wu
2016-10-11 07:48:34 -07:00
parent fb032eb0f8
commit 29c03eaa58
12 changed files with 159 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/vs/workbench/api/node/extHost.api.impl.ts
View File

@@ -18,7 +18,7 @@ import { ExtHostDocuments } from 'vs/workbench/api/node/extHostDocuments';
import { ExtHostDocumentSaveParticipant } from 'vs/workbench/api/node/extHostDocumentSaveParticipant';
import { ExtHostConfiguration } from 'vs/workbench/api/node/extHostConfiguration';
import { ExtHostDiagnostics } from 'vs/workbench/api/node/extHostDiagnostics';
import { ExtHostExplorers } from 'vs/workbench/api/node/extHostExplorers';
import { ExtHostTreeExplorers } from 'vs/workbench/api/node/extHostTreeExplorers';
import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
import { ExtHostQuickOpen } from 'vs/workbench/api/node/extHostQuickOpen';
import { ExtHostHeapService } from 'vs/workbench/api/node/extHostHeapService';
@@ -66,7 +66,7 @@ export function createApiFactory(threadService: IThreadService, extensionService
const extHostDocuments = col.define(ExtHostContext.ExtHostDocuments).set<ExtHostDocuments>(new ExtHostDocuments(threadService));
const extHostDocumentSaveParticipant = col.define(ExtHostContext.ExtHostDocumentSaveParticipant).set<ExtHostDocumentSaveParticipant>(new ExtHostDocumentSaveParticipant(extHostDocuments, threadService.get(MainContext.MainThreadWorkspace)));
const extHostEditors = col.define(ExtHostContext.ExtHostEditors).set<ExtHostEditors>(new ExtHostEditors(threadService, extHostDocuments));
const extHostExplorers = col.define(ExtHostContext.ExtHostExplorers).set<ExtHostExplorers>(new ExtHostExplorers(threadService));
const extHostExplorers = col.define(ExtHostContext.ExtHostExplorers).set<ExtHostTreeExplorers>(new ExtHostTreeExplorers(threadService));
const extHostCommands = col.define(ExtHostContext.ExtHostCommands).set<ExtHostCommands>(new ExtHostCommands(threadService, extHostEditors, extHostHeapService));
const extHostConfiguration = col.define(ExtHostContext.ExtHostConfiguration).set<ExtHostConfiguration>(new ExtHostConfiguration(threadService.get(MainContext.MainThreadConfiguration)));
const extHostDiagnostics = col.define(ExtHostContext.ExtHostDiagnostics).set<ExtHostDiagnostics>(new ExtHostDiagnostics(threadService));
@@ -335,7 +335,7 @@ export function createApiFactory(threadService: IThreadService, extensionService
onWillSaveTextDocument: (listener, thisArgs?, disposables?) => {
return extHostDocumentSaveParticipant.onWillSaveTextDocumentEvent(listener, thisArgs, disposables);
},
registerTreeContentProvider(providerId: string, provider: vscode.TreeContentProvider) {
registerTreeExplorerNodeProvider(providerId: string, provider: vscode.TreeExplorerNodeProvider) {
return extHostExplorers.registerTreeContentProvider(providerId, provider);
},
onDidChangeConfiguration: (listener: () => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) => {

4
src/vs/workbench/api/node/extHost.contribution.ts
View File

@@ -20,7 +20,7 @@ import { MainThreadDiagnostics } from './mainThreadDiagnostics';
import { MainThreadDocuments } from './mainThreadDocuments';
import { MainThreadEditors } from './mainThreadEditors';
import { MainThreadErrors } from './mainThreadErrors';
import { MainThreadExplorers } from './mainThreadExplorers';
import { MainThreadTreeExplorers } from './mainThreadTreeExplorers';
import { MainThreadLanguageFeatures } from './mainThreadLanguageFeatures';
import { MainThreadLanguages } from './mainThreadLanguages';
import { MainThreadMessageService } from './mainThreadMessageService';
@@ -71,7 +71,7 @@ export class ExtHostContribution implements IWorkbenchContribution {
col.define(MainContext.MainThreadDocuments).set(create(MainThreadDocuments));
col.define(MainContext.MainThreadEditors).set(create(MainThreadEditors));
col.define(MainContext.MainThreadErrors).set(create(MainThreadErrors));
col.define(MainContext.MainThreadExplorers).set(create(MainThreadExplorers));
col.define(MainContext.MainThreadExplorers).set(create(MainThreadTreeExplorers));
col.define(MainContext.MainThreadLanguageFeatures).set(create(MainThreadLanguageFeatures));
col.define(MainContext.MainThreadLanguages).set(create(MainThreadLanguages));
col.define(MainContext.MainThreadMessageService).set(create(MainThreadMessageService));

14
src/vs/workbench/api/node/extHost.protocol.ts
View File

@@ -34,7 +34,7 @@ import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
import { IWorkspaceSymbol } from 'vs/workbench/parts/search/common/search';
import { IApplyEditsOptions, TextEditorRevealType, ITextEditorConfigurationUpdate, IResolvedTextEditorConfiguration, ISelectionChangeEvent } from './mainThreadEditorsTracker';
import { ExtHostTreeNode } from 'vs/workbench/api/node/extHostExplorers';
import { InternalTreeExplorerNode } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
export interface InstanceSetter<T> {
set<R extends T>(instance: T): R;
@@ -117,7 +117,7 @@ export abstract class MainThreadEditorsShape {
$tryApplyEdits(id: string, modelVersionId: number, edits: editorCommon.ISingleEditOperation[], opts: IApplyEditsOptions): TPromise<boolean> { throw ni(); }
}
export abstract class MainThreadExplorersShape {
export abstract class MainThreadTreeExplorersShape {
$registerTreeContentProvider(treeContentProviderId: string): void { throw ni(); }
$unregisterTreeContentProvider(treeContentProviderId: string): void { throw ni(); }
}
@@ -264,9 +264,9 @@ export abstract class ExtHostEditorsShape {
$acceptTextEditorRemove(id: string): void { throw ni(); }
}
export abstract class ExtHostExplorersShape {
$provideTreeContent(treeContentProviderId: string): TPromise<ExtHostTreeNode> { throw ni(); };
$resolveChildren(treeContentProviderId: string, node: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> { throw ni(); }
export abstract class ExtHostTreeExplorersShape {
$provideRootNode(providerId: string): TPromise<InternalTreeExplorerNode> { throw ni(); };
$resolveChildren(providerId: string, node: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode[]> { throw ni(); }
}
export abstract class ExtHostExtensionServiceShape {
@@ -343,7 +343,7 @@ export const MainContext = {
MainThreadDocuments: createMainId<MainThreadDocumentsShape>('MainThreadDocuments', MainThreadDocumentsShape),
MainThreadEditors: createMainId<MainThreadEditorsShape>('MainThreadEditors', MainThreadEditorsShape),
MainThreadErrors: createMainId<MainThreadErrorsShape>('MainThreadErrors', MainThreadErrorsShape),
MainThreadExplorers: createMainId<MainThreadExplorersShape>('MainThreadExplorers', MainThreadExplorersShape),
MainThreadExplorers: createMainId<MainThreadTreeExplorersShape>('MainThreadExplorers', MainThreadTreeExplorersShape),
MainThreadLanguageFeatures: createMainId<MainThreadLanguageFeaturesShape>('MainThreadLanguageFeatures', MainThreadLanguageFeaturesShape),
MainThreadLanguages: createMainId<MainThreadLanguagesShape>('MainThreadLanguages', MainThreadLanguagesShape),
MainThreadMessageService: createMainId<MainThreadMessageServiceShape>('MainThreadMessageService', MainThreadMessageServiceShape),
@@ -364,7 +364,7 @@ export const ExtHostContext = {
ExtHostDocuments: createExtId<ExtHostDocumentsShape>('ExtHostDocuments', ExtHostDocumentsShape),
ExtHostDocumentSaveParticipant: createExtId<ExtHostDocumentSaveParticipantShape>('ExtHostDocumentSaveParticipant', ExtHostDocumentSaveParticipantShape),
ExtHostEditors: createExtId<ExtHostEditorsShape>('ExtHostEditors', ExtHostEditorsShape),
ExtHostExplorers: createExtId<ExtHostExplorersShape>('ExtHostExplorers',ExtHostExplorersShape),
ExtHostExplorers: createExtId<ExtHostTreeExplorersShape>('ExtHostExplorers',ExtHostTreeExplorersShape),
ExtHostFileSystemEventService: createExtId<ExtHostFileSystemEventServiceShape>('ExtHostFileSystemEventService', ExtHostFileSystemEventServiceShape),
ExtHostHeapService: createExtId<ExtHostHeapServiceShape>('ExtHostHeapMonitor', ExtHostHeapServiceShape),
ExtHostLanguageFeatures: createExtId<ExtHostLanguageFeaturesShape>('ExtHostLanguageFeatures', ExtHostLanguageFeaturesShape),

95
src/vs/workbench/api/node/extHostExplorers.ts
View File

@@ -1,95 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { TreeContentNode, TreeContentProvider } from 'vscode';
import {TPromise} from 'vs/base/common/winjs.base';
import {Disposable} from 'vs/workbench/api/node/extHostTypes';
import {IThreadService} from 'vs/workbench/services/thread/common/threadService';
import {MainContext, ExtHostExplorersShape, MainThreadExplorersShape} from './extHost.protocol';
export class ExtHostExplorers extends ExtHostExplorersShape {
private _proxy: MainThreadExplorersShape;
private _treeContentProviders: { [treeContentProviderId: string]: TreeContentProvider };
private _treeContents: { [treeContentProviderId: string]: ExtHostTreeNode };
private _treeNodeMaps: { [treeContentProviderId: string]: { [id: number]: ExtHostTreeNode }};
constructor(
threadService: IThreadService
) {
super();
this._proxy = threadService.get(MainContext.MainThreadExplorers);
this._treeContentProviders = Object.create(null);
this._treeContents = Object.create(null);
this._treeNodeMaps = Object.create(null);
}
registerTreeContentProvider(providerId: string, provider: TreeContentProvider): Disposable {
this._proxy.$registerTreeContentProvider(providerId);
this._treeContentProviders[providerId] = provider;
return new Disposable(() => {
if (delete this._treeContentProviders[providerId]) {
this._proxy.$unregisterTreeContentProvider(providerId);
}
});
}
$provideTreeContent(treeContentProviderId: string): TPromise<ExtHostTreeNode> {
const provider = this._treeContentProviders[treeContentProviderId];
if (!provider) {
throw new Error(`no TreeContentProvider registered with id '${treeContentProviderId}'`);
}
return TPromise.wrap(provider.provideTreeContent().then(treeContent => {
const treeNodeMap = Object.create(null);
this._treeNodeMaps[treeContentProviderId] = treeNodeMap;
this._treeContents[treeContentProviderId] = new ExtHostTreeNode(treeContent, null, treeNodeMap);
return this._treeContents[treeContentProviderId];
}));
}
$resolveChildren(treeContentProviderId: string, mainThreadNode: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> {
const provider = this._treeContentProviders[treeContentProviderId];
if (!provider) {
throw new Error(`no TreeContentProvider registered with id '${treeContentProviderId}'`);
}
const treeNodeMap = this._treeNodeMaps[treeContentProviderId];
const extHostNode = treeNodeMap[mainThreadNode.id];
return TPromise.wrap(provider.resolveChildren(extHostNode).then(children => {
extHostNode.children = children.map(child => {
return new ExtHostTreeNode(child, extHostNode, treeNodeMap);
});
return extHostNode.children;
}));
}
}
export class ExtHostTreeNode implements TreeContentNode {
static idCounter = 1;
id: number;
label: string;
shouldInitiallyExpand: boolean;
children: ExtHostTreeNode[];
constructor(node: TreeContentNode, parent: ExtHostTreeNode, treeNodeMap: { [id: number]: ExtHostTreeNode}) {
this.id = ExtHostTreeNode.idCounter++;
this.label = node.label;
this.shouldInitiallyExpand = node.shouldInitiallyExpand;
this.children = node.children.map(child => {
return new ExtHostTreeNode(child, this, treeNodeMap);
})
treeNodeMap[this.id] = this;
}
}

79
src/vs/workbench/api/node/extHostTreeExplorers.ts Normal file
View File

@@ -0,0 +1,79 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { TreeExplorerNode, TreeExplorerNodeProvider } from 'vscode';
import { TPromise } from 'vs/base/common/winjs.base';
import { Disposable } from 'vs/workbench/api/node/extHostTypes';
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import { MainContext, ExtHostTreeExplorersShape, MainThreadTreeExplorersShape } from './extHost.protocol';
import { InternalTreeExplorerNode } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
private _proxy: MainThreadTreeExplorersShape;
private _treeExplorerNodeProviders: { [providerId: string]: TreeExplorerNodeProvider };
private _trees: { [providerId: string]: InternalTreeExplorerNode };
private _treeNodeMaps: { [providerId: string]: { [id: number]: InternalTreeExplorerNode }};
constructor(
threadService: IThreadService
) {
super();
this._proxy = threadService.get(MainContext.MainThreadExplorers);
this._treeExplorerNodeProviders = Object.create(null);
this._trees = Object.create(null);
this._treeNodeMaps = Object.create(null);
}
registerTreeContentProvider(providerId: string, provider: TreeExplorerNodeProvider): Disposable {
this._proxy.$registerTreeContentProvider(providerId);
this._treeExplorerNodeProviders[providerId] = provider;
return new Disposable(() => {
if (delete this._treeExplorerNodeProviders[providerId]) {
this._proxy.$unregisterTreeContentProvider(providerId);
}
});
}
$provideRootNode(providerId: string): TPromise<InternalTreeExplorerNode> {
const provider = this._treeExplorerNodeProviders[providerId];
if (!provider) {
throw new Error(`no TreeContentProvider registered with id '${providerId}'`);
}
return TPromise.wrap(provider.provideRootNode().then(rootNode => {
const treeNodeMap = Object.create(null);
this._treeNodeMaps[providerId] = treeNodeMap;
const internalRootNode = new InternalTreeExplorerNode(rootNode);
this._trees[providerId] = internalRootNode;
this._treeNodeMaps[providerId][internalRootNode.id] = internalRootNode;
return this._trees[providerId];
}));
}
$resolveChildren(providerId: string, mainThreadNode: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode[]> {
const provider = this._treeExplorerNodeProviders[providerId];
if (!provider) {
throw new Error(`no TreeContentProvider registered with id '${providerId}'`);
}
const treeNodeMap = this._treeNodeMaps[providerId];
const extHostTreeContentNode = treeNodeMap[mainThreadNode.id];
return TPromise.wrap(provider.resolveChildren(extHostTreeContentNode).then(children => {
return children.map(child => {
const internalChild = new InternalTreeExplorerNode(child);
treeNodeMap[internalChild.id] = internalChild;
return internalChild;
});
}));
}
}

26
src/vs/workbench/api/node/mainThreadExplorers.ts → src/vs/workbench/api/node/mainThreadTreeExplorers.ts
View File

@@ -4,19 +4,17 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import {TreeContentNode} from 'vscode';
import {TPromise} from 'vs/base/common/winjs.base';
import {IThreadService} from 'vs/workbench/services/thread/common/threadService';
import {ExtHostContext, MainThreadExplorersShape, ExtHostExplorersShape} from './extHost.protocol';
import {ITreeExplorerViewletService} from 'vs/workbench/parts/explorers/browser/treeExplorerViewletService';
import {TreeViewNode} from 'vs/workbench/parts/explorers/common/treeViewModel';
import { TreeExplorerNode } from 'vscode';
import { TPromise } from 'vs/base/common/winjs.base';
import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
import { ExtHostContext, MainThreadTreeExplorersShape, ExtHostTreeExplorersShape } from './extHost.protocol';
import { ITreeExplorerViewletService } from 'vs/workbench/parts/explorers/browser/treeExplorerViewletService';
import { InternalTreeExplorerNode } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
import { ExtHostTreeNode } from 'vs/workbench/api/node/extHostExplorers';
export class MainThreadTreeExplorers extends MainThreadTreeExplorersShape {
private _proxy: ExtHostTreeExplorersShape;
export class MainThreadExplorers extends MainThreadExplorersShape {
private _proxy: ExtHostExplorersShape;
private _treeContents: { [treeContentProviderId: string]: ExtHostTreeNode };
private _treeContents: { [treeContentProviderId: string]: InternalTreeExplorerNode };
constructor(
@IThreadService threadService: IThreadService,
@@ -30,13 +28,13 @@ export class MainThreadExplorers extends MainThreadExplorersShape {
$registerTreeContentProvider(providerId: string): void {
this.treeExplorerViewletService.registerTreeContentProvider(providerId, {
provideTreeContent: (): TPromise<ExtHostTreeNode> => {
return this._proxy.$provideTreeContent(providerId).then(treeContent => {
provideRootNode: (): TPromise<InternalTreeExplorerNode> => {
return this._proxy.$provideRootNode(providerId).then(treeContent => {
this._treeContents[providerId] = treeContent;
return treeContent;
})
},
resolveChildren: (node: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> => {
resolveChildren: (node: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode[]> => {
return this._proxy.$resolveChildren(providerId, node);
}
});