Refactored registerCommands. Added show on refresh click

Author: mikecentola

src/views/navTreeView.ts

@@ -6,6 +6,7 @@
 import {
     commands,
     ConfigurationChangeEvent,
+    Disposable,
     Range,
     Selection,
     TextDocumentChangeEvent,
@@ -49,9 +50,6 @@ export class NavTreeView extends GView<NavTreeNode> {
         // Initialize View
         this.initialize();
 
-        // Register View Commands
-        this.registerCommands();
-
         // Initialize StatusBar
         this._statusbar = Control.statusBarController;
 
@@ -141,30 +139,36 @@ export class NavTreeView extends GView<NavTreeNode> {
         }
     }
 
-    protected registerCommands() {
-        // Refresh Command
-        commands.registerCommand(
-            ViewCommands.RefreshTree,
-            () => {
-                if (this._editor && this._editor.document) {
-                    if (this._editor.document.languageId === constants.langId) {
-                        void Control.setContext(Contexts.ViewsNavTreeEnabled, true);
-                    }
+    protected registerCommands(): Disposable[] {
+        return [
+            // Refresh Command
+            commands.registerCommand(
+                ViewCommands.RefreshTree,
+                () => {
+                    if (this._editor && this._editor.document) {
+                        if (this._editor.document.languageId === constants.langId) {
+                            void Control.setContext(Contexts.ViewsNavTreeEnabled, true);
+                        }
 
-                    void this.refresh();
-                }
-            },
-            this,
-        );
-
-        // Selection Command
-        commands.registerCommand(
-            ViewCommands.TreeSelect,
-            range => {
-                this.select(range);
-            },
-            this,
-        );
+                        // Refresh View
+                        void this.refresh();
+
+                        // Show Tree View
+                        void this.show();
+                    }
+                },
+                this,
+            ),
+
+            // Selection Command
+            commands.registerCommand(
+                ViewCommands.TreeSelect,
+                range => {
+                    this.select(range);
+                },
+                this,
+            ),
+        ];
     }
 
     protected async refresh(element?: NavTreeNode): Promise<void> {

src/views/statsView.ts

@@ -7,6 +7,7 @@
 import {
     commands,
     ConfigurationChangeEvent,
+    Disposable,
     TextDocumentChangeEvent,
     ThemeIcon,
     TreeItemCollapsibleState,
@@ -44,12 +45,8 @@ export class StatsView extends GView<StatsNode> {
     constructor() {
         super(StatsViewInfo.ViewId, StatsViewInfo.ViewName);
 
-        this._editor = window.activeTextEditor;
-
         this.initialize();
 
-        this.registerCommands();
-
         this._autoRefresh = configuration.getParam(StatsViewInfo.Config.AutoRefresh);
 
         if (this._autoRefresh) {
@@ -140,19 +137,25 @@ export class StatsView extends GView<StatsNode> {
         }
     }
 
-    protected registerCommands() {
-        // Refresh Command
-        commands.registerCommand(
-            ViewCommands.RefreshStats,
-            () => {
-                if (window.activeTextEditor?.document.languageId === constants.langId) {
-                    void Control.setContext(Contexts.ViewsStatsEnabled, true);
-                }
+    protected registerCommands(): Disposable[] {
+        return [
+            // Refresh Command
+            commands.registerCommand(
+                ViewCommands.RefreshStats,
+                () => {
+                    if (window.activeTextEditor?.document.languageId === constants.langId) {
+                        void Control.setContext(Contexts.ViewsStatsEnabled, true);
+                    }
 
-                void this.refresh();
-            },
-            this,
-        );
+                    // Refresh View
+                    void this.refresh();
+
+                    // Show Stats View
+                    void this.show();
+                },
+                this,
+            ),
+        ];
     }
 
     protected async refresh(element?: StatsNode): Promise<void> {

src/views/views.ts

@@ -5,6 +5,7 @@
 'use strict';
 
 import {
+    commands,
     ConfigurationChangeEvent,
     Disposable,
     Event,
@@ -14,15 +15,16 @@ import {
     TreeDataProvider,
     TreeItem,
     TreeView,
+    TreeViewVisibilityChangeEvent,
     window,
     workspace,
 } from 'vscode';
-import { Control } from '../control';
 import { configuration } from '../util/configuration/config';
+import { Logger } from '../util/logger';
 import { NodeTypes, ViewNode } from './nodes/nodes';
 
 export abstract class GView<TRoot extends ViewNode<NodeTypes>> implements TreeDataProvider<ViewNode>, Disposable {
-    protected _disposable: Disposable | undefined;
+    protected _disposables: Disposable[] = [];
     protected _root: TRoot | undefined;
     protected _tree: TreeView<ViewNode> | undefined;
     protected _editor: TextEditor | undefined;
@@ -33,9 +35,17 @@ export abstract class GView<TRoot extends ViewNode<NodeTypes>> implements TreeDa
         return this._onDidChangeTreeData.event;
     }
 
+    private _onDidChangeVisibility: EventEmitter<TreeViewVisibilityChangeEvent> =
+        new EventEmitter<TreeViewVisibilityChangeEvent>();
+    get onDidChangeVisibility(): Event<TreeViewVisibilityChangeEvent> {
+        return this._onDidChangeVisibility.event;
+    }
+
     protected abstract getRoot(): ViewNode | undefined;
 
-    constructor(public readonly id: string, public readonly name: string) {}
+    constructor(public readonly id: string, public readonly name: string) {
+        this._disposables.push(...this.registerCommands());
+    }
 
     protected ensureRoot() {
         if (this._root === undefined) {
@@ -46,26 +56,40 @@ export abstract class GView<TRoot extends ViewNode<NodeTypes>> implements TreeDa
     }
 
     protected initialize(options: { showCollapseAll?: boolean } = {}) {
-        if (this._disposable) {
-            this._disposable.dispose();
-            this._onDidChangeTreeData = new EventEmitter<ViewNode>();
-        }
-
         this._tree = window.createTreeView(this.id, {
             ...options,
             treeDataProvider: this,
         });
 
-        Control.context.subscriptions.push(configuration.onDidChange(this.onConfigurationChanged, this));
+        this._disposables.push(
+            configuration.onDidChange(this.onConfigurationChanged, this),
+            window.onDidChangeActiveTextEditor(() => this.onActiveEditorChanged()),
+            workspace.onDidChangeTextDocument(e => this.onDocumentChanged(e)),
+            this._tree,
+            this._tree.onDidChangeVisibility(this.onVisibilityChanged, this),
+        );
+    }
 
-        window.onDidChangeActiveTextEditor(() => this.onActiveEditorChanged());
-        workspace.onDidChangeTextDocument(e => this.onDocumentChanged(e));
+    protected onVisibilityChanged(e: TreeViewVisibilityChangeEvent) {
+        this._onDidChangeVisibility.fire(e);
+    }
 
-        this._disposable = Disposable.from(this._tree);
+    get visible(): boolean {
+        return this._tree?.visible ?? false;
+    }
+
+    protected async show() {
+        if (!this.visible) {
+            try {
+                void (await commands.executeCommand(`${this.id}.focus`));
+            } catch (err) {
+                Logger.error(err, 'Error focusing view');
+            }
+        }
     }
 
     dispose() {
-        this._disposable && this._disposable.dispose();
+        Disposable.from(...this._disposables).dispose();
     }
 
     getTreeItem(element: ViewNode): TreeItem | Promise<TreeItem> {
@@ -85,6 +109,8 @@ export abstract class GView<TRoot extends ViewNode<NodeTypes>> implements TreeDa
         return element.getParent();
     }
 
+    protected abstract registerCommands(): Disposable[];
+
     protected abstract refresh(element?: ViewNode): void;
 
     protected abstract onConfigurationChanged(e: ConfigurationChangeEvent): void;