perfectionnement des systems

Author: PyCompiler ARK++

Core/Compiler/mainprocess.py

@@ -41,54 +41,8 @@
 from ..Auto_Command_Builder import compute_for_all
 from ..preferences import MAX_PARALLEL
 
-# Wrapper ACASL inspiré du modèle BCASL: garantit arrêt propre et callback sur thread GUI
-from PySide6.QtCore import QTimer as _QTimer
+# ACASL support removed (obsolete)
 
-def safe_run_acasl_async(self, artifacts: list[str], finished_cb=None) -> None:
-    try:
-        from acasl import run_post_compile_async as _acasl_run, ensure_acasl_thread_stopped as _acasl_stop
-    except Exception:
-        # Si ACASL indisponible, renvoyer un rapport 'disabled'
-        try:
-            if callable(finished_cb):
-                _QTimer.singleShot(0, lambda: finished_cb({"status": "disabled", "plugins": []}))
-        except Exception:
-            pass
-        return
-    # Arrêt propre d'un éventuel ACASL en cours
-    try:
-        _acasl_stop(self)
-    except Exception:
-        pass
-    # Ne pas lancer si l'UI est en fermeture
-    try:
-        if hasattr(self, "_closing") and bool(getattr(self, "_closing")):
-            if callable(finished_cb):
-                _QTimer.singleShot(0, lambda: finished_cb({"status": "cancelled"}))
-            return
-    except Exception:
-        pass
-    # Wrapper qui garantit l'exécution du callback dans le thread GUI
-    def _finish_on_gui(rep):
-        try:
-            if callable(finished_cb):
-                _QTimer.singleShot(0, lambda r=rep: finished_cb(r))
-        except Exception:
-            pass
-    try:
-        _acasl_run(self, list(artifacts or []), finished_cb=_finish_on_gui)
-    except Exception as e:
-        # Journaliser et renvoyer une erreur non bloquante
-        try:
-            if hasattr(self, "log") and self.log:
-                self.log.append(f"❌ ACASL: échec de lancement: {e}")
-        except Exception:
-            pass
-        try:
-            if callable(finished_cb):
-                _QTimer.singleShot(0, lambda: finished_cb({"status": "error", "error": str(e)}))
-        except Exception:
-            pass
 
 
 def try_start_processes(self):
@@ -105,110 +59,34 @@ def try_start_processes(self):
         self.progress.setRange(0, 1)
         self.progress.setValue(1)
         from PySide6.QtWidgets import QApplication
-
         QApplication.processEvents()
         self.log.append("✔️ Toutes les compilations sont terminées.\n")
-        # Collecter les artefacts dès maintenant
-        artifacts = []
+        # Exécuter immédiatement les hooks de succès des moteurs et restaurer l'UI
         try:
-            import os as _os
-
-            ws = self.workspace_dir or os.getcwd()
-            for d in ("dist", "build"):
-                dp = os.path.join(ws, d)
-                if os.path.isdir(dp):
-                    for root, _dirs, files in os.walk(dp):
-                        for f in files:
-                            artifacts.append(os.path.join(root, f))
-        except Exception:
-            pass
-        # Décider si ACASL doit s'exécuter; sinon restaurer l'UI immédiatement
-        try:
-            import os as _os
-
-            no_hooks = True
-        except Exception:
-            no_hooks = False
-        # ACASL removed: execute engine success hooks immediately and restore UI
-        if True:
-            try:
-                hooks = getattr(self, "_pending_engine_success_hooks", [])
-                for (eng, fpath) in hooks:
-                    try:
-                        eng.on_success(self, fpath)
-                    except Exception:
-                        try:
-                            self.log.append(
-                                f"⚠️ on_success du moteur '{getattr(eng, 'id', '?')}' a échoué."
-                            )
-                        except Exception:
-                            pass
-            except Exception:
-                pass
-            finally:
+            hooks = getattr(self, "_pending_engine_success_hooks", [])
+            for (eng, fpath) in hooks:
                 try:
-                    if hasattr(self, "_pending_engine_success_hooks"):
-                        self._pending_engine_success_hooks.clear()
+                    eng.on_success(self, fpath)
                 except Exception:
