CursorLang.Agent.Tests/Services/CapsLockHotkeyServiceTests.cs

@@ -232,6 +232,32 @@ public sealed class CapsLockHotkeyServiceTests
         });
     }
 
+    /// <summary>
+    /// A hold is never announced for a key that has already been let go.
+    /// </summary>
+    /// <remarks>
+    /// The countdown started by the press can still be delivered just after the
+    /// release: Windows does not withdraw a WM_TIMER it has already posted. Taken at
+    /// face value it turned a tap into a hold — the popup came up showing the layout
+    /// the tap was about to change away from, and the switch followed it.
+    ///
+    /// The tick is driven straight in here rather than waited for, because the point is
+    /// the one ordering a real clock will not reproduce on demand.
+    /// </remarks>
+    [Fact]
+    public void A_hold_is_not_announced_after_the_key_has_been_released()
+    {
+        using var harness = Harness.Create(holdMilliseconds: 10_000);
+
+        harness.Press();
+        harness.Release();
+
+        harness.ForceHoldTick();
+        Pump.Drain();
+
+        Assert.Equal(["tap"], harness.Events);
+    }
+
     /// <summary>
     /// The service together with its settings and the list of events that happened.
     /// </summary>
@@ -271,6 +297,9 @@ public sealed class CapsLockHotkeyServiceTests
 
         internal void Release() => Pump.Run(() => Service.HandleKeyEvent(CapsLock, isKeyDown: false));
 
+        /// <summary>Delivers the hold countdown by hand, the way a late WM_TIMER does.</summary>
+        internal void ForceHoldTick() => Pump.Run(Service.HandleHoldElapsed);
+
         public void Dispose() => Pump.Run(Service.Dispose);
     }
 }

CursorLang.Agent/Interop/GdiNative.cs

@@ -5,7 +5,7 @@ using CursorLang.Core.Interop;
 namespace CursorLang.Agent.Interop;
 
 /// <summary>
-/// Plain GDI: a font, a brush, a rounded region and text on a device context.
+/// Plain GDI: a font, text, and an off-screen bitmap to draw them into.
 /// </summary>
 /// <remarks>
 /// GDI rather than GDI+ on purpose. <c>System.Drawing.Common</c> would make the drawing
@@ -85,11 +85,41 @@ internal static class GdiNative
         int iCharSet, int iOutPrecision, int iClipPrecision, int iQuality, int iPitchAndFamily,
         string pszFaceName);
 
-    [DllImport("gdi32.dll")]
-    internal static extern IntPtr CreateSolidBrush(uint color);
+    /// <summary>
+    /// A 32-bit surface to draw the popup into before anyone can see it.
+    /// </summary>
+    /// <remarks>
+    /// Top-down — a negative height — so that the first row of <paramref name="bits"/>
+    /// is the top row of the picture and the alpha fixing up afterwards can walk the
+    /// memory straight through.
+    /// </remarks>
+    internal static IntPtr CreateSurface(IntPtr deviceContext, int width, int height, out IntPtr bits)
+    {
+        var header = new BitmapInfoHeader
+        {
+            biSize = Marshal.SizeOf<BitmapInfoHeader>(),
+            biWidth = width,
+            biHeight = -height,
+            biPlanes = 1,
+            biBitCount = 32,
+            biCompression = BI_RGB,
+        };
+
+        return CreateDIBSection(deviceContext, ref header, DIB_RGB_COLORS, out bits, IntPtr.Zero, 0);
+    }
+
+    private const uint BI_RGB = 0;
+    private const uint DIB_RGB_COLORS = 0;
 
     [DllImport("gdi32.dll")]
-    internal static extern IntPtr CreateRoundRectRgn(int x1, int y1, int x2, int y2, int w, int h);
+    internal static extern IntPtr CreateCompatibleDC(IntPtr hdc);
+
+    [DllImport("gdi32.dll")]
+    internal static extern bool DeleteDC(IntPtr hdc);
+
+    [DllImport("gdi32.dll")]
+    private static extern IntPtr CreateDIBSection(IntPtr hdc, ref BitmapInfoHeader header, uint usage,
+        out IntPtr bits, IntPtr section, uint offset);
 
     [DllImport("gdi32.dll")]
     internal static extern IntPtr SelectObject(IntPtr hdc, IntPtr h);
@@ -103,9 +133,6 @@ internal static class GdiNative
     [DllImport("gdi32.dll")]
     internal static extern uint SetTextColor(IntPtr hdc, uint color);
 
-    [DllImport("user32.dll")]
-    internal static extern int FillRect(IntPtr hdc, ref PopupWindowNative.Rect lprc, IntPtr hbr);
-
     [DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "DrawTextW")]
     internal static extern int DrawText(IntPtr hdc, string lpchText, int cchText,
         ref PopupWindowNative.Rect lprc, uint format);
@@ -116,22 +143,19 @@ internal static class GdiNative
     [DllImport("user32.dll")]
     internal static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
 
-    [DllImport("user32.dll")]
-    internal static extern IntPtr BeginPaint(IntPtr hWnd, out PaintStruct lpPaint);
-
-    [DllImport("user32.dll")]
-    internal static extern bool EndPaint(IntPtr hWnd, ref PaintStruct lpPaint);
-
     [StructLayout(LayoutKind.Sequential)]
-    internal struct PaintStruct
+    private struct BitmapInfoHeader
     {
-        public IntPtr hdc;
-        public bool fErase;
-        public PopupWindowNative.Rect rcPaint;
-        public bool fRestore;
-        public bool fIncUpdate;
-
-        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
-        public byte[] rgbReserved;
+        public int biSize;
+        public int biWidth;
+        public int biHeight;
+        public short biPlanes;
+        public short biBitCount;
+        public uint biCompression;
+        public uint biSizeImage;
+        public int biXPelsPerMeter;
+        public int biYPelsPerMeter;
+        public uint biClrUsed;
+        public uint biClrImportant;
     }
 }

CursorLang.Agent/Interop/WindowNative.cs

@@ -13,7 +13,6 @@ internal static class WindowNative
     internal delegate IntPtr WindowProc(IntPtr hWnd, uint message, IntPtr wParam, IntPtr lParam);
 
     internal const int WS_POPUP = unchecked((int)0x80000000);
