MoleditPy-linux 2.1.1__py3-none-any.whl → 2.2.1__py3-none-any.whl

moleditpy_linux/modules/plugin_manager.py

@@ -1,6 +1,15 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
 """
 plugin_manager.py
 Manages discovery, loading, and execution of external plugins.
@@ -8,19 +17,48 @@ Manages discovery, loading, and execution of external plugins.
 
 import os
 import sys
+import shutil
 import importlib.util
 import traceback
+import ast
 from PyQt6.QtGui import QDesktopServices
 from PyQt6.QtCore import QUrl
 from PyQt6.QtWidgets import QMessageBox
 
+try:
+    from .plugin_interface import PluginContext
+except ImportError:
+    # Fallback if running as script
+    from modules.plugin_interface import PluginContext
+
 class PluginManager:
-    def __init__(self):
+    def __init__(self, main_window=None):
         self.plugin_dir = os.path.join(os.path.expanduser('~'), '.moleditpy', 'plugins')
-        self.plugins = [] # List of {"name": str, "module": module_obj}
+        self.plugins = [] # List of dicts
+        self.main_window = main_window
+        
+        # Registries for actions
+        self.menu_actions = [] # List of (plugin_name, path, callback, text, icon, shortcut)
+        self.toolbar_actions = [] 
+        self.drop_handlers = [] # List of (priority, plugin_name, callback)
+        
+        # Extended Registries (Added to prevent lazy initialization "monkey patching")
+        self.export_actions = [] 
+        self.optimization_methods = {}
+        self.file_openers = {}
+        self.analysis_tools = []
+        self.save_handlers = {}
+        self.load_handlers = {}
+        self.custom_3d_styles = {} # style_name -> {'plugin': name, 'callback': func}
+
+    def get_main_window(self):
+        return self.main_window
+
+    def set_main_window(self, mw):
+        self.main_window = mw
 
     def ensure_plugin_dir(self):
-        """Creates the plugin directory if it creates doesn't exist."""
+        """Creates the plugin directory if it doesn't exist."""
         if not os.path.exists(self.plugin_dir):
             try:
                 os.makedirs(self.plugin_dir)
@@ -32,14 +70,42 @@ class PluginManager:
         self.ensure_plugin_dir()
         QDesktopServices.openUrl(QUrl.fromLocalFile(self.plugin_dir))
 
+    def install_plugin(self, file_path):
+        """Copies a plugin file to the plugin directory."""
+        self.ensure_plugin_dir()
+        try:
+            filename = os.path.basename(file_path)
+            dest_path = os.path.join(self.plugin_dir, filename)
+            shutil.copy2(file_path, dest_path)
+            # Reload plugins after install
+            if self.main_window:
+                self.discover_plugins(self.main_window)
+            return True, f"Installed {filename}"
+        except Exception as e:
+            return False, str(e)
+
     def discover_plugins(self, parent=None):
         """
-        Recursively scans the plugin directory for .py files and attempts to import them.
-        Ignores __pycache__ and other directories starting with "__".
-        Returns a list of valid loaded plugins.
+        Recursively scans the plugin directory.
+        Supports both legacy autorun(parent) and new initialize(context).
         """
+        if parent:
+            self.main_window = parent
+            
         self.ensure_plugin_dir()
         self.plugins = []
+        self.menu_actions = []
+        self.toolbar_actions = []
+        self.drop_handlers = []
+        
+        # Clear extended registries
+        self.export_actions = [] 
+        self.optimization_methods = {}
+        self.file_openers = {}
+        self.analysis_tools = []
+        self.save_handlers = {}
+        self.load_handlers = {}
+        self.custom_3d_styles = {}
         
         if not os.path.exists(self.plugin_dir):
             return []
@@ -51,17 +117,11 @@ class PluginManager:
             for filename in files:
                 if filename.endswith(".py") and not filename.startswith("__"):
                     filepath = os.path.join(root, filename)
-                    
-                    # Calculate relative folder path for menu structure
-                    # equivalent to: rel_path = os.path.relpath(root, self.plugin_dir)
-                    # if root is plugin_dir, rel_path is '.'
                     rel_folder = os.path.relpath(root, self.plugin_dir)
                     if rel_folder == '.':
                         rel_folder = ""
                         
                     try:
