setiastrosuitepro 1.6.4__py3-none-any.whl → 1.7.1.post2__py3-none-any.whl

setiastro/saspro/whitebalance.py

@@ -88,7 +88,7 @@ def plot_star_color_ratios_comparison(raw_pixels: np.ndarray, after_pixels: np.n
 
     plt.suptitle("Star Color Ratios with RGB Mapping", fontsize=14)
     plt.tight_layout()
-    plt.show()
+    plt.show(block=False)
 
 def apply_manual_white_balance(img: np.ndarray, r_gain: float, g_gain: float, b_gain: float) -> np.ndarray:
     """Simple per-channel gain, clipped to [0,1]."""
@@ -184,6 +184,30 @@ def apply_white_balance_to_doc(doc, preset: Optional[Dict] = None):
         step_name="White Balance",
     )
 
+def apply_pivot_gain(img: np.ndarray, med: np.ndarray, gains: np.ndarray) -> np.ndarray:
+    # img: HxWx3 float32 in [0,1]
+    med3 = med.reshape(1, 1, 3).astype(np.float32)
+    g3   = gains.reshape(1, 1, 3).astype(np.float32)
+
+    # pivot around median; do not scale negative deltas
+    d = img - med3
+    d = np.maximum(d, 0.0)
+    out = d * g3 + med3
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+def smoothstep(edge0, edge1, x):
+    t = np.clip((x - edge0) / (edge1 - edge0 + 1e-12), 0.0, 1.0)
+    return t * t * (3.0 - 2.0 * t)
+
+def apply_soft_protect(img: np.ndarray, out_pivot: np.ndarray, k: float = 0.02) -> np.ndarray:
+    # luminance-based fade-in above median luminance
+    L = 0.2126*img[...,0] + 0.7152*img[...,1] + 0.0722*img[...,2]
+    Lm = float(np.median(L))
+    w = smoothstep(Lm, Lm + k, L).astype(np.float32)
+    w3 = w[..., None]
+    out = img * (1.0 - w3) + out_pivot * w3
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
 
 # -------------------------
 # Interactive dialog (UI)
@@ -193,16 +217,23 @@ class WhiteBalanceDialog(QDialog):
         super().__init__(parent)
         self._main = parent
         self.doc = doc
-
-        # Connect to active document change signal
+        self._active_doc_conn = False
         if hasattr(self._main, "currentDocumentChanged"):
-            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+            try:
+                self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+                self._active_doc_conn = True
+            except Exception:
+                self._active_doc_conn = False
         if icon:
             self.setWindowIcon(icon)
         self.setWindowTitle(self.tr("White Balance"))
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         self.resize(900, 600)
 
         self._build_ui()
@@ -213,6 +244,8 @@ class WhiteBalanceDialog(QDialog):
         self._update_mode_widgets()
         # kick off a first detection preview
         QTimer.singleShot(200, self._update_star_preview)
+        self.finished.connect(lambda *_: self._cleanup())
+
 
     # ---- UI construction ------------------------------------------------
     def _build_ui(self):
@@ -327,11 +360,16 @@ class WhiteBalanceDialog(QDialog):
             )
             self.star_count.setText(self.tr("Detected {0} stars.").format(count))
             # to pixmap
-            h, w, _ = overlay.shape
-            qimg = QImage((overlay * 255).astype(np.uint8).data, w, h, 3 * w, QImage.Format.Format_RGB888)
-            pm = QPixmap.fromImage(qimg).scaled(self.preview.width(), self.preview.height(),
-                                                Qt.AspectRatioMode.KeepAspectRatio,
-                                                Qt.TransformationMode.SmoothTransformation)
+            overlay8 = np.ascontiguousarray(np.clip(overlay * 255.0, 0, 255).astype(np.uint8))
+            h, w, _ = overlay8.shape
+            qimg = QImage(overlay8.data, w, h, 3 * w, QImage.Format.Format_RGB888)
+
+            # Make sure the numpy buffer stays alive until QPixmap is created
+            pm = QPixmap.fromImage(qimg.copy()).scaled(
+                self.preview.width(), self.preview.height(),
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation
+            )
             self.preview.setPixmap(pm)
         except Exception as e:
             self.star_count.setText(self.tr("Detection failed."))
