MoleditPy 2.1.1__py3-none-any.whl → 2.2.0a0__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.1.1'
+VERSION = '2.2.0a0'
 
 ATOM_RADIUS = 18
 BOND_OFFSET = 3.5

moleditpy/modules/main_window.py

@@ -600,6 +600,14 @@ class MainWindow(QMainWindow):
         # --- MOVED TO main_window_view_3d.py ---
         return self.main_window_view_3d.fit_to_view()
 
+    def draw_standard_3d_style(self, mol, style_override=None):
+        # --- MOVED TO main_window_view_3d.py ---
+        return self.main_window_view_3d.draw_standard_3d_style(mol, style_override)
+
+    def clear_measurement_selection(self):
+        # --- MOVED TO main_window_view_3d.py ---
+        return self.main_window_view_3d.clear_measurement_selection()
+
     def toggle_3d_edit_mode(self, checked):
         # --- MOVED TO main_window_ui_manager.py ---
         return self.main_window_ui_manager.toggle_3d_edit_mode(checked)

moleditpy/modules/main_window_app_state.py

@@ -595,6 +595,20 @@ class MainWindowAppState(object):
         except Exception:
             json_data["last_successful_optimization_method"] = None
         
+        # Plugin State Persistence (Phase 3)
+        if self.plugin_manager and self.plugin_manager.save_handlers:
+            plugin_data = {}
+            for name, callback in self.plugin_manager.save_handlers.items():
+                try:
+                    p_state = callback()
+                    # Ensure serializable? Use primitive types ideally.
+                    plugin_data[name] = p_state
+                except Exception as e:
+                    print(f"Error saving state for plugin {name}: {e}")
+            
+            if plugin_data:
+                json_data['plugins'] = plugin_data
+
         return json_data
 
 
@@ -614,6 +628,16 @@ class MainWindowAppState(object):
         except Exception:
             self.last_successful_optimization_method = None
 
+        # Plugin State Restoration (Phase 3)
+        if "plugins" in json_data and self.plugin_manager and self.plugin_manager.load_handlers:
+            plugin_data = json_data["plugins"]
+            for name, p_state in plugin_data.items():
+                if name in self.plugin_manager.load_handlers:
+                    try:
+                        self.plugin_manager.load_handlers[name](p_state)
+                    except Exception as e:
+                        print(f"Error loading state for plugin {name}: {e}")
+
 
         # 2D構造データの復元
         if "2d_structure" in json_data:

moleditpy/modules/main_window_compute.py

@@ -145,6 +145,11 @@ class MainWindowCompute(object):
         """右クリックで表示する一時的な3D変換メニュー。
         選択したモードは一時フラグとして保持され、その後の変換で使用されます（永続化しません）。
         """
