SageTube/ytsage/gui/ytsage_player_fullscreen.py

"""
Fullscreen without reparenting the video widget
===============================================

The obvious implementation -- take the player out of its layout, make it a
top-level window, `showFullScreen()` -- is what SageTube did, and it is a
reliable way to crash. Reparenting a widget into a new top-level destroys and
recreates the QOpenGLContext of every QOpenGLWidget beneath it, and each
recreation is another chance to lose the libmpv render context. A single
fullscreen toggle did it twice.

So nothing is reparented here. The **main window** goes fullscreen and the
chrome around the video is hidden. QMainWindow.showFullScreen() reuses the
same QWindow and native surface -- on Wayland it is an
`xdg_toplevel.set_fullscreen` -- so the GL context is untouched and the video
never blinks.

The same mechanism gives "cinema mode" (hide the chrome, stay windowed) for
free, and it gives Escape one unambiguous owner.
"""

from typing import Optional

from PySide6.QtCore import QObject, Qt, Signal
from PySide6.QtWidgets import QMainWindow, QWidget

from ..utils.ytsage_logger import logger


class FullscreenController(QObject):
    """
    Drives fullscreen for the Watch page.

    Owns no widgets and destroys nothing; it only toggles visibility and the
    main window's state, and can always put things back.
    """

    changed = Signal(bool)

    def __init__(
        self,
        window: QMainWindow,
        tabs: QWidget,
        watch_page: QWidget,
        parent: Optional[QObject] = None,
    ) -> None:
        super().__init__(parent)
        self._window = window
        self._tabs = tabs
        self._watch_page = watch_page
        self._active = False
        self._prev_window_state: Optional[Qt.WindowState] = None
        self._prev_margins = None

    # ------------------------------------------------------------------ state

    def is_active(self) -> bool:
        return self._active

    def toggle(self) -> None:
        # Trust the window, not just the flag. If something else put the
        # window into fullscreen -- a restored geometry, the window manager,
        # the user's own shortcut -- toggling must get *out* of it rather than
        # trying to enter a state it is already in and appearing to do nothing.
        if self._active or self._window.isFullScreen():
            self.exit()
        else:
            self.enter()

    # ------------------------------------------------------------ transitions

    def enter(self) -> None:
        if self._active:
            return
        try:
            # Fullscreening while another tab is showing would present an
            # empty screen, so make sure the video is the visible page first.
            self._show_watch_tab()

            self._prev_window_state = self._window.windowState()

            tab_bar = getattr(self._tabs, "tab_bar", None)
            if tab_bar is not None:
                tab_bar.hide()
            corner = getattr(self._tabs, "corner_widget", None)
            if corner is not None:
                corner.hide()

            queue_panel = getattr(self._watch_page, "queue_panel", None)
            if queue_panel is not None:
                queue_panel.hide()

            layout = self._watch_page.layout()
            if layout is not None:
                self._prev_margins = layout.contentsMargins()
                layout.setContentsMargins(0, 0, 0, 0)

            self._window.showFullScreen()
            self._active = True
            self.changed.emit(True)
        except Exception as e:
            logger.exception(f"Entering fullscreen failed: {e}")
            # Never leave the UI half-hidden with no way back.
            self.exit()

    def exit(self) -> None:
        # Also runs when the controller was never active but the window is
        # fullscreen anyway, so restoring the chrome is unconditional.
        if not self._active and self._prev_window_state is None and not self._window.isFullScreen():
            return
        try:
            tab_bar = getattr(self._tabs, "tab_bar", None)
            if tab_bar is not None:
                tab_bar.show()
            corner = getattr(self._tabs, "corner_widget", None)
            if corner is not None:
                corner.show()

            queue_panel = getattr(self._watch_page, "queue_panel", None)
            if queue_panel is not None:
                queue_panel.show()

            layout = self._watch_page.layout()
            if layout is not None and self._prev_margins is not None:
                layout.setContentsMargins(self._prev_margins)

            if self._prev_window_state is not None:
                # Never restore *into* fullscreen: that is what we are leaving.
                self._window.setWindowState(self._prev_window_state & ~Qt.WindowState.WindowFullScreen)
            else:
                self._window.showNormal()
            if self._window.isFullScreen():
                self._window.showNormal()
        except Exception as e:
            logger.exception(f"Leaving fullscreen failed: {e}")
        finally:
            self._prev_window_state = None
            self._prev_margins = None
            self._active = False
            self.changed.emit(False)

    # ---------------------------------------------------------------- helpers

    def _show_watch_tab(self) -> None:
        stack = getattr(self._tabs, "stack", None)
        set_index = getattr(self._tabs, "set_current_index", None)
        if stack is None or set_index is None:
            return
        for i in range(stack.count()):
            if stack.widget(i) is self._watch_page:
                set_index(i)
                return