MoleditPy 3.3.1__tar.gz → 3.4.0__tar.gz

{moleditpy-3.3.1 → moleditpy-3.4.0}/PKG-INFO

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

{moleditpy-3.3.1 → moleditpy-3.4.0}/pyproject.toml

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

{moleditpy-3.3.1 → moleditpy-3.4.0}/src/MoleditPy.egg-info/PKG-INFO

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

{moleditpy-3.3.1 → moleditpy-3.4.0}/src/moleditpy/__init__.py

@@ -19,4 +19,4 @@ try:
 except ImportError:
     OBABEL_AVAILABLE = False
 
-from .utils.constants import VERSION as __version__
+from .utils.constants import VERSION as __version__  # noqa: F401

{moleditpy-3.3.1 → moleditpy-3.4.0}/src/moleditpy/main.py

@@ -68,7 +68,8 @@ def main() -> None:
         ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(myappid)
 
     parser = argparse.ArgumentParser(
-        prog="moleditpy", description="MoleditPy molecular editor"
+        prog="moleditpy",
+        description="MoleditPy — A Python-based molecular editing software",
     )
     parser.add_argument("file", nargs="?", default=None, help="File to open on startup")
     _variant = " (Linux)" if "moleditpy_linux" in (__file__ or "") else ""

{moleditpy-3.3.1 → moleditpy-3.4.0}/src/moleditpy/ui/angle_dialog.py

@@ -189,8 +189,10 @@ class AngleDialog(GeometryBaseDialog):
                 self.atom2_idx = atom_idx
             elif self.atom3_idx is None:
                 self.atom3_idx = atom_idx
-                # Take a fresh snapshot immediately upon completing the triad selection
-                self._snapshot_positions = self.mol.GetConformer().GetPositions().copy()
+                # Capture the ABSOLUTE baseline for this selection session.
+                # This prevents 'direction change' drift during multiple slider drags.
+                self._baseline_positions = self.mol.GetConformer().GetPositions().copy()
+                self._snapshot_positions = self._baseline_positions.copy()
             else:
                 # Reset and start over
                 self.atom1_idx = atom_idx
@@ -205,6 +207,7 @@ class AngleDialog(GeometryBaseDialog):
         self.atom1_idx = None
         self.atom2_idx = None  # vertex atom
         self.atom3_idx = None
+        self._baseline_positions = None
         self._snapshot_positions = None
         self.clear_selection_labels()
         self.update_display()
@@ -212,7 +215,7 @@ class AngleDialog(GeometryBaseDialog):
     def show_atom_labels(self) -> None:
         """Display labels on the selected atoms."""
         selected_atoms = [self.atom1_idx, self.atom2_idx, self.atom3_idx]
-        labels = ["1st", "2nd (vertex)", "3rd"]
+        labels = ["1", "2", "3"]
         pairs = [
             (idx, labels[i]) for i, idx in enumerate(selected_atoms) if idx is not None
         ]
@@ -271,7 +274,7 @@ class AngleDialog(GeometryBaseDialog):
             self._snapshot_positions = None
             # Add labels
             self.add_selection_label(self.atom1_idx, "1")
-            self.add_selection_label(self.atom2_idx, "2(vertex)")
+            self.add_selection_label(self.atom2_idx, "2")
             # Clear angle input while selection is incomplete
             try:
                 self.angle_input.blockSignals(True)
@@ -295,23 +298,35 @@ class AngleDialog(GeometryBaseDialog):
             current_angle = self.calculate_angle()
             self.angle_label.setText(f"Current angle: {current_angle:.2f}°")
             self.apply_button.setEnabled(True)
-            # Update angle input box with current angle
+            # Update angle input box and slider
             try:
