added ability to unbind keys in custom bindings config

seung-lab · Dec 21, 2023 · 9efda03 · 9efda03
1 parent 6820a54
commit 9efda03
Show file tree

Hide file tree

Showing 2 changed files with 49 additions and 39 deletions.
diff --git a/config/custom-keybinds.json b/config/custom-keybinds.json
@@ -13,5 +13,6 @@
     "layer": "segmentation",
     "tool": "grapheneFindPath",
     "provider": "graphene"
-  }
+  },
+  "keyx": false
 }
diff --git a/src/neuroglancer/ui/default_viewer_setup.ts b/src/neuroglancer/ui/default_viewer_setup.ts
@@ -14,28 +14,31 @@
  * limitations under the License.
  */
 
+import {layerTypes, UserLayer, UserLayerConstructor} from 'neuroglancer/layer';
 import {StatusMessage} from 'neuroglancer/status';
 import {bindDefaultCopyHandler, bindDefaultPasteHandler} from 'neuroglancer/ui/default_clipboard_handling';
 import {setDefaultInputEventBindings} from 'neuroglancer/ui/default_input_event_bindings';
 import {makeDefaultViewer} from 'neuroglancer/ui/default_viewer';
 import {bindTitle} from 'neuroglancer/ui/title';
+import {restoreTool, Tool} from 'neuroglancer/ui/tool';
 import {UrlHashBinding} from 'neuroglancer/ui/url_hash_binding';
-import {UserLayer, UserLayerConstructor, layerTypes} from 'neuroglancer/layer';
-import {Tool, restoreTool} from 'neuroglancer/ui/tool';
 import {verifyObject, verifyObjectProperty, verifyString} from 'neuroglancer/util/json';
 
 declare var NEUROGLANCER_DEFAULT_STATE_FRAGMENT: string|undefined;
 
 type CustomBinding = {
-  layer: string, tool: unknown, provider?: string,
+  layer: string,
+  tool: unknown,
+  provider?: string,
 }
 
 type CustomBindings = {
   [key: string]: CustomBinding|string
 };
 
 declare const CUSTOM_BINDINGS: CustomBindings|undefined;
-export const hasCustomBindings = typeof CUSTOM_BINDINGS !== 'undefined' && Object.keys(CUSTOM_BINDINGS).length > 0;
+export const hasCustomBindings =
+    typeof CUSTOM_BINDINGS !== 'undefined' && Object.keys(CUSTOM_BINDINGS).length > 0;
 
 /**
  * Sets up the default neuroglancer viewer.
@@ -44,48 +47,54 @@ export function setupDefaultViewer() {
   let viewer = (<any>window)['viewer'] = makeDefaultViewer();
   setDefaultInputEventBindings(viewer.inputEventBindings);
 
-  const bindNonLayerSpecificTool = (obj: unknown, toolKey: string, desiredLayerType: UserLayerConstructor, desiredProvider?: string) => {
-    let previousTool: Tool<Object>|undefined;
-    let previousLayer: UserLayer|undefined;
-    if (typeof obj === 'string') {
-      obj = {'type': obj};
-    }
-    verifyObject(obj);
-    const type = verifyObjectProperty(obj, 'type', verifyString);
-    viewer.bindAction(`tool-${type}`, () => {
-      const acceptableLayers = viewer.layerManager.managedLayers.filter((managedLayer) => {
-        const correctLayerType = managedLayer.layer instanceof desiredLayerType;
-        if (desiredProvider && correctLayerType) {
-          for (const dataSource of managedLayer.layer?.dataSources || []) {
-            const protocol = viewer.dataSourceProvider.getProvider(dataSource.spec.url)[2];
-            if (protocol === desiredProvider) {
-              return true;
-            }
-          }
-          return false;
-        } else {
-          return correctLayerType;
+  const bindNonLayerSpecificTool =
+      (obj: unknown, toolKey: string, desiredLayerType: UserLayerConstructor,
+       desiredProvider?: string) => {
+        let previousTool: Tool<Object>|undefined;
+        let previousLayer: UserLayer|undefined;
+        if (typeof obj === 'string') {
+          obj = {'type': obj};
         }
-      });
-      if (acceptableLayers.length > 0) {
-        const firstLayer = acceptableLayers[0].layer;
-        if (firstLayer) {
-          if (firstLayer !== previousLayer) {
-            previousTool = restoreTool(firstLayer, obj);
-            previousLayer = firstLayer;
-          }
-          if (previousTool) {
-            viewer.activateTool(toolKey, previousTool);
+        verifyObject(obj);
+        const type = verifyObjectProperty(obj, 'type', verifyString);
+        viewer.bindAction(`tool-${type}`, () => {
+          const acceptableLayers = viewer.layerManager.managedLayers.filter((managedLayer) => {
+            const correctLayerType = managedLayer.layer instanceof desiredLayerType;
+            if (desiredProvider && correctLayerType) {
+              for (const dataSource of managedLayer.layer?.dataSources || []) {
+                const protocol = viewer.dataSourceProvider.getProvider(dataSource.spec.url)[2];
+                if (protocol === desiredProvider) {
+                  return true;
+                }
+              }
+              return false;
+            } else {
+              return correctLayerType;
+            }
+          });
+          if (acceptableLayers.length > 0) {
+            const firstLayer = acceptableLayers[0].layer;
+            if (firstLayer) {
+              if (firstLayer !== previousLayer) {
+                previousTool = restoreTool(firstLayer, obj);
+                previousLayer = firstLayer;
+              }
+              if (previousTool) {
+                viewer.activateTool(toolKey, previousTool);
+              }
+            }
           }
-        }
+        });
       }
-    });
-  }
 
   if (hasCustomBindings) {
     for (const [key, val] of Object.entries(CUSTOM_BINDINGS!)) {
       if (typeof val === 'string') {
         viewer.inputEventBindings.global.set(key, val);
+      } else if (typeof val === 'boolean') {
+        if (!val) {
+          viewer.inputEventBindings.global.delete(key);
+        }
       } else {
         viewer.inputEventBindings.global.set(key, `tool-${val.tool}`);
         const layerConstructor = layerTypes.get(val.layer);