+        # If button is disabled (during calculation), do not show menu
+        if not self.convert_button.isEnabled():
+            return
+
+
         try:
             menu = QMenu(self)
             conv_options = [
@@ -203,6 +208,16 @@ class MainWindowCompute(object):
                 a.triggered.connect(lambda checked=False, k=key: self._trigger_optimize_with_temp_method(k))
                 menu.addAction(a)
 
+            # Add Plugin Optimization Methods
+            if hasattr(self.mw, 'plugin_manager') and self.mw.plugin_manager.optimization_methods:
+                methods = self.mw.plugin_manager.optimization_methods
+                if methods:
+                     menu.addSeparator()
+                     for method_name, info in methods.items():
+                         a = QAction(info.get('label', method_name), self)
+                         a.triggered.connect(lambda checked=False, k=method_name: self._trigger_optimize_with_temp_method(k))
+                         menu.addAction(a)
+                         
             menu.exec_(self.optimize_3d_button.mapToGlobal(pos))
         except Exception as e:
             print(f"Error showing optimize menu: {e}")
@@ -765,6 +780,18 @@ class MainWindowCompute(object):
                 except Exception as e:
                     self.statusBar().showMessage(f"UFF (RDKit) optimization error: {e}")
                     return
+            # Plugin method dispatch
+            elif hasattr(self.mw, 'plugin_manager') and hasattr(self.mw.plugin_manager, 'optimization_methods') and method in self.mw.plugin_manager.optimization_methods:
+                info = self.mw.plugin_manager.optimization_methods[method]
+                callback = info['callback']
+                try:
+                     success = callback(self.current_mol)
+                     if not success:
+                         self.statusBar().showMessage(f"Optimization method '{method}' returned failure.")
+                         return
+                except Exception as e:
+                     self.statusBar().showMessage(f"Plugin optimization error ({method}): {e}")
+                     return
             else:
                 self.statusBar().showMessage("Selected optimization method is not available. Use MMFF94 (RDKit) or UFF (RDKit).")
                 return

moleditpy/modules/main_window_main_init.py

@@ -328,7 +328,7 @@ class MainWindowMainInit(object):
         else:
             print(f"警告: アイコンファイルが見つかりません: {icon_path}")
 
-        self.init_menu_bar()
+
 
         self.splitter = QSplitter(Qt.Orientation.Horizontal)
         # スプリッターハンドルを太くして視認性を向上
@@ -395,10 +395,11 @@ class MainWindowMainInit(object):
         self.plotter.setSizePolicy(
             QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding
         )
+        self.plotter.setContextMenuPolicy(Qt.ContextMenuPolicy.NoContextMenu)
+        
         # 2. 垂直レイアウトに3Dビューを追加
         right_layout.addWidget(self.plotter, 1)
         #self.plotter.installEventFilter(self)
-
         # 3. ボタンをまとめるための「水平」レイアウトを作成
         right_buttons_layout = QHBoxLayout()
 
@@ -414,6 +415,7 @@ class MainWindowMainInit(object):
             self.optimize_3d_button.customContextMenuRequested.connect(self.show_optimize_menu)
         except Exception:
             pass
+            pass
         right_buttons_layout.addWidget(self.optimize_3d_button)
 
         # エクスポートボタン (メニュー付き)
@@ -467,6 +469,9 @@ class MainWindowMainInit(object):
         # Keep a reference to the main toolbar for later updates
         self.toolbar = toolbar
 
+        # Now that toolbar exists, initialize menu bar (which might add toolbar actions from plugins)
+        # self.init_menu_bar() - Moved down
+
         # Templates toolbar: place it directly below the main toolbar (second row at the top)
         # Use addToolBarBreak to ensure this toolbar appears on the next row under the main toolbar.
         # Some older PyQt/PySide versions may not have addToolBarBreak; fall back silently in that case.
@@ -480,6 +485,20 @@ class MainWindowMainInit(object):
         toolbar_bottom = QToolBar("Templates Toolbar")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, toolbar_bottom)
         self.toolbar_bottom = toolbar_bottom
+
+        # Plugin Toolbar (Third Row)
+        try:
+            self.addToolBarBreak(Qt.ToolBarArea.TopToolBarArea)
+        except Exception:
+            pass
+
+        self.plugin_toolbar = QToolBar("Plugin Toolbar")
+        self.addToolBar(Qt.ToolBarArea.TopToolBarArea, self.plugin_toolbar)
+        self.plugin_toolbar.hide()
+        
+        # Initialize menu bar (and populate toolbars) AFTER all toolbars are created
+        self.init_menu_bar()
+
         self.tool_group = QActionGroup(self)
         self.tool_group.setExclusive(True)
 
@@ -853,30 +872,31 @@ class MainWindowMainInit(object):
         
         file_menu.addSeparator()
         
+        
         # === インポート ===
-        import_menu = file_menu.addMenu("Import")
+        self.import_menu = file_menu.addMenu("Import")
         
         load_mol_action = QAction("MOL/SDF File...", self)
         load_mol_action.triggered.connect(self.load_mol_file)
