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

moleditpy_linux/main.py

@@ -148,4 +148,14 @@ def main() -> None:
     app = QApplication([sys.argv[0]] + remaining)
     window = MainWindow(initial_file=args.file, safe_mode=args.safe)
     window.show()
+
+    # Force Windows to refresh taskbar/titlebar icon after event loop starts
+    if sys.platform == "win32":
+        try:
+            from PyQt6.QtCore import QTimer
+
+            QTimer.singleShot(100, lambda: window.setWindowIcon(window.windowIcon()))
+        except Exception:
+            pass
+
     sys.exit(app.exec())

moleditpy_linux/ui/custom_interactor_style.py

@@ -22,10 +22,8 @@ from vtkmodules.vtkInteractionStyle import vtkInteractorStyleTrackballCamera  #
 
 
 try:
-    from .move_group_dialog import MoveGroupDialog
     from .atom_picking import pick_atom_index_from_screen
 except ImportError:
-    from moleditpy_linux.ui.move_group_dialog import MoveGroupDialog
     from moleditpy_linux.ui.atom_picking import pick_atom_index_from_screen
 
 from rdkit import Geometry
@@ -107,10 +105,15 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         self._mouse_press_pos = None
 
         # Check Move Group dialog
+        # Check Move Group or Move Selected Atoms dialog
         move_group_dialog = None
         for widget in QApplication.topLevelWidgets():
             try:
-                if isinstance(widget, MoveGroupDialog) and widget.isVisible():
+                if (
+                    type(widget).__name__
+                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
+                    and widget.isVisible()
+                ):
                     move_group_dialog = widget
                     break
             except (AttributeError, RuntimeError, TypeError):
@@ -147,6 +150,20 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                     self._suppress_next_left_button_up = True
                     return  # Disable camera rotation
                 else:
+                    if type(move_group_dialog).__name__ == "MoveSelectedAtomsDialog":
+                        # For MoveSelectedAtomsDialog, we toggle ONLY the clicked atom, no BFS!
+                        def _deferred_toggle(
+                            idx=clicked_atom_idx, dlg=move_group_dialog
+                        ):
+                            try:
+                                dlg.on_atom_picked(idx)
+                            except (AttributeError, RuntimeError):
+                                pass
+
+                        QTimer.singleShot(0, _deferred_toggle)
+                        self._suppress_next_left_button_up = True
+                        return
+
                     # Clicked outside group - Search connected component
                     visited = set()
                     queue = [clicked_atom_idx]
@@ -172,8 +189,14 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
 
                     # Multi-selection with Ctrl
                     is_ctrl_pressed = bool(
-                        QApplication.keyboardModifiers()
-                        & Qt.KeyboardModifier.ControlModifier
+                        (
+                            QApplication.keyboardModifiers()
+                            & Qt.KeyboardModifier.ControlModifier
+                        )
+                        or (
+                            self.GetInteractor()
+                            and self.GetInteractor().GetControlKey()
+                        )
                     )
 
                     if is_ctrl_pressed:
@@ -208,8 +231,10 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
                 super(CustomInteractorStyle, self).OnLeftButtonDown()
                 return
 
+        interactor = self.GetInteractor()
         is_temp_mode = bool(
-            QApplication.keyboardModifiers() & Qt.KeyboardModifier.AltModifier
+            (QApplication.keyboardModifiers() & Qt.KeyboardModifier.AltModifier)
+            or (interactor and interactor.GetAltKey())
         )
         is_edit_active = mw.edit_3d_manager.is_3d_edit_mode or is_temp_mode
 
@@ -293,11 +318,15 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         """
         mw = self.main_window
 
-        # Check if Move Group dialog is open
+        # Check if Move Group dialog or Move Selected Atoms dialog is open
         move_group_dialog = None
         try:
             for widget in QApplication.topLevelWidgets():
-                if isinstance(widget, MoveGroupDialog) and widget.isVisible():
+                if (
+                    type(widget).__name__
+                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
+                    and widget.isVisible()
+                ):
                     move_group_dialog = widget
                     break
         except (AttributeError, RuntimeError, TypeError) as e:
@@ -350,11 +379,15 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         """
         mw = self.main_window
 
-        # Move Group drag handling
+        # Move Group / Selected Atoms drag handling
         move_group_dialog = None
         try:
             for widget in QApplication.topLevelWidgets():
