Move X11 dodge monitor behind visibility service (#144)

* Move X11 dodge monitor behind visibility service

* Clarification

Author: edumucelli

docking/app.py

@@ -108,6 +108,7 @@ def main() -> None:
         theme=theme,
         window_tracker=backend.windows,
         preview_service=backend.previews,
+        visibility_service=backend.visibility,
         launcher=launcher,
     )
     items_service = DockItemsService(model=model, window=window)

docking/platform/backends/x11/__init__.py

@@ -18,10 +18,12 @@
     build_x11_session_backend,
     build_x11_window_tracker,
 )
+from docking.platform.backends.x11.visibility import X11VisibilityService
 from docking.platform.backends.x11.windows import X11WindowService
 
 __all__ = [
     "X11SessionBackend",
+    "X11VisibilityService",
     "X11WindowService",
     "build_x11_session_backend",
     "build_x11_window_tracker",

docking/platform/backends/x11/session.py

@@ -16,7 +16,6 @@
 from __future__ import annotations
 
 import os
-from collections.abc import Callable
 from typing import TYPE_CHECKING
 
 from docking.log import get_logger
@@ -26,9 +25,9 @@
     PlatformCapabilities,
     Rect,
     ReservationRequest,
-    VisibilityMonitor,
 )
 from docking.platform.backends.x11.previews import X11PreviewService
+from docking.platform.backends.x11.visibility import X11VisibilityService
 from docking.platform.backends.x11.windows import X11WindowService
 from docking.platform.window_tracker import WindowTracker
 
