MoleditPy 2.2.0a1__tar.gz → 2.2.0a2__tar.gz

{moleditpy-2.2.0a1 → moleditpy-2.2.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy
-Version: 2.2.0a1
+Version: 2.2.0a2
 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.2.0a1 → moleditpy-2.2.0a2}/pyproject.toml

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

{moleditpy-2.2.0a1 → moleditpy-2.2.0a2}/src/MoleditPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MoleditPy
-Version: 2.2.0a1
+Version: 2.2.0a2
 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.2.0a1 → moleditpy-2.2.0a2}/src/moleditpy/modules/constants.py

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

{moleditpy-2.2.0a1 → moleditpy-2.2.0a2}/src/moleditpy/modules/main_window_ui_manager.py

@@ -298,7 +298,7 @@ class MainWindowUiManager(object):
 
 
     def dragEnterEvent(self, event):
-        """ウィンドウ全体で .pmeraw、.pmeprj、.mol、.sdf、.xyz ファイルのドラッグを受け入れる"""
+        """ウィンドウ全体でサポートされているファイルのドラッグを受け入れる"""
         # Accept if any dragged local file has a supported extension
         if event.mimeData().hasUrls():
             urls = event.mimeData().urls()
@@ -306,9 +306,28 @@ class MainWindowUiManager(object):
                 try:
                     if url.isLocalFile():
                         file_path = url.toLocalFile()
-                        if file_path.lower().endswith(('.pmeraw', '.pmeprj', '.mol', '.sdf', '.xyz')):
+                        file_lower = file_path.lower()
+                        
+                        # Built-in extensions
+                        if file_lower.endswith(('.pmeraw', '.pmeprj', '.mol', '.sdf', '.xyz')):
                             event.acceptProposedAction()
                             return
+                        
+                        # Plugin-registered file openers
+                        if self.plugin_manager and hasattr(self.plugin_manager, 'file_openers'):
+                            for ext in self.plugin_manager.file_openers.keys():
+                                if file_lower.endswith(ext):
+                                    event.acceptProposedAction()
+                                    return
+                        
+                        # Plugin drop handlers (accept more liberally for custom logic)
+                        # A plugin drop handler might handle it, so accept
+                        if self.plugin_manager and hasattr(self.plugin_manager, 'drop_handlers'):
+                            if len(self.plugin_manager.drop_handlers) > 0:
+                                # Accept any file if drop handlers are registered
+                                # They will check the file type in dropEvent
+                                event.acceptProposedAction()
+                                return
                 except Exception:
                     continue
         event.ignore()

{moleditpy-2.2.0a1 → moleditpy-2.2.0a2}/src/moleditpy/plugins/Input Generator/orca_xyz2inp_gui.py

@@ -9,7 +9,7 @@ import json
 __version__="2025.12.25"
 __author__="HiroYokoyama"
 PLUGIN_NAME = "ORCA xyz2inp GUI"
-SETTINGS_JSON = os.path.join(os.path.dirname(__file__), "orca_xyz2inp_settings.json")
+SETTINGS_JSON = os.path.join(os.path.dirname(__file__), "orca_xyz2inp_gui.json")
 
 class OrcaInputDialog(QDialog):
     def __init__(self, main_window):

moleditpy-2.2.0a2/src/moleditpy/plugins/Utility/atom_colorizer.py