-                self.angle_input.blockSignals(True)
-                self.angle_input.setText(f"{current_angle:.2f}")
-                self.angle_input.blockSignals(False)
-                self.angle_slider.blockSignals(True)
-                slider_val = int(round(current_angle))
-                slider_val = max(-180, min(180, slider_val))
-                self.angle_slider.setValue(slider_val)
-                self.angle_slider.setEnabled(True)
-                self.angle_slider.blockSignals(False)
+                # Update input box and slider only if not dragging
+                if not self._slider_dragging:
+                    self.angle_input.blockSignals(True)
+                    self.angle_input.setText(f"{current_angle:.2f}")
+                    self.angle_input.blockSignals(False)
+
+                    # UPDATE SLIDER: Logic to prevent 'jumping' to positive value
+                    slider_val = int(round(current_angle))
+                    current_slider_val = self.angle_slider.value()
+
+                    # If the user is on the negative side of the slider, keep the sign
+                    if current_slider_val < 0:
+                        slider_val = -slider_val
+
+                    if current_slider_val != slider_val:
+                        self.angle_slider.blockSignals(True)
+                        self.angle_slider.setValue(slider_val)
+                        self.angle_slider.blockSignals(False)
+                    self.angle_slider.setEnabled(True)
+                else:
+                    self.angle_slider.setEnabled(True)
             except (AttributeError, RuntimeError, TypeError):
                 pass
 
             # Add labels
             self.add_selection_label(self.atom1_idx, "1")
-            self.add_selection_label(self.atom2_idx, "2(vertex)")
+            self.add_selection_label(self.atom2_idx, "2")
             self.add_selection_label(self.atom3_idx, "3")
 
     def calculate_angle(self) -> float:
@@ -366,10 +381,14 @@ class AngleDialog(GeometryBaseDialog):
         """Adjust the bond angle."""
         conf = self.mol.GetConformer()
 
-        # Use snapshot if available (slider dragging) to keep the rotation axis stable
-        snapshot = self._snapshot_positions
-        if snapshot is not None:
-            positions = snapshot.copy()
+        # Use baseline positions (fixed for dialog session) to keep the rotation axis stable.
+        if (
+            hasattr(self, "_baseline_positions")
+            and self._baseline_positions is not None
+        ):
+            positions = self._baseline_positions.copy()
+        elif self._snapshot_positions is not None:
+            positions = self._snapshot_positions.copy()
         else:
             positions = conf.GetPositions()
 
@@ -379,10 +398,16 @@ class AngleDialog(GeometryBaseDialog):
         idx_b: int = self.atom2_idx  # vertex
         idx_c: int = self.atom3_idx
 
+        # Calculate baseline angle from the POSITIONS we are working on (important for snapshot stability)
+        p_a, p_b, p_c = positions[idx_a], positions[idx_b], positions[idx_c]
+        from moleditpy.core.mol_geometry import calc_angle_deg
+
+        baseline_angle = calc_angle_deg(p_a, p_b, p_c)
+
         if self.both_groups_radio.isChecked():
             # Both arms rotate equally (half angle each)
-            current_angle = self.calculate_angle()
-            half_delta_deg = (new_angle_deg - current_angle) / 2.0
+            # Use baseline_angle from snapshot to avoid drift/jumps
+            half_delta_deg = (new_angle_deg - baseline_angle) / 2.0
 
             group1 = get_connected_group(self.mol, idx_a, exclude=idx_b)
             group3 = get_connected_group(self.mol, idx_c, exclude=idx_b)
@@ -393,7 +418,7 @@ class AngleDialog(GeometryBaseDialog):
                 idx_c,
                 idx_b,
                 idx_a,
-                current_angle + half_delta_deg,
+                baseline_angle + half_delta_deg,
                 group1,
             )
             # Arm 3 rotates to the FINAL angle (relative to the now-moved Arm 1)

{moleditpy-3.3.1 → moleditpy-3.4.0}/src/moleditpy/ui/app_state.py

@@ -17,7 +17,8 @@ import binascii
 import copy
 import logging
 import os
-from typing import Any, Dict, Optional, Tuple, TYPE_CHECKING
+from typing import Any, Dict, Optional, Tuple
+
 
 import numpy as np
 
@@ -45,9 +46,6 @@ try:
 except (AttributeError, RuntimeError, TypeError, ImportError):
     from moleditpy.core.molecular_data import MolecularData
 
-if TYPE_CHECKING:
-    from .main_window import MainWindow
-
 
 # --- Class Definition ---
 class StateManager:
@@ -634,7 +632,7 @@ class StateManager:
             method = json_data.get("last_successful_optimization_method", None)
             if hasattr(self.host, "compute_manager"):
                 self.host.compute_manager.last_successful_optimization_method = method
-            else:  # [REPORT ERROR MISSING ATTRIBUTE]
+            else:
                 logging.error(
                     "REPORT ERROR: Missing attribute 'compute_manager' on self.host"
                 )
