MoleditPy-linux 3.6.0__py3-none-any.whl → 3.6.2__py3-none-any.whl

moleditpy_linux/__init__.py

@@ -8,15 +8,14 @@ Author: Hiromichi Yokoyama
 License: GPL-3.0 license
 Repo: https://github.com/HiroYokoyama/python_molecular_editor
 DOI: 10.5281/zenodo.17268532
-"""
 
-"""Top-level package for moleditpy_linux."""
+Top-level package for moleditpy_linux.
+"""
 
 import importlib.util
+from .utils.constants import VERSION as __version__  # noqa: F401
 
 try:
     OBABEL_AVAILABLE = False
 except ImportError:
     OBABEL_AVAILABLE = False
-
-from .utils.constants import VERSION as __version__  # noqa: F401

moleditpy_linux/ui/atom_picking.py

@@ -13,6 +13,7 @@ DOI: 10.5281/zenodo.17268532
 from __future__ import annotations
 
 from typing import Any, Optional
+import logging
 
 import numpy as np
 
@@ -101,7 +102,7 @@ def _projected_radius_px(
     return radius_px
 
 
-def pick_atom_index_from_screen(
+def pick_atom_index_from_screen_sequential(
     view_3d_manager: Any,
     click_pos: tuple[int, int],
     mol: Optional[Any] = None,
@@ -161,3 +162,149 @@ def pick_atom_index_from_screen(
             best_score = score
 
     return best_idx
+
+
+def pick_atom_index_from_screen_vectorized(
+    view_3d_manager: Any,
+    click_pos: tuple[int, int],
+    mol: Optional[Any] = None,
+    padding_px: float = 8.0,
+    min_radius_px: float = 14.0,
+    max_radius_px: float = 96.0,
+) -> Optional[int]:
+    """
+    Vectorized atom picking using the camera's projection matrix.
+    Eliminates the O(N) Python loop and VTK C++ boundary calls.
+    """
+    try:
+        plotter = view_3d_manager.plotter
+        renderer = plotter.renderer
+        positions = view_3d_manager.atom_positions_3d
+    except (AttributeError, RuntimeError, TypeError):
+        return None
+
+    if positions is None or len(positions) == 0:
+        return None
+
+    try:
+        positions_array = np.asarray(positions, dtype=float)  # Shape: (N, 3)
+    except (TypeError, ValueError):
+        return None
+
+    if positions_array.ndim != 2 or positions_array.shape[1] < 3:
+        return None
+
+    if mol is None:
+        mol = getattr(view_3d_manager, "current_mol", None)
+
+    try:
+        atom_count = int(mol.GetNumAtoms()) if mol is not None else len(positions_array)
+    except (AttributeError, RuntimeError, TypeError, ValueError):
+        atom_count = len(positions_array)
+
+    active_atoms = min(atom_count, len(positions_array))
+    if active_atoms == 0:
+        return None
+
+    positions_array = positions_array[:active_atoms]
+
+    # 1. Retrieve the View-Projection (Composite) Matrix from the active camera
+    try:
+        camera = renderer.GetActiveCamera()
+        aspect_ratio = renderer.GetTiledAspectRatio()
+        # Get the 4x4 composite projection matrix (vtkMatrix4x4)
+        vtk_matrix = camera.GetCompositeProjectionTransformMatrix(aspect_ratio, -1, 1)
+
+        # Convert vtkMatrix4x4 to a NumPy 4x4 array
+        matrix = np.zeros((4, 4))
+        for i in range(4):
+            for j in range(4):
+                matrix[i, j] = vtk_matrix.GetElement(i, j)
+    except Exception:
+        return None
+
+    # 2. Convert all N world coordinates to homogeneous coordinates (N, 4)
+    homogeneous_coords = np.hstack([positions_array, np.ones((active_atoms, 1))])
+
+    # 3. Apply Matrix Multiplication: (N, 4) x (4, 4).T -> Clip Space Coordinates
+    clip_coords = homogeneous_coords @ matrix.T
+
+    # 4. Perform Perspective Divide -> Normalized Device Coordinates (NDC)
+    w = clip_coords[:, 3:4]
+    w_copy = np.copy(w)
+    w_copy[np.abs(w_copy) < 1e-5] = 1.0
+    ndc_coords = clip_coords[:, :3] / w_copy
+
+    # 5. Transform NDC to Screen/Display Coordinates
+    try:
+        size = renderer.GetSize()  # (width, height)
+    except Exception:
+        return None
+
+    # VTK display space coordinates: X: [0, W], Y: [0, H]
+    display_coords = np.zeros((active_atoms, 2))
+    display_coords[:, 0] = (ndc_coords[:, 0] + 1.0) * 0.5 * size[0]
+    display_coords[:, 1] = (ndc_coords[:, 1] + 1.0) * 0.5 * size[1]
+
+    # 6. Vectorized Distance and Hit Radius Calculation
+    dx = display_coords[:, 0] - click_pos[0]
+    dy = display_coords[:, 1] - click_pos[1]
+    distances = np.hypot(dx, dy)
+
+    try:
+        if camera.GetParallelProjection():
+            pixel_scale = size[1] / (2.0 * camera.GetParallelScale())
+        else:
+            view_angle_rad = np.radians(camera.GetViewAngle())
+            pixel_scale = size[1] / (
+                2.0 * np.abs(w.flatten()) * np.tan(view_angle_rad / 2.0)
+            )
+    except Exception:
+        pixel_scale = 20.0  # Safe fallback scale
+
+    # Pre-calculate world radii for all atoms
+    world_radii = np.array(
+        [_atom_world_radius(view_3d_manager, mol, idx) for idx in range(active_atoms)]
+    )
+
+    projected_radii = world_radii * pixel_scale
+    hit_radii = np.maximum(
+        min_radius_px, np.minimum(max_radius_px, projected_radii + padding_px)
+    )
+
+    # 7. Mask out atoms that are further than their hit radius
+    valid_mask = distances <= hit_radii
+    if not np.any(valid_mask):
+        return None
+
+    # 8. Score calculation and find the best index
+    # Tie-breaking logic: (ratio) + (distances * 1e-8)
+    scores = (distances / hit_radii) + (distances * 1e-8)
+
+    scores[~valid_mask] = np.inf
+    best_idx = int(np.argmin(scores))
+
+    return best_idx if scores[best_idx] != np.inf else None
+
+
+def pick_atom_index_from_screen(
+    view_3d_manager: Any,
+    click_pos: tuple[int, int],
+    mol: Optional[Any] = None,
+    padding_px: float = 8.0,
+    min_radius_px: float = 14.0,
+    max_radius_px: float = 96.0,
+) -> Optional[int]:
+    """Return the atom nearest a screen click, trying vectorized first, falling back to sequential."""
+    try:
+        best_idx = pick_atom_index_from_screen_vectorized(
+            view_3d_manager, click_pos, mol, padding_px, min_radius_px, max_radius_px
+        )
+        if best_idx is not None:
+            return best_idx
+    except Exception as e:
+        logging.debug("Vectorized picking failed, falling back to sequential: %s", e)
+
+    return pick_atom_index_from_screen_sequential(
+        view_3d_manager, click_pos, mol, padding_px, min_radius_px, max_radius_px
+    )

moleditpy_linux/ui/constrained_optimization_dialog.py

@@ -877,6 +877,3 @@ class ConstrainedOptimizationDialog(Dialog3DPickingMixin, QDialog):
 
         # Default processing for other keys
         QDialog.keyPressEvent(self, event)
-
-
-from typing import Any

moleditpy_linux/ui/custom_interactor_style.py

@@ -405,7 +405,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             dx = current_pos[0] - move_group_dialog._drag_start_pos[0]
             dy = current_pos[1] - move_group_dialog._drag_start_pos[1]
 
-            if abs(dx) > 2 or abs(dy) > 2:
+            if abs(dx) > 5 or abs(dy) > 5:
                 move_group_dialog._mouse_moved = True
 
             return  # Disable camera rotation
@@ -423,7 +423,7 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             dx = current_pos[0] - move_group_dialog._rotation_start_pos[0]
             dy = current_pos[1] - move_group_dialog._rotation_start_pos[1]
 
-            if abs(dx) > 2 or abs(dy) > 2:
+            if abs(dx) > 5 or abs(dy) > 5:
                 move_group_dialog._rotation_mouse_moved = True
 
             return  # Disable camera rotation
@@ -493,6 +493,13 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
             if getattr(
                 move_group_dialog, "_is_dragging_group_vtk", False
             ) and not getattr(move_group_dialog, "_mouse_moved", False):
+                # No drag = click only -> toggle
+                clicked_atom = getattr(move_group_dialog, "_drag_atom_idx", None)
+                if clicked_atom is not None:
+                    try:
+                        move_group_dialog.on_atom_picked(clicked_atom)
+                    except (AttributeError, RuntimeError, TypeError, ValueError) as e:
+                        logging.error(f"Error in toggle: {e}")
                 # Reset if multi-clicked without drag
                 move_group_dialog._is_dragging_group_vtk = False
                 move_group_dialog._drag_start_pos = None

moleditpy_linux/ui/edit_3d_logic.py

@@ -12,15 +12,25 @@ DOI: 10.5281/zenodo.17268532
 
 from __future__ import annotations
 
-"""
-main_window_edit_3d.py
-Mixin class separated from main_window.py
-"""
+# main_window_edit_3d.py
+# Mixin class separated from main_window.py
 
 import logging
 from typing import Any, List, Optional
 
 import numpy as np
+import pyvista as pv
+from PyQt6.QtCore import QPointF
+from PyQt6.QtGui import QColor, QFont
+from PyQt6.QtWidgets import QGraphicsTextItem
+
+try:
+    from PyQt6 import sip as _sip  # type: ignore
+
+    _sip_isdeleted = getattr(_sip, "isdeleted", None)
+except ImportError:
+    _sip = None  # type: ignore[assignment]
+    _sip_isdeleted = None
 
 try:
     from .mol_geometry import (
@@ -41,20 +51,6 @@ try:
 except ImportError:
     from moleditpy_linux.utils.sip_isdeleted_safe import sip_isdeleted_safe
 
-# PyQt6 Modules
-import pyvista as pv
-from PyQt6.QtCore import QPointF
-from PyQt6.QtGui import QColor, QFont
-from PyQt6.QtWidgets import QGraphicsTextItem
-
-try:
-    from PyQt6 import sip as _sip  # type: ignore
-
-    _sip_isdeleted = getattr(_sip, "isdeleted", None)
-except ImportError:
-    _sip = None  # type: ignore[assignment]
-    _sip_isdeleted = None
-
 try:
     # package relative imports (preferred when running as `python -m moleditpy`)
     from .constants import VDW_RADII
@@ -169,8 +165,8 @@ class Edit3DManager:
             return
 
         # Prepare label positions and text
-        atom_indices = [l[0] for l in self.measurement_labels]
-        labels = [l[1] for l in self.measurement_labels]
+        atom_indices = [item[0] for item in self.measurement_labels]
+        labels = [item[1] for item in self.measurement_labels]
         positions = []
         texts = []
         positions_3d = self.host.view_3d_manager.atom_positions_3d

moleditpy_linux/ui/edit_actions_logic.py

@@ -1443,9 +1443,9 @@ class EditActionsManager:
                         pos_i = positions_i[k]
                         vdw_i = vdw_i_all[k]
 
-                        for l, _ in enumerate(frag_j["indices"]):
-                            pos_j = positions_j[l]
-                            vdw_j = vdw_j_all[l]
+                        for idx, _ in enumerate(frag_j["indices"]):
+                            pos_j = positions_j[idx]
+                            vdw_j = vdw_j_all[idx]
 
                             distance_vec = pos_i - pos_j
                             distance_sq = np.dot(

moleditpy_linux/ui/molecular_scene_handler.py

@@ -32,11 +32,10 @@ except ImportError:
     from moleditpy_linux.utils.sip_isdeleted_safe import sip_isdeleted_safe
 
 try:
-    from ..utils.constants import DEFAULT_BOND_LENGTH, SNAP_DISTANCE, SUM_TOLERANCE
+    from ..utils.constants import DEFAULT_BOND_LENGTH, SUM_TOLERANCE
 except ImportError:
     from moleditpy_linux.utils.constants import (
         DEFAULT_BOND_LENGTH,
-        SNAP_DISTANCE,
         SUM_TOLERANCE,
     )
 
@@ -724,7 +723,9 @@ class KeyboardMixin:
 
     temp_line: Optional[QGraphicsLineItem]
 
-    def _calculate_new_atom_position(self, start_atom: Any, bond_length: Any) -> Any:
+    def _calculate_new_atom_position(
+        self, start_atom: Any, bond_length: Any, target_order: int = 1
+    ) -> Any:
         """
         Calculate the position for a new atom based on the surroundings of start_atom.
         Returns the offset QPointF.
@@ -752,8 +753,12 @@ class KeyboardMixin:
             other_atom = bond.atom1 if bond.atom2 is start_atom else bond.atom2
             existing_bond_vector = start_pos - other_atom.pos()
 
-            # Rotate 60° clockwise from existing bond
-            angle_rad = math.radians(60)
+            # Rotate 60° clockwise/anticlockwise from existing bond (or 0°/180° straight continuation for alkyne)
+            is_clockwise = getattr(self, "placement_direction_clockwise", True)
+            angle_deg = 60 if is_clockwise else -60
+            if target_order == 3 or getattr(bond, "order", 1) == 3:
+                angle_deg = 0
+            angle_rad = math.radians(angle_deg)
             cos_a, sin_a = math.cos(angle_rad), math.sin(angle_rad)
             vx, vy = existing_bond_vector.x(), existing_bond_vector.y()
             new_vx, new_vy = vx * cos_a - vy * sin_a, vx * sin_a + vy * cos_a
@@ -820,9 +825,9 @@ class KeyboardMixin:
         if key == Qt.Key.Key_4:
             snap_dist = self.get_setting("template_snapping_distance_2d", 14.0)
             item_at_cursor = self.find_atom_near(cursor_pos, tol=snap_dist)
-        elif self.get_setting("template_fusing_enabled_2d", True):
-            fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-            item_at_cursor = self.find_atom_near(cursor_pos, tol=fuse_dist)
+        else:
+            snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+            item_at_cursor = self.find_atom_near(cursor_pos, tol=snap_dist)
         if item_at_cursor is None:
             item_at_cursor = self.itemAt(cursor_pos, transform)
 
@@ -1160,7 +1165,7 @@ class KeyboardMixin:
                     start_pos = start_atom.pos()
                     bond_len = DEFAULT_BOND_LENGTH
                     new_pos_offset = self._calculate_new_atom_position(
-                        start_atom, bond_len
+                        start_atom, bond_len, target_order
                     )
 
                     # SNAP_DISTANCE is a module-level constant
@@ -1168,11 +1173,8 @@ class KeyboardMixin:
 
                     # Find nearby atom
                     near_atom = None
-                    if self.get_setting("template_fusing_enabled_2d", True):
-                        fuse_dist = self.get_setting(
-                            "template_fusing_distance_2d", SNAP_DISTANCE
-                        )
-                        near_atom = self.find_atom_near(target_pos, tol=fuse_dist)
+                    snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+                    near_atom = self.find_atom_near(target_pos, tol=snap_dist)
 
                     if near_atom and near_atom is not start_atom:
                         # Bond if exists
@@ -1193,6 +1195,13 @@ class KeyboardMixin:
                             bond_stereo=0,
                         )
 
+                    if target_order != 3:
+                        if hasattr(self, "placement_direction_clockwise"):
+                            self.placement_direction_clockwise = (
+                                not self.placement_direction_clockwise
+                            )
+                        else:
+                            self.placement_direction_clockwise = False
                     self.clearSelection()
                     self.update_all_items()
                     self.window.edit_actions_manager.push_undo_state()

moleditpy_linux/ui/molecule_scene.py

@@ -177,6 +177,11 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
 
     def mousePressEvent(self, event: Any) -> None:
         self.press_pos = event.scenePos()
+        self.was_selected_on_press = False
+        if self.mode == "select" and event.button() == Qt.MouseButton.LeftButton:
+            item = self.itemAt(self.press_pos, self.views()[0].transform())
+            if isinstance(item, AtomItem) and item.isSelected():
+                self.was_selected_on_press = True
         self.mouse_moved_since_press = False
         self.data_changed_in_event = False
 
@@ -239,7 +244,7 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
                         if hasattr(item, "stereo") and item.stereo in [3, 4]:
                             item.set_stereo(0)
                             # Also update the data model
-                            for (id1, id2), bdata in self.data.bonds.items():
+                            for bdata in self.data.bonds.values():
                                 if bdata.get("item") is item:
                                     bdata["stereo"] = 0
                                     break
@@ -306,14 +311,14 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             event.accept()
 
         item = None
-        if (
-            self.mode.startswith("bond")
-            and self.get_setting("template_fusing_enabled_2d", True)
-            and self.press_pos
-        ):
-            fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-            item = self.find_atom_near(self.press_pos, tol=fuse_dist)
-        if item is None:
+        if self.mode.startswith("bond") and self.press_pos:
+            snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+            item = self.find_atom_near(self.press_pos, tol=snap_dist)
+            if item is None:
+                candidate = self.itemAt(self.press_pos, self.views()[0].transform())
+                if not isinstance(candidate, AtomItem):
+                    item = candidate
+        else:
             item = self.itemAt(self.press_pos, self.views()[0].transform())
 
         if isinstance(item, AtomItem):
@@ -360,14 +365,9 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             end_point = current_pos
 
             target_atom = None
-            if self.get_setting("template_fusing_enabled_2d", True) and current_pos:
-                fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-                target_atom = self.find_atom_near(current_pos, tol=fuse_dist)
-            else:
-                for item in self.items(current_pos):
-                    if isinstance(item, AtomItem):
-                        target_atom = item
-                        break
+            if current_pos:
+                snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+                target_atom = self.find_atom_near(current_pos, tol=snap_dist)
 
             is_valid_snap_target = target_atom is not None and (
                 self.start_atom is None or target_atom is not self.start_atom
@@ -387,7 +387,7 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
 
         end_pos = event.scenePos()
         is_click = (
-            self.press_pos
+            self.press_pos is not None
             and (end_pos - self.press_pos).manhattanLength()
             < QApplication.startDragDistance()
         )
@@ -557,11 +557,13 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
         ):
             line = QLineF(self.start_atom.pos(), end_pos)
             end_item = None
-            if self.get_setting("template_fusing_enabled_2d", True) and end_pos:
-                fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-                end_item = self.find_atom_near(end_pos, tol=fuse_dist)
+            if end_pos:
+                snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+                end_item = self.find_atom_near(end_pos, tol=snap_dist)
             if end_item is None:
-                end_item = self.itemAt(end_pos, self.views()[0].transform())
+                candidate = self.itemAt(end_pos, self.views()[0].transform())
+                if not isinstance(candidate, AtomItem):
+                    end_item = candidate
             # Determine bond style to use
             # In atom modes, set bond_order/stereo to None so create_bond uses defaults (1, 0)
             # In bond_* modes, use current settings (self.bond_order/stereo)
@@ -611,11 +613,13 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
                 self.data_changed_in_event = True
             else:
                 end_item = None
-                if self.get_setting("template_fusing_enabled_2d", True) and end_pos:
-                    fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
-                    end_item = self.find_atom_near(end_pos, tol=fuse_dist)
+                if end_pos:
+                    snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+                    end_item = self.find_atom_near(end_pos, tol=snap_dist)
                 if end_item is None:
-                    end_item = self.itemAt(end_pos, self.views()[0].transform())
+                    candidate = self.itemAt(end_pos, self.views()[0].transform())
+                    if not isinstance(candidate, AtomItem):
+                        end_item = candidate
                 if isinstance(end_item, AtomItem):
                     start_id = self.create_atom(
                         self.current_atom_symbol, self.start_pos
@@ -642,6 +646,14 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
         # 5. Other processing (Select mode, etc.)
         else:
             super().mouseReleaseEvent(event)
+            if (
+                self.mode == "select"
+                and is_click
+                and getattr(self, "was_selected_on_press", False)
+            ):
+                released_item = self.itemAt(end_pos, self.views()[0].transform())
+                if isinstance(released_item, AtomItem):
+                    released_item.setSelected(False)
 
         # Safely check for moved objects
         moved_atoms = []

moleditpy_linux/ui/move_group_dialog.py

@@ -288,10 +288,10 @@ class MoveGroupDialog(BasePickingDialog):
                                 RuntimeError,
                                 ValueError,
                                 TypeError,
-                            ):
-                                pass
-                    except (AttributeError, RuntimeError, ValueError, TypeError):
-                        pass
+                            ) as e:
+                                logging.debug(f"Failed to set closed hand cursor: {e}")
+                    except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                        logging.debug(f"Error initiating drag on move: {e}")
 
                     if not self.is_dragging_group:
                         return False
@@ -305,10 +305,10 @@ class MoveGroupDialog(BasePickingDialog):
                         current_pos = interactor.GetEventPosition()
                         dx = current_pos[0] - self.drag_start_pos[0]
                         dy = current_pos[1] - self.drag_start_pos[1]
-                        if abs(dx) > 2 or abs(dy) > 2:
+                        if abs(dx) > 5 or abs(dy) > 5:
                             self.mouse_moved_during_drag = True
-                    except (AttributeError, RuntimeError, ValueError, TypeError):
-                        pass
+                    except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                        logging.debug(f"Error tracking drag movement: {e}")
                     return True
 
                 # Hover handling
@@ -329,8 +329,8 @@ class MoveGroupDialog(BasePickingDialog):
                             plotter_ref.setCursor(Qt.CursorShape.OpenHandCursor)
                         else:
                             plotter_ref.setCursor(Qt.CursorShape.ArrowCursor)
-                    except (AttributeError, RuntimeError, ValueError, TypeError):
-                        pass
+                    except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                        logging.debug(f"Error updating hover cursor: {e}")
 
                 return False
 
@@ -373,16 +373,18 @@ class MoveGroupDialog(BasePickingDialog):
                                     RuntimeError,
                                     ValueError,
                                     TypeError,
-                                ):
-                                    pass
+                                ) as e:
+                                    logging.debug(
+                                        f"Failed to reset cursor to arrow: {e}"
+                                    )
                                 return True
                             else:
                                 logging.error(
                                     "REPORT ERROR: Missing attribute 'clicked_atom_for_toggle' on self"
                                 )
 
-                    except (AttributeError, RuntimeError, ValueError, TypeError):
-                        pass
+                    except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                        logging.debug(f"Error in mouse release handling: {e}")
                     finally:
                         self.is_dragging_group = False
                         self.drag_start_pos = None
@@ -392,8 +394,15 @@ class MoveGroupDialog(BasePickingDialog):
                             plotter_ptr = self.main_window.view_3d_manager.plotter
                             if plotter_ptr is not None:
                                 plotter_ptr.setCursor(Qt.CursorShape.ArrowCursor)
-                        except (AttributeError, RuntimeError, ValueError, TypeError):
-                            pass
+                        except (
+                            AttributeError,
+                            RuntimeError,
+                            ValueError,
+                            TypeError,
+                        ) as e:
+                            logging.debug(
+                                f"Failed to reset cursor in release finally: {e}"
+                            )
 
                     return True
 
@@ -428,10 +437,11 @@ class MoveGroupDialog(BasePickingDialog):
         # Toggle group
         if visited.issubset(self.group_atoms):
             self.group_atoms -= visited
+            if atom_idx in self.selected_atoms:
+                self.selected_atoms.remove(atom_idx)
         else:
             self.group_atoms |= visited
-
-        self.selected_atoms.add(atom_idx)
+            self.selected_atoms.add(atom_idx)
         self.show_atom_labels()
         self.update_display()
 
@@ -450,13 +460,18 @@ class MoveGroupDialog(BasePickingDialog):
 
     def show_atom_labels(self) -> None:
         """Highlight atoms in the selected group."""
+        plotter = self.main_window.view_3d_manager.plotter
+        try:
+            cam = plotter.camera_position if plotter else None
+        except (AttributeError, RuntimeError, TypeError):
+            cam = None
+
         self.clear_atom_labels()
 
         if not self.group_atoms:
             return
 
         selected_indices = list(self.group_atoms)
-        plotter = self.main_window.view_3d_manager.plotter
         if self.main_window.view_3d_manager.atom_positions_3d is None:
             logging.error("atom_positions_3d is None in update_atom_labels")
             return
@@ -486,8 +501,15 @@ class MoveGroupDialog(BasePickingDialog):
             opacity=0.3,
             name="move_group_highlight",
             pickable=False,
+            reset_camera=False,
         )
 
+        if cam is not None:
+            try:
+                plotter.camera_position = cam
+            except (AttributeError, RuntimeError, TypeError):
+                pass
+
         plotter.render()
 
     def clear_atom_labels(self) -> None:

moleditpy_linux/ui/move_selected_atoms_dialog.py

@@ -53,17 +53,15 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
             self.selected_atoms.update(preselected_atoms)
 
         self.clicked_atom_for_toggle: Optional[int] = None
+        # State for group movement (used by dialog's own event filter)
+        self.drag_atom_idx: Optional[int] = None
+        self.potential_drag: bool = False
+        self.is_dragging_group: bool = False
+        self.drag_start_pos: Optional[Any] = None
+        self.mouse_moved_during_drag: bool = False
+        self._consume_next_left_release: bool = False
         self.highlight_actor: Optional[pv.Actor] = None
 
-        # Grouped states to comply with Pylint instance attribute limit
-        self.drag_state: dict[str, Any] = {
-            "drag_atom_idx": None,
-            "potential_drag": False,
-            "is_dragging_group": False,
-            "drag_start_pos": (0, 0),
-            "mouse_moved_during_drag": False,
-            "consume_next_left_release": False,
-        }
         self.widgets: dict[str, Any] = {}
 
         self.init_ui()
@@ -231,180 +229,6 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
 
         layout.addLayout(button_layout)
 
-    def _handle_double_click(self) -> bool:
-        """Handle MouseButtonDblClick event."""
-        self.drag_state["is_dragging_group"] = False
-        self.drag_state["drag_start_pos"] = (0, 0)
-        self.drag_state["mouse_moved_during_drag"] = False
-        self.drag_state["potential_drag"] = False
-        self.clicked_atom_for_toggle = None
-        return False
-
-    def _handle_mouse_press(self, plotter: Any) -> bool:
-        """Handle MouseButtonPress event for LeftButton."""
-        self.drag_state["is_dragging_group"] = False
-        self.drag_state["potential_drag"] = False
-        self.clicked_atom_for_toggle = None
-
-        if self.selected_atoms:
-            return False
-
-        try:
-            interactor = plotter.interactor
-            if interactor is None:
-                return False
-            click_pos = interactor.GetEventPosition()
-
-            clicked_atom_idx = pick_atom_index_from_screen(
-                self.main_window.view_3d_manager,
-                (int(click_pos[0]), int(click_pos[1])),
-                self.mol,
-            )
-
-            if clicked_atom_idx is not None:
-                if self.selected_atoms and clicked_atom_idx in self.selected_atoms:
-                    self.drag_state["is_dragging_group"] = False
-                    self.drag_state["drag_start_pos"] = click_pos
-                    self.drag_state["drag_atom_idx"] = clicked_atom_idx
-                    self.drag_state["mouse_moved_during_drag"] = False
-                    self.drag_state["potential_drag"] = True
-                    self.clicked_atom_for_toggle = clicked_atom_idx
-                    return False
-
-                self.on_atom_picked(clicked_atom_idx)
-                self.drag_state["consume_next_left_release"] = True
-                return True
-
-            return False
-
-        except (AttributeError, RuntimeError, ValueError) as e:
-            logging.debug("Error in mouse press: %s", e)
-            return False
-
-    def _handle_potential_drag(self, plotter: Any) -> bool:
-        """Handle potential drag checking and threshold transition."""
-        start_pos = self.drag_state["drag_start_pos"]
-        try:
-            interactor = plotter.interactor
-            if interactor is None:
-                return False
-            current_pos = interactor.GetEventPosition()
-            dx = current_pos[0] - start_pos[0]
-            dy = current_pos[1] - start_pos[1]
-
-            if abs(dx) > 5 or abs(dy) > 5:
-                self.drag_state["is_dragging_group"] = True
-                self.drag_state["potential_drag"] = False
-                try:
-                    plotter.setCursor(Qt.CursorShape.ClosedHandCursor)
-                except (AttributeError, RuntimeError, ValueError, TypeError):
-                    pass
-        except (AttributeError, RuntimeError, ValueError, TypeError):
-            pass
-        return self.drag_state["is_dragging_group"]
-
-    def _handle_actual_drag(self, plotter: Any) -> bool:
-        """Update drag movement flags during active dragging."""
-        start_pos = self.drag_state["drag_start_pos"]
-        try:
-            interactor = plotter.interactor
-            if interactor is None:
-                return False
-            current_pos = interactor.GetEventPosition()
-            dx = current_pos[0] - start_pos[0]
-            dy = current_pos[1] - start_pos[1]
-            if abs(dx) > 2 or abs(dy) > 2:
-                self.drag_state["mouse_moved_during_drag"] = True
-        except (AttributeError, RuntimeError, ValueError, TypeError):
-            pass
-        return True
-
-    def _handle_hover_cursor(self, plotter: Any) -> bool:
-        """Set appropriate hover cursor style over selected atoms."""
-        try:
-            interactor = plotter.interactor
-            if interactor is None:
-                return False
-            current_pos = interactor.GetEventPosition()
-            closest_atom_idx = pick_atom_index_from_screen(
-                self.main_window.view_3d_manager,
-                (int(current_pos[0]), int(current_pos[1])),
-                self.mol,
-            )
-
-            if closest_atom_idx in self.selected_atoms:
-                plotter.setCursor(Qt.CursorShape.OpenHandCursor)
-            else:
-                plotter.setCursor(Qt.CursorShape.ArrowCursor)
-        except (AttributeError, RuntimeError, ValueError, TypeError):
-            pass
-        return False
-
-    def _handle_mouse_move(self, plotter: Any) -> bool:
-        """Handle MouseMove event."""
-        if (
-            self.drag_state["potential_drag"]
-            and not self.drag_state["is_dragging_group"]
-        ):
-            if not self._handle_potential_drag(plotter):
-                return False
-
-        if self.drag_state["is_dragging_group"]:
-            return self._handle_actual_drag(plotter)
-
-        if self.selected_atoms:
-            return self._handle_hover_cursor(plotter)
-
-        return False
-
-    def _reset_drag_state(self) -> None:
-        """Reset internal drag flags."""
-        self.drag_state["is_dragging_group"] = False
-        self.drag_state["drag_start_pos"] = (0, 0)
-        self.drag_state["mouse_moved_during_drag"] = False
-        self.drag_state["potential_drag"] = False
-
-    def _restore_arrow_cursor(self) -> None:
-        """Restore standard arrow cursor in the 3D viewer."""
-        try:
-            plotter_ptr = self.main_window.view_3d_manager.plotter
-            if plotter_ptr is not None:
-                plotter_ptr.setCursor(Qt.CursorShape.ArrowCursor)
-        except (AttributeError, RuntimeError, ValueError, TypeError):
-            pass
-
-    def _handle_mouse_release(self) -> bool:
-        """Handle MouseButtonRelease event for LeftButton."""
-        if self.drag_state["consume_next_left_release"]:
-            self.drag_state["consume_next_left_release"] = False
-            return True
-
-        is_drag_active = (
-            self.drag_state["potential_drag"] or self.drag_state["is_dragging_group"]
-        )
-        if not is_drag_active:
-            return False
-
-        has_moved = (
-            self.drag_state["is_dragging_group"]
-            and self.drag_state["mouse_moved_during_drag"]
-        )
-        clicked_atom = self.clicked_atom_for_toggle
-
-        if not has_moved and clicked_atom is not None:
-            self.clicked_atom_for_toggle = None
-            self._reset_drag_state()
-            try:
-                self.on_atom_picked(clicked_atom)
-            except (AttributeError, RuntimeError, ValueError, TypeError):
-                pass
-            self._restore_arrow_cursor()
-            return True
-
-        self._reset_drag_state()
-        self._restore_arrow_cursor()
-        return True
-
     def eventFilter(self, obj: Any, event: Any) -> bool:
         """Mouse event handling in 3D view.
 
@@ -417,31 +241,207 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
         if obj != plotter.interactor:
             return super().eventFilter(obj, event)
 
-        result = False
         e_type = event.type()
 
         if e_type == QEvent.Type.MouseButtonDblClick:
-            result = self._handle_double_click()
-        elif (
+            # Ignore double clicks and reset state
+            self.is_dragging_group = False
+            self.drag_start_pos = None
+            self.mouse_moved_during_drag = False
+            self.potential_drag = False
+            self.clicked_atom_for_toggle = None
+            return False
+
+        if (
             e_type == QEvent.Type.MouseButtonPress
             and isinstance(event, QMouseEvent)
             and event.button() == Qt.MouseButton.LeftButton
         ):
-            result = self._handle_mouse_press(plotter)
+            # Clean up previous state (triple-click countermeasure)
+            self.is_dragging_group = False
+            self.potential_drag = False
+            self.clicked_atom_for_toggle = None
+            # Delegate to CustomInteractorStyle if atoms are already selected
+            if self.selected_atoms:
+                return False
+
+            # Mouse press handling
+            try:
+                interactor = plotter.interactor
+                if interactor is None:
+                    return False
+                click_pos = interactor.GetEventPosition()
+
+                clicked_atom_idx = pick_atom_index_from_screen(
+                    self.main_window.view_3d_manager,
+                    (int(click_pos[0]), int(click_pos[1])),
+                    self.mol,
+                )
+
+                # Handle clicked atom
+                if clicked_atom_idx is not None:
+                    if self.selected_atoms and clicked_atom_idx in self.selected_atoms:
+                        # Atom within existing group - prepare for drag
+                        self.is_dragging_group = False
+                        self.drag_start_pos = click_pos
+                        self.drag_atom_idx = clicked_atom_idx
+                        self.mouse_moved_during_drag = False
+                        self.potential_drag = True
+                        self.clicked_atom_for_toggle = clicked_atom_idx
+                        return False
+                    else:
+                        # Atom outside group - select
+                        self.on_atom_picked(clicked_atom_idx)
+                        self._consume_next_left_release = True
+                        return True
+                else:
+                    # Clicked outside atoms
+                    return False
+
+            except (AttributeError, RuntimeError, ValueError) as e:
+                logging.debug(f"Error in mouse press: {e}")
+                return False
+
         elif e_type == QEvent.Type.MouseMove and isinstance(event, QMouseEvent):
-            result = self._handle_mouse_move(plotter)
+            # Mouse move handling
+            if (
+                getattr(self, "potential_drag", False)
+                and self.drag_start_pos
+                and not self.is_dragging_group
+            ):
+                try:
+                    plotter_ref = self.main_window.view_3d_manager.plotter
+                    if plotter_ref is None or plotter_ref.interactor is None:
+                        return False
+                    interactor = plotter_ref.interactor
+                    current_pos = interactor.GetEventPosition()
+                    dx = current_pos[0] - self.drag_start_pos[0]
+                    dy = current_pos[1] - self.drag_start_pos[1]
+
+                    # Start drag if threshold is exceeded
+                    drag_threshold = 5  # pixels
+                    if abs(dx) > drag_threshold or abs(dy) > drag_threshold:
+                        self.is_dragging_group = True
+                        self.potential_drag = False
+                        try:
+                            plotter_ptr = self.main_window.view_3d_manager.plotter
+                            if plotter_ptr is not None:
+                                plotter_ptr.setCursor(Qt.CursorShape.ClosedHandCursor)
+                        except (
+                            AttributeError,
+                            RuntimeError,
+                            ValueError,
+                            TypeError,
+                        ) as e:
+                            logging.debug(f"Failed to set closed hand cursor: {e}")
+                except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                    logging.debug(f"Error initiating drag on move: {e}")
+
+                if not self.is_dragging_group:
+                    return False
+
+            if self.is_dragging_group and self.drag_start_pos:
+                try:
+                    plotter_ref = self.main_window.view_3d_manager.plotter
+                    if plotter_ref is None or plotter_ref.interactor is None:
+                        return False
+                    interactor = plotter_ref.interactor
+                    current_pos = interactor.GetEventPosition()
+                    dx = current_pos[0] - self.drag_start_pos[0]
+                    dy = current_pos[1] - self.drag_start_pos[1]
+                    if abs(dx) > 5 or abs(dy) > 5:
+                        self.mouse_moved_during_drag = True
+                except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                    logging.debug(f"Error tracking drag movement: {e}")
+                return True
+
+            # Hover handling
+            if self.selected_atoms:
+                try:
+                    plotter_ref = self.main_window.view_3d_manager.plotter
+                    if plotter_ref is None or plotter_ref.interactor is None:
+                        return False
+                    interactor = plotter_ref.interactor
+                    current_pos = interactor.GetEventPosition()
+                    closest_atom_idx = pick_atom_index_from_screen(
+                        self.main_window.view_3d_manager,
+                        (int(current_pos[0]), int(current_pos[1])),
+                        self.mol,
+                    )
+
+                    if closest_atom_idx in self.selected_atoms:
+                        plotter_ref.setCursor(Qt.CursorShape.OpenHandCursor)
+                    else:
+                        plotter_ref.setCursor(Qt.CursorShape.ArrowCursor)
+                except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                    logging.debug(f"Error updating hover cursor: {e}")
+
+            return False
+
         elif (
             e_type == QEvent.Type.MouseButtonRelease
             and isinstance(event, QMouseEvent)
             and event.button() == Qt.MouseButton.LeftButton
         ):
-            result = self._handle_mouse_release()
+            if self._consume_next_left_release:
+                self._consume_next_left_release = False
+                return True
+
+            if getattr(self, "potential_drag", False) or (
+                self.is_dragging_group and self.drag_start_pos
+            ):
+                try:
+                    if not (self.is_dragging_group and self.mouse_moved_during_drag):
+                        # Mouse move below threshold = simple click (toggle)
+                        if self.clicked_atom_for_toggle is not None:
+                            clicked_atom = self.clicked_atom_for_toggle
+                            self.clicked_atom_for_toggle = None
+                            self.is_dragging_group = False
+                            self.drag_start_pos = None
+                            self.mouse_moved_during_drag = False
+                            self.potential_drag = False
+                            if clicked_atom is not None:
+                                self.on_atom_picked(clicked_atom)
+                            try:
+                                plotter_ptr = self.main_window.view_3d_manager.plotter
+                                if plotter_ptr is not None:
+                                    plotter_ptr.setCursor(Qt.CursorShape.ArrowCursor)
+                            except (
+                                AttributeError,
+                                RuntimeError,
+                                ValueError,
+                                TypeError,
+                            ) as e:
+                                logging.debug(f"Failed to reset cursor to arrow: {e}")
+                            return True
+                        else:
+                            logging.error(
+                                "REPORT ERROR: Missing attribute 'clicked_atom_for_toggle' on self"
+                            )
+
+                except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                    logging.debug(f"Error in mouse release handling: {e}")
+                finally:
+                    self.is_dragging_group = False
+                    self.drag_start_pos = None
+                    self.mouse_moved_during_drag = False
+                    self.potential_drag = False
+                    try:
+                        plotter_ptr = self.main_window.view_3d_manager.plotter
+                        if plotter_ptr is not None:
+                            plotter_ptr.setCursor(Qt.CursorShape.ArrowCursor)
+                    except (AttributeError, RuntimeError, ValueError, TypeError) as e:
+                        logging.debug(f"Failed to reset cursor in release finally: {e}")
 
-        return result
+                return True
+
+            return False
+
+        return super().eventFilter(obj, event)
 
     def on_atom_picked(self, atom_idx: int) -> None:
         """Select or deselect the clicked atom."""
-        if self.drag_state["is_dragging_group"]:
+        if getattr(self, "is_dragging_group", False):
             return
 
         if atom_idx in self.selected_atoms:
@@ -471,13 +471,18 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
 
     def show_atom_labels(self) -> None:
         """Highlight selected atoms."""
+        plotter = self.main_window.view_3d_manager.plotter
+        try:
+            cam = plotter.camera_position if plotter else None
+        except (AttributeError, RuntimeError, TypeError):
+            cam = None
+
         self.clear_atom_labels()
 
         if not self.selected_atoms:
             return
 
         selected_indices = list(self.selected_atoms)
-        plotter = self.main_window.view_3d_manager.plotter
         if self.main_window.view_3d_manager.atom_positions_3d is None:
             logging.error("atom_positions_3d is None in update_atom_labels")
             return
@@ -507,8 +512,15 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
             opacity=0.3,
             name="move_selected_atoms_highlight",
             pickable=False,
+            reset_camera=False,
         )
 
+        if cam is not None:
+            try:
+                plotter.camera_position = cam
+            except (AttributeError, RuntimeError, TypeError):
+                pass
+
         plotter.render()
 
     def clear_atom_labels(self) -> None:
@@ -636,5 +648,5 @@ class MoveSelectedAtomsDialog(BasePickingDialog):
         self.selected_atoms.clear()
         self.clear_atom_labels()
         self.update_display()
-        self.drag_state["is_dragging_group"] = False
-        self.drag_state["drag_start_pos"] = (0, 0)
+        self.is_dragging_group = False
+        self.drag_start_pos = None

moleditpy_linux/ui/settings_tabs/settings_2d_tab.py

@@ -147,6 +147,26 @@ class Settings2DTab(SettingsTabBase):
 
         form_layout.addRow(self._create_separator())
 
+        # --- Bond Snapping Settings ---
+        form_layout.addRow(QLabel("<b>Bond Snapping Settings</b>"))
+
+        # Bond Snapping Distance
+        self.bond_snapping_distance_2d_slider, self.bond_snapping_distance_2d_label = (
+            self._create_slider(5, 50, 1.0, is_int=True)
+        )
+        self.bond_snapping_distance_2d_slider.setToolTip(
+            "The distance in pixels within which drawing a bond will snap to an existing atom."
+        )
+        form_layout.addRow(
+            "Bond Snapping Distance (px):",
+            self._wrap_layout(
+                self.bond_snapping_distance_2d_slider,
+                self.bond_snapping_distance_2d_label,
+            ),
+        )
+
+        form_layout.addRow(self._create_separator())
+
         # --- Template Settings ---
         form_layout.addRow(QLabel("<b>Template Settings</b>"))
 
@@ -270,6 +290,10 @@ class Settings2DTab(SettingsTabBase):
         self.template_fusing_distance_2d_slider.setEnabled(fusing_enabled)
         self.template_fusing_distance_2d_label.setEnabled(fusing_enabled)
 
+        self.bond_snapping_distance_2d_slider.setValue(
+            int(settings_dict.get("bond_snapping_distance_2d", 14.0))
+        )
+
         self.template_fusing_distance_2d_slider.setValue(
             int(settings_dict.get("template_fusing_distance_2d", 14.0))
         )
@@ -290,6 +314,9 @@ class Settings2DTab(SettingsTabBase):
             "atom_font_family_2d": self.atom_font_family_2d_combo.currentFont().family(),
             "atom_font_size_2d": self.atom_font_size_2d_slider.value(),
             "atom_use_bond_color_2d": self.atom_use_bond_color_2d_checkbox.isChecked(),
+            "bond_snapping_distance_2d": float(
+                self.bond_snapping_distance_2d_slider.value()
+            ),
             "template_fusing_enabled_2d": self.template_fusing_enabled_2d_checkbox.isChecked(),
             "template_fusing_distance_2d": float(
                 self.template_fusing_distance_2d_slider.value()

moleditpy_linux/ui/settings_tabs/settings_other_tab.py

@@ -19,7 +19,6 @@ from PyQt6.QtWidgets import (
     QFormLayout,
     QFrame,
     QHBoxLayout,
-    QLabel,
     QSlider,
     QWidget,
     QDoubleSpinBox,

moleditpy_linux/ui/settings_tabs/settings_tab_base.py

@@ -17,7 +17,6 @@ from PyQt6.QtCore import Qt
 from PyQt6.QtWidgets import (
     QFrame,
     QHBoxLayout,
-    QLabel,
     QSlider,
     QWidget,
     QSpinBox,

moleditpy_linux/utils/default_settings.py

@@ -74,4 +74,5 @@ DEFAULT_SETTINGS = {
     "template_fusing_enabled_2d": True,
     "template_fusing_distance_2d": 7.0,
     "template_snapping_distance_2d": 14.0,
+    "bond_snapping_distance_2d": 14.0,
 }

{moleditpy_linux-3.6.0.dist-info → moleditpy_linux-3.6.2.dist-info}/METADATA

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

{moleditpy_linux-3.6.0.dist-info → moleditpy_linux-3.6.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-moleditpy_linux/__init__.py,sha256=D-XFLIZekmDUAxD9B6ntq6CFggaD_IHAhJ_BDocNKDQ,498
+moleditpy_linux/__init__.py,sha256=SBIBlrNkWvxt6fWR02XOA9A0Bokj_a5xhv7OZIaxhZ4,490
 moleditpy_linux/__main__.py,sha256=VHCD-CCX6iKUbmUyRv2BGVXCjHWEaISpmjO7_yh9AaU,654
 moleditpy_linux/main.py,sha256=jkew0v747koc4MTTlH6S3OfqkDI05cgsn9vWFZlJDQA,5444
 moleditpy_linux/assets/file_icon.ico,sha256=yyVj084A7HuMNbV073cE_Ag3Ne405qgOP3Mia1ZqLpE,101632
@@ -20,31 +20,31 @@ moleditpy_linux/ui/analysis_window.py,sha256=iVYzxLpL78XS46lzRC0DpT3hwD6FS60su_K
 moleditpy_linux/ui/angle_dialog.py,sha256=jEtq0BcMmaIq7iZA26j5w7n6DBwPZswcHuGhsj2nRUA,17803
 moleditpy_linux/ui/app_state.py,sha256=aNU2dy2lbW17pkZOurORFYmIimu715DioSH33UZn2QQ,40162
 moleditpy_linux/ui/atom_item.py,sha256=tN7paZGVVOLR2ppuI_qcYajiQ7YLH4mOhjzBYHeEN3w,21144
-moleditpy_linux/ui/atom_picking.py,sha256=seSG2XIFndYul2Axa9cnfUGV51CPO5PFzxddMHgwh9c,5190
+moleditpy_linux/ui/atom_picking.py,sha256=HhJ8kH1zVF3DIzMG1Qymk44d8MwUqbg9xr4pQ6H0lHA,10391
 moleditpy_linux/ui/base_picking_dialog.py,sha256=t4kdyKXgHj6IGbjL_bOJbFbIlaYkERPcxKeir1u-roA,5682
 moleditpy_linux/ui/bond_item.py,sha256=sn3Vk1XblmjfDP1zzPS_mn_5byFA4xPR_-qoYWjKTe8,26588
 moleditpy_linux/ui/bond_length_dialog.py,sha256=U7YQ6r75TueSA7lV_B9dUEnaEjOLEgkT1aW8KUItbtI,14962
 moleditpy_linux/ui/calculation_worker.py,sha256=HJz5NkXfNS66OODxKkR-IfGUtv7hRG-mp4Wfapw6D7M,41125
 moleditpy_linux/ui/color_settings_dialog.py,sha256=sV9w-fRh8dcRLBPwyNGkvATmOJXlvm8Em2yGpGHHb_k,16642
 moleditpy_linux/ui/compute_logic.py,sha256=qxUXBKb3-AvE0FdtrgeyyO9Dc93sEVpPP5sAviewZ78,28425
-moleditpy_linux/ui/constrained_optimization_dialog.py,sha256=vuGOS8X4MWU1mnk4jE9UWZucltjgcrB_LSjKB7ZXfv8,35070
-moleditpy_linux/ui/custom_interactor_style.py,sha256=TIi4bptNL_63vslyjav5DDMl2ZSDVAYfYDYKmq4F4GI,42135
+moleditpy_linux/ui/constrained_optimization_dialog.py,sha256=PNQN2d0nufI9s-N-60zG2HeKUuYzWFzNudYHb5y4KOQ,35042
+moleditpy_linux/ui/custom_interactor_style.py,sha256=poOgprQeffKtdL7cvoxWVPgRefO0OAOkAja_NOag4Ms,42564
 moleditpy_linux/ui/custom_qt_interactor.py,sha256=oAfCHIDVOJmLTdowrBiGsaCoQMJ-ZnQhpSkDLIHMe9U,3735
 moleditpy_linux/ui/dialog_3d_picking_mixin.py,sha256=iJg9bZDj2wvOG178mwOus5Y-6HmSmIMCX0KyvOJ-l0U,9901
 moleditpy_linux/ui/dialog_logic.py,sha256=nsQ7nhQrOH-DmM49rhu-S4dvmbQPDyXh17efJzjuC3k,21356
 moleditpy_linux/ui/dihedral_dialog.py,sha256=ZDihYt32_3V_uJXsJ4u3qGxn3pASWPcl8BIY3nTBQ0Q,18103
-moleditpy_linux/ui/edit_3d_logic.py,sha256=eskqxtcOnWADu4MrskQSG9RGUIHqR_XHoqMFm9uiJNw,19753
-moleditpy_linux/ui/edit_actions_logic.py,sha256=Y3BZjeS8sVvJO9CzJUfRYMwbjkShMFQjSarlZWS_Fpo,67665
+moleditpy_linux/ui/edit_3d_logic.py,sha256=y-6GabTZzlLA0u3j8ugy7yHV3jA4HvWTVCAmgFEKwh4,19740
+moleditpy_linux/ui/edit_actions_logic.py,sha256=KZZJOnAcN_wHwXX48z5j5zZPTO5v5f0hgikJXogbVvs,67671
 moleditpy_linux/ui/export_logic.py,sha256=4irp1z_7PRAAME-2gJUB8zVnM8eXdmaiM3vMLpLqSYg,43422
 moleditpy_linux/ui/geometry_base_dialog.py,sha256=eAlmZOPPXMKKBDWFiBN68-Zbp-EeqWrgXBf8q3ioxGY,4734
 moleditpy_linux/ui/io_logic.py,sha256=aHjZdTmBY2e35NpIgvawdOAXmDRg-DcJf9025AdSDqg,43839
 moleditpy_linux/ui/main_window.py,sha256=MIGs8M72OnT3TZG7RM8NeBfyInYysDlKzZqEoKUnSiE,4773
 moleditpy_linux/ui/main_window_init.py,sha256=lSfW6EDtcVptS37OUEPidz5WNcq7FSzmG86G8ftfH-4,94196
 moleditpy_linux/ui/mirror_dialog.py,sha256=iJriiS5U61tyw_7M_PUf3x1qAHh8ciBh751GH8O_BpQ,5075
-moleditpy_linux/ui/molecular_scene_handler.py,sha256=8FKOwT5p0iuOew_Z-sUNd-iBK1kFskUQhclygFMhCSM,69099
-moleditpy_linux/ui/molecule_scene.py,sha256=yB30JQMukQQpb_FIKq12wmCzgdr5sUtkMR-rz9w2Z5A,37914
-moleditpy_linux/ui/move_group_dialog.py,sha256=xR0NyDgKtoXfdgODp3hwpjez_SuA2bwCzOXQhcD52PE,25102
-moleditpy_linux/ui/move_selected_atoms_dialog.py,sha256=aub37TmapbYe35nx9u8LyZskf1Iyxjd5yWim7ubg84g,23214
+moleditpy_linux/ui/molecular_scene_handler.py,sha256=TFmvgs10xuEI0PiRxWYvUlh_gBunUfQb1BPrIDF5CtA,69602
+moleditpy_linux/ui/molecule_scene.py,sha256=qa-nWA653oEiJFJx7Gn-jBSHaPtJw4kq4KfK6pqJcQs,38524
+moleditpy_linux/ui/move_group_dialog.py,sha256=1T8vxhPcSp5r71WE90bINe4lm0Q8XEvCUBlUcXhHF7w,26259
+moleditpy_linux/ui/move_selected_atoms_dialog.py,sha256=samPLggErPkNQeZJ_zNbWKpbh3MFGVB6aHxg0waF5HI,25268
 moleditpy_linux/ui/periodic_table_dialog.py,sha256=2fgAILjcjYNt-x9UCqq2VFgwDY8oX7aE4jMQvyyCMho,5847
 moleditpy_linux/ui/planarize_dialog.py,sha256=F_xMk6Jcmq7PECKJfiKtQuRm1tRXLS7Se2h5wwpnD0w,7359
 moleditpy_linux/ui/settings_dialog.py,sha256=WTexmB8HOmdA-CjHK5M6TcS7ZrJtywyq7qMM2SZzu-k,7673
@@ -57,18 +57,18 @@ moleditpy_linux/ui/user_template_dialog.py,sha256=lH3gf5XtmOMxdMHWFWNhxh-c9vQcb4
 moleditpy_linux/ui/view_3d_logic.py,sha256=rO6svIUu7XurU6Vj3C7avAV5EvIAdrogevbOHXgBxIE,94668
 moleditpy_linux/ui/zoomable_view.py,sha256=eCHAgIMRaNoz7qjnZjrJBdxAmDt2bESII_Kc6l-Mzjg,5803
 moleditpy_linux/ui/settings_tabs/__init__.py,sha256=BEOaCz93HzgTe0FhBzSj6Sfk8MAWxcY9vCDGmOriJx4,267
-moleditpy_linux/ui/settings_tabs/settings_2d_tab.py,sha256=DntkpoTA6qpgqachiEh4tpuRnYTA0c0JwRx0hxV6YTY,11743
+moleditpy_linux/ui/settings_tabs/settings_2d_tab.py,sha256=7AsEz9mIZA4DYg-eiLt1UeYX9zw-8_I12qO8GCCQQsE,12786
 moleditpy_linux/ui/settings_tabs/settings_3d_tabs.py,sha256=S2ydaYjtc9AGZu86mDaLDi1DC6hEI5mFtPvjwVpBVaY,11341
-moleditpy_linux/ui/settings_tabs/settings_other_tab.py,sha256=0X-S_P0hfjcemz8rcmWVfTImpWZmQPDlqIVWvIr1j9A,5462
-moleditpy_linux/ui/settings_tabs/settings_tab_base.py,sha256=S356x3VnEk9tXV8agrqurizNG6sFkVTXBbbhAm6U8ew,3529
+moleditpy_linux/ui/settings_tabs/settings_other_tab.py,sha256=NLJiuFi4fTA7YVjt7wdnx1qPOoL_Ur76veGFjAfexfI,5449
+moleditpy_linux/ui/settings_tabs/settings_tab_base.py,sha256=pV9WdT16ZJTQGv74YIkFSQ79Iq1rerjM6G9svbYmIeY,3516
 moleditpy_linux/utils/__init__.py,sha256=BEOaCz93HzgTe0FhBzSj6Sfk8MAWxcY9vCDGmOriJx4,267
 moleditpy_linux/utils/constants.py,sha256=HsOqb9sAzRNujvBQwAeTWXS7fHfho46shmnSa3TuBDk,6633
-moleditpy_linux/utils/default_settings.py,sha256=fU1t9_dIKqc3ea19p1UfNPEq4ybq2aI4LfTXJhh6i08,2691
+moleditpy_linux/utils/default_settings.py,sha256=OxgIrdk-LCXBdhUPF_qzsbdsiM18kDWgP3seELyUgJU,2731
 moleditpy_linux/utils/sip_isdeleted_safe.py,sha256=My6IJqDewbYY6SoRYNk6XwFUQ9_yihaR3Ym7EOETuAw,1189
 moleditpy_linux/utils/system_utils.py,sha256=K5c9cJRgMFqtUtLefSu3w2hy2drgxNqfT200bSIFy2k,2325
-moleditpy_linux-3.6.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-moleditpy_linux-3.6.0.dist-info/METADATA,sha256=07BAWpysjHLdxDaQkKHOEsOaxNNjO8V27CWiAfoIdic,62978
-moleditpy_linux-3.6.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-moleditpy_linux-3.6.0.dist-info/entry_points.txt,sha256=-OzipSi__yVwlimNtu3eiRP5t5UMg55Cs0udyhXYiyw,60
-moleditpy_linux-3.6.0.dist-info/top_level.txt,sha256=qyqe-hDYL6CXyin9E5Me5rVl3PG84VqiOjf9bQvfJLs,16
-moleditpy_linux-3.6.0.dist-info/RECORD,,
+moleditpy_linux-3.6.2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+moleditpy_linux-3.6.2.dist-info/METADATA,sha256=Hvax71UUKc-KHdTtT9hmn0R_dF-kUWfEdmZqqQ0T4io,62978
+moleditpy_linux-3.6.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+moleditpy_linux-3.6.2.dist-info/entry_points.txt,sha256=-OzipSi__yVwlimNtu3eiRP5t5UMg55Cs0udyhXYiyw,60
+moleditpy_linux-3.6.2.dist-info/top_level.txt,sha256=qyqe-hDYL6CXyin9E5Me5rVl3PG84VqiOjf9bQvfJLs,16
+moleditpy_linux-3.6.2.dist-info/RECORD,,