@@ -394,7 +432,8 @@ class WhiteBalanceDialog(QDialog):
                 # Use the headless helper so doc metadata is consistent
                 apply_white_balance_to_doc(self.doc, preset)
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
             elif mode == "Auto":
                 preset = {"mode": "auto"}
@@ -404,7 +443,8 @@ class WhiteBalanceDialog(QDialog):
 
                 apply_white_balance_to_doc(self.doc, preset)
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
             else:  # --- Star-Based: compute here so we can plot like SASv2 ---
                 thr   = float(self.thr_slider.value())
@@ -472,7 +512,8 @@ class WhiteBalanceDialog(QDialog):
                     self.tr("Star-Based WB applied.\nDetected {0} stars.").format(int(star_count)),
                 )
                 # Dialog stays open - refresh document for next operation
-                self._refresh_document_from_active()
+                self._finish_and_close()
+                return
 
         except Exception as e:
             QMessageBox.critical(self, self.tr("White Balance"), self.tr("Failed to apply White Balance:\n{0}").format(e))
@@ -490,3 +531,34 @@ class WhiteBalanceDialog(QDialog):
                     self.doc = new_doc
         except Exception:
             pass
+
+    def _finish_and_close(self):
+        """
+        Close this dialog after a successful apply.
+        Use accept() so it behaves like a successful completion.
+        """
+        try:
+            self.accept()
+        except Exception:
+            self.close()
+
+    def _cleanup(self):
+        # Disconnect active-doc signal so the main window doesn't keep us alive
+        try:
+            if self._active_doc_conn and hasattr(self._main, "currentDocumentChanged"):
+                self._main.currentDocumentChanged.disconnect(self._on_active_doc_changed)
+        except Exception:
+            pass
+        self._active_doc_conn = False
+
+        # Stop debounce timer
+        try:
+            if getattr(self, "_debounce", None) is not None:
+                self._debounce.stop()
+        except Exception:
+            pass
+
+
+    def closeEvent(self, ev):
+        self._cleanup()
+        super().closeEvent(ev)

setiastro/saspro/widgets/common_utilities.py

