Make nodeProvider generic and add contentProvider

src/vs/vscode.d.ts

@@ -1348,12 +1348,17 @@ declare module 'vscode' {
 		provideTextDocumentContent(uri: Uri, token: CancellationToken): string | Thenable<string>;
 	}
 
-	export interface TreeExplorerNodeProvider {
-		provideRootNode(): Thenable<TreeExplorerNode>;
-		resolveChildren(node: TreeExplorerNode): Thenable<TreeExplorerNode[]>;
+	export interface TreeExplorerNodeProvider<T> {
+		contentProvider: TreeExplorerNodeContentProvider<T>;
+		provideRootNode(): Thenable<T>;
+		resolveChildren(node: T): Thenable<T[]>;
 	}
 
-	export interface TreeExplorerNode {
+	export interface TreeExplorerNodeContentProvider<T> {
+		provideNodeContent(node: T): TreeExplorerNodeContent;
+	}
+
+	export interface TreeExplorerNodeContent {
 		label: string;
 		shouldInitiallyExpand: boolean;
 		onClickCommand?: string;
@@ -3815,14 +3820,14 @@ declare module 'vscode' {
 		export function registerTextDocumentContentProvider(scheme: string, provider: TextDocumentContentProvider): Disposable;
 
 		/**
-		 * Register a tree content provider, used as a data source
+		 * Register a tree explorer node provider, used as a data source
 		 * for custom tree explorers.
 		 *
 		 * @param providerId A unique id that identifies the provider.
 		 * @param provider A [TreeContentProvider](#TreeContentProvider)
 		 * @return A [disposable](#Disposable) that unregisters this provider when being disposed.
 		 */
-		export function registerTreeExplorerNodeProvider(providerId: string, provider: TreeExplorerNodeProvider): Disposable;
+		export function registerTreeExplorerNodeProvider(providerId: string, provider: TreeExplorerNodeProvider<any>): Disposable;
 
 		/**
 		 * An event that is emitted when a [text document](#TextDocument) is opened.

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

@@ -335,7 +335,7 @@ export function createApiFactory(threadService: IThreadService, extensionService
 			onWillSaveTextDocument: (listener, thisArgs?, disposables?) => {
 				return extHostDocumentSaveParticipant.onWillSaveTextDocumentEvent(listener, thisArgs, disposables);
 			},
-			registerTreeExplorerNodeProvider(providerId: string, provider: vscode.TreeExplorerNodeProvider) {
+			registerTreeExplorerNodeProvider(providerId: string, provider: vscode.TreeExplorerNodeProvider<any>) {
 				return extHostExplorers.registerTreeContentProvider(providerId, provider);
 			},
 			onDidChangeConfiguration: (listener: () => any, thisArgs?: any, disposables?: extHostTypes.Disposable[]) => {

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { TreeExplorerNode, TreeExplorerNodeProvider } from 'vscode';
+import { TreeExplorerNodeContent, 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';
@@ -15,9 +15,8 @@ import { ExtHostCommands } from 'vs/workbench/api/node/extHostCommands';
 export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 	private _proxy: MainThreadTreeExplorersShape;
 
-	private _treeExplorerNodeProviders: { [providerId: string]: TreeExplorerNodeProvider };
-
-	private _externalNodeMaps: { [providerId: string]: { [id: number]: TreeExplorerNode }};
+	private _treeExplorerNodeProviders: { [providerId: string]: TreeExplorerNodeProvider<any> };
+	private _externalNodeMaps: { [providerId: string]: { [id: number]: TreeExplorerNodeContent }};
 
 	constructor(
 		threadService: IThreadService,
@@ -31,7 +30,7 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 		this._externalNodeMaps = Object.create(null);
 	}
 
-	registerTreeContentProvider(providerId: string, provider: TreeExplorerNodeProvider): Disposable {
+	registerTreeContentProvider(providerId: string, provider: TreeExplorerNodeProvider<any>): Disposable {
 		this._proxy.$registerTreeContentProvider(providerId);
 		this._treeExplorerNodeProviders[providerId] = provider;
 
@@ -52,7 +51,8 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 			const treeNodeMap = Object.create(null);
 			this._externalNodeMaps[providerId] = treeNodeMap;
 
-			const internalRootNode = new InternalTreeExplorerNode(externalRootNode);
+			const externalNodeContent = provider.contentProvider.provideNodeContent(externalRootNode);
+			const internalRootNode = new InternalTreeExplorerNode(externalNodeContent);
 			this._externalNodeMaps[providerId][internalRootNode.id] = externalRootNode;
 			return internalRootNode;
 		}));
@@ -69,7 +69,8 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 
 		return TPromise.wrap(provider.resolveChildren(externalNode).then(children => {
 			return children.map(externalChild => {
-				const internalChild = new InternalTreeExplorerNode(externalChild);
+				const externalChildContent = provider.contentProvider.provideNodeContent(externalChild);
+				const internalChild = new InternalTreeExplorerNode(externalChildContent);
 				externalNodeMap[internalChild.id] = externalChild;
 				return internalChild;
 			});
@@ -83,8 +84,8 @@ export class ExtHostTreeExplorers extends ExtHostTreeExplorersShape {
 		}
 
 		if (mainThreadNode.onClickCommand) {
-			return TPromise.wrap(this.commands.executeCommand(mainThreadNode.onClickCommand, this._externalNodeMaps[providerId][mainThreadNode.id]).then(() => {
-				// Todo: error handling
+			const externalNode = this._externalNodeMaps[providerId][mainThreadNode.id];
+			return TPromise.wrap(this.commands.executeCommand(mainThreadNode.onClickCommand, externalNode).then(() => {
 				return null;
 			}));
 		}

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { TreeExplorerNode } from 'vscode';
+import { TreeExplorerNodeContent } 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';
@@ -18,7 +18,7 @@ export class MainThreadTreeExplorers extends MainThreadTreeExplorersShape {
 
 	constructor(
 		@IThreadService threadService: IThreadService,
-		@ITreeExplorerService private treeExplorerViewletService: ITreeExplorerService
+		@ITreeExplorerService private treeExplorerService: ITreeExplorerService
 	) {
 		super();
 
@@ -27,7 +27,7 @@ export class MainThreadTreeExplorers extends MainThreadTreeExplorersShape {
 	}
 
 	$registerTreeContentProvider(providerId: string): void {
-		this.treeExplorerViewletService.registerTreeContentProvider(providerId, {
+		this.treeExplorerService.registerTreeContentProvider(providerId, {
 			provideRootNode: (): TPromise<InternalTreeExplorerNode> => {
 				return this._proxy.$provideRootNode(providerId).then(treeContent => {
 					this._treeContents[providerId] = treeContent;

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

 import { TPromise } from 'vs/base/common/winjs.base';
-import { TreeExplorerNode, TreeExplorerNodeProvider } from 'vscode';
+import { TreeExplorerNodeContent, TreeExplorerNodeProvider } from 'vscode';
 
-export class InternalTreeExplorerNode implements TreeExplorerNode {
+export class InternalTreeExplorerNode implements TreeExplorerNodeContent {
 	static idCounter = 1;
 
 	id: number;
 
-	// Property on TreeContentNode
 	label: string;
 	shouldInitiallyExpand: boolean;
 	onClickCommand: string;
 
-	constructor(node: TreeExplorerNode) {
+	constructor(node: TreeExplorerNodeContent) {
 		this.id = InternalTreeExplorerNode.idCounter++;
 
 		this.label = node.label;
@@ -20,6 +19,8 @@ export class InternalTreeExplorerNode implements TreeExplorerNode {
 	}
 }
 
-export interface InternalTreeExplorerNodeProvider extends TreeExplorerNodeProvider {
-	resolveCommand(node: TreeExplorerNode): TPromise<void>;
+export interface InternalTreeExplorerNodeProvider {
+	resolveCommand(node: TreeExplorerNodeContent): TPromise<void>;
+	provideRootNode(): Thenable<InternalTreeExplorerNode>;
+	resolveChildren(node: InternalTreeExplorerNode): Thenable<InternalTreeExplorerNode[]>;
 }
\ No newline at end of file