-    internal const int WS_DISABLED = 0x08000000;
 
     internal const int WS_EX_LAYERED = 0x00080000;
     internal const int WS_EX_TOOLWINDOW = 0x00000080;
@@ -25,19 +24,14 @@ internal static class WindowNative
     internal const int SW_SHOWNOACTIVATE = 4;
 
     internal const uint WM_DESTROY = 0x0002;
-    internal const uint WM_PAINT = 0x000F;
     internal const uint WM_CLOSE = 0x0010;
     internal const uint WM_QUIT = 0x0012;
     internal const uint WM_NULL = 0x0000;
-    internal const uint WM_DISPLAYCHANGE = 0x007E;
-    internal const uint WM_DPICHANGED = 0x02E0;
     internal const uint WM_ENDSESSION = 0x0016;
 
     /// <summary>WM_APP and up belong to the application; the tray takes WM_APP + 1.</summary>
     internal const uint WM_APP = 0x8000;
 
-    private const uint LWA_ALPHA = 0x00000002;
-
     /// <summary>
     /// Registers a window class. A class already there is not an error: the name is
     /// unique per window kind, and a second agent in the same process would meet its
@@ -80,9 +74,55 @@ internal static class WindowNative
         return window;
     }
 
-    /// <summary>The whole opacity of a layered window, 0 to 255.</summary>
-    internal static void SetAlpha(IntPtr window, byte alpha) =>
-        SetLayeredWindowAttributes(window, 0, alpha, LWA_ALPHA);
+    /// <summary>
+    /// Puts a finished picture into a layered window, together with where it goes and
+    /// how see-through it is.
+    /// </summary>
+    /// <remarks>
+    /// One call replaces moving the window, resizing it, painting it and setting its
+    /// opacity, and it works while the window is still hidden. That is the point: the
+    /// content is ready before anyone can see the window, so it can never be shown
+    /// holding the picture of the previous time.
+    /// </remarks>
+    internal static bool SetContent(
+        IntPtr window, PopupWindowNative.Point at, Size size, IntPtr sourceDc, byte alpha)
+    {
+        var source = new PopupWindowNative.Point { X = 0, Y = 0 };
+        var blend = new BlendFunction
+        {
+            BlendOp = AC_SRC_OVER,
+            SourceConstantAlpha = alpha,
+            AlphaFormat = AC_SRC_ALPHA,
+        };
+
+        return UpdateLayeredWindow(
+            window, IntPtr.Zero, ref at, ref size, sourceDc, ref source, 0, ref blend, ULW_ALPHA);
+    }
+
+    private const byte AC_SRC_OVER = 0;
+    private const byte AC_SRC_ALPHA = 1;
+    private const uint ULW_ALPHA = 0x00000002;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct BlendFunction
+    {
+        public byte BlendOp;
+        public byte BlendFlags;
+        public byte SourceConstantAlpha;
+        public byte AlphaFormat;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct Size
+    {
+        public int Width;
+        public int Height;
+    }
+
+    [DllImport("user32.dll", SetLastError = true)]
+    private static extern bool UpdateLayeredWindow(IntPtr hWnd, IntPtr hdcDst,
+        ref PopupWindowNative.Point pptDst, ref Size psize, IntPtr hdcSrc,
+        ref PopupWindowNative.Point pptSrc, uint crKey, ref BlendFunction pblend, uint dwFlags);
 
     [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
     private static extern ushort RegisterClassEx(ref WindowClass lpwcx);
@@ -104,27 +144,12 @@ internal static class WindowNative
     [DllImport("user32.dll")]
     internal static extern bool IsWindowVisible(IntPtr hWnd);
 
-    [DllImport("user32.dll")]
-    internal static extern bool InvalidateRect(IntPtr hWnd, IntPtr lpRect, bool bErase);
-
-    [DllImport("user32.dll")]
-    internal static extern bool UpdateWindow(IntPtr hWnd);
-
-    [DllImport("user32.dll")]
-    internal static extern bool SetWindowRgn(IntPtr hWnd, IntPtr hRgn, bool bRedraw);
-
-    [DllImport("user32.dll")]
-    internal static extern bool GetClientRect(IntPtr hWnd, out PopupWindowNative.Rect lpRect);
-
     [DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "PostMessageW")]
     internal static extern bool PostMessage(IntPtr hWnd, uint message, IntPtr wParam, IntPtr lParam);
 
     [DllImport("user32.dll")]
     internal static extern void PostQuitMessage(int nExitCode);
 
-    [DllImport("user32.dll")]
-    private static extern bool SetLayeredWindowAttributes(IntPtr hWnd, uint crKey, byte bAlpha, uint dwFlags);
-
     [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
     private static extern IntPtr GetModuleHandle(string? lpModuleName);
 

CursorLang.Agent/Services/CapsLockHotkeyService.cs

@@ -115,9 +115,28 @@ public sealed class CapsLockHotkeyService : ICapsLockHotkeyService, IDisposable
         return true;
     }
 
-    private void OnHoldTimerTick(object? sender, EventArgs e)
+    private void OnHoldTimerTick(object? sender, EventArgs e) => HandleHoldElapsed();
+
+    /// <summary>
+    /// The hold countdown has run out.
+    /// </summary>
+    /// <remarks>
+    /// The key being down is checked rather than assumed. A countdown started on the
+    /// press can still be delivered just after the release — Windows does not withdraw a
+    /// WM_TIMER it has already posted — and announcing a hold then would put the popup on
+    /// screen showing the layout the tap is about to change away from.
+    ///
+    /// The tests reach this directly: that ordering is the whole point and a real clock
+    /// will not reproduce it on demand.
+    /// </remarks>
+    internal void HandleHoldElapsed()
     {
         _holdTimer.Stop();
+        if (!_isPressed)
+        {
+            return;
+        }
+
         _isHolding = true;
         HoldStarted?.Invoke(this, EventArgs.Empty);
     }

CursorLang.Agent/Windows/NativePopupWindow.cs

@@ -1,4 +1,5 @@
 using System.Drawing;
+using System.Runtime.InteropServices;
 using CursorLang.Agent.Interop;
 using CursorLang.Agent.Services;
 using CursorLang.Core.Interop;
@@ -14,15 +15,18 @@ namespace CursorLang.Agent.Windows;
 /// A like-for-like replacement of the WPF popup this once was: a rounded rectangle of
 /// radius 4 with 10×4 padding, the fill and the text colour from the settings, the whole
 /// thing at the opacity from the settings, the name in Segoe UI SemiBold at the size
-/// from the settings. Measured against it side by side, the two agreed to the pixel in
-/// position and width.
+/// from the settings.
 ///
-/// The opacity comes from <c>SetLayeredWindowAttributes</c> and the rounded corners from
-/// a window region, which is the cheaper of the two ways of doing it: the text keeps
-/// ClearType, and no GDI+ or Direct2D is needed. The price is that a region is a binary
-/// mask — the corners are cut without antialiasing. At radius 4 that is a stepped arc of
-/// some fourteen pixels per corner, visible at eight times magnification and not at
-/// natural size, which is why this way was kept.
+/// The picture is drawn into an off-screen bitmap and handed to the window whole, by
+/// <c>UpdateLayeredWindow</c>. Painting on demand instead — a <c>WM_PAINT</c> after the
+/// window is shown — is what the first version did, and it had the popup appear holding
+/// the picture of the previous show: hiding a window does not throw its content away,
+/// and the content is always the other layout. Here there is nothing to be stale,
+/// because the window is never shown before its picture is in place.
+///
+/// It also does away with two devices the painted version needed: the corners came from
+/// a window region, which cuts without antialiasing, and the opacity from
+/// <c>SetLayeredWindowAttributes</c>. Both are now just pixels in the bitmap.
 ///
 /// Responsible only for showing the popup, its size and its place on screen: when to
 /// take it down is decided by <see cref="LayoutPopupService"/>.
@@ -38,16 +42,9 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
 
     private readonly AppSettings _settings;
 
-    private string _text = string.Empty;
     private IntPtr _font;
-    private IntPtr _background;
-
     private double _fontSize;
     private double _fontScale;
-    private uint _backgroundColorRef;
-    private byte? _alpha;
-    private Size _regionSize;
-    private int _regionRadius = -1;
 
     internal NativePopupWindow(AppSettings settings)
         : base(
@@ -71,8 +68,6 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
             return;
         }
 
-        _text = text;
-
         bool atFixedPoint = _settings.PlacementMode == PopupPlacementMode.FixedPoint;
         PopupWindowNative.Rect work = default;
         PopupWindowNative.Rect anchor = default;
@@ -90,7 +85,7 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
 
         EnsureFont(scale);
 
-        Size measured = MeasureText();
+        Size measured = MeasureText(text);
         int width = measured.Width + (2 * PopupLayout.ToPixels(PaddingX, scale));
         int height = measured.Height + (2 * PopupLayout.ToPixels(PaddingY, scale));
 
@@ -99,21 +94,15 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
                 work, _settings.ScreenPosition, PopupLayout.ToPixels(_settings.ScreenMargin, scale), width, height)
             : PopupLayout.NearAnchor(anchor, AnchorSideForMode(), OffsetForMode(scale), width, height);
 
