Hook up provider mechanism and add onClick

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

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

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

@@ -263,7 +263,7 @@ export abstract class ExtHostEditorsShape {
 }
 
 export abstract class ExtHostExplorersShape {
-	$provideTextDocumentContent(treeContentProviderId: string): vscode.ITree { throw ni(); };
+	$provideTreeContent(treeContentProviderId: string): TPromise<string> { throw ni(); };
 }
 
 export abstract class ExtHostExtensionServiceShape {

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

@@ -15,7 +15,9 @@ export class ExtHostExplorers extends ExtHostExplorersShape {
 
 	private _treeContentProviders: { [treeContentProviderId: string]: vscode.TreeContentProvider; };
 
-	constructor(threadService: IThreadService) {
+	constructor(
+		threadService: IThreadService
+	) {
 		super();
 
 		this._proxy = threadService.get(MainContext.MainThreadExplorers);
@@ -23,29 +25,25 @@ export class ExtHostExplorers extends ExtHostExplorersShape {
 		this._treeContentProviders = Object.create(null);
 	}
 
-	public registerTreeContentProvider(provider: vscode.TreeContentProvider): vscode.Disposable {
-		const treeContentProviderId = provider.id;
-
-		if (this._treeContentProviders[treeContentProviderId]) {
-			throw new Error(`TreeContentProvider with id '${provider.id} already registered`);
-		}
-
-		this._treeContentProviders[treeContentProviderId] = provider;
-		this._proxy.$registerTreeContentProvider(treeContentProviderId);
+	public registerTreeContentProvider(providerId: string, provider: vscode.TreeContentProvider): vscode.Disposable {
+		this._proxy.$registerTreeContentProvider(providerId);
+		this._treeContentProviders[providerId] = provider;
 
 		return new Disposable(() => {
-			if (delete this._treeContentProviders[treeContentProviderId]) {
-				this._proxy.$unregisterTreeContentProvider(treeContentProviderId);
+			if (delete this._treeContentProviders[providerId]) {
+				this._proxy.$unregisterTreeContentProvider(providerId);
 			}
 		});
 	}
 
-	$provideTextDocumentContent(treeContentProviderId: string): vscode.ITree {
+	$provideTreeContent(treeContentProviderId: string): TPromise<string> {
 		const provider = this._treeContentProviders[treeContentProviderId];
 		if (!provider) {
 			throw new Error(`no TreeContentProvider registered with id '${treeContentProviderId}'`);
 		}
 
-		return provider.provideTreeContent();
+		return TPromise.wrap(provider.provideTreeContent().then(treeContent => {
+			return JSON.stringify(treeContent);
+		}));
 	}
 }

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

@@ -1,19 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { ITreeNode } 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';
 
 export class MainThreadExplorers extends MainThreadExplorersShape {
 	private _proxy: ExtHostExplorersShape;
 
 	constructor(
-		@IThreadService threadService: IThreadService
+		@IThreadService threadService: IThreadService,
+		@ITreeExplorerViewletService private treeExplorerViewletService: ITreeExplorerViewletService
 	) {
 		super();
 
 		this._proxy = threadService.get(ExtHostContext.ExtHostExplorers);
 	}
 
-	$registerTreeContentProvider(treeContentProviderId: string): void {
-		const tree = this._proxy.$provideTextDocumentContent(treeContentProviderId);
+	$registerTreeContentProvider(providerId: string): void {
+		this.treeExplorerViewletService.registerTreeContentProvider(providerId, {
+			provideTreeContent: (): TPromise<ITreeNode> => {
+				return this._proxy.$provideTreeContent(providerId).then(jsonTree => {
+					return <ITreeNode>JSON.parse(jsonTree);
+				})
+			}
+		});
 	}
 
 	$unregisterTreeContentProvider(treeContentProviderId: string): void {