MoleditPy-linux 4.3.1__tar.gz → 4.3.2__tar.gz

{moleditpy_linux-4.3.1 → moleditpy_linux-4.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.3.1
+Version: 4.3.2
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy_linux-4.3.1 → moleditpy_linux-4.3.2}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "MoleditPy-linux"
 
-version = "4.3.1"
+version = "4.3.2"
 
 license = {file = "LICENSE"}
 

{moleditpy_linux-4.3.1 → moleditpy_linux-4.3.2}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.3.1
+Version: 4.3.2
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE

{moleditpy_linux-4.3.1 → moleditpy_linux-4.3.2}/src/moleditpy_linux/ui/custom_interactor_style.py

@@ -159,9 +159,8 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                             try:
                                 move_group_dialog.on_atom_picked(clicked_atom_idx)
                             except (AttributeError, RuntimeError):
-                                # Safe defensive fallback catching AttributeError, RuntimeError
-                                logging.debug(
-                                    "Suppressed non-critical error", exc_info=True
+                                logging.warning(
+                                    "Move-dialog atom toggle failed", exc_info=True
                                 )
 
                         QTimer.singleShot(0, _deferred_toggle)
@@ -273,9 +272,8 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                                         closest_atom_idx
                                     )
                                 except (AttributeError, RuntimeError):
