@kitware/vtk.js 25.8.1 → 25.8.3

package/Rendering/OpenGL/HardwareSelector.js

@@ -38,16 +38,10 @@ function convert(xx, yy, pb, area) {
   }
 
   var offset = (yy * (area[2] - area[0] + 1) + xx) * 4;
-  var rgb = [];
-  rgb[0] = pb[offset];
-  rgb[1] = pb[offset + 1];
-  rgb[2] = pb[offset + 2];
-  var val = rgb[2];
-  val *= 256;
-  val += rgb[1];
-  val *= 256;
-  val += rgb[0];
-  return val;
+  var r = pb[offset];
+  var g = pb[offset + 1];
+  var b = pb[offset + 2];
+  return (b * 256 + g) * 256 + r;
 }
 
 function getID(low24, high8) {

package/Rendering/OpenGL/RenderWindow.js

@@ -520,7 +520,8 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
 
     if (result !== undefined) {
       publicAPI.getTextureUnitManager().free(result);
-      delete model._textureResourceIds.delete(texture);
+
+      model._textureResourceIds.delete(texture);
     }
   };
 

package/Widgets/Core/WidgetManager.js

@@ -271,47 +271,59 @@ function vtkWidgetManager(publicAPI, model) {
   // --------------------------------------------------------------------------
 
 
-  function updateSelection(_x) {
+  function updateSelection(_x, _x2, _x3) {
     return _updateSelection.apply(this, arguments);
   }
 
   function _updateSelection() {
-    _updateSelection = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref) {
-      var position, _yield$publicAPI$getS, requestCount, selectedState, representation, widget, i, w;
+    _updateSelection = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(callData, fromTouchEvent, callID) {
+      var position, _yield$publicAPI$getS, requestCount, selectedState, representation, widget, activateHandle, i, w;
 
-      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
-              position = _ref.position;
-              model._selectionInProgress = true;
-              _context2.next = 4;
+              activateHandle = function _activateHandle(w) {
+                if (fromTouchEvent) {
+                  // release any previous left button interaction
+                  model._interactor.invokeLeftButtonRelease(callData);
+                }
+
+                w.activateHandle({
+                  selectedState: selectedState,
+                  representation: representation
+                });
+
+                if (fromTouchEvent) {
+                  // re-trigger the left button press to pick the now-active widget
+                  model._interactor.invokeLeftButtonPress(callData);
+                }
+              };
+
+              position = callData.position;
+              _context3.next = 4;
               return publicAPI.getSelectedDataForXY(position.x, position.y);
 
             case 4:
-              _yield$publicAPI$getS = _context2.sent;
+              _yield$publicAPI$getS = _context3.sent;
               requestCount = _yield$publicAPI$getS.requestCount;
               selectedState = _yield$publicAPI$getS.selectedState;
               representation = _yield$publicAPI$getS.representation;
               widget = _yield$publicAPI$getS.widget;
-              model._selectionInProgress = false;
 
-              if (!requestCount) {
-                _context2.next = 12;
+              if (!(requestCount || callID !== model._currentUpdateSelectionCallID)) {
+                _context3.next = 11;
                 break;
               }
 
-              return _context2.abrupt("return");
+              return _context3.abrupt("return");
 
-            case 12:
+            case 11:
               // Default cursor behavior
               model._apiSpecificRenderWindow.setCursor(widget ? 'pointer' : 'default');
 
               if (model.widgetInFocus === widget && widget.hasFocus()) {
-                widget.activateHandle({
-                  selectedState: selectedState,
-                  representation: representation
-                }); // Ken FIXME
+                activateHandle(widget); // Ken FIXME
 
                 model._interactor.render();
 
@@ -321,10 +333,7 @@ function vtkWidgetManager(publicAPI, model) {
                   w = model.widgets[i];
 
                   if (w === widget && w.getNestedPickable()) {
-                    w.activateHandle({
-                      selectedState: selectedState,
-                      representation: representation
-                    });
+                    activateHandle(w);
                     model.activeWidget = w;
                   } else {
                     w.deactivateAllHandles();
@@ -337,43 +346,49 @@ function vtkWidgetManager(publicAPI, model) {
                 model._interactor.render();
               }
 
-            case 14:
+            case 13:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
         }
-      }, _callee2);
+      }, _callee3);
     }));
     return _updateSelection.apply(this, arguments);
   }
 