-                    pass
-            if hasattr(self, "compiler_tabs") and self.compiler_tabs:
-                self.compiler_tabs.setEnabled(True)
-            self.set_controls_enabled(True)
-            self.save_preferences()
-            return
-            # Laisser l'UI désactivée jusqu'à la fin d'ACASL, puis restaurer dans le callback
-            try:
-                from acasl import run_post_compile_async
-
-                def _after_acasl(_rep):
-                    # Exécuter maintenant tous les hooks on_success engrangés
-                    try:
-                        hooks = getattr(self, "_pending_engine_success_hooks", [])
-                        for (eng, fpath) in hooks:
-                            try:
-                                eng.on_success(self, fpath)
-                            except Exception:
-                                try:
-                                    self.log.append(
-                                        f"⚠️ on_success du moteur '{getattr(eng, 'id', '?')}' a échoué."
-                                    )
-                                except Exception:
-                                    pass
-                    except Exception:
-                        pass
-                    finally:
-                        try:
-                            if hasattr(self, "_pending_engine_success_hooks"):
-                                self._pending_engine_success_hooks.clear()
-                        except Exception:
-                            pass
-                    # Restaurer l'UI
-                    try:
-                        if hasattr(self, "compiler_tabs") and self.compiler_tabs:
-                            self.compiler_tabs.setEnabled(True)
-                    except Exception:
-                        pass
                     try:
-                        self.set_controls_enabled(True)
+                        self.log.append(
+                            f"⚠️ on_success du moteur '{getattr(eng, 'id', '?')}' a échoué."
+                        )
                     except Exception:
                         pass
-                    try:
-                        self.save_preferences()
-                    except Exception:
-                        pass
-
-                QTimer.singleShot(
-                    0,
-                    lambda a=list(artifacts): safe_run_acasl_async(
-                        self, a, finished_cb=_after_acasl
-                    ),
-                )
+        except Exception:
+            pass
+        finally:
+            try:
+                if hasattr(self, "_pending_engine_success_hooks"):
+                    self._pending_engine_success_hooks.clear()
             except Exception:
-                # En cas d'échec de démarrage d'ACASL, restaurer l'UI immédiatement
-                if hasattr(self, "compiler_tabs") and self.compiler_tabs:
-                    self.compiler_tabs.setEnabled(True)
-                self.set_controls_enabled(True)
-                self.save_preferences()
+                pass
+        if hasattr(self, "compiler_tabs") and self.compiler_tabs:
+            self.compiler_tabs.setEnabled(True)
+        self.set_controls_enabled(True)
+        self.save_preferences()
+        return
 
 
 def start_compilation_process(self, file):
@@ -302,7 +180,26 @@ def start_compilation_process(self, file):
     process._cancel_file = cancel_file
     process.readyReadStandardOutput.connect(lambda p=process: self.handle_stdout(p))
     process.readyReadStandardError.connect(lambda p=process: self.handle_stderr(p))
-    process.finished.connect(lambda ec, es, p=process: self.handle_finished(p, ec, es))
+    
+    # Capture stderr data before process deletion to avoid accessing deleted C++ object
+    def _on_finished(ec, es, p=process):
+        try:
+            # Save stderr data before process is deleted
+            p._final_stderr = p.readAllStandardError().data().decode()
+        except Exception:
+            p._final_stderr = ""
+        try:
+            self.handle_finished(p, ec, es)
+        except Exception:
+            pass
+        finally:
+            # Schedule deletion after handle_finished completes
+            try:
+                p.deleteLater()
+            except Exception:
+                pass
+    
+    process.finished.connect(_on_finished)
     self.processes.append(process)
     self.current_compiling.add(file)
     # Optional: update dependent UI states
@@ -384,8 +281,6 @@ def _cancel_timer(_ec, _es, timer=t):
                     pass
 
             process.finished.connect(_cancel_timer)
-            # Ensure QProcess object is deleted later to avoid dangling C++ objects
-            process.finished.connect(lambda _ec, _es, p=process: p.deleteLater())
     except Exception:
         pass
     process.start()
@@ -790,7 +685,8 @@ def handle_finished(self, process, exit_code, exit_status):
             pass
     else:
         # Ajout d'un affichage détaillé pour les erreurs inattendues
-        error_details = process.readAllStandardError().data().decode()
+        # Use saved stderr data to avoid accessing deleted C++ object
+        error_details = getattr(process, "_final_stderr", "")
         self.log.append(
             f"<span style='color:red;'>❌ La compilation de {file_basename} ({file}) a échoué (code {exit_code}).</span>\n"
         )
@@ -989,12 +885,7 @@ def cancel_all_compilations(self):
                 self.processes.remove(process)
             except ValueError:
                 pass