@@ -808,7 +806,7 @@ class StateManager:
                                         "update_atom_id_menu_text",
                                     ):
                                         self.host.view_3d_manager.update_atom_id_menu_text()
-                                    else:  # [REPORT ERROR MISSING ATTRIBUTE]
+                                    else:
                                         logging.error(
                                             "REPORT ERROR: Missing attribute 'update_atom_id_menu_text' on object"
                                         )
@@ -817,13 +815,13 @@ class StateManager:
                                         "update_atom_id_menu_state",
                                     ):
                                         self.host.view_3d_manager.update_atom_id_menu_state()
-                                    else:  # [REPORT ERROR MISSING ATTRIBUTE]
+                                    else:
                                         logging.error(
                                             "REPORT ERROR: Missing attribute 'update_atom_id_menu_state' on object"
                                         )
                                 except (RuntimeError, TypeError, AttributeError):
                                     pass
-                            else:  # [REPORT ERROR MISSING ATTRIBUTE]
+                            else:
                                 logging.error(
                                     "REPORT ERROR: Missing attribute 'create_atom_id_mapping' on object"
                                 )
@@ -833,7 +831,7 @@ class StateManager:
                             self.host.view_3d_manager.draw_molecule_3d(
                                 self.host.view_3d_manager.current_mol
                             )
-                        else:  # [REPORT ERROR MISSING ATTRIBUTE]
+                        else:
                             logging.error(
                                 "REPORT ERROR: Missing attribute 'draw_molecule_3d' on object"
                             )

{moleditpy-3.3.1 → moleditpy-3.4.0}/src/moleditpy/ui/atom_item.py