@@ -80,9 +79,9 @@ class X11SessionBackend:
     """SessionBackend implementation for the current X11 runtime.
 
     This backend intentionally remains X11-only. It groups the already-migrated
-    window and preview services so application startup can depend on a session
-    backend shape before native Wayland services exist. Surface and visibility
-    stay transitional until their dedicated migration PRs.
+    window, preview, and visibility services so application startup can depend
+    on a session backend shape before native Wayland services exist. Surface
+    stays transitional until its dedicated migration PR.
     """
 
     def __init__(
@@ -93,7 +92,7 @@ def __init__(
         )
         self._previews = X11PreviewService(window_tracker=self._windows)
         self._surface = _TransitionalSurfaceService()
-        self._visibility = _TransitionalVisibilityService()
+        self._visibility = X11VisibilityService(config=config)
 
     @property
     def name(self) -> str:
@@ -147,7 +146,7 @@ def surface(self) -> _TransitionalSurfaceService:
         return self._surface
 
     @property
-    def visibility(self) -> _TransitionalVisibilityService:
+    def visibility(self) -> X11VisibilityService:
         return self._visibility
 
     @property
@@ -222,24 +221,3 @@ def update_input_region(self, rect: Rect) -> None:
 
     def set_blur_region(self, rect: Rect | None) -> None:
         return
-
-
-class _TransitionalVisibilityService:
-    """Unsupported visibility service until dodge ownership moves in PR 8."""
-
-    def start(self) -> None:
-        return
-
-    def stop(self) -> None:
-        return
-
-    def supports_hide_mode(self, mode: object) -> bool:
-        return False
-
-    def create_monitor(
-        self,
-        *,
-        get_dock_rect: Callable[[], Rect | None],
-        on_change: Callable[[bool], None],
-    ) -> VisibilityMonitor | None:
-        return None

docking/platform/backends/x11/visibility.py

@@ -0,0 +1,77 @@
+# Author: Eduardo Mucelli Rezende Oliveira
+# E-mail: edumucelli@gmail.com
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+
+"""X11 overlap/dodge visibility service."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from docking.core.config import HideMode
+from docking.platform.backends.base import Rect, VisibilityMonitor
+from docking.platform.dodge import ScreenRect, WindowDodgeMonitor
+
+if TYPE_CHECKING:
+    from docking.core.config import Config
+
+# These are only the hide modes that depend on foreign-window overlap state.
+# The simpler modes such as NONE, ALWAYS_ON_TOP, and AUTOHIDE are handled by
+# dock autohide/surface behavior and do not need an X11 dodge monitor.
+_OVERLAP_HIDE_MODES = frozenset(
+    {
+        HideMode.INTELLIGENT,
+        HideMode.DODGE_ACTIVE,
+        HideMode.WINDOW_DODGE,
+        HideMode.DODGE_MAXIMIZED,
+    }
+)
+
+
+class X11VisibilityService:
+    """VisibilityService backed by the existing Wnck WindowDodgeMonitor."""
+
+    def __init__(self, *, config: Config | None) -> None:
+        self._config = config
+
+    def start(self) -> None:
+        """No service-level runtime loop is needed."""
+
+    def stop(self) -> None:
+        """No service-level resources are held."""
+
+    def supports_hide_mode(self, mode: object) -> bool:
+        """Return whether X11 can monitor foreign-window overlap for a mode."""
+        return mode in _OVERLAP_HIDE_MODES
+
+    def create_monitor(
+        self,
+        *,
+        get_dock_rect: Callable[[], Rect | None],
+        on_change: Callable[[bool], None],
+    ) -> VisibilityMonitor | None:
+        """Create the current X11 dodge monitor, preserving old factory wiring."""
+        if self._config is None:
+            return None
+
+        return WindowDodgeMonitor(
+            config=self._config,
+            get_dock_rect=lambda: _to_screen_rect(get_dock_rect()),
+            on_change=on_change,
+        )
+
+
+def _to_screen_rect(rect: Rect | None) -> ScreenRect | None:
+    if rect is None:
+        return None
+    return ScreenRect(x=rect.x, y=rect.y, width=rect.width, height=rect.height)

docking/ui/dock_window.py

@@ -245,7 +245,7 @@
     from docking.core.config import Config
     from docking.core.items import DockItem
     from docking.core.theme import Theme
-    from docking.platform.dodge import WindowDodgeMonitor
+    from docking.platform.backends.base import VisibilityMonitor
     from docking.platform.launcher import Launcher
     from docking.platform.model import DockModel
     from docking.platform.window_tracker import WindowTracker
@@ -379,7 +379,7 @@ def __init__(
         self._redraw_source_id: int | None = None
         self.dock_hovered: bool = False
         self._last_autohide_state: HideState | None = None
-        self.dodge_monitor: WindowDodgeMonitor | None = None
+        self.dodge_monitor: VisibilityMonitor | None = None
 
         self._setup_window()
         self._setup_drawing_area()

docking/ui/factory.py

@@ -22,8 +22,7 @@
 
 from docking.core.config import Config
 from docking.core.theme import Theme
-from docking.platform.backends.base import PreviewService
-from docking.platform.dodge import ScreenRect, WindowDodgeMonitor
+from docking.platform.backends.base import PreviewService, Rect, VisibilityService
 from docking.platform.launcher import Launcher
 from docking.platform.model import DockModel
 from docking.platform.window_tracker import WindowTracker
@@ -39,6 +38,7 @@ def build_dock_window(
     theme: Theme,
     window_tracker: WindowTracker,
     preview_service: PreviewService,
+    visibility_service: VisibilityService,
     launcher: Launcher,
 ) -> DockWindow:
     """Build a fully wired dock window and its UI collaborators."""
@@ -52,18 +52,18 @@ def build_dock_window(
         preview_service=preview_service,
     )
 
-    def _get_dock_rect() -> ScreenRect | None:
+    def _get_dock_rect() -> Rect | None:
         if not window.get_realized():
             return None
         wx, wy = window.get_position()
         ww, wh = window.get_size()
-        return ScreenRect(x=wx, y=wy, width=ww, height=wh)
+        return Rect(x=wx, y=wy, width=ww, height=wh)
 
-    dodge_monitor = WindowDodgeMonitor(
-        config=config,
+    dodge_monitor = visibility_service.create_monitor(
         get_dock_rect=_get_dock_rect,
         on_change=window.autohide.set_window_should_hide,
     )
     window.dodge_monitor = dodge_monitor
-    dodge_monitor.start()
+    if dodge_monitor is not None:
+        dodge_monitor.start()
     return window

docs/WAYLAND.md

@@ -3160,10 +3160,10 @@ now has the X11 window facade, production X11 runtime wiring, neutral
 `WindowId` values alongside existing XIDs, and menu rows backed by
 `WindowSnapshot`.
 
-The next active X11 migration PR is the X11-only session backend shape. It
-should group the already-migrated window and preview services behind an explicit
-session backend without changing current X11 behavior, and it should leave
-visibility and surface ownership to their dedicated later PRs.
+The next active X11 migration PR is the visibility service step. It should move
+X11 dodge monitor ownership behind `VisibilityService` without changing current
+overlap or hide-mode behavior, and it should leave surface ownership to its
+dedicated later PR.
 
 An optional temporary fallback can make that step safer:
 
@@ -3431,7 +3431,7 @@ Exit criteria:
 - preview behavior remains the same on X11
 - tests cover stale/not-found `WindowId` handling
 
-#### [ ] PR 7: Complete Session Backend Shape With X11 Only
+#### [x] PR 7: Complete Session Backend Shape With X11 Only
 
 Complete the X11 `SessionBackend` shape after the first runtime service wiring
 and after menu/preview can consume services. Production still selects only the

tests/platform/test_x11_session.py

@@ -61,19 +61,25 @@ def test_build_x11_window_tracker_ignores_invalid_mode(monkeypatch):
 def test_build_x11_session_backend_groups_x11_services(monkeypatch):
     windows = MagicMock()
     previews = MagicMock()
+    visibility = MagicMock()
+    config = MagicMock()
     monkeypatch.setattr(
         session, "build_x11_window_tracker", MagicMock(return_value=windows)
     )
     monkeypatch.setattr(session, "X11PreviewService", MagicMock(return_value=previews))
+    monkeypatch.setattr(
+        session, "X11VisibilityService", MagicMock(return_value=visibility)
+    )
 
     backend = session.build_x11_session_backend(
-        model=MagicMock(), launcher=MagicMock(), config=MagicMock()
+        model=MagicMock(), launcher=MagicMock(), config=config
     )
 
     assert backend.name == "x11"
     assert backend.display_server is session.DisplayServer.X11
     assert backend.windows is windows
     assert backend.previews is previews
+    assert backend.visibility is visibility
     assert backend.workspaces is None
     assert backend.desktop_actions is None
     assert backend.screen_capture is None
@@ -82,16 +88,22 @@ def test_build_x11_session_backend_groups_x11_services(monkeypatch):
     assert backend.capabilities.tracks_windows is True
     assert backend.capabilities.supports_window_menu is True
     assert backend.capabilities.supports_screen_reservation is True
+    assert backend.capabilities.supports_overlap_active is True
     session.X11PreviewService.assert_called_once_with(window_tracker=windows)
+    session.X11VisibilityService.assert_called_once_with(config=config)
 
 
 def test_x11_session_backend_lifecycle_starts_and_stops_services(monkeypatch):
     windows = MagicMock()
     previews = MagicMock()
+    visibility = MagicMock()
     monkeypatch.setattr(
         session, "build_x11_window_tracker", MagicMock(return_value=windows)
     )
     monkeypatch.setattr(session, "X11PreviewService", MagicMock(return_value=previews))
+    monkeypatch.setattr(
+        session, "X11VisibilityService", MagicMock(return_value=visibility)
+    )
     backend = session.X11SessionBackend(
         model=MagicMock(), launcher=MagicMock(), config=MagicMock()
     )
@@ -101,23 +113,31 @@ def test_x11_session_backend_lifecycle_starts_and_stops_services(monkeypatch):
 
     windows.start.assert_called_once_with()
     previews.start.assert_called_once_with()
+    visibility.start.assert_called_once_with()
+    visibility.stop.assert_called_once_with()
     previews.stop.assert_called_once_with()
     windows.stop.assert_called_once_with()
 
 
 def test_x11_session_backend_allows_legacy_tracker_without_lifecycle(monkeypatch):
     windows = object()
     previews = MagicMock()
+    visibility = MagicMock()
     monkeypatch.setattr(
         session, "build_x11_window_tracker", MagicMock(return_value=windows)
     )
     monkeypatch.setattr(session, "X11PreviewService", MagicMock(return_value=previews))
+    monkeypatch.setattr(
+        session, "X11VisibilityService", MagicMock(return_value=visibility)
+    )
     backend = session.X11SessionBackend(
         model=MagicMock(), launcher=MagicMock(), config=MagicMock()
     )
 
     backend.start()
     backend.stop()
 
+    visibility.start.assert_called_once_with()
+    visibility.stop.assert_called_once_with()
     previews.start.assert_called_once_with()
     previews.stop.assert_called_once_with()