Ajouter l'annulation des processus sys deps et leur arrêt propre à la fermeture

Author: raidos23

Core/Gui.py

@@ -431,6 +431,14 @@ def _has_active_background_tasks(self) -> bool:
                 return True
         except Exception:
             pass
+        try:
+            tasks = getattr(self, "_sysdep_tasks", None) or []
+            for task in list(tasks):
+                proc = task.get("process") if isinstance(task, dict) else None
+                if proc is not None and proc.state() != proc.NotRunning:
+                    return True
+        except Exception:
+            pass
         return False
 
     def _terminate_background_tasks(self):
@@ -440,6 +448,25 @@ def _terminate_background_tasks(self):
                 self.venv_manager.terminate_tasks()
         except Exception:
             pass
+        try:
+            tasks = getattr(self, "_sysdep_tasks", None) or []
+            for task in list(tasks):
+                proc = task.get("process") if isinstance(task, dict) else None
+                dlg = task.get("dialog") if isinstance(task, dict) else None
+                try:
+                    if proc is not None and proc.state() != proc.NotRunning:
+                        proc.kill()
+                except Exception:
+                    pass
+                try:
+                    if dlg is not None:
+                        dlg.close()
+                except Exception:
+                    pass
+            if isinstance(tasks, list):
+                tasks.clear()
+        except Exception:
+            pass
 
     # =========================================================================
     # ÉVÉNEMENT DE FERMETURE
@@ -461,6 +488,20 @@ def closeEvent(self, event):
                     )
                 except Exception:
                     pass
+            try:
+                tasks = getattr(self, "_sysdep_tasks", None) or []
+                for task in list(tasks):
+                    if not isinstance(task, dict):
+                        continue
+                    proc = task.get("process")
+                    if proc is None or proc.state() == proc.NotRunning:
+                        continue
+                    if is_french:
+                        details.append(task.get("label_fr") or "dépendances système")
+                    else:
+                        details.append(task.get("label_en") or "system dependencies")
+            except Exception:
+                pass
 
             if not is_french:
                 mapping = {"compilation": "build"}

Core/sys_deps.py

@@ -53,6 +53,7 @@ def _invoke_in_main_thread(fn, *args, **kwargs):
 class SysDependencyManager:
     def __init__(self, parent_widget=None):
         self.parent_widget = parent_widget
+        self._cancelled_procs: set[int] = set()
         # Register list of system dependency tasks on the parent widget for global coordination
         try:
             if parent_widget is not None and not hasattr(
@@ -97,6 +98,81 @@ def _unregister_task(self, proc: QProcess) -> None:
                     tasks.remove(t)
         except Exception:
             pass
+        try:
+            if proc is not None:
+                self._cancelled_procs.discard(id(proc))
+        except Exception:
+            pass
+
+    def _mark_process_cancelled(self, proc: Optional[QProcess]) -> None:
+        try:
+            if proc is not None:
+                self._cancelled_procs.add(id(proc))
+        except Exception:
+            pass
+
+    def _is_process_cancelled(self, proc: Optional[QProcess]) -> bool:
+        try:
+            return proc is not None and id(proc) in self._cancelled_procs
+        except Exception:
+            return False
+
+    def _log_cancel(self, fr: str, en: str) -> None:
+        text = self.tr(fr, en)
+        try:
+            if (
+                self.parent_widget is not None
+                and hasattr(self.parent_widget, "_safe_log")
+                and callable(self.parent_widget._safe_log)
+            ):
+                self.parent_widget._safe_log(text)
+        except Exception:
+            pass
+        try:
+            self._dbg(text)
+        except Exception:
+            pass
+
+    def _cancel_task(
+        self, proc: Optional[QProcess], dlg: Optional[ProgressDialog], label_fr: str, label_en: str
+    ) -> None:
+        self._mark_process_cancelled(proc)
+        self._log_cancel(
+            f"🛑 Annulation demandée: {label_fr}.",
+            f"🛑 Cancellation requested: {label_en}.",
+        )
+        try:
+            if proc is not None and proc.state() != QProcess.NotRunning:
+                proc.kill()
+        except Exception:
+            pass
+        try:
+            if dlg is not None:
+                dlg.close()
+        except Exception:
+            pass
+        try:
+            if proc is not None:
+                self._unregister_task(proc)
+        except Exception:
+            pass
+
+    def _bind_cancel_button(
+        self,
+        dlg: Optional[ProgressDialog],
+        proc: Optional[QProcess],
+        label_fr: str,
+        label_en: str,
+    ) -> None:
+        try:
+            btn = getattr(dlg, "btn_cancel", None) if dlg is not None else None
+            if btn is None:
+                return
+            btn.clicked.connect(
+                lambda: self._cancel_task(proc, dlg, label_fr, label_en)
+            )
+        except Exception:
+            pass
 
     # ------------- Debug/telemetry helpers -------------
     def set_debug(self, enabled: bool = True) -> None:
@@ -532,14 +608,31 @@ def install_packages_windows(self, packages: list[dict]) -> Optional[QProcess]:
                     "Installing Windows dependencies",
                 ),
                 self.parent_widget,