-        PopupWindowNative.SetBounds(Handle, position.X, position.Y, width, height);
-
-        ApplyRegion(width, height, PopupLayout.ToPixels(CornerRadius, scale));
-        ApplyOpacity();
+        if (!Draw(text, position, width, height, PopupLayout.ToPixels(CornerRadius, scale)))
+        {
+            return;
+        }
 
         if (!WindowNative.IsWindowVisible(Handle))
         {
             WindowNative.ShowWindow(Handle, WindowNative.SW_SHOWNOACTIVATE);
         }
-
-        // The repaint is forced rather than left to the queue: a layout switch is
-        // followed at once by the user looking at the popup, and a WM_PAINT waiting its
-        // turn behind a slow message is exactly how stale text gets on screen
-        WindowNative.InvalidateRect(Handle, IntPtr.Zero, false);
-        WindowNative.UpdateWindow(Handle);
     }
 
     public void Hide()
@@ -130,27 +119,205 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
     public override void Dispose()
     {
         ReleaseFont();
-
-        if (_background != IntPtr.Zero)
-        {
-            GdiNative.DeleteObject(_background);
-            _background = IntPtr.Zero;
-        }
-
         base.Dispose();
     }
 
-    protected override bool OnMessage(uint message, IntPtr wParam, IntPtr lParam, out IntPtr result)
+    /// <summary>
+    /// Draws the popup off screen and hands the finished picture to the window.
+    /// </summary>
+    /// <remarks>
+    /// The bitmap is thrown away afterwards rather than kept: it is a few tens of
+    /// kilobytes for the length of one call, the popup is shown rarely, and a cached one
+    /// would have to be rebuilt on every change of size, colour or scale anyway.
+    /// </remarks>
+    private bool Draw(string text, PopupWindowNative.Point at, int width, int height, int radius)
     {
-        result = IntPtr.Zero;
-
-        if (message != WindowNative.WM_PAINT)
+        IntPtr screen = GdiNative.GetDC(IntPtr.Zero);
+        if (screen == IntPtr.Zero)
         {
             return false;
         }
 
-        Paint();
-        return true;
+        IntPtr memory = IntPtr.Zero;
+        IntPtr surface = IntPtr.Zero;
+
+        try
+        {
+            memory = GdiNative.CreateCompatibleDC(screen);
+            if (memory == IntPtr.Zero)
+            {
+                return false;
+            }
+
+            surface = GdiNative.CreateSurface(memory, width, height, out IntPtr bits);
+            if (surface == IntPtr.Zero)
+            {
+                return false;
+            }
+
+            GdiNative.SelectObject(memory, surface);
+
+            Fill(bits, width, height);
+            DrawText(memory, text, width, height);
+
+            // GDI writes nothing into the alpha channel, so the letters it just drew are
+            // sitting at zero alpha and would come out invisible. The inside of the
+            // popup is opaque anyway, so the whole surface is simply declared so — and
+            // the corners are rounded off afterwards, which is the only place alpha
+            // varies
+            MakeOpaque(bits, width, height);
+            RoundTheCorners(bits, width, height, radius);
+
+            var size = new WindowNative.Size { Width = width, Height = height };
+            var alpha = (byte)Math.Clamp(Math.Round(_settings.Opacity * 255), 0, 255);
+
+            return WindowNative.SetContent(Handle, at, size, memory, alpha);
+        }
+        finally
+        {
+            // The context goes first: a bitmap still selected into one cannot be
+            // deleted, and this way that holds however the method was left
+            if (memory != IntPtr.Zero)
+            {
+                GdiNative.DeleteDC(memory);
+            }
+
+            if (surface != IntPtr.Zero)
+            {
+                GdiNative.DeleteObject(surface);
+            }
+
+            GdiNative.ReleaseDC(IntPtr.Zero, screen);
+        }
+    }
+
+    private void Fill(IntPtr bits, int width, int height)
+    {
+        Color background = _settings.BackgroundColor;
+
+        // Straight into the bitmap rather than through a brush: the pixels have to be
+        // written anyway to carry an alpha channel GDI would not touch
+        int packed = (255 << 24) | (background.R << 16) | (background.G << 8) | background.B;
+        var row = new int[width];
+        Array.Fill(row, packed);
+
+        for (var y = 0; y < height; y++)
+        {
+            Marshal.Copy(row, 0, bits + (y * width * 4), width);
+        }
+    }
+
+    private void DrawText(IntPtr deviceContext, string text, int width, int height)
+    {
+        if (_font == IntPtr.Zero || text.Length == 0)
+        {
+            return;
+        }
+
+        var bounds = new PopupWindowNative.Rect { Left = 0, Top = 0, Right = width, Bottom = height };
+
+        IntPtr previousFont = GdiNative.SelectObject(deviceContext, _font);
+        GdiNative.SetBkMode(deviceContext, GdiNative.TRANSPARENT);
+        GdiNative.SetTextColor(deviceContext, GdiNative.ToColorRef(_settings.ForegroundColor));
+
+        GdiNative.DrawText(deviceContext, text, text.Length, ref bounds,
+            GdiNative.DT_SINGLELINE | GdiNative.DT_CENTER | GdiNative.DT_VCENTER |
+            GdiNative.DT_NOPREFIX | GdiNative.DT_NOCLIP);
+
+        GdiNative.SelectObject(deviceContext, previousFont);
+    }
+
+    private static void MakeOpaque(IntPtr bits, int width, int height)
+    {
+        var row = new int[width];
+
+        for (var y = 0; y < height; y++)
+        {
+            IntPtr line = bits + (y * width * 4);
+            Marshal.Copy(line, row, 0, width);
+
+            for (var x = 0; x < width; x++)
+            {
+                row[x] = (int)((uint)row[x] | 0xFF000000);
+            }
+
+            Marshal.Copy(row, 0, line, width);
+        }
+    }
+
+    /// <summary>
+    /// Cuts the four corners to a radius, fading the edge rather than stepping it.
+    /// </summary>
+    /// <remarks>
+    /// The painted version cut them with a window region, which is a yes-or-no mask and
+    /// left a visible staircase at 200% scale. Here the corner pixels carry a partial
+    /// alpha worked out from how far the pixel centre is past the arc, which is what
+    /// antialiasing amounts to. The colours are premultiplied to match, as
+    /// <c>UpdateLayeredWindow</c> expects.
+    /// </remarks>
+    private static void RoundTheCorners(IntPtr bits, int width, int height, int radius)
+    {
+        if (radius <= 0)
+        {
+            return;
+        }
+
+        radius = Math.Min(radius, Math.Min(width, height) / 2);
+
+        var row = new int[width];
+
+        for (var y = 0; y < height; y++)
+        {
+            bool nearTop = y < radius;
+            bool nearBottom = y >= height - radius;
+            if (!nearTop && !nearBottom)
+            {
+                continue;
+            }
+
+            IntPtr line = bits + (y * width * 4);
+            Marshal.Copy(line, row, 0, width);
+
+            double centreY = nearTop ? radius - 0.5 : height - radius - 0.5;
+
+            for (var x = 0; x < width; x++)
+            {
+                bool nearLeft = x < radius;
+                bool nearRight = x >= width - radius;
+                if (!nearLeft && !nearRight)
+                {
+                    continue;
+                }
+
+                double centreX = nearLeft ? radius - 0.5 : width - radius - 0.5;
+                double distance = Math.Sqrt(
+                    ((x - centreX) * (x - centreX)) + ((y - centreY) * (y - centreY)));
+
+                // One pixel of softness across the arc: fully inside, fully outside,
+                // and a ramp in between
+                double coverage = Math.Clamp(radius - distance + 0.5, 0, 1);
+                if (coverage >= 1)
+                {
+                    continue;
+                }
+
+                row[x] = Premultiply(row[x], coverage);
+            }
+
+            Marshal.Copy(row, 0, line, width);
+        }
+    }
+
+    private static int Premultiply(int pixel, double coverage)
+    {
+        var value = (uint)pixel;
+        var alpha = (uint)Math.Round(((value >> 24) & 0xFF) * coverage);
+
+        uint red = (uint)Math.Round(((value >> 16) & 0xFF) * coverage);
+        uint green = (uint)Math.Round(((value >> 8) & 0xFF) * coverage);
+        uint blue = (uint)Math.Round((value & 0xFF) * coverage);
+
+        return (int)((alpha << 24) | (red << 16) | (green << 8) | blue);
     }
 
     // The anchor point: the caret in the input field or the mouse cursor. The cursor
