Implement JBR-style resize interception on Linux Tao

Move resize hit-test, cursor management, and drag initiation from Tao's GTK event handlers to the Compose scene host boundary (onPointerMove/onPointerButton). This ensures resize claims events BEFORE scene.sendPointerEvent, preventing Compose scrollbars from stealing clicks on window edges.

Matches JBR's WLDecoratedPeer.postMouseEvent + FrameDecoration pattern with 5px edge band and natural corner detection via edge intersection.

Author: kdroidFilter

decorated-window-tao/src/main/kotlin/dev/nucleusframework/window/tao/NativeTaoBridge.kt

@@ -256,6 +256,23 @@ internal object NativeTaoBridge {
     @JvmStatic
     external fun nativeDragWindow(handle: Long)
 
+    /**
+     * Begin an interactive resize drag in [direction]. Linux-only meaningful
+     * today (X11 + Wayland through Tao's `Window::drag_resize_window`). The
+     * Compose-side `ResizeFrameDecoration` calls this from `onPointerButton`
+     * BEFORE forwarding the press to `scene.sendPointerEvent`, so it claims
+     * clicks even on top of a Compose scrollbar — same architectural pattern
+     * as JBR's `WLDecoratedPeer.startResize(...)`.
+     *
+     * Direction is the ordinal of `ResizeDirection`: 0=N, 1=S, 2=E, 3=W,
+     * 4=NW, 5=NE, 6=SW, 7=SE.
+     */
+    @JvmStatic
+    external fun nativeBeginResizeDrag(
+        handle: Long,
+        direction: Int,
+    )
+
     @JvmStatic
     external fun nativeIsMaximized(handle: Long): Boolean
 

decorated-window-tao/src/main/kotlin/dev/nucleusframework/window/tao/render/ResizeFrameDecoration.kt

@@ -0,0 +1,122 @@
+@file:Suppress("MagicNumber")
+
+package dev.nucleusframework.window.tao.render
+
+import dev.nucleusframework.window.tao.NativeTaoBridge
+import dev.nucleusframework.window.tao.TaoCursorIcon
+
+/**
+ * Compose-side peer-level resize hit-test, structurally identical to JBR's
+ * `sun.awt.wl.FrameDecoration`. Plugged into [TaoComposeSceneHostLinux] at the
+ * input-dispatch boundary (`onPointerMove` / `onPointerButton`) so that resize
+ * events are claimed BEFORE `scene.sendPointerEvent` runs — meaning Compose
+ * never sees a click that was meant for resize, even when the click lands on
+ * top of a scrollbar pinned to the window edge.
+ *
+ * Coordinates are logical pixels in the window's local frame (origin at
+ * top-left). Band thickness matches the JBR default
+ * (`FrameDecoration.DEFAULT_RESIZE_EDGE_THICKNESS = 5`), with corner detection
+ * emerging naturally from the intersection of two edges (no separate, wider
+ * corner zone — same precedence as JBR's `getResizeEdges` bitmask).
+ */
+internal class ResizeFrameDecoration(
+    private val windowHandle: Long,
+    /**
+     * Edge band thickness in logical pixels. Matches JBR's
+     * `FrameDecoration.DEFAULT_RESIZE_EDGE_THICKNESS = 5`. There is no
+     * separate, wider "corner" band — diagonal resize is detected as the
+     * intersection of two edges (top-left = top edge AND left edge), which
+     * gives a natural 5×5 corner hotspot. Widening it makes the band feel
+     * heavy on small windows; AWT's 5 px is the empirically-tuned sweet spot.
+     */
+    private val edgeThicknessLogical: Int = 5,
+) {
+    /** Ordinals MUST match `NativeTaoBridge.nativeBeginResizeDrag` direction encoding. */
+    enum class Direction(
+        val code: Int,
+        val cursorIcon: Int,
+    ) {
+        North(0, TaoCursorIcon.NS_RESIZE),
+        South(1, TaoCursorIcon.NS_RESIZE),
+        East(2, TaoCursorIcon.EW_RESIZE),
+        West(3, TaoCursorIcon.EW_RESIZE),
+        NorthWest(4, TaoCursorIcon.NWSE_RESIZE),
+        NorthEast(5, TaoCursorIcon.NESW_RESIZE),
+        SouthWest(6, TaoCursorIcon.NESW_RESIZE),
+        SouthEast(7, TaoCursorIcon.NWSE_RESIZE),
+    }
+
+    private var inBand: Boolean = false
+
+    /**
+     * Returns the resize direction if [x], [y] (logical px, window-local) sits
+     * in the edge band of a window sized [widthLogical] × [heightLogical].
+     * Returns `null` if outside the band — caller forwards the event normally.
+     *
+     * Corner zones win over edge zones (a click at (4, 4) on a 200×200 window
+     * is `NorthWest`, not `North`). This matches the JBR + Tao precedence.
+     */
+    fun hitTest(
+        x: Float,
+        y: Float,
+        widthLogical: Int,
+        heightLogical: Int,
+    ): Direction? {
+        if (widthLogical <= 0 || heightLogical <= 0) return null
+        val edge = edgeThicknessLogical
+        val nearLeft = x < edge
+        val nearRight = x >= widthLogical - edge
+        val nearTop = y < edge
+        val nearBottom = y >= heightLogical - edge
+
+        // Corner = intersection of two edges, exactly like JBR's
+        // `getResizeEdges` bitmask precedence.
+        return when {
+            nearLeft && nearTop -> Direction.NorthWest
+            nearRight && nearTop -> Direction.NorthEast
+            nearLeft && nearBottom -> Direction.SouthWest
+            nearRight && nearBottom -> Direction.SouthEast
+            nearLeft -> Direction.West
+            nearRight -> Direction.East
+            nearTop -> Direction.North
+            nearBottom -> Direction.South
+            else -> null
+        }
+    }
+
+    /**
+     * Pointer-move hook. If [direction] is non-null the cursor is updated to
+     * the matching resize icon and the caller MUST NOT forward the move to
+     * Compose (the band owns the pointer). When the pointer transitions out
+     * of the band the cursor override is cleared so Compose's
+     * `PointerIcon`-driven cursor takes over again on the next move.
+     *
+     * Returns `true` if the event was consumed and must NOT be forwarded.
+     */
+    fun onMove(direction: Direction?): Boolean {
+        if (direction != null) {
+            NativeTaoBridge.nativeSetCursorIcon(windowHandle, direction.cursorIcon)
+            inBand = true
+            return true
+        }
+        if (inBand) {
+            inBand = false
+            // Restore the default cursor immediately; Compose will overwrite
+            // it on the next motion if a `PointerIcon` modifier is in scope.
+            NativeTaoBridge.nativeSetCursorIcon(windowHandle, TaoCursorIcon.DEFAULT)
+        }
+        return false
+    }
+
+    /**
+     * Left-mouse-button press hook. If [direction] is non-null we start the
+     * Tao resize drag and the caller MUST NOT forward the press to Compose.
+     *
+     * Returns `true` if the event was consumed.
+     */
+    fun onLeftPress(direction: Direction?): Boolean {
+        if (direction == null) return false
+        NativeTaoBridge.nativeBeginResizeDrag(windowHandle, direction.code)
+        return true
+    }
+}

decorated-window-tao/src/main/kotlin/dev/nucleusframework/window/tao/render/TaoComposeSceneHostLinux.kt

@@ -141,6 +141,15 @@ internal class TaoComposeSceneHostLinux(
     private var heightPx: Int = 0
     private var scale: Float = 1f
 
+    /**
+     * Peer-level resize hit-test, mirrors JBR's `WLDecoratedPeer` calling
+     * `FrameDecoration.processMouseEvent` before `super.postMouseEvent`. Only
+     * active for resizable (non-maximized, non-fullscreen) undecorated windows
+     * — Tao on Linux always presents the toplevel as `decorations=false` and
+     * paints chrome via Compose. See [onPointerMove] / [onPointerButton].
+     */
+    private val resizeDecoration = ResizeFrameDecoration(window.handle)
+
     // Coalescing: `onResized`/`onScaleFactorChanged` arrive at 60–120 Hz during
     // a user drag. Doing the X11 round-trip (XResizeWindow + rounded-shape
     // XShape rebuild) on every event is what was deadlocking the NVIDIA driver
@@ -918,6 +927,14 @@ internal class TaoComposeSceneHostLinux(
         val yPx = bFixed / 1024f
         lastPointerX = xPx
         lastPointerY = yPx
+
+        // JBR-style peer hook: hit-test the resize edge band BEFORE forwarding
+        // the move to Compose. When the pointer is inside the band we set the
+        // resize cursor and swallow the event so Compose's own cursor /
+        // `PointerIcon` plumbing can't overwrite it on the next motion.
+        val direction = currentResizeDirection(xPx, yPx)
+        if (resizeDecoration.onMove(direction)) return
+
         scene?.sendPointerEvent(
             eventType = PointerEventType.Move,
             position = Offset(xPx, yPx),
@@ -946,6 +963,15 @@ internal class TaoComposeSceneHostLinux(
         buttonCode: Int,
         pressed: Boolean,
     ) {
+        // JBR-style peer hook: a LMB press inside the resize band starts the
+        // native resize drag and is NOT forwarded to Compose. Matches
+        // `WLDecoratedPeer.postMouseEvent` calling
+        // `FrameDecoration.processMouseEvent` first.
+        if (pressed && buttonCode == dev.nucleusframework.window.tao.TaoMouseButton.LEFT) {
+            val direction = currentResizeDirection(lastPointerX, lastPointerY)
+            if (resizeDecoration.onLeftPress(direction)) return
+        }
+
         scene?.sendPointerEvent(
             eventType = if (pressed) PointerEventType.Press else PointerEventType.Release,
             position = Offset(lastPointerX, lastPointerY),
@@ -954,6 +980,27 @@ internal class TaoComposeSceneHostLinux(
         )
     }
 
+    /**
+     * Hit-test the resize band at the given logical-pixel position. Returns
+     * `null` (no resize) when the window is non-resizable, maximized, or
+     * fullscreen — same gating as JBR's `peer.isInteractivelyResizable()`.
+     *
+     * [widthPx] / [heightPx] are physical pixels; we divide by [scale] to
+     * compare against pointer coords (which the JNI bridge ships in logical
+     * pixels, see [onPointerMove]).
+     */
+    private fun currentResizeDirection(
+        xLogical: Float,
+        yLogical: Float,
+    ): ResizeFrameDecoration.Direction? {
+        if (!window.isResizable) return null
+        if (window.isFullscreen) return null
+        if (window.isMaximized) return null
+        val widthLogical = (widthPx / scale).toInt()
+        val heightLogical = (heightPx / scale).toInt()
+        return resizeDecoration.hitTest(xLogical, yLogical, widthLogical, heightLogical)
+    }
+
     fun onPointerScroll(
         dxAwt: Float,
         dyAwt: Float,

decorated-window-tao/src/main/native/src/window_jni.rs

@@ -225,6 +225,43 @@ pub extern "system" fn Java_dev_nucleusframework_window_tao_NativeTaoBridge_nati
     }
 }
 
+/// Begin an interactive resize drag in the given direction. Mirrors the JBR
+/// `WLDecoratedPeer.startResize(...)` peer-level hook: the Compose-side
+/// `ResizeFrameDecoration` hit-tests the edge band on `onPointerButton` and
+/// calls this BEFORE forwarding the event to `scene.sendPointerEvent`, so
+/// Compose never sees a click that was claimed by resize.
+///
+/// Direction encoding (matches Compose-side `ResizeDirection` ordinal):
+/// 0=N, 1=S, 2=E, 3=W, 4=NW, 5=NE, 6=SW, 7=SE.
+#[no_mangle]
+pub extern "system" fn Java_dev_nucleusframework_window_tao_NativeTaoBridge_nativeBeginResizeDrag(
+    _env: JNIEnv,
+    _class: JClass,
+    handle: jlong,
+    direction: jint,
+) {
+    use tao::window::ResizeDirection;
+    let dir = match direction {
+        0 => ResizeDirection::North,
+        1 => ResizeDirection::South,
+        2 => ResizeDirection::East,
+        3 => ResizeDirection::West,
+        4 => ResizeDirection::NorthWest,
+        5 => ResizeDirection::NorthEast,
+        6 => ResizeDirection::SouthWest,
+        7 => ResizeDirection::SouthEast,
+        _ => return,
+    };
+    let guard = match WINDOWS.lock() {
+        Ok(g) => g,
+        Err(_) => return,
+    };
+    let Some(map) = guard.as_ref() else { return };
+    if let Some(window) = map.get(&(handle as u64)) {
+        let _ = window.drag_resize_window(dir);
+    }
+}
+
 #[no_mangle]
 pub extern "system" fn Java_dev_nucleusframework_window_tao_NativeTaoBridge_nativeIsMaximized(
     _env: JNIEnv,