feat: ajouter le split terminal (plusieurs panneaux par onglet)

Layouts : 1 (normal), 2 verticaux (cote a cote), 2 horizontaux (empiles), 4
panneaux (grille 2x2), via des QSplitter imbriques (app/ui/split_pane.py).
Chaque panneau reutilise tel quel un widget d'onglet existant
(SessionTabWidget, LocalTerminalTabWidget) : aucune modification de ces
classes, seule une fine barre (menu ☰ + fermeture) les enveloppe.

- Menu contextuel d'un onglet (SSH ou terminal local, pas SFTP, pas
  d'imbrication de splits) : "Diviser" -> choix du layout. Le contenu actuel
  occupe le premier panneau, les autres recoivent un terminal local par
  defaut.
- Menu ☰ d'un panneau : changer son contenu (autre terminal local), ou
  "Deplacer un onglet ici" pour y faire migrer un onglet de premier niveau
  existant sans fermer sa connexion.
- Fermer un panneau le retire de son QSplitter (qui redistribue l'espace tout
  seul) ; s'il n'en reste qu'un, l'onglet redevient un onglet normal
  (redescente automatique, pas de chrome de split residuel).
- Fermer l'onglet divise (bouton x) ferme toutes les connexions des panneaux.
- BroadcastManager (Multi-Send) atteint desormais aussi les panneaux a
  l'interieur d'un split (MainWindow._iter_tabs les deplie).