@@ -0,0 +1,262 @@
+import numpy as np
+import pyvista as pv
+from PyQt6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QPushButton, 
+                             QLabel, QColorDialog, QDockWidget, QMessageBox, 
+                             QLineEdit, QListWidget, QAbstractItemView, QGroupBox, QDialog)
+from PyQt6.QtGui import QColor, QCloseEvent
+from PyQt6.QtCore import Qt
+import traceback
+import sys
+import os
+import json
+
+# Try importing from the installed package first (pip package structure)
+try:
+    from moleditpy.modules.constants import CPK_COLORS_PV
+except ImportError:
+    # Fallback to local 'modules' if running from source or sys.path is set that way
+    try:
+        from modules.constants import CPK_COLORS_PV
+    except ImportError:
+        # Final fallback map
+        CPK_COLORS_PV = {}
+
+__version__="2025.12.25"
+__author__="HiroYokoyama"
+
+PLUGIN_NAME = "Atom Colorizer"
+
+class AtomColorizerWindow(QDialog):
+    def __init__(self, main_window):
+        super().__init__(parent=main_window)
+        self.mw = main_window
+        self.plotter = self.mw.plotter
+        
+        # Set window properties for modeless behavior
+        self.setModal(False)
+        self.setWindowTitle(PLUGIN_NAME)
+        self.setWindowFlags(Qt.WindowType.Window) # Ensures it has min/max/close buttons
+        
+        # Initialize current_color as QColor object
+        self.current_color = QColor(255, 0, 0) # Default red
+        
+        self.init_ui()
+        
+        # Auto-enable 3D Selection (Measurement Mode) if not already active
+        try:
+            if hasattr(self.mw, 'measurement_mode') and not self.mw.measurement_mode:
+                if hasattr(self.mw, 'toggle_measurement_mode'):
+                    self.mw.toggle_measurement_mode(True)
+                    # Sync UI button state if possible
+                    if hasattr(self.mw, 'measurement_action'):
+                        self.mw.measurement_action.setChecked(True)
+        except Exception as e:
+            print(f"Failed to auto-enable 3D selection: {e}")
+
+    def init_ui(self):
+        layout = QVBoxLayout()
+        
+        # Information Label
+        info_label = QLabel("Select atoms in the 3D viewer and apply color.")
+        info_label.setWordWrap(True)
+        layout.addWidget(info_label)
+
+        # Selection Group
+        sel_group = QGroupBox("Selection")
+        sel_layout = QVBoxLayout()
+        
+        self.le_indices = QLineEdit()
+        self.le_indices.setPlaceholderText("e.g. 0, 1, 5")
+        sel_layout.addWidget(self.le_indices)
+        
+        # Auto-update timer
+        from PyQt6.QtCore import QTimer
+        self.sel_timer = QTimer(self)
+        self.sel_timer.timeout.connect(self._auto_update_selection)
+        self.sel_timer.start(200) # Check every 200ms
+        
+        sel_group.setLayout(sel_layout)
+        layout.addWidget(sel_group)
+
+        # Color Group
+        col_group = QGroupBox("Color")
+        col_layout = QVBoxLayout()
+        
+        self.btn_color = QPushButton("Choose Color")
+        # Initial style based on self.current_color (QColor object)
+        self.btn_color.setStyleSheet(f"background-color: {self.current_color.name()}; color: {'black' if self.current_color.lightness() > 128 else 'white'};")
+        self.btn_color.clicked.connect(self.choose_color)
+        col_layout.addWidget(self.btn_color)
+        
+        btn_apply = QPushButton("Apply Color")
+        btn_apply.clicked.connect(self.apply_color)
+        col_layout.addWidget(btn_apply)
+        
+        col_group.setLayout(col_layout)
+        layout.addWidget(col_group)
+
+        # Reset Group
+        reset_group = QGroupBox("Reset")
+        reset_layout = QVBoxLayout()
+        
+        btn_reset = QPushButton("Reset to Element Colors")
+        btn_reset.clicked.connect(self.reset_colors)
+        reset_layout.addWidget(btn_reset)
+        
+        reset_group.setLayout(reset_layout)
+        layout.addWidget(reset_group)
+        
+        layout.addStretch()
+        
+        # Close Button
+        close_btn = QPushButton("Close")
+        close_btn.clicked.connect(self.close)
+        layout.addWidget(close_btn)
+
+        self.setLayout(layout)
+        
+        # Resize window to a reasonable default
+        self.resize(300, 400)
+
+    def get_selection_from_viewer(self):
+        """
+        Get selected atom indices from the main window.
+        Only checks 3D selection and Measurement selection. 2D selection is ignored per request.
+        """
+        indices = set()
+        
+        # 1. Check direct 3D selection (e.g. from 3D Drag or specific 3D select tools)
+        if hasattr(self.mw, 'selected_atoms_3d') and self.mw.selected_atoms_3d:
+            indices.update(self.mw.selected_atoms_3d)
+
+        # 2. Check measurement selection (commonly used for picking atoms in 3D)
+        if hasattr(self.mw, 'selected_atoms_for_measurement') and self.mw.selected_atoms_for_measurement:
+             # selected_atoms_for_measurement might be list of int or objects, typically ints in this internal API
+             for item in self.mw.selected_atoms_for_measurement:
+                 if isinstance(item, int):
+                     indices.add(item)
+
+        # Update the line edit
+        sorted_indices = sorted(list(indices))
+        new_text = ",".join(map(str, sorted_indices))
+        if self.le_indices.text() != new_text:
+             self.le_indices.setText(new_text)
+
+    def _auto_update_selection(self):
+        """Timer slot to auto-update selection."""
+        if self.le_indices.hasFocus():
+            return
+        self.get_selection_from_viewer()
+
+    def choose_color(self):
+        c = QColorDialog.getColor(initial=self.current_color, title="Select Color")
+        if c.isValid():
+            self.current_color = c
+            # Update button style
+            self.btn_color.setStyleSheet(f"background-color: {c.name()}; color: {'black' if c.lightness() > 128 else 'white'};")
+
+    def apply_color(self):
+        txt = self.le_indices.text().strip()
+        if not txt:
+            QMessageBox.warning(self, "Warning", "No atoms selected. Please select atoms in the 3D viewer first.")
+            return
+
+        try:
+            str_indices = [x.strip() for x in txt.split(',') if x.strip()]
+            target_indices = [int(x) for x in str_indices]
+        except ValueError:
+            QMessageBox.warning(self, "Error", "Invalid indices format.")
+            return
+
+        if not self.mw.current_mol:
+            QMessageBox.warning(self, "Error", "No molecule loaded.")
+            return
+
+        try:
+            # Use the API to set atom colors
+            hex_color = self.current_color.name()
+            
+            for idx in target_indices:
+                if 0 <= idx < self.mw.current_mol.GetNumAtoms():
+                    # Access via main_window_view_3d proxy
+                    if hasattr(self.mw, 'main_window_view_3d'):
+                        self.mw.main_window_view_3d.update_atom_color_override(idx, hex_color)
+                    else:
+                         # Fallback if unproxied (unlikely in this architecture)
+                         pass
+                    
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to apply color: {e}")
+            traceback.print_exc()
+
+    def reset_colors(self):
+        if not self.mw.current_mol:
+            return
+
+        try:
+            # Clear all color overrides using the API
+            for i in range(self.mw.current_mol.GetNumAtoms()):
+                if hasattr(self.mw, 'main_window_view_3d'):
+                    self.mw.main_window_view_3d.update_atom_color_override(i, None)
+                
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to reset colors: {e}")
+
+
+# Global reference to keep window alive
+_atom_colorizer_window = None
+
+def run(mw):
+    global _atom_colorizer_window
+    
+    # Check if window already exists
+    if _atom_colorizer_window is None:
+        _atom_colorizer_window = AtomColorizerWindow(mw)
+        # Handle cleanup when window is closed
+        _atom_colorizer_window.finished.connect(lambda: _cleanup_window())
+    
+    _atom_colorizer_window.show()
+    _atom_colorizer_window.raise_()
+    _atom_colorizer_window.activateWindow()
+
+def _cleanup_window():
+    global _atom_colorizer_window
+    _atom_colorizer_window = None
+
+
+def initialize(context):
+    """
+    Register plugin save/load handlers for persistence.
+    """
+    mw = context.get_main_window()
+    
+    def save_handler():
+        """Save color overrides to project file."""
+        # _plugin_color_overrides is stored on the MainWindow instance by the API
+        if not hasattr(mw, '_plugin_color_overrides'):
+            return {}
+        
+        # Convert color overrides to JSON-serializable format
+        return {
+            "atom_colors": {str(k): v for k, v in mw._plugin_color_overrides.items()}
+        }
+    
+    def load_handler(data):
+        """Load color overrides from project file."""
+        if not data:
+            return
+        
+        atom_colors = data.get("atom_colors", {})
+        
+        # Restore color overrides using the API
+        if hasattr(mw, 'main_window_view_3d'):
+            for atom_idx_str, hex_color in atom_colors.items():
+                try:
+                    atom_idx = int(atom_idx_str)
+                    mw.main_window_view_3d.update_atom_color_override(atom_idx, hex_color)
+                except Exception as e:
+                    print(f"Failed to restore color for atom {atom_idx_str}: {e}")
+    
+    # Register handlers
+    context.register_save_handler(save_handler)
+    context.register_load_handler(load_handler)

