Hook up provider mechanism and add onClick

src/vs/vscode.d.ts

@@ -1349,18 +1349,12 @@ declare module 'vscode' {
 	}
 
 	export interface TreeContentProvider {
-		id: string;
-		provideTreeContent(): ITree;
-	}
-
-	export interface ITree {
-		root: ITreeNode;
+		provideTreeContent(): Thenable<ITreeNode>;
 	}
 
 	export interface ITreeNode {
 		label: string;
 		isExpanded: boolean;
-		parent: ITreeNode;
 		children: ITreeNode[]
 	}
 
@@ -3819,7 +3813,7 @@ declare module 'vscode' {
 		 */
 		export function registerTextDocumentContentProvider(scheme: string, provider: TextDocumentContentProvider): Disposable;
 
-		export function registerTreeContentProvider(provider: TreeContentProvider): Disposable;
+		export function registerTreeContentProvider(providerId: string, provider: TreeContentProvider): Disposable;
 
 		/**
 		 * An event that is emitted when a [text document](#TextDocument) is opened.

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

+/*---------------------------------------------------------------------------------------------
+ *  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 {

src/vs/workbench/parts/explorers/browser/treeExplorerViewlet.contribution.ts

 'use strict';
 
-import 'vs/css!./media/treeExplorerViewlet.contribution';
\ No newline at end of file
+import 'vs/css!./media/treeExplorerViewlet.contribution';
+
+import {ITreeExplorerViewletService, TreeExplorerViewletService } from 'vs/workbench/parts/explorers/browser/treeExplorerViewletService';
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+
+registerSingleton(ITreeExplorerViewletService, TreeExplorerViewletService);
\ No newline at end of file

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

@@ -50,6 +50,12 @@ export class TreeExplorerViewlet extends Viewlet {
 		this.view.layout(dimension.height, Orientation.VERTICAL);
 	}
 
+	setVisible(visible: boolean): TPromise<void> {
+		return super.setVisible(visible).then(() => {
+			this.view.setVisible(visible).done();
+		})
+	}
+
 	private onConfigurationUpdated(config: ICustomViewletConfiguration): TPromise<void> {
 		return TPromise.as(null);
 	}

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

+'use strict';
+
+import { ITreeNode, TreeContentProvider } from 'vscode';
+import { TPromise } from 'vs/base/common/winjs.base';
+import Event, {Emitter} from 'vs/base/common/event';
+import { IInstantiationService, createDecorator } from 'vs/platform/instantiation/common/instantiation';
+import { TreeViewNode } from 'vs/workbench/parts/explorers/common/treeViewModel';
+
+export const ITreeExplorerViewletService = createDecorator<ITreeExplorerViewletService>('customViewletService');
+
+export interface ITreeExplorerViewletService {
+	_serviceBrand: any;
+
+	registerTreeContentProvider(providerId: string, provider: TreeContentProvider): void;
+	provideTreeContent(providerId: string): TPromise<ITreeNode>;
+}
+
+export class TreeExplorerViewletService implements ITreeExplorerViewletService {
+	public _serviceBrand: any;
+
+	private _treeContentProviders: { [providerId: string]: TreeContentProvider; };
+
+	constructor(
+		@IInstantiationService private _instantiationService: IInstantiationService,
+	) {
+		this._treeContentProviders = Object.create(null);
+	}
+
+	registerTreeContentProvider(providerId: string, provider: TreeContentProvider): void {
+		this._treeContentProviders[providerId] = provider;
+	}
+
+	provideTreeContent(providerId: string): TPromise<ITreeNode> {
+		return TPromise.wrap(this._treeContentProviders[providerId].provideTreeContent());
+	}
+}

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

@@ -16,6 +16,7 @@ import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IWorkbenchEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IEditorGroupService } from 'vs/workbench/services/group/common/groupService';
+import { ITreeExplorerViewletService } from 'vs/workbench/parts/explorers/browser/treeExplorerViewletService';
 
 import { ITree, IDataSource, IRenderer } from 'vs/base/parts/tree/browser/tree';
 import { Tree } from 'vs/base/parts/tree/browser/treeImpl';
@@ -61,7 +62,8 @@ export class TreeView extends CollapsibleViewletView {
 		@IWorkspaceContextService private contextService: IWorkspaceContextService,
 		@IInstantiationService private instantiationService: IInstantiationService,
 		@IWorkbenchEditorService private editorService: IWorkbenchEditorService,
-		@IEditorGroupService private editorGroupService: IEditorGroupService
+		@IEditorGroupService private editorGroupService: IEditorGroupService,
+		@ITreeExplorerViewletService private treeExplorerViewletService: ITreeExplorerViewletService
 	) {
 		super(actionRunner, false, nls.localize('treeExplorerViewletTree', "Tree Explorer Tree Section"), messageService, keybindingService, contextMenuService, headerSize);
 
@@ -80,7 +82,9 @@ export class TreeView extends CollapsibleViewletView {
 		DOM.addClass(this.treeContainer, 'tree-explorer-viewlet-tree-view');
 
 		this.tree = this.createViewer($(this.treeContainer));
-		this.tree.setInput(getTree());
+		this.treeExplorerViewletService.provideTreeContent('pineTree').then(tree => {
+			this.tree.setInput(tree);
+		});
 	}
 
 	getActions(): IAction[] {
@@ -90,7 +94,7 @@ export class TreeView extends CollapsibleViewletView {
 	createViewer(container: Builder): ITree {
 		const dataSource = this.instantiationService.createInstance(TreeDataSource);
 		const renderer = this.instantiationService.createInstance(TreeRenderer, this.viewletState, this.actionRunner, container.getHTMLElement());
-		const controller = null;
+		const controller = this.instantiationService.createInstance(TreeController);
 		const sorter = null;
 		const filter = null;
 		const dnd = null;
@@ -108,43 +112,19 @@ export class TreeView extends CollapsibleViewletView {
 	}
 
 	create(): TPromise<void> {
-		this.toDispose.push(this.editorGroupService.onEditorsChanged(() => this.onEditorsChanged()))
-		return TPromise.as(null);
-	}
-
-	private onEditorsChanged() {
-		const activeInput = this.editorService.getActiveEditorInput();
-
-		if (activeInput instanceof FileEditorInput) {
-			const fileResource = activeInput.getResource();
-
-			this.updateOutlineViewlet(fileResource);
-		}
+		return this.setVisible(true);
 	}
 
-	refresh(): TPromise<void> {
-		const input = this.tree.getInput();
-		return this.doRefresh();
-	}
-
-	private doRefresh(): TPromise<void> {
-		return TPromise.as(null);
-	}
-
-	private updateOutlineViewlet(fileURI: URI): TPromise<void> {
-		this.tree.setInput(getTree());
-		/*
-		documentSymbols(fileURI.path).then(nodes => {
-			const root = nodes[0];
-			this.tree.setInput(root);
+	setVisible(visible: boolean): TPromise<void> {
+		return super.setVisible(visible).then(() => {
+			this.updateInput().done();
 		});
-		*/
-
-		return TPromise.as(null);
 	}
 