-        import_menu.addAction(load_mol_action)
+        self.import_menu.addAction(load_mol_action)
         
         import_smiles_action = QAction("SMILES...", self)
         import_smiles_action.triggered.connect(self.import_smiles_dialog)
-        import_menu.addAction(import_smiles_action)
+        self.import_menu.addAction(import_smiles_action)
         
         import_inchi_action = QAction("InChI...", self)
         import_inchi_action.triggered.connect(self.import_inchi_dialog)
-        import_menu.addAction(import_inchi_action)
+        self.import_menu.addAction(import_inchi_action)
         
-        import_menu.addSeparator()
+        self.import_menu.addSeparator()
         
         load_3d_mol_action = QAction("3D MOL/SDF (3D View Only)...", self)
         load_3d_mol_action.triggered.connect(self.load_mol_file_for_3d_viewing)
-        import_menu.addAction(load_3d_mol_action)
+        self.import_menu.addAction(load_3d_mol_action)
         
         load_3d_xyz_action = QAction("3D XYZ (3D View Only)...", self)
         load_3d_xyz_action.triggered.connect(self.load_xyz_for_3d_viewing)
-        import_menu.addAction(load_3d_xyz_action)
+        self.import_menu.addAction(load_3d_xyz_action)
         
         # === エクスポート ===
         export_menu = file_menu.addMenu("Export")
@@ -1204,16 +1224,16 @@ class MainWindowMainInit(object):
         # Plugin menu
         plugin_menu = menu_bar.addMenu("&Plugin")
         
-        open_plugin_dir_action = QAction("Open Plugin Directory", self)
-        if self.plugin_manager:
-            open_plugin_dir_action.triggered.connect(self.plugin_manager.open_plugin_folder)
-        else:
-            open_plugin_dir_action.setEnabled(False)
-        plugin_menu.addAction(open_plugin_dir_action)
-        
-        reload_plugins_action = QAction("Reload Plugins", self)
-        reload_plugins_action.triggered.connect(lambda: self.update_plugin_menu(plugin_menu))
-        plugin_menu.addAction(reload_plugins_action)
+        # Only keep the Manager action, moving others to the Manager Window
+        manage_plugins_action = QAction("Plugin Manager...", self)
+        def show_plugin_manager():
+            from .plugin_manager_window import PluginManagerWindow
+            dlg = PluginManagerWindow(self.plugin_manager, self)
+            dlg.exec()
+            self.update_plugin_menu(plugin_menu) # Refresh after closing
+        manage_plugins_action.triggered.connect(show_plugin_manager)
+        plugin_menu.addAction(manage_plugins_action)
+
 
 
         
@@ -1386,6 +1406,8 @@ class MainWindowMainInit(object):
         )
         help_menu.addAction(manual_action)
 
+
+
         # 3D関連機能の初期状態を統一的に設定
         self._enable_3d_features(False)
         
@@ -1418,7 +1440,27 @@ class MainWindowMainInit(object):
         if not file_path or not os.path.exists(file_path):
             return
         
-        file_ext = file_path.lower().split('.')[-1]
+        # Helper for extension
+        _, ext_with_dot = os.path.splitext(file_path)
+        ext_with_dot = ext_with_dot.lower()
+        # Legacy variable name (no dot)
+        file_ext = ext_with_dot.lstrip('.')
+
+        # 1. Custom Plugin Openers
+        # 1. Custom Plugin Openers
+        if ext_with_dot in self.plugin_manager.file_openers:
+            opener = self.plugin_manager.file_openers[ext_with_dot]
+            try:
+                opener['callback'](file_path)
+                self.current_file_path = file_path
+                self.update_window_title()
+                return
+            except Exception as e:
+                print(f"Plugin opener failed: {e}")
+                QMessageBox.warning(self, "Plugin Error", f"Error opening file with plugin '{opener.get('plugin', 'Unknown')}':\n{e}")
+                # Fallback to standard logic if plugin fails? Or stop?
+                # Generally if a plugin claims it, we stop. But here we let it fall through if it errors?
+                # Let's simple check next.
         
         if file_ext in ['mol', 'sdf']:
             self.load_mol_file_for_3d_viewing(file_path)
