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

Keep a local tree at extHostExplorer side

Browse Source
This commit is contained in:
Pine Wu
2016-10-05 15:27:01 -07:00
parent f36453850f
commit 154cdf9103
3 changed files with 58 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -34,6 +34,8 @@ 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';
export interface InstanceSetter<T> {
set<R extends T>(instance: T): R;
}
@@ -263,8 +265,8 @@ export abstract class ExtHostEditorsShape {
}
export abstract class ExtHostExplorersShape {
$provideTreeContent(treeContentProviderId: string): TPromise<vscode.ITreeNode> { throw ni(); };
$resolveChildren(treeContentProviderId: string, node: vscode.ITreeNode): TPromise<vscode.ITreeNode[]> { throw ni(); }
$provideTreeContent(treeContentProviderId: string): TPromise<ExtHostTreeNode> { throw ni(); };
$resolveChildren(treeContentProviderId: string, node: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> { throw ni(); }
}
export abstract class ExtHostExtensionServiceShape {

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

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as vscode from 'vscode';
import { ITreeNode, 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';
@@ -13,7 +13,9 @@ import {MainContext, ExtHostExplorersShape, MainThreadExplorersShape} from './ex
export class ExtHostExplorers extends ExtHostExplorersShape {
private _proxy: MainThreadExplorersShape;
private _treeContentProviders: { [treeContentProviderId: string]: vscode.TreeContentProvider };
private _treeContentProviders: { [treeContentProviderId: string]: TreeContentProvider };
private _treeContents: { [treeContentProviderId: string]: ExtHostTreeNode };
private _treeNodeMaps: { [treeContentProviderId: string]: { [id: number]: ExtHostTreeNode }};
constructor(
threadService: IThreadService
@@ -23,9 +25,11 @@ export class ExtHostExplorers extends ExtHostExplorersShape {
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: vscode.TreeContentProvider): vscode.Disposable {
registerTreeContentProvider(providerId: string, provider: TreeContentProvider): Disposable {
this._proxy.$registerTreeContentProvider(providerId);
this._treeContentProviders[providerId] = provider;
@@ -36,25 +40,56 @@ export class ExtHostExplorers extends ExtHostExplorersShape {
});
}
$provideTreeContent(treeContentProviderId: string): TPromise<vscode.ITreeNode> {
$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 => {
return 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, node: vscode.ITreeNode): TPromise<vscode.ITreeNode[]> {
$resolveChildren(treeContentProviderId: string, mainThreadNode: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> {
const provider = this._treeContentProviders[treeContentProviderId];
if (!provider) {
throw new Error(`no TreeContentProvider registered with id '${treeContentProviderId}'`);
}
return TPromise.wrap(provider.resolveChildren(node).then(children => {
return children;
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 ITreeNode {
static idCounter = 1;
id: number;
label: string;
isExpanded: boolean;
children: ExtHostTreeNode[];
constructor(node: ITreeNode, parent: ExtHostTreeNode, treeNodeMap: { [id: number]: ExtHostTreeNode}) {
this.id = ExtHostTreeNode.idCounter++;
this.label = node.label;
this.isExpanded = node.isExpanded;
this.children = node.children.map(child => {
return new ExtHostTreeNode(child, this, treeNodeMap);
})
treeNodeMap[this.id] = this;
}
}

14
src/vs/workbench/api/node/mainThreadExplorers.ts
View File

@@ -11,9 +11,13 @@ import {ExtHostContext, MainThreadExplorersShape, ExtHostExplorersShape} from '.
import {ITreeExplorerViewletService} from 'vs/workbench/parts/explorers/browser/treeExplorerViewletService';
import {TreeViewNode} from 'vs/workbench/parts/explorers/common/treeViewModel';
import { ExtHostTreeNode } from 'vs/workbench/api/node/extHostExplorers';
export class MainThreadExplorers extends MainThreadExplorersShape {
private _proxy: ExtHostExplorersShape;
private _treeContents: { [treeContentProviderId: string]: ExtHostTreeNode };
constructor(
@IThreadService threadService: IThreadService,
@ITreeExplorerViewletService private treeExplorerViewletService: ITreeExplorerViewletService
@@ -21,14 +25,18 @@ export class MainThreadExplorers extends MainThreadExplorersShape {
super();
this._proxy = threadService.get(ExtHostContext.ExtHostExplorers);
this._treeContents = Object.create(null);
}
$registerTreeContentProvider(providerId: string): void {
this.treeExplorerViewletService.registerTreeContentProvider(providerId, {
provideTreeContent: (): TPromise<ITreeNode> => {
return this._proxy.$provideTreeContent(providerId);
provideTreeContent: (): TPromise<ExtHostTreeNode> => {
return this._proxy.$provideTreeContent(providerId).then(treeContent => {
this._treeContents[providerId] = treeContent;
return treeContent;
})
},
resolveChildren: (node: ITreeNode): TPromise<ITreeNode[]> => {
resolveChildren: (node: ExtHostTreeNode): TPromise<ExtHostTreeNode[]> => {
return this._proxy.$resolveChildren(providerId, node);
}
});