feat(hosting): NoActivate + IgnorePointerInput layered-window attrs

codemonkeychris · codemonkeychris · commit 619957a34e93 · 2026-05-25T21:44:11.000-07:00
Adds two WindowSpec flags and matching ReactorWindow runtime mutators for
opt-in Win32 extended-style behaviors needed by spec 045 §2.6 tear-off
floating-window previews:

  - NoActivate (WS_EX_NOACTIVATE) — window appears without stealing
    foreground activation. Matches VS tool-window / drag-preview behavior.
    Applied during chrome setup BEFORE Activate so the first show observes
    it.

  - IgnorePointerInput (WS_EX_TRANSPARENT) — mouse events pass THROUGH the
    window to whatever's underneath. Only effective on layered windows
    (Opacity &lt; 1.0). Lets a translucent preview window sit on top of a
    drop-target overlay without blocking clicks.

Both mutators mirror their values into _spec (matching SetOpacity) so a
later Update() diff sees the live state.

Selftest coverage (WindowModelFixtures):
  - WindowModel_OpacityRoundTrip — spec + mutator + WS_EX_LAYERED bit,
    1.0 strips the flag, out-of-range throws
  - WindowModel_NoActivateRoundTrip — spec + mutator + WS_EX_NOACTIVATE bit
  - WindowModel_IgnorePointerInputRoundTrip — spec + mutator + WS_EX_TRANSPARENT bit

All three pass on ARM64 (16/16 asserts).
diff --git a/src/Reactor/Hosting/ReactorWindow.cs b/src/Reactor/Hosting/ReactorWindow.cs
@@ -417,6 +417,12 @@ private void ApplyChrome(WindowSpec spec, bool isInitial)
         // windows pay zero layering overhead (Windows compositor fast-path).
         ApplyOpacity(spec.Opacity);
 
+        // Spec 045 §2.6 tear-off — NoActivate must be applied before
+        // Activate fires (in MountAndActivate) so the window's first show
+        // observes the flag. Re-applied on Update so flips stick.
+        SetNoActivate(spec.NoActivate);
+        SetIgnorePointerInput(spec.IgnorePointerInput);
+
         // Owner relationship — only meaningful at initial apply time.
         // Subsequent Update calls do not re-parent (changing ownership of a
         // realized window has no AppWindow API and is rarely the right thing
@@ -1014,10 +1020,57 @@ private void ApplyOpacity(double opacity)
         _ = NativeOpacity.SetLayeredWindowAttributes(_hwnd, 0, alpha, NativeOpacity.LWA_ALPHA);
     }
 