-                                    # Safe defensive fallback catching AttributeError, RuntimeError
-                                    logging.debug(
-                                        "Suppressed non-critical error", exc_info=True
+                                    logging.warning(
+                                        "Measurement selection failed", exc_info=True
                                     )
 
                             QTimer.singleShot(0, _deferred_measure)
@@ -383,6 +381,54 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         # Standard right-click
         super().OnRightButtonDown()
 
+    def _heal_stuck_pointer_state(self, move_group_dialog: Any) -> None:
+        """Self-heal drag/rotate state whose release event was lost.
+
+        A release can be lost mid-gesture (e.g. pyvista temporarily swapping
+        the interactor style, a dialog grabbing events), leaving this style or
+        a Move Group dialog in a permanent drag/rotate state that blocks
+        interaction. Verify against the real button state on every move and
+        reset when the button is not actually held.
+        """
+        try:
+            buttons = QApplication.mouseButtons()
+            left_held = bool(buttons & Qt.MouseButton.LeftButton)
+            right_held = bool(buttons & Qt.MouseButton.RightButton)
+            any_held = buttons != Qt.MouseButton.NoButton
+        except (AttributeError, RuntimeError, TypeError):
+            return
+
+        if self._is_dragging_atom and not left_held:
+            self.reset_interactor_state()
+
+        if not any_held:
+            try:
+                if self.GetState() != 0:  # stuck ROTATE/PAN/etc. without a button
+                    self.reset_interactor_state()
+            except (AttributeError, RuntimeError, TypeError):
+                # Safe defensive fallback catching AttributeError, RuntimeError, TypeError
+                logging.debug("Suppressed non-critical error", exc_info=True)
+
+        if move_group_dialog is not None:
+            try:
+                if (
+                    getattr(move_group_dialog, "is_dragging_group_vtk", False)
+                    and not left_held
+                ):
+                    move_group_dialog.is_dragging_group_vtk = False
+                    move_group_dialog.drag_start_pos_vtk = None
+                    move_group_dialog.mouse_moved_vtk = False
+                if (
+                    getattr(move_group_dialog, "is_rotating_group_vtk", False)
+                    and not right_held
+                ):
+                    move_group_dialog.is_rotating_group_vtk = False
+                    move_group_dialog.rotation_start_pos = None
+                    move_group_dialog.rotation_mouse_moved = False
+            except (AttributeError, RuntimeError, TypeError):
+                # Safe defensive fallback catching AttributeError, RuntimeError, TypeError
+                logging.debug("Suppressed non-critical error", exc_info=True)
+
     def on_mouse_move(self, obj: Any, event: Any) -> None:
         """
         Handle mouse move (drag vs camera/hover).
@@ -402,6 +448,8 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     break
         except (AttributeError, RuntimeError, TypeError):
             logging.warning("Caught exception in " + __file__, exc_info=True)
+
+        self._heal_stuck_pointer_state(move_group_dialog)
         if move_group_dialog and getattr(
             move_group_dialog, "is_dragging_group_vtk", False
         ):

moleditpy_linux-4.3.2/src/moleditpy_linux/ui/custom_qt_interactor.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
+import logging
+from typing import Any, Optional
+
+from PyQt6.QtCore import QEvent
+from PyQt6.QtGui import QMouseEvent
+from pyvistaqt import QtInteractor
+
+
+class CustomQtInteractor(QtInteractor):
+    """PyVista QtInteractor subclass that exposes the main window for event handling."""
+
+    def __init__(
+        self,
+        parent: Optional[Any] = None,
+        main_window: Optional[Any] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(parent, **kwargs)
+        self.main_window = main_window
+
+    def wheelEvent(self, event: Any) -> None:
+        """
+        Override the mouse wheel event.
+        """
+        # First call the parent class event to perform normal zoom processing
+        super().wheelEvent(event)
+
+        # Force focus back to the 2D view after zoom processing
+        if self.main_window and hasattr(self.main_window.init_manager, "view_2d"):
+            self.main_window.init_manager.view_2d.setFocus()
+
+    def mouseReleaseEvent(self, event: Any) -> None:
+        """
+        Override the Qt mouse release event to return focus to the 2D view after
+        all 3D view operations.
+        """
+        super().mouseReleaseEvent(event)  # Process parent class event first
+        if self.main_window and hasattr(self.main_window.init_manager, "view_2d"):
+            self.main_window.init_manager.view_2d.setFocus()
+
+    def mouseDoubleClickEvent(self, event: Any) -> None:
+        """Re-dispatch double-clicks as plain presses so fast clicking works.
+
+        Qt turns every second fast click into a double-click event. Forwarding
+        it unchanged would reach VTK with a repeat count and be dropped by the
+        interactor style, so the click would be lost (e.g. when rapidly
+        selecting atoms in measurement mode). Synthesizing a normal press keeps
+        press/release pairing intact and makes each fast click act as a click.
+        """
+        try:
+            synthetic_press = QMouseEvent(
+                QEvent.Type.MouseButtonPress,
+                event.position(),
+                event.globalPosition(),
+                event.button(),
+                event.buttons(),
+                event.modifiers(),
+            )
+            super().mousePressEvent(synthetic_press)
+            event.accept()
+        except (AttributeError, RuntimeError, TypeError):
+            # Safe defensive fallback catching AttributeError, RuntimeError, TypeError
+            logging.debug("Suppressed non-critical error", exc_info=True)

{moleditpy_linux-4.3.1 → moleditpy_linux-4.3.2}/src/moleditpy_linux/ui/dialog_3d_picking_mixin.py

@@ -82,9 +82,8 @@ class Dialog3DPickingMixin:
                             try:
                                 self.on_atom_picked(int(closest_atom_idx))
                             except (AttributeError, RuntimeError):
-                                # Safe defensive fallback catching AttributeError, RuntimeError
-                                logging.debug(
-                                    "Suppressed non-critical error", exc_info=True
+                                logging.warning(
+                                    "Dialog atom pick failed", exc_info=True
                                 )
 
                         from PyQt6.QtCore import QTimer

{moleditpy_linux-4.3.1 → moleditpy_linux-4.3.2}/src/moleditpy_linux/ui/move_selected_atoms_dialog.py

@@ -696,9 +696,13 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
         else:
             btn.setText("Box Selection: OFF")
             plotter.disable_picking()
-            # Restore original style
+            # Restore original style via pyvista's bookkeeping so its
+            # update_style() re-asserts ours instead of RubberBandPick
             if self.original_style is not None:
-                plotter.interactor.SetInteractorStyle(self.original_style)
+                try:
+                    plotter.iren.style = self.original_style
+                except AttributeError:
+                    plotter.interactor.SetInteractorStyle(self.original_style)
 
     def on_rectangle_picked(self, selection: Any) -> None:
         """Handle PyVista rectangle picking callback."""

{moleditpy_linux-4.3.1 → moleditpy_linux-4.3.2}/src/moleditpy_linux/ui/ui_manager.py

@@ -322,9 +322,51 @@ class UIManager(QObject):
         style = CustomInteractorStyle(self.host)
 
         # Set interactor style
-        self.host.view_3d_manager.plotter.interactor.SetInteractorStyle(style)
+        self._install_interactor_style(style)
         self.host.view_3d_manager.plotter.interactor.Initialize()
 
+        # Watchdog: if anything silently replaces the custom style (observed as
+        # "rotation works but pick/select is dead"), report it and reinstall.
+        self._expected_style = style
+        self._style_watchdog = QTimer(self)
+        self._style_watchdog.setInterval(2000)
+        self._style_watchdog.timeout.connect(self._check_interactor_style)
+        self._style_watchdog.start()
+
+    def _install_interactor_style(self, style: Any) -> None:
+        """Install *style* through pyvista's bookkeeping, not raw VTK.
+
+        pyvista's RenderWindowInteractor re-asserts its own ``_style_class``
+        via ``update_style()`` whenever its built-in double-click chart
+        handler fires (fast clicks!). Installing through the ``iren.style``
+        property keeps that bookkeeping pointing at our style so the
+        re-assert is a no-op instead of an eviction.
+        """
+        plotter = self.host.view_3d_manager.plotter
+        try:
+            plotter.iren.style = style
+        except AttributeError:
+            plotter.interactor.SetInteractorStyle(style)
+
+    def _check_interactor_style(self) -> None:
+        """Reinstall CustomInteractorStyle if it was silently replaced."""
+        try:
+            interactor = self.host.view_3d_manager.plotter.interactor
+            current = interactor.GetInteractorStyle()
+            if current is self._expected_style:
+                return
+            name = type(current).__name__
+            if "RubberBand" in name:  # legitimate temporary box-selection style
+                return
+            logging.debug(
+                "3D interactor style was replaced by %s — reinstalling "
+                "CustomInteractorStyle",
+                name,
+            )
+            self._install_interactor_style(self._expected_style)
+        except (AttributeError, RuntimeError):
+            logging.debug("Style watchdog check failed", exc_info=True)
+
     def handle_drag_enter_event(self, event: QDragEnterEvent) -> None:
         """Internal handler for drag enter event (bypasses PyQt type checks in tests)."""
         mime_data = event.mimeData()

moleditpy_linux-4.3.1/src/moleditpy_linux/ui/custom_qt_interactor.py

@@ -1,105 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-MoleditPy — A Python-based molecular editing software
-
-Author: Hiromichi Yokoyama
-License: GPL-3.0 license
-Repo: https://github.com/HiroYokoyama/python_molecular_editor
-DOI: 10.5281/zenodo.17268532
-"""
-
-import time
-from typing import Any, Optional
-
-from pyvistaqt import QtInteractor
-
-
-class CustomQtInteractor(QtInteractor):
-    """PyVista QtInteractor subclass that exposes the main window for event handling."""
-
-    def __init__(
-        self,
-        parent: Optional[Any] = None,
-        main_window: Optional[Any] = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(parent, **kwargs)
-        self.main_window = main_window
-        self._last_click_time = 0.0
-        self._click_count = 0
-        self._ignore_next_release = False
-
-    def wheelEvent(self, event: Any) -> None:
-        """
-        Override the mouse wheel event.
-        """
-        # First call the parent class event to perform normal zoom processing
-        super().wheelEvent(event)
-
-        # Force focus back to the 2D view after zoom processing
-        if self.main_window and hasattr(self.main_window.init_manager, "view_2d"):
-            self.main_window.init_manager.view_2d.setFocus()
-
-    def mouseReleaseEvent(self, event: Any) -> None:
-        """
-        Override the Qt mouse release event to return focus to the 2D view after
-        all 3D view operations. Also filters out "Ghost Release" (release without
-        a corresponding press).
-        """
-        if self._ignore_next_release:
-            self._ignore_next_release = False
-            event.accept()
-            return
-
-        super().mouseReleaseEvent(event)  # Process parent class event first
-        if self.main_window and hasattr(self.main_window.init_manager, "view_2d"):
-            self.main_window.init_manager.view_2d.setFocus()
-
-    def mousePressEvent(self, event: Any) -> None:
-        """
-        Custom mouse press handling to track accumulated clicks and filter out
-        triple-clicks.
-        """
-        current_time = time.time()
-        # Reset count if too much time has passed (0.5s is standard double-click time)
-        if current_time - self._last_click_time > 0.5:
-            self._click_count = 0
-
-        self._click_count += 1
-        self._last_click_time = current_time
-
-        # If this is the 3rd click (or more), swallow it to prevent
-        # the internal state desync that happens with rapid clicking sequences.
-        if self._click_count >= 3:
-            self._ignore_next_release = True
-            event.accept()
-            return
-
-        super().mousePressEvent(event)
-
-    def mouseDoubleClickEvent(self, event: Any) -> None:
-        """Ignore mouse double-clicks on the 3D widget to avoid accidental actions.
-
-        Swallow the double-click event so it doesn't trigger selection, editing,
-        or camera jumps. We intentionally do not call the superclass handler.
-        Crucially, we also flag the NEXT release event to be swallowed, preventing
-        a "Ghost Release" (Release without Press) from reaching VTK.
-        """
-        current_time = time.time()
-        self._last_click_time = current_time
-        # Set to 2 to ensure the next click counts as 3rd
-        if current_time - self._last_click_time < 0.5:
-            self._click_count = 2
-        else:
-            self._click_count = 2  # Force sync
-
-        self._ignore_next_release = True
-
-        try:
-            # Accept the event to mark it handled and prevent further processing.
-            event.accept()
-        except (AttributeError, RuntimeError, TypeError):
-            # If event doesn't support accept for some reason, just return.
-            return