{moleditpy-2.2.0a1 → moleditpy-2.2.0a2}/src/moleditpy/plugins/Utility/vdw_radii_overlay.py

@@ -7,8 +7,8 @@ import numpy as np
 import functools
 import types
 from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QLabel, 
-                             QSlider, QHBoxLayout, QPushButton)
-from PyQt6.QtGui import QAction
+                             QSlider, QHBoxLayout, QPushButton, QDoubleSpinBox)
+from PyQt6.QtGui import QAction, QColor
 from PyQt6.QtCore import Qt, QTimer
 
 # Try to import VDW radii from constants, fallback if needed
@@ -35,7 +35,8 @@ SETTINGS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "vdw_ra
 # Global State
 _config_window = None
 _vdw_settings = {
-    "occupancy": 0.3  # Opacity (0.0 - 1.0)
+    "occupancy": 0.3,  # Opacity (0.0 - 1.0)
+    "resolution": 0.125 # Voxel spacing in Angstroms
 }
 
 def load_settings():
@@ -44,9 +45,10 @@ def load_settings():
         if os.path.exists(SETTINGS_FILE):
             with open(SETTINGS_FILE, 'r') as f:
                 saved = json.load(f)
-                # Filter to only keep occupancy
                 if "occupancy" in saved:
                     _vdw_settings["occupancy"] = float(saved["occupancy"])