-                if isinstance(widget, MoveGroupDialog) and widget.isVisible():
+                if (
+                    type(widget).__name__
+                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
+                    and widget.isVisible()
+                ):
                     move_group_dialog = widget
                     break
         except (AttributeError, RuntimeError, TypeError):
@@ -442,11 +475,15 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         """
         mw = self.main_window
 
-        # Finalize Move Group drag
+        # Finalize Move Group / Selected Atoms drag
         move_group_dialog = None
         try:
             for widget in QApplication.topLevelWidgets():
-                if isinstance(widget, MoveGroupDialog) and widget.isVisible():
+                if (
+                    type(widget).__name__
+                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
+                    and widget.isVisible()
+                ):
                     move_group_dialog = widget
                     break
         except (AttributeError, RuntimeError, TypeError):
@@ -749,11 +786,15 @@ class CustomInteractorStyle(vtkInteractorStyleTrackballCamera):
         """
         mw = self.main_window
 
-        # Finalize Move Group rotation
+        # Finalize Move Group / Selected Atoms rotation
         move_group_dialog = None
         try:
             for widget in QApplication.topLevelWidgets():
-                if isinstance(widget, MoveGroupDialog) and widget.isVisible():
+                if (
+                    type(widget).__name__
+                    in ("MoveGroupDialog", "MoveSelectedAtomsDialog")
+                    and widget.isVisible()
+                ):
                     move_group_dialog = widget
                     break
         except (AttributeError, RuntimeError, TypeError):

moleditpy_linux/ui/dialog_logic.py

@@ -18,7 +18,8 @@ import json
 import os
 from typing import Any, List, Literal, Optional, cast
 
-from PyQt6.QtWidgets import QInputDialog, QMessageBox
+from PyQt6.QtWidgets import QInputDialog, QMessageBox, QDialog
+from PyQt6.QtCore import Qt
 
 
 try:
@@ -33,6 +34,7 @@ try:
     from .dihedral_dialog import DihedralDialog
     from .mirror_dialog import MirrorDialog
     from .move_group_dialog import MoveGroupDialog
+    from .move_selected_atoms_dialog import MoveSelectedAtomsDialog
     from .periodic_table_dialog import PeriodicTableDialog
     from .planarize_dialog import PlanarizeDialog
     from .settings_dialog import SettingsDialog
@@ -53,6 +55,7 @@ except ImportError:
     from moleditpy_linux.ui.dihedral_dialog import DihedralDialog
     from moleditpy_linux.ui.mirror_dialog import MirrorDialog
     from moleditpy_linux.ui.move_group_dialog import MoveGroupDialog
+    from moleditpy_linux.ui.move_selected_atoms_dialog import MoveSelectedAtomsDialog
     from moleditpy_linux.ui.periodic_table_dialog import PeriodicTableDialog
     from moleditpy_linux.ui.planarize_dialog import PlanarizeDialog
     from moleditpy_linux.ui.settings_dialog import SettingsDialog
@@ -213,6 +216,13 @@ class DialogManager:
                 self.host, "Error", f"Failed to save template: {str(e)}"
             )
 
+    def _show_modeless_dialog(self, dialog: QDialog) -> None:
+        """Show a modeless dialog on top, especially important for macOS."""
+        dialog.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
+        dialog.show()
+        dialog.raise_()
+        dialog.activateWindow()
+
     def open_translation_dialog(self) -> None:
         """Open the translation dialog"""
         # Get preselected atoms
@@ -229,8 +239,8 @@ class DialogManager:
             preselected_atoms,
             parent=self.host,
         )
-        self.host.edit_3d_manager.active_3d_dialogs.append(dialog)  # Keep reference
-        dialog.show()  # Use show for modeless display
+        self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
+        self._show_modeless_dialog(dialog)
         dialog.accepted.connect(
             lambda: self.host.statusBar().showMessage("Translation applied.")
         )
@@ -256,7 +266,7 @@ class DialogManager:
             parent=self.host,
         )
         self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
-        dialog.show()
+        self._show_modeless_dialog(dialog)
         dialog.accepted.connect(
             lambda: self.host.statusBar().showMessage("Group transformation applied.")
         )
@@ -265,6 +275,34 @@ class DialogManager:
             lambda: self.host.edit_3d_manager.remove_dialog_from_list(dialog)
         )
 
