Enahance tree api

- API to create a view passing the data provider
- Have methods on created API to refresh

src/vs/vscode.proposed.d.ts

@@ -538,30 +538,43 @@ declare module 'vscode' {
 	export namespace window {
 
 		/**
-		 * Register a [TreeExplorerNodeProvider](#TreeExplorerNodeProvider).
+		 * Create a new [TreeView](#TreeView) instance.
 		 *
-		 * @param providerId A unique id that identifies the provider.
-		 * @param provider A [TreeExplorerNodeProvider](#TreeExplorerNodeProvider).
-		 * @return A [disposable](#Disposable) that unregisters this provider when being disposed.
+		 * @param viewId A unique id that identifies the view.
+		 * @param provider A [TreeDataProvider](#TreeDataProvider).
+		 * @return An instance of [TreeView](#TreeView).
 		 */
-		export function registerTreeExplorerNodeProvider(providerId: string, provider: TreeExplorerNodeProvider<any>): Disposable;
+		export function createTreeView<T>(viewId: string, provider: TreeDataProvider<T>): TreeView<T>;
 	}
 
 	/**
-	 * A node provider for a tree explorer contribution.
-	 *
-	 * Providers are registered through (#window.registerTreeExplorerNodeProvider) with a
-	 * `providerId` that corresponds to the `treeExplorerNodeProviderId` in the extension's
-	 * `contributes.explorer` section.
+	 * An source control is able to provide [resource states](#SourceControlResourceState)
+	 * to the editor and interact with the editor in several source control related ways.
+	 */
+	export interface TreeView<T> {
+
+		/**
+		 * Refresh the given nodes
+		 */
+		refresh(...nodes: T[]): void;
+
+		/**
+		 * Dispose this view
+		 */
+		dispose(): void;
+	}
+
+	/**
+	 * A data provider for a tree view contribution.
 	 *
-	 * The contributed tree explorer will ask the corresponding provider to provide the root
+	 * The contributed tree view will ask the corresponding provider to provide the root
 	 * node and resolve children for each node. In addition, the provider could **optionally**
 	 * provide the following information for each node:
 	 * - label: A human-readable label used for rendering the node.
 	 * - hasChildren: Whether the node has children and is expandable.
 	 * - clickCommand: A command to execute when the node is clicked.
 	 */
-	export interface TreeExplorerNodeProvider<T> {
+	export interface TreeDataProvider<T> {
 
 		/**
 		 * Provide the root node. This function will be called when the tree explorer is activated
@@ -607,11 +620,6 @@ declare module 'vscode' {
 		 * @return The command to execute when `node` is clicked.
 		 */
 		getClickCommand?(node: T): Command;
-
-		/**
-		 * Event to be listened for any changes
-		 */
-		onChange?: Event<T>;
 	}
 
 	/**

src/vs/workbench/api/node/extHost.api.impl.ts

@@ -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 { ExtHostTreeExplorers } from 'vs/workbench/api/node/extHostTreeExplorers';
+import { ExtHostTreeView } from 'vs/workbench/api/node/extHostTreeView';
 import { ExtHostWorkspace } from 'vs/workbench/api/node/extHostWorkspace';
 import { ExtHostQuickOpen } from 'vs/workbench/api/node/extHostQuickOpen';
 import { ExtHostProgress } from 'vs/workbench/api/node/extHostProgress';
@@ -111,7 +111,7 @@ export function createApiFactory(
 	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, extHostDocumentsAndEditors));
 	const extHostCommands = col.define(ExtHostContext.ExtHostCommands).set<ExtHostCommands>(new ExtHostCommands(threadService, extHostHeapService));
-	const extHostExplorers = col.define(ExtHostContext.ExtHostExplorers).set<ExtHostTreeExplorers>(new ExtHostTreeExplorers(threadService, extHostCommands));
+	const extHostTreeView = col.define(ExtHostContext.ExtHostTreeView).set<ExtHostTreeView>(new ExtHostTreeView(threadService, extHostCommands));
 	const extHostConfiguration = col.define(ExtHostContext.ExtHostConfiguration).set<ExtHostConfiguration>(new ExtHostConfiguration(threadService.get(MainContext.MainThreadConfiguration), initData.configuration));
 	const extHostDiagnostics = col.define(ExtHostContext.ExtHostDiagnostics).set<ExtHostDiagnostics>(new ExtHostDiagnostics(threadService));
 	const languageFeatures = col.define(ExtHostContext.ExtHostLanguageFeatures).set<ExtHostLanguageFeatures>(new ExtHostLanguageFeatures(threadService, extHostDocuments, extHostCommands, extHostHeapService, extHostDiagnostics));
@@ -363,8 +363,8 @@ export function createApiFactory(
 			sampleFunction: proposedApiFunction(extension, () => {
 				return extHostMessageService.showMessage(Severity.Info, 'Hello Proposed Api!', {}, []);
 			}),
-			registerTreeExplorerNodeProvider: proposedApiFunction(extension, (providerId: string, provider: vscode.TreeExplorerNodeProvider<any>) => {
-				return extHostExplorers.registerTreeExplorerNodeProvider(providerId, provider);
+			createTreeView: proposedApiFunction(extension, (providerId: string, provider: vscode.TreeDataProvider<any>): vscode.TreeView<any> => {
+				return extHostTreeView.createTreeView(providerId, provider);
 			})
 		};
 

src/vs/workbench/api/node/extHost.contribution.ts

@@ -19,7 +19,7 @@ import { MainThreadDiagnostics } from './mainThreadDiagnostics';
 import { MainThreadDocuments } from './mainThreadDocuments';
 import { MainThreadEditors } from './mainThreadEditors';
 import { MainThreadErrors } from './mainThreadErrors';
-import { MainThreadTreeExplorers } from './mainThreadTreeExplorers';
+import { MainThreadTreeView } from './mainThreadTreeView';
 import { MainThreadLanguageFeatures } from './mainThreadLanguageFeatures';
 import { MainThreadLanguages } from './mainThreadLanguages';
 import { MainThreadMessageService } from './mainThreadMessageService';
@@ -74,7 +74,7 @@ export class ExtHostContribution implements IWorkbenchContribution {
 		col.define(MainContext.MainThreadDocuments).set(this.instantiationService.createInstance(MainThreadDocuments, documentsAndEditors));
 		col.define(MainContext.MainThreadEditors).set(this.instantiationService.createInstance(MainThreadEditors, documentsAndEditors));
 		col.define(MainContext.MainThreadErrors).set(create(MainThreadErrors));
-		col.define(MainContext.MainThreadExplorers).set(create(MainThreadTreeExplorers));
+		col.define(MainContext.MainThreadExplorers).set(create(MainThreadTreeView));
 		col.define(MainContext.MainThreadLanguageFeatures).set(create(MainThreadLanguageFeatures));
 		col.define(MainContext.MainThreadLanguages).set(create(MainThreadLanguages));
 		col.define(MainContext.MainThreadMessageService).set(create(MainThreadMessageService));

src/vs/workbench/api/node/extHost.protocol.ts

@@ -36,7 +36,7 @@ import { IPickOpenEntry, IPickOptions } from 'vs/platform/quickOpen/common/quick
 import { SaveReason } from 'vs/workbench/services/textfile/common/textfiles';
 import { IApplyEditsOptions, IUndoStopOptions, TextEditorRevealType, ITextEditorConfigurationUpdate, IResolvedTextEditorConfiguration, ISelectionChangeEvent } from './mainThreadEditor';
 
-import { InternalTreeExplorerNodeContent } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
+import { InternalTreeNodeContent } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
 import { TaskSet } from 'vs/workbench/parts/tasks/common/tasks';
 import { IModelChangedEvent } from 'vs/editor/common/model/mirrorModel';
 import { IPosition } from "vs/editor/common/core/position";
@@ -147,14 +147,14 @@ export abstract class MainThreadEditorsShape {
 	$getDiffInformation(id: string): TPromise<editorCommon.ILineChange[]> { throw ni(); }
 }
 
-export abstract class MainThreadTreeExplorersShape {
-	$registerTreeExplorerNodeProvider(providerId: string): void { throw ni(); }
-	$refresh(providerId: string, node: InternalTreeExplorerNodeContent): void { throw ni(); }
+export abstract class MainThreadTreeViewShape {
+	$registerTreeDataProvider(providerId: string): void { throw ni(); }
+	$refresh(providerId: string, node: InternalTreeNodeContent): void { throw ni(); }
 }
 
 export abstract class MainThreadTreeShape {
-	$registerTreeExplorerNodeProvider(providerId: string, node: InternalTreeExplorerNodeContent): void { throw ni(); }
-	$refresh(providerId: string, node: InternalTreeExplorerNodeContent): void { throw ni(); }
+	$registerTreeExplorerNodeProvider(providerId: string, node: InternalTreeNodeContent): void { throw ni(); }
+	$refresh(providerId: string, node: InternalTreeNodeContent): void { throw ni(); }
 }
 
 export abstract class MainThreadErrorsShape {
@@ -358,15 +358,15 @@ export abstract class ExtHostDocumentsAndEditorsShape {
 }
 
 
-export abstract class ExtHostTreeExplorersShape {
-	$provideRootNode(providerId: string): TPromise<InternalTreeExplorerNodeContent> { throw ni(); };
-	$resolveChildren(providerId: string, node: InternalTreeExplorerNodeContent): TPromise<InternalTreeExplorerNodeContent[]> { throw ni(); }
-	$getInternalCommand(providerId: string, node: InternalTreeExplorerNodeContent): TPromise<modes.Command> { throw ni(); }
+export abstract class ExtHostTreeViewShape {
+	$provideRootNode(providerId: string): TPromise<InternalTreeNodeContent> { throw ni(); };
+	$resolveChildren(providerId: string, node: InternalTreeNodeContent): TPromise<InternalTreeNodeContent[]> { throw ni(); }
+	$getInternalCommand(providerId: string, node: InternalTreeNodeContent): TPromise<modes.Command> { throw ni(); }
 }
 
 export abstract class ExtHostTreeShape {
-	$resolveChildren(providerId: string, node: InternalTreeExplorerNodeContent): TPromise<InternalTreeExplorerNodeContent[]> { throw ni(); }
-	$getInternalCommand(providerId: string, node: InternalTreeExplorerNodeContent): TPromise<modes.Command> { throw ni(); }
+	$resolveChildren(providerId: string, node: InternalTreeNodeContent): TPromise<InternalTreeNodeContent[]> { throw ni(); }
+	$getInternalCommand(providerId: string, node: InternalTreeNodeContent): TPromise<modes.Command> { throw ni(); }
 }
 
 export abstract class ExtHostExtensionServiceShape {
@@ -457,7 +457,7 @@ export const MainContext = {
 	MainThreadDocuments: createMainId<MainThreadDocumentsShape>('MainThreadDocuments', MainThreadDocumentsShape),
 	MainThreadEditors: createMainId<MainThreadEditorsShape>('MainThreadEditors', MainThreadEditorsShape),
 	MainThreadErrors: createMainId<MainThreadErrorsShape>('MainThreadErrors', MainThreadErrorsShape),
-	MainThreadExplorers: createMainId<MainThreadTreeExplorersShape>('MainThreadExplorers', MainThreadTreeExplorersShape),
+	MainThreadExplorers: createMainId<MainThreadTreeViewShape>('MainThreadTreeView', MainThreadTreeViewShape),
 	MainThreadLanguageFeatures: createMainId<MainThreadLanguageFeaturesShape>('MainThreadLanguageFeatures', MainThreadLanguageFeaturesShape),
 	MainThreadLanguages: createMainId<MainThreadLanguagesShape>('MainThreadLanguages', MainThreadLanguagesShape),
 	MainThreadMessageService: createMainId<MainThreadMessageServiceShape>('MainThreadMessageService', MainThreadMessageServiceShape),
@@ -482,7 +482,7 @@ export const ExtHostContext = {
 	ExtHostDocuments: createExtId<ExtHostDocumentsShape>('ExtHostDocuments', ExtHostDocumentsShape),
 	ExtHostDocumentSaveParticipant: createExtId<ExtHostDocumentSaveParticipantShape>('ExtHostDocumentSaveParticipant', ExtHostDocumentSaveParticipantShape),
 	ExtHostEditors: createExtId<ExtHostEditorsShape>('ExtHostEditors', ExtHostEditorsShape),
-	ExtHostExplorers: createExtId<ExtHostTreeExplorersShape>('ExtHostExplorers', ExtHostTreeExplorersShape),
+	ExtHostTreeView: createExtId<ExtHostTreeViewShape>('ExtHostTreeView', ExtHostTreeViewShape),
 	ExtHostFileSystemEventService: createExtId<ExtHostFileSystemEventServiceShape>('ExtHostFileSystemEventService', ExtHostFileSystemEventServiceShape),
 	ExtHostHeapService: createExtId<ExtHostHeapServiceShape>('ExtHostHeapMonitor', ExtHostHeapServiceShape),
 	ExtHostLanguageFeatures: createExtId<ExtHostLanguageFeaturesShape>('ExtHostLanguageFeatures', ExtHostLanguageFeaturesShape),

src/vs/workbench/api/node/extHostTree.ts

-/*---------------------------------------------------------------------------------------------
- *  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 { TreeNode } from 'vscode';
-import { TPromise } from 'vs/base/common/winjs.base';
-import { Disposable } from 'vs/workbench/api/node/extHostTypes';
-import { defaultGenerator } from 'vs/base/common/idGenerator';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { MainContext, ExtHostTreeShape, MainThreadTreeShape } from './extHost.protocol';
-import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
-import { asWinJsPromise } from 'vs/base/common/async';
-import { localize } from 'vs/nls';
-import { InternalTreeExplorerNode } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
-import * as modes from 'vs/editor/common/modes';
-
-class InternalTreeExplorerNodeImpl implements InternalTreeExplorerNode {
-
-	readonly id: string;
-	label: string;
-	hasChildren: boolean;
-	clickCommand: string;
-
-	constructor(node: TreeNode) {
-		this.id = defaultGenerator.nextId();
-		this.label = node.label;
-		this.hasChildren = !!node.getChildren;
-		this.clickCommand = node.command ? node.command.command : null;
-	}
-}
-
-export class ExtHostTree extends ExtHostTreeShape {
-
-	private _proxy: MainThreadTreeShape;
-
-	private _providers: Map<string, Map<string, TreeNode>> = new Map<string, Map<string, TreeNode>>();
-	private _disposables: Map<string, Disposable[]> = new Map<string, Disposable[]>();
-	private _nodeDisposables: Map<string, Disposable[]> = new Map<string, Disposable[]>();
-
-	constructor(
-		threadService: IThreadService,
-		private commands: ExtHostCommands
-	) {
-		super();
-		this._proxy = threadService.get(MainContext.MainThreadTree);
-	}
-
-	registerTree(providerId: string, root: TreeNode): Disposable {
-		this._providers.set(providerId, new Map<string, TreeNode>());
-		this._disposables.set(providerId, []);
-
-		const internalNode = new InternalTreeExplorerNodeImpl(root);
-		this._providers.get(providerId).set(internalNode.id, root);
-
-		const disposable = root.onChange(() => {
-			this._proxy.$refresh(providerId, internalNode);
-		});
-		this._disposables.get(providerId).push(new Disposable(() => disposable.dispose()));
-
-		this._proxy.$registerTreeExplorerNodeProvider(providerId, internalNode);
-
-		return new Disposable(() => {
-			this._providers.delete(providerId);
-			const disposables = this._disposables.get(providerId);
-			if (disposables) {
-				for (const disposable of disposables) {
-					disposable.dispose();
-				}
-			}
-			this._disposables.delete(providerId);
-		});
-	}
-
-	$resolveChildren(providerId: string, mainThreadNode: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode[]> {
-		const provider = this._providers.get(providerId);
-		if (!provider) {
-			const errMessage = localize('treeExplorer.notRegistered', 'No TreeExplorerNodeProvider with id \'{0}\' registered.', providerId);
-			return TPromise.wrapError(errMessage);
-		}
-
-		const extNode = provider.get(mainThreadNode.id);
-		const disposables = this._nodeDisposables.get(mainThreadNode.id);
-		if (disposables) {
-			for (const disposable of disposables) {
-				disposable.dispose();
-			}
-		}
-		this._nodeDisposables.set(mainThreadNode.id, []);
-		return asWinJsPromise(() => extNode.getChildren()).then(children => {
-			return children.map(extChild => {
-				const internalChild = new InternalTreeExplorerNodeImpl(extChild);
-				provider.set(internalChild.id, extChild);
-				if (extChild.onChange) {
-					const disposable = extChild.onChange(() => this._proxy.$refresh(providerId, internalChild));
-					this._disposables.get(providerId).push(new Disposable(() => disposable.dispose()));
-					this._nodeDisposables.get(mainThreadNode.id).push(new Disposable(() => disposable.dispose()));
-				}
-				return internalChild;
-			});
-		}, err => {
-			const errMessage = localize('treeExplorer.failedToResolveChildren', 'TreeExplorerNodeProvider \'{0}\' failed to resolveChildren.', providerId);
-			return TPromise.wrapError(errMessage);
-		});
-	}
-
-	// Convert the command on the ExtHost side so we can pass the original externalNode to the registered handler
-	$getInternalCommand(providerId: string, mainThreadNode: InternalTreeExplorerNode): TPromise<modes.Command> {
-		const commandConverter = this.commands.converter;
-
-		if (mainThreadNode.clickCommand) {
-			const extNode = this._providers.get(providerId).get(mainThreadNode.id);
-
-			const internalCommand = commandConverter.toInternal({
-				title: '',
-				command: mainThreadNode.clickCommand,
-				arguments: [extNode]
-			});
-
-			return TPromise.wrap(internalCommand);
-		}
-
-		return TPromise.as(null);
-	}
-
-}*/
\ No newline at end of file

src/vs/workbench/api/node/extHostTreeExplorers.ts → src/vs/workbench/api/node/extHostTreeView.ts

@@ -5,25 +5,24 @@
 'use strict';
 
 import { localize } from 'vs/nls';
-import { TreeExplorerNodeProvider } from 'vscode';
+import { TreeView, TreeDataProvider } from 'vscode';
 import { defaultGenerator } from 'vs/base/common/idGenerator';
 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';
+import { MainContext, ExtHostTreeViewShape, MainThreadTreeViewShape } from './extHost.protocol';
+import { InternalTreeNode } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
 import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
 import { asWinJsPromise } from 'vs/base/common/async';
 import * as modes from 'vs/editor/common/modes';
 
-class InternalTreeExplorerNodeImpl implements InternalTreeExplorerNode {
+class InternalTreeNodeImpl implements InternalTreeNode {
 
 	readonly id: string;
 	label: string;
 	hasChildren: boolean;
 	clickCommand: string = null;
 
-	constructor(node: any, provider: TreeExplorerNodeProvider<any>) {
+	constructor(node: any, provider: TreeDataProvider<any>) {
 		this.id = defaultGenerator.nextId();
 		this.label = provider.getLabel ? provider.getLabel(node) : node.toString();
 		this.hasChildren = provider.getHasChildren ? provider.getHasChildren(node) : true;
@@ -36,12 +35,13 @@ class InternalTreeExplorerNodeImpl implements InternalTreeExplorerNode {
 	}
 }
 
-export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
-	private _proxy: MainThreadTreeExplorersShape;
+export class ExtHostTreeView extends ExtHostTreeViewShape {
+	private _proxy: MainThreadTreeViewShape;
 
-	private _extNodeProviders: { [providerId: string]: TreeExplorerNodeProvider<any> };
-	private _extNodeMaps: { [providerId: string]: { [id: string]: InternalTreeExplorerNode } };
-	private _mainNodesMap: Map<string, Map<any, InternalTreeExplorerNode>>;
+	private _extNodeProviders: { [providerId: string]: TreeDataProvider<any> };
+	private _extViews: Map<string, TreeView<any>> = new Map<string, TreeView<any>>();
+	private _extNodeMaps: { [providerId: string]: { [id: string]: InternalTreeNode } };
+	private _mainNodesMap: Map<string, Map<any, InternalTreeNode>>;
 	private _childrenNodesMap: Map<string, Map<any, any[]>>;
 
 	constructor(
@@ -54,36 +54,34 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 
 		this._extNodeProviders = Object.create(null);
 		this._extNodeMaps = Object.create(null);
-		this._mainNodesMap = new Map<string, Map<any, InternalTreeExplorerNode>>();
+		this._mainNodesMap = new Map<string, Map<any, InternalTreeNode>>();
 		this._childrenNodesMap = new Map<string, Map<any, any[]>>();
 	}
 
-	registerTreeExplorerNodeProvider(providerId: string, provider: TreeExplorerNodeProvider<any>): Disposable {
-		this._proxy.$registerTreeExplorerNodeProvider(providerId);
+	createTreeView<T>(providerId: string, provider: TreeDataProvider<T>): TreeView<T> {
+		this._proxy.$registerTreeDataProvider(providerId);
 		this._extNodeProviders[providerId] = provider;
-		this._mainNodesMap.set(providerId, new Map<any, InternalTreeExplorerNode>());
+		this._mainNodesMap.set(providerId, new Map<any, InternalTreeNode>());
 		this._childrenNodesMap.set(providerId, new Map<any, any>());
 
-		let disposable = null;
-		if (provider.onChange) {
-			disposable = provider.onChange(node => {
+		const treeView: TreeView<T> = {
+			refresh: (node: T) => {
 				const mainThreadNode = this._mainNodesMap.get(providerId).get(node);
 				this._proxy.$refresh(providerId, mainThreadNode);
-			});
-		}
-
-		return new Disposable(() => {
-			delete this._extNodeProviders[providerId];
-			delete this._extNodeProviders[providerId];
-			this._mainNodesMap.delete(providerId);
-			this._childrenNodesMap.delete(providerId);
-			if (disposable) {
-				disposable.dispose();
+			},
+			dispose: () => {
+				delete this._extNodeProviders[providerId];
+				delete this._extNodeProviders[providerId];
+				this._mainNodesMap.delete(providerId);
+				this._childrenNodesMap.delete(providerId);
+				this._extViews.delete(providerId);
 			}
-		});
+		};
+		this._extViews.set(providerId, treeView);
+		return treeView;
 	}
 
-	$provideRootNode(providerId: string): TPromise<InternalTreeExplorerNode> {
+	$provideRootNode(providerId: string): TPromise<InternalTreeNode> {
 		const provider = this._extNodeProviders[providerId];
 		if (!provider) {
 			const errMessage = localize('treeExplorer.notRegistered', 'No TreeExplorerNodeProvider with id \'{0}\' registered.', providerId);
@@ -91,8 +89,8 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 		}
 
 		return asWinJsPromise(() => provider.provideRootNode()).then(extRootNode => {
-			const extNodeMap: { [id: string]: InternalTreeExplorerNode } = Object.create(null);
-			const internalRootNode = new InternalTreeExplorerNodeImpl(extRootNode, provider);
+			const extNodeMap: { [id: string]: InternalTreeNode } = Object.create(null);
+			const internalRootNode = new InternalTreeNodeImpl(extRootNode, provider);
 
 			extNodeMap[internalRootNode.id] = extRootNode;
 			this._extNodeMaps[providerId] = extNodeMap;
@@ -106,7 +104,7 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 		});
 	}
 
-	$resolveChildren(providerId: string, mainThreadNode: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode[]> {
+	$resolveChildren(providerId: string, mainThreadNode: InternalTreeNode): TPromise<InternalTreeNode[]> {
 		const provider = this._extNodeProviders[providerId];
 		if (!provider) {
 			const errMessage = localize('treeExplorer.notRegistered', 'No TreeExplorerNodeProvider with id \'{0}\' registered.', providerId);
@@ -125,7 +123,7 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 
 		return asWinJsPromise(() => provider.resolveChildren(extNode)).then(children => {
 			return children.map(extChild => {
-				const internalChild = new InternalTreeExplorerNodeImpl(extChild, provider);
+				const internalChild = new InternalTreeNodeImpl(extChild, provider);
 				extNodeMap[internalChild.id] = extChild;
 				this._mainNodesMap.get(providerId).set(extChild, internalChild);
 				return internalChild;
@@ -134,7 +132,7 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 	}
 
 	// Convert the command on the ExtHost side so we can pass the original externalNode to the registered handler
-	$getInternalCommand(providerId: string, mainThreadNode: InternalTreeExplorerNode): TPromise<modes.Command> {
+	$getInternalCommand(providerId: string, mainThreadNode: InternalTreeNode): TPromise<modes.Command> {
 		const commandConverter = this.commands.converter;
 
 		if (mainThreadNode.clickCommand) {
@@ -151,4 +149,4 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 
 		return TPromise.as(null);
 	}
-}
+}
\ No newline at end of file

src/vs/workbench/api/node/mainThreadTree.ts

-/*---------------------------------------------------------------------------------------------
- *  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 { TPromise } from 'vs/base/common/winjs.base';
-import Event, { Emitter } from 'vs/base/common/event';
-import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { ExtHostContext, MainThreadTreeShape, ExtHostTreeShape } from './extHost.protocol';
-import { ITreeExplorerService } from 'vs/workbench/parts/explorers/common/treeExplorerService';
-import { InternalTreeExplorerNodeContent, InternalTreeExplorerNodeProvider } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
-import { IMessageService, Severity } from 'vs/platform/message/common/message';
-import { ICommandService } from 'vs/platform/commands/common/commands';
-
-export class MainThreadTree extends MainThreadTreeShape {
-	private _proxy: ExtHostTreeShape;
-
-	constructor(
-		@IThreadService threadService: IThreadService,
-		@ITreeExplorerService private treeExplorerService: ITreeExplorerService,
-		@IMessageService private messageService: IMessageService,
-		@ICommandService private commandService: ICommandService
-	) {
-		super();
-
-		this._proxy = threadService.get(ExtHostContext.ExtHostTree);
-	}
-
-	$registerTreeExplorerNodeProvider(providerId: string, rootNode: InternalTreeExplorerNodeContent): void {
-		const provider = new TreeExplorerNodeProvider(providerId, rootNode, this._proxy, this.messageService, this.commandService);
-		this.treeExplorerService.registerTreeExplorerNodeProvider(providerId, provider);
-	}
-
-	$refresh(providerId: string, node: InternalTreeExplorerNodeContent): void {
-		(<TreeExplorerNodeProvider>this.treeExplorerService.getProvider(providerId))._onRefresh.fire(node);
-	}
-}
-
-class TreeExplorerNodeProvider implements InternalTreeExplorerNodeProvider {
-
-	readonly _onRefresh: Emitter<InternalTreeExplorerNodeContent> = new Emitter<InternalTreeExplorerNodeContent>();
-	readonly onRefresh: Event<InternalTreeExplorerNodeContent> = this._onRefresh.event;
-
-	constructor(public readonly id: string, private rootNode: InternalTreeExplorerNodeContent, private _proxy: ExtHostTreeShape,
-		private messageService: IMessageService,
-		private commandService: ICommandService
-	) {
-	}
-
-	provideRootNode(): TPromise<InternalTreeExplorerNodeContent> {
-		return TPromise.as(this.rootNode);
-	}
-
-	resolveChildren(node: InternalTreeExplorerNodeContent): TPromise<InternalTreeExplorerNodeContent[]> {
-		return this._proxy.$resolveChildren(this.id, node).then(children => children, err => this.messageService.show(Severity.Error, err));
-	}
-
-	executeCommand(node: InternalTreeExplorerNodeContent): TPromise<any> {
-		return this._proxy.$getInternalCommand(this.id, node).then(command => {
-			return this.commandService.executeCommand(command.id, ...command.arguments);
-		});
-	}
-}
-*/
\ No newline at end of file

src/vs/workbench/api/node/mainThreadTreeExplorers.ts → src/vs/workbench/api/node/mainThreadTreeView.ts

@@ -7,14 +7,14 @@
 import { TPromise } from 'vs/base/common/winjs.base';
 import Event, { Emitter } from 'vs/base/common/event';
 import { IThreadService } from 'vs/workbench/services/thread/common/threadService';
-import { ExtHostContext, MainThreadTreeExplorersShape, ExtHostTreeExplorersShape } from './extHost.protocol';
+import { ExtHostContext, MainThreadTreeViewShape, ExtHostTreeViewShape } from './extHost.protocol';
 import { ITreeExplorerService } from 'vs/workbench/parts/explorers/common/treeExplorerService';
-import { InternalTreeExplorerNodeContent, InternalTreeExplorerNodeProvider } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
+import { InternalTreeNodeContent, InternalTreeNodeProvider } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
 import { IMessageService, Severity } from 'vs/platform/message/common/message';
 import { ICommandService } from 'vs/platform/commands/common/commands';
 
-export class MainThreadTreeExplorers extends MainThreadTreeExplorersShape {
-	private _proxy: ExtHostTreeExplorersShape;
+export class MainThreadTreeView extends MainThreadTreeViewShape {
+	private _proxy: ExtHostTreeViewShape;
 
 	constructor(
 		@IThreadService threadService: IThreadService,
@@ -24,39 +24,39 @@ export class MainThreadTreeExplorers extends MainThreadTreeExplorersShape {
 	) {
 		super();
 
-		this._proxy = threadService.get(ExtHostContext.ExtHostExplorers);
+		this._proxy = threadService.get(ExtHostContext.ExtHostTreeView);
 	}
 
-	$registerTreeExplorerNodeProvider(providerId: string): void {
+	$registerTreeDataProvider(providerId: string): void {
 		const provider = new TreeExplorerNodeProvider(providerId, this._proxy, this.messageService, this.commandService);
 		this.treeExplorerService.registerTreeExplorerNodeProvider(providerId, provider);
 	}
 
-	$refresh(providerId: string, node: InternalTreeExplorerNodeContent): void {
+	$refresh(providerId: string, node: InternalTreeNodeContent): void {
 		(<TreeExplorerNodeProvider>this.treeExplorerService.getProvider(providerId))._onRefresh.fire(node);
 	}
 }
 
-class TreeExplorerNodeProvider implements InternalTreeExplorerNodeProvider {
+class TreeExplorerNodeProvider implements InternalTreeNodeProvider {
 
-	readonly _onRefresh: Emitter<InternalTreeExplorerNodeContent> = new Emitter<InternalTreeExplorerNodeContent>();
-	readonly onRefresh: Event<InternalTreeExplorerNodeContent> = this._onRefresh.event;
+	readonly _onRefresh: Emitter<InternalTreeNodeContent> = new Emitter<InternalTreeNodeContent>();
+	readonly onRefresh: Event<InternalTreeNodeContent> = this._onRefresh.event;
 
-	constructor(public readonly id: string, private _proxy: ExtHostTreeExplorersShape,
+	constructor(public readonly id: string, private _proxy: ExtHostTreeViewShape,
 		private messageService: IMessageService,
 		private commandService: ICommandService
 	) {
 	}
 
-	provideRootNode(): TPromise<InternalTreeExplorerNodeContent> {
+	provideRootNode(): TPromise<InternalTreeNodeContent> {
 		return this._proxy.$provideRootNode(this.id).then(rootNode => rootNode, err => this.messageService.show(Severity.Error, err));
 	}
 
-	resolveChildren(node: InternalTreeExplorerNodeContent): TPromise<InternalTreeExplorerNodeContent[]> {
+	resolveChildren(node: InternalTreeNodeContent): TPromise<InternalTreeNodeContent[]> {
 		return this._proxy.$resolveChildren(this.id, node).then(children => children, err => this.messageService.show(Severity.Error, err));
 	}
 
-	executeCommand(node: InternalTreeExplorerNodeContent): TPromise<any> {
+	executeCommand(node: InternalTreeNodeContent): TPromise<any> {
 		return this._proxy.$getInternalCommand(this.id, node).then(command => {
 			return this.commandService.executeCommand(command.id, ...command.arguments);
 		});

src/vs/workbench/parts/explorers/browser/treeExplorerService.ts

@@ -8,7 +8,7 @@ import Event, { Emitter } from 'vs/base/common/event';
 import { localize } from 'vs/nls';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { IMessageService, Severity } from 'vs/platform/message/common/message';
-import { InternalTreeExplorerNode, InternalTreeExplorerNodeProvider } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
+import { InternalTreeNode, InternalTreeNodeProvider } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
 import { ITreeExplorerService } from 'vs/workbench/parts/explorers/common/treeExplorerService';
 import { IContextKeyService, IContextKey } from 'vs/platform/contextkey/common/contextkey';
 
@@ -24,7 +24,7 @@ export class TreeExplorerService implements ITreeExplorerService {
 	private _onTreeExplorerNodeProviderRegistered = new Emitter<String>();
 	public get onTreeExplorerNodeProviderRegistered(): Event<string> { return this._onTreeExplorerNodeProviderRegistered.event; };
 
-	private _treeExplorerNodeProviders: { [providerId: string]: InternalTreeExplorerNodeProvider };
+	private _treeExplorerNodeProviders: { [providerId: string]: InternalTreeNodeProvider };
 
 	constructor(
 		@IContextKeyService private contextKeyService: IContextKeyService,
@@ -53,7 +53,7 @@ export class TreeExplorerService implements ITreeExplorerService {
 		this._onDidChangeProvider.fire(provider);
 	}
 
-	public registerTreeExplorerNodeProvider(providerId: string, provider: InternalTreeExplorerNodeProvider): void {
+	public registerTreeExplorerNodeProvider(providerId: string, provider: InternalTreeNodeProvider): void {
 		this._treeExplorerNodeProviders[providerId] = provider;
 		this._onTreeExplorerNodeProviderRegistered.fire(providerId);
 	}
@@ -62,22 +62,22 @@ export class TreeExplorerService implements ITreeExplorerService {
 		return !!this._treeExplorerNodeProviders[providerId];
 	}
 
-	public provideRootNode(providerId: string): TPromise<InternalTreeExplorerNode> {
+	public provideRootNode(providerId: string): TPromise<InternalTreeNode> {
 		const provider = this.getProvider(providerId);
 		return TPromise.wrap(provider.provideRootNode());
 	}
 
-	public resolveChildren(providerId: string, node: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode[]> {
+	public resolveChildren(providerId: string, node: InternalTreeNode): TPromise<InternalTreeNode[]> {
 		const provider = this.getProvider(providerId);
 		return TPromise.wrap(provider.resolveChildren(node));
 	}
 
-	public executeCommand(providerId: string, node: InternalTreeExplorerNode): TPromise<any> {
+	public executeCommand(providerId: string, node: InternalTreeNode): TPromise<any> {
 		const provider = this.getProvider(providerId);
 		return TPromise.wrap(provider.executeCommand(node));
 	}
 
-	public getProvider(providerId: string): InternalTreeExplorerNodeProvider {
+	public getProvider(providerId: string): InternalTreeNodeProvider {
 		const provider = this._treeExplorerNodeProviders[providerId];
 
 		if (!provider) {

src/vs/workbench/parts/explorers/browser/views/treeExplorerViewer.ts

@@ -7,7 +7,7 @@
 import { TPromise } from 'vs/base/common/winjs.base';
 import { $, Builder } from 'vs/base/browser/builder';
 import { ITree, IDataSource, IRenderer, IActionProvider } from 'vs/base/parts/tree/browser/tree';
-import { InternalTreeExplorerNode } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
+import { InternalTreeNode } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
 import { ClickBehavior, DefaultController } from 'vs/base/parts/tree/browser/treeDefaults';
 import { IMouseEvent } from 'vs/base/browser/mouseEvent';
 import { IActionRunner } from 'vs/base/common/actions';
@@ -25,15 +25,15 @@ export class TreeDataSource implements IDataSource {
 
 	}
 
-	public getId(tree: ITree, node: InternalTreeExplorerNode): string {
+	public getId(tree: ITree, node: InternalTreeNode): string {
 		return node.id.toString();
 	}
 
-	public hasChildren(tree: ITree, node: InternalTreeExplorerNode): boolean {
+	public hasChildren(tree: ITree, node: InternalTreeNode): boolean {
 		return node.hasChildren;
 	}
 
-	public getChildren(tree: ITree, node: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode[]> {
+	public getChildren(tree: ITree, node: InternalTreeNode): TPromise<InternalTreeNode[]> {
 		const promise = this.treeExplorerService.resolveChildren(this.treeNodeProviderId, node);
 
 		this.progressService.showWhile(promise, 800);
@@ -41,7 +41,7 @@ export class TreeDataSource implements IDataSource {
 		return promise;
 	}
 
-	public getParent(tree: ITree, node: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode> {
+	public getParent(tree: ITree, node: InternalTreeNode): TPromise<InternalTreeNode> {
 		return TPromise.as(null);
 	}
 }
@@ -80,7 +80,7 @@ export class TreeRenderer implements IRenderer {
 		return { label: link };
 	}
 
-	public renderElement(tree: ITree, node: InternalTreeExplorerNode, templateId: string, templateData: ITreeExplorerTemplateData): void {
+	public renderElement(tree: ITree, node: InternalTreeNode, templateId: string, templateData: ITreeExplorerTemplateData): void {
 		templateData.label.text(node.label).title(node.label);
 	}
 
@@ -97,7 +97,7 @@ export class TreeController extends DefaultController {
 		super({ clickBehavior: ClickBehavior.ON_MOUSE_UP /* do not change to not break DND */, keyboardSupport: false });
 	}
 
-	public onLeftClick(tree: ITree, node: InternalTreeExplorerNode, event: IMouseEvent, origin: string = 'mouse'): boolean {
+	public onLeftClick(tree: ITree, node: InternalTreeNode, event: IMouseEvent, origin: string = 'mouse'): boolean {
 		super.onLeftClick(tree, node, event, origin);
 
 		if (node.clickCommand) {

src/vs/workbench/parts/explorers/common/treeExplorerService.ts

@@ -7,7 +7,7 @@
 import Event from 'vs/base/common/event';
 import { TPromise } from 'vs/base/common/winjs.base';
 import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
-import { InternalTreeExplorerNode, InternalTreeExplorerNodeProvider } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
+import { InternalTreeNode, InternalTreeNodeProvider } from 'vs/workbench/parts/explorers/common/treeExplorerViewModel';
 
 export const ITreeExplorerService = createDecorator<ITreeExplorerService>('treeExplorerService');
 
@@ -18,11 +18,11 @@ export interface ITreeExplorerService {
 	activeProvider: string;
 
 	onTreeExplorerNodeProviderRegistered: Event<String>;
-	registerTreeExplorerNodeProvider(providerId: string, provider: InternalTreeExplorerNodeProvider): void;
+	registerTreeExplorerNodeProvider(providerId: string, provider: InternalTreeNodeProvider): void;
 	hasProvider(providerId: string): boolean;
-	getProvider(providerId: string): InternalTreeExplorerNodeProvider;
+	getProvider(providerId: string): InternalTreeNodeProvider;
 
-	provideRootNode(providerId: string): TPromise<InternalTreeExplorerNode>;
-	resolveChildren(providerId: string, node: InternalTreeExplorerNode): TPromise<InternalTreeExplorerNode[]>;
-	executeCommand(providerId: string, node: InternalTreeExplorerNode): TPromise<void>;
+	provideRootNode(providerId: string): TPromise<InternalTreeNode>;
+	resolveChildren(providerId: string, node: InternalTreeNode): TPromise<InternalTreeNode[]>;
+	executeCommand(providerId: string, node: InternalTreeNode): TPromise<void>;
 }

src/vs/workbench/parts/explorers/common/treeExplorerViewModel.ts

@@ -7,20 +7,20 @@
 import { TPromise } from 'vs/base/common/winjs.base';
 import Event from 'vs/base/common/event';
 
-export interface InternalTreeExplorerNodeContent {
+export interface InternalTreeNodeContent {
 	label: string;
 	hasChildren: boolean;
 	clickCommand: string;
 }
 
-export interface InternalTreeExplorerNode extends InternalTreeExplorerNodeContent {
+export interface InternalTreeNode extends InternalTreeNodeContent {
 	readonly id: string;
 }
 
-export interface InternalTreeExplorerNodeProvider {
+export interface InternalTreeNodeProvider {
 	id: string;
-	provideRootNode(): Thenable<InternalTreeExplorerNodeContent>;
-	resolveChildren(node: InternalTreeExplorerNodeContent): Thenable<InternalTreeExplorerNodeContent[]>;
-	executeCommand(node: InternalTreeExplorerNodeContent): TPromise<any>;
-	onRefresh?: Event<InternalTreeExplorerNodeContent>;
+	provideRootNode(): Thenable<InternalTreeNodeContent>;
+	resolveChildren(node: InternalTreeNodeContent): Thenable<InternalTreeNodeContent[]>;
+	executeCommand(node: InternalTreeNodeContent): TPromise<any>;
+	onRefresh?: Event<InternalTreeNodeContent>;
 }