MoleditPy 2.2.0a1__py3-none-any.whl → 2.2.0a2__py3-none-any.whl

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/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/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/plugins/Utility/atom_colorizer.py

@@ -9,7 +9,6 @@ import traceback
 import sys
 import os
 import json
-import functools # Added for polite patching
 
 # Try importing from the installed package first (pip package structure)
 try:
@@ -31,7 +30,6 @@ class AtomColorizerWindow(QDialog):
     def __init__(self, main_window):
         super().__init__(parent=main_window)
         self.mw = main_window
-        # self.dock = dock_widget # Removed as per instruction
         self.plotter = self.mw.plotter
         
         # Set window properties for modeless behavior
@@ -71,8 +69,6 @@ class AtomColorizerWindow(QDialog):
         self.le_indices.setPlaceholderText("e.g. 0, 1, 5")
         sel_layout.addWidget(self.le_indices)
         
-        # 'Get Selection' button removed as per user request (auto-update is active)
-        
         # Auto-update timer
         from PyQt6.QtCore import QTimer
         self.sel_timer = QTimer(self)
@@ -140,13 +136,6 @@ class AtomColorizerWindow(QDialog):
                  if isinstance(item, int):
                      indices.add(item)
 
-        # 2D Selection logic removed as per request ("2Dはいらない")
-
-        if not indices:
-            # Silent return if auto-updating, or maybe clear? 
-            # If we invoke manually, we might want info, but generic message is okay if list is empty.
-            pass
-
         # Update the line edit
         sorted_indices = sorted(list(indices))
         new_text = ",".join(map(str, sorted_indices))
@@ -155,9 +144,6 @@ class AtomColorizerWindow(QDialog):
 
     def _auto_update_selection(self):
         """Timer slot to auto-update selection."""
-        # Only update if the user is not actively typing? 
-        # For now, just call get_selection_from_viewer which now checks for changes before setting text.
-        # However, checking if le_indices has focus might be good.
         if self.le_indices.hasFocus():
             return
         self.get_selection_from_viewer()
@@ -169,51 +155,6 @@ class AtomColorizerWindow(QDialog):
             # Update button style
             self.btn_color.setStyleSheet(f"background-color: {c.name()}; color: {'black' if c.lightness() > 128 else 'white'};")
 
-    def _update_3d_actor(self):
-        """Re-generate glyphs and update the actor to reflect color changes."""
-        try:
-            # 1. Re-run glyph filter to propagate color changes from glyph_source to mesh
-            if hasattr(self.mw, 'glyph_source') and self.mw.glyph_source:
-                # Read resolution from settings or default
-                try:
-                    style = self.mw.current_3d_style
-                    if style == 'cpk':
-                        resolution = self.mw.settings.get('cpk_resolution', 32)
-                    elif style == 'stick':
-                        resolution = self.mw.settings.get('stick_resolution', 16)
-                    else: # ball_stick
-                        resolution = self.mw.settings.get('ball_stick_resolution', 16)
-                except Exception:
-                    resolution = 16
-
-                glyphs = self.mw.glyph_source.glyph(
-                    scale='radii',
-                    geom=pv.Sphere(radius=1.0, theta_resolution=resolution, phi_resolution=resolution),
-                    orient=False
-                )
-                
-                # 2. Update the actor
-                if hasattr(self.mw, 'atom_actor') and self.mw.atom_actor:
-                    self.mw.plotter.remove_actor(self.mw.atom_actor)
-                
-                # Re-add mesh (copying properties logic from main_window_view_3d roughly)
-                is_lighting_enabled = self.mw.settings.get('lighting_enabled', True)
-                mesh_props = dict(
-                    smooth_shading=True,
-                    specular=self.mw.settings.get('specular', 0.2),
-                    specular_power=self.mw.settings.get('specular_power', 20),
-                    lighting=is_lighting_enabled,
-                )
-                
-                self.mw.atom_actor = self.mw.plotter.add_mesh(
-                    glyphs, scalars='colors', rgb=True, **mesh_props
-                )
-                
-                self.mw.plotter.render()
-        except Exception as e:
-            print(f"Error updating 3D actor: {e}")
-            traceback.print_exc()
-
     def apply_color(self):
         txt = self.le_indices.text().strip()
         if not txt:
@@ -227,321 +168,95 @@ class AtomColorizerWindow(QDialog):
             QMessageBox.warning(self, "Error", "Invalid indices format.")
             return
 
-        if not hasattr(self.mw, 'glyph_source') or self.mw.glyph_source is None:
-            QMessageBox.warning(self, "Error", "No 3D molecule found (glyph_source is None).")
+        if not self.mw.current_mol:
+            QMessageBox.warning(self, "Error", "No molecule loaded.")
             return
 
-        
-        # 1. Update glyph_source colors
         try:
-            if not hasattr(self.mw, 'custom_atom_colors'):
-                self.mw.custom_atom_colors = {}
-                
-            colors = self.mw.glyph_source.point_data['colors']
+            # Use the API to set atom colors
+            hex_color = self.current_color.name()
             
-            # Helper to normalize color to whatever format 'colors' is using
-            r, g, b = self.current_color.red(), self.current_color.green(), self.current_color.blue()
-            
-            # Store simple 0-255 list for persistence to avoid numpy type issues in JSON
-            stored_color = [r, g, b]
-            
-            # Check if colors are float (0-1) or uint8 (0-255)
-            is_float = (colors.dtype.kind == 'f')
-            
-            new_color_val = [r/255.0, g/255.0, b/255.0] if is_float else [r, g, b]
-
             for idx in target_indices:
-                if 0 <= idx < len(colors):
-                    colors[idx] = new_color_val
-                    # Update persistent storage
-                    self.mw.custom_atom_colors[idx] = stored_color
-            
-            # 2. Force update of the actor
-            self._update_3d_actor()
-            
+                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}")
+            QMessageBox.critical(self, "Error", f"Failed to apply color: {e}")
             traceback.print_exc()
 
     def reset_colors(self):
-        if not hasattr(self.mw, 'glyph_source') or self.mw.glyph_source is None:
-            return
         if not self.mw.current_mol:
             return
 
         try:
-            # Clear persistent storage
-            if hasattr(self.mw, 'custom_atom_colors'):
-                self.mw.custom_atom_colors = {}
-                
-            colors = self.mw.glyph_source.point_data['colors']
-            is_float = (colors.dtype.kind == 'f')
-
-            # Iterate atoms and reset to CPK
+            # Clear all color overrides using the API
             for i in range(self.mw.current_mol.GetNumAtoms()):
-                atom = self.mw.current_mol.GetAtomWithIdx(i)
-                sym = atom.GetSymbol()
-                # Get default color (float 0-1)
-                base_col = CPK_COLORS_PV.get(sym, [0.5, 0.5, 0.5])
+                if hasattr(self.mw, 'main_window_view_3d'):
+                    self.mw.main_window_view_3d.update_atom_color_override(i, None)
                 