@@ -1,3 +1,4 @@
+#src/setiastro/saspro/widgets/common_utilities.py
 """
 Common UI utilities and shared components.
 
@@ -220,32 +221,38 @@ _strip_ui_decorations = strip_ui_decorations
 # ---------------------------------------------------------------------------
 
 def install_crash_handlers(app: 'QApplication') -> None:
-    """
-    Install global crash and exception handlers for the application.
-    
-    Sets up:
-    1. faulthandler for hard crashes (segfaults) → saspro_crash.log
-    2. sys.excepthook for uncaught main thread exceptions
-    3. threading.excepthook for uncaught background thread exceptions
-    
-    All exceptions are logged and displayed in a dialog to the user.
-    
-    Args:
-        app: The QApplication instance
-        
-    Example:
-        app = QApplication(sys.argv)
-        install_crash_handlers(app)
-    """
     import faulthandler
-    
-    # 1) Hard crashes (segfaults, access violations) → saspro_crash.log
+    import tempfile
+    from pathlib import Path
+
+    def _get_crash_log_path() -> str:
+        try:
+            if hasattr(sys, "_MEIPASS"):
+                if sys.platform.startswith("win"):
+                    log_dir = Path(os.path.expandvars("%APPDATA%")) / "SetiAstroSuitePro" / "logs"
+                elif sys.platform.startswith("darwin"):
+                    log_dir = Path.home() / "Library" / "Logs" / "SetiAstroSuitePro"
+                else:
+                    log_dir = Path.home() / ".local" / "share" / "SetiAstroSuitePro" / "logs"
+            else:
+                # dev fallback
+                log_dir = Path("logs")
+
+            log_dir.mkdir(parents=True, exist_ok=True)
+            return str(log_dir / "saspro_crash.log")
+        except Exception:
+            return str(Path(tempfile.gettempdir()) / "saspro_crash.log")
+
+    # 1) Hard crashes → saspro_crash.log
     try:
-        _crash_log = open("saspro_crash.log", "w", encoding="utf-8", errors="replace")
+        crash_path = _get_crash_log_path()
+        _crash_log = open(crash_path, "a", encoding="utf-8", errors="replace")
         faulthandler.enable(file=_crash_log, all_threads=True)
         atexit.register(_crash_log.close)
+        logging.info("Faulthandler crash log: %s", crash_path)
     except Exception:
         logging.exception("Failed to enable faulthandler")
+
     
     def _show_dialog(title: str, head: str, details: str) -> None:
         """Show error dialog marshaled to main thread."""
@@ -261,7 +268,7 @@ def install_crash_handlers(app: 'QApplication') -> None:
             m.setStandardButtons(QMessageBox.StandardButton.Ok)
             m.exec()
         QTimer.singleShot(0, _ui)
-    
+
     # 2) Any uncaught exception on the main thread
     def _excepthook(exc_type, exc_value, exc_tb):
         tb = "".join(traceback.format_exception(exc_type, exc_value, exc_tb))

setiastro/saspro/widgets/resource_monitor.py

@@ -1,101 +1,134 @@
 # src/setiastro/saspro/widgets/resource_monitor.py
 from __future__ import annotations
+
 import os
+import time
+import subprocess
+import numpy as np
+
 import psutil
+
 from PyQt6.QtCore import Qt, QUrl, QTimer, QObject, pyqtProperty, pyqtSignal, QThread
-from PyQt6.QtWidgets import QWidget, QVBoxLayout, QFrame
 from PyQt6.QtQuickWidgets import QQuickWidget
 
 from setiastro.saspro.memory_utils import get_memory_usage_mb
 from setiastro.saspro.resources import _get_base_path
 
+
 class GPUWorker(QThread):
-    """Background worker to monitor GPU without blocking the UI."""
     resultReady = pyqtSignal(float)
 
     def __init__(self, has_nvidia: bool, parent=None):
         super().__init__(parent)
         self._has_nvidia = has_nvidia
-        self._last_val = 0.0
+
+        # cache + throttle (Windows PowerShell is expensive)
+        self._last_win_poll = 0.0
+        self._cached_win_val = 0.0
+
+        self._last_emit = 0.0
+        self._last_emitted_val = None
+
+    def _startupinfo_hidden(self):
+        if os.name != "nt":
+            return None
+        si = subprocess.STARTUPINFO()
+        si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        si.wShowWindow = 0
+        return si
 
     def _get_windows_gpu_load(self) -> float:
-        if os.name != 'nt':
+        if os.name != "nt":
             return 0.0
+
+        now = time.monotonic()
+
+        # THROTTLE: run this at most once every 1.5 seconds
+        if (now - self._last_win_poll) < 1.5:
+            return self._cached_win_val
+
+        self._last_win_poll = now
+
         try:
-            import subprocess
-            # Aggregation logic to match Task Manager:
-            # 1. Group by unique engine (Adapter LUID + Engine Type/Index).
-            # 2. Sum utilization of all processes sharing that engine.
-            # 3. Take the Maximum of these sums as the overall GPU load.
-            # Aggregation logic to match Task Manager:
-            # 1. Group by unique engine (Adapter LUID + Engine Type/Index).
-            # 2. Sum utilization of all processes sharing that engine.
-            # 3. Take the Maximum of these sums as the overall GPU load.
-            cmd = (
-                "powershell -NoProfile -ExecutionPolicy Bypass -Command \""
-                "$groups = Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine -ErrorAction SilentlyContinue | "
-                "Group-Object -Property { $_.Name -replace '^pid_\\d+_', '' }; "
-                "$res_list = $groups | ForEach-Object { ($_.Group | Measure-Object -Property UtilizationPercentage -Sum).Sum }; "
-                "$max_val = ($res_list | Measure-Object -Maximum).Maximum; "
-                "if ($max_val) { [math]::Round($max_val, 1) } else { 0 }\""
+            cmd = [
+                "powershell.exe",
+                "-NoProfile",
+                "-NonInteractive",
+                "-ExecutionPolicy", "Bypass",
+                "-Command",
+                (
+                    "$x = Get-CimInstance Win32_PerfFormattedData_GPUPerformanceCounters_GPUEngine "
+                    "-ErrorAction SilentlyContinue; "
+                    "if (-not $x) { 0 } else { "
+                    "  $m = ($x | Measure-Object -Property UtilizationPercentage -Maximum).Maximum; "
+                    "  if ($m) { [math]::Round([double]$m, 1) } else { 0 } "
+                    "}"
+                ),
+            ]
+
+            out = subprocess.check_output(
+                cmd,
+                startupinfo=self._startupinfo_hidden(),
+                timeout=2.0,
+                stderr=subprocess.DEVNULL,
             )
-            startupinfo = subprocess.STARTUPINFO()
-            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-            startupinfo.wShowWindow = 0 
-            
-            out = subprocess.check_output(cmd, startupinfo=startupinfo, timeout=5.0)
-            val_str = out.decode("utf-8").strip()
-            
-            if not val_str: return 0.0
-            return float(val_str.replace(",", "."))
+            val_str = out.decode("utf-8", errors="ignore").strip()
+
+            val = float(val_str.replace(",", ".")) if val_str else 0.0
+            self._cached_win_val = val
+            return val
         except Exception:
-            return 0.0
+            # keep last known value instead of spamming 0.0
+            return self._cached_win_val
 
     def _get_gpu_load(self) -> float:
         nv_val = 0.0
         win_val = 0.0
-        
-        # 1. Check NVIDIA (Discrete)
+
+        # NVIDIA (fast)
         if self._has_nvidia:
             try:
-                import subprocess
-                startupinfo = None
-                if os.name == 'nt':
-                    startupinfo = subprocess.STARTUPINFO()
-                    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-                    startupinfo.wShowWindow = 0 
-
                 out = subprocess.check_output(
                     ["nvidia-smi", "--query-gpu=utilization.gpu", "--format=csv,noheader,nounits"],
-                    startupinfo=startupinfo,
-                    timeout=0.6
+                    startupinfo=self._startupinfo_hidden(),
+                    timeout=0.6,
+                    stderr=subprocess.DEVNULL,
                 )
-                line = out.decode("utf-8").strip().split('\n')[0]
+                line = out.decode("utf-8", errors="ignore").strip().split("\n")[0]
                 nv_val = float(line)
             except Exception:
-                pass 
-        
-        # 2. Check Universal (Integrated)
-        if os.name == 'nt':
+                pass
+
+        # Windows integrated (slow, throttled)
+        if os.name == "nt":
             win_val = self._get_windows_gpu_load()
-            
+
         return max(nv_val, win_val)
 
     def run(self):
         while not self.isInterruptionRequested():
             try:
                 val = self._get_gpu_load()
-                self.resultReady.emit(val)
-                # Sleep between measurements. 250ms as requested.
-                # Note: PowerShell queries might take longer than 250ms, 
-                # but this loop will run as fast as the hardware allows without blocking UI.
+
+                # emit only if changed enough OR periodically
+                now = time.monotonic()
+                if (
+                    self._last_emitted_val is None
+                    or abs(val - self._last_emitted_val) >= 1.0
+                    or (now - self._last_emit) >= 0.5
+                ):
+                    self._last_emit = now
+                    self._last_emitted_val = val
+                    self.resultReady.emit(val)
+
                 self.msleep(250)
             except Exception:
-                self.msleep(1000) # Error backoff on failure
+                self.msleep(1000)
+
 
 class ResourceBackend(QObject):
-    """Backend logic for the QML Resource Monitor."""
-    
+    """Backend logic for the QML Resource Monitor (SYSTEM usage, not app usage)."""
+
     cpuChanged = pyqtSignal()
     ramChanged = pyqtSignal()
     gpuChanged = pyqtSignal()
@@ -103,12 +136,25 @@ class ResourceBackend(QObject):
 
     def __init__(self, parent=None):
         super().__init__(parent)
-        self._cpu = 0.0
-        self._ram = 0.0
-        self._gpu = 0.0
+
+        self._cpu = 0.0          # system CPU %
+        self._ram = 0.0          # system RAM %
+        self._gpu = 0.0          # GPU %
         self._app_ram_val = 0.0
         self._app_ram_str = "0 MB"
-        
+
+        # ---- Prime psutil CPU baselines (IMPORTANT on Windows) ----
+        # First call returns a meaningless 0.0 (or weird) because it establishes the baseline.
+        try:
+            psutil.cpu_percent(interval=None)
+            psutil.cpu_percent(percpu=True, interval=None)
+        except Exception:
+            pass
+
+        # Optional smoothing so gauge feels like Task Manager
+        self._cpu_ema = None  # exponential moving average
+        self._last_cpu_times = None
+        self._last_cpu_sample_t = 0.0
         # Check if nvidia-smi is reachable once
         has_nvidia = False
         try:
@@ -123,49 +169,101 @@ class ResourceBackend(QObject):
         self._gpu_worker.resultReady.connect(self._on_gpu_measured)
         self._gpu_worker.start()
 
-        # Timer for CPU/RAM updates (250ms as requested)
+        # Timer for CPU/RAM updates (250ms)
         self._timer = QTimer(self)
-        self._timer.setInterval(250) 
+        self._timer.setInterval(250)
         self._timer.timeout.connect(self._update_stats)
         self._timer.start()
 
     def _on_gpu_measured(self, val: float):
-        self._gpu = val
+        self._gpu = float(val)
         self.gpuChanged.emit()
 
     @pyqtProperty(float, notify=cpuChanged)
-    def cpuUsage(self):
-        return self._cpu
+    def cpuUsage(self) -> float:
+        return float(self._cpu)
 
     @pyqtProperty(float, notify=ramChanged)
-    def ramUsage(self):
-        return self._ram
+    def ramUsage(self) -> float:
+        return float(self._ram)
 
     @pyqtProperty(float, notify=gpuChanged)
-    def gpuUsage(self):
-        return self._gpu
+    def gpuUsage(self) -> float:
+        return float(self._gpu)
 
     @pyqtProperty(str, notify=appRamChanged)
-    def appRamString(self):
+    def appRamString(self) -> str:
         return self._app_ram_str
 
-    def _update_stats(self):
-        # 1. CPU
+    def _read_system_cpu_percent(self) -> float:
+        """
+        Return SYSTEM-wide CPU utilization as 0..100 using cpu_times() deltas.
+        This is robust even if other code calls psutil.cpu_percent().
+        """
         try:
-            self._cpu = psutil.cpu_percent(interval=None)
+            now = time.monotonic()
+            cur = psutil.cpu_times(percpu=True)
+
+            if not cur:
+                return 0.0
+
+            # first sample: store and return 0 (or keep last)
+            if self._last_cpu_times is None:
+                self._last_cpu_times = cur
+                self._last_cpu_sample_t = now
+                return float(self._cpu)  # keep whatever we had
+
+            prev = self._last_cpu_times
+            self._last_cpu_times = cur
+            self._last_cpu_sample_t = now
+
+            # usage per logical CPU
+            usages = []
+            for t0, t1 in zip(prev, cur):
+                # sum all fields to get total time
+                total0 = float(sum(t0))
+                total1 = float(sum(t1))
+                dt_total = total1 - total0
+                if dt_total <= 1e-9:
+                    continue
+
+                idle0 = float(getattr(t0, "idle", 0.0) + getattr(t0, "iowait", 0.0))
+                idle1 = float(getattr(t1, "idle", 0.0) + getattr(t1, "iowait", 0.0))
+                dt_idle = idle1 - idle0
+
+                busy = 1.0 - (dt_idle / dt_total)
+                usages.append(busy)
+
+            if not usages:
+                return float(self._cpu)
+
+            return float(np.clip((sum(usages) / len(usages)) * 100.0, 0.0, 100.0))
         except Exception:
-            self._cpu = 0.0
-        
-        # 2. System RAM
+            return float(self._cpu)
+
+
+    def _update_stats(self):
+        # 1) SYSTEM CPU
+        cpu = self._read_system_cpu_percent()
+
+        # light smoothing (keeps spikes but reduces jitter)
+        if self._cpu_ema is None:
+            self._cpu_ema = cpu
+        else:
+            a = 0.25  # smoothing factor (0.0=no update, 1.0=no smoothing)
+            self._cpu_ema = (1.0 - a) * self._cpu_ema + a * cpu
+        self._cpu = float(self._cpu_ema)
+
+        # 2) SYSTEM RAM
         try:
             vm = psutil.virtual_memory()
-            self._ram = vm.percent
+            self._ram = float(vm.percent)
         except Exception:
             self._ram = 0.0
 
-        # 3. App RAM
+        # 3) APP RAM (your process)
         try:
-            mb = get_memory_usage_mb()
+            mb = float(get_memory_usage_mb())
             self._app_ram_val = mb
             self._app_ram_str = f"{int(mb)} MB"
         except Exception:
@@ -177,13 +275,22 @@ class ResourceBackend(QObject):
 
     def stop(self):
         """Explicitly stop background threads."""
+        try:
+            if hasattr(self, "_timer") and self._timer.isActive():
+                self._timer.stop()
+        except Exception:
+            pass
+
         if hasattr(self, "_gpu_worker") and self._gpu_worker.isRunning():
             self._gpu_worker.requestInterruption()
             self._gpu_worker.quit()
             self._gpu_worker.wait(1000)
 
     def __del__(self):
-        self.stop()
+        try:
+            self.stop()
+        except Exception:
+            pass
 
 
 class SystemMonitorWidget(QQuickWidget):
@@ -192,7 +299,7 @@ class SystemMonitorWidget(QQuickWidget):
     """
     def __init__(self, parent=None):
         super().__init__(parent)
