MoleditPy-linux 4.5.1__tar.gz → 4.6.0__tar.gz

{moleditpy_linux-4.5.1 → moleditpy_linux-4.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.5.1
+Version: 4.6.0
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -697,7 +697,7 @@ Requires-Dist: numpy
 Requires-Dist: pyqt6<6.10; python_version == "3.9"
 Requires-Dist: pyqt6<6.12; python_version != "3.9"
 Requires-Dist: pyvista<0.49
-Requires-Dist: pyvistaqt<0.12
+Requires-Dist: pyvistaqt<0.13
 Requires-Dist: rdkit<2026.4
 Dynamic: license-file
 
@@ -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.1 → moleditpy_linux-4.6.0}/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.1 → moleditpy_linux-4.6.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "MoleditPy-linux"
 
-version = "4.5.1"
+version = "4.6.0"
 
 license = {file = "LICENSE"}
 
@@ -37,7 +37,7 @@ dependencies = [
     "pyqt6 < 6.10; python_version == '3.9'",
     "pyqt6 < 6.12; python_version != '3.9'",
     "pyvista < 0.49",
-    "pyvistaqt < 0.12",
+    "pyvistaqt < 0.13",
     "rdkit < 2026.4",
 ]
 

{moleditpy_linux-4.5.1 → moleditpy_linux-4.6.0}/src/MoleditPy_linux.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy-linux
-Version: 4.5.1
+Version: 4.6.0
 Summary: A cross-platform, simple, and intuitive molecular structure editor built in Python. It allows 2D molecular drawing and 3D structure visualization. It supports exporting structure files for input to DFT calculation software.
 Author-email: HiroYokoyama <titech.yoko.hiro@gmail.com>
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -697,7 +697,7 @@ Requires-Dist: numpy
 Requires-Dist: pyqt6<6.10; python_version == "3.9"
 Requires-Dist: pyqt6<6.12; python_version != "3.9"
 Requires-Dist: pyvista<0.49
-Requires-Dist: pyvistaqt<0.12
+Requires-Dist: pyvistaqt<0.13
 Requires-Dist: rdkit<2026.4
 Dynamic: license-file
 
@@ -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.1 → moleditpy_linux-4.6.0}/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.1 → moleditpy_linux-4.6.0}/src/MoleditPy_linux.egg-info/requires.txt

@@ -1,6 +1,6 @@
 numpy
 pyvista<0.49
-pyvistaqt<0.12
+pyvistaqt<0.13
 rdkit<2026.4
 
 [:python_version != "3.9"]

{moleditpy_linux-4.5.1 → moleditpy_linux-4.6.0}/src/moleditpy_linux/ui/atom_item.py

@@ -43,6 +43,34 @@ from ..utils.sip_isdeleted_safe import sip_isdeleted_safe
 if TYPE_CHECKING:
     from .bond_item import BondItem
 
+SUBSCRIPT_MAP = str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉")
+
+# Every subscript digit, so one warm-up covers any implicit-H count.
+_WARM_UP_TEXT = "CH" + "0123456789".translate(SUBSCRIPT_MAP)
+
+
+def warm_font_cache(font: Optional[QFont] = None) -> None:
+    """Pay Qt's one-off font costs up front instead of on the first heteroatom.
+
+    Two process-wide costs hide in QFontMetricsF: the first text shaping in a
+    family (~10-120 ms, worse on a cold Windows font cache) and the first
+    lookup of a subscript digit, which Arial lacks — Qt answers that by walking
+    the whole system font database (~200-330 ms, measured).
+
+    Drawing a carbon skeleton pays neither: a bonded neutral carbon is
+    invisible, so it renders no glyph at all. The first O or N a user places
+    gets "OH₂" and pays both at once, mid-click, as a visible freeze.
+
+    Call once on the GUI thread after the window is up. QFontMetricsF is not
+    usable off the GUI thread, so this cannot move to a worker.
+    """
+    try:
+        QFontMetricsF(font or QFont(FONT_FAMILY, 20, FONT_WEIGHT_BOLD)).boundingRect(
+            _WARM_UP_TEXT
+        )
+    except (RuntimeError, TypeError, ValueError):
+        logging.debug("Font cache warm-up skipped", exc_info=True)
+
 
 class AtomItem(QGraphicsItem):
     """2D scene item representing a single atom in the molecule editor."""
@@ -138,8 +166,7 @@ class AtomItem(QGraphicsItem):
             if not is_skeletal_carbon:
                 hydrogen_part = "H"
                 if self.implicit_h_count > 1:
-                    subscript_map = str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉")
-                    hydrogen_part += str(self.implicit_h_count).translate(subscript_map)
+                    hydrogen_part += str(self.implicit_h_count).translate(SUBSCRIPT_MAP)
 
         flip_text = False
         if hydrogen_part and self.bonds:
@@ -261,8 +288,7 @@ class AtomItem(QGraphicsItem):
             if not is_skeletal_carbon:
                 hydrogen_part = "H"
                 if self.implicit_h_count > 1:
-                    subscript_map = str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉")
-                    hydrogen_part += str(self.implicit_h_count).translate(subscript_map)
+                    hydrogen_part += str(self.implicit_h_count).translate(SUBSCRIPT_MAP)
 
         flip_text = False
         if hydrogen_part and self.bonds:
@@ -361,9 +387,8 @@ class AtomItem(QGraphicsItem):
                 if not is_skeletal_carbon:
                     hydrogen_part = "H"
                     if self.implicit_h_count > 1:
-                        subscript_map = str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉")
                         hydrogen_part += str(self.implicit_h_count).translate(
-                            subscript_map
+                            SUBSCRIPT_MAP
                         )
 
             # --- Determine if the text should be flipped ---

moleditpy_linux-4.6.0/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.1 → moleditpy_linux-4.6.0}/src/moleditpy_linux/ui/main_window_init.py

@@ -20,9 +20,6 @@ import os
 import sys
 from typing import Any, Dict, Optional
 
-# RDKit imports (explicit to satisfy flake8 and used features)
-from rdkit import Chem
-
 # PyQt6 Modules
 from PyQt6.QtCore import QLineF, QPointF, QRectF, Qt, QTimer, QUrl
 from PyQt6.QtGui import (
@@ -65,7 +62,8 @@ except ImportError:
     winreg = None  # type: ignore[assignment]
 
 
-from ..utils.constants import DEFAULT_CPK_COLORS, NUM_DASHES, VERSION
+from ..utils.constants import DEFAULT_CPK_COLORS, FONT_FAMILY, NUM_DASHES, VERSION
+from .atom_item import warm_font_cache
 from .custom_qt_interactor import CustomQtInteractor
 from ..core.molecular_data import MolecularData
 from .molecule_scene import MoleculeScene
@@ -74,6 +72,10 @@ from .settings_dialog import SettingsDialog
 from .zoomable_view import ZoomableView
 
 
+# Distinct from None, which is a real answer meaning "OS preference unknown".
+_UNQUERIED = object()
+
+
 class MainInitManager:
     """Feature class separated from main_window.py"""
 
@@ -82,6 +84,7 @@ class MainInitManager:
     ) -> None:
         self.host = host
         # Explicit declarations for Mypy
+        self._os_dark_pref: Any = _UNQUERIED
         self.scene: Any = None  # MoleculeScene, created during init
         self.data: Optional[MolecularData] = None
         self.formula_label: Optional[QLabel] = None
@@ -179,18 +182,6 @@ class MainInitManager:
         # Install event filter to capture window close events (handled in UIManager)
         self.host.installEventFilter(self.host.ui_manager)
 
-        # RDKit Warm-up (initial execution cost)
-        try:
-            # Create a molecule with a variety of common atoms to ensure
-            # the valence/H-count machinery is fully initialized.
-            warmup_smiles = "OC(N)C(S)P"
-            warmup_mol = Chem.MolFromSmiles(warmup_smiles)
-            if warmup_mol:
-                for atom in warmup_mol.GetAtoms():
-                    atom.GetNumImplicitHs()
-        except (AttributeError, RuntimeError, ValueError) as e:
-            logging.warning(f"RDKit warm-up failed: {e}")
-
         self.host.state_manager.reset_undo_stack()
         self.scene.selectionChanged.connect(  # type: ignore[attr-defined]
             self.host.edit_actions_manager.update_edit_menu_actions
@@ -206,6 +197,8 @@ class MainInitManager:
             QTimer.singleShot(0, lambda: self.load_command_line_file(initial_file))
 
         QTimer.singleShot(0, self.apply_initial_settings)
+        # After apply_initial_settings, so the user's own font family is warmed.
+        QTimer.singleShot(0, self._warm_font_cache)
         # Camera initialization flag (permits reset only during the first draw)
         self._camera_initialized = False
 
@@ -226,6 +219,19 @@ class MainInitManager:
                 f"Suppressed exception: {e}"
             )  # Suppress non-critical UI/menu initialization errors
 
+    def _warm_font_cache(self) -> None:
+        """Resolve the atom-label font now, in the user's configured family."""
+        scene = getattr(self, "scene", None)
+        font = None
+        if scene is not None and hasattr(scene, "get_setting"):
+            family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
+            size = scene.get_setting("atom_font_size_2d", 20)
+            bold = scene.get_setting("atom_font_bold_2d", True)
+            font = QFont(
+                family, size, QFont.Weight.Bold if bold else QFont.Weight.Normal
+            )
+        warm_font_cache(font)
+
     def init_ui(self) -> None:
         """Set the window icon and initialize main layout, toolbars, and menu bar."""
         script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -867,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 = [
@@ -904,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")
@@ -1033,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:
@@ -1076,7 +1146,11 @@ class MainInitManager:
                 return QColor(fg)
 
         with suppress_log(Exception):
-            os_pref = detect_system_dark_mode()
+            # Cached: this forks `defaults`/`gsettings` on macOS and Linux, and
+            # icon painting asks once per icon (15+ during startup).
+            if self._os_dark_pref is _UNQUERIED:
+                self._os_dark_pref = detect_system_dark_mode()
+            os_pref = self._os_dark_pref
             if os_pref is not None:
                 return QColor("#FFFFFF") if os_pref else QColor("#000000")
 

{moleditpy_linux-4.5.1 → moleditpy_linux-4.6.0}/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

{moleditpy_linux-4.5.1 → moleditpy_linux-4.6.0}/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.1 → moleditpy_linux-4.6.0}/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.1 → moleditpy_linux-4.6.0}/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)

{moleditpy_linux-4.5.1 → moleditpy_linux-4.6.0}/src/moleditpy_linux/utils/system_utils.py

@@ -21,6 +21,9 @@ try:
 except ImportError:
     winreg = None  # type: ignore[assignment]
 
+# A wedged `defaults`/`gsettings` must not take the app's startup with it.
+_THEME_QUERY_TIMEOUT_S = 5.0
+
 
 def detect_system_dark_mode() -> Optional[bool]:
     """Return True if the OS prefers dark app theme, False if light, or None if unknown."""
@@ -33,8 +36,18 @@ def detect_system_dark_mode() -> Optional[bool]:
 
 
 def detect_system_theme() -> Optional[str]:
-    """Return the OS's preferred theme setting as 'dark', 'light', or None."""
-    with suppress_log(AttributeError, RuntimeError, OSError, FileNotFoundError):
+    """Return the OS's preferred theme setting as 'dark', 'light', or None.
+
+    Forks a helper process on macOS and Linux, so callers that ask repeatedly
+    should hold on to the answer rather than re-querying.
+    """
+    with suppress_log(
+        AttributeError,
+        RuntimeError,
+        OSError,
+        FileNotFoundError,
+        subprocess.SubprocessError,
+    ):
         # Windows
         if platform.system() == "Windows" and winreg is not None:
             with winreg.OpenKey(
@@ -50,6 +63,7 @@ def detect_system_theme() -> Optional[str]:
                 ["defaults", "read", "-g", "AppleInterfaceStyle"],
                 capture_output=True,
                 text=True,
+                timeout=_THEME_QUERY_TIMEOUT_S,
             )
             if p.returncode == 0 and "dark" in p.stdout.strip().lower():
                 return "dark"
@@ -61,6 +75,7 @@ def detect_system_theme() -> Optional[str]:
                 ["gsettings", "get", "org.gnome.desktop.interface", "color-scheme"],
                 capture_output=True,
                 text=True,
+                timeout=_THEME_QUERY_TIMEOUT_S,
             )
             if p.returncode == 0:
                 out = p.stdout.strip().strip("'\n ")
@@ -73,6 +88,7 @@ def detect_system_theme() -> Optional[str]:
                 ["gsettings", "get", "org.gnome.desktop.interface", "gtk-theme"],
                 capture_output=True,
                 text=True,
+                timeout=_THEME_QUERY_TIMEOUT_S,
             )
             if p.returncode == 0 and "-dark" in p.stdout.lower():
                 return "dark"