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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.3.1
+Version: 4.4.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.3.1 → moleditpy_linux-4.4.0}/pyproject.toml

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.3.1
+Version: 4.4.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.3.1 → moleditpy_linux-4.4.0}/src/moleditpy_linux/ui/app_state.py

@@ -420,6 +420,19 @@ class StateManager:
                             # Skip property access if atom data is inconsistent
                             original_id = None
 
+                        # Implicit/explicit H counts raise on an unsanitized mol
+                        # (e.g. an XYZ import whose valences never passed
+                        # sanitization). Default to 0 so the structure still saves
+                        # and round-trips via the binary rather than being dropped.
+                        try:
+                            num_explicit_hs = atom.GetNumExplicitHs()
+                        except (RuntimeError, ValueError):
+                            num_explicit_hs = 0
+                        try:
+                            num_implicit_hs = atom.GetNumImplicitHs()
+                        except (RuntimeError, ValueError):
+                            num_implicit_hs = 0
+
                         atom_3d = {
                             "index": i,
                             "symbol": atom.GetSymbol(),
@@ -428,8 +441,8 @@ class StateManager:
                             "y": pos.y,
                             "z": pos.z,
                             "formal_charge": atom.GetFormalCharge(),
-                            "num_explicit_hs": atom.GetNumExplicitHs(),
-                            "num_implicit_hs": atom.GetNumImplicitHs(),
+                            "num_explicit_hs": num_explicit_hs,
+                            "num_implicit_hs": num_implicit_hs,
                             # include original editor atom id when available for round-trip
                             "original_id": original_id,
                         }
@@ -462,17 +475,21 @@ class StateManager:
                     "constraints_3d": json_safe_constraints,
                 }
 
-                # Molecular info
-                json_data["molecular_info"] = {
-                    "num_atoms": self.host.view_3d_manager.current_mol.GetNumAtoms(),
-                    "num_bonds": self.host.view_3d_manager.current_mol.GetNumBonds(),
-                    "molecular_weight": Descriptors.MolWt(
-                        self.host.view_3d_manager.current_mol
-                    ),
-                    "formula": rdMolDescriptors.CalcMolFormula(
-                        self.host.view_3d_manager.current_mol
-                    ),
-                }
+                # Molecular info — MolWt/CalcMolFormula can raise on an
+                # unsanitized mol; keep it optional so it never blocks the save.
+                try:
+                    json_data["molecular_info"] = {
+                        "num_atoms": self.host.view_3d_manager.current_mol.GetNumAtoms(),
+                        "num_bonds": self.host.view_3d_manager.current_mol.GetNumBonds(),
+                        "molecular_weight": Descriptors.MolWt(
+                            self.host.view_3d_manager.current_mol
+                        ),
+                        "formula": rdMolDescriptors.CalcMolFormula(
+                            self.host.view_3d_manager.current_mol
+                        ),
+                    }
+                except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                    logging.warning("Could not compute molecular info: %s", e)
 
                 # Identifiers (SMILES/InChI)
                 try:
@@ -637,7 +654,9 @@ class StateManager:
                                                 ValueError,
                                                 TypeError,
                                                 IndexError,