+    /// <summary>
+    /// Toggle the <c>WS_EX_NOACTIVATE</c> extended style on the underlying
+    /// HWND. When set, the window appears without stealing foreground
+    /// activation (matches VS tool-window / drag-preview behavior).
+    /// UI-thread only. No-op after disposal.
+    /// </summary>
+    public void SetNoActivate(bool noActivate)
+    {
+        ThreadAffinity.ThrowIfNotOnUIThread(nameof(SetNoActivate));
+        if (_disposed) return;
+        var current = NativeOpacity.GetWindowLongPtr(_hwnd, NativeOpacity.GWL_EXSTYLE);
+        long bits = (long)current;
+        long updated = noActivate
+            ? bits | NativeOpacity.WS_EX_NOACTIVATE
+            : bits & ~NativeOpacity.WS_EX_NOACTIVATE;
+        if (updated != bits)
+            _ = NativeOpacity.SetWindowLongPtr(_hwnd, NativeOpacity.GWL_EXSTYLE, (nint)updated);
+        // Mirror into _spec so Update() diffs see the live value.
+        var prev = Volatile.Read(ref _spec);
+        if (prev.NoActivate != noActivate)
+            Volatile.Write(ref _spec, prev with { NoActivate = noActivate });
+    }
+
+    /// <summary>
+    /// Toggle the <c>WS_EX_TRANSPARENT</c> extended style on the underlying
+    /// HWND. When set, mouse events pass THROUGH the window to whatever's
+    /// underneath. Only effective on layered windows (i.e. paired with
+    /// <see cref="SetOpacity"/> &lt; 1.0). UI-thread only. No-op after disposal.
+    /// </summary>
+    public void SetIgnorePointerInput(bool ignore)
+    {
+        ThreadAffinity.ThrowIfNotOnUIThread(nameof(SetIgnorePointerInput));
+        if (_disposed) return;
+        var current = NativeOpacity.GetWindowLongPtr(_hwnd, NativeOpacity.GWL_EXSTYLE);
+        long bits = (long)current;
+        long updated = ignore
+            ? bits | NativeOpacity.WS_EX_TRANSPARENT
+            : bits & ~NativeOpacity.WS_EX_TRANSPARENT;
+        if (updated != bits)
+            _ = NativeOpacity.SetWindowLongPtr(_hwnd, NativeOpacity.GWL_EXSTYLE, (nint)updated);
+        var prev = Volatile.Read(ref _spec);
+        if (prev.IgnorePointerInput != ignore)
+            Volatile.Write(ref _spec, prev with { IgnorePointerInput = ignore });
+    }
+
     private static class NativeOpacity
     {
         public const int GWL_EXSTYLE = -20;
         public const long WS_EX_LAYERED = 0x00080000;
+        public const long WS_EX_NOACTIVATE = 0x08000000;
+        public const long WS_EX_TRANSPARENT = 0x00000020;
         public const uint LWA_ALPHA = 0x00000002;
 
         [DllImport("user32.dll", EntryPoint = "GetWindowLongPtrW", SetLastError = true)]
diff --git a/src/Reactor/Hosting/WindowSpec.cs b/src/Reactor/Hosting/WindowSpec.cs
@@ -115,6 +115,24 @@ public sealed record WindowSpec
     /// </summary>
     public double Opacity { get; init; } = 1.0;
 
+    /// <summary>
+    /// Apply the Win32 <c>WS_EX_NOACTIVATE</c> extended style so the window
+    /// appears without stealing foreground activation. Matches VS tool-window
+    /// / drag-preview behavior. Default false. The flag is applied during
+    /// chrome setup (before Activate) so the first show observes it.
+    /// </summary>
+    public bool NoActivate { get; init; }
+
+    /// <summary>
+    /// Apply the Win32 <c>WS_EX_TRANSPARENT</c> extended style so mouse events
+    /// pass THROUGH the window to whatever's underneath. Requires
+    /// <see cref="Opacity"/> &lt; 1.0 (the OS only honors transparent on
+    /// layered windows). Default false. Used by spec 045 §2.6 tear-off so
+    /// the drag preview doesn't block clicks on drop-target overlays
+    /// below it.
+    /// </summary>
+    public bool IgnorePointerInput { get; init; }
+
     /// <summary>
     /// Construct with explicit field values. Validation runs after the record
     /// auto-init.
diff --git a/tests/Reactor.AppTests.Host/SelfTest/Fixtures/WindowModelFixtures.cs b/tests/Reactor.AppTests.Host/SelfTest/Fixtures/WindowModelFixtures.cs
@@ -5,6 +5,7 @@
 using Microsoft.UI.Xaml;
 using static Microsoft.UI.Reactor.Factories;
 using System.Reflection;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.UI.Reactor.AppTests.Host.SelfTest.Fixtures;
 
@@ -492,4 +493,152 @@ public override async Task RunAsync()
             H.Check("WindowMut_OwnedRemoved", child is null || !parent.OwnedWindows.Contains(child));
         }
     }
