Durcit les flux de compilation et détend la mise en page IDE-like

Sécurise la lecture temps réel stdout/stderr du processus de compilation pour éviter les crashs lorsque les flux ne sont pas disponibles.

Ajoute une détection explicite des flux monitorables, émet un warning unique quand stdout/stderr sont indisponibles, puis interrompt proprement la lecture live au lieu de laisser select ou read échouer.

Protège également la lecture résiduelle de fin de compilation en gérant le cas où stdout ou stderr valent None.

Ajoute un test de non-régression couvrant ce cas limite afin de vérifier qu'un warning est émis, qu'aucune sortie parasite n'est publiée et que la boucle de lecture live se désactive proprement.

Ajuste en parallèle la disposition de l'interface IDE-like pour réduire l'effet de compression visuelle : barre haute plus généreuse, largeur minimale accrue pour les boutons Build et Cancel, panneaux latéraux mieux bornés et proportions de splitters rééquilibrées afin de redonner de l'espace utile à la zone centrale et aux logs.

Author: raidos23

Core/Compiler/compiler.py

@@ -101,6 +101,8 @@ def __init__(
         self.cancel_requested = False
         self.process: Optional[subprocess.Popen] = None
         self.start_time: Optional[datetime] = None
+        self._live_output_disabled = False
+        self._stream_warning_emitted = False
 
     def run(self) -> None:
         """Exécute le processus de compilation."""
@@ -154,21 +156,15 @@ def _read_output(self) -> None:
             if self.process is None or self.process.poll() is not None:
                 break
 
-            stdout_stream = self.process.stdout
-            stderr_stream = self.process.stderr
-            if stdout_stream is None and stderr_stream is None:
-                self.error_ready.emit(
-                    "Warning: process streams are unavailable; stopping realtime read."
-                )
-                break
-
-            watched_streams = [s for s in (stdout_stream, stderr_stream) if s is not None]
-            if not watched_streams:
+            streams = self._available_live_streams()
+            if not streams:
+                self._warn_missing_live_streams()
+                self._live_output_disabled = True
                 break
 
             # Utiliser select pour attendre des données
             try:
-                ready, _, _ = select.select(watched_streams, [], [], 0.1)
+                ready, _, _ = select.select(streams, [], [], 0.1)
 
                 for stream in ready:
                     if stdout_stream is not None and stream == stdout_stream:
@@ -183,6 +179,8 @@ def _read_output(self) -> None:
                             self._update_progress(line)
 
             except Exception:
+                self._warn_missing_live_streams()
+                self._live_output_disabled = True
                 break
 
             time.sleep(0.01)
@@ -194,7 +192,10 @@ def _read_remaining(self) -> None:
 
         # Lire stdout restant
         try:
-            remaining_stdout = self.process.stdout.read() if self.process.stdout else ""
+            if self.process.stdout is None:
+                remaining_stdout = None
+            else:
+                remaining_stdout = self.process.stdout.read()
             if remaining_stdout:
                 for line in remaining_stdout.strip().split("\n"):
                     if line:
@@ -204,14 +205,43 @@ def _read_remaining(self) -> None:
 
         # Lire stderr restant
         try:
-            remaining_stderr = self.process.stderr.read() if self.process.stderr else ""
+            if self.process.stderr is None:
+                remaining_stderr = None
+            else:
+                remaining_stderr = self.process.stderr.read()
             if remaining_stderr:
                 for line in remaining_stderr.strip().split("\n"):
                     if line:
                         self.error_ready.emit(line.rstrip())
         except Exception:
             pass
 
+    def _available_live_streams(self) -> list:
+        """Return stdout/stderr streams that can be safely monitored in real time."""
+        if self.process is None:
+            return []
+        streams = []
+        try:
+            if getattr(self.process, "stdout", None) is not None:
+                streams.append(self.process.stdout)
+        except Exception:
+            pass
+        try:
+            if getattr(self.process, "stderr", None) is not None:
+                streams.append(self.process.stderr)
+        except Exception:
+            pass
+        return streams
+
+    def _warn_missing_live_streams(self) -> None:
+        """Emit a single warning when live stdout/stderr monitoring is unavailable."""
+        if self._stream_warning_emitted:
+            return
+        self._stream_warning_emitted = True
+        self.error_ready.emit(
+            "Warning: stdout/stderr unavailable; stopping real-time output reading."
+        )
+
     def _update_progress(self, line: str) -> None:
         """Met à jour la progression basée sur la sortie."""
         # Détecter les patterns de progression courants

Core/IdeLikeGui/connections.py

@@ -29,6 +29,8 @@
     QToolButton,
     QStatusBar,
     QWidget,
+    QFrame,
+    QSplitter,
 )
 
 