+                if "resolution" in saved:
+                    _vdw_settings["resolution"] = float(saved["resolution"])
     except Exception as e:
         print(f"Error loading VDW settings: {e}")
 
@@ -63,7 +65,7 @@ class VDWConfigWindow(QDialog):
         self.mw = main_window
         self.setWindowTitle("VDW Overlay Settings")
         self.setModal(False)
-        self.resize(300, 100)
+        self.resize(350, 150)
         self.init_ui()
 
     def init_ui(self):
@@ -74,14 +76,45 @@ class VDWConfigWindow(QDialog):
         occ_layout.addWidget(QLabel("Occupancy:"))
         self.slider_occ = QSlider(Qt.Orientation.Horizontal)
         self.slider_occ.setRange(0, 100)
-        current_occ = int(_vdw_settings.get("occupancy", 0.3) * 100)
-        self.slider_occ.setValue(current_occ)
-        self.slider_occ.valueChanged.connect(self.on_occupancy_changed)
+        current_occ = _vdw_settings.get("occupancy", 0.3)
+        self.slider_occ.setValue(int(current_occ * 100))
+        self.slider_occ.valueChanged.connect(self.on_occupancy_slider_changed)
         occ_layout.addWidget(self.slider_occ)
-        self.lbl_occ_val = QLabel(f"{current_occ}%")
-        occ_layout.addWidget(self.lbl_occ_val)
+        
+        self.spin_occ = QDoubleSpinBox()
+        self.spin_occ.setRange(0.0, 1.0)
+        self.spin_occ.setSingleStep(0.05)
+        self.spin_occ.setValue(current_occ)
+        self.spin_occ.valueChanged.connect(self.on_occupancy_spin_changed)
+        occ_layout.addWidget(self.spin_occ)
+        
         layout.addLayout(occ_layout)
