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

moleditpy/plugins/File/cube_viewer.py

@@ -0,0 +1,689 @@
+
+import os
+import tempfile
+import numpy as np
+import pyvista as pv
+from PyQt6.QtWidgets import (QFileDialog, QDockWidget, QWidget, QVBoxLayout, 
+                             QSlider, QLabel, QHBoxLayout, QPushButton, QMessageBox, 
+                             QDoubleSpinBox, QColorDialog, QInputDialog, QDialog, 
+                             QFormLayout, QDialogButtonBox, QSpinBox, QCheckBox)
+from PyQt6.QtGui import QColor
+from PyQt6.QtCore import Qt
+
+# RDKit imports for molecule construction
+try:
+    from rdkit import Chem
+    from rdkit import Geometry
+    try:
+        from rdkit.Chem import rdDetermineBonds
+    except ImportError:
+        rdDetermineBonds = None
+except ImportError:
+    Chem = None
+    Geometry = None
+    rdDetermineBonds = None
+    
+__version__="2025.12.20"
+__author__="HiroYokoyama"
+PLUGIN_NAME = "Cube File Viewer"
+
+def parse_cube_data(filename):
+    """
+    Parses a Gaussian Cube file and returns raw data structures.
+    Adapted from test.py with robust header handling.
+    """
+    with open(filename, 'r') as f:
+        lines = f.readlines()
+
+    if len(lines) < 6:
+        raise ValueError("File too short to be a Cube file.")
+
+    # --- Header Parsing ---
+    # Line 3: Natoms, Origin
+    tokens = lines[2].split()
+    n_atoms_raw = int(tokens[0])
+    n_atoms = abs(n_atoms_raw)
+    origin_raw = np.array([float(tokens[1]), float(tokens[2]), float(tokens[3])])
+
+    # Lines 4-6: NX, NY, NZ and vectors
+    def parse_vec(line):
+        t = line.split()
+        return int(t[0]), np.array([float(t[1]), float(t[2]), float(t[3])])
+
+    nx, x_vec_raw = parse_vec(lines[3])
+    ny, y_vec_raw = parse_vec(lines[4])
+    nz, z_vec_raw = parse_vec(lines[5])
+    
+    # Auto-detect units based on sign of NX/NY/NZ (Gaussian standard)
+    is_angstrom_header = (nx < 0 or ny < 0 or nz < 0)
+    
+    nx, ny, nz = abs(nx), abs(ny), abs(nz)
+
+    # --- Atoms Parsing ---
+    atoms = []
+    current_line = 6
+    if n_atoms_raw < 0:
+        # Smart check: if next line does not look like an atom line, skip it.
+        try:
+            parts = lines[current_line].split()
+            if len(parts) != 5: 
+                 current_line += 1
+        except:
+             current_line += 1
+
+    for _ in range(n_atoms):
+        line = lines[current_line].split()
+        current_line += 1
+        atomic_num = int(line[0])
+        try:
+            x, y, z = float(line[2]), float(line[3]), float(line[4])
+        except:
+            x, y, z = 0.0, 0.0, 0.0
+        atoms.append((atomic_num, np.array([x, y, z])))
+
+    # --- Volumetric Data Parsing ---
+    
+    # Skip metadata lines (e.g. "1 150") before data starts
+    while current_line < len(lines):
+        line_content = lines[current_line].strip()
+        parts = line_content.split()
+        
+        # Skip empty lines
+        if not parts:
+            current_line += 1
+            continue
+            
+        # Skip short lines (metadata often has few columns, data usually has 6)
+        if len(parts) < 6:
+            current_line += 1
+            continue
+            
+        # Check if start is numeric
+        try:
+            float(parts[0])
+        except ValueError:
+            current_line += 1
+            continue
+            
+        # If we get here, it's likely data
+        break
+
+    # Read rest of file
+    full_str = " ".join(lines[current_line:])
+    try:
+        data_values = np.fromstring(full_str, sep=' ')
+    except:
+        data_values = np.array([])
+    
+    expected_size = nx * ny * nz
+    actual_size = len(data_values)
+    
+    # FIX: Trim from START if excess > 0 (The header values are at the start)
+    # This logic fixes the shift issue test.py had.
+    if actual_size > expected_size:
+        excess = actual_size - expected_size
+        data_values = data_values[excess:]
+    elif actual_size < expected_size:
+        pad = np.zeros(expected_size - actual_size)
+        data_values = np.concatenate((data_values, pad))
+    
+    return {
+        "atoms": atoms,
+        "origin": origin_raw,
+        "x_vec": x_vec_raw,
+        "y_vec": y_vec_raw,
+        "z_vec": z_vec_raw,
+        "dims": (nx, ny, nz),
+        "data_flat": data_values,
+        "is_angstrom_header": is_angstrom_header
+    }
+
+def build_grid_from_meta(meta):
+    """
+    Reconstructs the PyVista grid.
+    Correctly handles standard Cube (Z-fast) mapping.
+    """
+    nx, ny, nz = meta['dims']
+    origin = meta['origin'].copy()
+    x_vec = meta['x_vec'].copy()
+    y_vec = meta['y_vec'].copy()
+    z_vec = meta['z_vec'].copy()
+    atoms = []
+    
+    # Units Handling (replicated logic)
+    BOHR_TO_ANGSTROM = 0.529177210903
+    convert_to_ang = True
+    if meta['is_angstrom_header']:
+        convert_to_ang = False
+            
+    if convert_to_ang:
+        origin *= BOHR_TO_ANGSTROM
+        x_vec *= BOHR_TO_ANGSTROM
+        y_vec *= BOHR_TO_ANGSTROM
+        z_vec *= BOHR_TO_ANGSTROM
+        
+    for anum, pos in meta['atoms']:
+        p = pos.copy()
+        if convert_to_ang:
+            p *= BOHR_TO_ANGSTROM
+        atoms.append((anum, p))
+
+    # Grid Points Generation (Matches test.py logic for F-order consistency)
+    x_range = np.arange(nx)
+    y_range = np.arange(ny)
+    z_range = np.arange(nz)
+    
+    gx, gy, gz = np.meshgrid(x_range, y_range, z_range, indexing='ij')
+    
+    # Flatten using Fortran order (X-fast) for VTK Structure
+    gx_f = gx.flatten(order='F')
+    gy_f = gy.flatten(order='F')
+    gz_f = gz.flatten(order='F')
+    
+    points = (origin + 
+              np.outer(gx_f, x_vec) + 
+              np.outer(gy_f, y_vec) + 
+              np.outer(gz_f, z_vec))
+    
+    grid = pv.StructuredGrid()
+    grid.points = points
+    grid.dimensions = [nx, ny, nz]
+    
+    # Data Mapping
+    raw_data = meta['data_flat']
+    
+    # Standard Cube: Z-Fast (C-order reshape)
+    # Then flatten F-order to match the X-fast points we just generated
+    # This logic matches test.py's implementation which user preferred
+    vol_3d = raw_data.reshape((nx, ny, nz), order='C')
+    grid.point_data["values"] = vol_3d.flatten(order='F')
+        
+    return {"atoms": atoms}, grid
+
+def read_cube(filename):
+    meta = parse_cube_data(filename)
+    return build_grid_from_meta(meta)
+
+class CubeViewerWidget(QWidget):
+    def __init__(self, parent_window, dock_widget, grid, data_max=1.0):
+        super().__init__(parent_window)
+        self.mw = parent_window
+        self.dock = dock_widget 
+        self.grid = grid
+        # Ensure we have a reasonable positive max value
+        self.data_max = max(abs(float(data_max)), 1e-6)
+        
+        self.iso_actor_p = None
+        self.iso_actor_n = None
+        
+        self.plotter = self.mw.plotter
+        
+        # Initial Colors
+        self.color_p = "#0000FF" # Blue
+        self.color_n = "#FF0000" # Red
+
+        self.init_ui()
+        self.update_iso() 
+
+    def init_ui(self):
+        layout = QVBoxLayout()
+        
+        # --- Isovalue Controls ---
+        ctrl_layout = QHBoxLayout()
+        ctrl_layout.addWidget(QLabel("Isovalue:"))
+        
+        # Spinbox: Fixed max 1.0 as requested
+        # Spinbox: Dynamic max based on data
+        # We allow going a bit higher than the max found in data, e.g. 1.2x, just in case
+        self.max_val = self.data_max * 1.2
+        
+        self.spin = QDoubleSpinBox()
+        self.spin.setRange(0.0001, self.max_val) 
+        self.spin.setSingleStep(0.01) # User requested 0.01 step
+        self.spin.setDecimals(5)
+        
+        # Default value strategy: 
+        # User requested hardcoded 0.05
+        default_val = 0.05
+        
+        # If default is outside the max range, adjust it
+        if default_val > self.max_val:
+            default_val = self.max_val * 0.1
+            
+        self.spin.setValue(default_val)
+        
+        self.spin.valueChanged.connect(self.on_spin_changed)
+        ctrl_layout.addWidget(self.spin)
+        
+        # Slider
+        self.slider_max_int = 1000
+        
+        self.slider = QSlider(Qt.Orientation.Horizontal)
+        self.slider.setRange(0, self.slider_max_int)
+        
+        # Default 0.05
+        # Default set from spinbox value
+        self.slider.setValue(int((default_val / self.max_val) * self.slider_max_int))
+        
+        self.slider.valueChanged.connect(self.on_slider_changed)
+        ctrl_layout.addWidget(self.slider)
+
+        layout.addLayout(ctrl_layout)
+        
+        # --- Color Controls ---
+        # Fixed size for color buttons to align them nicely
+        btn_size = (50, 24)
+        
+        # Positive
+        pos_color_layout = QHBoxLayout()
+        pos_color_layout.addWidget(QLabel("Pos Color:"))
+        self.btn_color_p = QPushButton()
+        self.btn_color_p.setFixedSize(*btn_size)
+        self.btn_color_p.setStyleSheet(f"background-color: {self.color_p}; border: 1px solid gray;")
+        self.btn_color_p.clicked.connect(self.choose_color_p)
+        pos_color_layout.addWidget(self.btn_color_p)
+        pos_color_layout.addStretch() # Align left
+        layout.addLayout(pos_color_layout)
+
+        # Negative
+        neg_color_layout = QHBoxLayout()
+        neg_color_layout.addWidget(QLabel("Neg Color:"))
+        self.btn_color_n = QPushButton()
+        self.btn_color_n.setFixedSize(*btn_size)
+        self.btn_color_n.setStyleSheet(f"background-color: {self.color_n}; border: 1px solid gray;")
+        self.btn_color_n.clicked.connect(self.choose_color_n)
+        neg_color_layout.addWidget(self.btn_color_n)
+        neg_color_layout.addStretch() # Align left
+        layout.addLayout(neg_color_layout)
+
+        # Complementary Checkbox (Next line)
+        comp_layout = QHBoxLayout()
+        self.check_comp_color = QCheckBox("Use complementary color for neg")
+        self.check_comp_color.toggled.connect(self.on_comp_color_toggled)
+        comp_layout.addWidget(self.check_comp_color)
+        comp_layout.addStretch()
+        layout.addLayout(comp_layout)
+
+        # --- Opacity Controls ---
+        opacity_layout = QHBoxLayout()
+        # Static label (no numeric value displayed)
+        self.opacity_label = QLabel("Opacity:")
+        opacity_layout.addWidget(self.opacity_label)
+        
+        # Numeric opacity input: place before the slider to match isovalue controls
+        self.opacity_spin = QDoubleSpinBox()
+        self.opacity_spin.setRange(0.0, 1.0)
+        self.opacity_spin.setSingleStep(0.01)
+        self.opacity_spin.setDecimals(2)
+        self.opacity_spin.setValue(0.4)
+        self.opacity_spin.valueChanged.connect(self.on_opacity_spin_changed)
+        opacity_layout.addWidget(self.opacity_spin)
+
+        self.opacity_slider = QSlider(Qt.Orientation.Horizontal)
+        self.opacity_slider.setRange(0, 100)
+        self.opacity_slider.setValue(40) # Match spinbox
+        self.opacity_slider.valueChanged.connect(self.on_opacity_changed)
+        opacity_layout.addWidget(self.opacity_slider)
+        
+        layout.addLayout(opacity_layout)
+
+        close_btn = QPushButton("Close Plugin")
+        close_btn.clicked.connect(self.close_plugin)
+        layout.addWidget(close_btn)
+        
+        layout.addStretch()
+        self.setLayout(layout)
+
+    def on_comp_color_toggled(self, checked):
+        self.btn_color_n.setEnabled(not checked)
+        if checked:
+            self.update_complementary_color()
+
+    def update_complementary_color(self):
+        # Convert hex/name to QColor
+        col_p = QColor(self.color_p)
+        if not col_p.isValid():
+            return
+            
+        h = col_p.hue()
+        s = col_p.saturation()
+        v = col_p.value()
+        
+        # Complementary = hue + 180 degrees
+        if h != -1: # -1 means grayscale/achromatic
+             new_h = (h + 180) % 360
+        else:
+             new_h = h # Keep achromatic
+        
+        col_n = QColor.fromHsv(new_h, s, v)
+        self.color_n = col_n.name()
+        self.btn_color_n.setStyleSheet(f"background-color: {self.color_n}; border: 1px solid gray;")
+        self.update_iso()
+
+    def choose_color_p(self):
+        c = QColorDialog.getColor(initial=QColor(self.color_p), title="Select Positive Lobe Color")
+        if c.isValid():
+            self.color_p = c.name()
+            self.btn_color_p.setStyleSheet(f"background-color: {self.color_p}; border: 1px solid gray;")
+            
+            if self.check_comp_color.isChecked():
+                self.update_complementary_color()
+            else:
+                self.update_iso()
+
+    def choose_color_n(self):
+        c = QColorDialog.getColor(initial=QColor(self.color_n), title="Select Negative Lobe Color")
+        if c.isValid():
+            self.color_n = c.name()
+            self.btn_color_n.setStyleSheet(f"background-color: {self.color_n}; border: 1px solid gray;")
+            self.update_iso()
+
+    def update_iso(self):
+        val = self.spin.value()
+        # Prefer numeric spinbox value (kept in sync with slider)
+        opacity = self.opacity_spin.value() if hasattr(self, 'opacity_spin') else self.opacity_slider.value() / 100.0
+        
+        try:
+            # Cleanup previous
+            if self.iso_actor_p: self.plotter.remove_actor(self.iso_actor_p)
+            if self.iso_actor_n: self.plotter.remove_actor(self.iso_actor_n)
+            
+            # Additional safety cleanup by name
+            self.plotter.remove_actor("cube_iso_p")
+            self.plotter.remove_actor("cube_iso_n")
+            
+            # Using full grid
+            using_grid = self.grid
+
+            # Positive lobe
+            iso_p = using_grid.contour(isosurfaces=[val])
+            if iso_p.n_points > 0:
+                self.iso_actor_p = self.plotter.add_mesh(iso_p, color=self.color_p, opacity=opacity, name="cube_iso_p", reset_camera=False)
+                
+            # Negative lobe
+            iso_n = using_grid.contour(isosurfaces=[-val])
+            if iso_n.n_points > 0:
+                self.iso_actor_n = self.plotter.add_mesh(iso_n, color=self.color_n, opacity=opacity, name="cube_iso_n", reset_camera=False)
+                
+            self.plotter.render()
+            
+        except Exception as e:
+            print(f"Iso update error: {e}")
+            import traceback
+            traceback.print_exc()
+
+    def on_opacity_changed(self, val):
+        opacity = val / 100.0
+        # Sync numeric spinbox without re-triggering signals
+        if hasattr(self, 'opacity_spin'):
+            self.opacity_spin.blockSignals(True)
+            self.opacity_spin.setValue(opacity)
+            self.opacity_spin.blockSignals(False)
+        self.update_iso()
+
+    def on_opacity_spin_changed(self, val):
+        # val is between 0.0 and 1.0
+        # Sync slider (0-100)
+        if hasattr(self, 'opacity_slider'):
+            int_val = int(round(val * 100))
+            self.opacity_slider.blockSignals(True)
+            self.opacity_slider.setValue(int_val)
+            self.opacity_slider.blockSignals(False)
+        self.update_iso()
+
+    def on_slider_changed(self, val):
+        float_val = (val / self.slider_max_int) * self.max_val
+        self.spin.blockSignals(True)
+        self.spin.setValue(float_val)
+        self.spin.blockSignals(False)
+        self.update_iso()
+
+    def on_spin_changed(self, val):
+        if self.max_val > 0:
+            int_val = int((val / self.max_val) * self.slider_max_int)
+            self.slider.blockSignals(True)
+            self.slider.setValue(int_val)
+            self.slider.blockSignals(False)
+        self.update_iso()
+
+    def close_plugin(self):
+        try:
+             # Full cleanup
+             self.mw.plotter.clear()
+             self.mw.current_mol = None
+             self.mw.current_file_path = None
+             self.mw.plotter.render()
+             
+             # Restore UI state
+             if hasattr(self.mw, 'restore_ui_for_editing'):
+                 self.mw.restore_ui_for_editing()
+        except: pass
+        
+        if self.dock:
+            self.mw.removeDockWidget(self.dock)
+            self.dock.deleteLater()
+            self.dock = None
+        
+        self.deleteLater()
+
+class ChargeDialog(QDialog):
+    def __init__(self, parent=None, current_charge=0):
+        super().__init__(parent)
+        self.setWindowTitle("Bond Connectivity Error")
+        self.result_action = "cancel" # retry, skip, cancel
+        self.charge = current_charge
+        
+        self.init_ui()
+        
+    def init_ui(self):
+        layout = QVBoxLayout()
+        layout.addWidget(QLabel("Could not determine connectivity with charge: " + str(self.charge)))
+        layout.addWidget(QLabel("Please specificy correct charge or skip chemistry check."))
+        
+        form = QFormLayout()
+        self.spin = QSpinBox()
+        self.spin.setRange(-20, 20)
+        self.spin.setValue(self.charge)
+        form.addRow("Charge:", self.spin)
+        layout.addLayout(form)
+        
+        btns = QHBoxLayout()
+        retry_btn = QPushButton("Retry")
+        retry_btn.clicked.connect(self.on_retry)
+        
+        skip_btn = QPushButton("Skip Chemistry")
+        skip_btn.clicked.connect(self.on_skip)
+        
+        cancel_btn = QPushButton("Cancel")
+        cancel_btn.clicked.connect(self.reject)
+        
+        btns.addWidget(retry_btn)
+        btns.addWidget(skip_btn)
+        btns.addWidget(cancel_btn)
+        layout.addLayout(btns)
+        
+        self.setLayout(layout)
+        
+    def on_retry(self):
+        self.charge = self.spin.value()
+        self.result_action = "retry"
+        self.accept()
+        
+    def on_skip(self):
+        self.result_action = "skip"
+        self.accept()
+
+def open_cube_viewer(main_window, fname):
+    """Core logic to open cube viewer with a specific file."""
+    if Chem is None:
+        QMessageBox.critical(main_window, "Error", "RDKit is required for this plugin.")
+        return
+
+    # Close existing docks
+    docks_to_close = []
+    for dock in main_window.findChildren(QDockWidget):
+        if dock.windowTitle() == "Cube Viewer":
+            docks_to_close.append(dock)
+    
+    for dock in docks_to_close:
+        try:
+            widget = dock.widget()
+            if hasattr(widget, 'close_plugin'):
+                widget.close_plugin()
+            else:
+                main_window.removeDockWidget(dock)
+                dock.deleteLater()
+        except:
+             pass
+
+    try:
+        if not fname: # Should not happen if called correctly
+            return
+
+        try:
+            meta, grid = read_cube(fname)
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            QMessageBox.critical(main_window, "Error", f"Failed to parse Cube file:\n{e}")
+            return
+        
+        if hasattr(main_window, 'plotter'):
+            main_window.plotter.clear()
+        
+        if hasattr(main_window, 'main_window_ui_manager'):
+            main_window.main_window_ui_manager._enter_3d_viewer_ui_mode()
+        
+        # Create Molecule (XYZ)
+        atoms = meta['atoms']
+        xyz_lines = [f"{len(atoms)}", "Generated by Cube Plugin"]
+        pt = Chem.GetPeriodicTable()
+        for atomic_num, pos in atoms:
+            symbol = pt.GetElementSymbol(atomic_num)
+            xyz_lines.append(f"{symbol} {pos[0]:.4f} {pos[1]:.4f} {pos[2]:.4f}")
+        
+        xyz_content = "\n".join(xyz_lines)
+        
+        mol = Chem.MolFromXYZBlock(xyz_content)
+        
+        # Use rdDetermineBonds if available and no bonds found
+        current_charge = 0
+        if mol is not None and mol.GetNumBonds() == 0 and rdDetermineBonds is not None:
+            while True:
+                # Re-create fresh molecule for this attempt to avoid dirty state on retry
+                mol = Chem.MolFromXYZBlock(xyz_content)
+                
+                try:
+                    rdDetermineBonds.DetermineConnectivity(mol, charge=current_charge)
+                    rdDetermineBonds.DetermineBondOrders(mol, charge=current_charge)
+                    break # Success
+                except Exception as e:
+                    # Show Dialog
+                    dlg = ChargeDialog(main_window, current_charge)
+                    if dlg.exec() == QDialog.DialogCode.Accepted:
+                        if dlg.result_action == "retry":
+                            current_charge = dlg.charge
+                            continue # Loop again with new charge
+                        elif dlg.result_action == "skip":
+                            # Ensure we have a clean unbonded mol
+                            mol = Chem.MolFromXYZBlock(xyz_content)
+                            rdDetermineBonds.DetermineConnectivity(mol, charge=0)
+                            break # Break loop, accept no bonds/bad connectivity
+                    else:
+                        return # User Cancelled plugin load
+        
+        if mol is None:
+            # Fallback
+            mol = Chem.RWMol()
+            conf = Chem.Conformer()
+            for i, (atomic_num, pos) in enumerate(atoms):
+                idx = mol.AddAtom(Chem.Atom(atomic_num))
+                conf.SetAtomPosition(idx, Geometry.Point3D(pos[0], pos[1], pos[2]))
+            mol.AddConformer(conf)
+
+        # Set current molecular data in main window for consistency
+        main_window.current_mol = mol
+        main_window.current_file_path = fname
+
+        # Draw
+        if hasattr(main_window, 'draw_molecule_3d'):
+             main_window.draw_molecule_3d(mol)
+        elif hasattr(main_window, 'main_window_view_3d'):
+             main_window.main_window_view_3d.draw_molecule_3d(mol)
+             
+        # Report bonds
+        nb = mol.GetNumBonds() if mol else 0
+        if hasattr(main_window, 'statusBar'):
+            main_window.statusBar().showMessage(f"Loaded Cube. Atoms: {len(atoms)}, Bonds: {nb}")
+
+        # Setup Dock
+        dock = QDockWidget("Cube Viewer", main_window)
+        dock.setAllowedAreas(Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea)
+        
+        # Calculate max absolute value in data for dynamic scaling
+        try:
+            # Data is stored in grid.point_data["values"]
+            # "make sure that the data is only in the plot data"
+            flat_data = grid.point_data["values"]
+            if len(flat_data) > 0:
+                data_max = float(np.max(np.abs(flat_data)))
+            else:
+                data_max = 1.0
+        except:
+             data_max = 1.0
+
+        viewer = CubeViewerWidget(main_window, dock, grid, data_max=data_max)
+        dock.setWidget(viewer)
+        
+        main_window.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, dock)
+        
+        main_window.plotter.reset_camera()
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        print(f"Plugin Error: {e}")
+
+def run(mw):
+    if Chem is None:
+        QMessageBox.critical(mw, "Error", "RDKit is required for this plugin.")
+        return
+
+    fname, _ = QFileDialog.getOpenFileName(mw, "Open Gaussian Cube File", "", "Cube Files (*.cube *.cub);;All Files (*)")
+    if fname:
+        open_cube_viewer(mw, fname)
+
+def initialize(context):
+    """
+    New Plugin System Entry Point
+    """
+    mw = context.get_main_window()
+
+    def open_cube_wrapper(fname):
+        open_cube_viewer(mw, fname)
+
+    # 1. Register File Opener (Handle File > Import)
+    context.register_file_opener('.cube', open_cube_wrapper)
+    context.register_file_opener('.cub', open_cube_wrapper)
+
+    # 2. Register Drop Handler (for robustness)
+    # The system iterates drop handlers. Return True if we handled it.
+    def drop_handler(file_path):
+        if file_path.lower().endswith(('.cube', '.cub')):
+            open_cube_viewer(mw, file_path)
+            return True
+        return False
+
+    if hasattr(context, 'register_drop_handler'):
+        context.register_drop_handler(drop_handler, priority=10)
+
+    # 4. Command Line Args (Legacy support logic moved here)
+    import sys
+    import os
+    from PyQt6.QtCore import QTimer
+    # Simple check for CLI args
+    for arg in sys.argv[1:]:
+        if arg.lower().endswith(('.cube', '.cub')) and os.path.exists(arg):
+            QTimer.singleShot(100, lambda f=arg: open_cube_viewer(mw, f))
+            break
+