capture/restore expansion state before/after filtering

src/vs/workbench/parts/outline/electron-browser/outlineModel.ts

@@ -120,4 +120,21 @@ export class OutlineItemGroup {
 		}
 		return item;
 	}
+
+	getItemById(id: string): OutlineItem {
+		return this._getItemById(id, this.children);
+	}
+
+	private _getItemById(id: string, items: OutlineItem[]): OutlineItem {
+		for (const item of items) {
+			if (item.id === id) {
+				return item;
+			}
+			let candidate = this._getItemById(id, item.children);
+			if (candidate) {
+				return candidate;
+			}
+		}
+		return undefined;
+	}
 }

src/vs/workbench/parts/outline/electron-browser/outlinePanel.ts

@@ -31,7 +31,7 @@ import { IViewOptions, ViewsViewletPanel } from 'vs/workbench/browser/parts/view
 import { IWorkbenchEditorService } from 'vs/workbench/services/editor/common/editorService';
 import { IEditorGroupService } from 'vs/workbench/services/group/common/groupService';
 import { OutlineItem, OutlineItemGroup, getOutline } from './outlineModel';
-import { OutlineDataSource, OutlineItemComparator, OutlineItemCompareType, OutlineItemFilter, OutlineRenderer } from './outlineTree';
+import { OutlineDataSource, OutlineItemComparator, OutlineItemCompareType, OutlineItemFilter, OutlineRenderer, OutlineTreeState } from './outlineTree';
 import { KeyCode } from '../../../../base/common/keyCodes';
 
 class ActiveEditorOracle {
@@ -216,13 +216,26 @@ export class OutlinePanel extends ViewsViewletPanel {
 
 			this._input.enable();
 
-			this._editorDisposables.push(this._input.onDidChange(async query => {
-				let item = model.updateMatches(query);
+			let beforePatternState: OutlineTreeState;
+
+			this._editorDisposables.push(this._input.onDidChange(async pattern => {
+
+				if (!beforePatternState) {
+					beforePatternState = OutlineTreeState.capture(this._tree);
+				}
+
+				let item = model.updateMatches(pattern);
 				await this._tree.refresh(undefined, true);
 				if (item) {
 					await this._tree.reveal(item);
 					this._tree.setFocus(item, this);
 					this._tree.setSelection([item], this);
+					this._tree.expandAll(undefined /*all*/);
+				}
+
+				if (!pattern && beforePatternState) {
+					await OutlineTreeState.restore(this._tree, beforePatternState);
+					beforePatternState = undefined;
 				}
 			}));
 

src/vs/workbench/parts/outline/electron-browser/outlineTree.ts

@@ -108,3 +108,38 @@ export class OutlineRenderer implements IRenderer {
 		template.label.dispose();
 	}
 }
+
+export class OutlineTreeState {
+
+	readonly expanded: string[];
+
+	static capture(tree: ITree): OutlineTreeState {
+		let expanded = new Array<string>();
+		let nav = tree.getNavigator();
+		while (nav.next()) {
+			let element = nav.current();
+			if (element instanceof OutlineItem) {
+				if (tree.isExpanded(element)) {
+					expanded.push(element.id);
+				}
+			}
+		}
+		return { expanded };
+	}
+
+	static async restore(tree: ITree, state: OutlineTreeState): TPromise<void> {
+		let input = <OutlineItemGroup>tree.getInput();
+		if (!(input instanceof OutlineItemGroup)) {
+			return TPromise.as(undefined);
+		}
+		let items: OutlineItem[] = [];
+		for (const id of state.expanded) {
+			let item = input.getItemById(id);
+			if (item) {
+				items.push(item);
+			}
+		}
+		await tree.collapseAll(undefined);
+		await tree.expandAll(items);
+	}
+}