+    def open_move_selected_atoms_dialog(self) -> None:
+        """Open Move Selected Atoms dialog"""
+        # Get preselected atoms
+        preselected_atoms = self._get_preselected_atoms_3d()
+
+        # Disable measurement mode
+        if self.host.edit_3d_manager.measurement_mode:
+            self.host.init_manager.measurement_action.setChecked(False)
+            self.host.edit_3d_manager.toggle_measurement_mode(False)
+
+        dialog = MoveSelectedAtomsDialog(
+            self.host.view_3d_manager.current_mol,
+            self.host,
+            preselected_atoms,
+            parent=self.host,
+        )
+        self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
+        self._show_modeless_dialog(dialog)
+        dialog.accepted.connect(
+            lambda: self.host.statusBar().showMessage(
+                "Selected atoms transformation applied."
+            )
+        )
+        dialog.accepted.connect(self.host.edit_actions_manager.push_undo_state)
+        dialog.finished.connect(
+            lambda: self.host.edit_3d_manager.remove_dialog_from_list(dialog)
+        )
+
     def open_align_plane_dialog(self, plane: str) -> None:
         """Open align dialog"""
         # Get pre-selected atoms
@@ -283,7 +321,7 @@ class DialogManager:
             parent=self.host,
         )
         self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
-        dialog.show()
+        self._show_modeless_dialog(dialog)
         dialog.accepted.connect(
             lambda: self.host.statusBar().showMessage(
                 f"Atoms aligned to {plane.upper()} plane."
@@ -311,7 +349,7 @@ class DialogManager:
             parent=self.host,
         )
         self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
-        dialog.show()
+        self._show_modeless_dialog(dialog)
         dialog.accepted.connect(
             lambda: self.host.statusBar().showMessage(
                 "Selection planarized to best-fit plane."
@@ -340,7 +378,7 @@ class DialogManager:
             parent=self.host,
         )
         self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
-        dialog.show()
+        self._show_modeless_dialog(dialog)
         dialog.accepted.connect(
             lambda: self.host.statusBar().showMessage(
                 f"Atoms aligned to {axis.upper()}-axis."
@@ -368,7 +406,7 @@ class DialogManager:
             parent=self.host,
         )
         self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
-        dialog.show()
+        self._show_modeless_dialog(dialog)
         dialog.accepted.connect(
             lambda: self.host.statusBar().showMessage("Bond length adjusted.")
         )
@@ -394,7 +432,7 @@ class DialogManager:
             parent=self.host,
         )
         self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
-        dialog.show()
+        self._show_modeless_dialog(dialog)
         dialog.accepted.connect(
             lambda: self.host.statusBar().showMessage("Angle adjusted.")
         )
@@ -420,7 +458,7 @@ class DialogManager:
             parent=self.host,
         )
         self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
-        dialog.show()
+        self._show_modeless_dialog(dialog)
         dialog.accepted.connect(
             lambda: self.host.statusBar().showMessage("Dihedral angle adjusted.")
         )
@@ -440,8 +478,18 @@ class DialogManager:
             self.host.init_manager.measurement_action.setChecked(False)
             self.host.edit_3d_manager.toggle_measurement_mode(False)
 
-        dialog = MirrorDialog(self.host.view_3d_manager.current_mol, self.host)
-        dialog.exec()
+        dialog = MirrorDialog(
+            self.host.view_3d_manager.current_mol, self.host, parent=self.host
+        )
+        self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
+        self._show_modeless_dialog(dialog)
+        dialog.accepted.connect(
+            lambda: self.host.statusBar().showMessage("Mirror applied.")
+        )
+        dialog.accepted.connect(self.host.edit_actions_manager.push_undo_state)
+        dialog.finished.connect(
+            lambda: self.host.edit_3d_manager.remove_dialog_from_list(dialog)
+        )
 
     def open_settings_dialog(self) -> None:
         """Open the application settings dialog."""
@@ -468,7 +516,7 @@ class DialogManager:
             self.host.view_3d_manager.current_mol, self.host, parent=self.host
         )
         self.host.edit_3d_manager.active_3d_dialogs.append(dialog)
-        dialog.show()
+        self._show_modeless_dialog(dialog)
         dialog.finished.connect(
             lambda: self.host.edit_3d_manager.remove_dialog_from_list(dialog)
         )

moleditpy_linux/ui/main_window_init.py

@@ -1866,6 +1866,14 @@ class MainInitManager:
         edit_3d_menu.addAction(translation_action)
         self.host.translation_action = translation_action
 
