pycforge-sdk 0.6.3__py3-none-any.whl

pycforge_sdk/gui/visual/qt_window_chrome.py

@@ -0,0 +1,314 @@
+"""Compact, accessible frameless window chrome for the Qt workspace.
+
+The native menu bar remains the actual ``QMenuBar``.  It also becomes the
+drag surface, so removing the operating-system title bar gains vertical space
+without replacing menu semantics, mnemonics, hover behavior, or keyboard
+navigation.  Moving and resizing are delegated to Qt's system APIs first;
+bounded manual behavior is retained as a fallback for window managers that do
+not expose those APIs.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QEvent, QObject, QPoint, QRect, Qt
+from PySide6.QtGui import (
+    QKeySequence,
+    QShortcut,
+)
+from PySide6.QtWidgets import (
+    QMainWindow,
+    QMenu,
+    QMenuBar,
+    QWidget,
+)
+
+from .qt_actions import build_window_system_actions
+from .qt_window_resize import WindowResizeHandle as _ResizeHandle
+from .qt_title_controls import _TitleControls, _WindowControlButton
+
+
+_RESIZE_BORDER = 5
+_RESIZE_CORNER = 10
+# WindowResizeHandle owns accessible labels beginning "Resize window from".
+
+
+class FramelessWindowChrome(QObject):
+    """Own compact title interactions while preserving native menu surfaces."""
+
+    def __init__(self, window: QMainWindow, menu_bar: QMenuBar) -> None:
+        if not isinstance(window, QMainWindow):
+            raise TypeError("window must be a QMainWindow")
+        if not isinstance(menu_bar, QMenuBar):
+            raise TypeError("menu_bar must be a QMenuBar")
+        super().__init__(window)
+        self.window = window
+        self.menu_bar = menu_bar
+        self._manual_move_origin: tuple[QPoint, QPoint] | None = None
+        self._manual_move_surface: QWidget | None = None
+
+        window.setWindowFlag(
+            Qt.WindowType.FramelessWindowHint,
+            True,
+        )
+        window.setWindowFlag(
+            Qt.WindowType.NoDropShadowWindowHint,
+            False,
+        )
+        window.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, True)
+        menu_bar.setAccessibleDescription(
+            "Full PyCForge menus and the frameless window drag surface. "
+            "Double-click empty space to maximize or restore."
+        )
+
+        self.controls = _TitleControls(self)
+        menu_bar.setCornerWidget(
+            self.controls,
+            Qt.Corner.TopRightCorner,
+        )
+        self._drag_surfaces = (menu_bar, self.controls)
+        for surface in self._drag_surfaces:
+            surface.installEventFilter(self)
+        window.installEventFilter(self)
+
+        self.resize_handles = self._build_resize_handles()
+        self.system_menu = self._build_system_menu()
+        self.system_menu_shortcut = QShortcut(
+            QKeySequence("Alt+Space"),
+            window,
+        )
+        self.system_menu_shortcut.setContext(
+            Qt.ShortcutContext.WindowShortcut
+        )
+        self.system_menu_shortcut.activated.connect(
+            self.show_system_menu
+        )
+        self._sync_window_state()
+        self._sync_resize_handles()
+
+    def eventFilter(self, watched, event) -> bool:  # noqa: N802 - Qt API
+        event_type = event.type()
+        if watched is self.window:
+            if event_type == QEvent.Type.WindowTitleChange:
+                self.controls.sync_title()
+            elif event_type in {
+                QEvent.Type.Resize,
+                QEvent.Type.Show,
+                QEvent.Type.WindowStateChange,
+            }:
+                self._sync_window_state()
+                self._sync_resize_handles()
+            elif event_type == QEvent.Type.ActivationChange:
+                for button in (
+                    self.controls.minimize_button,
+                    self.controls.maximize_button,
+                    self.controls.close_button,
+                ):
+                    button.update()
+            return False
+
+        if watched not in self._drag_surfaces:
+            return False
+        if event_type == QEvent.Type.MouseButtonDblClick:
+            if event.button() == Qt.MouseButton.LeftButton and self._drag_allowed(
+                watched, event.position().toPoint()
+            ):
+                self.toggle_maximized()
+                event.accept()
+                return True
+        elif event_type == QEvent.Type.MouseButtonPress:
+            if event.button() == Qt.MouseButton.LeftButton and self._drag_allowed(
+                watched, event.position().toPoint()
+            ):
+                self._begin_move(
+                    watched,
+                    event.globalPosition().toPoint(),
+                )
+                event.accept()
+                return True
+        elif event_type == QEvent.Type.MouseMove:
+            if self._manual_move_origin is not None:
+                self._continue_manual_move(event.globalPosition().toPoint())
+                event.accept()
+                return True
+        elif event_type == QEvent.Type.MouseButtonRelease:
+            if self._manual_move_origin is not None:
+                self._finish_manual_move()
+                event.accept()
+                return True
+        return False
+
+    def toggle_maximized(self) -> None:
+        if self.window.isMaximized():
+            self.window.showNormal()
+        else:
+            self.window.showMaximized()
+        self._sync_window_state()
+
+    def start_system_resize(self, edges: Qt.Edge) -> bool:
+        if self.window.isMaximized() or self.window.isFullScreen():
+            return False
+        handle = self.window.windowHandle()
+        if handle is None:
+            return False
+        try:
+            return bool(handle.startSystemResize(edges))
+        except (AttributeError, RuntimeError):
+            return False
+
+    def show_system_menu(self) -> None:
+        self._restore_action.setEnabled(
+            self.window.isMaximized() or self.window.isMinimized()
+        )
+        self._minimize_action.setEnabled(not self.window.isMinimized())
+        self._maximize_action.setEnabled(not self.window.isMaximized())
+        self.system_menu.popup(
+            self.window.mapToGlobal(QPoint(7, self.menu_bar.height()))
+        )
+
+    def _drag_allowed(self, watched: QWidget, position: QPoint) -> bool:
+        return not (
+            watched is self.menu_bar
+            and self.menu_bar.actionAt(position) is not None
+        )
+
+    def _begin_move(self, surface: QWidget, global_position: QPoint) -> None:
+        handle = self.window.windowHandle()
+        if handle is not None:
+            try:
+                if handle.startSystemMove():
+                    return
+            except (AttributeError, RuntimeError):
+                pass
+
+        if self.window.isMaximized():
+            maximized = self.window.geometry()
+            normal = self.window.normalGeometry()
+            ratio = max(
+                0.0,
+                min(
+                    1.0,
+                    (global_position.x() - maximized.x())
+                    / max(1, maximized.width()),
+                ),
+            )
+            self.window.showNormal()
+            self.window.move(
+                int(global_position.x() - normal.width() * ratio),
+                global_position.y() - min(16, self.menu_bar.height() // 2),
+            )
+
+        self._manual_move_origin = (
+            global_position,
+            self.window.frameGeometry().topLeft(),
+        )
+        self._manual_move_surface = surface
+        surface.grabMouse()
+
+    def _continue_manual_move(self, global_position: QPoint) -> None:
+        if self._manual_move_origin is None:
+            return
+        start, origin = self._manual_move_origin
+        self.window.move(origin + global_position - start)
+
+    def _finish_manual_move(self) -> None:
+        surface = self._manual_move_surface
+        self._manual_move_origin = None
+        self._manual_move_surface = None
+        if surface is not None:
+            surface.releaseMouse()
+
+    def _build_resize_handles(self) -> tuple[_ResizeHandle, ...]:
+        left = Qt.Edge.LeftEdge
+        right = Qt.Edge.RightEdge
+        top = Qt.Edge.TopEdge
+        bottom = Qt.Edge.BottomEdge
+        specs = (
+            ("left edge", left, Qt.CursorShape.SizeHorCursor),
+            ("right edge", right, Qt.CursorShape.SizeHorCursor),
+            ("top edge", top, Qt.CursorShape.SizeVerCursor),
+            ("bottom edge", bottom, Qt.CursorShape.SizeVerCursor),
+            ("top-left corner", top | left, Qt.CursorShape.SizeFDiagCursor),
+            ("top-right corner", top | right, Qt.CursorShape.SizeBDiagCursor),
+            ("bottom-left corner", bottom | left, Qt.CursorShape.SizeBDiagCursor),
+            ("bottom-right corner", bottom | right, Qt.CursorShape.SizeFDiagCursor),
+        )
+        return tuple(
+            _ResizeHandle(self, name, edges, cursor)
+            for name, edges, cursor in specs
+        )
+
+    def _sync_resize_handles(self) -> None:
+        visible = not (
+            self.window.isMaximized()
+            or self.window.isMinimized()
+            or self.window.isFullScreen()
+        )
+        if not visible:
+            for handle in self.resize_handles:
+                handle.hide()
+            return
+
+        width, height = self.window.width(), self.window.height()
+        border, corner = _RESIZE_BORDER, _RESIZE_CORNER
+        geometries = (
+            QRect(0, corner, border, max(0, height - 2 * corner)),
+            QRect(width - border, corner, border, max(0, height - 2 * corner)),
+            QRect(corner, 0, max(0, width - 2 * corner), border),
+            QRect(corner, height - border, max(0, width - 2 * corner), border),
+            QRect(0, 0, corner, corner),
+            QRect(width - corner, 0, corner, corner),
+            QRect(0, height - corner, corner, corner),
+            QRect(width - corner, height - corner, corner, corner),
+        )
+        for handle, geometry in zip(self.resize_handles, geometries, strict=True):
+            handle.setGeometry(geometry)
+            handle.show()
+            handle.raise_()
+
+    def _build_system_menu(self) -> QMenu:
+        menu = QMenu("Window", self.window)
+        menu.setObjectName("FramelessSystemMenu")
+        menu.setAccessibleName("PyCForge window menu")
+        actions = build_window_system_actions(
+            menu,
+            {
+                "restore": self.window.showNormal,
+                "minimize": self.window.showMinimized,
+                "maximize": self.window.showMaximized,
+                "close": self.window.close,
+            },
+        )
+        self._restore_action = actions["restore"]
+        self._minimize_action = actions["minimize"]
+        self._maximize_action = actions["maximize"]
+        menu.addAction(self._restore_action)
+        menu.addAction(self._minimize_action)
+        menu.addAction(self._maximize_action)
+        menu.addSeparator()
+        menu.addAction(actions["close"])
+        return menu
+
+    def _sync_window_state(self) -> None:
+        self.controls.sync_window_state()
+        self.controls.sync_available_width()
+        self.controls.schedule_available_width_sync()
+
+
+def install_frameless_window_chrome(
+    window: QMainWindow,
+    menu_bar: QMenuBar,
+) -> FramelessWindowChrome:
+    """Install one retained chrome controller on an unshown main window."""
+
+    existing = getattr(window, "_frameless_window_chrome", None)
+    if isinstance(existing, FramelessWindowChrome):
+        return existing
+    chrome = FramelessWindowChrome(window, menu_bar)
+    window._frameless_window_chrome = chrome
+    return chrome
+
+
+__all__ = [
+    "FramelessWindowChrome",
+    "install_frameless_window_chrome",
+]

pycforge_sdk/gui/visual/qt_window_resize.py

@@ -0,0 +1,93 @@
+"""Manual fallback handle for the frameless PyCForge main window."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from PySide6.QtCore import QPoint, QRect, Qt
+from PySide6.QtWidgets import QMainWindow, QWidget
+
+
+class _ResizeController(Protocol):
+    window: QMainWindow
+
+    def start_system_resize(self, edges: Qt.Edge) -> bool: ...
+
+
+class WindowResizeHandle(QWidget):
+    """Prefer compositor resize and retain one bounded manual fallback."""
+
+    def __init__(
+        self,
+        controller: _ResizeController,
+        edge_name: str,
+        edges: Qt.Edge,
+        cursor: Qt.CursorShape,
+    ) -> None:
+        super().__init__(controller.window)
+        self.controller = controller
+        self.edges = edges
+        self.setObjectName("FramelessResizeHandle")
+        self.setProperty("resizeEdge", edge_name)
+        self.setAccessibleName(f"Resize window from {edge_name}")
+        self.setCursor(cursor)
+        self._manual_origin: tuple[QPoint, QRect] | None = None
+
+    def mousePressEvent(self, event) -> None:  # noqa: N802 - Qt API
+        if event.button() != Qt.MouseButton.LeftButton:
+            super().mousePressEvent(event)
+            return
+        if self.controller.start_system_resize(self.edges):
+            event.accept()
+            return
+        self._manual_origin = (
+            event.globalPosition().toPoint(),
+            self.controller.window.geometry(),
+        )
+        self.grabMouse()
+        event.accept()
+
+    def mouseMoveEvent(self, event) -> None:  # noqa: N802 - Qt API
+        if self._manual_origin is None:
+            super().mouseMoveEvent(event)
+            return
+        start, original = self._manual_origin
+        delta = event.globalPosition().toPoint() - start
+        self.controller.window.setGeometry(
+            self._manual_geometry(original, delta)
+        )
+        event.accept()
+
+    def mouseReleaseEvent(self, event) -> None:  # noqa: N802 - Qt API
+        if self._manual_origin is not None:
+            self._manual_origin = None
+            self.releaseMouse()
+            event.accept()
+            return
+        super().mouseReleaseEvent(event)
+
+    def _manual_geometry(self, original: QRect, delta: QPoint) -> QRect:
+        window = self.controller.window
+        minimum_width = window.minimumWidth()
+        minimum_height = window.minimumHeight()
+        maximum_width = window.maximumWidth()
+        maximum_height = window.maximumHeight()
+        x, y = original.x(), original.y()
+        width, height = original.width(), original.height()
+
+        if self.edges & Qt.Edge.LeftEdge:
+            proposed = max(minimum_width, min(maximum_width, width - delta.x()))
+            x += width - proposed
+            width = proposed
+        elif self.edges & Qt.Edge.RightEdge:
+            width = max(minimum_width, min(maximum_width, width + delta.x()))
+        if self.edges & Qt.Edge.TopEdge:
+            proposed = max(minimum_height, min(maximum_height, height - delta.y()))
+            y += height - proposed
+            height = proposed
+        elif self.edges & Qt.Edge.BottomEdge:
+            height = max(minimum_height, min(maximum_height, height + delta.y()))
+        return QRect(x, y, width, height)
+
+
+__all__ = ["WindowResizeHandle"]