@ohif/app 3.13.0-beta.65 → 3.13.0-beta.67

package/dist/{2851.bundle.ffc5656f20a4159d591d.js → 2851.bundle.daa0f5f8bca6492d7033.js}

@@ -2779,14 +2779,12 @@ function resolveConfigFetchPolicy(rawUrl, policy = {}) {
 }
 async function fetchConfigJson(normalizedPolicy) {
   const {
-    normalizedUrl,
-    isAuthenticated,
-    isSameOrigin
+    normalizedUrl
   } = normalizedPolicy;
-  const response = isAuthenticated || isSameOrigin ? await fetch(normalizedUrl) : await fetch(normalizedUrl, {
+  const response = await fetch(normalizedUrl, {
     method: 'GET',
     mode: 'cors',
-    credentials: 'omit',
+    credentials: 'same-origin',
     redirect: 'error',
     referrerPolicy: 'no-referrer'
   });
@@ -10614,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.65";
-  const commitHash = "62620afb9b7d8d0302584f125704509d65ae6a2d";
+  const versionNumber = "3.13.0-beta.67";
+  const commitHash = "691e26731f4f3b3957fe81fc051b09c972696cf6";
   const [main, beta] = versionNumber.split('-');
   return /*#__PURE__*/react.createElement(ui_next_src/* AboutModal */.VTU, {
     className: "w-[400px]"
@@ -10646,16 +10644,49 @@ 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 getToolBindingsStorageKey(customizationService) {
+  const customizationValue = customizationService?.getCustomization('ohif.userPreferences.toolBindingsStorageKey');
+  return typeof customizationValue === 'string' && customizationValue.length > 0 ? customizationValue : DEFAULT_TOOL_BINDINGS_STORAGE_KEY;
+}
+function getToolModifier(toolGroupService, toolGroupId, toolName) {
+  if (!toolGroupService) {
+    return null;
+  }
+  const bindings = toolGroupService.getToolBindings(toolGroupId, toolName);
+  if (!bindings?.length) {
+    return null;
+  }
+  const modifierBinding = bindings.find(binding => 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 customizationService = servicesManager?.services?.customizationService;
+  const toolBindingsStorageKey = getToolBindingsStorageKey(customizationService);
   const {
     hotkeyDefinitions = {},
     hotkeyDefaults = {}
@@ -10672,9 +10703,11 @@ 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'), [toolGroupService]);
   const [state, setState] = (0,react.useState)({
     hotkeyDefinitions: initialHotkeyDefinitions,
-    languageValue: currentLanguage.value
+    languageValue: currentLanguage.value,
+    crosshairModifier: initialCrosshairModifier
   });
   const onLanguageChangeHandler = value => {
     setState(state => ({
@@ -10698,9 +10731,11 @@ function UserPreferencesModalDefault({
     setState(state => ({
       ...state,
       languageValue: defaultLanguage.value,
-      hotkeyDefinitions: resolvedHotkeyDefaults
+      hotkeyDefinitions: resolvedHotkeyDefaults,
+      crosshairModifier: initialCrosshairModifier
     }));
     hotkeysManager.restoreDefaultBindings();
+    localStorage.removeItem(toolBindingsStorageKey);
   };
   const displayNames = react.useMemo(() => {
     if (typeof Intl === 'undefined' || typeof Intl.DisplayNames !== 'function') {
@@ -10757,7 +10792,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: () => {
@@ -10774,6 +10834,19 @@ 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');
+        localStorage.setItem(toolBindingsStorageKey, JSON.stringify({
+          mpr: {
+            Crosshairs: bindings
+          }
+        }));
+      }
       src/* hotkeys */.ot.stopRecord();
       src/* hotkeys */.ot.unpause();
       hide();
@@ -10781,7 +10854,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.c59e61ecef95882924d1.js → 5485.bundle.2149d00e98cfcecb114b.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.bd50b3917b5ee6166971.js → 7166.bundle.04b935471132c7d203f2.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,9 @@ 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();
     /**
      * Service-specific
      */
@@ -18653,11 +18707,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 +18771,7 @@ class ToolGroupService {
   destroy() {
     dist_esm.ToolGroupManager.destroy();
     this.toolGroupIds = new Set();
+    this.toolBindingsMap.clear();
     esm.eventTarget.removeEventListener(dist_esm.Enums.Events.TOOL_ACTIVATED, this._onToolActivated);
   }
   destroyToolGroup(toolGroupId) {
@@ -18769,6 +18826,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 +18866,46 @@ 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, bindings);
+  }
+  applyToolBindings(toolGroupId, toolName) {
+    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) {
+      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 +18918,9 @@ class ToolGroupService {
         toolName,
         bindings
       }) => {
+        if (bindings) {
+          this.setToolBindings(toolGroup.id, toolName, bindings);
+        }
         toolGroup.setToolActive(toolName, {
           bindings
         });
@@ -18827,22 +18928,34 @@ class ToolGroupService {
     }
     if (passive) {
       passive.forEach(({
-        toolName
+        toolName,
+        bindings
       }) => {
+        if (bindings) {
+          this.setToolBindings(toolGroup.id, toolName, bindings);
+        }
         toolGroup.setToolPassive(toolName);
       });
     }
     if (enabled) {
       enabled.forEach(({
-        toolName
+        toolName,
+        bindings
       }) => {
+        if (bindings) {
+          this.setToolBindings(toolGroup.id, toolName, bindings);
+        }
         toolGroup.setToolEnabled(toolName);
       });
     }
     if (disabled) {
       disabled.forEach(({
-        toolName
+        toolName,
+        bindings
       }) => {
+        if (bindings) {
+          this.setToolBindings(toolGroup.id, toolName, bindings);
+        }
         toolGroup.setToolDisabled(toolName);
       });
     }
@@ -18878,6 +18991,28 @@ class ToolGroupService {
       addTools(tools.disabled);
     }
   }
+  _loadPersistedBindings(toolGroupId) {
+    try {
+      const stored = localStorage.getItem(this._getToolBindingsStorageKey());
+      if (!stored) {
+        return;
+      }
+      const parsed = JSON.parse(stored);
+      const toolGroupBindings = parsed[toolGroupId];
+      if (!toolGroupBindings) {
+        return;
+      }
+      for (const [toolName, bindings] of Object.entries(toolGroupBindings)) {
+        this.setToolBindings(toolGroupId, toolName, bindings);
+      }
+    } catch {
+      // ignore corrupt localStorage
+    }
+  }
+  _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.21cdba4cf5309feb8b7d.js → 9927.bundle.e4186f993674729cef10.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: {