MoleditPy 2.3.3__py3-none-any.whl → 2.4.1__py3-none-any.whl

moleditpy/modules/atom_item.py

@@ -13,7 +13,7 @@ DOI: 10.5281/zenodo.17268532
 from PyQt6.QtWidgets import QGraphicsItem
 
 from PyQt6.QtGui import (
-    QPen, QBrush, QColor, QFont, QPainterPath, QFontMetricsF
+    QPen, QBrush, QColor, QFont, QPainterPath, QFontMetricsF, QPainter
 )
 
 from PyQt6.QtCore import (
@@ -45,14 +45,41 @@ class AtomItem(QGraphicsItem):
         self.setPos(pos)
         self.implicit_h_count = 0 
         self.setFlags(QGraphicsItem.GraphicsItemFlag.ItemIsMovable | QGraphicsItem.GraphicsItemFlag.ItemIsSelectable)
-        self.setZValue(1); self.font = QFont(FONT_FAMILY, FONT_SIZE_LARGE, FONT_WEIGHT_BOLD); self.update_style()
+        self.setZValue(1)
+        self.update_style()
         self.setAcceptHoverEvents(True)
         self.hovered = False
         self.has_problem = False 
 
+
+    def update_style(self):
+        # Allow updating font preference dynamically
+        font_size = 20
+        try:
+            if self.scene() and self.scene().views():
+                win = self.scene().views()[0].window()
+                if win and hasattr(win, 'settings'):
+                    font_size = win.settings.get('atom_font_size_2d', 20)
+        except Exception:
+            pass
+        self.font = QFont(FONT_FAMILY, font_size, FONT_WEIGHT_BOLD)
+        self.prepareGeometryChange()
+        
+        self.is_visible = not (self.symbol == 'C' and len(self.bonds) > 0 and self.charge == 0 and self.radical == 0)
+        self.update()
+
     def boundingRect(self):
         # --- paint()メソッドと完全に同じロジックでテキストの位置とサイズを計算 ---
-        font = QFont(FONT_FAMILY, FONT_SIZE_LARGE, FONT_WEIGHT_BOLD)
+        # Get dynamic font size
+        font_size = 20
+        try:
+            if self.scene() and self.scene().views():
+                win = self.scene().views()[0].window()
+                if win and hasattr(win, 'settings'):
+                    font_size = win.settings.get('atom_font_size_2d', 20)
+        except Exception:
+            pass
+        font = QFont(FONT_FAMILY, font_size, FONT_WEIGHT_BOLD)
         fm = QFontMetricsF(font)
 
         hydrogen_part = ""
@@ -164,9 +191,21 @@ class AtomItem(QGraphicsItem):
         return path
 
     def paint(self, painter, option, widget):
+        # Color logic: check if we should use bond color (uniform) or CPK (element-specific)
         color = CPK_COLORS.get(self.symbol, CPK_COLORS['DEFAULT'])
+        try:
+            if self.scene() and self.scene().views():
+                win = self.scene().views()[0].window()
+                if win and hasattr(win, 'settings'):
+                    if win.settings.get('atom_use_bond_color_2d', False):
+                        bond_col = win.settings.get('bond_color_2d', '#222222')
+                        color = QColor(bond_col)
+        except Exception:
+            pass
+
         if self.is_visible:
             # 1. 描画の準備
+            # Ensure correct font is used (self.font should be updated by update_style)
             painter.setFont(self.font)
             fm = painter.fontMetrics()
 
@@ -253,19 +292,29 @@ class AtomItem(QGraphicsItem):
                 offset_x = -symbol_rect.width() // 2
                 text_rect.moveTo(offset_x, -text_rect.height() // 2)
 
-            # 2. 原子記号の背景を白で塗りつぶす
+            # 2. 原子記号の背景を処理（白で塗りつぶす か 透明なら切り抜く）
             if self.scene():
                 bg_brush = self.scene().backgroundBrush()
                 bg_rect = text_rect.adjusted(-5, -8, 5, 8)
-                painter.setBrush(bg_brush)
-                painter.setPen(Qt.PenStyle.NoPen)
-                painter.drawEllipse(bg_rect)
+                
+                if bg_brush.style() == Qt.BrushStyle.NoBrush:
+                    # 背景が透明の場合は、CompositionMode_Clearを使って
+                    # 重なっている結合の線を「消しゴム」のように消す
+                    painter.save()
+                    painter.setCompositionMode(QPainter.CompositionMode.CompositionMode_Clear)
+                    painter.setBrush(QColor(0, 0, 0, 255)) # 色は何でも良い（アルファが重要）
+                    painter.setPen(Qt.PenStyle.NoPen)
+                    painter.drawEllipse(bg_rect)
+                    painter.restore()
+                else:
+                    # 背景がある場合は、その背景色で塗りつぶす（従来通り）
+                    painter.setBrush(bg_brush)
+                    painter.setPen(Qt.PenStyle.NoPen)
+                    painter.drawEllipse(bg_rect)
             
             # 3. 原子記号自体を描画
-            if self.symbol == 'H':
-                painter.setPen(QPen(Qt.GlobalColor.black))
-            else:
-                painter.setPen(QPen(color))
+            # Color is already determined above
+            painter.setPen(QPen(color))
             painter.drawText(text_rect, int(alignment_flag), display_text)
             
             # --- 電荷とラジカルの描画  ---
@@ -316,9 +365,7 @@ class AtomItem(QGraphicsItem):
             painter.setPen(pen)
             painter.drawRect(self.boundingRect())
 
-    def update_style(self):
-        self.is_visible = not (self.symbol == 'C' and len(self.bonds) > 0 and self.charge == 0 and self.radical == 0)
-        self.update()
+
 
 
     # 約203行目 AtomItem クラス内

moleditpy/modules/bond_item.py

@@ -105,7 +105,21 @@ class BondItem(QGraphicsItem):
             line = self.get_line_in_local_coords()
         except Exception:
             line = QLineF(0, 0, 0, 0)
-        bond_offset = globals().get('BOND_OFFSET', 2)
+        
+        # Get dynamic bond offset (spacing)
+        bond_offset = 3.5
+        try:
+            if self.scene() and hasattr(self.scene(), 'views') and self.scene().views():
+                win = self.scene().views()[0].window()
+                if win and hasattr(win, 'settings'):
+                    # Use specific spacing based on bond order
+                    if getattr(self, 'order', 1) == 3:
+                        bond_offset = win.settings.get('bond_spacing_triple_2d', 3.5)
+                    else:
+                        bond_offset = win.settings.get('bond_spacing_double_2d', 3.5)
+        except Exception:
+             bond_offset = globals().get('BOND_OFFSET', 3.5)
+
         extra = (getattr(self, 'order', 1) - 1) * bond_offset + 20
         rect = QRectF(line.p1(), line.p2()).normalized().adjusted(-extra, -extra, extra, extra)
 
@@ -142,7 +156,18 @@ class BondItem(QGraphicsItem):
         view = scene.views()[0]
         scale = view.transform().m11()
 
-        scene_width = DESIRED_BOND_PIXEL_WIDTH / scale
+        # Dynamic bond width
+        width_2d = 2.0
+        try:
+            if view.window() and hasattr(view.window(), 'settings'):
+                width_2d = view.window().settings.get('bond_width_2d', 2.0)
+        except Exception:
+            pass
+
+        # Hit area should be roughly closely matched or slightly larger than visual
+        # Ensure minimum hit width for usability
+        scene_width = max(DESIRED_BOND_PIXEL_WIDTH, width_2d * 10) / scale
+
 
         stroker = QPainterPathStroker()
         stroker.setWidth(scene_width)
@@ -160,24 +185,44 @@ class BondItem(QGraphicsItem):
         line = self.get_line_in_local_coords()
         if line.length() == 0: return
 
-        # --- 1. 選択状態に応じてペンとブラシを準備 ---
-        if self.isSelected():
-            selection_color = QColor("blue")
-            painter.setPen(QPen(selection_color, 3))
-            painter.setBrush(QBrush(selection_color))
-        else:
-            # Allow bond color override from app settings (2D color)
-            try:
-                sc = self.scene()
-                if sc is not None and hasattr(sc, 'window') and sc.window is not None:
-                    bond_hex = sc.window.settings.get('bond_color', '#222222')
-                    bond_color = QColor(bond_hex)
-                    painter.setPen(QPen(bond_color, 2))
+        # Allow bond color override from app settings (2D color)
+        width_2d = 2.0
+        
+        try:
+            sc = self.scene()
+            if sc is not None and hasattr(sc, 'window') and sc.window is not None:
+                # Get settings
+                settings = sc.window.settings
+                
+                # Width
+                width_2d = settings.get('bond_width_2d', 2.0)
+                
+                # Cap Style logic
+                cap_style_str = settings.get('bond_cap_style_2d', 'Round')
+                cap_style = Qt.PenCapStyle.RoundCap # Default
+                
+                if cap_style_str == 'Flat':
+                    cap_style = Qt.PenCapStyle.FlatCap
+                elif cap_style_str == 'Square':
+                    cap_style = Qt.PenCapStyle.SquareCap
+                
+                # Color
+                if self.isSelected():
+                    bond_color = QColor("blue") # Selection color
                 else:
-                    painter.setPen(self.pen)
-            except Exception:
+                    bond_hex = settings.get('bond_color_2d', '#222222')
+                    bond_color = QColor(bond_hex)
+                
+                pen = QPen(bond_color, width_2d)
+                pen.setCapStyle(cap_style)
+                painter.setPen(pen)
+                
+            else:
                 painter.setPen(self.pen)
-            painter.setBrush(QBrush(Qt.GlobalColor.black))
+        except Exception:
+            painter.setPen(self.pen)
+            
+        painter.setBrush(QBrush(Qt.GlobalColor.black))
 
         # --- 立体化学 (Wedge/Dash) の描画 ---
         if self.order == 1 and self.stereo in [1, 2]:
@@ -213,7 +258,19 @@ class BondItem(QGraphicsItem):
                 painter.drawLine(line)
             else:
                 v = line.unitVector().normalVector()
-                offset = QPointF(v.dx(), v.dy()) * BOND_OFFSET
+                # Use dynamic offset
+                bond_offset = 3.5
+                try:
+                    sc = self.scene()
+                    if sc and sc.views() and hasattr(sc.views()[0].window(), 'settings'):
+                        if self.order == 3:
+                            bond_offset = sc.views()[0].window().settings.get('bond_spacing_triple_2d', 3.5)
+                        else:
+                            bond_offset = sc.views()[0].window().settings.get('bond_spacing_double_2d', 3.5)
+                except Exception:
+                    bond_offset = globals().get('BOND_OFFSET', 3.5)
+                
+                offset = QPointF(v.dx(), v.dy()) * bond_offset
 
                 if self.order == 2:
                     # 環構造かどうかを判定し、描画方法を変更
@@ -274,7 +331,8 @@ class BondItem(QGraphicsItem):
                         is_in_ring = False
                     
                     v = line.unitVector().normalVector()
-                    offset = QPointF(v.dx(), v.dy()) * BOND_OFFSET
+                    # Re-calculate offset in case loop variable scope issue, though strictly not needed if offset defined above works
+                    offset = QPointF(v.dx(), v.dy()) * bond_offset
                     
                     if is_in_ring and ring_center:
                         # 環構造: 1本の中心線（単結合位置） + 1本の短い内側線

moleditpy/modules/constants.py

@@ -16,7 +16,7 @@ from PyQt6.QtGui import QFont, QColor
 from rdkit import Chem
 
 #Version
-VERSION = '2.3.3'
+VERSION = '2.4.1'
 
 ATOM_RADIUS = 18
 BOND_OFFSET = 3.5

moleditpy/modules/main_window.py

@@ -500,6 +500,10 @@ class MainWindow(QMainWindow):
         # --- MOVED TO main_window_export.py ---
         return self.main_window_export.export_2d_png()
 
+    def export_2d_svg(self):
+        # --- MOVED TO main_window_export.py ---
+        return self.main_window_export.export_2d_svg()
+
     def export_3d_png(self):
         # --- MOVED TO main_window_export.py ---
         return self.main_window_export.export_3d_png()
@@ -524,6 +528,10 @@ class MainWindow(QMainWindow):
         # --- MOVED TO main_window_edit_actions.py ---
         return self.main_window_edit_actions.adjust_molecule_positions_to_avoid_collisions(mol, frags)
 
+    def open_rotate_2d_dialog(self):
+        # --- MOVED TO main_window_edit_actions.py ---
+        return self.main_window_edit_actions.open_rotate_2d_dialog()
+
     def draw_molecule_3d(self, mol):
         # --- MOVED TO main_window_view_3d.py ---
         return self.main_window_view_3d.draw_molecule_3d(mol)

moleditpy/modules/main_window_edit_actions.py

@@ -34,7 +34,7 @@ from rdkit.Chem import AllChem
 
 # PyQt6 Modules
 from PyQt6.QtWidgets import (
-    QApplication
+    QApplication, QDialog, QVBoxLayout, QHBoxLayout, QLabel, QSpinBox, QSlider, QPushButton
 )
 
 from PyQt6.QtGui import (
@@ -43,9 +43,51 @@ from PyQt6.QtGui import (
 
 
 from PyQt6.QtCore import (
-    QPointF, QLineF, QMimeData, QByteArray, QTimer
+    QPointF, QLineF, QMimeData, QByteArray, QTimer, Qt
 )
 
+class Rotate2DDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Rotate 2D")
+        self.setFixedWidth(300)
+        
+        layout = QVBoxLayout(self)
+        
+        # Angle input
+        input_layout = QHBoxLayout()
+        input_layout.addWidget(QLabel("Angle (degrees):"))
+        self.angle_spin = QSpinBox()
+        self.angle_spin.setRange(-360, 360)
+        self.angle_spin.setValue(45)
+        input_layout.addWidget(self.angle_spin)
+        layout.addLayout(input_layout)
+        
+        # Slider
+        self.slider = QSlider(Qt.Orientation.Horizontal)
+        self.slider.setRange(-180, 180)
+        self.slider.setValue(45)
+        self.slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        self.slider.setTickInterval(15)
+        layout.addWidget(self.slider)
+
+        # Sync slider and spinbox
+        self.angle_spin.valueChanged.connect(self.slider.setValue)
+        self.slider.valueChanged.connect(self.angle_spin.setValue)
+        
+        # Buttons
+        btn_layout = QHBoxLayout()
+        ok_btn = QPushButton("Rotate")
+        ok_btn.clicked.connect(self.accept)
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        btn_layout.addWidget(ok_btn)
+        btn_layout.addWidget(cancel_btn)
+        layout.addLayout(btn_layout)
+    
+    def get_angle(self):
+        return self.angle_spin.value()
+
 
 # Use centralized Open Babel availability from package-level __init__
 # Use per-package modules availability (local __init__).
@@ -568,6 +610,67 @@ class MainWindowEditActions(object):
 
 
 
+    def open_rotate_2d_dialog(self):
+        """2D回転ダイアログを開く"""
+        dialog = Rotate2DDialog(self)
+        if dialog.exec() == QDialog.DialogCode.Accepted:
+            angle = dialog.get_angle()
+            self.rotate_molecule_2d(angle)
+
+    def rotate_molecule_2d(self, angle_degrees):
+        """2D分子を指定角度回転させる（選択範囲があればそれのみ、なければ全体）"""
+        try:
+            # Determine target atoms
+            selected_items = self.scene.selectedItems()
+            target_atoms = [item for item in selected_items if isinstance(item, AtomItem)]
+            
+            # If no selection, rotate everything
+            if not target_atoms:
+                target_atoms = [data['item'] for data in self.data.atoms.values() if data.get('item') and not sip_isdeleted_safe(data['item'])]
+            
+            if not target_atoms:
+                self.statusBar().showMessage("No atoms to rotate.")
+                return
+
+            # Calculate Center
+            xs = [atom.pos().x() for atom in target_atoms]
+            ys = [atom.pos().y() for atom in target_atoms]
+            if not xs: return
+            
+            center_x = sum(xs) / len(xs)
+            center_y = sum(ys) / len(ys)
+            center = QPointF(center_x, center_y)
+            
+            rad = math.radians(angle_degrees)
+            cos_a = math.cos(rad)
+            sin_a = math.sin(rad)
+            
+            for atom in target_atoms:
+                # Relative pos
+                dx = atom.pos().x() - center_x
+                dy = atom.pos().y() - center_y
+                
+                # Rotate
+                new_dx = dx * cos_a - dy * sin_a
+                new_dy = dx * sin_a + dy * cos_a
+                
+                new_pos = QPointF(center_x + new_dx, center_y + new_dy)
+                atom.setPos(new_pos)
+            
+            # Update bonds
+            self.scene.update_connected_bonds(target_atoms)
+            
+            self.push_undo_state()
+            self.statusBar().showMessage(f"Rotated {len(target_atoms)} atoms by {angle_degrees} degrees.")
+            self.scene.update()
+            
+        except Exception as e:
+            print(f"Error rotating molecule: {e}")
+            traceback.print_exc()
+            self.statusBar().showMessage(f"Error rotating: {e}")
+
+
+
 
     def select_all(self):
         for item in self.scene.items():

moleditpy/modules/main_window_export.py

@@ -37,9 +37,11 @@ from PyQt6.QtGui import (
     QBrush, QColor, QPainter, QImage
 )
 
+from PyQt6.QtSvg import QSvgGenerator
+
 
 from PyQt6.QtCore import (
-    Qt, QRectF
+    Qt, QRectF, QSize
 )
 
 import pyvista as pv
@@ -672,7 +674,7 @@ class MainWindowExport(object):
             filePath += ".png"
 
         reply = QMessageBox.question(self, 'Choose Background',
-                                     'Do you want a transparent background?\n(Choose "No" for a white background)',
+                                     'Do you want a transparent background?\n(Choose "No" to use the current background color)',
                                      QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No | QMessageBox.StandardButton.Cancel,
                                      QMessageBox.StandardButton.Yes)
 
@@ -706,8 +708,7 @@ class MainWindowExport(object):
 
             if is_transparent:
                 self.scene.setBackgroundBrush(QBrush(Qt.BrushStyle.NoBrush))
-            else:
-                self.scene.setBackgroundBrush(QBrush(QColor("#FFFFFF")))
+            # Else: keep original_background (current 2D background)
 
             rect_to_render = molecule_bounds.adjusted(-20, -20, 20, 20)
 
@@ -719,10 +720,8 @@ class MainWindowExport(object):
                 return
 
             image = QImage(w, h, QImage.Format.Format_ARGB32_Premultiplied)
-            if is_transparent:
-                image.fill(Qt.GlobalColor.transparent)
-            else:
-                image.fill(Qt.GlobalColor.white)
+            # Always fill with transparent; render will paint opaque background if present
+            image.fill(Qt.GlobalColor.transparent)
 
             painter = QPainter()
             ok = painter.begin(image)
@@ -756,6 +755,118 @@ class MainWindowExport(object):
 
 
 
+    def export_2d_svg(self):
+        """2D drawingをSVGとしてエクスポート"""
+        if not self.data.atoms:
+            self.statusBar().showMessage("Nothing to export.")
+            return
+
+        # default filename
+        default_name = "untitled-2d"
+        try:
+            if self.current_file_path:
+                base = os.path.basename(self.current_file_path)
+                name = os.path.splitext(base)[0]
+                default_name = f"{name}-2d"
+        except Exception:
+            default_name = "untitled-2d"
+
+        # prefer same directory
+        default_path = default_name
+        try:
+            if self.current_file_path:
+                default_path = os.path.join(os.path.dirname(self.current_file_path), default_name)
+        except Exception:
+            default_path = default_name
+
+        filePath, _ = QFileDialog.getSaveFileName(self, "Export 2D as SVG", default_path, "SVG Files (*.svg)")
+        if not filePath:
+            return
+
+        if not (filePath.lower().endswith(".svg")):
+            filePath += ".svg"
+
+        # Ask about transparency
+        reply = QMessageBox.question(self, 'Choose Background',
+                                     'Do you want a transparent background?\n(Choose "No" to use the current background color)',
+                                     QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No | QMessageBox.StandardButton.Cancel,
+                                     QMessageBox.StandardButton.Yes)
+
+        if reply == QMessageBox.StandardButton.Cancel:
+            self.statusBar().showMessage("Export cancelled.", 2000)
+            return
+
+        is_transparent = (reply == QMessageBox.StandardButton.Yes)
+
+        try:
+            # 1. Hide non-molecular items if needed (optional, keeping consistent with PNG export)
+            items_to_restore = {}
+            original_background = self.scene.backgroundBrush()
+            
+            all_items = list(self.scene.items())
+            for item in all_items:
+                is_mol_part = isinstance(item, (AtomItem, BondItem))
+                if not (is_mol_part and item.isVisible()):
+                    # Keep measurement items visible if they are part of the scene? 
+                    # For now, let's stick to hiding everything that isn't atom/bond,
+                    # similar to png export logic, or we can decide to export everything visible.
+                    # The PNG export hides non-atom/bond items. Let's follow that for consistency.
+                    items_to_restore[item] = item.isVisible()
+                    item.hide()
+
+            # 2. Calculate bounds
+            molecule_bounds = QRectF()
+            for item in self.scene.items():
+                if isinstance(item, (AtomItem, BondItem)) and item.isVisible():
+                    molecule_bounds = molecule_bounds.united(item.sceneBoundingRect())
+
+            if molecule_bounds.isEmpty() or not molecule_bounds.isValid():
+                self.statusBar().showMessage("Error: Could not determine molecule bounds for export.")
+                # Restore
+                for item, was_visible in items_to_restore.items():
+                    item.setVisible(was_visible)
+                return
+
+            if is_transparent:
+                self.scene.setBackgroundBrush(QBrush(Qt.BrushStyle.NoBrush))
+            
+            # Margin
+            rect_to_render = molecule_bounds.adjusted(-20, -20, 20, 20)
+            
+            width = int(rect_to_render.width())
+            height = int(rect_to_render.height())
+
+            # 3. Setup QSvgGenerator
+            generator = QSvgGenerator()
+            generator.setFileName(filePath)
+            generator.setSize(QSize(width, height))
+            generator.setViewBox(rect_to_render)
+            generator.setTitle("MoleditPy Molecule")
+            
+            # 4. Render
+            painter = QPainter()
+            painter.begin(generator)
+            try:
+                self.scene.render(painter, rect_to_render, rect_to_render)
+            finally:
+                painter.end()
+
+            self.statusBar().showMessage(f"2D view exported to {filePath}")
+
+        except Exception as e:
+            self.statusBar().showMessage(f"An unexpected error occurred during SVG export: {e}")
+
+        finally:
+            # Restore
+            for item, was_visible in items_to_restore.items():
+                item.setVisible(was_visible)
+            if 'original_background' in locals():
+                self.scene.setBackgroundBrush(original_background)
+            if self.view_2d:
+                self.view_2d.viewport().update()
+
+
+
     def export_3d_png(self):
         if not self.current_mol:
             self.statusBar().showMessage("No 3D molecule to export.", 2000)

moleditpy/modules/main_window_main_init.py

@@ -372,7 +372,7 @@ class MainWindowMainInit(object):
 
         # --- 左パネルのボタンレイアウト ---
         left_buttons_layout = QHBoxLayout()
-        self.cleanup_button = QPushButton("Optimize 2D")
+        self.cleanup_button = QPushButton("Clean Up 2D")
         self.cleanup_button.clicked.connect(self.clean_up_2d_structure)
         left_buttons_layout.addWidget(self.cleanup_button)
 
@@ -920,6 +920,10 @@ class MainWindowMainInit(object):
         export_2d_png_action = QAction("PNG Image...", self)
         export_2d_png_action.triggered.connect(self.export_2d_png)
         export_2d_menu.addAction(export_2d_png_action)
+
+        export_2d_svg_action = QAction("SVG Image...", self)
+        export_2d_svg_action.triggered.connect(self.export_2d_svg)
+        export_2d_menu.addAction(export_2d_svg_action)
         
         # 3D エクスポート
         export_3d_menu = export_menu.addMenu("3D Formats")
@@ -987,7 +991,13 @@ class MainWindowMainInit(object):
 
         edit_menu.addSeparator()
 
-        optimize_2d_action = QAction("Optimize 2D", self)
+        rotate_2d_action = QAction("Rotate 2D...", self)
+        rotate_2d_action.triggered.connect(self.open_rotate_2d_dialog)
+        edit_menu.addAction(rotate_2d_action)
+
+        edit_menu.addSeparator()
+
+        optimize_2d_action = QAction("Clean Up 2D", self)
         optimize_2d_action.setShortcut(QKeySequence("Ctrl+J"))
         optimize_2d_action.triggered.connect(self.clean_up_2d_structure)
         edit_menu.addAction(optimize_2d_action)
@@ -1247,7 +1257,7 @@ class MainWindowMainInit(object):
 
         settings_menu = menu_bar.addMenu("&Settings")
         # 1) 3D View settings (existing)
-        view_settings_action = QAction("3D View Settings...", self)
+        view_settings_action = QAction("Settings...", self)
         view_settings_action.triggered.connect(self.open_settings_dialog)
         settings_menu.addAction(view_settings_action)
         
@@ -1495,6 +1505,10 @@ class MainWindowMainInit(object):
         
         try:
             if hasattr(self, 'scene') and self.scene:
+                # Apply 2D background color
+                bg_color_2d = self.settings.get('background_color_2d', '#FFFFFF')
+                self.scene.setBackgroundBrush(QBrush(QColor(bg_color_2d)))
+
                 for it in list(self.scene.items()):
                     if hasattr(it, 'update_style'):
                         it.update_style()
@@ -1587,6 +1601,15 @@ class MainWindowMainInit(object):
                 except Exception:
                     pass
                 # Update 2D scene styling to reflect default CPK colors
+                try:
+                    # Reset 2D background specifically
+                    if hasattr(self, 'scene') and self.scene:
+                        bg_c = self.settings.get('background_color_2d', '#FFFFFF')
+                        self.scene.setBackgroundBrush(QBrush(QColor(bg_c)))
+                    
+                    self.update_cpk_colors_from_settings()
+                except Exception:
+                    pass
                 try:
                     if hasattr(self, 'scene') and self.scene:
                         for it in list(self.scene.items()):
@@ -1674,6 +1697,18 @@ class MainWindowMainInit(object):
             # Whether to kekulize aromatic systems for 3D display
             'display_kekule_3d': False,
             'always_ask_charge': False,
+            'display_aromatic_circles_3d': False,
+            'ball_stick_use_cpk_bond_color': False,
+            
+            # --- 2D Settings Defaults ---
+            'bond_width_2d': 2.0,
+            'bond_spacing_double_2d': 3.5,
+            'bond_spacing_triple_2d': 3.5,
+            'atom_font_size_2d': 20,
+            'background_color_2d': '#FFFFFF',
+            'bond_color_2d': '#222222', # Almost black
+            'atom_use_bond_color_2d': False,
+            'bond_cap_style_2d': 'Round',
         }
 
         try:

moleditpy/modules/settings_dialog.py

@@ -26,8 +26,8 @@ except Exception:
 class SettingsDialog(QDialog):
     def __init__(self, current_settings, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("3D View Settings")
-        self.setMinimumSize(500, 600)
+        self.setWindowTitle("Settings")
+        self.setMinimumSize(700, 800)
         
         # 親ウィンドウの参照を保存（Apply機能のため）
         self.parent_window = parent
@@ -89,6 +89,16 @@ class SettingsDialog(QDialog):
             # (shows alternating single/double bonds rather than aromatic circles)
             'display_kekule_3d': False,
             'ball_stick_use_cpk_bond_color': False,
+            
+            # --- 2D Settings Defaults ---
+            'bond_width_2d': 2.0,
+            'bond_spacing_double_2d': 3.5,
+            'bond_spacing_triple_2d': 3.5,
+            'atom_font_size_2d': 20,
+            'background_color_2d': '#FFFFFF',
+            'bond_color_2d': '#222222', # Almost black
+            'atom_use_bond_color_2d': False,
+            'bond_cap_style_2d': 'Round',
         }
         
         # --- 選択された色を管理する専用のインスタンス変数 ---
@@ -101,6 +111,9 @@ class SettingsDialog(QDialog):
         self.tab_widget = QTabWidget()
         layout.addWidget(self.tab_widget)
 
+        # 2D Settings Tab (First)
+        self.create_2d_settings_tab()
+
         # Scene設定タブ
         self.create_scene_tab()
         
@@ -129,6 +142,13 @@ class SettingsDialog(QDialog):
         self.aromatic_torus_thickness_slider.setValue(int(thickness_factor * 100))
         self.aromatic_torus_thickness_label.setText(f"{thickness_factor:.1f}")
 
+        # Initialize internal 2D colors
+        self.current_bg_color_2d = current_settings.get('background_color_2d', self.default_settings['background_color_2d'])
+        self.current_bond_color_2d = current_settings.get('bond_color_2d', self.default_settings['bond_color_2d'])
+        
+        # Apply initial 2D button styles
+        self.update_2d_color_buttons()
+
         # --- ボタンの配置 ---
         buttons = QHBoxLayout()
         
@@ -160,6 +180,121 @@ class SettingsDialog(QDialog):
         buttons.addWidget(ok_button)
         buttons.addWidget(cancel_button)
         layout.addLayout(buttons)
+
+    def create_2d_settings_tab(self):
+        """2D Settings Tab"""
+        widget = QWidget()
+        form_layout = QFormLayout(widget)
+
+        # --- View Settings ---
+        form_layout.addRow(QLabel("<b>View Appearance</b>"))
+        
+        # Background Color
+        self.bg_color_2d_button = QPushButton()
+        self.bg_color_2d_button.setFixedSize(60, 24)
+        self.bg_color_2d_button.clicked.connect(self.pick_bg_color_2d)
+        form_layout.addRow("Background Color:", self.bg_color_2d_button)
+
+        line = QFrame()
+        line.setFrameShape(QFrame.Shape.HLine)
+        line.setFrameShadow(QFrame.Shadow.Sunken)
+        form_layout.addRow(line)
+
+        # --- Bond Settings ---
+        form_layout.addRow(QLabel("<b>Bond Settings</b>"))
+
+        # Bond Color
+        self.bond_color_2d_button = QPushButton()
+        self.bond_color_2d_button.setFixedSize(60, 24)
+        self.bond_color_2d_button.clicked.connect(self.pick_bond_color_2d)
+        form_layout.addRow("Bond Color:", self.bond_color_2d_button)
+
+        # Bond Width
+        self.bond_width_2d_slider = QSlider(Qt.Orientation.Horizontal)
+        self.bond_width_2d_slider.setRange(10, 200) # 1.0 - 20.0
+        self.bond_width_2d_label = QLabel("2.0")
+        self.bond_width_2d_slider.valueChanged.connect(lambda v: self.bond_width_2d_label.setText(f"{v/10:.1f}"))
+        bw_layout = QHBoxLayout()
+        bw_layout.addWidget(self.bond_width_2d_slider)
+        bw_layout.addWidget(self.bond_width_2d_label)
+        form_layout.addRow("Bond Width:", bw_layout)
+
+        # Double Bond Spacing
+        self.bond_spacing_double_2d_slider = QSlider(Qt.Orientation.Horizontal)
+        self.bond_spacing_double_2d_slider.setRange(10, 200) # 1.0 - 20.0
+        self.bond_spacing_double_2d_label = QLabel("3.5")
+        self.bond_spacing_double_2d_slider.valueChanged.connect(lambda v: self.bond_spacing_double_2d_label.setText(f"{v/10:.1f}"))
+        bsd_layout = QHBoxLayout()
+        bsd_layout.addWidget(self.bond_spacing_double_2d_slider)
+        bsd_layout.addWidget(self.bond_spacing_double_2d_label)
+        form_layout.addRow("Double Bond Spacing:", bsd_layout)
+
+        # Triple Bond Spacing
+        self.bond_spacing_triple_2d_slider = QSlider(Qt.Orientation.Horizontal)
+        self.bond_spacing_triple_2d_slider.setRange(10, 200) # 1.0 - 20.0
+        self.bond_spacing_triple_2d_label = QLabel("3.5")
+        self.bond_spacing_triple_2d_slider.valueChanged.connect(lambda v: self.bond_spacing_triple_2d_label.setText(f"{v/10:.1f}"))
+        bst_layout = QHBoxLayout()
+        bst_layout.addWidget(self.bond_spacing_triple_2d_slider)
+        bst_layout.addWidget(self.bond_spacing_triple_2d_label)
+        form_layout.addRow("Triple Bond Spacing:", bst_layout)
+        
+        # Bond Cap Style
+        self.bond_cap_style_2d_combo = QComboBox()
+        self.bond_cap_style_2d_combo.addItems(['Round', 'Flat', 'Square'])
+        form_layout.addRow("Bond Cap Style:", self.bond_cap_style_2d_combo)
+
+
+        line2 = QFrame()
+        line2.setFrameShape(QFrame.Shape.HLine)
+        line2.setFrameShadow(QFrame.Shadow.Sunken)
+        form_layout.addRow(line2)
+
+        # --- Atom Settings ---
+        form_layout.addRow(QLabel("<b>Atom Settings</b>"))
+
+        # Font Size
+        self.atom_font_size_2d_slider = QSlider(Qt.Orientation.Horizontal)
+        self.atom_font_size_2d_slider.setRange(8, 72)
+        self.atom_font_size_2d_label = QLabel("20")
+        self.atom_font_size_2d_slider.valueChanged.connect(lambda v: self.atom_font_size_2d_label.setText(str(v)))
+        fs_layout = QHBoxLayout()
+        fs_layout.addWidget(self.atom_font_size_2d_slider)
+        fs_layout.addWidget(self.atom_font_size_2d_label)
+        form_layout.addRow("Atom Label Font Size:", fs_layout)
+        
+        # Use Bond Color Checkbox
+        self.atom_use_bond_color_2d_checkbox = QCheckBox()
+        self.atom_use_bond_color_2d_checkbox.setToolTip("If checked, atoms will use the unified Bond Color instead of element-specific colors (CPK).")
+        form_layout.addRow("Use Bond Color for Atoms:", self.atom_use_bond_color_2d_checkbox)
+
+        self.tab_widget.addTab(widget, "2D Settings")
+        
+
+        
+        # Initialize internal variable for combo updates
+        # (Usually done in update_ui_from_settings, but we add direct access here for simple binding if needed)
+        # We rely on update_ui_from_settings to set current selection.
+
+
+    def pick_bg_color_2d(self):
+        color = QColorDialog.getColor(QColor(self.current_bg_color_2d), self, "Select 2D Background Color")
+        if color.isValid():
+            self.current_bg_color_2d = color.name()
+            self.update_2d_color_buttons()
+
+    def pick_bond_color_2d(self):
+        color = QColorDialog.getColor(QColor(self.current_bond_color_2d), self, "Select 2D Bond Color")
+        if color.isValid():
+            self.current_bond_color_2d = color.name()
+            self.update_2d_color_buttons()
+
+    def update_2d_color_buttons(self):
+        try:
+            self.bg_color_2d_button.setStyleSheet(f"background-color: {self.current_bg_color_2d}; border: 1px solid #888;")
+            self.bond_color_2d_button.setStyleSheet(f"background-color: {self.current_bond_color_2d}; border: 1px solid #888;")
+        except Exception:
+            pass
     
     def create_scene_tab(self):
         """基本設定タブを作成"""
@@ -217,7 +352,7 @@ class SettingsDialog(QDialog):
         self.projection_combo.setToolTip("Choose camera projection mode: Perspective (default) or Orthographic")
         form_layout.addRow("Projection Mode:", self.projection_combo)
         
-        self.tab_widget.addTab(scene_widget, "Scene")
+        self.tab_widget.addTab(scene_widget, "3D Scene")
     
     def create_other_tab(self):
         """other設定タブを作成"""
@@ -643,11 +778,22 @@ class SettingsDialog(QDialog):
         tab_name = self.tab_widget.tabText(current_tab_index)
         
         # 各タブの設定項目を定義
-        # Note: tab labels must match those added to the QTabWidget ("Scene", "Ball & Stick",
+        # Each tab settings
+        # Note: tab labels must match those added to the QTabWidget ("2D Settings", "Scene", "Ball & Stick", ...
         # "CPK (Space-filling)", "Wireframe", "Stick", "Other"). Use the per-model
         # multi-bond keys present in self.default_settings.
         tab_settings = {
-            "Scene": {
+            "2D Settings": {
+                'bond_width_2d': self.default_settings['bond_width_2d'],
+                'bond_spacing_double_2d': self.default_settings['bond_spacing_double_2d'],
+                'bond_spacing_triple_2d': self.default_settings['bond_spacing_triple_2d'],
+                'atom_font_size_2d': self.default_settings['atom_font_size_2d'],
+                'background_color_2d': self.default_settings['background_color_2d'],
+                'bond_color_2d': self.default_settings['bond_color_2d'],
+                'atom_use_bond_color_2d': self.default_settings['atom_use_bond_color_2d'],
+                'bond_cap_style_2d': self.default_settings['bond_cap_style_2d']
+            },
+            "3D Scene": {
                 'background_color': self.default_settings['background_color'],
                 'projection_mode': self.default_settings['projection_mode'],
                 'show_3d_axes': self.default_settings['show_3d_axes'],
@@ -711,6 +857,13 @@ class SettingsDialog(QDialog):
             
             # UIを更新
             self.update_ui_from_settings(updated_settings)
+            
+            # If 2D settings were reset, update internal color variables too
+            if tab_name == "2D Settings":
+                self.current_bg_color_2d = updated_settings.get('background_color_2d', self.default_settings['background_color_2d'])
+                self.current_bond_color_2d = updated_settings.get('bond_color_2d', self.default_settings['bond_color_2d'])
+                self.update_2d_color_buttons()
+
             # CPK tab: do not change parent/settings immediately; let Apply/OK persist any changes
             
             # ユーザーへのフィードバック
@@ -748,7 +901,9 @@ class SettingsDialog(QDialog):
                         if 'cpk_colors' in self.parent_window.settings:
                             # Reset to defaults (empty override dict)
                             self.parent_window.settings['cpk_colors'] = {}
-                        # 2D bond color is fixed and not part of the settings; do not modify it here
+                        
+                        # Reset 2D Settings (colors need manual refresh in parent scene/view usually handled by apply)
+                        
                         # Reset 3D Ball & Stick uniform bond color to default
                         self.parent_window.settings['ball_stick_bond_color'] = self.default_settings.get('ball_stick_bond_color', '#7F7F7F')
                         # Update global CPK colors and reapply 3D settings immediately
@@ -1063,9 +1218,17 @@ class SettingsDialog(QDialog):
             'aromatic_torus_thickness_factor': self.aromatic_torus_thickness_slider.value() / 100.0,
             'skip_chemistry_checks': self.skip_chem_checks_checkbox.isChecked(),
             'always_ask_charge': self.always_ask_charge_checkbox.isChecked(),
-            # Ball & Stick bond color (3D grey/uniform color)
             'ball_stick_bond_color': getattr(self, 'bs_bond_color', self.default_settings.get('ball_stick_bond_color', '#7F7F7F')),
             'ball_stick_use_cpk_bond_color': self.bs_use_cpk_bond_checkbox.isChecked(),
+            # 2D Settings
+            'bond_width_2d': self.bond_width_2d_slider.value() / 10.0,
+            'bond_spacing_double_2d': self.bond_spacing_double_2d_slider.value() / 10.0,
+            'bond_spacing_triple_2d': self.bond_spacing_triple_2d_slider.value() / 10.0,
+            'atom_font_size_2d': self.atom_font_size_2d_slider.value(),
+            'background_color_2d': self.current_bg_color_2d,
+            'bond_color_2d': self.current_bond_color_2d,
+            'atom_use_bond_color_2d': self.atom_use_bond_color_2d_checkbox.isChecked(),
+            'bond_cap_style_2d': self.bond_cap_style_2d_combo.currentText(),
         }
 
     def pick_bs_bond_color(self):
@@ -1119,6 +1282,27 @@ class SettingsDialog(QDialog):
             # 現在の分子を再描画（設定変更を反映）
             if hasattr(self.parent_window, 'current_mol') and self.parent_window.current_mol:
                 self.parent_window.draw_molecule_3d(self.parent_window.current_mol)
+            
+            # 2Dビューの設定適用 (背景色、結合スタイルなど)
+            # update_style() will read the new settings from parent_window.settings
+            try:
+                if hasattr(self.parent_window, 'scene') and self.parent_window.scene:
+                    # Update Background
+                    bg_col_2d = self.parent_window.settings.get('background_color_2d', '#FFFFFF')
+                    self.parent_window.scene.setBackgroundBrush(QColor(bg_col_2d))
+                    
+                    # Update Items
+                    for item in self.parent_window.scene.items():
+                        if hasattr(item, 'update_style'):
+                            item.update_style()
+                        elif hasattr(item, 'update'):
+                            item.update()
+                            
+                    if hasattr(self.parent_window.view_2d, 'viewport'):
+                        self.parent_window.view_2d.viewport().update()
+            except Exception:
+                pass
+            
             # ステータスバーに適用完了を表示
             self.parent_window.statusBar().showMessage("Settings applied successfully")
 
@@ -1147,3 +1331,173 @@ class SettingsDialog(QDialog):
         # apply_settingsを呼び出して設定を適用
         self.apply_settings()
         super().accept()
+
+    def update_ui_from_settings(self, settings_dict):
+        """設定辞書に基づいてUIを更新"""
+        # 1. Scene settings
+        self.current_bg_color = settings_dict.get('background_color', self.default_settings['background_color'])
+        self.update_color_button(self.current_bg_color)
+        
+        self.axes_checkbox.setChecked(settings_dict.get('show_3d_axes', self.default_settings['show_3d_axes']))
+        self.light_checkbox.setChecked(settings_dict.get('lighting_enabled', self.default_settings['lighting_enabled']))
+        
+        intensity = settings_dict.get('light_intensity', self.default_settings['light_intensity'])
+        self.intensity_slider.setValue(int(intensity * 100))
+        self.intensity_label.setText(f"{intensity:.2f}")
+        
+        specular = settings_dict.get('specular', self.default_settings['specular'])
+        self.specular_slider.setValue(int(specular * 100))
+        self.specular_label.setText(f"{specular:.2f}")
+        
+        spec_power = settings_dict.get('specular_power', self.default_settings['specular_power'])
+        self.spec_power_slider.setValue(int(spec_power))
+        self.spec_power_label.setText(str(spec_power))
+        
+        proj_mode = settings_dict.get('projection_mode', self.default_settings['projection_mode'])
+        idx = self.projection_combo.findText(proj_mode)
+        if idx >= 0:
+            self.projection_combo.setCurrentIndex(idx)
+            
+        # 2. Ball & Stick settings
+        bs_atom_scale = settings_dict.get('ball_stick_atom_scale', self.default_settings['ball_stick_atom_scale'])
+        self.bs_atom_scale_slider.setValue(int(bs_atom_scale * 100))
+        self.bs_atom_scale_label.setText(f"{bs_atom_scale:.2f}")
+        
+        bs_bond_radius = settings_dict.get('ball_stick_bond_radius', self.default_settings['ball_stick_bond_radius'])
+        self.bs_bond_radius_slider.setValue(int(bs_bond_radius * 100))
+        self.bs_bond_radius_label.setText(f"{bs_bond_radius:.2f}")
+
+        # Multi-bond offsets (Ball & Stick)
+        bs_db_offset = settings_dict.get('ball_stick_double_bond_offset_factor', self.default_settings.get('ball_stick_double_bond_offset_factor', 2.0))
+        self.bs_double_offset_slider.setValue(int(bs_db_offset * 100))
+        self.bs_double_offset_label.setText(f"{bs_db_offset:.2f}")
+
+        bs_tr_offset = settings_dict.get('ball_stick_triple_bond_offset_factor', self.default_settings.get('ball_stick_triple_bond_offset_factor', 2.0))
+        self.bs_triple_offset_slider.setValue(int(bs_tr_offset * 100))
+        self.bs_triple_offset_label.setText(f"{bs_tr_offset:.2f}")
+        
+        bs_db_rad = settings_dict.get('ball_stick_double_bond_radius_factor', self.default_settings.get('ball_stick_double_bond_radius_factor', 0.8))
+        self.bs_double_radius_slider.setValue(int(bs_db_rad * 100))
+        self.bs_double_radius_label.setText(f"{bs_db_rad:.2f}")
+
+        bs_tr_rad = settings_dict.get('ball_stick_triple_bond_radius_factor', self.default_settings.get('ball_stick_triple_bond_radius_factor', 0.75))
+        self.bs_triple_radius_slider.setValue(int(bs_tr_rad * 100))
+        self.bs_triple_radius_label.setText(f"{bs_tr_rad:.2f}")
+
+        bs_res = settings_dict.get('ball_stick_resolution', self.default_settings['ball_stick_resolution'])
+        self.bs_resolution_slider.setValue(int(bs_res))
+        self.bs_resolution_label.setText(str(bs_res))
+
+        # Ball & Stick bond color
+        self.bs_bond_color = settings_dict.get('ball_stick_bond_color', self.default_settings.get('ball_stick_bond_color', '#7F7F7F'))
+        try:
+            self.bs_bond_color_button.setStyleSheet(f"background-color: {self.bs_bond_color}; border: 1px solid #888;")
+            self.bs_bond_color_button.setToolTip(self.bs_bond_color)
+        except Exception:
+            pass
+
+        self.bs_use_cpk_bond_checkbox.setChecked(settings_dict.get('ball_stick_use_cpk_bond_color', self.default_settings.get('ball_stick_use_cpk_bond_color', False)))
+            
+        # 3. CPK settings
+        cpk_atom_scale = settings_dict.get('cpk_atom_scale', self.default_settings['cpk_atom_scale'])
+        self.cpk_atom_scale_slider.setValue(int(cpk_atom_scale * 100))
+        self.cpk_atom_scale_label.setText(f"{cpk_atom_scale:.2f}")
+        
+        cpk_res = settings_dict.get('cpk_resolution', self.default_settings['cpk_resolution'])
+        self.cpk_resolution_slider.setValue(int(cpk_res))
+        self.cpk_resolution_label.setText(str(cpk_res))
+        
+        # 4. Wireframe settings
+        wf_bond_radius = settings_dict.get('wireframe_bond_radius', self.default_settings['wireframe_bond_radius'])
+        self.wf_bond_radius_slider.setValue(int(wf_bond_radius * 100))
+        self.wf_bond_radius_label.setText(f"{wf_bond_radius:.2f}")
+        
+        wf_res = settings_dict.get('wireframe_resolution', self.default_settings['wireframe_resolution'])
+        self.wf_resolution_slider.setValue(int(wf_res))
+        self.wf_resolution_label.setText(str(wf_res))
+
+        # Multi-bond offsets (Wireframe)
+        wf_db_offset = settings_dict.get('wireframe_double_bond_offset_factor', self.default_settings.get('wireframe_double_bond_offset_factor', 3.0))
+        self.wf_double_offset_slider.setValue(int(wf_db_offset * 100))
+        self.wf_double_offset_label.setText(f"{wf_db_offset:.2f}")
+
+        wf_tr_offset = settings_dict.get('wireframe_triple_bond_offset_factor', self.default_settings.get('wireframe_triple_bond_offset_factor', 3.0))
+        self.wf_triple_offset_slider.setValue(int(wf_tr_offset * 100))
+        self.wf_triple_offset_label.setText(f"{wf_tr_offset:.2f}")
+        
+        wf_db_rad = settings_dict.get('wireframe_double_bond_radius_factor', self.default_settings.get('wireframe_double_bond_radius_factor', 0.8))
+        self.wf_double_radius_slider.setValue(int(wf_db_rad * 100))
+        self.wf_double_radius_label.setText(f"{wf_db_rad:.2f}")
+
+        wf_tr_rad = settings_dict.get('wireframe_triple_bond_radius_factor', self.default_settings.get('wireframe_triple_bond_radius_factor', 0.75))
+        self.wf_triple_radius_slider.setValue(int(wf_tr_rad * 100))
+        self.wf_triple_radius_label.setText(f"{wf_tr_rad:.2f}")
+            
+        # 5. Stick settings
+        stick_bond_radius = settings_dict.get('stick_bond_radius', self.default_settings['stick_bond_radius'])
+        self.stick_bond_radius_slider.setValue(int(stick_bond_radius * 100))
+        self.stick_bond_radius_label.setText(f"{stick_bond_radius:.2f}")
+        
+        stick_res = settings_dict.get('stick_resolution', self.default_settings['stick_resolution'])
+        self.stick_resolution_slider.setValue(int(stick_res))
+        self.stick_resolution_label.setText(str(stick_res))
+
+        # Multi-bond offsets (Stick)
+        stick_db_offset = settings_dict.get('stick_double_bond_offset_factor', self.default_settings.get('stick_double_bond_offset_factor', 1.5))
+        self.stick_double_offset_slider.setValue(int(stick_db_offset * 100))
+        self.stick_double_offset_label.setText(f"{stick_db_offset:.2f}")
+
+        stick_tr_offset = settings_dict.get('stick_triple_bond_offset_factor', self.default_settings.get('stick_triple_bond_offset_factor', 1.0))
+        self.stick_triple_offset_slider.setValue(int(stick_tr_offset * 100))
+        self.stick_triple_offset_label.setText(f"{stick_tr_offset:.2f}")
+        
+        stick_db_rad = settings_dict.get('stick_double_bond_radius_factor', self.default_settings.get('stick_double_bond_radius_factor', 0.6))
+        self.stick_double_radius_slider.setValue(int(stick_db_rad * 100))
+        self.stick_double_radius_label.setText(f"{stick_db_rad:.2f}")
+
+        stick_tr_rad = settings_dict.get('stick_triple_bond_radius_factor', self.default_settings.get('stick_triple_bond_radius_factor', 0.4))
+        self.stick_triple_radius_slider.setValue(int(stick_tr_rad * 100))
+        self.stick_triple_radius_label.setText(f"{stick_tr_rad:.2f}")
+
+        # 6. Other settings
+        self.skip_chem_checks_checkbox.setChecked(settings_dict.get('skip_chemistry_checks', self.default_settings.get('skip_chemistry_checks', False)))
+        self.kekule_3d_checkbox.setChecked(settings_dict.get('display_kekule_3d', self.default_settings.get('display_kekule_3d', False)))
+        # always ask for charge on XYZ imports
+        self.always_ask_charge_checkbox.setChecked(settings_dict.get('always_ask_charge', self.default_settings.get('always_ask_charge', False)))
+        # Aromatic ring circle display and torus thickness factor
+        self.aromatic_circle_checkbox.setChecked(settings_dict.get('display_aromatic_circles_3d', self.default_settings.get('display_aromatic_circles_3d', False)))
+        thickness_factor = float(settings_dict.get('aromatic_torus_thickness_factor', self.default_settings.get('aromatic_torus_thickness_factor', 0.6)))
+        try:
+            self.aromatic_torus_thickness_slider.setValue(int(thickness_factor * 100))
+            self.aromatic_torus_thickness_label.setText(f"{thickness_factor:.1f}")
+        except Exception:
+            pass
+
+        # 7. 2D Settings
+        bw_2d = settings_dict.get('bond_width_2d', self.default_settings['bond_width_2d'])
+        self.bond_width_2d_slider.setValue(int(bw_2d * 10))
+        self.bond_width_2d_label.setText(f"{bw_2d:.1f}")
+
+        bsd_2d = settings_dict.get('bond_spacing_double_2d', self.default_settings['bond_spacing_double_2d'])
+        self.bond_spacing_double_2d_slider.setValue(int(bsd_2d * 10))
+        self.bond_spacing_double_2d_label.setText(f"{bsd_2d:.1f}")
+
+        bst_2d = settings_dict.get('bond_spacing_triple_2d', self.default_settings['bond_spacing_triple_2d'])
+        self.bond_spacing_triple_2d_slider.setValue(int(bst_2d * 10))
+        self.bond_spacing_triple_2d_label.setText(f"{bst_2d:.1f}")
+
+        fs_2d = settings_dict.get('atom_font_size_2d', self.default_settings['atom_font_size_2d'])
+        self.atom_font_size_2d_slider.setValue(int(fs_2d))
+        self.atom_font_size_2d_label.setText(str(fs_2d))
+
+        self.atom_use_bond_color_2d_checkbox.setChecked(settings_dict.get('atom_use_bond_color_2d', self.default_settings.get('atom_use_bond_color_2d', False)))
+
+        self.current_bg_color_2d = settings_dict.get('background_color_2d', self.default_settings['background_color_2d'])
+
+        # Load Bond Cap Style
+        cap_style = settings_dict.get('bond_cap_style_2d', self.default_settings.get('bond_cap_style_2d', 'Round'))
+        index = self.bond_cap_style_2d_combo.findText(cap_style)
+        if index >= 0:
+            self.bond_cap_style_2d_combo.setCurrentIndex(index)
+        self.current_bond_color_2d = settings_dict.get('bond_color_2d', self.default_settings['bond_color_2d'])
+        self.update_2d_color_buttons()

{moleditpy-2.3.3.dist-info → moleditpy-2.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy
-Version: 2.3.3
+Version: 2.4.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

{moleditpy-2.3.3.dist-info → moleditpy-2.4.1.dist-info}/RECORD

@@ -7,25 +7,25 @@ moleditpy/modules/align_plane_dialog.py,sha256=SEC32l8z2x1W1Sf1Gu001OQEtinuvqGuC
 moleditpy/modules/alignment_dialog.py,sha256=CPubSJI52mNSXmWt7oKQ2un5lXnN8_K4Z-LMM7wWTxQ,11309
 moleditpy/modules/analysis_window.py,sha256=zjP5ipSTpKw8oLr1eKdoxW8Bk1SslGlPqsVucD-x_5w,9403
 moleditpy/modules/angle_dialog.py,sha256=uc2WbvSfRe892xoEirqpZ78pf2Smwzkinkso6zLWr0Y,17751
-moleditpy/modules/atom_item.py,sha256=u8ge6B1M9sOGobfzg3tp1-EGXtEUmvdee7Fx6msg8Wk,15566
-moleditpy/modules/bond_item.py,sha256=eVkEeKvM4igYI67DYxpey3FllqDyt_iWDo4VPYMhaPk,19137
+moleditpy/modules/atom_item.py,sha256=zPV6AO0Je4rKgZekyYCGehucleKP21ALDsjVhGV8n-M,17738
+moleditpy/modules/bond_item.py,sha256=hOwga7DcxZf8zxwZr8F7viTNgEi_9wftKFgSpROUJs8,21602
 moleditpy/modules/bond_length_dialog.py,sha256=6bFPGssnqlgINuqpxLv-OhjMH3_hspnaH8QtorAyu2M,14782
 moleditpy/modules/calculation_worker.py,sha256=KiGQY7i-QCQofEoE0r65KoQgpEGFcbhmxWv6egfkUdc,42324
 moleditpy/modules/color_settings_dialog.py,sha256=Ow44BhCOLo0AFb6klO001k6B4drOgKX9DeNBQhZLp5o,15474
-moleditpy/modules/constants.py,sha256=ehyCNblUR4uHs1xVpBAzY2-tQuuF05_6vGY7OYFTfbE,4702
+moleditpy/modules/constants.py,sha256=_KThEyBuzjfnKMFRCmrcHetn0kEWmXmVyiLT2bFsrQ0,4702
 moleditpy/modules/constrained_optimization_dialog.py,sha256=REsk4ePsqNmAGPMTS_jckeM7jexrU3krwun8sKqKUCs,30062
 moleditpy/modules/custom_interactor_style.py,sha256=LDNODMJoNHGe1AUSrvqv6PdeJm-hpPmSpWINppnJLt0,38942
 moleditpy/modules/custom_qt_interactor.py,sha256=vCZsDfRO-FtphD5cTP7Ps-5rpHZMIGloaoe6EaKzrsw,4139
 moleditpy/modules/dialog3_d_picking_mixin.py,sha256=z4udbkiX9PYmIGazPXsbftkk_oRRwZhcvlCqbyJzr24,6493
 moleditpy/modules/dihedral_dialog.py,sha256=bOTDO6-b74vEDn_z6OyuBr5cRz3RnRj83PiaEBUyWJA,18002
-moleditpy/modules/main_window.py,sha256=IL8dH3qPx2TkPgO7amuDgjlFoadh5J59xYUEVhlNZqA,36338
+moleditpy/modules/main_window.py,sha256=bYioEvqRVZVfLSJeV_Sw0TyA0rVWR4unQ0C5OgaDN2s,36642
 moleditpy/modules/main_window_app_state.py,sha256=8YDcGNCSpLTO1NGL9tEvNkXpUcS7JW-uK7TdUGvEqnk,35189
 moleditpy/modules/main_window_compute.py,sha256=ipIkhH_DONXDnPzh7xeym9X-Yfx8EhsvXYOdyxsAj4c,53347
 moleditpy/modules/main_window_dialog_manager.py,sha256=QR96LqHAPSOShXbc9cK-Ffq8a16JrXAoMKB0pHjESrQ,20072
 moleditpy/modules/main_window_edit_3d.py,sha256=CUArB5wcsgq1C7LygAEC6URlbnn4RhRYDa5n-Y-etWI,19731
-moleditpy/modules/main_window_edit_actions.py,sha256=MtCFmbKVAIMrm6hp0rUUNCQ37xYzE8MerVR7d1Coutk,65007
-moleditpy/modules/main_window_export.py,sha256=dSVfylsybDDboDuXU9Inotf6YkrKJwgBTqGYSfq1lRE,38241
-moleditpy/modules/main_window_main_init.py,sha256=stZT2Swcd_yry3C_a7R2bC9-kew8yifRqy8Q3H3a3kk,93220
+moleditpy/modules/main_window_edit_actions.py,sha256=jjMBwCzwflEHHvf_zh_RBcup9ceR_H4dDEvdRrb6wno,69009
+moleditpy/modules/main_window_export.py,sha256=_Vd7MeP_xaLWDYDm3-ZIZiPuAXhP-AvrQbi7Yx3Jy3c,43020
+moleditpy/modules/main_window_main_init.py,sha256=t-um1lHvXo_tPXSkjx5Y0mjZlrKUhZbmb529e-7ffNU,94781
 moleditpy/modules/main_window_molecular_parsers.py,sha256=KR6vzuqc3nutOcorpYr0QOyX3MFBcxTwDhZX96VgJ9Q,48291
 moleditpy/modules/main_window_project_io.py,sha256=TWwtuKDuvgcvPZ9IGmW8r1EJJOrgxrIJRnxe_f4C1oM,17149
 moleditpy/modules/main_window_string_importers.py,sha256=v47wOd4RtjKYcF-aLP-mogGGdYTpTEo3dDyAu79_5MM,10782
@@ -41,7 +41,7 @@ moleditpy/modules/planarize_dialog.py,sha256=eaqI1MpF35e-VUMpJATt-EtGG5FhcSUlbAe
 moleditpy/modules/plugin_interface.py,sha256=JfobFdAOLp5OnyJp3BNsWnpmZNJYypWQHNVNT0fP1N8,8171
 moleditpy/modules/plugin_manager.py,sha256=ZFQz8VlCy1_IHX7DnMro7iRbouB_rxZQowfrKuZ76G8,21133
 moleditpy/modules/plugin_manager_window.py,sha256=b4kEv0DaWHZG76ZaFTOxn6CVtA62_0MpPYYr10ehCtA,12544
-moleditpy/modules/settings_dialog.py,sha256=Nr7yE8UmYRi3VObWvRlrnv0DnjSjmYXbvqryZ02O12k,65348
+moleditpy/modules/settings_dialog.py,sha256=kT1c4INl0EOlazDRv1WZbpg2AHEPfworyq8BO-6z79k,85511
 moleditpy/modules/template_preview_item.py,sha256=djdq3tz73d_fJGOvai3E-V9Hk9q9ZW7skx7BV59mooA,6556
 moleditpy/modules/template_preview_view.py,sha256=4OCHZDO51BvJpKdfrBWJ4_4WfLfFSKxsVIyf7I-Kj2E,3350
 moleditpy/modules/translation_dialog.py,sha256=x_GJsbVk-cj4aN2KgmYWDRUDInFlXezAoYoTvX-OT30,14553
@@ -51,9 +51,9 @@ moleditpy/modules/assets/file_icon.ico,sha256=yyVj084A7HuMNbV073cE_Ag3Ne405qgOP3
 moleditpy/modules/assets/icon.icns,sha256=wD5R6-Vw7K662tVKhu2E1ImN0oUuyAP4youesEQsn9c,139863
 moleditpy/modules/assets/icon.ico,sha256=RfgFcx7-dHY_2STdsOQCQziY5SNhDr3gPnjO6jzEDPI,147975
 moleditpy/modules/assets/icon.png,sha256=kCFN1WacYIdy0GN6SFEbNA00ef39pCczBnFdkkBI8Bs,147110
-moleditpy-2.3.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-moleditpy-2.3.3.dist-info/METADATA,sha256=VbBIVoZs0NPTK88hUAwg8s9MVwt6aVqsIqs1NYcM0po,60629
-moleditpy-2.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-moleditpy-2.3.3.dist-info/entry_points.txt,sha256=yH1h9JjALhok1foXT3-hYrC4ufoZt8b7oiBcsdnGNNM,54
-moleditpy-2.3.3.dist-info/top_level.txt,sha256=ARICrS4ihlPXqywlKl6o-oJa3Qz3gZRWu_VZsQ3_c44,10
-moleditpy-2.3.3.dist-info/RECORD,,
+moleditpy-2.4.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+moleditpy-2.4.1.dist-info/METADATA,sha256=Au-0u49T92vgtUFeMp_45D-KulYajiHuKYL0K0LsScw,60629
+moleditpy-2.4.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+moleditpy-2.4.1.dist-info/entry_points.txt,sha256=yH1h9JjALhok1foXT3-hYrC4ufoZt8b7oiBcsdnGNNM,54
+moleditpy-2.4.1.dist-info/top_level.txt,sha256=ARICrS4ihlPXqywlKl6o-oJa3Qz3gZRWu_VZsQ3_c44,10
+moleditpy-2.4.1.dist-info/RECORD,,

{moleditpy-2.3.3.dist-info → moleditpy-2.4.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any