MoleditPy-linux 4.5.2__tar.gz → 4.6.1__tar.gz

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.5.2
+Version: 4.6.1
 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
@@ -742,6 +742,7 @@ This application combines a modern GUI built with **PyQt6**, powerful cheminform
 
   * **Intuitive Operations:** Easily add, edit, and delete atoms and bonds with simple mouse controls. Left-click and drag to create, and right-click to delete.
   * **Advanced Templates:** Place templates for benzene or 3- to 9-membered rings with a live preview. Features intelligent logic to automatically adjust the double-bond configuration when fusing a benzene ring to an existing structure.
+  * **Alkyl Chain Tool:** Drag to draw a zigzag chain of any length — the bond length stays fixed, the chain axis snaps to 15° steps, and the number of carbons that will be added (`n`) is previewed next to the cursor.
   * **Charges & Radicals:** Quickly set formal charges (`+`/`-`) and radicals (`.`) on any atom using keyboard shortcuts or the toolbar.
   * **Full Element Support:** Select any element from a built-in periodic table dialog.
   * **Clipboard Operations:** Full support for `Cut` (Ctrl+X), `Copy` (Ctrl+C), and `Paste` (Ctrl+V) for molecular fragments.

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/README.md

@@ -39,6 +39,7 @@ This application combines a modern GUI built with **PyQt6**, powerful cheminform
 
   * **Intuitive Operations:** Easily add, edit, and delete atoms and bonds with simple mouse controls. Left-click and drag to create, and right-click to delete.
   * **Advanced Templates:** Place templates for benzene or 3- to 9-membered rings with a live preview. Features intelligent logic to automatically adjust the double-bond configuration when fusing a benzene ring to an existing structure.
+  * **Alkyl Chain Tool:** Drag to draw a zigzag chain of any length — the bond length stays fixed, the chain axis snaps to 15° steps, and the number of carbons that will be added (`n`) is previewed next to the cursor.
   * **Charges & Radicals:** Quickly set formal charges (`+`/`-`) and radicals (`.`) on any atom using keyboard shortcuts or the toolbar.
   * **Full Element Support:** Select any element from a built-in periodic table dialog.
   * **Clipboard Operations:** Full support for `Cut` (Ctrl+X), `Copy` (Ctrl+C), and `Paste` (Ctrl+V) for molecular fragments.

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/pyproject.toml

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

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.5.2
+Version: 4.6.1
 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
@@ -742,6 +742,7 @@ This application combines a modern GUI built with **PyQt6**, powerful cheminform
 
   * **Intuitive Operations:** Easily add, edit, and delete atoms and bonds with simple mouse controls. Left-click and drag to create, and right-click to delete.
   * **Advanced Templates:** Place templates for benzene or 3- to 9-membered rings with a live preview. Features intelligent logic to automatically adjust the double-bond configuration when fusing a benzene ring to an existing structure.
+  * **Alkyl Chain Tool:** Drag to draw a zigzag chain of any length — the bond length stays fixed, the chain axis snaps to 15° steps, and the number of carbons that will be added (`n`) is previewed next to the cursor.
   * **Charges & Radicals:** Quickly set formal charges (`+`/`-`) and radicals (`.`) on any atom using keyboard shortcuts or the toolbar.
   * **Full Element Support:** Select any element from a built-in periodic table dialog.
   * **Clipboard Operations:** Full support for `Cut` (Ctrl+X), `Copy` (Ctrl+C), and `Paste` (Ctrl+V) for molecular fragments.

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/MoleditPy_linux.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ src/moleditpy_linux/ui/base_picking_dialog.py
 src/moleditpy_linux/ui/bond_item.py
 src/moleditpy_linux/ui/bond_length_dialog.py
 src/moleditpy_linux/ui/calculation_worker.py
+src/moleditpy_linux/ui/chain_mixin.py
 src/moleditpy_linux/ui/color_settings_dialog.py
 src/moleditpy_linux/ui/compute_logic.py
 src/moleditpy_linux/ui/constrained_optimization_dialog.py

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/atom_item.py