-        
+
         self.setResizeMode(QQuickWidget.ResizeMode.SizeRootObjectToView)
         self.setAttribute(Qt.WidgetAttribute.WA_AlwaysStackOnTop, False)
         self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
@@ -201,48 +308,39 @@ class SystemMonitorWidget(QQuickWidget):
         # Connect Backend
         self.backend = ResourceBackend(self)
         self.rootContext().setContextProperty("backend", self.backend)
-        
-        # We need to manually wire property updates because we are binding to root properties in QML
-        # Actually, simpler pattern: QML file reads from an object we inject.
-        # Let's adjust QML slightly to bind to `backend.cpuUsage` etc. if we can,
-        # OR we leave QML as having properties and we set them from Python.
-        #
-        # Better approach for Py+QML: 
-        # Inject `backend` into context, modify QML to use `backend.cpuUsage`.
-        # But since I already wrote QML with root properties, I will just set them directly 
-        # or update the QML file. Updating QML is cleaner.
-        #
-        # For now, let's keep QML independent and binding via setProperty? 
-        # No, properly: context property is best.
-        #
-        # Let's re-write the QML loading part to use a safer 'initialProperties' approach or just signal/slots.
-        #
-        # EASIEST: QML binds to `root.cpuUsage`. Python sets `root.cpuUsage`.
-        
-        self.backend.cpuChanged.connect(self._push_data_to_qml)
-        self.backend.ramChanged.connect(self._push_data_to_qml)
-        self.backend.gpuChanged.connect(self._push_data_to_qml)
-        self.backend.appRamChanged.connect(self._push_data_to_qml)
-        
+
         # Load QML
         qml_path = os.path.join(_get_base_path(), "qml", "ResourceMonitor.qml")
         self.setSource(QUrl.fromLocalFile(qml_path))
 
-    def _push_data_to_qml(self):
-        root = self.rootObject()
-        if root:
-            root.setProperty("cpuUsage", self.backend.cpuUsage)
-            root.setProperty("ramUsage", self.backend.ramUsage)
-            root.setProperty("gpuUsage", self.backend.gpuUsage)
-            root.setProperty("appRamString", self.backend.appRamString)
+    def closeEvent(self, e):
+        # make sure worker threads stop when widget closes
+        try:
+            if hasattr(self, "backend") and self.backend is not None:
+                self.backend.stop()
+        except Exception:
+            pass
+        super().closeEvent(e)
 
     # --- Drag & Drop Support ---
     def mousePressEvent(self, event):
         if event.button() == Qt.MouseButton.LeftButton:
+            # Wayland-friendly: ask compositor to move the window
+            wh = self.windowHandle()
+            if wh is not None:
+                try:
+                    wh.startSystemMove()
+                    event.accept()
+                    return
+                except Exception:
+                    pass
+
+            # Fallback (Windows/X11): manual move tracking
             self._drag_start_pos = event.globalPosition().toPoint() - self.frameGeometry().topLeft()
             event.accept()
-        else:
-            super().mousePressEvent(event)
+            return
+
+        super().mousePressEvent(event)
 
     def mouseMoveEvent(self, event):
         if event.buttons() & Qt.MouseButton.LeftButton: