fix(decorated-window-tao): restore focus and popup rendering on Windows

Replace SetCapture-based focus trapping with thread-local WH_MOUSE hook
that observes clicks without consuming them, allowing the parent window
to maintain focus while popups remain interactive. Fixes: popups losing
input focus when appearing, clicks not reaching parent/popup content.

Add multi-host GL state management: force resetGLAll() every frame when
multiple TaoComposeSceneHostWindows coexist (main + DecoratedDialog) to
prevent Skia DirectContext state cache drift from sibling HGLRC swaps.

Replace AWT-based monitor work area detection with JNI bridge to avoid
Java2D/D3D initialization on Tao UI thread, which blocked WGL context.
Extended workAreaSize constraint to popup scenes for proper layout when
popup content exceeds parent window bounds.

- Removed SetCapture() mechanism; replaced with refcounted WH_MOUSE hook
- Changed nucleus_tao_windows_popup.c PopupState.captureHeld → outsideMonitorActive
- Added TaoComposeSceneHostWindows.attachedHostCount: AtomicInteger
- Added TaoPopupHostWindows.workAreaSize property with JNI implementation
- Added TaoPopupSceneLayer(Windows).sceneLayoutSize computed from workAreaSize
- Added NativeViewOverlayControllerWindows.workAreaSize forwarding

Author: kdroidFilter

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

@@ -117,6 +117,7 @@ internal class NativeViewOverlayControllerWindows(
             override val parentHwnd: Long get() = popupHost.parentHwnd
             override val scale: Float get() = popupHost.scale
             override val parentWindowSize: IntSize get() = popupHost.parentWindowSize
+            override val workAreaSize: IntSize get() = popupHost.workAreaSize
             override val sceneCoroutineContext: CoroutineContext get() = popupHost.sceneCoroutineContext
             override val hostDirectContext: DirectContext get() = popupHost.hostDirectContext
             override val coordinateOffset: IntOffset

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

@@ -170,6 +170,7 @@ internal class TaoComposeSceneHostWindows(
         attachmentHandle = handle
 
         directContext = DirectContext.makeGL()
+        attachedHostCount.incrementAndGet()
 
         @OptIn(androidx.compose.ui.ExperimentalComposeUiApi::class)
         val dndManager =
@@ -645,7 +646,16 @@ internal class TaoComposeSceneHostWindows(
         // (state-cache invalidation only); calling it on every frame
         // unconditionally is too heavy for some drivers (nvoglv64 chokes),
         // so we gate on the flag.
-        if (hostContextDirtied) {
+        // Sibling-host mode: another TaoComposeSceneHostWindows is alive
+        // (e.g., DecoratedDialog over a DecoratedWindow). Each host owns
+        // its own HGLRC + DirectContext, and the dialog's onRedrawRequested
+        // can run between our frames — swapping the current WGL context
+        // behind our back. Our DirectContext's per-context GL state cache
+        // is then stale relative to GL, and the next flushAndSubmit
+        // reaches a NULL pointer inside the driver. Force resetGLAll on
+        // every frame entry while >1 host coexists; revert to the
+        // popup-only flag-gated path once it's just us.
+        if (hostContextDirtied || attachedHostCount.get() > 1) {
             ctx.resetGLAll()
             hostContextDirtied = false
         }
@@ -841,6 +851,23 @@ internal class TaoComposeSceneHostWindows(
             override val parentHwnd: Long get() = outer.hwnd
             override val scale: Float get() = outer.scale
             override val parentWindowSize: IntSize get() = IntSize(outer.widthPx, outer.heightPx)
+            override val workAreaSize: IntSize get() {
+                // Use the primary monitor's work area resolved via the
+                // existing JNI bridge — avoids touching AWT
+                // (GraphicsEnvironment.getLocalGraphicsEnvironment) on the
+                // Tao UI thread, which on Windows can lazily initialise
+                // Java2D's D3D pipeline and conflict with the WGL context
+                // bound to this thread (manifested as a hang + crash when
+                // a second host attached, e.g. on DecoratedDialog open).
+                if (!NativeTaoWindowsDecoBridge.isLoaded) return parentWindowSize
+                val area =
+                    NativeTaoWindowsDecoBridge.nativeGetPrimaryMonitorWorkArea()
+                        ?: return parentWindowSize
+                if (area.size < 4) return parentWindowSize
+                val w = area[2].toInt().coerceAtLeast(1)
+                val h = area[3].toInt().coerceAtLeast(1)
+                return IntSize(w, h)
+            }
             override val sceneCoroutineContext: kotlin.coroutines.CoroutineContext
                 get() = outer.coroutineContext + outer.frameClock + outer.flushingDispatcher
             override val hostDirectContext: DirectContext get() = ctx
@@ -991,8 +1018,11 @@ internal class TaoComposeSceneHostWindows(
     fun detach() {
         scene?.close()
         scene = null
-        directContext?.close()
-        directContext = null
+        if (directContext != null) {
+            directContext?.close()
+            directContext = null
+            attachedHostCount.decrementAndGet()
+        }
         if (attachmentHandle != 0L) {
             NativeTaoGlBridge.nativeDetach(attachmentHandle)
             attachmentHandle = 0L
@@ -1014,6 +1044,23 @@ internal class TaoComposeSceneHostWindows(
         // `TOUCH_FORCE_FIXED_SCALE` in `events.rs`.
         private const val TOUCH_POSITION_SCALE: Float = 1024f
         private const val TOUCH_FORCE_SCALE: Float = 10_000f
+
+        /**
+         * Live attached-host count across the JVM. When > 1, every host
+         * shares the process with at least one sibling that owns its own
+         * HGLRC and DirectContext (e.g., main window + DecoratedDialog).
+         * Skia's per-DirectContext GL state cache can drift any time the
+         * other host's onRedrawRequested swaps WGL contexts behind our
+         * back, so we resetGLAll on every frame entry in that regime.
+         * The flag-gated path stays for the single-host case to keep the
+         * single-window hot path cheap.
+         */
+        private val attachedHostCount =
+            java
+                .util
+                .concurrent
+                .atomic
+                .AtomicInteger(0)
     }
 
     private inner class FlushingMainDispatcher : CoroutineDispatcher() {

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

@@ -29,6 +29,16 @@ internal interface TaoPopupHostWindows {
     /** Host window's content size in physical pixels. */
     val parentWindowSize: IntSize
 
+    /**
+     * Screen work area in physical pixels. Used as the inner scene's
+     * layout size so a tall popup (DropdownMenu, expanded Tooltip) in a
+     * small parent window lays out at full height instead of being
+     * artificially clipped by the owner window's bounds. Mirrors the
+     * macOS [TaoPopupHost.workAreaSize] contract. Defaults to
+     * [parentWindowSize] when the host can't resolve the monitor.
+     */
+    val workAreaSize: IntSize get() = parentWindowSize
+
     /** Coroutine context to feed inner scenes. */
     val sceneCoroutineContext: CoroutineContext
 

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

@@ -92,9 +92,10 @@ internal class TaoPopupSceneLayer(
      * height + the `Popup.PositionProvider` flips/clips at the screen
      * edge. Read once; not reactive (the popup is rebuilt on owner-move).
      */
-    private val sceneLayoutSize: IntSize = host.workAreaSize.let {
-        IntSize(it.width.coerceAtLeast(1), it.height.coerceAtLeast(1))
-    }
+    private val sceneLayoutSize: IntSize =
+        host.workAreaSize.let {
+            IntSize(it.width.coerceAtLeast(1), it.height.coerceAtLeast(1))
+        }
 
     /**
      * Panel created at parent-window-size offscreen so the inner scene

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

@@ -62,6 +62,23 @@ internal class TaoPopupSceneLayerWindows(
     private var heightPx: Int = host.parentWindowSize.height.coerceAtLeast(1)
     private val scale: Float = host.scale
 
+    /**
+     * Layout-size constraint for the inner [CanvasLayersComposeScene] —
+     * mirrors [TaoPopupSceneLayer] on macOS. The popup HWND itself (and
+     * the WGL framebuffer) stays at `widthPx`/`heightPx` so we don't
+     * allocate a full-screen-sized surface, but the scene is laid out
+     * with screen-work-area constraints so popups anchored near the
+     * window edges (Tooltip in title bar, DropdownMenu in a small
+     * floating window…) can flip/extend without being artificially
+     * clipped — which manifested as an empty-content flicker on Windows
+     * when the parent's `parentWindowSize` constraint conflicted with
+     * the Popup.PositionProvider's layout pass.
+     */
+    private val sceneLayoutSize: IntSize =
+        host.workAreaSize.let {
+            IntSize(it.width.coerceAtLeast(1), it.height.coerceAtLeast(1))
+        }
+
     private val panelHandle: Long =
         PopupNativeBridgeWindows
             .nativeCreatePanel(
@@ -87,7 +104,7 @@ internal class TaoPopupSceneLayerWindows(
         CanvasLayersComposeScene(
             density = _density,
             layoutDirection = _layoutDirection,
-            size = IntSize(widthPx, heightPx),
+            size = sceneLayoutSize,
             coroutineContext = host.sceneCoroutineContext,
             platformContext =
                 object : PlatformContext.Empty() {

decorated-window-tao/src/main/native/windows/nucleus_tao_windows_deco.c

@@ -541,3 +541,4 @@ Java_dev_nucleusframework_window_tao_NativeTaoWindowsDecoBridge_nativeGetWindowR
     (*env)->SetLongArrayRegion(env, arr, 0, 4, values);
     return arr;
 }
+