@@ -34,7 +34,6 @@ from PyQt6.QtWidgets import (
 from ..utils.constants import (
     ATOM_RADIUS,
     CPK_COLORS,
-    DESIRED_ATOM_PIXEL_RADIUS,
     FONT_FAMILY,
     FONT_WEIGHT_BOLD,
 )
@@ -332,7 +331,13 @@ class AtomItem(QGraphicsItem):
         return path
 
     def shape(self) -> QPainterPath:
-        """Define the shape of the atom item for collision detection."""
+        """Define the shape of the atom item for collision detection.
+
+        The hit radius is derived from the ``bond_snapping_distance_2d``
+        setting so that hover highlight matches the snapping / keyboard
+        instant-switch zone exactly.  The radius is expressed in screen
+        pixels and divided by the current view scale.
+        """
         scene = self.scene()
         if not scene or not scene.views():
             path = QPainterPath()
@@ -342,8 +347,16 @@ class AtomItem(QGraphicsItem):
 
         view = scene.views()[0]
         scale = view.transform().m11()
+        if scale <= 0.0:
+            scale = 1.0
 
-        scene_radius = DESIRED_ATOM_PIXEL_RADIUS / scale
+        # Use the same setting that find_atom_near() uses for snapping,
+        # so hover highlight and snap zones are identical.
+        if hasattr(scene, "get_setting"):
+            hit_px = scene.get_setting("bond_snapping_distance_2d", 14.0)
+        else:
+            hit_px = 14.0
+        scene_radius = hit_px / scale
 
         path = QPainterPath()
         path.addEllipse(QPointF(0, 0), scene_radius, scene_radius)

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/bond_item.py

@@ -36,7 +36,6 @@ from PyQt6.QtWidgets import (
 )
 
 from ..utils.constants import (
-    DESIRED_BOND_PIXEL_WIDTH,
     EZ_LABEL_BOX_SIZE,
     EZ_LABEL_MARGIN,
     EZ_LABEL_TEXT_OUTLINE,
@@ -293,10 +292,25 @@ class BondItem(QGraphicsItem):
             path.moveTo(line.p1())
             path.lineTo(line.p2())
 
-            # Stroke it to give it some width (e.g., 10px or dynamic based on settings) generally easier to click
-            # even if the visual width is smaller.
+            # Use the exact same setting as atom hover highlight and snapping, zoom-aware.
+            scene = self.scene()
+            if scene and scene.views():
+                view = scene.views()[0]
+                scale = view.transform().m11()
+                if scale <= 0.0:
+                    scale = 1.0
+                if hasattr(scene, "get_setting"):
+                    hit_px = scene.get_setting("bond_snapping_distance_2d", 14.0)
+                else:
+                    hit_px = 14.0
+                # width is diameter, so 2 * radius
+                scene_width = (hit_px * 2) / scale
+            else:
+                scene_width = 28.0
+
+            # Stroke it to give it some width
             stroker = QPainterPathStroker()
-            stroker.setWidth(DESIRED_BOND_PIXEL_WIDTH)  # Use constant (20.0)
+            stroker.setWidth(scene_width)
             path = stroker.createStroke(path)
 
             # If there's an E/Z label, add its rect to the selection shape

moleditpy_linux-4.6.1/src/moleditpy_linux/ui/chain_mixin.py

@@ -0,0 +1,178 @@
+#!/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
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any, List, Optional, Tuple
+
+from PyQt6.QtCore import QPointF
+
+from .atom_item import AtomItem
+from ..utils.constants import DEFAULT_BOND_LENGTH
+
+# Half of the 120 deg zigzag angle, measured from the chain axis.
+CHAIN_HALF_ANGLE_DEG = 30.0
+CHAIN_ANGLE_SNAP_DEG = 15.0
+MAX_CHAIN_LENGTH = 100
+# Reject an end snap that would collapse the tail bond onto its neighbour.
+MIN_TAIL_BOND_RATIO = 0.4
+
+
+class ChainMixin:
+    """Drag-to-draw tool that grows a fixed-bond-length zigzag alkyl chain."""
+
+    add_molecule_fragment: Any
+    current_atom_symbol: Any
+    find_atom_near: Any
+    get_setting: Any
+    template_preview: Any
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.chain_anchor: Optional[QPointF] = None
+        self.chain_start_atom: Optional[AtomItem] = None
+        self.chain_end_atom: Optional[AtomItem] = None
+        self.chain_points: List[QPointF] = []
+        self.chain_active: bool = False
+        super().__init__(*args, **kwargs)
+
+    def begin_chain(self, pos: QPointF, start_atom: Optional[AtomItem] = None) -> None:
+        """Anchor a new chain drag at ``pos`` (or at ``start_atom`` if given)."""
+        self.chain_start_atom = start_atom
+        self.chain_end_atom = None
+        self.chain_anchor = start_atom.pos() if start_atom is not None else QPointF(pos)
+        self.chain_points = []
+        self.chain_active = True
+
+    def chain_geometry(
+        self, cursor: QPointF
+    ) -> Tuple[List[QPointF], Optional[AtomItem]]:
+        """Zigzag for this cursor, with the last vertex pulled onto a nearby atom.
+
+        Every other bond keeps the fixed length, so the tail bond absorbs the
+        whole difference and may end up longer or shorter. Both ends of the drag
+        use the shared 2D bond snapping distance, as bond drawing does.
+        """
+        if self.chain_anchor is None:
+            return [], None
+
+        points = self.calculate_chain_points(self.chain_anchor, cursor)
+        if len(points) < 2:
+            return points, None
+
+        snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+        target = self.find_atom_near(cursor, tol=snap_dist)
+        if target is None or target is self.chain_start_atom:
+            return points, None
+
+        end = target.pos()
+        prev = points[-2]
+        tail = math.hypot(end.x() - prev.x(), end.y() - prev.y())
+        if tail < MIN_TAIL_BOND_RATIO * DEFAULT_BOND_LENGTH:
+            return points, None
+
+        points[-1] = end
+        return points, target
+
+    def calculate_chain_points(self, anchor: QPointF, cursor: QPointF) -> List[QPointF]:
+        """Return the zigzag vertices from ``anchor`` toward ``cursor``.
+
+        The chain axis is snapped to 15 deg steps, every bond keeps the standard
+        2D bond length, and the number of bonds follows the drag distance
+        projected onto the axis.
+        """
+        vx = cursor.x() - anchor.x()
+        vy = cursor.y() - anchor.y()
+
+        snap = math.radians(CHAIN_ANGLE_SNAP_DEG)
+        axis_angle = round(math.atan2(vy, vx) / snap) * snap
+        ax, ay = math.cos(axis_angle), math.sin(axis_angle)
+
+        half = math.radians(CHAIN_HALF_ANGLE_DEG)
+        step = DEFAULT_BOND_LENGTH * math.cos(half)
+        offset = DEFAULT_BOND_LENGTH * math.sin(half)
+
+        count = int(round((vx * ax + vy * ay) / step))
+        if count < 1:
+            return []
+        count = min(count, MAX_CHAIN_LENGTH)
+
+        # Zigzag bulges toward the side of the axis the cursor drifted to.
+        side = -1.0 if (ax * vy - ay * vx) < 0 else 1.0
+        px, py = -ay * offset * side, ax * offset * side
+
+        points = [QPointF(anchor)]
+        for k in range(1, count + 1):
+            wobble = 1.0 if k % 2 else 0.0
+            points.append(
+                QPointF(
+                    anchor.x() + ax * step * k + px * wobble,
+                    anchor.y() + ay * step * k + py * wobble,
+                )
+            )
+        return points
+
+    def update_chain_preview(self, pos: QPointF) -> None:
+        """Refresh the ghost chain and the repeat-count label near the cursor."""
+        if not self.chain_active or self.chain_anchor is None:
+            return
+
+        self.chain_points, self.chain_end_atom = self.chain_geometry(pos)
+        if len(self.chain_points) < 2:
+            self.template_preview.hide()
+            return
+
+        self.template_preview.set_chain_geometry(
+            self.chain_points,
+            f"n = {self.new_atom_count()}",
+            QPointF(pos.x() + 16, pos.y() - 12),
+        )
+        self.template_preview.show()
+
+    def new_atom_count(self) -> int:
+        """Atoms the previewed chain would add; reused end atoms do not count."""
+        if not self.chain_points:
+            return 0
+        reused = sum(
+            1
+            for atom in (self.chain_start_atom, self.chain_end_atom)
+            if atom is not None
+        )
+        return len(self.chain_points) - reused
+
+    def clear_chain_preview(self) -> None:
+        """Hide the ghost chain and drop the drag state."""
+        self.chain_anchor = None
+        self.chain_start_atom = None
+        self.chain_end_atom = None
+        self.chain_points = []
+        self.chain_active = False
+        self.template_preview.hide()
+
+    def commit_chain(self, pos: QPointF) -> bool:
+        """Materialize the previewed chain as atoms and bonds. True if anything was added."""
+        if self.chain_anchor is None:
+            return False
+
+        points, end_atom = self.chain_geometry(pos)
+        if len(points) < 2:
+            return False
+
+        bonds_info = [(i, i + 1, 1) for i in range(len(points) - 1)]
+        # Naming both reused atoms fuses them even with template fusing turned off.
+        existing = [
+            atom for atom in (self.chain_start_atom, end_atom) if atom is not None
+        ]
+        self.add_molecule_fragment(
+            points, bonds_info, existing_items=existing, symbol=self.current_atom_symbol
+        )
+        return True

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/main_window_init.py

@@ -873,6 +873,17 @@ class MainInitManager:
             self.tool_group.addAction(action)  # type: ignore[union-attr]
         toolbar.addSeparator()
 
+    def _add_chain_action(self, toolbar: QToolBar) -> None:
+        """Add the drag-to-draw alkyl chain action."""
+        action = QAction(self.host)
+        action.setIcon(self._create_chain_icon())
+        action.setToolTip("Alkyl Chain — drag to draw a zigzag chain")
+        action.setCheckable(True)
+        action.triggered.connect(lambda checked: self.host.ui_manager.set_mode("chain"))
+        self.mode_actions["chain"] = action
+        toolbar.addAction(action)
+        self.tool_group.addAction(action)  # type: ignore[union-attr]
+
     def _add_charge_radical_actions(self, toolbar: QToolBar) -> None:
         """Add charge and radical modification actions."""
         ops = [
@@ -910,6 +921,8 @@ class MainInitManager:
             toolbar_bottom.addAction(action)
             self.tool_group.addAction(action)  # type: ignore[union-attr]
 
+        self._add_chain_action(toolbar_bottom)
+
         user_action = QAction("USER", self.host)
         user_action.setCheckable(True)
         user_action.setToolTip("Open User Templates Dialog")
@@ -1039,6 +1052,57 @@ class MainInitManager:
         painter.end()
         return QIcon(pixmap)
 
+    def _create_chain_icon(self, size: int = 32) -> QIcon:
+        """Generate the -(-)n- repeat-unit icon for the alkyl chain tool."""
+        fg = self._get_icon_foreground_color()
+        pixmap = QPixmap(size, size)
+        pixmap.fill(Qt.GlobalColor.transparent)
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.setPen(QPen(fg, max(1.8, size / 16.0)))
+        painter.setBrush(Qt.BrushStyle.NoBrush)
+
+        cy = size * 0.375
+        amp = size * 0.17
+        # Backbone zigzag spans the full width so the repeat brackets cross it.
+        zig = [
+            QPointF(1 + i * (size - 2) / 2.0, cy + (amp if i % 2 == 0 else -amp))
+            for i in range(3)
+        ]
+        for start, end in zip(zig, zig[1:]):
+            painter.drawLine(start, end)
+
+        painter.setPen(QPen(fg, max(1.5, size / 20.0)))
+        bracket_h = size * 0.55
+        bracket_w = size * 0.19
+        inset = size * 0.13
+        painter.drawArc(
+            QRectF(inset, cy - bracket_h / 2, bracket_w, bracket_h), 118 * 16, 124 * 16
+        )
+        painter.drawArc(
+            QRectF(size - inset - bracket_w, cy - bracket_h / 2, bracket_w, bracket_h),
+            -62 * 16,
+            124 * 16,
+        )
+
+        font = painter.font()
+        font.setPixelSize(max(8, int(size * 0.30)))
+        font.setBold(True)
+        painter.setFont(font)
+        painter.drawText(
+            QRectF(
+                size - size * 0.26,
+                cy + bracket_h / 2 - size * 0.06,
+                size * 0.24,
+                size * 0.36,
+            ),
+            Qt.AlignmentFlag.AlignCenter,
+            "n",
+        )
+
+        painter.end()
+        return QIcon(pixmap)
+
     def _create_template_icon(
         self, n: int, is_benzene: bool = False, size: int = 32
     ) -> QIcon:

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/molecular_scene_handler.py

@@ -856,7 +856,10 @@ class KeyboardMixin:
             return
 
         view = self.views()[0]
-        cursor_pos = view.mapToScene(view.mapFromGlobal(QCursor.pos()))
+        # mapToScene expects viewport coordinates. Mapping to the view widget directly
+        # includes the widget's frame margins, introducing a cursor offset that gets
+        # magnified when zooming.
+        cursor_pos = view.mapToScene(view.viewport().mapFromGlobal(QCursor.pos()))
         transform = view.transform()
         key = event.key()
         modifiers = event.modifiers()
@@ -1587,9 +1590,22 @@ class SceneQueryMixin:
             return False
 
     def find_atom_near(self, pos: Any, tol: float = 14.0) -> Any:
-        """Return the AtomItem within tolerance distance of pos, or None."""
+        """Return the AtomItem within tolerance distance of pos, or None.
+
+        ``tol`` is specified in **screen pixels**.  It is divided by the
+        current view scale so that the effective snap radius stays constant
+        on screen regardless of zoom level — matching the behaviour of
+        ``AtomItem.shape()`` (hover highlight).
+        """
         if pos is None:
             return None
+        # Convert screen-pixel tolerance to scene units (zoom-aware).
+        if self.views():
+            xform = self.views()[0].transform()
+            if xform is not None:
+                scale = xform.m11()
+                if scale > 0:
+                    tol = tol / scale
         # Create a small search rectangle around the position
         search_rect = QRectF(pos.x() - tol, pos.y() - tol, 2 * tol, 2 * tol)
         nearby_items = self.items(search_rect)

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/molecule_scene.py

@@ -36,9 +36,12 @@ from .template_preview_item import TemplatePreviewItem
 from ..utils.sip_isdeleted_safe import sip_isdeleted_safe
 
 from .molecular_scene_handler import TemplateMixin, KeyboardMixin, SceneQueryMixin
+from .chain_mixin import ChainMixin
 
 
-class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScene):
+class MoleculeScene(
+    ChainMixin, TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScene
+):
     """Central QGraphicsScene that owns all 2D atom and bond items."""
 
     def __init__(self, data: MolecularData, window: MainWindow) -> None:
@@ -433,6 +436,15 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
             event.accept()
             return  # Complete right-click processing and prevent proceeding to left-click logic
 
+        if self.mode == "chain":
+            self.clearSelection()
+            snap_dist = self.get_setting("bond_snapping_distance_2d", 14.0)
+            self.begin_chain(
+                self.press_pos, self.find_atom_near(self.press_pos, tol=snap_dist)
+            )
+            event.accept()
+            return
+
         if self.mode.startswith("template"):
             self.clearSelection()  # In template mode, no selection is made; only the click position is recorded.
             return
@@ -487,6 +499,10 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
         if self.mode.startswith("template"):
             self.update_template_preview(event.scenePos())
 
+        if self.mode == "chain" and self.chain_active:
+            self.update_chain_preview(event.scenePos())
+            return
+
         if not self.mouse_moved_since_press and self.press_pos:
             if (
                 event.scenePos() - self.press_pos
@@ -544,6 +560,20 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
 
             self.temp_line = None
 
+        if self.mode == "chain":
+            committed = False
+            if self.chain_active:
+                committed = self.commit_chain(end_pos)
+            self.clear_chain_preview()
+            self.start_atom = None
+            self.start_pos = None
+            self.press_pos = None
+            if committed:
+                self.data_changed_in_event = True
+                self.update_all_items()
+                self.window.edit_actions_manager.push_undo_state()
+            return
+
         if self.mode.startswith("template") and is_click:
             if self.template_context and self.template_context.get("points"):
                 context = self.template_context
@@ -972,8 +1002,8 @@ class MoleculeScene(TemplateMixin, KeyboardMixin, SceneQueryMixin, QGraphicsScen
         # Find the active view for this scene
         for view in self.views():
             if view.isVisible():
-                # Map global cursor position to scene coordinates
-                local_pos = view.mapFromGlobal(global_pos)
+                # Map global cursor position to scene coordinates (via viewport)
+                local_pos = view.viewport().mapFromGlobal(global_pos)
                 scene_pos = view.mapToScene(local_pos)
 
                 # If the mouse is within the viewport, trigger the preview update

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/settings_tabs/settings_2d_tab.py

@@ -198,7 +198,10 @@ class Settings2DTab(SettingsTabBase):
             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."
+            "The distance in screen pixels (zoom-independent) within which:\n"
+            "• Drawing a bond snaps to an existing atom\n"
+            "• Keyboard shortcuts instantly edit the atom under cursor\n"
+            "• Atoms show hover highlight"
         )
         form_layout.addRow(
             "Bond Snapping Distance (px):",

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/template_preview_item.py

@@ -34,6 +34,10 @@ class TemplatePreviewItem(QGraphicsItem):
         self.user_template_bonds: List[Any] = []
         self.user_template_atoms: List[Any] = []
         self.is_user_template = False
+        self.chain_points: List[QPointF] = []
+        self.chain_label = ""
+        self.chain_label_pos = QPointF()
+        self.is_chain = False
 
     def set_geometry(self, points: list[QPointF], is_aromatic: bool = False) -> None:
         """Set polygon points for a standard ring template preview."""
@@ -41,6 +45,21 @@ class TemplatePreviewItem(QGraphicsItem):
         self.polygon = QPolygonF(points)
         self.is_aromatic = is_aromatic
         self.is_user_template = False
+        self.is_chain = False
+        self.update()
+
+    def set_chain_geometry(
+        self, points: list[QPointF], label: str, label_pos: QPointF
+    ) -> None:
+        """Set the zigzag vertices and the repeat-count label for a chain preview."""
+        self.prepareGeometryChange()
+        self.chain_points = list(points)
+        self.chain_label = label
+        self.chain_label_pos = QPointF(label_pos)
+        self.is_chain = True
+        self.is_user_template = False
+        self.is_aromatic = False
+        self.polygon = QPolygonF()
         self.update()
 
     def set_user_template_geometry(
@@ -55,12 +74,22 @@ class TemplatePreviewItem(QGraphicsItem):
         self.user_template_bonds = bonds_info
         self.user_template_atoms = atoms_data
         self.is_user_template = True
+        self.is_chain = False
         self.is_aromatic = False
         self.polygon = QPolygonF()
         self.update()
 
     def boundingRect(self) -> QRectF:
         """Return the bounding rect encompassing the preview geometry."""
+        if self.is_chain and self.chain_points:
+            xs = [p.x() for p in self.chain_points] + [self.chain_label_pos.x()]
+            ys = [p.y() for p in self.chain_points] + [self.chain_label_pos.y()]
+            return QRectF(
+                min(xs) - 10,
+                min(ys) - 20,
+                max(xs) - min(xs) + 90,
+                max(ys) - min(ys) + 40,
+            )
         if self.is_user_template and self.user_template_points:
             # Calculate bounding rect for user template
             min_x = min(p.x() for p in self.user_template_points)
@@ -81,11 +110,43 @@ class TemplatePreviewItem(QGraphicsItem):
         """Dispatch to the regular or user-template painter."""
         if painter is None:
             return
-        if self.is_user_template:
+        if self.is_chain:
+            self.paint_chain(painter)
+        elif self.is_user_template:
             self.paint_user_template(painter)
         else:
             self.paint_regular_template(painter)
 
+    def paint_chain(self, painter: QPainter) -> None:
+        """Paint the ghost zigzag chain plus the repeat count next to the cursor."""
+        if len(self.chain_points) < 2:
+            return
+
+        painter.setPen(QPen(QColor(80, 80, 80, 180), 2.5))
+        painter.setBrush(Qt.BrushStyle.NoBrush)
+        for i in range(len(self.chain_points) - 1):
+            painter.drawLine(QLineF(self.chain_points[i], self.chain_points[i + 1]))
+
+        dot = QColor(80, 80, 80, 140)
+        painter.setBrush(QBrush(dot))
+        painter.setPen(QPen(dot, 1))
+        for p in self.chain_points[1:]:
+            painter.drawEllipse(p, 2.5, 2.5)
+
+        if not self.chain_label:
+            return
+        font = QFont("Arial", 11, QFont.Weight.Bold)
+        painter.setFont(font)
+        metrics = painter.fontMetrics()
+        rect = QRectF(metrics.boundingRect(self.chain_label))
+        rect.moveTopLeft(self.chain_label_pos)
+        rect = rect.adjusted(-5, -3, 5, 3)
+        painter.setPen(QPen(QColor(80, 80, 80, 180), 1))
+        painter.setBrush(QBrush(QColor(255, 255, 255, 225)))
+        painter.drawRoundedRect(rect, 4, 4)
+        painter.setPen(QPen(QColor(40, 40, 40)))
+        painter.drawText(rect, Qt.AlignmentFlag.AlignCenter, self.chain_label)
+
     def paint_regular_template(self, painter: QPainter) -> None:
         """Paint a standard ring or aromatic template as a polygon outline."""
         painter.setPen(self.pen)

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/ui_manager.py

@@ -62,6 +62,10 @@ class UIManager(QObject):
 
         # Trigger immediate scene refresh to show/update template previews
         self.host.init_manager.scene.refresh_mode_state()
+        # A shortcut key can switch modes mid-drag; drop the abandoned chain anchor.
+        if prev_mode == "chain" and mode_str != "chain":
+            self.host.init_manager.scene.clear_chain_preview()
+
         # Clear ghost when leaving template mode
         if (
             prev_mode
@@ -75,7 +79,7 @@ class UIManager(QObject):
         # Set cursor shape
         if mode_str == "select":
             self.host.init_manager.view_2d.setCursor(Qt.CursorShape.ArrowCursor)
-        elif mode_str.startswith(("atom", "bond", "template")):
+        elif mode_str.startswith(("atom", "bond", "template", "chain")):
             self.host.init_manager.view_2d.setCursor(Qt.CursorShape.CrossCursor)
         elif mode_str.startswith(("charge", "radical")):
             self.host.init_manager.view_2d.setCursor(Qt.CursorShape.CrossCursor)
@@ -101,6 +105,14 @@ class UIManager(QObject):
             )
             self.host.init_manager.view_2d.setDragMode(QGraphicsView.DragMode.NoDrag)
             self.host.init_manager.view_2d.setMouseTracking(True)
+        elif mode_str == "chain":
+            self.host.set_scene_atom_symbol("C")
+            self.host.set_scene_bond_properties(1, 0)
+            self.host.update_status_message(
+                "Mode: Alkyl Chain (Drag to set the chain length)"
+            )
+            self.host.init_manager.view_2d.setDragMode(QGraphicsView.DragMode.NoDrag)
+            self.host.init_manager.view_2d.setMouseTracking(True)
         elif mode_str.startswith("template"):
             if mode_str.startswith("template_user"):
                 # User template mode

{moleditpy_linux-4.5.2 → moleditpy_linux-4.6.1}/src/moleditpy_linux/ui/zoomable_view.py

@@ -113,7 +113,7 @@ class ZoomableView(QGraphicsView):
             current_mode = self.scene().mode if self.scene() else "select"  # type: ignore[union-attr]
             if current_mode == "select":
                 self.setCursor(Qt.CursorShape.ArrowCursor)
-            elif current_mode.startswith(("atom", "bond", "template")):
+            elif current_mode.startswith(("atom", "bond", "template", "chain")):
                 self.setCursor(Qt.CursorShape.CrossCursor)
             elif current_mode.startswith(("charge", "radical")):
                 self.setCursor(Qt.CursorShape.CrossCursor)