-                                            ):  # [RDKIT GUARD] RDKit atom property assignment may fail on invalid ids; skip silently.
+                                            ):
+                                                # [RDKIT GUARD] property set may
+                                                # fail on invalid ids; skip.
                                                 logging.debug(
                                                     "Suppressed non-critical error",
                                                     exc_info=True,

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

@@ -25,6 +25,16 @@ from .atom_picking import pick_atom_index_from_screen
 
 from rdkit import Geometry
 
+# VTK's trackball state id for camera rotation (VTKIS_ROTATE); the enum is not
+# exposed to Python, so the literal is used with this name for clarity.
+_VTKIS_ROTATE = 1
+
+# Reference 3D-canvas size (px) that camera rotation speed is normalized to.
+# VTK's stock Rotate divides motion by the live render size, so rotation slows
+# as the canvas grows; normalizing to a fixed reference makes the speed
+# window-size independent and matches the feel at the default window size.
+_ROTATION_REFERENCE_SIZE = 640.0
+
 
 class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
     """VTK interactor style extending trackball-camera with 3D atom drag and measurement."""
@@ -81,6 +91,43 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                 # Safe defensive fallback catching AttributeError, RuntimeError
                 logging.debug("Suppressed non-critical error", exc_info=True)
 
+    def _rotate_size_independent(self) -> None:
+        """Rotate the camera at a speed that does not depend on canvas size.
+
+        Mirrors vtkInteractorStyleTrackballCamera::Rotate but normalizes the
+        per-pixel azimuth/elevation to a fixed reference size instead of the
+        live render size, and scales by the user's rotation-sensitivity setting.
+        """
+        renderer = self.GetCurrentRenderer()
+        interactor = self.GetInteractor()
+        if renderer is None or interactor is None:
+            return
+
+        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
+        camera = renderer.GetActiveCamera()
+        camera.Azimuth(dx * delta)
+        camera.Elevation(dy * delta)
+        camera.OrthogonalizeViewUp()
+
+        if self.GetAutoAdjustCameraClippingRange():
+            renderer.ResetCameraClippingRange()
+        if interactor.GetLightFollowCamera():
+            renderer.UpdateLightsGeometryToFollowCamera()
+        interactor.Render()
+
     def _stop_vtk_left_button_state(self) -> None:
         """Clear VTK's button/drag state after a custom-handled left click."""
         try:
@@ -159,9 +206,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 +319,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 +428,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 +495,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
         ):
@@ -453,8 +548,14 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             # Custom atom drag
             self.is_dragging = True
         else:
-            # Delegate camera rotation to parent
-            super().OnMouseMove()
+            # Camera interaction. VTK's built-in Rotate divides mouse motion by
+            # the live render size, so rotation slows as the canvas grows. Handle
+            # the rotate state ourselves for window-size-independent speed;
+            # delegate pan/dolly/spin to the parent unchanged.
+            if self.GetState() == _VTKIS_ROTATE:
+                self._rotate_size_independent()
+            else:
+                super().OnMouseMove()
 
             # Update cursor display
             is_edit_active = (

moleditpy_linux-4.4.0/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.4.0}/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.4.0}/src/moleditpy_linux/ui/io_logic.py

