Working hover

Author: mikecentola

src/control.ts

@@ -18,16 +18,20 @@ import { Version } from './util/version';
 import { Messages } from './util/messages';
 import { StateControl } from './util/stateControl';
 import { CodesWebview } from './webviews/codesWebview';
+import { MachineTypeControl } from './util/machineType';
+import { GCodeHoverControl } from './hovers/gcodeHoverControl';
 
 export class Control {
     private static _config: Config | undefined;
     private static _context: ExtensionContext;
     private static _units: string | undefined;
 
     // Controllers
+    private static _machineTypeControl: MachineTypeControl | undefined;
     private static _statusBarControl: StatusBarControl;
     private static _unitsController: GCodeUnitsController | undefined;
     private static _stateController: StateControl;
+    private static _hoverController: GCodeHoverControl;
 
     // Views
     private static _statsView: StatsView | undefined;
@@ -67,12 +71,18 @@ export class Control {
         this._context = context;
         this._config = config;
 
+        // Load Machine Type
+        context.subscriptions.push((this._machineTypeControl = new MachineTypeControl()));
+
         // Load State Controller
         this._stateController = new StateControl(context);
 
         // Load StatusBars
         context.subscriptions.push((this._statusBarControl = new StatusBarControl(this._context)));
 
+        // Load Hover Controller
+        context.subscriptions.push((this._hoverController = new GCodeHoverControl()));
+
         // Units
         this._units = <string>config.getParam('general.units');
         Logger.log(`Units: ${this._units}`);
@@ -143,7 +153,15 @@ export class Control {
     static terminate() {
         Logger.log('Terminating Extension...');
 
-        // Dispose of status bars
+        // Dispose Views
+        this._codesWebview?.dispose();
+        this._statsView?.dispose();
+        this._statsView?.dispose();
+
+        // Dispose Controllers
+        this._hoverController.dispose();
+        this._unitsController?.dispose();
+        this._machineTypeControl?.dispose();
         this._statusBarControl?.dispose();
     }
 
@@ -164,6 +182,10 @@ export class Control {
         return this._config;
     }
 
+    static get machineType() {
+        return this._machineTypeControl;
+    }
+
     static get navTree() {
         if (this._navTree === undefined) {
             this._context.subscriptions.push((this._navTree = new NavTreeView()));

src/hovers/dictionary.ts

@@ -7,6 +7,7 @@
 import { ConfigurationChangeEvent, Disposable, languages, TextEditor, Uri, window } from 'vscode';
 import { configuration } from '../util/config';
 import { constants } from '../util/constants';
+import { Logger } from '../util/logger';
 import { GCodeHoverProvider } from './gcodeHoverProvider';
 
 export class GCodeHoverControl implements Disposable {
@@ -19,6 +20,11 @@ export class GCodeHoverControl implements Disposable {
         this._disposable = Disposable.from(configuration.onDidChange(this.onConfigurationChanged, this));
 
         this._enabled = <boolean>configuration.getParam('general.hovers.enabled');
+
+        if (this._enabled) {
+            Logger.log('Loading Hover Controller...');
+            this.register(window.activeTextEditor);
+        }
     }
 
     dispose() {
@@ -29,9 +35,11 @@ export class GCodeHoverControl implements Disposable {
         if (configuration.changed(e, 'general.hovers.enabled')) {
             if (this._enabled) {
                 // Disable and Dispose
+                Logger.log('Disabling Hover Controller...');
                 this.unregister();
             } else {
                 // Enable
+                Logger.log('Enabling Hover Controller...');
                 this.register(window.activeTextEditor);
             }
         }

src/hovers/gcodeHoverControl.ts

@@ -4,15 +4,39 @@
  * -------------------------------------------------------------------------------------------- */
 'use strict';
 
-import { CancellationToken, Hover, HoverProvider, MarkdownString, Position, TextDocument } from 'vscode';
+import {
+    CancellationToken,
+    Hover,
+    HoverProvider,
+    MarkdownString,
+    Position,
+    ProviderResult,
+    TextDocument,
+} from 'vscode';
+import { Control } from '../control';
 
 export class GCodeHoverProvider implements HoverProvider {
-    async provideHover(document: TextDocument, position: Position, _token: CancellationToken): Promise<Hover> {
+    provideHover(document: TextDocument, position: Position, _token: CancellationToken): ProviderResult<Hover> {
         const range = document.getWordRangeAtPosition(position);
         const text = document.getText(range);
 
-        return new Hover();
+        const def = this.lookup(text);
+        if (def === undefined) {
+            return;
+        } else {
+            return new Hover(def, range);
+        }
     }
 
-    private async gcodeLookup(text: string): MarkdownString {}
+    private lookup(text: string): MarkdownString | undefined {
+        const ref = Control.machineType?.gReference;
+
+        const code = ref?.get(text);
+
+        if (code === undefined) {
+            return;
+        }
+
+        return new MarkdownString(`**${text}**: `).appendMarkdown(code.shortDesc ?? '');
+    }
 }

src/hovers/gcodeHoverProvider.ts

@@ -71,6 +71,7 @@ export const enum VSBuiltInCommands {
 }
 
 export const enum Contexts {
+    MachineType = 'gcode:general:machineType',
     ViewsNavTreeEnabled = 'gcode:navTree:enabled',
     ViewsStatsEnabled = 'gcode:stats:enabled',
 }

src/util/constants.ts

@@ -0,0 +1,65 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Applied Eng & Design All rights reserved.
+ *  Licensed under the MIT License. See License.md in the project root for license information.
+ * -------------------------------------------------------------------------------------------- */
+'use strict';
+
+import { ConfigurationChangeEvent, Disposable, Event, EventEmitter, workspace } from 'vscode';
+import { GReference, MachineTypes } from '@appliedengdesign/gcode-reference';
+import { configuration } from './config';
+import { Logger } from './logger';
+
+export class MachineTypeControl implements Disposable {
+    private readonly _dispoable: Disposable | undefined;
+    private _machineType: MachineTypes | undefined;
+    private _gReference: GReference;
+
+    private _onDidChange = new EventEmitter<ConfigurationChangeEvent>();
+    get onDidChange(): Event<ConfigurationChangeEvent> {
+        return this._onDidChange.event;
+    }
+
+    constructor() {
+        this.update();
+        this._gReference = new GReference(this._machineType);
+
+        this._dispoable = Disposable.from(workspace.onDidChangeConfiguration(this.onConfigurationChanged, this));
+    }
+
+    dispose() {
+        this._dispoable && this._dispoable.dispose();
+    }
+
+    private onConfigurationChanged(e: ConfigurationChangeEvent) {
+        if (configuration.changed(e, 'general.machineType')) {
+            this.update();
+        } else {
+            return;
+        }
+    }
+
+    private update() {
+        const cfgMachineType = <string>configuration.getParam('general.machineType');
+        Logger.log(`Machine Type: ${cfgMachineType}`);
+        switch (cfgMachineType) {
+            case 'Mill':
+                this._machineType = MachineTypes.Mill;
+                break;
+
+            case 'Lathe':
+                this._machineType = MachineTypes.Lathe;
+                break;
+
+            case '3D Printer':
+                this._machineType = MachineTypes.Printer;
+                break;
+
+            default:
+                return;
+        }
+    }
+
+    get gReference() {
+        return this._gReference;
+    }
+}