+        move_selected_atoms_action = QAction("Move Selected Atoms...", self.host)
+        move_selected_atoms_action.triggered.connect(
+            self.host.dialog_manager.open_move_selected_atoms_dialog
+        )
+        move_selected_atoms_action.setEnabled(False)
+        edit_3d_menu.addAction(move_selected_atoms_action)
+        self.host.move_selected_atoms_action = move_selected_atoms_action
+
         move_group_action = QAction("Move Group...", self.host)
         move_group_action.triggered.connect(
             self.host.dialog_manager.open_move_group_dialog

moleditpy_linux/ui/molecular_scene_handler.py

@@ -228,6 +228,9 @@ class TemplateMixin:
             return math.hypot(ax - bx, ay - by)
 
         # --- 1) Map already clicked existing_items to template vertices ---
+        alt_pressed = bool(
+            QApplication.keyboardModifiers() & Qt.KeyboardModifier.AltModifier
+        )
         existing_items = existing_items or []
         used_indices = set()
         ref_lengths = [
@@ -258,8 +261,14 @@ class TemplateMixin:
 
         # --- 2) Enumerate existing atoms in the scene from self.data.atoms and map them ---
         mapped_atoms = {it for it in atom_items if it is not None}
-        if self.get_setting("template_fusing_enabled_2d", True):
-            map_threshold = self.get_setting("template_fusing_distance_2d", 14.0)
+        if (
+            hasattr(self, "data")
+            and hasattr(self.data, "atoms")
+            and self.data.atoms is not None
+            and self.get_setting("template_fusing_enabled_2d", True)
+            and not alt_pressed
+        ):
+            map_threshold = self.get_setting("template_fusing_distance_2d", 7.0)
             for i, p in enumerate(points):
                 if atom_items[i] is not None:
                     continue
@@ -353,12 +362,14 @@ class TemplateMixin:
 
         return atom_items
 
-    def update_template_preview(self, pos: QPointF) -> None:
+    def update_template_preview(
+        self, pos: QPointF, alt_pressed: Optional[bool] = None
+    ) -> None:
         mode_parts = self.mode.split("_")
 
         # Check if this is a user template
         if len(mode_parts) >= 3 and mode_parts[1] == "user":
-            self.update_user_template_preview(pos)
+            self.update_user_template_preview(pos, alt_pressed=alt_pressed)
             return
 
         is_aromatic = False
@@ -371,6 +382,10 @@ class TemplateMixin:
             except ValueError:
                 return
 
+        if alt_pressed is None:
+            alt_pressed = bool(
+                QApplication.keyboardModifiers() & Qt.KeyboardModifier.AltModifier
+            )
         item = None
         if pos:
             snap_dist = self.get_setting("template_snapping_distance_2d", 14.0)
@@ -383,7 +398,7 @@ class TemplateMixin:
                     break
 
         points, bonds_info = [], []
-        l = DEFAULT_BOND_LENGTH
+        bond_len = DEFAULT_BOND_LENGTH
         self.template_context = {}
 
         if isinstance(item, AtomItem):
@@ -391,7 +406,10 @@ class TemplateMixin:
             continuous_angle = math.atan2(pos.y() - p0.y(), pos.x() - p0.x())
             snap_angle_rad = math.radians(15)
             snapped_angle = round(continuous_angle / snap_angle_rad) * snap_angle_rad
-            p1 = p0 + QPointF(l * math.cos(snapped_angle), l * math.sin(snapped_angle))
+            p1 = p0 + QPointF(
+                bond_len * math.cos(snapped_angle),
+                bond_len * math.sin(snapped_angle),
+            )
             points = self._calculate_polygon_from_edge(p0, p1, n)
             self.template_context["items"] = [item]
 
@@ -409,8 +427,8 @@ class TemplateMixin:
             points = [
                 pos
                 + QPointF(
-                    l * math.cos(start_angle + i * angle_step),
-                    l * math.sin(start_angle + i * angle_step),
+                    bond_len * math.cos(start_angle + i * angle_step),
+                    bond_len * math.sin(start_angle + i * angle_step),
                 )
                 for i in range(n)
             ]
@@ -426,6 +444,57 @@ class TemplateMixin:
             self.template_context["points"] = points
             self.template_context["bonds_info"] = bonds_info
 
+            # Snap individual preview vertices to nearby atoms to reflect template fusing visually
+            if self.get_setting("template_fusing_enabled_2d", True) and not alt_pressed:
+                fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
+                mapped_atoms = set(self.template_context.get("items", []))
+                used_indices = set()
+                click_map_threshold = max(0.5 * bond_len, 8.0)
+
+                # Map already clicked existing items first
+                for ex_item in self.template_context.get("items", []):
+                    try:
+                        ex_pos = ex_item.pos()
+                        best_idx, best_d = -1, float("inf")
+                        for i, p in enumerate(points):
+                            if i in used_indices:
+                                continue
+                            d = math.hypot(p.x() - ex_pos.x(), p.y() - ex_pos.y())
+                            if d < best_d:
+                                best_d, best_idx = d, i
+                        if best_idx != -1 and best_d <= click_map_threshold:
+                            points[best_idx] = ex_pos
+                            used_indices.add(best_idx)
+                    except (AttributeError, TypeError, IndexError):
+                        pass
+
+                # Map unmapped points to other unmapped nearby atoms in the scene
+                if (
+                    hasattr(self, "data")
+                    and hasattr(self.data, "atoms")
+                    and self.data.atoms is not None
+                ):
+                    for i, p in enumerate(points):
+                        if i in used_indices:
+                            continue
+                        nearby = None
+                        best_d = float("inf")
+                        for atom_data in self.data.atoms.values():
+                            a_item = atom_data.get("item")
+                            if not a_item or a_item in mapped_atoms:
+                                continue
+                            try:
+                                d = math.hypot(
+                                    p.x() - a_item.pos().x(), p.y() - a_item.pos().y()
+                                )
+                            except (AttributeError, TypeError):
+                                continue
+                            if d < best_d:
+                                best_d, nearby = d, a_item
+                        if nearby and best_d <= fuse_dist:
+                            points[i] = nearby.pos()
+                            mapped_atoms.add(nearby)
+
             self.template_preview.set_geometry(points, is_aromatic)
 
             self.template_preview.show()
@@ -558,7 +627,9 @@ class TemplateMixin:
             if atom_id in self.data.atoms and self.data.atoms[atom_id]["item"]:
                 self.data.atoms[atom_id]["item"].update_style()
 
-    def update_user_template_preview(self, pos: QPointF) -> None:
+    def update_user_template_preview(
+        self, pos: QPointF, alt_pressed: Optional[bool] = None
+    ) -> None:
         """Update user template preview"""
         # Robust preview: avoid self.data.atoms for preview-only atoms
         if not hasattr(self, "user_template_data") or not self.user_template_data:
@@ -659,8 +730,8 @@ class KeyboardMixin:
         Returns the offset QPointF.
         """
         start_pos = start_atom.pos()
-        l = bond_length
-        new_pos_offset = QPointF(0, -l)  # Default offset (up)
+        bond_len = bond_length
+        new_pos_offset = QPointF(0, -bond_len)  # Default offset (up)
 
         # Get non-H neighbors
         neighbor_positions = []
@@ -673,7 +744,7 @@ class KeyboardMixin:
 
         if num_non_H_neighbors == 0:
             # Zero bonds: default direction (up)
-            new_pos_offset = QPointF(0, -l)
+            new_pos_offset = QPointF(0, -bond_len)
 
         elif num_non_H_neighbors == 1:
             # One bond: ~120/60 degree angle
@@ -688,7 +759,7 @@ class KeyboardMixin:
             new_vx, new_vy = vx * cos_a - vy * sin_a, vx * sin_a + vy * cos_a
             rotated_vector = QPointF(new_vx, new_vy)
             line = QLineF(QPointF(0, 0), rotated_vector)
-            line.setLength(l)
+            line.setLength(bond_len)
             new_pos_offset = line.p2()
 
         elif num_non_H_neighbors == 3:
@@ -705,10 +776,10 @@ class KeyboardMixin:
             # SUM_TOLERANCE is now a module-level constant
             if bond_vectors_sum.manhattanLength() > SUM_TOLERANCE:
                 new_direction_line = QLineF(QPointF(0, 0), -bond_vectors_sum)
-                new_direction_line.setLength(l)
+                new_direction_line.setLength(bond_len)
                 new_pos_offset = new_direction_line.p2()
             else:
-                new_pos_offset = QPointF(l * 0.7071, -l * 0.7071)
+                new_pos_offset = QPointF(bond_len * 0.7071, -bond_len * 0.7071)
 
         else:  # 2, 4+ bonds: skeleton continuation or over-bonding
             bond_vectors_sum = QPointF(0, 0)
@@ -721,26 +792,36 @@ class KeyboardMixin:
 
             if bond_vectors_sum.manhattanLength() > 0.01:
                 new_direction_line = QLineF(QPointF(0, 0), -bond_vectors_sum)
-                new_direction_line.setLength(l)
+                new_direction_line.setLength(bond_len)
                 new_pos_offset = new_direction_line.p2()
             else:
                 # Default (up) if sum is zero
-                new_pos_offset = QPointF(0, -l)
+                new_pos_offset = QPointF(0, -bond_len)
 
         return new_pos_offset
 
     def keyPressEvent(self, event: Any) -> None:
+        if not self.views():
+            try:
+                from PyQt6.QtWidgets import QGraphicsScene
+
+                QGraphicsScene.keyPressEvent(self, event)  # type: ignore[arg-type]
+            except (ImportError, AttributeError, TypeError, RuntimeError):
+                logging.exception("Error delegating keyPressEvent")
+            return
+
         view = self.views()[0]
         cursor_pos = view.mapToScene(view.mapFromGlobal(QCursor.pos()))
         transform = view.transform()
         key = event.key()
         modifiers = event.modifiers()
+
         item_at_cursor = None
         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", 14.0)
+            fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
             item_at_cursor = self.find_atom_near(cursor_pos, tol=fuse_dist)
         if item_at_cursor is None:
             item_at_cursor = self.itemAt(cursor_pos, transform)
@@ -759,7 +840,7 @@ class KeyboardMixin:
                     # Calculate placement like update_template_preview
                     if isinstance(item_at_cursor, AtomItem):
                         p0 = item_at_cursor.pos()
-                        l = DEFAULT_BOND_LENGTH
+                        bond_len = DEFAULT_BOND_LENGTH
 
                         # Check if this is a terminal atom (exactly 1 neighbor)
                         neighbor_positions = []
@@ -807,7 +888,8 @@ class KeyboardMixin:
                                 angle_plus if diff_plus < diff_minus else angle_minus
                             )
                             p1 = p0 + QPointF(
-                                l * math.cos(best_angle), l * math.sin(best_angle)
+                                bond_len * math.cos(best_angle),
+                                bond_len * math.sin(best_angle),
                             )
                             bend_dir = p0 - v_to_neighbor
                             points = self._calculate_polygon_from_edge(
@@ -816,9 +898,9 @@ class KeyboardMixin:
                         else:
                             direction = QLineF(p0, cursor_pos).unitVector()
                             p1 = (
-                                p0 + direction.p2() * l
+                                p0 + direction.p2() * bond_len
                                 if direction.length() > 0
-                                else p0 + QPointF(l, 0)
+                                else p0 + QPointF(bond_len, 0)
                             )
                             points = self._calculate_polygon_from_edge(
                                 p0, p1, n, cursor_pos=cursor_pos
@@ -1076,8 +1158,10 @@ class KeyboardMixin:
 
                 if start_atom:
                     start_pos = start_atom.pos()
-                    l = DEFAULT_BOND_LENGTH
-                    new_pos_offset = self._calculate_new_atom_position(start_atom, l)
+                    bond_len = DEFAULT_BOND_LENGTH
+                    new_pos_offset = self._calculate_new_atom_position(
+                        start_atom, bond_len
+                    )
 
                     # SNAP_DISTANCE is a module-level constant
                     target_pos = start_pos + new_pos_offset

moleditpy_linux/ui/molecule_scene.py

@@ -311,7 +311,7 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             and self.get_setting("template_fusing_enabled_2d", True)
             and self.press_pos
         ):
-            fuse_dist = self.get_setting("template_fusing_distance_2d", 14.0)
+            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:
             item = self.itemAt(self.press_pos, self.views()[0].transform())
@@ -361,7 +361,7 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
 
             target_atom = None
             if self.get_setting("template_fusing_enabled_2d", True) and current_pos:
-                fuse_dist = self.get_setting("template_fusing_distance_2d", 14.0)
+                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):
@@ -558,7 +558,7 @@ 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", 14.0)
+                fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
                 end_item = self.find_atom_near(end_pos, tol=fuse_dist)
             if end_item is None:
                 end_item = self.itemAt(end_pos, self.views()[0].transform())
@@ -612,7 +612,7 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             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", 14.0)
+                    fuse_dist = self.get_setting("template_fusing_distance_2d", 7.0)
                     end_item = self.find_atom_near(end_pos, tol=fuse_dist)
                 if end_item is None:
                     end_item = self.itemAt(end_pos, self.views()[0].transform())