-    # Last resort: stop ACASL thread and nuke any remaining descendants of our GUI process
-    try:
-        # ACASL removed: nothing to stop here
-        pass
-    except Exception:
-        pass
+    # ACASL removed: no post-compile thread to stop
     try:
         _kill_all_descendants(timeout=1.0, log=self.log.append)
     except Exception:

Core/MainWindow.py

@@ -184,6 +184,8 @@ def __init__(self):
 
         self.load_preferences()
         self.init_ui()
+        
+                
         # Détection langue système si préférence = "System"
         import locale
 
@@ -1547,17 +1549,9 @@ def _on_result(res):
                 # Registry-based propagation to engine instances
                 try:
                     import Core.engines_loader as engines_loader
-
                     engines_loader.registry.apply_translations(self, tr)
                 except Exception:
                     pass
-                # Propagate translations to all BCASL plugins
-                try:
-                    import bcasl.Loader as bcasl_loader
-
-                    bcasl_loader.apply_translations(self, tr)
-                except Exception:
-                    pass
             except Exception:
                 pass
             # Update markers
@@ -1717,6 +1711,7 @@ def _safe_log(self, text):
             except Exception:
                 pass
 
+    
     def _has_active_background_tasks(self):
         # Compilation en cours
         if self.processes:
@@ -1728,6 +1723,13 @@ def _has_active_background_tasks(self):
             and self.venv_manager.has_active_tasks()
         ):
             return True
+        # BCASL (pré-compilation) en cours
+        try:
+            bcasl_thread = getattr(self, "_bcasl_thread", None)
+            if bcasl_thread is not None and bcasl_thread.is_alive():
+                return True
+        except Exception:
+            pass
         return False
 
     def _terminate_background_tasks(self):
@@ -1745,28 +1747,60 @@ def closeEvent(self, event):
                 details.append("compilation")
             if hasattr(self, "venv_manager") and self.venv_manager:
                 details.extend(self.venv_manager.get_active_task_labels("Français"))
-            if getattr(self, "current_language", "Français") == "English":
+            
+            is_english = getattr(self, "current_language", "Français") == "English"
+            
+            if is_english:
                 mapping = {
                     "compilation": "build",
                     "création du venv": "venv creation",
                     "installation des dépendances": "dependencies installation",
                     "vérification/installation du venv": "venv check/installation",
                 }
                 details_disp = [mapping.get(d, d) for d in details]
-                msg = "A process is running"
+                
+                # Construire le message détaillé
+                title = "⚠️ Process Running"
+                msg = "A process is currently running:\n\n"
                 if details_disp:
-                    msg += " (" + ", ".join(details_disp) + ")"
-                msg += ". Do you really want to stop and quit?"
-                title = "Process running"
+                    for detail in details_disp:
+                        msg += f"  • {detail}\n"
+                    msg += "\n"
+                msg += "If you quit now, the process will be stopped and any unsaved work will be lost.\n\n"
+                msg += "Do you really want to quit?"
+                
+                yes_text = "Yes, Quit"
+                no_text = "No, Continue"
             else:
-                msg = "Un processus est en cours"
-                if details:
-                    msg += " (" + ", ".join(details) + ")"
-                msg += ". Voulez-vous vraiment arrêter et quitter ?"
-                title = "Processus en cours"
-            reply = QMessageBox.question(
-                self, title, msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.No
-            )
+                details_disp = details
+                
+                # Construire le message détaillé
+                title = "⚠️ Processus en cours"
+                msg = "Un processus est actuellement en cours :\n\n"
+                if details_disp:
+                    for detail in details_disp:
+                        msg += f"  • {detail}\n"
+                    msg += "\n"
+                msg += "Si vous quittez maintenant, le processus sera arrêté et tout travail non sauvegardé sera perdu.\n\n"
+                msg += "Voulez-vous vraiment quitter ?"
+                
+                yes_text = "Oui, Quitter"
+                no_text = "Non, Continuer"
+            
+            # Créer la boîte de dialogue avec des boutons personnalisés
+            msgbox = QMessageBox(self)
+            msgbox.setWindowTitle(title)
+            msgbox.setText(msg)
+            msgbox.setIcon(QMessageBox.Warning)
+            msgbox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
+            msgbox.setDefaultButton(QMessageBox.No)
+            
+            # Personnaliser les textes des boutons
+            msgbox.button(QMessageBox.Yes).setText(yes_text)
+            msgbox.button(QMessageBox.No).setText(no_text)
+            
+            reply = msgbox.exec()
+            
             if reply == QMessageBox.Yes:
                 self._closing = True
                 # Annule les compilations en cours si nécessaire