@@ -11,7 +11,7 @@ DOI: 10.5281/zenodo.17268532
 """
 
 from __future__ import annotations
-import logging  # [REPORT ERROR MISSING ATTRIBUTE]
+import logging
 from typing import Any, List, Optional
 
 from PyQt6.QtCore import QPointF, QRectF, Qt
@@ -92,7 +92,7 @@ class AtomItem(QGraphicsItem):
             if hasattr(scene, "get_setting"):
                 font_size = scene.get_setting("atom_font_size_2d", 20)
                 font_family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
-            else:  # [REPORT ERROR MISSING ATTRIBUTE]
+            else:
                 logging.error(
                     f"REPORT ERROR: Missing attribute 'get_setting' on scene of type {type(scene)}"
                 )
@@ -119,7 +119,7 @@ class AtomItem(QGraphicsItem):
             if hasattr(scene, "get_setting"):
                 font_size = scene.get_setting("atom_font_size_2d", 20)
                 font_family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
-            else:  # [REPORT ERROR MISSING ATTRIBUTE]
+            else:
                 logging.error(
                     f"REPORT ERROR: Missing attribute 'get_setting' on scene of type {type(scene)}"
                 )
@@ -225,6 +225,77 @@ class AtomItem(QGraphicsItem):
         # 3. Add final margins for selection highlights, etc.
         return full_visual_rect.adjusted(-3, -3, 3, 3)
 
+    def get_bg_ellipse_path(self) -> QPainterPath:
+        path = QPainterPath()
+        if not self.is_visible:
+            return path
+
+        font_size = 20
+        font_family = FONT_FAMILY
+        scene = self.scene()
+        if scene is not None:
+            if hasattr(scene, "get_setting"):
+                font_size = scene.get_setting("atom_font_size_2d", 20)
+                font_family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
+
+        font = QFont(font_family, font_size, FONT_WEIGHT_BOLD)
+        fm = QFontMetricsF(font)
+
+        hydrogen_part = ""
+        if self.implicit_h_count > 0:
+            is_skeletal_carbon = (
+                self.symbol == "C"
+                and self.charge == 0
+                and self.radical == 0
+                and len(self.bonds) > 0
+            )
+            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)
+
+        flip_text = False
+        if hydrogen_part and self.bonds:
+            my_pos_x = self.pos().x()
+            total_dx = 0.0
+            for b in self.bonds:
+                partner = b.atom2 if b.atom1 is self else b.atom1
+                try:
+                    if partner is None or sip_isdeleted_safe(partner):
+                        continue
+                    partner_pos = partner.pos()
+                    if partner_pos is None:
+                        continue
+                    total_dx += partner_pos.x() - my_pos_x
+                except (AttributeError, RuntimeError, TypeError, ValueError):
+                    # Suppress non-critical UI sync errors during atom position retrieval
+                    continue
+            if total_dx > 0:
+                flip_text = True
+
+        if flip_text:
+            display_text = hydrogen_part + self.symbol
+        else:
+            display_text = self.symbol + hydrogen_part
+
+        text_rect = fm.boundingRect(display_text)
+        text_rect.adjust(-2, -2, 2, 2)
+        if hydrogen_part:
+            symbol_rect = fm.boundingRect(self.symbol)
+            if flip_text:
+                offset_x = symbol_rect.width() // 2
+                text_rect.moveTo(offset_x - text_rect.width(), -text_rect.height() / 2)
+            else:
+                offset_x = -symbol_rect.width() // 2
+                text_rect.moveTo(offset_x, -text_rect.height() / 2)
+        else:
+            text_rect.moveCenter(QPointF(0, 0))
+
+        bg_rect = text_rect.adjusted(-5, -8, 5, 8)
+        path.addEllipse(bg_rect)
+        return path
+
     def shape(self) -> QPainterPath:
         """Define the shape of the atom item for collision detection."""
         scene = self.scene()
@@ -360,29 +431,6 @@ class AtomItem(QGraphicsItem):
                 offset_x = -symbol_rect.width() // 2
                 text_rect.moveTo(offset_x, -text_rect.height() // 2)
 
-            # 2. Handle background (fill with white or clear if transparent)
-            if self.scene():
-                bg_brush = self.scene().backgroundBrush()
-                bg_rect = text_rect.adjusted(-5, -8, 5, 8)
-
-                if bg_brush.style() == Qt.BrushStyle.NoBrush:
-                    # Use CompositionMode_Clear to erase overlapping bond lines
-                    painter.save()
-                    painter.setCompositionMode(
-                        QPainter.CompositionMode.CompositionMode_Clear
-                    )
-                    painter.setBrush(
-                        QColor(0, 0, 0, 255)
-                    )  # Color doesn't matter (alpha is key)
-                    painter.setPen(Qt.PenStyle.NoPen)
-                    painter.drawEllipse(bg_rect)
-                    painter.restore()
-                else:
-                    # Fill with background color if it exists
-                    painter.setBrush(bg_brush)
-                    painter.setPen(Qt.PenStyle.NoPen)
-                    painter.drawEllipse(bg_rect)
-
             # 3. Draw the atom symbol itself
             # Color is already determined above
             painter.setPen(QPen(color))
@@ -454,7 +502,9 @@ class AtomItem(QGraphicsItem):
                 for bond in self.bonds:
                     if bond.scene():
                         bond.update_position()
-
+        elif change == QGraphicsItem.GraphicsItemChange.ItemSceneHasChanged:
+            if self.scene() is not None:
+                self.update_style()
         return res
 
     def hoverEnterEvent(self, event: Any) -> None:

{moleditpy-3.3.1 → moleditpy-3.4.0}/src/moleditpy/ui/base_picking_dialog.py

@@ -14,7 +14,7 @@ import logging
 from typing import TYPE_CHECKING, Optional, Union
 
 import numpy as np
-from PyQt6.QtCore import Qt
+from PyQt6.QtCore import Qt, QTimer
 from PyQt6.QtGui import QCloseEvent, QKeyEvent
 from PyQt6.QtWidgets import QDialog, QWidget
 from rdkit import Chem, Geometry
@@ -114,14 +114,28 @@ class BasePickingDialog(Dialog3DPickingMixin, QDialog):
             # If for some reason the cache is incompatible, draw_molecule_3d below will rebuild it
             pass
 
-        # 3. Redraw
+        # 3. Redraw molecule
         self.main_window.view_3d_manager.draw_molecule_3d(self.mol)
         self._molecule_modified = True
 
-        # 4. Refresh chiral/cis-trans labels if applicable
+        # 4. Refresh display (deferred to ensure stability)
+        is_dragging = getattr(self, "_slider_dragging", False)
+
+        if is_dragging and hasattr(self, "show_atom_labels"):
+            QTimer.singleShot(200, self.show_atom_labels)
+        elif hasattr(self, "update_display"):
+            QTimer.singleShot(200, self.update_display)
+
+        if (
+            hasattr(self.main_window.view_3d_manager, "plotter")
+            and self.main_window.view_3d_manager.plotter
+        ):
+            QTimer.singleShot(200, self.main_window.view_3d_manager.plotter.render)
+
+        # 5. Refresh chiral/cis-trans labels if applicable
         if hasattr(self.main_window.view_3d_manager, "update_chiral_labels"):
             self.main_window.view_3d_manager.update_chiral_labels()
-        else:  # [REPORT ERROR MISSING ATTRIBUTE]
+        else:
             logging.error(
                 "REPORT ERROR: Missing attribute 'update_chiral_labels' on object"
             )
@@ -131,7 +145,7 @@ class BasePickingDialog(Dialog3DPickingMixin, QDialog):
         if hasattr(self.main_window, "state_manager"):
             self.main_window.edit_actions_manager.push_undo_state()
             self._molecule_modified = False
-        else:  # [REPORT ERROR MISSING ATTRIBUTE]
+        else:
             logging.error(
                 "REPORT ERROR: Missing attribute 'state_manager' on self.main_window"
             )

{moleditpy-3.3.1 → moleditpy-3.4.0}/src/moleditpy/ui/bond_item.py

@@ -11,7 +11,7 @@ DOI: 10.5281/zenodo.17268532
 """
 
 from __future__ import annotations