Bug intercepte par les tests avant integration : reparenter le widget d'origine
dans son panneau retire automatiquement son onglet du QTabWidget (un widget ne
peut avoir qu'un seul parent), ce qui decale les onglets suivants ; un appel
explicite a removeTab() ensuite visait donc le mauvais onglet. Corrige en
laissant Qt gerer ce retrait implicitement plutot que de le dupliquer.

tests/test_split_terminal.py : SSHConnection.start()/LocalTerminalConnection.start()
neutralisees (teste l'agencement des panneaux et le cycle de vie des onglets,
pas une connexion reelle).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

app/controllers/connection_controller.py

@@ -15,6 +15,7 @@ from app.openssh.config import OpenSSHHost, session_from_openssh_host
 from app.bastion import BastionTarget, resolve_bastion_target, BastionResolutionError
 from app.controllers.broadcast_manager import BroadcastManager
 from app.ui.tabs import BaseTerminalTab, SessionTabWidget, SFTPTabWidget, LocalTerminalTabWidget
+from app.ui.split_pane import SplitContainer, PaneSlot, LAYOUT_LABELS
 
 
 class ConnectionController(QObject):
@@ -108,13 +109,19 @@ class ConnectionController(QObject):
         self.open_session(session_from_openssh_host(host))
 
     def open_local_terminal(self, shell: str = DEFAULT_SHELL) -> None:
-        tab = LocalTerminalTabWidget(shell)
-        tab.sftp_requested.connect(self.quick_sftp)
-        self.broadcast.register(tab)
+        tab = self._new_local_terminal(shell)
         label = SHELL_LABELS.get(shell, shell)
         index = self.tabs.addTab(tab, f"💻 {label}")
         self.tabs.setCurrentIndex(index)
 
+    def _new_local_terminal(self, shell: str = DEFAULT_SHELL) -> LocalTerminalTabWidget:
+        """Cree un terminal local cable (multi-send, SFTP detecte), sans l'ajouter
+        au QTabWidget : reutilise pour un onglet normal comme pour un panneau."""
+        tab = LocalTerminalTabWidget(shell)
+        tab.sftp_requested.connect(self.quick_sftp)
+        self.broadcast.register(tab)
+        return tab
+
     def quick_sftp(self, target: dict | None = None) -> None:
         """Ouvre un SFTP en saisissant directement les infos de connexion, sans favori.
 
@@ -183,9 +190,20 @@ class ConnectionController(QObject):
         index = bar.tabAt(pos)
         if index < 0:
             return
+        widget = self.tabs.widget(index)
         menu = QMenu(self._parent_widget)
         act_rename = menu.addAction("Renommer... (double-clic)")
         menu.addSeparator()
+
+        # Diviser : seulement pour un terminal simple (SSH ou local), pas pour
+        # un SFTP ni pour un split existant (pas d'imbrication de splits).
+        split_actions = {}
+        if isinstance(widget, (SessionTabWidget, LocalTerminalTabWidget)):
+            split_menu = menu.addMenu("Diviser")
+            for kind, label in LAYOUT_LABELS.items():
+                split_actions[split_menu.addAction(label)] = kind
+            menu.addSeparator()
+
         act_close = menu.addAction("Fermer cet onglet")
         act_close_others = menu.addAction("Fermer les autres onglets")
         act_close_others.setEnabled(self.tabs.count() > 1)
@@ -201,10 +219,14 @@ class ConnectionController(QObject):
             for other in range(self.tabs.count() - 1, -1, -1):
                 if self.tabs.widget(other) is not cible:
                     self._on_tab_close(other)
+        elif action in split_actions:
+            self.split_tab(index, split_actions[action])
 
     def _on_tab_close(self, index: int) -> None:
         widget = self.tabs.widget(index)
-        if isinstance(widget, (BaseTerminalTab, SFTPTabWidget)):
+        if isinstance(widget, SplitContainer):
+            widget.close_all()
+        elif isinstance(widget, (BaseTerminalTab, SFTPTabWidget)):
             widget.close_connection()
         self.tabs.removeTab(index)
 
@@ -213,5 +235,92 @@ class ConnectionController(QObject):
         connexions (SSH, locales, SFTP) avant que les widgets ne soient detruits."""
         for i in range(self.tabs.count()):
             widget = self.tabs.widget(i)
-            if isinstance(widget, (BaseTerminalTab, SFTPTabWidget)):
+            if isinstance(widget, SplitContainer):
+                widget.close_all()
+            elif isinstance(widget, (BaseTerminalTab, SFTPTabWidget)):
                 widget.close_connection()
+
+    # ---------- split terminal ----------
+    def split_tab(self, index: int, layout_kind: str) -> None:
+        """Transforme l'onglet en une grille de terminaux : le contenu actuel
+        occupe le premier panneau, les autres recoivent un terminal local par
+        defaut (remplacable ensuite via le menu ☰ de chaque panneau)."""
+        widget = self.tabs.widget(index)
+        if not isinstance(widget, (SessionTabWidget, LocalTerminalTabWidget)):
+            return
+        title = self.tabs.tabText(index)
+        # SplitContainer reparente `widget` dans un de ses panneaux ; Qt retire
+        # alors tout seul l'onglet correspondant (un widget ne peut avoir qu'un
+        # parent), en decalant les onglets suivants - inutile donc d'appeler
+        # removeTab(index) explicitement, ce qui viserait desormais un autre onglet.
+        container = SplitContainer(widget, layout_kind, self._new_local_terminal)
+        container.all_panes_closed.connect(
+            lambda remaining, c=container: self._on_split_collapsed(c, remaining)
+        )
+        container.pane_menu_requested.connect(self._show_pane_menu)
+        self.tabs.insertTab(index, container, f"⊞ {title}")
+        self.tabs.setCurrentIndex(index)
+
+    def _on_split_collapsed(self, container: SplitContainer, remaining: QWidget | None) -> None:
+        """Il ne reste plus qu'un panneau : on redeplie vers un onglet normal."""
+        index = self.tabs.indexOf(container)
+        if index < 0:
+            return
+        self.tabs.removeTab(index)
+        if remaining is None:
+            return
+        title = self._default_title_for(remaining)
+        self.tabs.insertTab(index, remaining, title)
+        self.tabs.setCurrentIndex(index)
+
+    @staticmethod
+    def _default_title_for(widget: QWidget) -> str:
+        if isinstance(widget, SessionTabWidget):
+            return f"🖥 {widget.session.name}"
+        if isinstance(widget, SFTPTabWidget):
+            return f"📁 {widget.session.name}"
+        if isinstance(widget, LocalTerminalTabWidget):
+            return f"💻 {SHELL_LABELS.get(widget.shell, widget.shell)}"
+        return "Onglet"
+
+    def _movable_tabs(self) -> list[tuple[int, str, QWidget]]:
+        """Onglets de premier niveau deplacables vers un panneau (ni SFTP, ni
+        un split - on ne gere pas les deplacements panneau-a-panneau)."""
+        result = []
+        for i in range(self.tabs.count()):
+            widget = self.tabs.widget(i)
+            if isinstance(widget, (SessionTabWidget, LocalTerminalTabWidget)):
+                result.append((i, self.tabs.tabText(i), widget))
+        return result
+
+    def _show_pane_menu(self, pane: PaneSlot, container: SplitContainer) -> None:
+        menu = QMenu(self._parent_widget)
+        term_menu = menu.addMenu("Terminal local")
+        shell_actions = {}
+        for shell_id, label in SHELL_LABELS.items():
+            shell_actions[term_menu.addAction(label)] = shell_id
+
+        movable = self._movable_tabs()
+        move_actions = {}
+        if movable:
+            menu.addSeparator()
+            move_menu = menu.addMenu("Deplacer un onglet ici")
+            for index, title, widget in movable:
+                move_actions[move_menu.addAction(title)] = (index, widget)
+        else:
+            hint = menu.addAction("(aucun autre onglet a deplacer ici)")
+            hint.setEnabled(False)
+
+        action = menu.exec(pane.menu_btn.mapToGlobal(pane.menu_btn.rect().bottomLeft()))
+        if action in shell_actions:
+            container.replace_pane_content(pane, self._new_local_terminal(shell_actions[action]))
+        elif action in move_actions:
+            index, moved_widget = move_actions[action]
+            self.move_tab_into_pane(index, container, pane)
+
+    def move_tab_into_pane(self, tab_index: int, container: SplitContainer, pane: PaneSlot) -> None:
+        """Deplace l'onglet de premier niveau `tab_index` dans `pane` : sa
+        connexion continue de vivre, seul son emplacement visuel change."""
+        widget = self.tabs.widget(tab_index)
+        self.tabs.removeTab(tab_index)  # ne ferme pas la connexion : elle continue dans le panneau
+        container.replace_pane_content(pane, widget)

app/main_window.py

@@ -22,6 +22,7 @@ from app.theme import THEME_LABELS, apply_theme, current_theme, save_theme
 from app.controllers.broadcast_manager import BroadcastManager
 from app.controllers.session_controller import SessionController
 from app.controllers.connection_controller import ConnectionController
+from app.ui.split_pane import SplitContainer
 
 # re-exporte pour compatibilite (utilise par tests/test_detect.py et du code existant)
 from app.services.ssh_target import detect_ssh_target  # noqa: F401
@@ -59,8 +60,17 @@ class MainWindow(QMainWindow):
         return self.connection_controller.tabs
 
     def _iter_tabs(self):
+        """Widgets de terminal joignables par le Multi-Send : les onglets de
+        premier niveau, et les panneaux a l'interieur des onglets divises."""
         tabs = self.connection_controller.tabs
-        return [tabs.widget(i) for i in range(tabs.count())]
+        result = []
+        for i in range(tabs.count()):
+            widget = tabs.widget(i)
+            if isinstance(widget, SplitContainer):
+                result.extend(pane.content for pane in widget.panes)
+            else:
+                result.append(widget)
+        return result
 
     # ---------- cablage entre controleurs ----------
     def _wire_controllers(self) -> None:

app/ui/split_pane.py

@@ -0,0 +1,150 @@
+"""Affichage de plusieurs terminaux dans un meme onglet (split), via des
+QSplitter imbriques.
+
+Un SplitContainer prend la place d'un onglet normal dans le QTabWidget de
+ConnectionController ; chaque panneau (PaneSlot) heberge un widget d'onglet
+existant (SessionTabWidget, LocalTerminalTabWidget, ...) sans le modifier.
+"""
+from __future__ import annotations
+
+from typing import Callable
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QSplitter, QToolButton, QFrame,
+)
+
+LAYOUT_SINGLE = "1"
+LAYOUT_2V = "2v"  # 2 panneaux cote a cote (ligne de separation verticale)
+LAYOUT_2H = "2h"  # 2 panneaux empiles (ligne de separation horizontale)
+LAYOUT_4 = "4"    # grille 2x2
+
+LAYOUT_LABELS = {
+    LAYOUT_2V: "2 panneaux verticaux (cote a cote)",
+    LAYOUT_2H: "2 panneaux horizontaux (empiles)",
+    LAYOUT_4: "4 panneaux",
+}
+
+_PANE_COUNTS = {LAYOUT_SINGLE: 1, LAYOUT_2V: 2, LAYOUT_2H: 2, LAYOUT_4: 4}
+
+
+class PaneSlot(QWidget):
+    """Un emplacement dans la grille : une fine barre (menu + fermeture)
+    au-dessus du contenu, qui reste un widget d'onglet inchange."""
+
+    close_requested = Signal(object)   # emet elle-meme
+    menu_requested = Signal(object)    # emet elle-meme ; le conteneur construit le menu
+
+    def __init__(self, content: QWidget, parent=None):
+        super().__init__(parent)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+
+        bar = QHBoxLayout()
+        bar.setContentsMargins(4, 2, 4, 2)
+        self.menu_btn = QToolButton()
+        self.menu_btn.setText("☰")
+        self.menu_btn.setToolTip("Changer le contenu de ce panneau")
+        self.menu_btn.clicked.connect(lambda: self.menu_requested.emit(self))
+        bar.addWidget(self.menu_btn)
+        bar.addStretch()
+        close_btn = QToolButton()
+        close_btn.setText("✕")
+        close_btn.setToolTip("Fermer ce panneau")
+        close_btn.clicked.connect(lambda: self.close_requested.emit(self))
+        bar.addWidget(close_btn)
+        bar_frame = QFrame()
+        bar_frame.setObjectName("tabBar")
+        bar_frame.setLayout(bar)
+        layout.addWidget(bar_frame)
+
+        self.content = content
+        layout.addWidget(content, 1)
+
+    def close_connection(self) -> None:
+        if hasattr(self.content, "close_connection"):
+            self.content.close_connection()
+
+    def set_content(self, new_content: QWidget) -> None:
+        self.layout().replaceWidget(self.content, new_content)
+        self.content.setParent(None)
+        self.content = new_content
+        new_content.show()
+
+
+class SplitContainer(QWidget):
+    """Grille de terminaux (1/2/4 panneaux). Redescend automatiquement a un
+    seul panneau quand il n'en reste plus qu'un (ferme les autres)."""
+
+    all_panes_closed = Signal(object)     # (widget restant) -> le proprietaire deplie l'onglet
+    pane_menu_requested = Signal(object, object)  # (pane, container) -> le proprietaire affiche un menu
+
+    def __init__(self, first_widget: QWidget, layout_kind: str, make_filler: Callable[[], QWidget], parent=None):
+        super().__init__(parent)
+        self.panes: list[PaneSlot] = []
+        self._root_layout = QVBoxLayout(self)
+        self._root_layout.setContentsMargins(0, 0, 0, 0)
+        self._root_layout.setSpacing(0)
+
+        contents = [first_widget] + [make_filler() for _ in range(_PANE_COUNTS[layout_kind] - 1)]
+        for content in contents:
+            self._add_pane(content)
+        self._root_layout.addWidget(self._arrange(layout_kind, self.panes))
+
+    def _make_pane(self, content: QWidget) -> PaneSlot:
+        pane = PaneSlot(content)
+        pane.close_requested.connect(self._on_pane_close_requested)
+        pane.menu_requested.connect(lambda p: self.pane_menu_requested.emit(p, self))
+        return pane
+
+    def _add_pane(self, content: QWidget) -> PaneSlot:
+        pane = self._make_pane(content)
+        self.panes.append(pane)
+        return pane
+
+    @staticmethod
+    def _arrange(layout_kind: str, panes: list[PaneSlot]) -> QWidget:
+        if layout_kind == LAYOUT_SINGLE:
+            return panes[0]
+        if layout_kind == LAYOUT_2V:
+            splitter = QSplitter(Qt.Horizontal)
+        elif layout_kind == LAYOUT_2H:
+            splitter = QSplitter(Qt.Vertical)
+        elif layout_kind == LAYOUT_4:
+            top = QSplitter(Qt.Horizontal)
+            top.addWidget(panes[0])
+            top.addWidget(panes[1])
+            bottom = QSplitter(Qt.Horizontal)
+            bottom.addWidget(panes[2])
+            bottom.addWidget(panes[3])
+            outer = QSplitter(Qt.Vertical)
+            outer.addWidget(top)
+            outer.addWidget(bottom)
+            return outer
+        else:
+            raise ValueError(f"layout de split inconnu : {layout_kind}")
+        for pane in panes:
+            splitter.addWidget(pane)
+        return splitter
+
+    def replace_pane_content(self, pane: PaneSlot, new_content: QWidget) -> None:
+        """Ferme l'ancien contenu du panneau et le remplace (ex : terminal
+        local par defaut remplace par un onglet deplace ici)."""
+        pane.close_connection()
+        pane.set_content(new_content)
+
+    def _on_pane_close_requested(self, pane: PaneSlot) -> None:
+        pane.close_connection()
+        self.panes.remove(pane)
+        # Le retirer de son QSplitter suffit : celui-ci redistribue l'espace
+        # aux panneaux restants tout seul, sans reconstruire toute la grille.
+        pane.setParent(None)
+        pane.deleteLater()
+        if len(self.panes) <= 1:
+            remaining = self.panes[0].content if self.panes else None
+            self.all_panes_closed.emit(remaining)
+
+    def close_all(self) -> None:
+        for pane in self.panes:
+            pane.close_connection()