@ohif/app 3.13.0-beta.66 → 3.13.0-beta.68

package/dist/{2851.bundle.8757dd07775645121b52.js → 2851.bundle.2f84126ab3178c254a4f.js}

@@ -10612,8 +10612,8 @@ function AboutModalDefault() {
     name
   } = (0,browser_detect_es5/* default */.A)();
   const browser = `${name[0].toUpperCase()}${name.substr(1)} ${version}`;
-  const versionNumber = "3.13.0-beta.66";
-  const commitHash = "468e5734a9ab02516430cc0dab5d7f2106dea950";
+  const versionNumber = "3.13.0-beta.68";
+  const commitHash = "979d619f7ccb426beb75d59721b01c98175d5241";
   const [main, beta] = versionNumber.split('-');
   return /*#__PURE__*/react.createElement(ui_next_src/* AboutModal */.VTU, {
     className: "w-[400px]"
@@ -10644,16 +10644,50 @@ const {
   defaultLanguage,
   currentLanguage: currentLanguageFn
 } = i18n_src/* default */.A;
+const MODIFIER_OPTIONS = [{
+  value: '16',
+  label: 'Shift'
+}, {
+  value: '17',
+  label: 'Ctrl'
+}, {
+  value: '18',
+  label: 'Alt'
+}, {
+  value: '91',
+  label: 'Meta'
+}];
+const DEFAULT_TOOL_BINDINGS_STORAGE_KEY = 'user-preferred-tool-bindings';
+function getToolModifier(toolGroupService, toolGroupId, toolName, mouseButton) {
+  if (!toolGroupService) {
+    return null;
+  }
+  const bindings = toolGroupService.getToolBindings(toolGroupId, toolName);
+  if (!bindings?.length) {
+    return null;
+  }
+  const modifierBinding = bindings.find(binding => binding.mouseButton === mouseButton && binding.modifierKey != null && binding.numTouchPoints == null);
+  return modifierBinding?.modifierKey != null ? String(modifierBinding.modifierKey) : null;
+}
+function getModifierFromBindings(bindings, mouseButton) {
+  if (!bindings?.length) {
+    return null;
+  }
+  const modifierBinding = bindings.find(binding => binding.mouseButton === mouseButton && binding.modifierKey != null && binding.numTouchPoints == null);
+  return modifierBinding?.modifierKey != null ? String(modifierBinding.modifierKey) : null;
+}
 function UserPreferencesModalDefault({
   hide
 }) {
   const {
-    hotkeysManager
+    hotkeysManager,
+    servicesManager
   } = (0,src/* useSystem */.Jg)();
   const {
     t,
     i18n: i18nextInstance
   } = (0,es/* useTranslation */.Bd)('UserPreferencesModal');
+  const toolGroupService = servicesManager?.services?.toolGroupService;
   const {
     hotkeyDefinitions = {},
     hotkeyDefaults = {}
@@ -10670,9 +10704,12 @@ function UserPreferencesModalDefault({
   const resolvedHotkeyDefaults = Object.keys(hotkeyDefaults).length ? hotkeyDefaults : fallbackHotkeyDefinitions;
   const initialHotkeyDefinitions = Object.keys(hotkeyDefinitions).length ? hotkeyDefinitions : resolvedHotkeyDefaults;
   const currentLanguage = currentLanguageFn();
+  const initialCrosshairModifier = (0,react.useMemo)(() => getToolModifier(toolGroupService, 'mpr', 'Crosshairs', 1), [toolGroupService]);
+  const defaultCrosshairBindings = (0,react.useMemo)(() => toolGroupService?.getDefaultToolBindings?.('mpr', 'Crosshairs'), [toolGroupService]);
   const [state, setState] = (0,react.useState)({
     hotkeyDefinitions: initialHotkeyDefinitions,
-    languageValue: currentLanguage.value
+    languageValue: currentLanguage.value,
+    crosshairModifier: initialCrosshairModifier
   });
   const onLanguageChangeHandler = value => {
     setState(state => ({
@@ -10696,9 +10733,17 @@ function UserPreferencesModalDefault({
     setState(state => ({
       ...state,
       languageValue: defaultLanguage.value,
-      hotkeyDefinitions: resolvedHotkeyDefaults
+      hotkeyDefinitions: resolvedHotkeyDefaults,
+      crosshairModifier: getModifierFromBindings(defaultCrosshairBindings, 1)
     }));
     hotkeysManager.restoreDefaultBindings();
+    if (toolGroupService && defaultCrosshairBindings?.length) {
+      toolGroupService.setToolBindings('mpr', 'Crosshairs', defaultCrosshairBindings);
+      toolGroupService.applyToolBindings('mpr', 'Crosshairs', {
+        replaceExisting: true
+      });
+    }
+    toolGroupService?.removePersistedToolBindings('mpr', 'Crosshairs');
   };
   const displayNames = react.useMemo(() => {
     if (typeof Intl === 'undefined' || typeof Intl.DisplayNames !== 'function') {
@@ -10755,7 +10800,32 @@ function UserPreferencesModalDefault({
     onChange: newKeys => onHotkeyChangeHandler(id, newKeys),
     placeholder: definition.keys,
     hotkeys: src/* hotkeys */.ot
-  })))), /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu, null, /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu.Left, null, /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu.Auxiliary, {
+  }))), state.crosshairModifier != null && /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(ui_next_src/* UserPreferencesModal */.xMy.SubHeading, null, t('ModifierKeys', {
+    defaultValue: 'Modifier Keys'
+  })), /*#__PURE__*/react.createElement(ui_next_src/* UserPreferencesModal */.xMy.HotkeysGrid, null, /*#__PURE__*/react.createElement("div", {
+    className: "flex items-center justify-between gap-2"
+  }, /*#__PURE__*/react.createElement("span", {
+    className: "text-foreground text-base"
+  }, t('CrosshairsModifier', {
+    defaultValue: 'Crosshairs'
+  })), /*#__PURE__*/react.createElement("div", {
+    className: "flex items-center gap-1.5"
+  }, /*#__PURE__*/react.createElement("span", {
+    className: "text-muted-foreground text-sm"
+  }, t('PlusLeftClick', {
+    defaultValue: 'Left Click +'
+  })), /*#__PURE__*/react.createElement(ui_next_src/* Select */.l6P, {
+    value: state.crosshairModifier,
+    onValueChange: val => setState(s => ({
+      ...s,
+      crosshairModifier: val
+    }))
+  }, /*#__PURE__*/react.createElement(ui_next_src/* SelectTrigger */.bqE, {
+    className: "w-16"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* SelectValue */.yvm, null)), /*#__PURE__*/react.createElement(ui_next_src/* SelectContent */.gCo, null, MODIFIER_OPTIONS.map(opt => /*#__PURE__*/react.createElement(ui_next_src/* SelectItem */.ebT, {
+    key: opt.value,
+    value: opt.value
+  }, opt.label))))))))), /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu, null, /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu.Left, null, /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu.Auxiliary, {
     onClick: onResetHandler
   }, t('Reset to defaults'))), /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu.Right, null, /*#__PURE__*/react.createElement(ui_next_src/* FooterAction */.esu.Secondary, {
     onClick: () => {
@@ -10772,6 +10842,17 @@ function UserPreferencesModalDefault({
         return; // Exit early since we're reloading
       }
       hotkeysManager.setHotkeys(state.hotkeyDefinitions);
+      if (toolGroupService && state.crosshairModifier != null) {
+        const bindings = [{
+          mouseButton: 1,
+          modifierKey: Number(state.crosshairModifier)
+        }];
+        toolGroupService.setToolBindings('mpr', 'Crosshairs', bindings);
+        toolGroupService.applyToolBindings('mpr', 'Crosshairs', {
+          replaceExisting: true
+        });
+        toolGroupService.persistToolBindings('mpr', 'Crosshairs', bindings);
+      }
       src/* hotkeys */.ot.stopRecord();
       src/* hotkeys */.ot.unpause();
       hide();
@@ -10779,7 +10860,8 @@ function UserPreferencesModalDefault({
   }, t('Save')))));
 }
 /* harmony default export */ const userPreferencesCustomization = ({
-  'ohif.userPreferencesModal': UserPreferencesModalDefault
+  'ohif.userPreferencesModal': UserPreferencesModalDefault,
+  'ohif.userPreferences.toolBindingsStorageKey': DEFAULT_TOOL_BINDINGS_STORAGE_KEY
 });
 ;// ../../../extensions/default/src/customizations/reportDialogCustomization.tsx
 

package/dist/{5485.bundle.adc11bc68e91358ea7bf.js → 5485.bundle.b2de6b5aee00e1366dbf.js}

@@ -295,6 +295,10 @@ function initMPRToolGroup(extensionManager, toolGroupService, commandsManager) {
     }],
     disabled: [{
       toolName: toolNames.Crosshairs,
+      bindings: [{
+        mouseButton: Enums.MouseBindings.Primary,
+        modifierKey: Enums.KeyboardBindings.Shift
+      }],
       configuration: {
         viewportIndicators: true,
         viewportIndicatorsConfig: {
@@ -302,7 +306,6 @@ function initMPRToolGroup(extensionManager, toolGroupService, commandsManager) {
           xOffset: 0.95,
           yOffset: 0.05
         },
-        disableOnPassive: true,
         autoPan: {
           enabled: false,
           panSize: 10
@@ -921,15 +924,18 @@ const toolbarButtons = [
     type: 'tool',
     icon: 'tool-crosshair',
     label: i18next/* default */.A.t('Buttons:Crosshairs'),
+    tooltip: i18next/* default */.A.t('Buttons:Click to toggle on or off'),
     commands: {
-      commandName: 'setToolActiveToolbar',
+      commandName: 'toggleActiveDisabledToolbar',
       commandOptions: {
         toolGroupIds: ['mpr']
       }
     },
     evaluate: {
-      name: 'evaluate.cornerstoneTool',
-      disabledText: i18next/* default */.A.t('Buttons:Select an MPR viewport to enable this tool')
+      name: 'evaluate.cornerstoneTool.toggleWithModifier',
+      disabledText: i18next/* default */.A.t('Buttons:Select an MPR viewport to enable this tool'),
+      toggledOnIcon: 'tool-crosshair-checked',
+      defaultIcon: 'tool-crosshair'
     }
   }
 }, {

package/dist/{7166.bundle.12ada8e535973df9c8fd.js → 7166.bundle.a446247d3420500ebf08.js}

@@ -10577,7 +10577,14 @@ function commandsModule({
   }
   function _getActiveViewportToolGroupId() {
     const viewport = _getActiveViewportEnabledElement();
-    return toolGroupService.getToolGroupForViewport(viewport.id);
+    const toolGroup = viewport && toolGroupService.getToolGroupForViewport(viewport.id);
+    return toolGroup?.id;
+  }
+  function _usesPrimaryActivation(bindings) {
+    if (!bindings?.length) {
+      return true;
+    }
+    return bindings.some(binding => binding.mouseButton === dist_esm.Enums.MouseBindings.Primary && binding.modifierKey == null && binding.numTouchPoints == null);
   }
   function _getActiveSegmentationInfo() {
     const viewportId = viewportGridService.getActiveViewportId();
@@ -11444,31 +11451,46 @@ function commandsModule({
     toggleActiveDisabledToolbar({
       value,
       itemId,
-      toolGroupId
+      toolGroupId,
+      toolGroupIds
     }) {
       const toolName = itemId || value;
-      toolGroupId = toolGroupId ?? _getActiveViewportToolGroupId();
-      const toolGroup = toolGroupService.getToolGroup(toolGroupId);
-      if (!toolGroup || !toolGroup.hasTool(toolName)) {
-        return;
-      }
-      const toolIsActive = [dist_esm.Enums.ToolModes.Active, dist_esm.Enums.ToolModes.Enabled, dist_esm.Enums.ToolModes.Passive].includes(toolGroup.getToolOptions(toolName).mode);
-      toolIsActive ? toolGroup.setToolDisabled(toolName) : actions.setToolActive({
-        toolName,
-        toolGroupId
-      });
-
-      // we should set the previously active tool to active after we set the
-      // current tool disabled
-      if (toolIsActive) {
-        const prevToolName = toolGroup.getPrevActivePrimaryToolName();
-        if (prevToolName !== toolName) {
+      const resolvedToolGroupIds = toolGroupIds?.length ? toolGroupIds : [toolGroupId ?? _getActiveViewportToolGroupId()];
+      resolvedToolGroupIds.forEach(toolGroupId => {
+        const toolGroup = toolGroupService.getToolGroup(toolGroupId);
+        if (!toolGroup || !toolGroup.hasTool(toolName)) {
+          return;
+        }
+        const toolIsActive = [dist_esm.Enums.ToolModes.Active, dist_esm.Enums.ToolModes.Enabled, dist_esm.Enums.ToolModes.Passive].includes(toolGroup.getToolOptions(toolName).mode);
+        if (toolIsActive) {
+          toolGroup.setToolDisabled(toolName);
+          const bindings = toolGroupService.getToolBindings(toolGroupId, toolName);
+          if (_usesPrimaryActivation(bindings)) {
+            // we should set the previously active tool to active after we set the
+            // current tool disabled
+            const prevToolName = toolGroup.getPrevActivePrimaryToolName();
+            if (prevToolName !== toolName) {
+              actions.setToolActive({
+                toolName: prevToolName,
+                toolGroupId
+              });
+            }
+          }
+          return;
+        }
+        const bindings = toolGroupService.getToolBindings(toolGroupId, toolName);
+        if (_usesPrimaryActivation(bindings)) {
           actions.setToolActive({
-            toolName: prevToolName,
-            toolGroupId
+            toolName,
+            toolGroupId,
+            bindings
+          });
+        } else {
+          toolGroup.setToolActive(toolName, {
+            bindings
           });
         }
-      }
+      });
     },
     setToolActiveToolbar: ({
       value,
@@ -18475,6 +18497,36 @@ function getToolbarModule({
         isActive: isPrimaryActive
       };
     }
+  }, {
+    name: 'evaluate.cornerstoneTool.toggleWithModifier',
+    evaluate: ({
+      viewportId,
+      button,
+      disabledText,
+      toggledOnIcon,
+      defaultIcon
+    }) => {
+      const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
+      if (!toolGroup) {
+        return;
+      }
+      const toolName = toolbarService.getToolNameForButton(button);
+      if (!toolGroup.hasTool(toolName)) {
+        return getDisabledState(disabledText);
+      }
+      const {
+        mode
+      } = toolGroup.getToolOptions(toolName) ?? {};
+      const isToggled = mode === dist_esm.Enums.ToolModes.Passive || mode === dist_esm.Enums.ToolModes.Active || mode === dist_esm.Enums.ToolModes.Enabled;
+      const toolBindings = toolGroupService.getToolBindings(toolGroup.id, toolName);
+      const hasModifierKey = toolBindings?.some(binding => binding.modifierKey != null) ?? false;
+      return {
+        disabled: false,
+        isActive: false,
+        isToggled,
+        icon: isToggled && hasModifierKey && toggledOnIcon ? toggledOnIcon : defaultIcon ?? button.props.icon
+      };
+    }
   }, {
     name: 'evaluate.action',
     evaluate: () => {
@@ -18627,7 +18679,10 @@ class ToolGroupService {
     this.cornerstoneViewportService = void 0;
     this.viewportGridService = void 0;
     this.uiNotificationService = void 0;
+    this.customizationService = void 0;
     this.toolGroupIds = new Set();
+    this.toolBindingsMap = new Map();
+    this.defaultToolBindingsMap = new Map();
     /**
      * Service-specific
      */
@@ -18653,11 +18708,13 @@ class ToolGroupService {
     const {
       cornerstoneViewportService,
       viewportGridService,
-      uiNotificationService
+      uiNotificationService,
+      customizationService
     } = servicesManager.services;
     this.cornerstoneViewportService = cornerstoneViewportService;
     this.viewportGridService = viewportGridService;
     this.uiNotificationService = uiNotificationService;
+    this.customizationService = customizationService;
     this.listeners = {};
     this.EVENTS = ToolGroupService_EVENTS;
     Object.assign(this, src/* pubSubServiceInterface */.Ml);
@@ -18715,6 +18772,8 @@ class ToolGroupService {
   destroy() {
     dist_esm.ToolGroupManager.destroy();
     this.toolGroupIds = new Set();
+    this.toolBindingsMap.clear();
+    this.defaultToolBindingsMap.clear();
     esm.eventTarget.removeEventListener(dist_esm.Enums.Events.TOOL_ACTIVATED, this._onToolActivated);
   }
   destroyToolGroup(toolGroupId) {
@@ -18769,6 +18828,7 @@ class ToolGroupService {
     // this.changeConfigurationIfNecessary(toolGroup, volumeId);
     this._addTools(toolGroup, tools, configs);
     this._setToolsMode(toolGroup, tools);
+    this._loadPersistedBindings(toolGroupId);
   }
   createToolGroupAndAddTools(toolGroupId, tools) {
     const toolGroup = this.createToolGroup(toolGroupId);
@@ -18808,6 +18868,84 @@ class ToolGroupService {
   getActivePrimaryMouseButtonTool(toolGroupId) {
     return this.getToolGroup(toolGroupId)?.getActivePrimaryMouseButtonTool();
   }
+  getToolBindings(toolGroupId, toolName) {
+    return this.toolBindingsMap.get(toolGroupId)?.get(toolName);
+  }
+  setToolBindings(toolGroupId, toolName, bindings) {
+    if (!this.toolBindingsMap.has(toolGroupId)) {
+      this.toolBindingsMap.set(toolGroupId, new Map());
+    }
+    this.toolBindingsMap.get(toolGroupId).set(toolName, this._cloneToolBindings(bindings));
+  }
+  getDefaultToolBindings(toolGroupId, toolName) {
+    const defaultBindings = this.defaultToolBindingsMap.get(toolGroupId)?.get(toolName);
+    return defaultBindings ? this._cloneToolBindings(defaultBindings) : undefined;
+  }
+  persistToolBindings(toolGroupId, toolName, bindings) {
+    const persistedBindings = this._readPersistedToolBindings();
+    if (!persistedBindings[toolGroupId]) {
+      persistedBindings[toolGroupId] = {};
+    }
+    persistedBindings[toolGroupId][toolName] = bindings;
+    this._writePersistedToolBindings(persistedBindings);
+  }
+  removePersistedToolBindings(toolGroupId, toolName) {
+    const persistedBindings = this._readPersistedToolBindings();
+    if (!persistedBindings[toolGroupId]) {
+      return;
+    }
+    if (toolName) {
+      delete persistedBindings[toolGroupId][toolName];
+      if (!Object.keys(persistedBindings[toolGroupId]).length) {
+        delete persistedBindings[toolGroupId];
+      }
+    } else {
+      delete persistedBindings[toolGroupId];
+    }
+    this._writePersistedToolBindings(persistedBindings);
+  }
+
+  /**
+   * Applies the currently tracked bindings to the runtime tool instance.
+   *
+   * Note: this method may activate tools that are currently Passive or Enabled.
+   * Assigning bindings is treated as making the tool interactable.
+   */
+  applyToolBindings(toolGroupId, toolName, options = {}) {
+    const toolGroup = dist_esm.ToolGroupManager.getToolGroup(toolGroupId);
+    if (!toolGroup || !toolGroup.hasTool(toolName)) {
+      return;
+    }
+    const bindings = this.getToolBindings(toolGroupId, toolName);
+    if (!bindings) {
+      return;
+    }
+    const {
+      mode
+    } = toolGroup.getToolOptions(toolName);
+    if (mode === dist_esm.Enums.ToolModes.Active || mode === dist_esm.Enums.ToolModes.Passive || mode === dist_esm.Enums.ToolModes.Enabled) {
+      if (options.replaceExisting) {
+        // Opt-in behavior for callers that need replacement semantics.
+        toolGroup.setToolDisabled(toolName);
+      }
+      toolGroup.setToolActive(toolName, {
+        bindings
+      });
+    }
+  }
+  getAllToolBindings() {
+    const result = [];
+    for (const [toolGroupId, toolMap] of this.toolBindingsMap) {
+      for (const [toolName, bindings] of toolMap) {
+        result.push({
+          toolGroupId,
+          toolName,
+          bindings
+        });
+      }
+    }
+    return result;
+  }
   _setToolsMode(toolGroup, tools) {
     const {
       active,
@@ -18820,6 +18958,10 @@ class ToolGroupService {
         toolName,
         bindings
       }) => {
+        if (bindings) {
+          this.setToolBindings(toolGroup.id, toolName, bindings);
+          this._setDefaultToolBindingsIfMissing(toolGroup.id, toolName, bindings);
+        }
         toolGroup.setToolActive(toolName, {
           bindings
         });
@@ -18827,26 +18969,50 @@ class ToolGroupService {
     }
     if (passive) {
       passive.forEach(({
-        toolName
+        toolName,
+        bindings
       }) => {
+        if (bindings) {
+          this.setToolBindings(toolGroup.id, toolName, bindings);
+          this._setDefaultToolBindingsIfMissing(toolGroup.id, toolName, bindings);
+        }
         toolGroup.setToolPassive(toolName);
       });
     }
     if (enabled) {
       enabled.forEach(({
-        toolName
+        toolName,
+        bindings
       }) => {
+        if (bindings) {
+          this.setToolBindings(toolGroup.id, toolName, bindings);
+          this._setDefaultToolBindingsIfMissing(toolGroup.id, toolName, bindings);
+        }
         toolGroup.setToolEnabled(toolName);
       });
     }
     if (disabled) {
       disabled.forEach(({
-        toolName
+        toolName,
+        bindings
       }) => {
+        if (bindings) {
+          this.setToolBindings(toolGroup.id, toolName, bindings);
+          this._setDefaultToolBindingsIfMissing(toolGroup.id, toolName, bindings);
+        }
         toolGroup.setToolDisabled(toolName);
       });
     }
   }
+  _setDefaultToolBindingsIfMissing(toolGroupId, toolName, bindings) {
+    if (!this.defaultToolBindingsMap.has(toolGroupId)) {
+      this.defaultToolBindingsMap.set(toolGroupId, new Map());
+    }
+    const toolMap = this.defaultToolBindingsMap.get(toolGroupId);
+    if (!toolMap.has(toolName)) {
+      toolMap.set(toolName, this._cloneToolBindings(bindings));
+    }
+  }
   _addTools(toolGroup, tools) {
     const addTools = tools => {
       tools.forEach(({
@@ -18878,6 +19044,60 @@ class ToolGroupService {
       addTools(tools.disabled);
     }
   }
+  _loadPersistedBindings(toolGroupId) {
+    const toolGroupBindings = this._readPersistedToolBindings()[toolGroupId];
+    if (!toolGroupBindings) {
+      return;
+    }
+    const toolGroup = dist_esm.ToolGroupManager.getToolGroup(toolGroupId);
+    for (const [toolName, bindings] of Object.entries(toolGroupBindings)) {
+      this.setToolBindings(toolGroupId, toolName, bindings);
+      if (!toolGroup || !toolGroup.hasTool(toolName)) {
+        continue;
+      }
+      const {
+        mode
+      } = toolGroup.getToolOptions(toolName);
+      if (mode === dist_esm.Enums.ToolModes.Active) {
+        this.applyToolBindings(toolGroupId, toolName, {
+          replaceExisting: true
+        });
+      }
+    }
+  }
+  _readPersistedToolBindings() {
+    try {
+      const stored = localStorage.getItem(this._getToolBindingsStorageKey());
+      if (!stored) {
+        return {};
+      }
+      const parsed = JSON.parse(stored);
+      if (!parsed || typeof parsed !== 'object') {
+        return {};
+      }
+      return parsed;
+    } catch {
+      // ignore corrupt localStorage
+      return {};
+    }
+  }
+  _writePersistedToolBindings(bindings) {
+    const storageKey = this._getToolBindingsStorageKey();
+    if (!Object.keys(bindings).length) {
+      localStorage.removeItem(storageKey);
+      return;
+    }
+    localStorage.setItem(storageKey, JSON.stringify(bindings));
+  }
+  _cloneToolBindings(bindings) {
+    return bindings.map(binding => ({
+      ...binding
+    }));
+  }
+  _getToolBindingsStorageKey() {
+    const customizationValue = this.customizationService?.getCustomization('ohif.userPreferences.toolBindingsStorageKey');
+    return typeof customizationValue === 'string' && customizationValue.length > 0 ? customizationValue : 'user-preferred-tool-bindings';
+  }
 }
 _ToolGroupService = ToolGroupService;
 ToolGroupService.REGISTRATION = {

package/dist/{9927.bundle.c2acd65fc6ae5ee07148.js → 9927.bundle.57766e5471d115426d9f.js}

@@ -157,6 +157,10 @@ function _initToolGroups(toolNames, Enums, toolGroupService, commandsManager) {
     enabled: [],
     disabled: [{
       toolName: toolNames.Crosshairs,
+      bindings: [{
+        mouseButton: Enums.MouseBindings.Primary,
+        modifierKey: Enums.KeyboardBindings.Shift
+      }],
       configuration: {
         disableOnPassive: true,
         autoPan: {