-                if is_float:
-                    colors[i] = base_col
-                else:
-                    colors[i] = [int(c*255) for c in base_col]
-            
-            self._update_3d_actor()
-            
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Failed to reset colors: {e}")
 
 
-    def _restore_colors_from_file(self):
-        """
-        Check if the main window has a valid .pmeprj file open.
-        If so, read it manually to find 'custom_atom_colors' and apply them.
-        This handles the case where the file was loaded *before* this plugin started.
-        """
-        # If no file path or not a .pmeprj, ignore
-        if not hasattr(self.mw, 'current_file_path') or not self.mw.current_file_path:
-            return
-        if not self.mw.current_file_path.lower().endswith('.pmeprj'):
-            return
-        
-        # If we already have colors (unlikely if plugin just started, unless double-patched), skip
-        if hasattr(self.mw, 'custom_atom_colors') and self.mw.custom_atom_colors:
-            return
-
-        try:
-            with open(self.mw.current_file_path, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-            
-            if "3d_structure" in data and data["3d_structure"]:
-                raw_colors = data["3d_structure"].get("custom_atom_colors")
-                if raw_colors:
-                    custom_colors = {int(k): v for k, v in raw_colors.items()}
-                    
-                    # Apply to MainWindow
-                    self.mw.custom_atom_colors = custom_colors
-                    
-                    # Force update of 3D actor
-                    # We might need to ensure glyph_source is ready; assuming file load populated it.
-                    if hasattr(self.mw, 'glyph_source') and self.mw.glyph_source:
-                         # We need to manually inject these colors into the polydata
-                         colors = self.mw.glyph_source.point_data['colors']
-                         is_float = (colors.dtype.kind == 'f')
-
-                         for idx, col_val in custom_colors.items():
-                             if 0 <= idx < len(colors):
-                                 if is_float:
-                                     # If stored as 0-255 but buffer is float 0-1
-                                     if any(c > 1.0 for c in col_val):
-                                         colors[idx] = [c/255.0 for c in col_val]
-                                     else:
-                                         colors[idx] = col_val
-                                 else:
-                                      # If stored as float 0-1 but buffer is uint8
-                                      if all(c <= 1.0 for c in col_val):
-                                         colors[idx] = [int(c*255) for c in col_val]
-                                      else:
-                                         colors[idx] = col_val
-                         
-                         self._update_3d_actor()
-                         print(f"Atom Colorizer: Restored {len(custom_colors)} custom colors from file.")
-        except Exception as e:
-            print(f"Atom Colorizer: Failed to lazy-load colors from file: {e}")
-            traceback.print_exc()
-
 # Global reference to keep window alive
 _atom_colorizer_window = None
-_patches_installed = False
 
 def run(mw):
-    global _atom_colorizer_window, _patches_installed
-    
-    # Check if this is the first run (patches not installed)
-    first_run = not _patches_installed
-
-    # Install patches for persistence
-    install_patches(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())
     
-    # Only restore from file if this is the first execution
-    if first_run:
-        _atom_colorizer_window._restore_colors_from_file()
-
     _atom_colorizer_window.show()
     _atom_colorizer_window.raise_()
     _atom_colorizer_window.activateWindow()
 
-# initialize removed as it only registered the menu action
-
 def _cleanup_window():
     global _atom_colorizer_window
     _atom_colorizer_window = None
 
-def install_patches(mw):
+
+def initialize(context):
     """
-    Install monkey patches to core modules to ensure color persistence.
-    Checks `_patches_installed` to avoid double patching.
+    Register plugin save/load handlers for persistence.
     """
-    global _patches_installed
-    if _patches_installed:
-        return
-
-    # Initialize persistent storage on MainWindow if not present
-    if not hasattr(mw, 'custom_atom_colors'):
-        mw.custom_atom_colors = {} 
-
-    # --- Patch 1: MainWindowView3d.draw_molecule_3d ---
-    # Purpose: Re-apply colors after any redraw (e.g. style change, molecular edit)
-    # We patch the instance method on 'mw' which is the entry point for other modules.
-    
-    original_draw_3d = mw.draw_molecule_3d
-
-    def patched_draw_3d(mol):
-        # Call original
-        res = original_draw_3d(mol)
-        
-        # Apply custom colors if they exist
-        if hasattr(mw, 'custom_atom_colors') and mw.custom_atom_colors and hasattr(mw, 'glyph_source') and mw.glyph_source:
-             try:
-                import pyvista as pv # Ensure pyvista is available inside closure if needed
-                
-                colors = mw.glyph_source.point_data['colors']
-                is_float = (colors.dtype.kind == 'f')
-                
-                # 1. Update the source colors
-                for idx, col_val in mw.custom_atom_colors.items():
-                    if isinstance(idx, str): idx = int(idx)
-                    # Check index bounds
-                    if 0 <= idx < len(colors):
-                        if is_float:
-                            if any(c > 1.0 for c in col_val):
-                                colors[idx] = [c/255.0 for c in col_val]
-                            else:
-                                colors[idx] = col_val
-                        else:
-                             if all(c <= 1.0 for c in col_val):
-                                colors[idx] = [int(c*255) for c in col_val]
-                             else:
-                                colors[idx] = col_val
-                
-                # 2. Re-generate the actor (Glyph filter)
-                # Mimic common 3D view logic to respect resolution settings
-                try:
-                    style = getattr(mw, 'current_3d_style', 'cpk')
-                    if style == 'cpk':
-                        resolution = mw.settings.get('cpk_resolution', 32)
-                    elif style == 'stick':
-                        resolution = mw.settings.get('stick_resolution', 16)
-                    else: # ball_stick
-                        resolution = mw.settings.get('ball_stick_resolution', 16)
-                except Exception:
-                    resolution = 16
-
-                glyphs = mw.glyph_source.glyph(
-                    scale='radii',
-                    geom=pv.Sphere(radius=1.0, theta_resolution=resolution, phi_resolution=resolution),
-                    orient=False
-                )
-                
-                # Remove old actor
-                if hasattr(mw, 'atom_actor') and mw.atom_actor:
-                    mw.plotter.remove_actor(mw.atom_actor)
-                
-                # Add new actor
-                is_lighting_enabled = mw.settings.get('lighting_enabled', True)
-                mesh_props = dict(
-                    smooth_shading=True,
-                    specular=mw.settings.get('specular', 0.2),
-                    specular_power=mw.settings.get('specular_power', 20),
-                    lighting=is_lighting_enabled,
-                )
-                
-                mw.atom_actor = mw.plotter.add_mesh(
-                    glyphs, scalars='colors', rgb=True, **mesh_props
-                )
-                
-                # Force render
-                if hasattr(mw, 'plotter'):
-                    mw.plotter.render()
-
-             except Exception as e:
-                print(f"Patched draw_3d error: {e}")
-                traceback.print_exc()
-        return res
-
-    mw.draw_molecule_3d = patched_draw_3d
-
-    # --- Patch 2: MainWindowAppState.create_json_data ---
-    # Purpose: Save colors to .pmeprj
-    
-    original_create_json = mw.create_json_data
-    
-    def patched_create_json():
-        data = original_create_json()
-        if hasattr(mw, 'custom_atom_colors') and mw.custom_atom_colors:
-            if "3d_structure" in data and data["3d_structure"]:
-                data["3d_structure"]["custom_atom_colors"] = mw.custom_atom_colors
-        return data
-
-    mw.create_json_data = patched_create_json
-    
-    # --- Patch 3: MainWindowAppState.load_from_json_data ---
-    # Purpose: Load colors from .pmeprj
+    mw = context.get_main_window()
     
-    original_load_json = mw.load_from_json_data
-    
-    def patched_load_json(json_data):
-        # Extract custom colors
-        custom_colors = {}
-        if "3d_structure" in json_data and json_data["3d_structure"]:
-             raw_colors = json_data["3d_structure"].get("custom_atom_colors")
-             if raw_colors:
-                 # Ensure keys are ints (JSON keys are strings)
-                 custom_colors = {int(k): v for k, v in raw_colors.items()}
-        
-        # Set colors to mw BEFORE calling original logic 
-        # (because original logic calls draw_molecule_3d, which uses our patch)
-        mw.custom_atom_colors = custom_colors
-        
-        return original_load_json(json_data)
+    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 {}
         
-    mw.load_from_json_data = patched_load_json
-
-    # --- Patch 4: MainWindow.clear_all (New / Clear) ---
-    # Purpose: Reset colors when starting fresh
-    
-    original_clear_all = mw.clear_all
+        # Convert color overrides to JSON-serializable format
+        return {
+            "atom_colors": {str(k): v for k, v in mw._plugin_color_overrides.items()}
+        }
     
-    @functools.wraps(original_clear_all)
-    def patched_clear_all():
-        # Reset colors BEFORE clearing logic
-        if hasattr(mw, 'custom_atom_colors'):
-            mw.custom_atom_colors = {}
-        return original_clear_all()
+    def load_handler(data):
+        """Load color overrides from project file."""
+        if not data:
+            return
         
-    mw.clear_all = patched_clear_all
-    
-    # --- Patch 5: MainWindow.trigger_conversion (2D -> 3D) ---
-    # Purpose: Reset colors when generating new 3D structure
-    
-    original_trigger_conversion = mw.trigger_conversion
-    
-    @functools.wraps(original_trigger_conversion)
-    def patched_trigger_conversion():
-        # Reset colors because structure is being regenerated
-        if hasattr(mw, 'custom_atom_colors'):
-            mw.custom_atom_colors = {}
-        return original_trigger_conversion()
+        atom_colors = data.get("atom_colors", {})
         
-    mw.trigger_conversion = patched_trigger_conversion
+        # 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}")
     
-    _patches_installed = True
-    print("Atom Colorizer patches installed.")
+    # Register handlers
+    context.register_save_handler(save_handler)
+    context.register_load_handler(load_handler)

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()

{moleditpy-2.2.0a1.dist-info → moleditpy-2.2.0a2.dist-info}/METADATA

@@ -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.dist-info → moleditpy-2.2.0a2.dist-info}/RECORD