@@ -174,42 +341,7 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
         _settings.PlacementMode == PopupPlacementMode.AtCaret ? _settings.CaretOffset : _settings.CursorOffset,
         scale);
 
-    private void Paint()
-    {
-        IntPtr deviceContext = GdiNative.BeginPaint(Handle, out GdiNative.PaintStruct paint);
-        if (deviceContext == IntPtr.Zero)
-        {
-            return;
-        }
-
-        try
-        {
-            WindowNative.GetClientRect(Handle, out PopupWindowNative.Rect client);
-
-            GdiNative.FillRect(deviceContext, ref client, EnsureBackground());
-
-            if (_font == IntPtr.Zero || _text.Length == 0)
-            {
-                return;
-            }
-
-            IntPtr previousFont = GdiNative.SelectObject(deviceContext, _font);
-            GdiNative.SetBkMode(deviceContext, GdiNative.TRANSPARENT);
-            GdiNative.SetTextColor(deviceContext, GdiNative.ToColorRef(_settings.ForegroundColor));
-
-            GdiNative.DrawText(deviceContext, _text, _text.Length, ref client,
-                GdiNative.DT_SINGLELINE | GdiNative.DT_CENTER | GdiNative.DT_VCENTER |
-                GdiNative.DT_NOPREFIX | GdiNative.DT_NOCLIP);
-
-            GdiNative.SelectObject(deviceContext, previousFont);
-        }
-        finally
-        {
-            GdiNative.EndPaint(Handle, ref paint);
-        }
-    }
-
-    private Size MeasureText()
+    private Size MeasureText(string text)
     {
         IntPtr deviceContext = GdiNative.GetDC(Handle);
         if (deviceContext == IntPtr.Zero)
@@ -220,10 +352,10 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
         try
         {
             IntPtr previousFont = GdiNative.SelectObject(deviceContext, _font);
-            Size size = GdiNative.MeasureText(deviceContext, _text);
+            Size measured = GdiNative.MeasureText(deviceContext, text);
             GdiNative.SelectObject(deviceContext, previousFont);
 
-            return size;
+            return measured;
         }
         finally
         {
@@ -231,13 +363,13 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
         }
     }
 