-                        # Unique module name based on file path to avoid conflicts
-                        # e.g. plugins.subdir.myplugin
                         module_name = os.path.splitext(os.path.relpath(filepath, self.plugin_dir))[0].replace(os.sep, '.')
                         
                         spec = importlib.util.spec_from_file_location(module_name, filepath)
@@ -70,51 +130,180 @@ class PluginManager:
                             sys.modules[spec.name] = module 
                             spec.loader.exec_module(module)
 
-                            # Check for required attributes
+                            # --- Metadata Extraction ---
                             plugin_name = getattr(module, 'PLUGIN_NAME', filename[:-3])
+                            plugin_version = getattr(module, 'PLUGIN_VERSION', getattr(module, '__version__', 'Unknown'))
+                            plugin_author = getattr(module, 'PLUGIN_AUTHOR', getattr(module, '__author__', 'Unknown'))
+                            plugin_desc = getattr(module, 'PLUGIN_DESCRIPTION', getattr(module, '__doc__', ''))
                             
-                            # Valid plugin if it has 'run' OR 'autorun'
+                            # Clean up docstring if used as description
+                            if plugin_desc:
+                                plugin_desc = plugin_desc.strip().split('\n')[0]
+
+                            # check for interface compliance
                             has_run = hasattr(module, 'run') and callable(module.run)
                             has_autorun = hasattr(module, 'autorun') and callable(module.autorun)
-                             
-                            if has_run:
-                                self.plugins.append({
-                                    'name': plugin_name,
-                                    'module': module,
-                                    'rel_folder': rel_folder
-                                })
+                            has_init = hasattr(module, 'initialize') and callable(module.initialize)
+                            
+                            status = "Loaded"
                             
-                            if has_autorun:
+                            # Execute loading logic
+                            if has_init:
+                                context = PluginContext(self, plugin_name)
+                                try:
+                                    module.initialize(context)
+                                except Exception as e:
+                                    status = f"Error (Init): {e}"
+                                    print(f"Plugin {plugin_name} initialize error: {e}")
+                                    traceback.print_exc()
+                            elif has_autorun:
                                 try:
-                                    if parent:
-                                        module.autorun(parent)
+                                    if self.main_window:
+                                        module.autorun(self.main_window)
                                     else:
-                                        print(f"Skipping autorun for {plugin_name}: parent not provided.")
+                                        status = "Skipped (No MW)"
                                 except Exception as e:
-                                    print(f"Error executing autorun for {filename}: {e}")
+                                    status = f"Error (Autorun): {e}"
+                                    print(f"Plugin {plugin_name} autorun error: {e}")
                                     traceback.print_exc()
+                            elif not has_run:
+                                status = "No Entry Point"
 
-                            if not has_run and not has_autorun:
-                                print(f"Plugin {filename} skipped: Missing 'run(main_window)' or 'autorun(main_window)' function.")
-
+                            self.plugins.append({
+                                'name': plugin_name,
+                                'version': plugin_version,
+                                'author': plugin_author,
+                                'description': plugin_desc,
+                                'module': module,
+                                'rel_folder': rel_folder,
+                                'status': status,
+                                'filepath': filepath,
+                                'has_run': has_run # for menu manual run
+                            })
+                            
                     except Exception as e:
-                        # Robust error handling
-                        msg = f"Failed to load plugin {filename}:\n{e}"
-                        print(msg)
+                        print(f"Failed to load plugin {filename}: {e}")
                         traceback.print_exc()
-                        if parent:
-                            # Use print/status bar instead of popups for non-critical failures during bulk load?
-                            # For now, keep it visible but maybe less intrusive if many fail?
-                            # sticking to original logic just in catch block
-                            pass 
         
         return self.plugins
 
     def run_plugin(self, module, main_window):
-        """Executes the plugin's run method."""
+        """Executes the plugin's run method (Legacy manual trigger)."""
         try:
             module.run(main_window)
         except Exception as e:
             QMessageBox.critical(main_window, "Plugin Error", f"Error running plugin '{getattr(module, 'PLUGIN_NAME', 'Unknown')}':\n{e}")
             traceback.print_exc()
 