@@ -12,7 +12,7 @@ moleditpy/modules/bond_item.py,sha256=eVkEeKvM4igYI67DYxpey3FllqDyt_iWDo4VPYMhaP
 moleditpy/modules/bond_length_dialog.py,sha256=k5x_DhK9Q8CSwouKhEo_kLRRdaYHDaK84KDNmuDNLvY,14868
 moleditpy/modules/calculation_worker.py,sha256=KiGQY7i-QCQofEoE0r65KoQgpEGFcbhmxWv6egfkUdc,42324
 moleditpy/modules/color_settings_dialog.py,sha256=Ow44BhCOLo0AFb6klO001k6B4drOgKX9DeNBQhZLp5o,15474
-moleditpy/modules/constants.py,sha256=FeDinXswiCE3mVvn04ts1K8_wT2lsxft6PqIEAGHnSA,4704
+moleditpy/modules/constants.py,sha256=7m9mLA8eKnYh2PPXu5pXMtRndPdZVQdSej_WjMGpsrI,4704
 moleditpy/modules/constrained_optimization_dialog.py,sha256=IEdNVhFoNSEMeA5ABpUH9Q88-YzDXFloQM2gwnPwnHY,30150
 moleditpy/modules/custom_interactor_style.py,sha256=NjsXE2a43IDNEanZBlcG9eR4ZIERT1MsQC6lbfesapQ,38453
 moleditpy/modules/custom_qt_interactor.py,sha256=MFaTuDh-FPeFBS4303CqxsxmsOIOW4QXUz6USwI8PHQ,2451