-	focus(): void {
-
+	private updateInput(): TPromise<void> {
+		return this.treeExplorerViewletService.provideTreeContent('pineTree').then(tree => {
+			this.tree.setInput(tree);
+		})
 	}
 
 	public getOptimalWidth(): number {

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

@@ -5,6 +5,7 @@ import { ITree, IDataSource, IRenderer, IElementCallback } from 'vs/base/parts/t
 import { Tree } from 'vs/base/parts/tree/browser/treeImpl';
 import { TreeViewNode } from 'vs/workbench/parts/explorers/common/treeViewModel';
 import { DefaultController } from 'vs/base/parts/tree/browser/treeDefaults';
+import { IMouseEvent } from 'vs/base/browser/mouseEvent';
 
 import { IActionRunner } from 'vs/base/common/actions';
 import { IActionProvider, ActionsRenderer } from 'vs/base/parts/tree/browser/actionsRenderer';
@@ -25,7 +26,7 @@ export class TreeDataSource implements IDataSource {
 	}
 
 	public hasChildren(tree: ITree, node: TreeViewNode): boolean {
-		return node.children.length > 0;
+		return node.children && node.children.length > 0;
 	}
 
 	public getChildren(tree: ITree, node: TreeViewNode): TPromise<TreeViewNode[]> {
@@ -74,6 +75,11 @@ export class TreeRenderer extends ActionsRenderer implements IRenderer {
 
 export class TreeController extends DefaultController {
 
+	/* protected */ public onLeftClick(tree: ITree, node: TreeViewNode, event: IMouseEvent, origin: string = 'mouse'): boolean {
+		super.onLeftClick(tree, node, event, origin);
+		console.log(node.label);
+		return true;
+	}
 }
 
 export interface ITreeExplorerViewletState {

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

-
 export class TreeViewNode implements vscode.ITreeNode {
   id: number;
   label: string;
   isExpanded: boolean;
-  parent: vscode.ITreeNode;
-  children: vscode.ITreeNode[];
+  parent: TreeViewNode
+  children: TreeViewNode[];
 
   constructor(
     id: number,
     label: string,
     isExpanded: boolean = true,
-    parent: vscode.ITreeNode = null,
-    children: vscode.ITreeNode[] = []) {
+    parent: TreeViewNode = null,
+    children: TreeViewNode[] = []) {
     this.id = id;
     this.label = label;
     this.isExpanded = isExpanded;
@@ -19,7 +18,7 @@ export class TreeViewNode implements vscode.ITreeNode {
     this.children = children;
   }
 
-  addChild(child: vscode.ITreeNode) {
+  addChild(child: TreeViewNode) {
     this.children.push(child);
     child.parent = this;
   }