-    // The font is rebuilt only when the size in the settings or the monitor changes:
-    // creating one costs a trip to the font mapper, and the popup is shown often
+    // The font is rebuilt only when the size in the settings or the monitor scale
+    // changes: it is the one expensive thing a show does
     private void EnsureFont(double scale)
     {
         if (_font != IntPtr.Zero &&
-            Math.Abs(_fontSize - _settings.FontSize) < 0.001 &&
-            Math.Abs(_fontScale - scale) < 0.001)
+            Math.Abs(_fontSize - _settings.FontSize) < 0.01 &&
+            Math.Abs(_fontScale - scale) < 0.01)
         {
             return;
         }
@@ -251,71 +383,10 @@ internal sealed class NativePopupWindow : NativeWindow, ILayoutPopupWindow
 
     private void ReleaseFont()
     {
-        if (_font == IntPtr.Zero)
+        if (_font != IntPtr.Zero)
         {
-            return;
+            GdiNative.DeleteObject(_font);
+            _font = IntPtr.Zero;
         }
-
-        GdiNative.DeleteObject(_font);
-        _font = IntPtr.Zero;
-    }
-
-    private IntPtr EnsureBackground()
-    {
-        uint colorRef = GdiNative.ToColorRef(_settings.BackgroundColor);
-        if (_background != IntPtr.Zero && _backgroundColorRef == colorRef)
-        {
-            return _background;
-        }
-
-        if (_background != IntPtr.Zero)
-        {
-            GdiNative.DeleteObject(_background);
-        }
-
-        _backgroundColorRef = colorRef;
-        _background = GdiNative.CreateSolidBrush(colorRef);
-
-        return _background;
-    }
-
-    // A region is in window coordinates, so a resize invalidates it. Reapplying it
-    // every show would do no harm, but the system frees the old region each time and
-    // the popup is shown far more often than it changes size
-    private void ApplyRegion(int width, int height, int radius)
-    {
-        if (_regionSize.Width == width && _regionSize.Height == height && _regionRadius == radius)
-        {
-            return;
-        }
-
-        // The right and bottom edges of CreateRoundRectRgn are exclusive, and the
-        // ellipse the corners are cut with is twice the radius across
-        IntPtr region = GdiNative.CreateRoundRectRgn(0, 0, width + 1, height + 1, radius * 2, radius * 2);
-        if (region == IntPtr.Zero)
-        {
-            return;
-        }
-
-        if (!WindowNative.SetWindowRgn(Handle, region, false))
-        {
-            GdiNative.DeleteObject(region);
-            return;
-        }
-
-        _regionSize = new Size(width, height);
-        _regionRadius = radius;
-    }
-
-    private void ApplyOpacity()
-    {
-        var alpha = (byte)Math.Clamp(Math.Round(_settings.Opacity * 255), 0, 255);
-        if (alpha == _alpha)
-        {
-            return;
-        }
-
-        _alpha = alpha;
-        WindowNative.SetAlpha(Handle, alpha);
     }
 }

CursorLang.Agent/Windows/NativeWindow.cs

@@ -67,9 +67,14 @@ internal abstract class NativeWindow : IDisposable
 
     /// <summary>
     /// A message for this window. Returning <c>false</c> passes it to
-    /// <c>DefWindowProcW</c>, which is what the vast majority of messages want.
+    /// <c>DefWindowProcW</c>, which is what the vast majority of messages want — and
+    /// what all of them want for a window whose content is set from the outside.
     /// </summary>
-    protected abstract bool OnMessage(uint message, IntPtr wParam, IntPtr lParam, out IntPtr result);
+    protected virtual bool OnMessage(uint message, IntPtr wParam, IntPtr lParam, out IntPtr result)
+    {
+        result = IntPtr.Zero;
+        return false;
+    }
 
     private static IntPtr StaticWindowProc(IntPtr hWnd, uint message, IntPtr wParam, IntPtr lParam)
     {

CursorLang.Core.Tests/Services/KeyboardLayoutServiceTests.cs

@@ -17,7 +17,6 @@ public sealed class KeyboardLayoutServiceTests
 
     private const int English = 0x0409;
     private const int Russian = 0x0419;
-    private const int German = 0x0407;
 
     [Fact]
     public void The_current_layout_is_taken_from_the_foreground_window()
@@ -52,7 +51,6 @@ public sealed class KeyboardLayoutServiceTests
         Pump.Run(service.Start);
         world.LocaleId = Russian;
         Pump.Run(service.Poll);
-        Pump.Run(service.Poll);
 
         LayoutChangedEventArgs change = Assert.Single(world.Changes);
         Assert.Equal(LayoutChangeReason.UserSwitched, change.Reason);
@@ -70,7 +68,6 @@ public sealed class KeyboardLayoutServiceTests
         world.ForegroundWindow = SecondWindow;
         world.LocaleId = Russian;
         Pump.Run(service.Poll);
-        Pump.Run(service.Poll);
 
         LayoutChangedEventArgs change = Assert.Single(world.Changes);
         Assert.Equal(LayoutChangeReason.ApplicationSwitched, change.Reason);
@@ -125,91 +122,10 @@ public sealed class KeyboardLayoutServiceTests
         // And the layout was not remembered: the change is noticed once a window is back
         world.ForegroundWindow = FirstWindow;
         Pump.Run(service.Poll);
-        Pump.Run(service.Poll);
 
         Assert.Single(world.Changes);
     }
 