+
+    // ════════════════════════════════════════════════════════════════════
+    //  Layered-window attrs — Opacity / NoActivate / IgnorePointerInput
+    //
+    //  Verifies the Win32 WS_EX_LAYERED / WS_EX_NOACTIVATE / WS_EX_TRANSPARENT
+    //  extended-style bits flip via WindowSpec at construction and via the
+    //  runtime mutators (SetOpacity / SetNoActivate / SetIgnorePointerInput).
+    //  Each fixture reads GWL_EXSTYLE directly to confirm the OS-level flag
+    //  is set; the managed spec mirror is exercised in parallel so the next
+    //  Update() diff sees the live values. (spec 045 §2.6 tear-off
+    //  foundation primitives.)
+    // ════════════════════════════════════════════════════════════════════
+
+    private static class WindowAttrInterop
+    {
+        public const int GWL_EXSTYLE = -20;
+        public const long WS_EX_LAYERED = 0x00080000;
+        public const long WS_EX_NOACTIVATE = 0x08000000;
+        public const long WS_EX_TRANSPARENT = 0x00000020;
+
+        [DllImport("user32.dll", EntryPoint = "GetWindowLongPtrW", SetLastError = true)]
+        public static extern nint GetWindowLongPtr(nint hWnd, int nIndex);
+
+        public static long ExStyle(nint hwnd) => (long)GetWindowLongPtr(hwnd, GWL_EXSTYLE);
+        public static bool HasFlag(nint hwnd, long flag) => (ExStyle(hwnd) & flag) != 0;
+    }
+
+    private static nint HwndOf(ReactorWindow win) =>
+        WinRT.Interop.WindowNative.GetWindowHandle(win.NativeWindow);
+
+    internal class WindowOpacityRoundTrip(Harness h) : SelfTestFixtureBase(h)
+    {
+        public override async Task RunAsync()
+        {
+            EnsureUIDispatcher();
+
+            // Spec-set opacity at construction → WS_EX_LAYERED on.
+            var win = await OpenAndSettle(
+                new WindowSpec { Title = "Opacity Test", Width = 320, Height = 200, Opacity = 0.5 },
+                () => new StubComponent());
+            try
+            {
+                var hwnd = HwndOf(win);
+                H.Check("WindowAttr_Opacity_SpecValue", Math.Abs(win.Spec.Opacity - 0.5) < 0.0001);
+                H.Check("WindowAttr_Opacity_LayeredOnAtSpec",
+                    WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_LAYERED));
+
+                // Mutator round-trip to 0.25 → still layered, spec updated.
+                win.SetOpacity(0.25);
+                await Harness.Render();
+                H.Check("WindowAttr_Opacity_SpecAfterMutator", Math.Abs(win.Spec.Opacity - 0.25) < 0.0001);
+                H.Check("WindowAttr_Opacity_LayeredOnAfterMutator",
+                    WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_LAYERED));
+
+                // 1.0 strips WS_EX_LAYERED (compositor fast-path restored).
+                win.SetOpacity(1.0);
+                await Harness.Render();
+                H.Check("WindowAttr_Opacity_LayeredOffAt1",
+                    !WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_LAYERED));
+
+                // Out-of-range throws.
+                bool threw = false;
+                try { win.SetOpacity(1.5); }
+                catch (ArgumentOutOfRangeException) { threw = true; }
+                H.Check("WindowAttr_Opacity_OutOfRangeThrows", threw);
+            }
+            finally
+            {
+                await CloseAndSettle(win);
+            }
+        }
+    }
+
+    internal class WindowNoActivateRoundTrip(Harness h) : SelfTestFixtureBase(h)
+    {
+        public override async Task RunAsync()
+        {
+            EnsureUIDispatcher();
+
+            // Spec-set NoActivate → flag on at first show.
+            var win = await OpenAndSettle(
+                new WindowSpec { Title = "NoActivate Test", Width = 320, Height = 200, NoActivate = true },
+                () => new StubComponent());
+            try
+            {
+                var hwnd = HwndOf(win);
+                H.Check("WindowAttr_NoActivate_SpecValue", win.Spec.NoActivate);
+                H.Check("WindowAttr_NoActivate_FlagOnAtSpec",
+                    WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_NOACTIVATE));
+
+                // Mutator off → flag clears, spec mirrors.
+                win.SetNoActivate(false);
+                H.Check("WindowAttr_NoActivate_SpecAfterMutator", !win.Spec.NoActivate);
+                H.Check("WindowAttr_NoActivate_FlagOffAfterMutator",
+                    !WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_NOACTIVATE));
+
+                // Mutator back on → flag returns.
+                win.SetNoActivate(true);
+                H.Check("WindowAttr_NoActivate_FlagOnAgain",
+                    WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_NOACTIVATE));
+            }
+            finally
+            {
+                await CloseAndSettle(win);
+            }
+        }
+    }
+
+    internal class WindowIgnorePointerInputRoundTrip(Harness h) : SelfTestFixtureBase(h)
+    {
+        public override async Task RunAsync()
+        {
+            EnsureUIDispatcher();
+
+            // Spec-set IgnorePointerInput together with Opacity<1.0 (the OS
+            // only honors transparent on layered windows).
+            var win = await OpenAndSettle(
+                new WindowSpec
+                {
+                    Title = "IgnorePointer Test",
+                    Width = 320,
+                    Height = 200,
+                    Opacity = 0.5,
+                    IgnorePointerInput = true,
+                },
+                () => new StubComponent());
+            try
+            {
+                var hwnd = HwndOf(win);
+                H.Check("WindowAttr_IgnorePointer_SpecValue", win.Spec.IgnorePointerInput);
+                H.Check("WindowAttr_IgnorePointer_FlagOnAtSpec",
+                    WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_TRANSPARENT));
+
+                win.SetIgnorePointerInput(false);
+                H.Check("WindowAttr_IgnorePointer_SpecAfterMutator", !win.Spec.IgnorePointerInput);
+                H.Check("WindowAttr_IgnorePointer_FlagOffAfterMutator",
+                    !WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_TRANSPARENT));
+
+                win.SetIgnorePointerInput(true);
+                H.Check("WindowAttr_IgnorePointer_FlagOnAgain",
+                    WindowAttrInterop.HasFlag(hwnd, WindowAttrInterop.WS_EX_TRANSPARENT));
+            }
+            finally
+            {
+                await CloseAndSettle(win);
+            }
+        }
+    }
 }