@@ -35,7 +35,12 @@ from PyQt6.QtWidgets import (
 from rdkit import Chem
 from rdkit.Chem import AllChem, rdGeometry, rdMolTransforms, Descriptors
 
-from ..utils.constants import COVALENT_RADII, DUMMY_XYZ_SYMBOLS, VERSION
+from ..utils.constants import (
+    COVALENT_RADII,
+    DUMMY_XYZ_SYMBOLS,
+    VALID_ELEMENT_SYMBOLS,
+    VERSION,
+)
 
 
 class IOManager:
@@ -97,6 +102,38 @@ class IOManager:
         lines[3] = self.fix_mol_counts_line(lines[3])
         return "\n".join(lines)
 
+    @staticmethod
+    def _is_numeric_token(token: str) -> bool:
+        """True if *token* parses as a float."""
+        try:
+            float(token)
+            return True
+        except ValueError:
+            return False
+
+    @staticmethod
+    def _extract_xyz_coords(tokens: list[str]) -> Optional[Tuple[float, float, float]]:
+        """Return the first three float-parseable tokens as (x, y, z).
+
+        Skips non-numeric separator/label columns so ghost-atom rows like
+        ``XX : x y z`` (a colon in the second column) parse the same as a
+        standard ``symbol x y z`` row. Returns None if fewer than three numbers
+        are present.
+        """
+        nums: list[float] = []
+        for tok in tokens:
+            try:
+                nums.append(float(tok))
+            except ValueError:
+                if nums:
+                    break  # trailing non-numeric column after the coordinates
+                continue  # leading label/separator column before the coordinates
+            if len(nums) == 3:
+                break
+        if len(nums) == 3:
+            return (nums[0], nums[1], nums[2])
+        return None
+
     def _normalize_xyz_symbol(self, raw_symbol: str) -> Tuple[str, bool]:
         """Return the RDKit symbol for an XYZ atom and whether it is a dummy."""
         stripped = raw_symbol.strip()
@@ -105,11 +142,11 @@ class IOManager:
         if stripped.upper() in DUMMY_XYZ_SYMBOLS:
             return "*", True
         symbol = stripped.capitalize()
-        try:
-            atomic_num = Chem.GetPeriodicTable().GetAtomicNumber(symbol)
-        except (RuntimeError, ValueError, TypeError):
-            return "*", True
-        if atomic_num <= 0:
+        # Membership test rather than GetAtomicNumber(symbol): the latter makes
+        # RDKit's C++ layer print an "Element 'Xx' not found" violation to
+        # stderr for any dummy/pseudo label even though we catch the exception,
+        # which users read as a failed load.
+        if symbol not in VALID_ELEMENT_SYMBOLS:
             return "*", True
         return symbol, False
 
@@ -138,9 +175,19 @@ class IOManager:
 
         atoms_data = []
         has_dummy_atoms = False
-        atom_lines = lines[atom_start : atom_start + num_atoms]
+        nonstandard_rows = 0
+        atom_end = atom_start + num_atoms
+        atom_lines = lines[atom_start:atom_end]
         if len(atom_lines) < num_atoms:
-            raise ValueError("XYZ file format error: fewer atom rows than expected")
+            # Header count exceeds the rows present (truncated / miscounted file).
+            # Load the atoms that are actually there rather than refusing the
+            # whole file, so any parseable XYZ still opens.
+            logging.warning(
+                "XYZ declares %d atoms but only %d rows present; loading %d.",
+                num_atoms,
+                len(atom_lines),
+                len(atom_lines),
+            )
 
         for i, line in enumerate(atom_lines):
             parts = line.split()
@@ -149,9 +196,15 @@ class IOManager:
             raw_symbol = parts[0]
             symbol, is_dummy = self._normalize_xyz_symbol(raw_symbol)
             has_dummy_atoms = has_dummy_atoms or is_dummy
-            atoms_data.append(
-                (symbol, float(parts[1]), float(parts[2]), float(parts[3]))
-            )
+            coords = self._extract_xyz_coords(parts[1:])
+            if coords is None:
+                raise ValueError(f"Invalid atom data at line {atom_start + i + 1}")
+            # Standard rows put coordinates in the first three columns after the
+            # symbol; a non-numeric first column means an extra separator/label
+            # (e.g. the ':' in "XX : x y z") was skipped — flag it for the user.
+            if not self._is_numeric_token(parts[1]):
+                nonstandard_rows += 1
+            atoms_data.append((symbol, *coords))
 
         if not atoms_data:
             raise ValueError("No valid atoms found in XYZ file")
@@ -162,6 +215,8 @@ class IOManager:
             atom = Chem.Atom(symbol)
             atom.SetIntProp("xyz_unique_id", i)
             if atom.GetAtomicNum() == 0:
+                # Ghost/dummy rows (e.g. "XX : x y z") load as the wildcard "*";
+                # stash the real label token so it is kept for round-tripping.
                 atom.SetProp("xyz_original_symbol", atom_lines[i].split()[0])
             mol.AddAtom(atom)
             conf.SetAtomPosition(i, rdGeometry.Point3D(x, y, z))
@@ -190,7 +245,16 @@ class IOManager:
                 _set_prop(candidate, "_xyz_charge", charge_val)
                 return candidate
             else:
-                self.estimate_bonds_from_distances(mol)
+                # Distance-based bonding is best-effort: a failure here must not
+                # lose the molecule. The skip/dummy path only needs atoms and
+                # coordinates, so fall back to a bond-free structure so that any
+                # parseable XYZ still loads.
+                try:
+                    self.estimate_bonds_from_distances(mol)
+                except (RuntimeError, ValueError, TypeError, AttributeError) as e:
+                    logging.warning(
+                        "Bond estimation failed; loading atoms without bonds: %s", e
+                    )
                 candidate = mol.GetMol()
                 _set_prop(candidate, "_xyz_charge", charge_val)
                 return candidate
@@ -240,6 +304,8 @@ class IOManager:
 
         if final_mol:
             final_mol.xyz_atom_data = atoms_data
+            if nonstandard_rows:
+                _set_prop(final_mol, "_xyz_nonstandard_rows", nonstandard_rows)
         return final_mol
 
     def _report_load_error(self, title: str, message: str) -> None:
@@ -866,9 +932,17 @@ class IOManager:
             self.host.view_3d_manager.update_atom_id_menu_state()
 
             if self.host.statusBar():
-                self.host.statusBar().showMessage(
-                    f"3D Viewer Mode: Loaded {os.path.basename(file_path)}"
-                )
+                message = f"3D Viewer Mode: Loaded {os.path.basename(file_path)}"
+                nonstandard = 0
+                with suppress_log(AttributeError, KeyError, RuntimeError, TypeError):
+                    if mol.HasProp("_xyz_nonstandard_rows"):
+                        nonstandard = mol.GetIntProp("_xyz_nonstandard_rows")
+                if nonstandard:
+                    message += (
+                        f" (non-standard columns in {nonstandard} row(s); "
+                        "coordinates read from the numeric columns)"
+                    )
+                self.host.statusBar().showMessage(message)
             self.host.set_current_file_path(file_path)
             self.host.set_has_unsaved_changes(False)
             self.host.state_manager.update_window_title()

{moleditpy_linux-4.3.1 → moleditpy_linux-4.4.0}/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.4.0}/src/moleditpy_linux/ui/settings_tabs/settings_3d_tabs.py