-    /// <summary>
-    /// A value the switch is only passing through never reaches the subscribers.
-    /// </summary>
-    /// <remarks>
-    /// A layout change is rarely a single step: the Windows language switcher takes the
-    /// focus while it is up, and applications with a rendering engine of their own move
-    /// a helper thread first. Reporting what polling caught in between meant the popup
-    /// coming up with one layout and turning into another in front of the user.
-    /// </remarks>
-    [Fact]
-    public void A_layout_the_switch_only_passes_through_is_never_reported()
-    {
-        using var world = new World { LocaleId = English };
-        KeyboardLayoutService service = world.CreateService();
-
-        Pump.Run(service.Start);
-
-        world.LocaleId = German;
-        Pump.Run(service.Poll);
-
-        Assert.Empty(world.Changes);
-
-        world.LocaleId = Russian;
-        Pump.Run(service.Poll);
-        Pump.Run(service.Poll);
-
-        LayoutChangedEventArgs change = Assert.Single(world.Changes);
-        Assert.Equal("RU", change.Layout.ShortName);
-    }
-
-    // A switch that goes out and comes back is not a switch at all
-    [Fact]
-    public void A_layout_that_returns_to_where_it_was_yields_no_events()
-    {
-        using var world = new World { LocaleId = English };
-        KeyboardLayoutService service = world.CreateService();
-
-        Pump.Run(service.Start);
-
-        world.LocaleId = Russian;
-        Pump.Run(service.Poll);
-
-        world.LocaleId = English;
-        Pump.Run(service.Poll);
-        Pump.Run(service.Poll);
-
-        Assert.Empty(world.Changes);
-    }
-
-    /// <summary>
-    /// A window the switch passes through does not make it an application switch.
-    /// </summary>
-    /// <remarks>
-    /// The Windows language switcher is a window of its own and holds the foreground
-    /// while it is up. Judging by the window seen on the previous tick would call that
-    /// an application switch and swallow the popup, so the judgement is made against
-    /// the window that was there before the whole transition started.
-    /// </remarks>
-    [Fact]
-    public void A_window_the_switch_passes_through_is_not_an_application_switch()
-    {
-        using var world = new World { LocaleId = English };
-        KeyboardLayoutService service = world.CreateService();
-
-        Pump.Run(service.Start);
-
-        world.ForegroundWindow = SecondWindow;
-        world.LocaleId = German;
-        Pump.Run(service.Poll);
-
-        world.ForegroundWindow = FirstWindow;
-        world.LocaleId = Russian;
-        Pump.Run(service.Poll);
-        Pump.Run(service.Poll);
-
-        LayoutChangedEventArgs change = Assert.Single(world.Changes);
-        Assert.Equal(LayoutChangeReason.UserSwitched, change.Reason);
-        Assert.Equal("RU", change.Layout.ShortName);
-    }
-
     [Fact]
     public void One_change_yields_exactly_one_event()
     {
@@ -221,7 +137,6 @@ public sealed class KeyboardLayoutServiceTests
         world.LocaleId = Russian;
         Pump.Run(service.Poll);
         Pump.Run(service.Poll);
-        Pump.Run(service.Poll);
 
         Assert.Single(world.Changes);
     }