diff --git a/tests/Reactor.AppTests.Host/SelfTest/SelfTestFixtureRegistry.cs b/tests/Reactor.AppTests.Host/SelfTest/SelfTestFixtureRegistry.cs
@@ -890,6 +890,9 @@ internal static class SelfTestFixtureRegistry
         "WindowModel_TrayIconRoundTrip",
         "WindowModel_UseOpenWindowReusesByKey",
         "WindowModel_MutatorsOwnerAndGuards",
+        "WindowModel_OpacityRoundTrip",
+        "WindowModel_NoActivateRoundTrip",
+        "WindowModel_IgnorePointerInputRoundTrip",
         // Spec 045 §2.19 — Phase-1 wrapper-based Docking_* smoke fixtures
         // were retired with the XAML wrapper at the §2.29 review gate.
         // NativeDocking_* below covers the same surface against the P2
@@ -1939,6 +1942,9 @@ internal static class SelfTestFixtureRegistry
         "WindowModel_TrayIconRoundTrip" => new WindowModelFixtures.TrayIconRoundTrip(harness),
         "WindowModel_UseOpenWindowReusesByKey" => new WindowModelFixtures.UseOpenWindowReusesByKey(harness),
         "WindowModel_MutatorsOwnerAndGuards" => new WindowModelFixtures.WindowMutatorsOwnerAndGuards(harness),
+        "WindowModel_OpacityRoundTrip" => new WindowModelFixtures.WindowOpacityRoundTrip(harness),
+        "WindowModel_NoActivateRoundTrip" => new WindowModelFixtures.WindowNoActivateRoundTrip(harness),
+        "WindowModel_IgnorePointerInputRoundTrip" => new WindowModelFixtures.WindowIgnorePointerInputRoundTrip(harness),
         // Spec 045 §2.19 — Phase-1 DockingSmokeFixtures retired alongside
         // the XAML wrapper unhooking. NativeDockingSmokeFixtures (below)
         // covers the same mount/update/unmount surface against the P2