+
+        # Resolution Slider
+        res_layout = QHBoxLayout()
+        res_layout.addWidget(QLabel("Resolution (Å):"))
+        self.slider_res = QSlider(Qt.Orientation.Horizontal)
+        self.slider_res.setRange(5, 50) # 0.05 to 0.50
+        current_res = _vdw_settings.get("resolution", 0.125)
+        self.slider_res.setValue(int(current_res * 100))
+        self.slider_res.valueChanged.connect(self.on_resolution_slider_changed)
+        res_layout.addWidget(self.slider_res)
+        
+        self.spin_res = QDoubleSpinBox()
+        self.spin_res.setRange(0.05, 0.50)
+        self.spin_res.setSingleStep(0.005)
+        self.spin_res.setDecimals(3)
+        self.spin_res.setValue(current_res)
+        self.spin_res.valueChanged.connect(self.on_resolution_spin_changed)
+        res_layout.addWidget(self.spin_res)
         
+        layout.addLayout(res_layout)
+        
+        # Reset Button
+        btn_reset = QPushButton("Reset to Defaults")
+        btn_reset.clicked.connect(self.reset_defaults)
+        layout.addWidget(btn_reset)
+
         # Close Button
         btn_close = QPushButton("Close")
         btn_close.clicked.connect(self.close)
@@ -89,13 +122,93 @@ class VDWConfigWindow(QDialog):
         
         self.setLayout(layout)
 
-    def on_occupancy_changed(self, value):
-        opacity = value / 100.0
-        _vdw_settings["occupancy"] = opacity
-        self.lbl_occ_val.setText(f"{value}%")
+    def on_occupancy_slider_changed(self, value):
+        val_float = value / 100.0
+        self.spin_occ.blockSignals(True)
+        self.spin_occ.setValue(val_float)
+        self.spin_occ.blockSignals(False)
+        self._update_occupancy(val_float)
+
+    def on_occupancy_spin_changed(self, value):
+        val_int = int(value * 100)
+        self.slider_occ.blockSignals(True)
+        self.slider_occ.setValue(val_int)
+        self.slider_occ.blockSignals(False)
+        self._update_occupancy(value)
+
+    def _update_occupancy(self, value):
+        _vdw_settings["occupancy"] = value
+        save_settings()
+        self.update_view()
+
+    def on_resolution_slider_changed(self, value):
+        val_float = value / 100.0
+        self.spin_res.blockSignals(True)
+        self.spin_res.setValue(val_float)
+        self.spin_res.blockSignals(False)
+        self._update_resolution(val_float)
+
+    def on_resolution_spin_changed(self, value):
+        val_int = int(value * 100)
+        self.slider_res.blockSignals(True)
+        self.slider_res.setValue(val_int)
+        self.slider_res.blockSignals(False)
+        self._update_resolution(value)
+        
+    def _update_resolution(self, value):
+        _vdw_settings["resolution"] = value
         save_settings()
         self.update_view()
 