@@ -1717,26 +1759,88 @@ class MainWindowMainInit(object):
         # Clear existing plugin actions
         plugin_menu.clear()
         
-        # Re-add static actions
-        open_plugin_dir_action = QAction("Open Plugin Directory", self)
-        open_plugin_dir_action.triggered.connect(self.plugin_manager.open_plugin_folder)
-        plugin_menu.addAction(open_plugin_dir_action)
-        
-        reload_plugins_action = QAction("Reload Plugins", self)
-        reload_plugins_action.triggered.connect(lambda: self.update_plugin_menu(plugin_menu))
-        plugin_menu.addAction(reload_plugins_action)
-
-        explore_plugins_action = QAction("Explore Plugins", self)
-        explore_plugins_action.triggered.connect(
-            lambda: QDesktopServices.openUrl(QUrl("https://hiroyokoyama.github.io/moleditpy-plugins/explorer/"))
-        )
-        plugin_menu.addAction(explore_plugins_action)
+        # Only keep the Manager action
+        manage_plugins_action = QAction("Plugin Manager...", self)
+        def show_plugin_manager():
+            from .plugin_manager_window import PluginManagerWindow
+            dlg = PluginManagerWindow(self.plugin_manager, self)
+            dlg.exec()
+            self.update_plugin_menu(plugin_menu) # Refresh after closing
+        manage_plugins_action.triggered.connect(show_plugin_manager)
+        plugin_menu.addAction(manage_plugins_action)
         
         plugin_menu.addSeparator()
         
-        # Add dynamic plugin actions
+        # Add dynamic plugin actions (Legacy + New Registration)
         plugins = self.plugin_manager.discover_plugins(self)
         
+        # 1. Add Registered Menu Actions (New System)
+        if self.plugin_manager.menu_actions:
+             for action_def in self.plugin_manager.menu_actions:
+                 path = action_def['path']
+                 callback = action_def['callback']
+                 text = action_def['text']
+                 # Create/Find menu path
+                 current_menu = self.menuBar() # Or find specific top-level
+                 
+                 # Handling top-level menus vs nested
+                 parts = path.split('/')
+                 
+                 # If path starts with existing top-level (File, Edit, etc), grab it
+                 # Otherwise create new top-level
+                 top_level_title = parts[0]
+                 found_top = False
+                 for act in self.menuBar().actions():
+                     if act.menu() and act.text().replace('&', '') == top_level_title:
+                         current_menu = act.menu()
+                         found_top = True
+                         break
+                 
+                 if not found_top:
+                     current_menu = self.menuBar().addMenu(top_level_title)
+                 
+                 # Traverse rest
+                 for part in parts[1:]:
+                      found_sub = False
+                      for act in current_menu.actions():
+                          if act.menu() and act.text().replace('&', '') == part:
+                              current_menu = act.menu()
+                              found_sub = True
+                              break
+                      if not found_sub:
+                          current_menu = current_menu.addMenu(part)
+                 
+                 # Add action
+                 action_text = text if text else parts[-1]
+                 action = QAction(action_text, self)
+                 action.triggered.connect(callback)
+                 current_menu.addAction(action)
+
+        # 2. Add Toolbar Buttons (New System)
+        # 2. Add Toolbar Buttons (New System)
+        # Use dedicated plugin toolbar
+        if hasattr(self, 'plugin_toolbar'):
+             self.plugin_toolbar.clear()
+
+             if self.plugin_manager.toolbar_actions:
+                 self.plugin_toolbar.show()
+                 for action_def in self.plugin_manager.toolbar_actions:
+                     text = action_def['text']
+                     callback = action_def['callback']
+                     
+                     action = QAction(text, self)
+                     action.triggered.connect(callback)
+                     if action_def['icon']:
+                          if os.path.exists(action_def['icon']):
+                               action.setIcon(QIcon(action_def['icon']))
+                     if action_def['tooltip']:
+                          action.setToolTip(action_def['tooltip'])
+                     self.plugin_toolbar.addAction(action)
+             else:
+                 self.plugin_toolbar.hide()
+
+        # 3. Legacy Menu Building (Folder based)
+        
         if not plugins:
             no_plugin_action = QAction("(No plugins found)", self)
             no_plugin_action.setEnabled(False)
@@ -1750,28 +1854,142 @@ class MainWindowMainInit(object):
             menus = { "": plugin_menu }
 
             for p in plugins:
-                rel_folder = p.get('rel_folder', "")
+                # Only add legacy plugins (with 'run' function) to the generic Plugins menu.
+                # New plugins (with 'initialize') should register their own menu actions if needed.
+                if hasattr(p['module'], 'run'):
+                    rel_folder = p.get('rel_folder', '')
+                    # Get or create the parent menu for this plugin
+                    parent_menu = menus.get("") # Start at root
+                    
+                    if rel_folder:
+                        # Split path and traverse/create submenus
+                        parts = rel_folder.split(os.sep)
+                        current_path = ""
+                        for part in parts:
+                            new_path = os.path.join(current_path, part) if current_path else part
+                            
+                            if new_path not in menus:
+                                # Create new submenu
+                                sub_menu = parent_menu.addMenu(part)
+                                menus[new_path] = sub_menu
+                            
+                            parent_menu = menus[new_path]
+                            current_path = new_path
+
+                    # Add action to the resolved parent_menu
+                    action = QAction(p['name'], self)
+                    action.triggered.connect(lambda checked, mod=p['module']: self.plugin_manager.run_plugin(mod, self.mw if hasattr(self, 'mw') else self)) 
+                    parent_menu.addAction(action)
+
+        # 4. Integrate Export Actions into Export Button and Menu
+        if self.plugin_manager.export_actions:
+            # Add separator if we have custom exports (and haven't added it yet for this session/update)
+            # Since update_plugin_menu clears the dynamic plugin actions but NOT the export menu (which is on a button),
+            # we need to be careful not to duplicate.
+            # Ideally, we should clear custom actions from the export menu first.
+            # For simplicity, we'll just check existence.
+            
+            if hasattr(self, 'export_button') and self.export_button.menu():
+                # Naive approach: check if separator/actions exist. 
+                # Better approach: Add them to a specific section or manage them explicitly.
+                # Here we just append if not present.
                 
+                # Check if we need a separator (if we have built-in actions)
+                if self.export_button.menu().actions():
+                     has_sep = False
+                     for a in self.export_button.menu().actions():
+                         if a.isSeparator():
+                             has_sep = True
                 # Get or create the parent menu for this plugin
-                parent_menu = menus.get("") # Start at root
+                # For folder based hierarchy only?
+                # ... (Refer to existing code for menu building, skipped here for brevity)
+                pass
+
+        # 5. Integrate File Openers into Import Menu
+        if hasattr(self, 'import_menu') and self.plugin_manager.file_openers:
+             # Add a separator if plugins are present
+             has_plugins = len(self.plugin_manager.file_openers) > 0
+             if has_plugins:
+                 self.import_menu.addSeparator()
+                 
+             for ext, info in self.plugin_manager.file_openers.items():
+                 # ext e.g. .xyz
+                 # info = {'plugin': name, 'callback': cb}
+                 label = f"Import {ext} ({info.get('plugin', 'Plugin')})..."
+                 
+                 # duplicate check
+                 exists = False
+                 for act in self.import_menu.actions():
+                     if act.text() == label:
+                         exists = True
+                         break
+                 
+                 if not exists:
+                     def make_cb(callback):
+                         def _cb():
+                             # Standard file dialog to pick file, then callback
+                             fpath, _ = QFileDialog.getOpenFileName(
+                                 self, f"Import {ext}", "", 
+                                 f"{info.get('plugin', 'Plugin')} File (*{ext});;All Files (*)"
+                             )
+                             if fpath:
+                                 callback(fpath)
+                                 self.current_file_path = fpath # Update current file path?
+                                 self.update_window_title()
+                         return _cb
+
+                     a = QAction(label, self)
+                     a.triggered.connect(make_cb(info['callback']))
+                     self.import_menu.addAction(a)
+    
+        # 6. Integrate Analysis Tools into Analysis Menu
+        if hasattr(self, 'analysis_action') and self.plugin_manager.analysis_tools:
+             # Determine parent menu (Analysis)
+             # self.analysis_action is just an action, we need the menu it belongs to? 
+             # Or did we stash the analysis_menu?
+             # Looking at init, analysis_menu wasn't stored as self.analysis_menu, but we can find it via menuBar.
+             
+             # Let's find "Analysis" menu
+             analysis_menu = None
+             for action in self.menuBar().actions():
+                 if action.text().replace('&', '') == 'Analysis':
+                     analysis_menu = action.menu()
+                     break
+            
+             if analysis_menu:
+                 # Add separator if we have plugins
+                 if self.plugin_manager.analysis_tools:
+                     analysis_menu.addSeparator()
+                     
+                 for tool in self.plugin_manager.analysis_tools:
+                     label = f"{tool['label']} ({tool.get('plugin', 'Plugin')})"
+                     # duplicate check
+                     exists = False
+                     for act in analysis_menu.actions():
+                         if act.text() == label:
+                             exists = True
+                             break
+                     if not exists:
+                         a = QAction(label, self)
+                         a.triggered.connect(tool['callback'])
+                         analysis_menu.addAction(a)
+
+        # 7. Integrate Export Actions (Continued)
+        if self.plugin_manager.export_actions:
+            for exp in self.plugin_manager.export_actions:
+                label = exp['label']
+                callback = exp['callback']
+                
+                exists = False
+                for act in self.export_button.menu().actions():
+                    if act.text() == label:
+                        exists = True
+                        break
                 
-                if rel_folder:
-                    # Split path and traverse/create submenus
-                    parts = rel_folder.split(os.sep)
-                    current_path = ""
-                    for part in parts:
-                        new_path = os.path.join(current_path, part) if current_path else part
-                        
-                        if new_path not in menus:
-                            # Create new submenu
-                            sub_menu = parent_menu.addMenu(part)
-                            menus[new_path] = sub_menu
-                        
-                        parent_menu = menus[new_path]
-                        current_path = new_path
-
-                # Add action to the resolved parent_menu
-                action = QAction(p['name'], self)
-                action.triggered.connect(lambda checked, mod=p['module']: self.plugin_manager.run_plugin(mod, self.mw if hasattr(self, 'mw') else self)) 
-                parent_menu.addAction(action)
+                if not exists:
+                    a = QAction(label, self)
+                    a.triggered.connect(callback)
+                    self.export_button.menu().addAction(a)
+
+        # 5. Integrate File Openers (Implicitly handled during file load) uses PluginManager directly
 

moleditpy/modules/main_window_ui_manager.py

@@ -83,7 +83,7 @@ class MainWindowUiManager(object):
 
     def __init__(self, main_window):
         """ クラスの初期化 """
-        self.mw = main_window
+        self = main_window
 
 
     def update_status_bar(self, message):
@@ -330,6 +330,17 @@ class MainWindowUiManager(object):
                     continue
 
         if file_path:
+            # 1. Custom Plugin Handlers
+            if self.plugin_manager and hasattr(self.plugin_manager, 'drop_handlers'):
+                for handler_def in self.plugin_manager.drop_handlers:
+                    try:
+                         callback = handler_def['callback']
+                         handled = callback(file_path)
+                         if handled:
+                             event.acceptProposedAction()
+                             return
+                    except Exception as e:
+                         print(f"Error in plugin drop handler: {e}")
             # ドロップ位置を取得
             drop_pos = event.position().toPoint()
             # 拡張子に応じて適切な読み込みメソッドを呼び出す