@@ -29,7 +29,7 @@ moleditpy/modules/main_window_main_init.py,sha256=2MWBLY_u4UoSC4orjhDh1WcfR8FoWE
 moleditpy/modules/main_window_molecular_parsers.py,sha256=Ex4-urYsKf6PyHp4XToOhgXzuYWa_n7q--QmHci4OCU,48401
 moleditpy/modules/main_window_project_io.py,sha256=q1vEmWQDqla32HVkmk8-j0OY9ut5TI5NJ4ikahewkEo,17259
 moleditpy/modules/main_window_string_importers.py,sha256=mQVDv2Dj4MwnPgMRe2IqdAAKnB_quE6QfYeAgCjfv28,10892
-moleditpy/modules/main_window_ui_manager.py,sha256=dqnBzvYZdE5Da6x4IAeGYSgwHp4EUO13THudf2hUePo,22843
+moleditpy/modules/main_window_ui_manager.py,sha256=HofI6T9EvcSSzPbsdPqkYEEDoB6Hui1Uj2Ll-wwczGA,24016
 moleditpy/modules/main_window_view_3d.py,sha256=TKRerktpCTYxX9HU-dSOnIhx4OyZaVrRYj4pEOUXmGc,74088
 moleditpy/modules/main_window_view_loaders.py,sha256=Dbdgv4TY_ZkX8Qyaevwr-mBJYJ59CBzRTEks-U1FiGw,14462
 moleditpy/modules/mirror_dialog.py,sha256=c3v4qY6R4FAljzk4EPaDjL9ZdZMjLQSFLqDMXz2fBUk,4696