-  var handleEvent = function handleEvent(eventName) {
-    var guard = false;
-    return function (callData) {
-      if (guard || model.isAnimating || !model.pickingEnabled || model._selectionInProgress) {
-        return macro.VOID;
-      }
+  var handleEvent = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(callData) {
+      var fromTouchEvent,
+          callID,
+          _args = arguments;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              fromTouchEvent = _args.length > 1 && _args[1] !== undefined ? _args[1] : false;
 
-      var updatePromise = updateSelection(callData);
-      macro.measurePromiseExecution(updatePromise, function (elapsed) {
-        // 100ms is deemed fast enough. Anything higher can degrade usability.
-        if (elapsed > 100) {
-          macro.vtkWarningMacro("vtkWidgetManager updateSelection() took ".concat(elapsed, "ms on ").concat(eventName));
-        }
-      });
-      updatePromise.then(function () {
-        if (model._interactor) {
-          // re-trigger the event, ignoring our own handler
-          guard = true;
+              if (!(!model.isAnimating && model.pickingEnabled)) {
+                _context.next = 6;
+                break;
+              }
 
-          model._interactor["invoke".concat(eventName)](callData);
+              callID = Symbol('UpdateSelection');
+              model._currentUpdateSelectionCallID = callID;
+              _context.next = 6;
+              return updateSelection(callData, fromTouchEvent, callID);
 
-          guard = false;
+            case 6:
+            case "end":
+              return _context.stop();
+          }
         }
-      });
-      return macro.EVENT_ABORT;
+      }, _callee);
+    }));
+
+    return function handleEvent(_x4) {
+      return _ref.apply(this, arguments);
     };
-  };
+  }();
 
   function updateWidgetForRender(w) {
     w.updateRepresentationForRender(model.renderingType);
@@ -389,42 +404,42 @@ function vtkWidgetManager(publicAPI, model) {
     model.widgets.forEach(updateWidgetForRender);
   }
 
-  function captureBuffers(_x2, _x3, _x4, _x5) {
+  function captureBuffers(_x5, _x6, _x7, _x8) {
     return _captureBuffers.apply(this, arguments);
   }
 
   function _captureBuffers() {
-    _captureBuffers = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(x1, y1, x2, y2) {
-      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+    _captureBuffers = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(x1, y1, x2, y2) {
+      return _regeneratorRuntime.wrap(function _callee4$(_context4) {
         while (1) {
-          switch (_context3.prev = _context3.next) {
+          switch (_context4.prev = _context4.next) {
             case 0:
               if (!model._captureInProgress) {
-                _context3.next = 2;
+                _context4.next = 2;
                 break;
               }
 
-              return _context3.abrupt("return");
+              return _context4.abrupt("return");
 
             case 2:
               model._captureInProgress = true;
               renderPickingBuffer();
               model._capturedBuffers = null;
-              _context3.next = 7;
+              _context4.next = 7;
               return model._selector.getSourceDataAsync(model._renderer, x1, y1, x2, y2);
 
             case 7:
-              model._capturedBuffers = _context3.sent;
+              model._capturedBuffers = _context4.sent;
               model.previousSelectedData = null;
               renderFrontBuffer();
               model._captureInProgress = false;
 
             case 11:
             case "end":
-              return _context3.stop();
+              return _context4.stop();
           }
         }
-      }, _callee3);
+      }, _callee4);
     }));
     return _captureBuffers.apply(this, arguments);
   }
@@ -480,9 +495,21 @@ function vtkWidgetManager(publicAPI, model) {
       model.isAnimating = false;
       publicAPI.renderWidgets();
     }));