+    # --- Registration Callbacks ---
+    def register_menu_action(self, plugin_name, path, callback, text, icon, shortcut):
+        self.menu_actions.append({
+            'plugin': plugin_name, 'path': path, 'callback': callback,
+            'text': text, 'icon': icon, 'shortcut': shortcut
+        })
+    
+    def register_toolbar_action(self, plugin_name, callback, text, icon, tooltip):
+        self.toolbar_actions.append({
+            'plugin': plugin_name, 'callback': callback, 
+            'text': text, 'icon': icon, 'tooltip': tooltip
+        })
+
+
+        
+    def register_drop_handler(self, plugin_name, callback, priority):
+        self.drop_handlers.append({
+            'priority': priority, 'plugin': plugin_name, 'callback': callback
+        })
+        # Sort by priority desc
+        self.drop_handlers.sort(key=lambda x: x['priority'], reverse=True)
+
+    def register_export_action(self, plugin_name, label, callback):
+        self.export_actions.append({
+            'plugin': plugin_name, 'label': label, 'callback': callback
+        })
+
+    def register_optimization_method(self, plugin_name, method_name, callback):
+        # Key by upper-case method name for consistency
+        self.optimization_methods[method_name.upper()] = {
+            'plugin': plugin_name, 'callback': callback, 'label': method_name
+        }
+
+    def register_file_opener(self, plugin_name, extension, callback):
+        # Normalize extension to lowercase
+        ext = extension.lower()
+        if not ext.startswith('.'):
+            ext = '.' + ext
+        self.file_openers[ext] = {
+            'plugin': plugin_name, 'callback': callback
+        }
+
+    # Analysis Tools registration
+    def register_analysis_tool(self, plugin_name, label, callback):
+        self.analysis_tools.append({'plugin': plugin_name, 'label': label, 'callback': callback})
+
+    # State Persistence registration
+    def register_save_handler(self, plugin_name, callback):
+        self.save_handlers[plugin_name] = callback
+
+    def register_load_handler(self, plugin_name, callback):
+        self.load_handlers[plugin_name] = callback
+
+    def register_3d_style(self, plugin_name, style_name, callback):
+        self.custom_3d_styles[style_name] = {
+            'plugin': plugin_name, 'callback': callback
+        }
+
+    def get_plugin_info_safe(self, file_path):
+        """Extracts plugin metadata using AST parsing (safe, no execution)."""
+        info = {
+            'name': os.path.basename(file_path),
+            'version': 'Unknown',
+            'author': 'Unknown',
+            'description': ''
+        }
+        try:
+             with open(file_path, "r", encoding="utf-8") as f:
+                 tree = ast.parse(f.read())
+             
+             for node in tree.body:
+                 if isinstance(node, ast.Assign):
+                     for target in node.targets:
+                         if isinstance(target, ast.Name):
+                             # Helper to extract value
+                             val = None
+                             if isinstance(node.value, ast.Constant): # Py3.8+
+                                 val = node.value.value
+                             elif hasattr(ast, 'Str') and isinstance(node.value, ast.Str): # Py3.7 and below
+                                 val = node.value.s
+                             
+                             if val is not None:
+                                 if target.id == 'PLUGIN_NAME':
+                                     info['name'] = val
+                                 elif target.id == 'PLUGIN_VERSION':
+                                     info['version'] = val
+                                 elif target.id == 'PLUGIN_AUTHOR':
+                                     info['author'] = val
+                                 elif target.id == 'PLUGIN_DESCRIPTION':
+                                     info['description'] = val
+                                 elif target.id == '__version__' and info['version'] == 'Unknown':
+                                     info['version'] = val
+                                 elif target.id == '__author__' and info['author'] == 'Unknown':
+                                     info['author'] = val
+                 
+                 # Docstring extraction
+                 if isinstance(node, ast.Expr):
+                     val = None
+                     if isinstance(node.value, ast.Constant) and isinstance(node.value.value, str):
+                          val = node.value.value
+                     elif hasattr(ast, 'Str') and isinstance(node.value, ast.Str):
+                          val = node.value.s
+                          
+                     if val and not info['description']:
+                          info['description'] = val.strip().split('\n')[0]
+
+        except Exception as e:
+            print(f"Error parsing plugin info: {e}")
+        return info
+
+
+

moleditpy_linux/modules/plugin_manager_window.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+MoleditPy — A Python-based molecular editing software
+
+Author: Hiromichi Yokoyama
+License: GPL-3.0 license
+Repo: https://github.com/HiroYokoyama/python_molecular_editor
+DOI: 10.5281/zenodo.17268532
+"""
+
+import os
+import sys
+from PyQt6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QPushButton, QTableWidget, 
+    QTableWidgetItem, QHeaderView, QLabel, QFileDialog, QMessageBox, QAbstractItemView
+)
+from PyQt6.QtCore import Qt, QMimeData, QUrl
+from PyQt6.QtGui import QDragEnterEvent, QDropEvent, QDesktopServices
+
+class PluginManagerWindow(QDialog):
+    def __init__(self, plugin_manager, parent=None):
+        super().__init__(parent)
+        self.plugin_manager = plugin_manager
+        self.setWindowTitle("Plugin Manager")
+        self.resize(800, 500)
+        self.setAcceptDrops(True) # Enable drag & drop for the whole window
+        
+        self.init_ui()
+        self.refresh_plugin_list()
+
+    def init_ui(self):
+        layout = QVBoxLayout(self)
+        
+        # Header / Instruction
+        lbl_info = QLabel("Drag & Drop .py files here to install plugins.")
+        lbl_info.setStyleSheet("color: gray; font-style: italic;")
+        layout.addWidget(lbl_info)
+
+        # Plugin Table
+        self.table = QTableWidget()
+        self.table.setColumnCount(6)
+        self.table.setHorizontalHeaderLabels(["Status", "Name", "Version", "Author", "Location", "Description"])
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Interactive)
+        self.table.horizontalHeader().setSectionResizeMode(4, QHeaderView.ResizeMode.Interactive) 
+        self.table.horizontalHeader().setSectionResizeMode(5, QHeaderView.ResizeMode.Stretch) # Description stretches
+        self.table.setColumnWidth(1, 200) # Make Name column wider
+        self.table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.table.itemSelectionChanged.connect(self.update_button_state)
+        self.table.itemDoubleClicked.connect(self.show_plugin_details)
+        layout.addWidget(self.table)
+
+        # Buttons
+        btn_layout = QHBoxLayout()
+        
+        btn_reload = QPushButton("Reload Plugins")
+        btn_reload.clicked.connect(self.on_reload)
+        btn_layout.addWidget(btn_reload)
+        
+        btn_folder = QPushButton("Open Plugin Folder")
+        btn_folder.clicked.connect(self.plugin_manager.open_plugin_folder)
+        btn_layout.addWidget(btn_folder)
+        
+        self.btn_remove = QPushButton("Remove Plugin")
+        self.btn_remove.clicked.connect(self.on_remove_plugin)
+        self.btn_remove.setEnabled(False)
+        btn_layout.addWidget(self.btn_remove)
+
+        btn_explore = QPushButton("Explore Plugins Online")
+        btn_explore.clicked.connect(lambda: QDesktopServices.openUrl(QUrl("https://hiroyokoyama.github.io/moleditpy-plugins/explorer/")))
+        btn_layout.addWidget(btn_explore)
+
+        btn_close = QPushButton("Close")
+        btn_close.clicked.connect(self.close)
+        btn_layout.addStretch()
+        btn_layout.addWidget(btn_close)
+        
+        layout.addLayout(btn_layout)
+
+    def refresh_plugin_list(self):
+        self.table.setRowCount(0)
+        plugins = self.plugin_manager.plugins
+        
+        self.table.setRowCount(len(plugins))
+        for row, p in enumerate(plugins):
+            self.table.setItem(row, 0, QTableWidgetItem(str(p.get('status', 'Unknown'))))
+            self.table.setItem(row, 1, QTableWidgetItem(str(p.get('name', 'Unknown'))))
+            self.table.setItem(row, 2, QTableWidgetItem(str(p.get('version', ''))))
+            self.table.setItem(row, 3, QTableWidgetItem(str(p.get('author', ''))))
+            
+            # Location (Relative Path)
+            full_path = p.get('filepath', '')
+            rel_path = ""
+            if full_path:
+                try:
+                    rel_path = os.path.relpath(full_path, self.plugin_manager.plugin_dir)
+                except Exception:
+                    rel_path = os.path.basename(full_path)
+            self.table.setItem(row, 4, QTableWidgetItem(str(rel_path)))
+            
+            self.table.setItem(row, 5, QTableWidgetItem(str(p.get('description', ''))))
+            
+            # Simple color coding for status
+            status = str(p.get('status', ''))
+            color = None
+            if status.startswith("Error"):
+                color = Qt.GlobalColor.red
+            elif status == "Loaded":
+                color = Qt.GlobalColor.green
+            elif status == "No Entry Point":
+                color = Qt.GlobalColor.gray
+            
+            if color:
+                self.table.item(row, 0).setForeground(color)
+
+    def update_button_state(self):
+        has_selection = (self.table.currentRow() >= 0)
+        if hasattr(self, 'btn_remove'):
+            self.btn_remove.setEnabled(has_selection)
+
+    def on_reload(self):
+        # Trigger reload in main manager
+        if self.plugin_manager.main_window:
+            self.plugin_manager.discover_plugins(self.plugin_manager.main_window)
+            self.refresh_plugin_list()
+            # Also update main window menu if possible, but that might require a callback or signal
+            # For now we assume discover_plugins re-runs autoruns which might duplicate stuff if not careful?
+            # Actually discover_plugins clears lists, so re-running is safe logic-wise, 
+            # but main_window need to rebuild its menu.
+            # We will handle UI rebuild in the main window code by observing or callback.
+            
+            # For immediate feedback:
+            QMessageBox.information(self, "Reloaded", "Plugins have been reloaded.")
+        else:
+            self.plugin_manager.discover_plugins()
+            self.refresh_plugin_list()
+
+    def on_remove_plugin(self):
+        row = self.table.currentRow()
+        if row < 0:
+            QMessageBox.warning(self, "Warning", "Please select a plugin to remove.")
+            return
+
+        # Assuming table row index matches plugins list index (confirmed in refresh_plugin_list)
+        if row < len(self.plugin_manager.plugins):
+            plugin = self.plugin_manager.plugins[row]
+            filepath = plugin.get('filepath')
+            
+            if filepath and os.path.exists(filepath):
+               reply = QMessageBox.question(self, "Remove Plugin", 
+                                            f"Are you sure you want to remove '{plugin.get('name', 'Unknown')}'?\n\nFile: {filepath}\nThis cannot be undone.", 
+                                            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+               if reply == QMessageBox.StandardButton.Yes:
+                   try:
+                       os.remove(filepath)
+                       self.on_reload() # Reload list and plugins
+                       QMessageBox.information(self, "Success", f"Removed '{plugin.get('name', 'Unknown')}'.")
+                   except Exception as e:
+                       QMessageBox.critical(self, "Error", f"Failed to delete file: {e}")
+            else:
+               QMessageBox.warning(self, "Error", f"Plugin file not found:\n{filepath}")
+
+    def show_plugin_details(self, item):
+        row = item.row()
+        if row < len(self.plugin_manager.plugins):
+            p = self.plugin_manager.plugins[row]
+            msg = f"Name: {p.get('name', 'Unknown')}\n" \
+                  f"Version: {p.get('version', 'Unknown')}\n" \
+                  f"Author: {p.get('author', 'Unknown')}\n" \
+                  f"Status: {p.get('status', 'Unknown')}\n" \
+                  f"Location: {p.get('filepath', 'Unknown')}\n\n" \
+                  f"Description:\n{p.get('description', 'No description available.')}"
+            QMessageBox.information(self, "Plugin Details", msg)
+
+    # --- Drag & Drop Support ---
+    def dragEnterEvent(self, event: QDragEnterEvent):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            event.ignore()
+
+    def dropEvent(self, event: QDropEvent):
+        files_installed = []
+        errors = []
+        for url in event.mimeData().urls():
+            file_path = url.toLocalFile()
+            if os.path.isfile(file_path) and file_path.endswith('.py'):
+                # Extract info and confirm
+                info = self.plugin_manager.get_plugin_info_safe(file_path)
+                msg = (f"Do you want to install this plugin?\n\n"
+                       f"Name: {info['name']}\n"
+                       f"Author: {info['author']}\n"
+                       f"Version: {info['version']}\n"
+                       f"Description: {info['description']}\n\n"
+                       f"File: {os.path.basename(file_path)}")
+                
+                reply = QMessageBox.question(self, "Install Plugin?", msg, 
+                                             QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+                
+                if reply == QMessageBox.StandardButton.Yes:
+                    success, msg = self.plugin_manager.install_plugin(file_path)
+                    if success:
+                        files_installed.append(msg)
+                    else:
+                        errors.append(msg)
+        
+        if files_installed or errors:
+            self.refresh_plugin_list()
+            summary = ""
+            if files_installed:
+                summary += "Installed:\n" + "\n".join(files_installed) + "\n\n"
+            if errors:
+                summary += "Errors:\n" + "\n".join(errors)
+            
+            QMessageBox.information(self, "Plugin Installation", summary)
+

moleditpy_linux/modules/template_preview_item.py

@@ -88,12 +88,9 @@ class TemplatePreviewItem(QGraphicsItem):
             return
         
         # Draw bonds first with better visibility
-        # Bond preview color may also follow the configured bond color
-        try:
-            bond_hex = self.scene().window.settings.get('bond_color', '#222222')
-            bond_pen = QPen(QColor(bond_hex), 2.5)
-        except Exception:
-            bond_pen = QPen(QColor(100, 100, 100, 200), 2.5)
+        # Draw bonds first with better visibility
+        # Use gray (ghost) color for template preview to distinguish from real bonds
+        bond_pen = QPen(QColor(80, 80, 80, 180), 2.5)
         painter.setPen(bond_pen)
         
         for bond_info in self.user_template_bonds:

moleditpy_linux/modules/user_template_dialog.py

@@ -81,10 +81,68 @@ class UserTemplateDialog(QDialog):
         button_layout.addWidget(self.delete_button)
         
         close_button = QPushButton("Close")
-        close_button.clicked.connect(self.accept)
+        close_button.clicked.connect(self.close)
         button_layout.addWidget(close_button)
         
         layout.addLayout(button_layout)
+
+    def closeEvent(self, event):
+        """ダイアログクローズ時にモードをリセット"""
+        self.cleanup_template_mode()
+        super().closeEvent(event)
+
+    def cleanup_template_mode(self):
+        """テンプレートモードを終了し、atom_C(炭素描画)モードに戻す (Defensive implementation)"""
+        # 1. Reset Dialog State
+        self.selected_template = None
+        if hasattr(self, 'delete_button'):
+            self.delete_button.setEnabled(False)
+
+        # 2. Reset Main Window Mode (UI/Toolbar)
+        target_mode = 'atom_C'
+        try:
+            if hasattr(self.main_window, 'set_mode_and_update_toolbar'):
+                 self.main_window.set_mode_and_update_toolbar(target_mode)
+            elif hasattr(self.main_window, 'set_mode'):
+                 self.main_window.set_mode(target_mode)
+            
+            # Fallback: set attribute directly if methods fail/don't exist
+            if hasattr(self.main_window, 'mode'):
+                self.main_window.mode = target_mode
+        except Exception as e:
+            logging.error(f"Error resetting main window mode: {e}")
+
+        # 3. Reset Scene State (The Source of Truth)
+        try:
+            if hasattr(self.main_window, 'scene') and self.main_window.scene:
+                 scene = self.main_window.scene
+                 
+                 # A. FORCE MODE
+                 scene.mode = target_mode
+                 scene.current_atom_symbol = 'C'
+                 
+                 # B. Clear Data
+                 if hasattr(scene, 'user_template_data'):
+                     scene.user_template_data = None
+                 if hasattr(scene, 'template_context'):
+                     scene.template_context = {}
+                 
+                 # C. Clear/Hide Preview Item
+                 if hasattr(scene, 'clear_template_preview'):
+                     scene.clear_template_preview()
+                 
+                 if hasattr(scene, 'template_preview') and scene.template_preview:
+                     scene.template_preview.hide()
+                     
+                 # D. Reset Cursor & View
+                 if scene.views():
+                     view = scene.views()[0]
+                     view.setCursor(Qt.CursorShape.CrossCursor)
+                     view.viewport().update()
+                 
+                 scene.update()
+        except Exception as e:
+            logging.error(f"Error cleaning up scene state: {e}")
     
     def resizeEvent(self, event):
         """ダイアログリサイズ時にテンプレートプレビューを再フィット"""

{moleditpy_linux-2.1.1.dist-info → moleditpy_linux-2.2.1.dist-info}/METADATA

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