@@ -344,11 +259,9 @@ public sealed class KeyboardLayoutServiceTests
 
         internal KeyboardLayoutService CreateService(TimeSpan? pollInterval = null)
         {
-            TimeSpan interval = pollInterval ?? TimeSpan.FromHours(1);
             var options = new KeyboardLayoutOptions
             {
-                PollInterval = interval,
-                SettleInterval = interval,
+                PollInterval = pollInterval ?? TimeSpan.FromHours(1),
             };
 
             _service = Pump.Run(() => new KeyboardLayoutService(

CursorLang.Core.Tests/Services/LayoutNotificationCoordinatorTests.cs

@@ -10,6 +10,7 @@ namespace CursorLang.Core.Tests.Services;
 public sealed class LayoutNotificationCoordinatorTests
 {
     private static readonly KeyboardLayout Russian = KeyboardLayout.FromLocaleId(0x0419);
+    private static readonly KeyboardLayout English = KeyboardLayout.FromLocaleId(0x0409);
 
     [Fact]
     public void Starting_turns_on_the_layout_watch()

CursorLang.Core.Tests/Threading/MessageTimerTests.cs

@@ -0,0 +1,129 @@
+using CursorLang.Core.Threading;
+using CursorLang.Tests.Shared;
+
+namespace CursorLang.Core.Tests.Threading;
+
+/// <summary>
+/// The timer the agent has instead of a dispatcher timer.
+/// </summary>
+/// <remarks>
+/// It ticks on the message loop, so everything here runs on the pump thread — a timer
+/// started on one thread and awaited on another would never be seen to fire.
+/// </remarks>
+public sealed class MessageTimerTests
+{
+    [Fact]
+    public void A_started_timer_ticks()
+    {
+        int ticks = 0;
+
+        Pump.Run(() =>
+        {
+            using var timer = new MessageTimer();
+            timer.Interval = TimeSpan.FromMilliseconds(15);
+            timer.Tick += (_, _) => ticks++;
+            timer.Start();
+
+            Pump.WaitFor(() => ticks > 0, "the timer ticked");
+        });
+    }
+
+    [Fact]
+    public void A_timer_keeps_ticking_until_it_is_stopped()
+    {
+        var ticks = 0;
+
+        Pump.Run(() =>
+        {
+            using var timer = new MessageTimer();
+            timer.Interval = TimeSpan.FromMilliseconds(15);
+            timer.Tick += (_, _) => ticks++;
+            timer.Start();
+
+            Pump.WaitFor(() => ticks >= 3, "the timer ticked more than once");
+        });
+    }
+
+    // A stopped countdown does not go off, however long the loop runs afterwards
+    [Fact]
+    public void A_stopped_timer_does_not_tick()
+    {
+        var ticks = 0;
+
+        Pump.Run(() =>
+        {
+            using var timer = new MessageTimer();
+            timer.Interval = TimeSpan.FromMilliseconds(10);
+            timer.Tick += (_, _) => ticks++;
+            timer.Start();
+            timer.Stop();
+
+            Pump.Pause(TimeSpan.FromMilliseconds(80));
+        });
+
+        Assert.Equal(0, ticks);
+    }
+
+    // Restarting means from zero, so a countdown kept short by repeated restarts
+    // never reaches its end
+    [Fact]
+    public void Restarting_begins_the_countdown_again()
+    {
+        var ticks = 0;
+
+        Pump.Run(() =>
+        {
+            using var timer = new MessageTimer();
+            timer.Interval = TimeSpan.FromMilliseconds(60);
+            timer.Tick += (_, _) => ticks++;
+
+            for (var i = 0; i < 6; i++)
+            {
+                timer.Start();
+                Pump.Pause(TimeSpan.FromMilliseconds(20));
+            }
+
+            Assert.Equal(0, ticks);
+
+            Pump.WaitFor(() => ticks > 0, "left alone, the timer reached its end");
+        });
+    }
+
+    [Fact]
+    public void Closing_the_timer_ends_the_ticking()
+    {
+        var ticks = 0;
+
+        Pump.Run(() =>
+        {
+            var timer = new MessageTimer { Interval = TimeSpan.FromMilliseconds(15) };
+            timer.Tick += (_, _) => ticks++;
+            timer.Start();
+
+            Pump.WaitFor(() => ticks > 0, "the timer ticked");
+            timer.Dispose();
+
+            int seen = ticks;
+            Pump.Pause(TimeSpan.FromMilliseconds(80));
+
+            Assert.Equal(seen, ticks);
+        });
+    }
+
+    [Fact]
+    public void A_timer_that_was_never_started_says_so()
+    {
+        Pump.Run(() =>
+        {
+            using var timer = new MessageTimer();
+
+            Assert.False(timer.IsRunning);
+
+            timer.Start();
+            Assert.True(timer.IsRunning);
+
+            timer.Stop();
+            Assert.False(timer.IsRunning);
+        });
+    }
+}

CursorLang.Core/Interop/PopupWindowNative.cs

@@ -21,12 +21,6 @@ internal static class PopupWindowNative
     [DllImport("user32.dll")]
     private static extern IntPtr GetForegroundWindow();
 
-    [DllImport("user32.dll", SetLastError = true)]
-    private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
-
-    [DllImport("user32.dll")]
-    private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
-
     [DllImport("user32.dll")]
     private static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter,
         int X, int Y, int cx, int cy, uint uFlags);
@@ -61,12 +55,6 @@ internal static class PopupWindowNative
         public uint dwFlags;
     }
 
-    private const int GWL_EXSTYLE = -20;
-    // The window does not take focus away from the active application
-    private const int WS_EX_NOACTIVATE = 0x08000000;
-    // And does not show up in Alt+Tab
-    private const int WS_EX_TOOLWINDOW = 0x00000080;
-
     private const uint SWP_NOSIZE = 0x0001;
     private const uint SWP_NOZORDER = 0x0004;
     private const uint SWP_NOACTIVATE = 0x0010;
@@ -80,16 +68,6 @@ internal static class PopupWindowNative
         return cursor;
     }
 
-    /// <summary>
-    /// The popup shows up on top of other applications, so it must neither
-    /// activate itself nor steal input focus from the active window.
-    /// </summary>
-    internal static void MakePassive(IntPtr hWnd)
-    {
-        int exStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
-        SetWindowLong(hWnd, GWL_EXSTYLE, exStyle | WS_EX_NOACTIVATE | WS_EX_TOOLWINDOW);
-    }
-
     /// <summary>
     /// Moves the window to a screen point without changing its size or z-order.
     /// The coordinates are physical pixels: monitors have different scaling, while
@@ -101,21 +79,6 @@ internal static class PopupWindowNative
         SetWindowPos(hWnd, IntPtr.Zero, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
     }
 
-    /// <summary>
-    /// Sets the window position and size in physical pixels.
-    /// </summary>
-    /// <remarks>
-    /// The size is set this way rather than through Width/Height: on the first show the
-    /// window is still subject to the system minimum window size (SM_CXMIN×SM_CYMIN)
-    /// and the popup comes out noticeably larger than its text. By the time this is
-    /// called the window is already shown and has become a popup window, which that
-    /// restriction does not apply to.
-    /// </remarks>
-    internal static void SetBounds(IntPtr hWnd, int x, int y, int width, int height)
-    {
-        SetWindowPos(hWnd, IntPtr.Zero, x, y, width, height, SWP_NOZORDER | SWP_NOACTIVATE);
-    }
-
     /// <summary>The scale of the monitor the point is on (1.0 at 96 DPI).</summary>
     internal static double GetScaleAt(Point point) =>
         GetScaleOf(MonitorFromPoint(point, MONITOR_DEFAULTTONEAREST));

CursorLang.Core/Services/KeyboardLayoutService.cs

@@ -11,16 +11,6 @@ public sealed class KeyboardLayoutOptions
 {
     /// <summary>How often to check the layout of the active window.</summary>
     public TimeSpan PollInterval { get; init; } = TimeSpan.FromMilliseconds(150);
-
-    /// <summary>
-    /// How long to wait for a layout that has just changed to stop changing.
-    /// </summary>
-    /// <remarks>
-    /// Short on purpose: it is added to the delay before the popup shows, and it only
-    /// applies while a switch is in flight. See the settling in
-    /// <see cref="KeyboardLayoutService"/>.
-    /// </remarks>
-    public TimeSpan SettleInterval { get; init; } = TimeSpan.FromMilliseconds(40);
 }
 
 /// <summary>
@@ -36,18 +26,6 @@ public sealed class KeyboardLayoutOptions
 ///
 /// The timer ticks on the message loop of whatever thread starts it, the same as a
 /// dispatcher timer did: the agent has a plain Win32 loop and no dispatcher to offer.
-///
-/// A switch is not reported the moment it is first seen but once the value has stopped
-/// moving. A layout change is rarely a single step: the language switcher of Windows
-/// takes the focus while it is up, and applications with a rendering engine of their
-/// own change the layout of a helper thread before that of the input window. Polling
-/// catches those in-between values, and reporting them meant the popup appearing with
-/// one layout and turning into another in front of the user.
-///
-/// The price is that the popup comes up one short tick later. While a switch is in
-/// flight the timer runs at <see cref="KeyboardLayoutOptions.SettleInterval"/> rather
-/// than at the polling interval, so that tick is a few tens of milliseconds and not
-/// another whole poll.
 /// </remarks>
 public sealed class KeyboardLayoutService : IKeyboardLayoutService, IDisposable
 {
@@ -55,11 +33,9 @@ public sealed class KeyboardLayoutService : IKeyboardLayoutService, IDisposable
     private readonly Func<IntPtr> _getForegroundWindow;
     private readonly Func<int> _getActiveLocaleId;
     private readonly Action _requestNextLayout;
-    private readonly KeyboardLayoutOptions _options;
 
     private int _lastLocaleId = -1;
     private IntPtr _lastForegroundWindow;
-    private int _settlingLocaleId = -1;
 
     public KeyboardLayoutService(KeyboardLayoutOptions options)
         : this(
@@ -83,7 +59,6 @@ public sealed class KeyboardLayoutService : IKeyboardLayoutService, IDisposable
         _getForegroundWindow = getForegroundWindow;
         _getActiveLocaleId = getActiveLocaleId;
         _requestNextLayout = requestNextLayout;
-        _options = options;
 
         _pollTimer = new MessageTimer { Interval = options.PollInterval };
         _pollTimer.Tick += OnTick;
@@ -97,8 +72,6 @@ public sealed class KeyboardLayoutService : IKeyboardLayoutService, IDisposable
     {
         _lastForegroundWindow = _getForegroundWindow();
         _lastLocaleId = _getActiveLocaleId();
-        _settlingLocaleId = -1;
-        _pollTimer.Interval = _options.PollInterval;
         _pollTimer.Start();
     }
 
@@ -125,28 +98,16 @@ public sealed class KeyboardLayoutService : IKeyboardLayoutService, IDisposable
             return;
         }
 
+        bool appSwitched = foreground != _lastForegroundWindow;
+        _lastForegroundWindow = foreground;
+
         int localeId = _getActiveLocaleId();
         if (localeId == _lastLocaleId)
         {
-            _lastForegroundWindow = foreground;
-            Settle(inFlight: false);
-
             return;
         }
 
-        if (localeId != _settlingLocaleId)
-        {
-            _settlingLocaleId = localeId;
-            Settle(inFlight: true);
-
-            return;
-        }
-
-        bool appSwitched = foreground != _lastForegroundWindow;
-
         _lastLocaleId = localeId;
-        _lastForegroundWindow = foreground;
-        Settle(inFlight: false);
 
         // Moving to another application with a layout of its own is not the same as
         // the user switching the layout, and the subscribers are free to react to
@@ -157,23 +118,4 @@ public sealed class KeyboardLayoutService : IKeyboardLayoutService, IDisposable
 
         LayoutChanged?.Invoke(this, new LayoutChangedEventArgs(KeyboardLayout.FromLocaleId(localeId), reason));
     }
-
-    // While a switch is in flight the next look comes sooner: that wait is added to the
-    // delay before the popup, and a whole polling interval there would be felt
-    private void Settle(bool inFlight)
-    {
-        if (!inFlight)
-        {
-            _settlingLocaleId = -1;
-        }
-
-        TimeSpan wanted = inFlight ? _options.SettleInterval : _options.PollInterval;
-        if (_pollTimer.Interval == wanted || !_pollTimer.IsRunning)
-        {
-            return;
-        }
-
-        _pollTimer.Interval = wanted;
-        _pollTimer.Start();
-    }
 }