-    subscriptions.push(model._interactor.onMouseMove(handleEvent('MouseMove')));
-    subscriptions.push(model._interactor.onLeftButtonPress(handleEvent('LeftButtonPress'), // stay after widgets, but before default of 0
-    WIDGET_PRIORITY / 2));
+    subscriptions.push(model._interactor.onMouseMove(function (eventData) {
+      handleEvent(eventData);
+      return macro.VOID;
+    })); // must be handled after widgets, hence the given priority.
+
+    subscriptions.push(model._interactor.onLeftButtonPress(function (eventData) {
+      var deviceType = eventData.deviceType;
+      var touchEvent = deviceType === 'touch' || deviceType === 'pen'; // only try selection if the left button press is from touch.
+
+      if (touchEvent) {
+        handleEvent(eventData, touchEvent);
+      }
+
+      return macro.VOID;
+    }, WIDGET_PRIORITY / 2));
     publicAPI.modified();
 
     if (model.pickingEnabled) {
@@ -564,16 +591,16 @@ function vtkWidgetManager(publicAPI, model) {
   };
 
   publicAPI.getSelectedDataForXY = /*#__PURE__*/function () {
-    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(x, y) {
+    var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(x, y) {
       var i, widget, hoveredSVGReps, selection, capturedRegion;
-      return _regeneratorRuntime.wrap(function _callee$(_context) {
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
         while (1) {
-          switch (_context.prev = _context.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
               model.selections = null;
 
               if (!model.pickingEnabled) {
-                _context.next = 24;
+                _context2.next = 24;
                 break;
               }
 
@@ -581,7 +608,7 @@ function vtkWidgetManager(publicAPI, model) {
 
             case 3:
               if (!(i < model.widgets.length)) {
-                _context.next = 16;
+                _context2.next = 16;
                 break;
               }
 
@@ -591,7 +618,7 @@ function vtkWidgetManager(publicAPI, model) {
               });
 
               if (!hoveredSVGReps.length) {
-                _context.next = 13;
+                _context2.next = 13;
                 break;
               }
 
@@ -600,20 +627,20 @@ function vtkWidgetManager(publicAPI, model) {
               selection.getProperties().widget = widget;
               selection.getProperties().representation = hoveredSVGReps[0];
               model.selections = [selection];
-              return _context.abrupt("return", publicAPI.getSelectedData());
+              return _context2.abrupt("return", publicAPI.getSelectedData());
 
             case 13:
               ++i;
-              _context.next = 3;
+              _context2.next = 3;
               break;
 
             case 16:
               if (!(!model._capturedBuffers || model.captureOn === CaptureOn.MOUSE_MOVE)) {
-                _context.next = 19;
+                _context2.next = 19;
                 break;
               }
 
-              _context.next = 19;
+              _context2.next = 19;
               return captureBuffers(x, y, x, y);
 
             case 19:
@@ -621,28 +648,28 @@ function vtkWidgetManager(publicAPI, model) {
               capturedRegion = model._capturedBuffers.area;
 
               if (!(x < capturedRegion[0] || x > capturedRegion[2] || y < capturedRegion[1] || y > capturedRegion[3])) {
-                _context.next = 23;
+                _context2.next = 23;
                 break;
               }
 
-              _context.next = 23;
+              _context2.next = 23;
               return captureBuffers(x, y, x, y);
 
             case 23:
               model.selections = model._capturedBuffers.generateSelection(x, y, x, y);
 
             case 24:
-              return _context.abrupt("return", publicAPI.getSelectedData());
+              return _context2.abrupt("return", publicAPI.getSelectedData());
 
             case 25:
             case "end":
-              return _context.stop();
+              return _context2.stop();
           }
         }
-      }, _callee);
+      }, _callee2);
     }));
 
-    return function (_x6, _x7) {
+    return function (_x9, _x10) {
       return _ref2.apply(this, arguments);
     };
   }();
@@ -791,6 +818,7 @@ function vtkWidgetManager(publicAPI, model) {
 var DEFAULT_VALUES = {
   // _camera: null,
   // _selector: null,
+  // _currentUpdateSelectionCallID: null,
   viewId: null,
   widgets: [],
   renderer: null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "25.8.1",
+  "version": "25.8.3",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",