@@ -222,6 +224,78 @@ def _find(cls, name: str):
     _setup_status_bar(self)
 
 
+def _tune_ide_like_layout(self) -> None:
+    """Relax tight layout constraints in the IDE-like UI for better label fit."""
+    header = self.ui.findChild(QFrame, "header")
+    if header is not None:
+        try:
+            header.setMinimumHeight(48)
+            header.setMaximumHeight(56)
+        except Exception:
+            pass
+
+    for btn_name in ("compile_btn", "cancel_btn"):
+        btn = getattr(self, btn_name, None)
+        if btn is None:
+            continue
+        try:
+            btn.setMinimumSize(124, 34)
+        except Exception:
+            pass
+
+    workspace_panel = self.ui.findChild(QFrame, "workspace_panel")
+    if workspace_panel is not None:
+        try:
+            workspace_panel.setMinimumWidth(280)
+            workspace_panel.setMaximumWidth(400)
+        except Exception:
+            pass
+
+    tools_panel = self.ui.findChild(QFrame, "tools_panel")
+    if tools_panel is not None:
+        try:
+            tools_panel.setMinimumWidth(200)
+            tools_panel.setMaximumWidth(280)
+        except Exception:
+            pass
+
+    logs_panel = self.ui.findChild(QFrame, "logs_panel")
+    if logs_panel is not None:
+        try:
+            logs_panel.setMinimumHeight(190)
+            logs_panel.setMaximumHeight(320)
+        except Exception:
+            pass
+
+    main_splitter = self.ui.findChild(QSplitter, "mainSplitter")
+    if main_splitter is not None:
+        try:
+            main_splitter.setStretchFactor(0, 0)
+            main_splitter.setStretchFactor(1, 0)
+            main_splitter.setStretchFactor(2, 1)
+            main_splitter.setSizes([52, 300, 1013])
+        except Exception:
+            pass
+
+    top_splitter = self.ui.findChild(QSplitter, "topSplitter")
+    if top_splitter is not None:
+        try:
+            top_splitter.setStretchFactor(0, 1)
+            top_splitter.setStretchFactor(1, 0)
+            top_splitter.setSizes([820, 245])
+        except Exception:
+            pass
+
+    right_splitter = self.ui.findChild(QSplitter, "rightSplitter")
+    if right_splitter is not None:
+        try:
+            right_splitter.setStretchFactor(0, 1)
+            right_splitter.setStretchFactor(1, 0)
+            right_splitter.setSizes([470, 230])
+        except Exception:
+            pass
+
+
 def _setup_ide_like_compiler_tabs(self) -> None:
     """Bind engine tabs to compiler_tabs using existing EngineLoader registry."""
     tabs = getattr(self, "compiler_tabs", None)
@@ -572,6 +646,7 @@ def init_ide_like_ui(self) -> None:
     """Initialize the ide-like UI and wire it to existing Core methods."""
     _load_ide_like_ui(self)
     _map_ide_like_widgets(self)
+    _tune_ide_like_layout(self)
     _apply_classic_policies(self)
     _setup_more_tools_menu(self)
     try:

tests/test_compiler_smoke.py

@@ -17,8 +17,13 @@
 
 from __future__ import annotations
 
+import pytest
+
+pytest.importorskip("PySide6")
+
 from Core.ArkConfigManager import set_entrypoint
 import Core.Compiler as compiler_module
+from Core.Compiler.compiler import CompilationThread
 
 
 class DummyMainProcess:
@@ -101,3 +106,28 @@ def fake_start(_self, _engine, files):
     compiler_module.compile_all(gui)
 
     assert captured.get("files") == [str(entry)]
+
+
+def test_compilation_thread_warns_when_live_streams_are_unavailable() -> None:
+    thread = CompilationThread(program="python", args=["-V"])
+    warnings: list[str] = []
+    outputs: list[str] = []
+
+    thread.error_ready.connect(warnings.append)
+    thread.output_ready.connect(outputs.append)
+
+    class DummyProcess:
+        stdout = None
+        stderr = None
+
+        def poll(self):
+            return None
+
+    thread.process = DummyProcess()
+
+    thread._read_output()
+    thread._read_remaining()
+
+    assert thread._live_output_disabled is True
+    assert any("stdout/stderr unavailable" in msg for msg in warnings)
+    assert outputs == []