MoleditPy-linux 4.4.1__py3-none-any.whl → 4.5.0__py3-none-any.whl

moleditpy_linux/plugins/plugin_interface.py

@@ -11,7 +11,7 @@ DOI: 10.5281/zenodo.17268532
 """
 
 import logging
-from typing import Any, Callable, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 
 class PluginContext:
@@ -353,6 +353,28 @@ class PluginContext:
         """
         self._manager.register_document_reset_handler(self._plugin_name, callback)
 
+    def register_atom_drag_handler(
+        self,
+        callback: Callable[
+            [str, List[int], Dict[int, Tuple[float, float, float]]], None
+        ],
+    ) -> None:
+        """Register a handler called during 3D atom or group dragging.
+
+        The callback receives:
+            event_type (str): ``"start"``, ``"move"``, or ``"end"``.
+            atom_indices (List[int]): RDKit atom indices being dragged.
+            positions (dict[int, tuple[float, float, float]]):
+                Current 3D positions of the dragged atoms.
+                Empty dict on ``"start"``.
+        """
+        self._manager.register_atom_drag_handler(self._plugin_name, callback)
+
+    @property
+    def is_dragging_atom(self) -> bool:
+        """Return True if an atom or group is currently being dragged in 3D."""
+        return self._manager.is_dragging_atom()  # type: ignore[no-any-return]
+
     def get_setting(self, key: str, default: Any = None) -> Any:
         """
         Get a plugin-specific persistent setting.

moleditpy_linux/plugins/plugin_manager.py

@@ -23,8 +23,9 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from PyQt6.QtCore import QUrl
 from PyQt6.QtGui import QDesktopServices
-from PyQt6.QtWidgets import QMessageBox
+from PyQt6.QtWidgets import QApplication, QMessageBox
 
+from ..utils.constants import MOVE_DIALOG_TYPES
 from .plugin_interface import PluginContext
 
 
@@ -95,6 +96,7 @@ class PluginManager:
         self.load_handlers: Dict[str, Callable] = {}
         self.custom_3d_styles: Dict[str, Dict[str, Any]] = {}
         self.document_reset_handlers: List[Dict[str, Any]] = []
+        self.atom_drag_handlers: List[Dict[str, Any]] = []
         self.plugin_windows: Dict[
             str, Dict[str, Any]
         ] = {}  # Map of plugin_name -> {window_id -> window}
@@ -247,6 +249,7 @@ class PluginManager:
         self.load_handlers = {}
         self.custom_3d_styles = {}
         self.document_reset_handlers = []
+        self.atom_drag_handlers = []
 
         if not os.path.exists(self.plugin_dir):
             return []
@@ -558,6 +561,10 @@ class PluginManager:
             {"plugin": plugin_name, "callback": callback}
         )
 
+    def register_atom_drag_handler(self, plugin_name: str, callback: Callable) -> None:
+        """Register a handler called during 3D atom/group dragging."""
+        self.atom_drag_handlers.append({"plugin": plugin_name, "callback": callback})
+
     # --- New API Implementation ---
     def show_status_message(self, message: str, timeout: int = 3000) -> None:
         """Display a message in the MainWindow status bar."""
@@ -653,6 +660,48 @@ class PluginManager:
                     exc_info=True,
                 )
 
+    def invoke_atom_drag_handlers(
+        self,
+        event_type: str,
+        atom_indices: List[int],
+        positions: Dict[int, tuple],
+    ) -> None:
+        """Call all registered atom drag handlers."""
+        for handler in self.atom_drag_handlers:
+            try:
+                handler["callback"](event_type, atom_indices, positions)
+            except Exception as e:  # plugins have full app access; catch everything to keep the drag alive
+                logging.warning(
+                    "Error in atom drag handler for %s: %s",
+                    handler["plugin"],
+                    e,
+                    exc_info=True,
+                )
+
+    def is_dragging_atom(self) -> bool:
+        """Return True if an atom or group is currently being dragged in 3D."""
+        mw = self.main_window
+        if mw is None:
+            return False
+        if getattr(mw, "dragged_atom_info", None) is not None:
+            return True
+        return self._is_dragging_group()
+
+    @staticmethod
+    def _is_dragging_group() -> bool:
+        """Return True while a Move Group / Move Selected Atoms gesture is active."""
+        try:
+            for widget in QApplication.topLevelWidgets():
+                if type(widget).__name__ not in MOVE_DIALOG_TYPES:
+                    continue
+                if getattr(widget, "is_dragging_group_vtk", False) or getattr(
+                    widget, "is_rotating_group_vtk", False
+                ):
+                    return True
+        except (AttributeError, RuntimeError, TypeError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+        return False
+
     def get_plugin_info_safe(self, file_path: str) -> Dict[str, str]:
         """Extracts plugin metadata using AST parsing (safe, no execution)."""
         info = {

moleditpy_linux/ui/atom_item.py

@@ -63,6 +63,8 @@ class AtomItem(QGraphicsItem):
         self.setFlags(
             QGraphicsItem.GraphicsItemFlag.ItemIsMovable
             | QGraphicsItem.GraphicsItemFlag.ItemIsSelectable
+            # Without this Qt never calls itemChange for moves, so bonds lag.
+            | QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges
         )
         self.setZValue(1)
         self.update_style()

moleditpy_linux/ui/custom_interactor_style.py

@@ -13,7 +13,8 @@ DOI: 10.5281/zenodo.17268532
 from __future__ import annotations
 
 import logging
-from typing import Any, Optional
+import time
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 from PyQt6.QtCore import Qt, QTimer
@@ -22,6 +23,7 @@ from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera  #
 
 
 from .atom_picking import pick_atom_index_from_screen
+from ..utils.constants import MOVE_DIALOG_TYPES
 
 from rdkit import Geometry
 
@@ -35,6 +37,32 @@ _VTKIS_ROTATE = 1
 # window-size independent and matches the feel at the default window size.
 _ROTATION_REFERENCE_SIZE = 640.0
 
+# Minimum seconds between real-time drag redraws (~30 fps).
+_DRAG_REDRAW_INTERVAL = 0.033
+
+# Largest molecule that still gets real-time drag feedback (each frame is a
+# full scene rebuild).
+_REALTIME_DRAG_MAX_ATOMS = 300
+
+# Radians of group rotation per pixel of mouse travel, before sensitivity.
+_GROUP_ROTATION_RADIANS_PER_PIXEL = 0.008
+
+
+def _rodrigues_matrix(axis: np.ndarray, angle: float) -> np.ndarray:
+    """Return the rotation matrix for `angle` radians about `axis` (Rodrigues)."""
+    norm = float(np.linalg.norm(axis))
+    if norm < 1e-6 or abs(angle) < 1e-6:
+        return np.eye(3)
+    unit = axis / norm
+    k_mat = np.array(
+        [
+            [0.0, -unit[2], unit[1]],
+            [unit[2], 0.0, -unit[0]],
+            [-unit[1], unit[0], 0.0],
+        ]
+    )
+    return np.eye(3) + np.sin(angle) * k_mat + (1.0 - np.cos(angle)) * (k_mat @ k_mat)
+
 
 class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
     """VTK interactor style extending trackball-camera with 3D atom drag and measurement."""
@@ -48,6 +76,10 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         self._mouse_moved_during_drag = False
         self._mouse_press_pos: Optional[tuple[int, int]] = None
         self._suppress_next_left_button_up = False
+        # Throttle for real-time drag redraws
+        self._last_drag_redraw_time: float = 0.0
+        self._drag_redraw_pending = False
+        self._active_drag_atoms: Optional[List[int]] = None
 
         self.AddObserver("LeftButtonPressEvent", self.on_left_button_down)  # type: ignore[arg-type]
         # self.AddObserver("LeftButtonDoubleClickEvent", self.on_left_button_down)
@@ -70,6 +102,8 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             # Safe defensive fallback catching AttributeError, RuntimeError
             logging.debug("Suppressed non-critical error", exc_info=True)
 
+        self._end_drag_event()
+
         # Reset all custom flags
         self._is_dragging_atom = False
         self.is_dragging = False
@@ -91,6 +125,198 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                 # Safe defensive fallback catching AttributeError, RuntimeError
                 logging.debug("Suppressed non-critical error", exc_info=True)
 
+    def _find_move_dialog(self) -> Any:
+        """Return the visible Move Group / Move Selected Atoms dialog, if any."""
+        try:
+            for widget in QApplication.topLevelWidgets():
+                if type(widget).__name__ in MOVE_DIALOG_TYPES and widget.isVisible():
+                    return widget
+        except (AttributeError, RuntimeError, TypeError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+        return None
+
+    def _display_to_world(
+        self,
+        renderer: Any,
+        screen_x: float,
+        screen_y: float,
+        depth_z: float,
+    ) -> Optional[Tuple[float, float, float]]:
+        """Convert screen (display) coordinates to 3D world coordinates.
+
+        Uses the given depth_z (already in display-space) so the result
+        lies on the same depth plane as the reference atom.
+        """
+        try:
+            renderer.SetDisplayPoint(screen_x, screen_y, depth_z)
+            renderer.DisplayToWorld()
+            wp = renderer.GetWorldPoint()
+            return (wp[0], wp[1], wp[2])
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+            return None
+
+    def _world_to_display_depth(
+        self, renderer: Any, x: float, y: float, z: float
+    ) -> Optional[float]:
+        """Return the display-space Z depth for a world-space point."""
+        try:
+            renderer.SetWorldPoint(x, y, z, 1.0)
+            renderer.WorldToDisplay()
+            return float(renderer.GetDisplayPoint()[2])
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+            return None
+
+    def _invoke_drag_handlers(
+        self,
+        event_type: str,
+        atom_indices: List[int],
+        positions: Dict[int, Tuple[float, float, float]],
+    ) -> None:
+        """Forward a drag event to all registered plugin handlers."""
+        mw = self.main_window
+        if mw is None:
+            return
+        pm = getattr(mw, "plugin_manager", None)
+        if pm is None:
+            return
+        invoke = getattr(pm, "invoke_atom_drag_handlers", None)
+        if invoke is not None:
+            try:
+                invoke(event_type, atom_indices, positions)
+            # Plugin faults are already isolated per handler by the manager.
+            except (AttributeError, RuntimeError, TypeError, ValueError):
+                logging.warning("invoke_atom_drag_handlers raised", exc_info=True)
+
+    def _current_positions(
+        self, atom_indices: List[int]
+    ) -> Dict[int, Tuple[float, float, float]]:
+        """Read the current conformer coordinates of the given atoms."""
+        positions: Dict[int, Tuple[float, float, float]] = {}
+        try:
+            mol = self.main_window.view_3d_manager.current_mol
+            if mol is None or mol.GetNumConformers() == 0:
+                return positions
+            conf = mol.GetConformer()
+            for idx in atom_indices:
+                pos = conf.GetAtomPosition(idx)
+                positions[idx] = (float(pos.x), float(pos.y), float(pos.z))
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+        return positions
+
+    def _begin_drag_event(self, atom_indices: Any) -> None:
+        """Report the start of a drag gesture and arm the redraw throttle.
+
+        A right-button press never passes through reset_interactor_state, so
+        close any gesture whose end was missed before opening a new one.
+        """
+        self._end_drag_event()
+        atoms = [int(idx) for idx in atom_indices]
+        self._active_drag_atoms = atoms
+        self._last_drag_redraw_time = 0.0
+        self._drag_redraw_pending = False
+        self._invoke_drag_handlers("start", list(atoms), {})
+
+    def _end_drag_event(self) -> None:
+        """Report the end of the active drag gesture exactly once.
+
+        Every exit path (normal release, aborted gesture, forced reset) routes
+        through here so a plugin can never be left believing a drag is still
+        in progress.
+        """
+        atoms = self._active_drag_atoms
+        self._active_drag_atoms = None
+        self._drag_redraw_pending = False
+        if atoms is None:
+            return
+        self._invoke_drag_handlers("end", list(atoms), self._current_positions(atoms))
+
+    def _realtime_drag_active(self) -> bool:
+        """Return True when real-time drag is both enabled and affordable here.
+
+        Every frame rebuilds the whole 3D scene, so past a few hundred atoms
+        the rebuild costs more than the throttle interval and dragging feels
+        worse with it than without; the move is then applied on release only.
+        """
+        if not self._realtime_drag_enabled():
+            return False
+        return not self._molecule_too_large_for_realtime()
+
+    def _molecule_too_large_for_realtime(self) -> bool:
+        """Return True when the molecule exceeds the real-time drag size limit."""
+        try:
+            mol = self.main_window.view_3d_manager.current_mol
+            if mol is None:
+                return False
+            return int(mol.GetNumAtoms()) > _REALTIME_DRAG_MAX_ATOMS
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+            return False
+
+    def _should_drag_redraw(self) -> bool:
+        """Return True when a real-time drag frame may be rendered now.
+
+        Skips while a previous deferred redraw is still queued so a scene that
+        rebuilds slower than the throttle interval cannot pile up frames.
+        """
+        if not self._realtime_drag_active():
+            return False
+        if self._drag_redraw_pending:
+            return False
+        return time.monotonic() - self._last_drag_redraw_time >= _DRAG_REDRAW_INTERVAL
+
+    def _finish_drag_redraw(self) -> None:
+        """Release the redraw gate once a deferred drag frame has rendered."""
+        self._drag_redraw_pending = False
+        self._last_drag_redraw_time = time.monotonic()
+
+    def _abort_active_drag(self, moved: bool) -> None:
+        """Close out a gesture whose release event was lost.
+
+        Real-time dragging has already written the new geometry, so a moved
+        gesture still needs an undo entry even though it never reached the
+        release handler.
+        """
+        if self._active_drag_atoms is None:
+            return
+        if moved and self._realtime_drag_active():
+            self._push_undo_after_aborted_drag()
+        self._end_drag_event()
+
+    def _push_undo_after_aborted_drag(self) -> None:
+        """Record geometry left behind by a gesture whose release was lost.
+
+        Real-time dragging mutates the conformer on every frame, so an aborted
+        gesture would otherwise leave the molecule moved with nothing on the
+        undo stack.
+        """
+        try:
+            self.main_window.edit_actions_manager.push_undo_state()
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+
+    def _realtime_drag_enabled(self) -> bool:
+        """Return True if real-time drag redraw is enabled in settings."""
+        mw = self.main_window
+        if mw is None:
+            return True
+        try:
+            return bool(mw.get_settings().get("realtime_3d_drag", True))
+        except (AttributeError, RuntimeError, TypeError):
+            return True
+
+    def _rotation_sensitivity(self) -> float:
+        """Return the user's rotation-speed multiplier, shared by camera and group rotation."""
+        mw = self.main_window
+        if mw is None:
+            return 1.0
+        try:
+            return float(mw.get_settings().get("mouse_rotation_sensitivity", 1.0))
+        except (AttributeError, TypeError, ValueError):
+            return 1.0
+
     def _rotate_size_independent(self) -> None:
         """Rotate the camera at a speed that does not depend on canvas size.
 
@@ -106,17 +332,12 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         dx = interactor.GetEventPosition()[0] - interactor.GetLastEventPosition()[0]
         dy = interactor.GetEventPosition()[1] - interactor.GetLastEventPosition()[1]
 
-        sensitivity = 1.0
-        mw = self.main_window
-        if mw is not None:
-            try:
-                sensitivity = float(
-                    mw.get_settings().get("mouse_rotation_sensitivity", 1.0)
-                )
-            except (AttributeError, TypeError, ValueError):
-                sensitivity = 1.0
-
-        delta = -20.0 / _ROTATION_REFERENCE_SIZE * self.GetMotionFactor() * sensitivity
+        delta = (
+            -20.0
+            / _ROTATION_REFERENCE_SIZE
+            * self.GetMotionFactor()
+            * self._rotation_sensitivity()
+        )
         camera = renderer.GetActiveCamera()
         camera.Azimuth(dx * delta)
         camera.Elevation(dy * delta)
@@ -154,20 +375,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         self._mouse_moved_during_drag = False
         self._mouse_press_pos = None
 
-        # Check Move Group dialog
-        # Check Move Group or Move Selected Atoms dialog
-        move_group_dialog: Any = None
-        for widget in QApplication.topLevelWidgets():
-            try:
-                if (
-                    type(widget).__name__
-                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
-                    and widget.isVisible()
-                ):
-                    move_group_dialog = widget
-                    break
-            except (AttributeError, RuntimeError, TypeError):
-                logging.warning("Caught exception in " + __file__, exc_info=True)
+        move_group_dialog = self._find_move_dialog()
 
         if move_group_dialog and move_group_dialog.group_atoms:
             # Group drag if selected
@@ -197,6 +405,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     mw.view_3d_manager.plotter.setCursor(
                         Qt.CursorShape.ClosedHandCursor
                     )
+                    self._begin_drag_event(move_group_dialog.group_atoms)
                     self._suppress_next_left_button_up = True
                     return  # Disable camera rotation
                 else:
@@ -358,6 +567,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                             mw.view_3d_manager.plotter.setCursor(
                                 Qt.CursorShape.ClosedHandCursor
                             )
+                            self._begin_drag_event([int(closest_atom_idx)])
                             self._suppress_next_left_button_up = True
                             return  # Prevent camera rotation
 
@@ -373,21 +583,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         """
         mw = self.main_window
 
-        # Check if Move Group dialog or Move Selected Atoms dialog is open
-        move_group_dialog: Any = None
-        try:
-            for widget in QApplication.topLevelWidgets():
-                if (
-                    type(widget).__name__
-                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
-                    and widget.isVisible()
-                ):
-                    move_group_dialog = widget
-                    break
-        except (AttributeError, RuntimeError, TypeError) as e:
-            logging.debug(
-                f"Suppressed exception: {e}"
-            )  # Suppress non-critical widget search noise
+        move_group_dialog = self._find_move_dialog()
 
         if move_group_dialog and move_group_dialog.group_atoms:
             # Start rotation drag if group selected
@@ -398,17 +594,29 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                 mw.view_3d_manager.current_mol,
             )
 
-            # Start rotation drag if atom inside group clicked
-            if (
+            follow_mouse = False
+            try:
+                follow_mouse = bool(
+                    mw.get_settings().get("rotate_group_follow_mouse", False)
+                )
+            except (AttributeError, RuntimeError, TypeError):
+                follow_mouse = False
+
+            # If follow_mouse is True, require clicking directly on an atom in the group.
+            # If follow_mouse is False (default), allow right-clicking anywhere on display.
+            if not follow_mouse or (
                 clicked_atom_idx is not None
                 and clicked_atom_idx in move_group_dialog.group_atoms
             ):
                 move_group_dialog.is_rotating_group_vtk = True
                 move_group_dialog.rotation_start_pos = click_pos
                 move_group_dialog.rotation_mouse_moved = False
-                move_group_dialog.rotation_atom_idx = (
-                    clicked_atom_idx  # Record grabbed atom
-                )
+                if clicked_atom_idx is not None:
+                    move_group_dialog.rotation_atom_idx = (
+                        clicked_atom_idx  # Record grabbed atom
+                    )
+                elif hasattr(move_group_dialog, "rotation_atom_idx"):
+                    delattr(move_group_dialog, "rotation_atom_idx")
 
                 # Save initial positions and centroid
                 move_group_dialog.initial_positions = {}
@@ -423,6 +631,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                 move_group_dialog.group_centroid = centroid
 
                 mw.view_3d_manager.plotter.setCursor(Qt.CursorShape.ClosedHandCursor)
+                self._begin_drag_event(move_group_dialog.group_atoms)
                 return  # Disable camera rotation
 
         # Standard right-click
@@ -446,6 +655,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             return
 
         if self._is_dragging_atom and not left_held:
+            self._abort_active_drag(self.is_dragging)
             self.reset_interactor_state()
 
         if not any_held:
@@ -462,16 +672,20 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     getattr(move_group_dialog, "is_dragging_group_vtk", False)
                     and not left_held
                 ):
+                    moved = getattr(move_group_dialog, "mouse_moved_vtk", False)
                     move_group_dialog.is_dragging_group_vtk = False
                     move_group_dialog.drag_start_pos_vtk = None
                     move_group_dialog.mouse_moved_vtk = False
+                    self._abort_active_drag(moved)
                 if (
                     getattr(move_group_dialog, "is_rotating_group_vtk", False)
                     and not right_held
                 ):
+                    moved = getattr(move_group_dialog, "rotation_mouse_moved", False)
                     move_group_dialog.is_rotating_group_vtk = False
                     move_group_dialog.rotation_start_pos = None
                     move_group_dialog.rotation_mouse_moved = False
+                    self._abort_active_drag(moved)
             except (AttributeError, RuntimeError, TypeError):
                 # Safe defensive fallback catching AttributeError, RuntimeError, TypeError
                 logging.debug("Suppressed non-critical error", exc_info=True)
@@ -482,25 +696,13 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         """
         mw = self.main_window
 
-        # Move Group / Selected Atoms drag handling
-        move_group_dialog: Any = None
-        try:
-            for widget in QApplication.topLevelWidgets():
-                if (
-                    type(widget).__name__
-                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
-                    and widget.isVisible()
-                ):
-                    move_group_dialog = widget
-                    break
-        except (AttributeError, RuntimeError, TypeError):
-            logging.warning("Caught exception in " + __file__, exc_info=True)
+        move_group_dialog = self._find_move_dialog()
 
         self._heal_stuck_pointer_state(move_group_dialog)
         if move_group_dialog and getattr(
             move_group_dialog, "is_dragging_group_vtk", False
         ):
-            # Dragging group - record offset
+            # Dragging group - record offset and update positions in real-time
             interactor = self.GetInteractor()
             current_pos = interactor.GetEventPosition()
 
@@ -513,6 +715,13 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             if abs(dx) > 5 or abs(dy) > 5:
                 move_group_dialog.mouse_moved_vtk = True
 
+            if (
+                move_group_dialog.mouse_moved_vtk
+                and hasattr(move_group_dialog, "initial_positions")
+                and self._should_drag_redraw()
+            ):
+                self._do_realtime_group_translate(mw, move_group_dialog, current_pos)
+
             return  # Disable camera rotation
 
         # Group rotation handling
@@ -531,6 +740,14 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             if abs(dx) > 5 or abs(dy) > 5:
                 move_group_dialog.rotation_mouse_moved = True
 
+            if (
+                move_group_dialog.rotation_mouse_moved
+                and hasattr(move_group_dialog, "initial_positions")
+                and hasattr(move_group_dialog, "group_centroid")
+                and self._should_drag_redraw()
+            ):
+                self._do_realtime_group_rotate(mw, move_group_dialog, current_pos)
+
             return  # Disable camera rotation
 
         interactor = self.GetInteractor()
@@ -547,6 +764,8 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         if self._is_dragging_atom and mw.dragged_atom_info is not None:
             # Custom atom drag
             self.is_dragging = True
+            if self._should_drag_redraw():
+                self._do_realtime_atom_drag(mw)
         else:
             # Camera interaction. VTK's built-in Rotate divides mouse motion by
             # the live render size, so rotation slows as the canvas grows. Handle
@@ -580,25 +799,276 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             else:
                 mw.view_3d_manager.plotter.setCursor(Qt.CursorShape.ArrowCursor)
 
+    def _do_realtime_atom_drag(self, mw: Any) -> None:
+        """Update the dragged atom's position and redraw during mouse-move."""
+        try:
+            atom_id = mw.dragged_atom_info.get("id") if mw.dragged_atom_info else None
+            if atom_id is None:
+                return
+            if not (
+                mw.view_3d_manager.current_mol
+                and mw.view_3d_manager.current_mol.GetNumConformers() > 0
+            ):
+                return
+
+            interactor = self.GetInteractor()
+            renderer = mw.view_3d_manager.plotter.renderer
+            current_pos = interactor.GetEventPosition()
+            conf = mw.view_3d_manager.current_mol.GetConformer()
+            pos_3d = conf.GetAtomPosition(atom_id)
+
+            depth_z = self._world_to_display_depth(
+                renderer, pos_3d.x, pos_3d.y, pos_3d.z
+            )
+            if depth_z is None:
+                return
+            new_world = self._display_to_world(
+                renderer, current_pos[0], current_pos[1], depth_z
+            )
+            if new_world is None:
+                return
+
+            conf.SetAtomPosition(
+                atom_id,
+                Geometry.Point3D(
+                    float(new_world[0]), float(new_world[1]), float(new_world[2])
+                ),
+            )
+            if isinstance(
+                mw.view_3d_manager.atom_positions_3d, (list, np.ndarray)
+            ) and atom_id < len(mw.view_3d_manager.atom_positions_3d):
+                mw.view_3d_manager.atom_positions_3d[atom_id] = list(new_world)
+
+            _rt_mol = mw.view_3d_manager.current_mol
+
+            def _deferred_rt_atom() -> None:
+                try:
+                    mw.view_3d_manager.draw_molecule_3d(_rt_mol)
+                except (AttributeError, RuntimeError, ValueError, TypeError):
+                    logging.debug("Suppressed non-critical error", exc_info=True)
+                finally:
+                    self._finish_drag_redraw()
+
+            self._drag_redraw_pending = True
+            QTimer.singleShot(0, _deferred_rt_atom)
+            self._invoke_drag_handlers(
+                "move",
+                [atom_id],
+                {atom_id: new_world},
+            )
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+
+    def _do_realtime_group_translate(
+        self, mw: Any, move_group_dialog: Any, current_pos: Any
+    ) -> None:
+        """Translate group atoms and redraw during mouse-move."""
+        try:
+            renderer = mw.view_3d_manager.plotter.renderer
+            drag_atom_idx = move_group_dialog.drag_atom_idx_vtk
+            drag_initial_pos = move_group_dialog.initial_positions[drag_atom_idx]
+
+            depth_z = self._world_to_display_depth(
+                renderer, drag_initial_pos[0], drag_initial_pos[1], drag_initial_pos[2]
+            )
+            if depth_z is None:
+                return
+            new_world = self._display_to_world(
+                renderer, current_pos[0], current_pos[1], depth_z
+            )
+            if new_world is None:
+                return
+
+            conf = mw.view_3d_manager.current_mol.GetConformer()
+            translation = np.array(new_world) - drag_initial_pos
+            new_positions: Dict[int, Tuple[float, float, float]] = {}
+            for atom_idx in move_group_dialog.group_atoms:
+                initial_pos = move_group_dialog.initial_positions[atom_idx]
+                new_pos = initial_pos + translation
+                mw.view_3d_manager.atom_positions_3d[atom_idx] = new_pos
+                conf.SetAtomPosition(
+                    atom_idx,
+                    Geometry.Point3D(
+                        float(new_pos[0]), float(new_pos[1]), float(new_pos[2])
+                    ),
+                )
+                new_positions[atom_idx] = (
+                    float(new_pos[0]),
+                    float(new_pos[1]),
+                    float(new_pos[2]),
+                )
+
+            _rt_mol = mw.view_3d_manager.current_mol
+            _rt_dlg = move_group_dialog
+
+            def _deferred_rt_grp() -> None:
+                try:
+                    mw.view_3d_manager.draw_molecule_3d(_rt_mol)
+                    _rt_dlg.show_atom_labels()
+                except (AttributeError, RuntimeError, ValueError, TypeError):
+                    logging.debug("Suppressed non-critical error", exc_info=True)
+                finally:
+                    self._finish_drag_redraw()
+
+            self._drag_redraw_pending = True
+            QTimer.singleShot(0, _deferred_rt_grp)
+            self._invoke_drag_handlers(
+                "move", list(move_group_dialog.group_atoms), new_positions
+            )
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+
+    def _compute_delta_rotation_matrix(
+        self, renderer: Any, start_pos: tuple, current_pos: tuple
+    ) -> Optional[np.ndarray]:
+        """Compute 3D rotation matrix from screen mouse displacement (dx, dy)."""
+        try:
+            dx = current_pos[0] - start_pos[0]
+            dy = current_pos[1] - start_pos[1]
+            if abs(dx) < 1e-3 and abs(dy) < 1e-3:
+                return None
+
+            camera = renderer.GetActiveCamera()
+            view_up = np.array(camera.GetViewUp())
+            v_dir = np.array(camera.GetDirectionOfProjection())
+            right = np.cross(v_dir, view_up)
+
+            right_norm = np.linalg.norm(right)
+            if right_norm > 1e-6:
+                right = right / right_norm
+
+            view_up_norm = np.linalg.norm(view_up)
+            if view_up_norm > 1e-6:
+                view_up = view_up / view_up_norm
+
+            speed = _GROUP_ROTATION_RADIANS_PER_PIXEL * self._rotation_sensitivity()
+            rot_y = _rodrigues_matrix(view_up, float(dx) * speed)
+            rot_x = _rodrigues_matrix(right, -float(dy) * speed)
+            return rot_x @ rot_y
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+            return None
+
+    def _get_group_rotation_matrix(
+        self, mw: Any, move_group_dialog: Any, current_pos: Any
+    ) -> Optional[np.ndarray]:
+        """Compute group rotation matrix using delta or follow-mouse method."""
+        try:
+            renderer = mw.view_3d_manager.plotter.renderer
+            centroid = move_group_dialog.group_centroid
+            start_pos = getattr(move_group_dialog, "rotation_start_pos", None)
+            if start_pos is None:
+                return None
+
+            follow_mouse = bool(
+                mw.get_settings().get("rotate_group_follow_mouse", False)
+            )
+
+            if follow_mouse:
+                if not hasattr(move_group_dialog, "rotation_atom_idx"):
+                    move_group_dialog.rotation_atom_idx = next(
+                        iter(move_group_dialog.group_atoms)
+                    )
+                grabbed_atom_idx = move_group_dialog.rotation_atom_idx
+                grabbed_initial_pos = move_group_dialog.initial_positions[
+                    grabbed_atom_idx
+                ]
+
+                depth_z = self._world_to_display_depth(
+                    renderer,
+                    grabbed_initial_pos[0],
+                    grabbed_initial_pos[1],
+                    grabbed_initial_pos[2],
+                )
+                if depth_z is None:
+                    return None
+                target_world = self._display_to_world(
+                    renderer, current_pos[0], current_pos[1], depth_z
+                )
+                if target_world is None:
+                    return None
+                target_pos = np.array(target_world)
+
+                v1 = grabbed_initial_pos - centroid
+                v2 = target_pos - centroid
+                v1_norm = np.linalg.norm(v1)
+                v2_norm = np.linalg.norm(v2)
+                if v1_norm < 1e-6 or v2_norm < 1e-6:
+                    return None
+
+                v1_n = v1 / v1_norm
+                v2_n = v2 / v2_norm
+                rotation_axis = np.cross(v1_n, v2_n)
+                axis_norm = np.linalg.norm(rotation_axis)
+                if axis_norm < 1e-6:
+                    return None
+                rotation_axis /= axis_norm
+
+                cos_angle = float(np.clip(np.dot(v1_n, v2_n), -1.0, 1.0))
+                return _rodrigues_matrix(rotation_axis, float(np.arccos(cos_angle)))
+            return self._compute_delta_rotation_matrix(renderer, start_pos, current_pos)
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+            return None
+
+    def _do_realtime_group_rotate(
+        self, mw: Any, move_group_dialog: Any, current_pos: Any
+    ) -> None:
+        """Rotate group atoms around their centroid and redraw during mouse-move."""
+        try:
+            rot_matrix = self._get_group_rotation_matrix(
+                mw, move_group_dialog, current_pos
+            )
+            if rot_matrix is None:
+                return
+
+            centroid = move_group_dialog.group_centroid
+
+            conf = mw.view_3d_manager.current_mol.GetConformer()
+            new_positions: Dict[int, Tuple[float, float, float]] = {}
+            for atom_idx in move_group_dialog.group_atoms:
+                initial_pos = move_group_dialog.initial_positions[atom_idx]
+                new_pos = rot_matrix @ (initial_pos - centroid) + centroid
+                mw.view_3d_manager.atom_positions_3d[atom_idx] = new_pos
+                conf.SetAtomPosition(
+                    atom_idx,
+                    Geometry.Point3D(
+                        float(new_pos[0]), float(new_pos[1]), float(new_pos[2])
+                    ),
+                )
+                new_positions[atom_idx] = (
+                    float(new_pos[0]),
+                    float(new_pos[1]),
+                    float(new_pos[2]),
+                )
+
+            _rt_mol = mw.view_3d_manager.current_mol
+            _rt_dlg = move_group_dialog
+
+            def _deferred_rt_rot() -> None:
+                try:
+                    mw.view_3d_manager.draw_molecule_3d(_rt_mol)
+                    _rt_dlg.show_atom_labels()
+                except (AttributeError, RuntimeError, ValueError, TypeError):
+                    logging.debug("Suppressed non-critical error", exc_info=True)
+                finally:
+                    self._finish_drag_redraw()
+
+            self._drag_redraw_pending = True
+            QTimer.singleShot(0, _deferred_rt_rot)
+            self._invoke_drag_handlers(
+                "move", list(move_group_dialog.group_atoms), new_positions
+            )
+        except (AttributeError, RuntimeError, TypeError, ValueError):
+            logging.debug("Suppressed non-critical error", exc_info=True)
+
     def on_left_button_up(self, obj: Any, event: Any) -> None:
         """
         Handle click release and reset state.
         """
         mw = self.main_window
 
-        # Finalize Move Group / Selected Atoms drag
-        move_group_dialog: Any = None
-        try:
-            for widget in QApplication.topLevelWidgets():
-                if (
-                    type(widget).__name__
-                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
-                    and widget.isVisible()
-                ):
-                    move_group_dialog = widget
-                    break
-        except (AttributeError, RuntimeError, TypeError):
-            logging.warning("Caught exception in " + __file__, exc_info=True)
+        move_group_dialog = self._find_move_dialog()
         # Prevent multi-click issues
         if move_group_dialog:
             if getattr(
@@ -699,6 +1169,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                         move_group_dialog.on_atom_picked(clicked_atom)
                     except (AttributeError, RuntimeError, TypeError, ValueError):
                         logging.warning("Error in toggle", exc_info=True)
+            self._end_drag_event()
 
         # Background click: deselect Move Group
         if move_group_dialog and not getattr(
@@ -844,6 +1315,8 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                         mw.edit_actions_manager.push_undo_state()
 
                     QTimer.singleShot(0, _deferred_atom_redraw)
+
+            self._end_drag_event()
             mw.dragged_atom_info = None
             self._stop_vtk_left_button_state()
 
@@ -911,19 +1384,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         """
         mw = self.main_window
 
-        # Finalize Move Group / Selected Atoms rotation
-        move_group_dialog: Any = None
-        try:
-            for widget in QApplication.topLevelWidgets():
-                if (
-                    type(widget).__name__
-                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
-                    and widget.isVisible()
-                ):
-                    move_group_dialog = widget
-                    break
-        except (AttributeError, RuntimeError, TypeError):
-            logging.warning("Caught exception in " + __file__, exc_info=True)
+        move_group_dialog = self._find_move_dialog()
         if move_group_dialog and getattr(
             move_group_dialog, "is_rotating_group_vtk", False
         ):
@@ -932,113 +1393,39 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                 # Apply rotation on release if moved
                 try:
                     interactor = self.GetInteractor()
-                    renderer = mw.view_3d_manager.plotter.renderer
                     current_pos = interactor.GetEventPosition()
                     conf = mw.view_3d_manager.current_mol.GetConformer()
                     centroid = move_group_dialog.group_centroid
 
-                    # Save initial grabbed atom index
-                    if not hasattr(move_group_dialog, "rotation_atom_idx"):
-                        move_group_dialog.rotation_atom_idx = next(
-                            iter(move_group_dialog.group_atoms)
-                        )
-
-                    grabbed_atom_idx = move_group_dialog.rotation_atom_idx
-                    grabbed_initial_pos = move_group_dialog.initial_positions[
-                        grabbed_atom_idx
-                    ]
-
-                    # Get start screen coordinates
-                    renderer.SetWorldPoint(
-                        grabbed_initial_pos[0],
-                        grabbed_initial_pos[1],
-                        grabbed_initial_pos[2],
-                        1.0,
-                    )
-                    renderer.WorldToDisplay()
-                    start_display = renderer.GetDisplayPoint()
-
-                    # Convert current mouse pos to world (same depth)
-                    renderer.SetDisplayPoint(
-                        current_pos[0], current_pos[1], start_display[2]
-                    )
-                    renderer.DisplayToWorld()
-                    target_world = renderer.GetWorldPoint()
-                    target_pos = np.array(
-                        [target_world[0], target_world[1], target_world[2]]
+                    rot_matrix = self._get_group_rotation_matrix(
+                        mw, move_group_dialog, current_pos
                     )
+                    if rot_matrix is not None:
+                        for atom_idx in move_group_dialog.group_atoms:
+                            initial_pos = move_group_dialog.initial_positions[atom_idx]
+                            relative_pos = initial_pos - centroid
+                            rotated_pos = rot_matrix @ relative_pos
+                            new_pos = rotated_pos + centroid
 
-                    # Vectors relative to centroid
-                    v1 = grabbed_initial_pos - centroid
-                    v2 = target_pos - centroid
-
-                    # Normalize vectors
-                    v1_norm = np.linalg.norm(v1)
-                    v2_norm = np.linalg.norm(v2)
-
-                    if v1_norm > 1e-6 and v2_norm > 1e-6:
-                        v1_normalized = v1 / v1_norm
-                        v2_normalized = v2 / v2_norm
-
-                        # Rotation axis
-                        rotation_axis = np.cross(v1_normalized, v2_normalized)
-                        axis_norm = np.linalg.norm(rotation_axis)
-
-                        if axis_norm > 1e-6:
-                            rotation_axis = rotation_axis / axis_norm
-
-                            # Rotation angle
-                            cos_angle = np.clip(
-                                np.dot(v1_normalized, v2_normalized), -1.0, 1.0
-                            )
-                            angle = np.arccos(cos_angle)
-
-                            # Create rotation matrix
-                            K = np.array(
-                                [
-                                    [0, -rotation_axis[2], rotation_axis[1]],
-                                    [rotation_axis[2], 0, -rotation_axis[0]],
-                                    [-rotation_axis[1], rotation_axis[0], 0],
-                                ]
-                            )
-
-                            rot_matrix = (
-                                np.eye(3)
-                                + np.sin(angle) * K
-                                + (1 - np.cos(angle)) * (K @ K)
+                            conf.SetAtomPosition(
+                                atom_idx,
+                                Geometry.Point3D(
+                                    float(new_pos[0]),
+                                    float(new_pos[1]),
+                                    float(new_pos[2]),
+                                ),
                             )
+                            mw.view_3d_manager.atom_positions_3d[atom_idx] = new_pos
 
-                            # Rotate group around centroid
-                            for atom_idx in move_group_dialog.group_atoms:
-                                initial_pos = move_group_dialog.initial_positions[
-                                    atom_idx
-                                ]
-                                # Relative position from centroid
-                                relative_pos = initial_pos - centroid
-                                # Apply rotation
-                                rotated_pos = rot_matrix @ relative_pos
-                                # Restore absolute position
-                                new_pos = rotated_pos + centroid
-
-                                conf.SetAtomPosition(
-                                    atom_idx,
-                                    Geometry.Point3D(
-                                        float(new_pos[0]),
-                                        float(new_pos[1]),
-                                        float(new_pos[2]),
-                                    ),
-                                )
-                                mw.view_3d_manager.atom_positions_3d[atom_idx] = new_pos
-
-                            # Update 3D display
-                            mw.view_3d_manager.draw_molecule_3d(
-                                mw.view_3d_manager.current_mol
-                            )
-                            mw.view_3d_manager.update_chiral_labels()
-                            move_group_dialog.show_atom_labels()
-                            mw.edit_actions_manager.push_undo_state()
+                        mw.view_3d_manager.draw_molecule_3d(
+                            mw.view_3d_manager.current_mol
+                        )
+                        mw.view_3d_manager.update_chiral_labels()
+                        move_group_dialog.show_atom_labels()
+                        mw.edit_actions_manager.push_undo_state()
                 except (AttributeError, RuntimeError, TypeError, ValueError):
                     logging.warning("Error finalizing group rotation", exc_info=True)
+            self._end_drag_event()
 
             # Reset state
             move_group_dialog.is_rotating_group_vtk = False

moleditpy_linux/ui/move_group_dialog.py

@@ -53,11 +53,6 @@ class MoveGroupDialog(BasePickingDialog):
         self.selected_atoms: set[int] = set()
         self.group_atoms: set[int] = set()  # All atoms connected to selected atoms
 
-        # Add preselected atoms
-        if preselected_atoms:
-            # For MoveGroup, we pick the first atom and select its connected group
-            self.on_atom_picked(preselected_atoms[0])
-
         self.clicked_atom_for_toggle: Optional[int] = None
         # State for group movement (used by CustomInteractorStyle)
         self.initial_positions: dict = {}
@@ -82,6 +77,11 @@ class MoveGroupDialog(BasePickingDialog):
 
         self.init_ui()
 
+        # After init_ui: picking an atom highlights it and updates the labels,
+        # which needs both the actor state and the widgets to exist.
+        if preselected_atoms:
+            self.on_atom_picked(preselected_atoms[0])
+
     def init_ui(self) -> None:
         """Build the move-group dialog with atom picker, translate/rotate inputs, and controls."""
         self.setWindowTitle("Move Group")

moleditpy_linux/ui/settings_tabs/settings_3d_tabs.py

@@ -37,6 +37,8 @@ class Settings3DSceneTab(SettingsTabBase):
         self.bg_button: Any = None
         self.light_checkbox: Any = None
         self.projection_combo: Any = None
+        self.realtime_drag_checkbox: Any = None
+        self.rotate_group_follow_mouse_checkbox: Any = None
         self.current_bg_color = default_settings["background_color"]
         self._setup_ui()
 
@@ -88,6 +90,24 @@ class Settings3DSceneTab(SettingsTabBase):
             self._wrap_layout(self.rotation_sens_slider, self.rotation_sens_label),
         )
 
+        self.realtime_drag_checkbox = QCheckBox()
+        self.realtime_drag_checkbox.setToolTip(
+            "Update the structure continuously while dragging an atom or group.\n"
+            "When off, the move is applied only on mouse release.\n"
+            "Structures larger than 300 atoms always use release-only updates."
+        )
+        form_layout.addRow("Real-time 3D Drag:", self.realtime_drag_checkbox)
+
+        self.rotate_group_follow_mouse_checkbox = QCheckBox()
+        self.rotate_group_follow_mouse_checkbox.setToolTip(
+            "On: right-drag rotation must start on an atom of the group,\n"
+            "and that atom follows the cursor.\n"
+            "Off: right-dragging anywhere on the 3D view rotates the group."
+        )
+        form_layout.addRow(
+            "Rotate Groups: Follow Mouse:", self.rotate_group_follow_mouse_checkbox
+        )
+
     def _select_color(self) -> None:
         color = QColorDialog.getColor(QColor(self.current_bg_color), self)
         if color.isValid():
@@ -123,6 +143,12 @@ class Settings3DSceneTab(SettingsTabBase):
 
         sens_val = settings_dict.get("mouse_rotation_sensitivity", 1.0)
         self.rotation_sens_slider.setValue(int(sens_val * 100))
+        self.realtime_drag_checkbox.setChecked(
+            settings_dict.get("realtime_3d_drag", True)
+        )
+        self.rotate_group_follow_mouse_checkbox.setChecked(
+            settings_dict.get("rotate_group_follow_mouse", False)
+        )
 
     def get_settings(self) -> dict[str, Any]:
         return {
@@ -134,6 +160,8 @@ class Settings3DSceneTab(SettingsTabBase):
             "specular_power": self.spec_power_slider.value(),
             "projection_mode": self.projection_combo.currentText(),
             "mouse_rotation_sensitivity": self.rotation_sens_slider.value() / 100.0,
+            "realtime_3d_drag": self.realtime_drag_checkbox.isChecked(),
+            "rotate_group_follow_mouse": self.rotate_group_follow_mouse_checkbox.isChecked(),
         }
 
 

moleditpy_linux/utils/constants.py

@@ -17,6 +17,9 @@ import os
 from PyQt6.QtGui import QColor, QFont
 from rdkit import Chem
 
+# Dialog classes that drive group drag / rotate gestures in the 3D view.
+MOVE_DIALOG_TYPES = ("MoveGroupDialog", "MoveSelectedAtomsDialog")
+
 
 def _get_version() -> str:
     try:

moleditpy_linux/utils/default_settings.py

@@ -21,6 +21,8 @@ DEFAULT_SETTINGS = {
     "show_3d_axes": True,
     # Camera rotation speed multiplier for the 3D scene (window-size independent).
     "mouse_rotation_sensitivity": 1.0,
+    "realtime_3d_drag": True,
+    "rotate_group_follow_mouse": False,
     # --- 3D Model Parameters (Ball and Stick) ---
     "ball_stick_atom_scale": 1.0,
     "ball_stick_bond_radius": 0.1,

{moleditpy_linux-4.4.1.dist-info → moleditpy_linux-4.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.4.1
+Version: 4.5.0
 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.4.1.dist-info → moleditpy_linux-4.5.0.dist-info}/RECORD

@@ -9,8 +9,8 @@ moleditpy_linux/core/__init__.py,sha256=BEOaCz93HzgTe0FhBzSj6Sfk8MAWxcY9vCDGmOri
 moleditpy_linux/core/mol_geometry.py,sha256=PzdJGxWs6vXwVyILBG6-6qhiVYuB33YTr8lcHRJVLNE,23933
 moleditpy_linux/core/molecular_data.py,sha256=CboEOZMjtbyRSQ7-f6kj0jngUM0Tw-7L6lU9eDtdycQ,18606
 moleditpy_linux/plugins/__init__.py,sha256=BEOaCz93HzgTe0FhBzSj6Sfk8MAWxcY9vCDGmOriJx4,267
-moleditpy_linux/plugins/plugin_interface.py,sha256=GGRQsUGSb36RgujErcQWX-dr5pm55dnQ8K75NfviAe0,22054
-moleditpy_linux/plugins/plugin_manager.py,sha256=h6QrHl57ChRKX3hpIE8-2e3qWVhEFV_-nZDCD9v_fh4,32289
+moleditpy_linux/plugins/plugin_interface.py,sha256=shBuVwQu3cQxhhM5M82EkQWMt19RcOxyXZ6CvkjXHtg,22981
+moleditpy_linux/plugins/plugin_manager.py,sha256=NzDKllVYLNaFDyV_rEDxtMyKfMWl4LFHfEKnEcOUtcA,34390
 moleditpy_linux/plugins/plugin_manager_window.py,sha256=M3JJhMWLYQ2jRZcLiPj2Ho5xXqwRwT_sb5fJaaqjr7U,13375
 moleditpy_linux/ui/__init__.py,sha256=_BslFbhSM4Ba4GDzH1XpvlqlGgvi4OFkcuU3pPeIz3s,751
 moleditpy_linux/ui/about_dialog.py,sha256=saCFGcJXoWTIwWkH3iwIPy9dRy-zlgVUKfN6x2E1S2Y,4552
@@ -19,7 +19,7 @@ moleditpy_linux/ui/alignment_dialog.py,sha256=21-RCNXHwdeD9ARQ1GZxdOS0wTeYwzQmFm
 moleditpy_linux/ui/analysis_window.py,sha256=tAsm8GLPjXGuMupM3uHbcaMVuJ3X_MZNB8yBcjECcyk,9800
 moleditpy_linux/ui/angle_dialog.py,sha256=Wgyz3VYTVJZYILxCuj_0NGtKBnq47sSg0IwlXqFRNK8,18842
 moleditpy_linux/ui/app_state.py,sha256=4Q1Lygj_1DbG83prV1I3eLbuNWtF3_19SGpVHhCxOxE,32442
-moleditpy_linux/ui/atom_item.py,sha256=fixMGu1rIyDWen5W3mt0lVS_mKZ3rAB2GmLgoB6JttY,22401
+moleditpy_linux/ui/atom_item.py,sha256=vWBINnyhN8w8GzEflibfQ268wVQJerqE0rHA-HEUGlQ,22551
 moleditpy_linux/ui/atom_picking.py,sha256=nbdFdcaEOgLQtqZXYoKQUvFyVHagPKlms96chw00m2Y,10566
 moleditpy_linux/ui/base_picking_dialog.py,sha256=F4XAx7Rrk6pZG7KECrJxNghtz4sB1JIaOd2mDsz2BfU,5975
 moleditpy_linux/ui/bond_item.py,sha256=rVjORuGLp_Cxhmw7ARTE83QM614VSIDA5LVcIYpWWc0,25995
@@ -28,7 +28,7 @@ moleditpy_linux/ui/calculation_worker.py,sha256=bwrzCW5935Twe5EY7Mtd35YQaWJILvBP
 moleditpy_linux/ui/color_settings_dialog.py,sha256=RFp8h0R1yC8YwqOxc972Da9xO95Gu-0qywAAEeXMj4E,14224
 moleditpy_linux/ui/compute_logic.py,sha256=OBEJvw4atAaEXIv4eueoilIjTF1sxvJQGQB4ABOthYA,31462
 moleditpy_linux/ui/constrained_optimization_dialog.py,sha256=rc3YK6DOJdIbhriwsM2jOAW9j_-3PvFz1XtFHpGw4E4,36346
-moleditpy_linux/ui/custom_interactor_style.py,sha256=0bN4UiSH6YVSx4mYSnY0tW8KyDnBAtxrGKd_P5NajB8,49226
+moleditpy_linux/ui/custom_interactor_style.py,sha256=ut4p-S4iUr8lTVp2T1m_-d7l9pSUCoOdzk08qssECn8,65499
 moleditpy_linux/ui/custom_qt_interactor.py,sha256=76L0Jpbg09VXzHOzJs9kG260Vs9qcwbt8Chn0iOopDg,2820
 moleditpy_linux/ui/dialog_3d_picking_mixin.py,sha256=nsZQ27PYZrO9s_w5EXxxluVfOOmNKcv0vvm89IWN7mU,10604
 moleditpy_linux/ui/dialog_logic.py,sha256=KCz3ZPJap4K_tiNDjCzGqQHYxdEsvcUG6Lws2tDhvx4,19617
@@ -43,7 +43,7 @@ moleditpy_linux/ui/main_window_init.py,sha256=94_Sf_E5ZTtkyQvSIURWXbuXxabg46L0Ax
 moleditpy_linux/ui/mirror_dialog.py,sha256=Tsc2O9Ktjz0zzJWB_YkVgkqgDhytQ7ksN_PwpcY9vJI,5169
 moleditpy_linux/ui/molecular_scene_handler.py,sha256=p_OhYC965qden-aFQVifNTcMMi_Ikx8TzCwH9XgWR3A,70110
 moleditpy_linux/ui/molecule_scene.py,sha256=ZUZBaCyWaNEAITHI4JmJ__gQcI9kgttj8qBP6dgF6LU,44090
-moleditpy_linux/ui/move_group_dialog.py,sha256=3jfj8zmKrYs0N9537o3g0V3f0UOnr0pj8uNT0qvUlPM,27063
+moleditpy_linux/ui/move_group_dialog.py,sha256=elgrjcSh3uP6sPc5WLgDI9EvtpiGPcutaKkmNJg-taM,27096
 moleditpy_linux/ui/move_selected_atoms_dialog.py,sha256=7_Krz69LDx71_pBr9_bP55UhT97SJZU-W6OEN59waDg,29889
 moleditpy_linux/ui/periodic_table_dialog.py,sha256=yadE1bbJaObAiIfpKwANqiDOBI8R3yOHvDTZYrw1J4Q,6134
 moleditpy_linux/ui/planarize_dialog.py,sha256=PvEXAx27iO3d9OWrr0kL4WTeNI2eMIx-FRZaFWW-cao,7936
@@ -59,18 +59,18 @@ moleditpy_linux/ui/view_3d_logic.py,sha256=fuXQKAQFH8e_Xm6e8mG2y4EN2EnBqFxJRqslo
 moleditpy_linux/ui/zoomable_view.py,sha256=Kpr9SaIYAKH-Fexm5-gi3cswsiT5V7g7yTk7acutZjA,6239
 moleditpy_linux/ui/settings_tabs/__init__.py,sha256=BEOaCz93HzgTe0FhBzSj6Sfk8MAWxcY9vCDGmOriJx4,267
 moleditpy_linux/ui/settings_tabs/settings_2d_tab.py,sha256=GbiRYuf1Jem7TsdXL9Kcdp_SNx4vuBG6f5_PanJgBU0,15294
-moleditpy_linux/ui/settings_tabs/settings_3d_tabs.py,sha256=2KAx0-AXefaWEXoxWFs2ELMBU5NCkmipOfPa-DKFc78,12480
+moleditpy_linux/ui/settings_tabs/settings_3d_tabs.py,sha256=GqHS8Ni17fPyPAS1ElnLr4Q5Fr2zDjsU2qA8VHe-fP0,13910
 moleditpy_linux/ui/settings_tabs/settings_other_tab.py,sha256=gCg9ambXvN9WCYWaH5qDgbQzvom02Vscrbp0Pt4NrFM,7295
 moleditpy_linux/ui/settings_tabs/settings_tab_base.py,sha256=c7nX6I0-8mgemI9q9cVSwDWtJSOU36laEfNiq7hOprE,3619
 moleditpy_linux/utils/__init__.py,sha256=BEOaCz93HzgTe0FhBzSj6Sfk8MAWxcY9vCDGmOriJx4,267
-moleditpy_linux/utils/constants.py,sha256=JjNnXLHCrquuCgYUfehZ44I9-CJzQeGIQwARIyHUC0o,7872
-moleditpy_linux/utils/default_settings.py,sha256=K3wzi3cj4WAoyO_2xD8_XCNkzZpcrZYqSVIoLmP_R-4,3018
+moleditpy_linux/utils/constants.py,sha256=73UzGo1aJBp_jDulb_1F2TUz6YTcI_4_wWuOV3qnexM,8016
+moleditpy_linux/utils/default_settings.py,sha256=c3FfGWpaCvUYLJ57fdMhWyqGEeaYEbClPoVKZ9LPxn8,3090
 moleditpy_linux/utils/sip_isdeleted_safe.py,sha256=aXoW_PDHAsu0SkqcvkUZAsWDhl9Ka8-VnzgNE5ub41Y,1215
 moleditpy_linux/utils/suppress_log.py,sha256=EFkN79q6QfYXAuii8g1fBuvFJrnVsio3aFTKMvAmXW4,928
 moleditpy_linux/utils/system_utils.py,sha256=j1RAiiKXg3N-rjpTh7yxKVAYED_kUJy4aVrY-9Hh0Mc,2674
-moleditpy_linux-4.4.1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-moleditpy_linux-4.4.1.dist-info/METADATA,sha256=dfwO08W-auR4Wb7PGGQ1s7yaNNA8WI_LqPN-wIoqaoc,65353
-moleditpy_linux-4.4.1.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-moleditpy_linux-4.4.1.dist-info/entry_points.txt,sha256=-OzipSi__yVwlimNtu3eiRP5t5UMg55Cs0udyhXYiyw,60
-moleditpy_linux-4.4.1.dist-info/top_level.txt,sha256=qyqe-hDYL6CXyin9E5Me5rVl3PG84VqiOjf9bQvfJLs,16
-moleditpy_linux-4.4.1.dist-info/RECORD,,
+moleditpy_linux-4.5.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+moleditpy_linux-4.5.0.dist-info/METADATA,sha256=K2BAcuLvCky-mQGYbzrNRCgpOhn5Zh_CUjmyc_Emmas,65353
+moleditpy_linux-4.5.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+moleditpy_linux-4.5.0.dist-info/entry_points.txt,sha256=-OzipSi__yVwlimNtu3eiRP5t5UMg55Cs0udyhXYiyw,60
+moleditpy_linux-4.5.0.dist-info/top_level.txt,sha256=qyqe-hDYL6CXyin9E5Me5rVl3PG84VqiOjf9bQvfJLs,16
+moleditpy_linux-4.5.0.dist-info/RECORD,,