@@ -59,17 +59,17 @@ moleditpy/plugins/File/orca_out_freq_analyzer.py,sha256=6opjTpcK3B2XUIPk8fpOKlZ_
 moleditpy/plugins/File/paste_xyz.py,sha256=kV-_CMmXLcqMIyFNRAeiwsOECPE64GCizT3hDCNfaXk,15112
 moleditpy/plugins/Input Generator/gaussian_input_generator_neo.py,sha256=3EXzxcxmJmgxVF9F-jFOPYJksubUdxZxvmNoUx7DTW4,37769
 moleditpy/plugins/Input Generator/orca_input_generator_neo.py,sha256=vqMpwJ9NaUw2SLcSqgIhWpdUaaJjnBvWHc4S0vtA7FI,40013
-moleditpy/plugins/Input Generator/orca_xyz2inp_gui.py,sha256=bWwkLwauyXZkjxGMztdCgESnD3fZw0WsvqdNwnxDLes,11050
+moleditpy/plugins/Input Generator/orca_xyz2inp_gui.py,sha256=6d6v_UC9s-2bJihGqCX3usIplw-lOUVq96kEBf32S3g,11045
 moleditpy/plugins/Optimization/all-trans_optimizer.py,sha256=_7zAnYIRShPquIOFUf8_5N1o0g7iIXKFmcD0Eey8Lac,2532
 moleditpy/plugins/Optimization/complex_molecule_untangler.py,sha256=kGJ1nIWdLCcSxmKJOHLhTW4SAQSrESMkKsILeDqKbhA,10837
 moleditpy/plugins/Optimization/conf_search.py,sha256=equ6W02Yf2DAYSj1jSNeVrQSYPPpdlNrPDt3lm_Bek8,9110
-moleditpy/plugins/Utility/atom_colorizer.py,sha256=vysv-nmNZFVgfDA5tbJtMvEU2qkeHxrwNU7BxaEvePY,22824
+moleditpy/plugins/Utility/atom_colorizer.py,sha256=BUO-EkIeWwkGE6DtOuXgw0QkDABet_YfNXfpPZFWBlQ,9936
 moleditpy/plugins/Utility/console.py,sha256=4_WgDiEHhalDFOLJGmYNRa1odzxdtg46qr9DUz_ht4I,5943
 moleditpy/plugins/Utility/pubchem_ressolver.py,sha256=w1Zfm_2LTDhuU6uYKQSSaGpyU36-14kvDssc0L8hsDc,10048
-moleditpy/plugins/Utility/vdw_radii_overlay.py,sha256=TtufVe8Gowmpd2O-JmN4nECBoCphfcwXy4LlpVt_LMc,11390
-moleditpy-2.2.0a1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-moleditpy-2.2.0a1.dist-info/METADATA,sha256=IE4vrtPdPiLDEfMQfz_vV5bazWJvsglrxiN6gs8OKwk,59277
-moleditpy-2.2.0a1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-moleditpy-2.2.0a1.dist-info/entry_points.txt,sha256=yH1h9JjALhok1foXT3-hYrC4ufoZt8b7oiBcsdnGNNM,54
-moleditpy-2.2.0a1.dist-info/top_level.txt,sha256=ARICrS4ihlPXqywlKl6o-oJa3Qz3gZRWu_VZsQ3_c44,10
-moleditpy-2.2.0a1.dist-info/RECORD,,
+moleditpy/plugins/Utility/vdw_radii_overlay.py,sha256=C7cD82AiJIeaQk12gKjIt0oneJny2fDRAbw-t01vpEg,16533
+moleditpy-2.2.0a2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+moleditpy-2.2.0a2.dist-info/METADATA,sha256=0pjsuxHg7SWfSJWfdNf-0zi2R5j4fbG0s8KSPYWeE3s,59277
+moleditpy-2.2.0a2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+moleditpy-2.2.0a2.dist-info/entry_points.txt,sha256=yH1h9JjALhok1foXT3-hYrC4ufoZt8b7oiBcsdnGNNM,54
+moleditpy-2.2.0a2.dist-info/top_level.txt,sha256=ARICrS4ihlPXqywlKl6o-oJa3Qz3gZRWu_VZsQ3_c44,10
+moleditpy-2.2.0a2.dist-info/RECORD,,