CursorLang.Core/Threading/MessageLoop.cs

@@ -38,38 +38,10 @@ public static class MessageLoop
     /// <summary>Asks the loop on this thread to finish.</summary>
     public static void Quit(int exitCode = 0) => PostQuitMessage(exitCode);
 
-    /// <summary>
-    /// Runs everything already waiting in the queue and returns.
-    /// </summary>
-    /// <remarks>
-    /// For the tests and for the rare place that has to let a posted message through
-    /// without giving up control for good.
-    /// </remarks>
-    public static void DrainQueue()
-    {
-        while (PeekMessage(out Message message, IntPtr.Zero, 0, 0, PM_REMOVE))
-        {
-            if (message.message == WM_QUIT)
-            {
-                PostQuitMessage((int)message.wParam);
-                return;
-            }
-
-            TranslateMessage(ref message);
-            DispatchMessage(ref message);
-        }
-    }
-
-    private const uint WM_QUIT = 0x0012;
-    private const uint PM_REMOVE = 0x0001;
 
     [DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "GetMessageW")]
     private static extern int GetMessage(out Message lpMsg, IntPtr hWnd, uint filterMin, uint filterMax);
 
-    [DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "PeekMessageW")]
-    private static extern bool PeekMessage(
-        out Message lpMsg, IntPtr hWnd, uint filterMin, uint filterMax, uint removeMsg);
-
     [DllImport("user32.dll")]
     private static extern bool TranslateMessage(ref Message lpMsg);
 

CursorLang.Settings.Tests/Interop/NativeWrappersTests.cs

@@ -94,23 +94,6 @@ public sealed class NativeWrappersTests
         });
     }
 
-    [Fact]
-    public void The_window_bounds_are_set_as_a_whole()
-    {
-        Sta.Run(() =>
-        {
-            using var window = new HandleWindow();
-
-            PopupWindowNative.SetBounds(window.Handle, 60, 70, 320, 240);
-
-            PopupWindowNative.Rect bounds = WindowPlacementNative.TryGetBounds(window.Handle)!.Value;
-            Assert.Equal(60, bounds.Left);
-            Assert.Equal(70, bounds.Top);
-            Assert.Equal(380, bounds.Right);
-            Assert.Equal(310, bounds.Bottom);
-        });
-    }
-
     [Fact]
     public void The_work_area_is_found_by_the_rectangle_of_the_window()
     {
@@ -139,21 +122,6 @@ public sealed class NativeWrappersTests
         Assert.True(work.Value.Right > work.Value.Left);
     }
 
-    [Fact]
-    public void A_window_becomes_invisible_to_the_focus_and_the_switcher()
-    {
-        Sta.Run(() =>
-        {
-            using var window = new HandleWindow();
-
-            PopupWindowNative.MakePassive(window.Handle);
-
-            // Checked through the same wrapper: the style has to stick and not
-            // be reset by a repeated call
-            PopupWindowNative.MakePassive(window.Handle);
-        });
-    }
-
     [Fact]
     public void The_layout_of_the_foreground_window_is_read()
     {