@@ -78,6 +78,16 @@ class Settings3DSceneTab(SettingsTabBase):
         self.projection_combo.addItems(["Perspective", "Orthographic"])
         form_layout.addRow("Projection Mode:", self.projection_combo)
 
+        # Camera rotation speed (0.10x–3.00x). Speed is normalized to a fixed
+        # reference canvas size, so it stays constant regardless of window size.
+        self.rotation_sens_slider, self.rotation_sens_label = self._create_slider(
+            10, 300, 100.0
+        )
+        form_layout.addRow(
+            "Mouse Rotation Speed:",
+            self._wrap_layout(self.rotation_sens_slider, self.rotation_sens_label),
+        )
+
     def _select_color(self) -> None:
         color = QColorDialog.getColor(QColor(self.current_bg_color), self)
         if color.isValid():
@@ -111,6 +121,9 @@ class Settings3DSceneTab(SettingsTabBase):
         if idx >= 0:
             self.projection_combo.setCurrentIndex(idx)
 
+        sens_val = settings_dict.get("mouse_rotation_sensitivity", 1.0)
+        self.rotation_sens_slider.setValue(int(sens_val * 100))
+
     def get_settings(self) -> dict[str, Any]:
         return {
             "background_color": self.current_bg_color,
@@ -120,6 +133,7 @@ class Settings3DSceneTab(SettingsTabBase):
             "specular": self.specular_slider.value() / 100.0,
             "specular_power": self.spec_power_slider.value(),
             "projection_mode": self.projection_combo.currentText(),
+            "mouse_rotation_sensitivity": self.rotation_sens_slider.value() / 100.0,
         }
 
 

{moleditpy_linux-4.3.1 → moleditpy_linux-4.4.0}/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 → moleditpy_linux-4.4.0}/src/moleditpy_linux/utils/constants.py

@@ -24,7 +24,8 @@ def _get_version() -> str:
 
         try:
             return version("MoleditPy-linux")
-        except PackageNotFoundError:  # [OPTIONAL] Package not installed in editable mode; fall through to pyproject.toml.
+        except PackageNotFoundError:
+            # [OPTIONAL] Not installed in editable mode; fall through to pyproject.toml.
             logging.debug("Suppressed non-critical error", exc_info=True)
     except ImportError:
         logging.debug("Suppressed non-critical error", exc_info=True)
@@ -209,6 +210,13 @@ DEFAULT_CPK_COLORS = {
 
 
 pt = Chem.GetPeriodicTable()
+# Real element symbols (H..Og). Membership-test against this instead of calling
+# GetAtomicNumber() on an unknown label: probing the periodic table with a
+# non-element makes RDKit's C++ layer print an alarming "Element 'Xx' not found"
+# violation to stderr even when the Python exception is caught.
+VALID_ELEMENT_SYMBOLS: frozenset[str] = frozenset(
+    pt.GetElementSymbol(i) for i in range(1, 119)
+)
 # 0.3-scaled vdW radii for 3D display only — not physical values
 VDW_DISPLAY_RADII = {pt.GetElementSymbol(i): pt.GetRvdw(i) * 0.3 for i in range(1, 119)}
 # Deprecated alias kept for external plugins

{moleditpy_linux-4.3.1 → moleditpy_linux-4.4.0}/src/moleditpy_linux/utils/default_settings.py

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

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