+    def reset_defaults(self):
+        # Default values
+        def_occ = 0.3
+        def_res = 0.125
+        
+        # Block signals to prevent redundant updates/saves during setting
+        self.slider_occ.blockSignals(True)
+        self.spin_occ.blockSignals(True)
+        self.slider_res.blockSignals(True)
+        self.spin_res.blockSignals(True)
+        
+        # Set values
+        self.slider_occ.setValue(int(def_occ * 100))
+        self.spin_occ.setValue(def_occ)
+        self.slider_res.setValue(int(def_res * 100))
+        self.spin_res.setValue(def_res)
+        
+        # Unblock
+        self.slider_occ.blockSignals(False)
+        self.spin_occ.blockSignals(False)
+        self.slider_res.blockSignals(False)
+        self.spin_res.blockSignals(False)
+        
+        # Update settings and view once
+        _vdw_settings["occupancy"] = def_occ
+        _vdw_settings["resolution"] = def_res
+        save_settings()
+        self.update_view()
+
+    def refresh_ui_values(self):
+        """Update UI elements from global settings."""
+        occ = _vdw_settings.get("occupancy", 0.3)
+        res = _vdw_settings.get("resolution", 0.125)
+        
+        self.slider_occ.blockSignals(True)
+        self.spin_occ.blockSignals(True)
+        self.slider_res.blockSignals(True)
+        self.spin_res.blockSignals(True)
+
+        self.slider_occ.setValue(int(occ * 100))
+        self.spin_occ.setValue(occ)
+        self.slider_res.setValue(int(res * 100))
+        self.spin_res.setValue(res)
+
+        self.slider_occ.blockSignals(False)
+        self.spin_occ.blockSignals(False)
+        self.slider_res.blockSignals(False)
+        self.spin_res.blockSignals(False)
+
     def update_view(self):
         # Trigger redraw if we are in the correct mode
         if hasattr(self.mw, 'current_3d_style') and self.mw.current_3d_style == "vdw_overlay":
@@ -130,8 +243,10 @@ def draw_vdw_overlay(mw, mol):
             radii = []
             atom_colors = []
             
-            # Use custom colors if available, otherwise CPK
-            custom_map = getattr(mw, 'custom_atom_colors', {})
+            # Use custom colors if available (API-based or legacy)
+            custom_map = getattr(mw, '_plugin_color_overrides', {})
+            if not custom_map:
+                custom_map = getattr(mw, 'custom_atom_colors', {})
             
             if mol.GetNumConformers() > 0:
                 conf = mol.GetConformer()
@@ -149,10 +264,18 @@ def draw_vdw_overlay(mw, mol):
                     
                     # Color handling
                     if i in custom_map:
-                        c = custom_map[i]
-                        # Normalize 0-255 to 0-1 if needed
-                        if any(x > 1.0 for x in c):
-                            c = [x/255.0 for x in c]
+                        val = custom_map[i]
+                        # Handling new API (Hex string) vs Legacy (List/Tuple)
+                        if isinstance(val, str) and val.startswith('#'):
+                            # Convert Hex to RGB [0-1]
+                            qc = QColor(val)
+                            c = [qc.redF(), qc.greenF(), qc.blueF()]
+                        else:
+                            # Assume legacy list/tuple
+                            c = val
+                            # Normalize 0-255 to 0-1 if needed
+                            if any(x > 1.0 for x in c):
+                                c = [x/255.0 for x in c]
                     else:
                         c = CPK_COLORS_PV.get(sym, [0.8, 0.8, 0.8]) # Default grey if missing
                     atom_colors.append(c)
@@ -170,7 +293,10 @@ def draw_vdw_overlay(mw, mol):
                 max_bounds = positions.max(axis=0) + padding
                 
                 # Resolution (voxel size in Angstroms)
-                spacing = (0.125, 0.125, 0.125) 
+                res_val = _vdw_settings.get("resolution", 0.125)
+                # Clamp to safe limits just in case
+                if res_val < 0.01: res_val = 0.01
+                spacing = (res_val, res_val, res_val) 
                 
                 dims = np.ceil((max_bounds - min_bounds) / spacing).astype(int)
                 
@@ -242,6 +368,9 @@ def run(mw):
         _config_window = VDWConfigWindow(mw)
         _config_window.finished.connect(lambda: _cleanup_config())
     
+    # Ensure UI reflects the loaded settings (important if window was already open or reused)
+    _config_window.refresh_ui_values()
+    
     _config_window.show()
     _config_window.raise_()
     _config_window.activateWindow()