+                cancelable=True,
             )
             dlg.set_message(self.tr("Préparation…", "Preparing…"))
             dlg.progress.setRange(0, 0)
             dlg.show()
             queue = list(packages)
             proc = QProcess(self.parent_widget)
+            state = {"cancelled": False}
+
+            def _cancel_winget():
+                if state["cancelled"]:
+                    return
+                state["cancelled"] = True
+                self._cancel_task(proc, dlg, "installation winget", "winget installation")
+
+            try:
+                btn = getattr(dlg, "btn_cancel", None)
+                if btn is not None:
+                    btn.clicked.connect(_cancel_winget)
+            except Exception:
+                pass
 
             def _start_next():
+                if state["cancelled"] or self._is_process_cancelled(proc):
+                    return
                 if not queue:
                     try:
                         dlg.close()
@@ -581,6 +674,8 @@ def _start_next():
                 proc.start()
 
             def _on_output(p: QProcess, error: bool = False):
+                if state["cancelled"] or self._is_process_cancelled(proc):
+                    return
                 try:
                     data = (
                         p.readAllStandardError().data().decode()
@@ -601,6 +696,8 @@ def _on_output(p: QProcess, error: bool = False):
                     pass
 
             def _on_finished(_ec, _es):
+                if state["cancelled"] or self._is_process_cancelled(proc):
+                    return
                 _start_next()
 
             proc.readyReadStandardOutput.connect(lambda p=proc: _on_output(p, False))
@@ -632,18 +729,25 @@ def start_process_with_progress(
         Le dialogue se ferme automatiquement à la fin du processus.
         """
         try:
-            dlg = ProgressDialog(self.tr(title_fr, title_en), self.parent_widget)
+            dlg = ProgressDialog(
+                self.tr(title_fr, title_en), self.parent_widget, cancelable=True
+            )
             dlg.set_message(self.tr(start_msg_fr, start_msg_en))
             dlg.progress.setRange(0, 0)  # indéterminé
             dlg.show()
             proc = QProcess(self.parent_widget)
+            self._bind_cancel_button(
+                dlg, proc, "installation des dépendances", "dependencies installation"
+            )
             if cwd:
                 proc.setWorkingDirectory(cwd)
             proc.setProgram(program)
             proc.setArguments(list(args or []))
 
             # Mise à jour du message avec la dernière ligne reçue
             def _on_output(p: QProcess, error: bool = False):
+                if self._is_process_cancelled(proc):
+                    return
                 try:
                     data = (
                         p.readAllStandardError().data().decode()
@@ -710,11 +814,16 @@ def run_sudo_shell_with_progress(
                     "This sudo operation is supported on Linux only.",
                 )
                 return None
-            dlg = ProgressDialog(self.tr(title_fr, title_en), self.parent_widget)
+            dlg = ProgressDialog(
+                self.tr(title_fr, title_en), self.parent_widget, cancelable=True
+            )
             dlg.set_message(self.tr(start_msg_fr, start_msg_en))
             dlg.progress.setRange(0, 0)
             dlg.show()
             proc = QProcess(self.parent_widget)
+            self._bind_cancel_button(
+                dlg, proc, "installation des dépendances", "dependencies installation"
+            )
             if cwd:
                 proc.setWorkingDirectory(cwd)
             # Utiliser bash -lc pour exécuter la chaîne
@@ -723,6 +832,8 @@ def run_sudo_shell_with_progress(
 
             # maj message sur sortie
             def _on_output(p: QProcess, error: bool = False):
+                if self._is_process_cancelled(proc):
+                    return
                 try:
                     data = (
                         p.readAllStandardError().data().decode()