-import logging  # [REPORT ERROR MISSING ATTRIBUTE]
+import logging
 from typing import Any, Optional, Tuple, Union
 
 from PyQt6.QtCore import QLineF, QPointF, QRectF, Qt
@@ -138,7 +138,48 @@ class BondItem(QGraphicsItem):
             # This is robust and efficient.
             p1 = self.atom1.pos()
             p2 = self.atom2.pos()
-            return QLineF(QPointF(0, 0), p2 - p1)
+            line = QLineF(QPointF(0, 0), p2 - p1)
+
+            if line.length() == 0:
+                return line
+
+            # Shorten from atom1 side
+            t1 = 0.0
+            if getattr(self.atom1, "is_visible", True) and hasattr(
+                self.atom1, "get_bg_ellipse_path"
+            ):
+                path1 = self.atom1.get_bg_ellipse_path()
+                if not path1.isEmpty():
+                    low, high = 0.0, 1.0
+                    for _ in range(12):
+                        mid = (low + high) / 2
+                        if path1.contains(line.pointAt(mid)):
+                            low = mid
+                        else:
+                            high = mid
+                    t1 = low
+
+            # Shorten from atom2 side
+            t2 = 1.0
+            if getattr(self.atom2, "is_visible", True) and hasattr(
+                self.atom2, "get_bg_ellipse_path"
+            ):
+                path2 = self.atom2.get_bg_ellipse_path()
+                if not path2.isEmpty():
+                    line2 = QLineF(QPointF(0, 0), p1 - p2)
+                    low, high = 0.0, 1.0
+                    for _ in range(12):
+                        mid = (low + high) / 2
+                        if path2.contains(line2.pointAt(mid)):
+                            low = mid
+                        else:
+                            high = mid
+                    t2 = 1.0 - low
+
+            if t1 < t2:
+                return QLineF(line.pointAt(t1), line.pointAt(t2))
+            else:
+                return QLineF(line.center(), line.center())
         except (AttributeError, RuntimeError, ValueError, TypeError):
             # Fallback for inconsistent/deleted atom references
             # return zero line to prevent downstream crashes.
@@ -164,7 +205,7 @@ class BondItem(QGraphicsItem):
                 )
                 bond_offset = scene.get_setting(key, 3.5)
                 wedge_width = scene.get_setting("bond_wedge_width_2d", 6.0)
-            else:  # [REPORT ERROR MISSING ATTRIBUTE]
+            else:
                 logging.error(
                     f"REPORT ERROR: Missing attribute 'get_setting' on scene of type {type(scene)}"
                 )
@@ -184,7 +225,7 @@ class BondItem(QGraphicsItem):
                 if hasattr(scene, "get_setting"):
                     font_size = scene.get_setting("atom_font_size_2d", 20)
                     font_family = scene.get_setting("atom_font_family_2d", FONT_FAMILY)
-                else:  # [REPORT ERROR MISSING ATTRIBUTE]
+                else:
                     logging.error(
                         f"REPORT ERROR: Missing attribute 'get_setting' on scene of type {type(scene)}"
                     )
@@ -298,7 +339,7 @@ class BondItem(QGraphicsItem):
                     pen.setCapStyle(cap_style)
                     painter.setPen(pen)
                     painter.setBrush(QBrush(bond_color))
-                else:  # [REPORT ERROR MISSING ATTRIBUTE]
+                else:
                     logging.error(
                         f"REPORT ERROR: Missing attribute 'get_setting' on scene of type {type(scene)}"
                     )
@@ -310,16 +351,48 @@ class BondItem(QGraphicsItem):
             wedge_width_half = 6.0
             num_dashes = 8
 
+        painter.save()
+
         # --- Draw Stereochemistry (Wedge/Dash) ---
         if self.order == 1 and self.stereo in [1, 2]:
-            vec = line.unitVector()
+            try:
+                orig_line = QLineF(QPointF(0, 0), self.atom2.pos() - self.atom1.pos())
+                orig_len = orig_line.length()
+                if orig_len > 0:
+                    d1 = QLineF(orig_line.p1(), line.p1()).length()
+                    t1 = max(d1, 5.0) / orig_len
+                    d2 = QLineF(orig_line.p1(), line.p2()).length()
+                    t2 = min(d2, orig_len - 5.0) / orig_len
+                    if t1 > t2:
+                        t1, t2 = 0.5, 0.5
+                else:
+                    t1, t2 = 0.0, 1.0
+            except (AttributeError, TypeError, ValueError):
+                orig_line = line
+                orig_len = line.length()
+                t1, t2 = 0.0, 1.0
+
+            vec = orig_line.unitVector()
             normal = vec.normalVector()
-            p1 = line.p1() + vec.p2() * 5
-            p2 = line.p2() - vec.p2() * 5
 
             if self.stereo == 1:  # Wedge
-                offset = QPointF(normal.dx(), normal.dy()) * wedge_width_half
-                poly = QPolygonF([p1, p2 + offset, p2 - offset])
+                p_start = orig_line.pointAt(t1)
+                p_end = orig_line.pointAt(t2)
+
+                width_start = wedge_width_half * t1
+                width_end = wedge_width_half * t2
+
+                offset_start = QPointF(normal.dx(), normal.dy()) * width_start
+                offset_end = QPointF(normal.dx(), normal.dy()) * width_end
+
+                poly = QPolygonF(
+                    [
+                        p_start - offset_start,
+                        p_start + offset_start,
+                        p_end + offset_end,
+                        p_end - offset_end,
+                    ]
+                )
                 painter.drawPolygon(poly)
 
             elif self.stereo == 2:  # Dash
@@ -329,13 +402,15 @@ class BondItem(QGraphicsItem):
                     pen.setWidthF(2.5)
                     painter.setPen(pen)
 
-                # Use configured number of dashes (default 8)
+                # Draw dashes evenly spaced along the original length,
+                # but only draw the ones that fall within the visible shortened segment.
                 for i in range(num_dashes + 1):
                     t = i / num_dashes
-                    start_pt = p1 * (1 - t) + p2 * t
-                    width = (wedge_width_half * 2.0) * t
-                    offset = QPointF(normal.dx(), normal.dy()) * width / 2.0
-                    painter.drawLine(start_pt - offset, start_pt + offset)
+                    if t1 <= t <= t2:
+                        start_pt = orig_line.pointAt(t)
+                        width = wedge_width_half * t
+                        offset = QPointF(normal.dx(), normal.dy()) * width
+                        painter.drawLine(start_pt - offset, start_pt + offset)
                 painter.restore()
 
         # --- Draw Regular Bonds (Single/Double/Triple) ---
@@ -355,7 +430,7 @@ class BondItem(QGraphicsItem):
                             else "bond_spacing_double_2d"
                         )
                         bond_offset = scene.get_setting(key, 3.5)
-                    else:  # [REPORT ERROR MISSING ATTRIBUTE]
+                    else:
                         logging.error(
                             f"REPORT ERROR: Missing attribute 'get_setting' on scene of type {type(scene)}"
                         )
@@ -495,6 +570,8 @@ class BondItem(QGraphicsItem):
                 # If highlight fails, it's just a visual artifact.
                 pass
 
+        painter.restore()
+
     def update_position(self, notify: bool = True) -> None:
         try:
             if notify: