lightweight variant (#1)

Reviewed-on: #1 Co-authored-by: Aleksandr Neychev <alexnejchev73@gmail.com>
2026-08-12 13:37:30 +00:00
parent a0d3098fe4
commit 55ac8e6556
147 changed files with 4055 additions and 2349 deletions
@@ -0,0 +1,179 @@
+using System.Windows;
+using System.Windows.Interop;
+using CursorLang.Core.Interop;
+using CursorLang.Settings.Interop;
+
+namespace CursorLang.Settings.Services;
+
+/// <summary>
+/// Decides where the settings window shows up: for the first time in a session — in
+/// the centre of the monitor the user is working on, and after that — where they
+/// left that window.
+/// </summary>
+/// <remarks>
+/// The position lives in memory only and is not kept between launches: the set of
+/// monitors may be different by the next launch, while "in the centre of the active
+/// one" is always right.
+/// </remarks>
+public sealed class MainWindowPlacement
+{
+    private PopupWindowNative.Point? _position;
+
+    // The window reports a move when we move it ourselves as well;
+    // what has to be remembered is only what the user chose
+    private bool _isPlacing;
+
+    /// <summary>
+    /// Takes over the placement of the window: puts it in place by the first show
+    /// and follows where the user moves it.
+    /// </summary>
+    public void Attach(Window window)
+    {
+        window.SourceInitialized += OnSourceInitialized;
+        window.LocationChanged += OnLocationChanged;
+    }
+
+    /// <summary>
+    /// Returns the window to the remembered place, and when it has not been shown
+    /// yet during this session — puts it in the centre of the active monitor.
+    /// </summary>
+    public void Apply(Window window)
+    {
+        // A minimized window has no meaningful bounds: it is restored in its former
+        // place, and it can be positioned only after that
+        if (window.WindowState != WindowState.Normal)
+        {
+            return;
+        }
+
+        IntPtr handle = new WindowInteropHelper(window).Handle;
+        if (handle == IntPtr.Zero || WindowPlacementNative.TryGetBounds(handle) is not { } bounds)
+        {
+            return;
+        }
+
+        PopupWindowNative.Point? wanted = _position ?? CenterOnActiveMonitor(bounds);
+        if (wanted is null || KeepOnScreen(wanted.Value, bounds) is not { } target)
+        {
+            return;
+        }
+
+        _isPlacing = true;
+        try
+        {
+            PopupWindowNative.MoveTo(handle, target.X, target.Y);
+        }
+        finally
+        {
+            _isPlacing = false;
+        }
+
+        _position = target;
+    }
+
+    // The window height adapts to its content and is unknown until the first layout
+    // pass — an empty window frame would end up in the centre. So we ask for the
+    // layout to be computed right away: by that moment the window is not shown yet,
+    // so it will not flash in its former place
+    private void OnSourceInitialized(object? sender, EventArgs e)
+    {
+        if (sender is not Window window)
+        {
+            return;
+        }
+
+        window.SourceInitialized -= OnSourceInitialized;
+        window.UpdateLayout();
+        Apply(window);
+    }
+
+    private void OnLocationChanged(object? sender, EventArgs e)
+    {
+        if (_isPlacing || sender is not Window { WindowState: WindowState.Normal } window)
+        {
+            return;
+        }
+
+        IntPtr handle = new WindowInteropHelper(window).Handle;
+        if (handle != IntPtr.Zero && WindowPlacementNative.TryGetBounds(handle) is { } bounds)
+        {
+            _position = new PopupWindowNative.Point { X = bounds.Left, Y = bounds.Top };
+        }
+    }
+
+    private static PopupWindowNative.Point? CenterOnActiveMonitor(PopupWindowNative.Rect bounds)
+    {
+        (PopupWindowNative.Rect work, _) = PopupWindowNative.GetActiveMonitorWorkArea();
+        return IsEmpty(work) ? null : Center(bounds, work);
+    }
+
+    /// <summary>
+    /// The point at which a window with the given bounds ends up in the centre of the work area.
+    /// </summary>
+    internal static PopupWindowNative.Point Center(
+        PopupWindowNative.Rect bounds, PopupWindowNative.Rect work) => new()
+        {
+            X = work.Left + (((work.Right - work.Left) - Width(bounds)) / 2),
+            Y = work.Top + (((work.Bottom - work.Top) - Height(bounds)) / 2),
+        };
+
+    /// <summary>
+    /// Pulls the window into the work area of the nearest monitor.
+    /// </summary>
+    /// <remarks>
+    /// Needed in two cases. The monitor the user put the window on may be disconnected
+    /// during the session — returning the window to its place would then leave the
+    /// user without a window, so the remembered position is a wish here rather than an
+    /// order. And the window height equals the height of its content and may exceed
+    /// the work area on a short monitor — then the title bar of a window placed in the
+    /// centre would go past the top edge.
+    /// </remarks>
+    private static PopupWindowNative.Point? KeepOnScreen(
+        PopupWindowNative.Point position, PopupWindowNative.Rect bounds)
+    {
+        int width = Width(bounds);
+        int height = Height(bounds);
+
+        var wanted = new PopupWindowNative.Rect
+        {
+            Left = position.X,
+            Top = position.Y,
+            Right = position.X + width,
+            Bottom = position.Y + height,
+        };
+
+        if (WindowPlacementNative.TryGetWorkAreaNear(wanted) is not { } work || IsEmpty(work))
+        {
+            return null;
+        }
+
+        return Clamp(position, bounds, work);
+    }
+
+    /// <summary>
+    /// Pulls the point so that a window with the given bounds fits into the work area
+    /// entirely. A window taller than the work area gets its top edge: the title bar
+    /// is needed more than the lower part of the window.
+    /// </summary>
+    internal static PopupWindowNative.Point Clamp(
+        PopupWindowNative.Point position,
+        PopupWindowNative.Rect bounds,
+        PopupWindowNative.Rect work)
+    {
+        int width = Width(bounds);
+        int height = Height(bounds);
+
+        return new PopupWindowNative.Point
+        {
+            X = Math.Clamp(position.X, work.Left, Math.Max(work.Left, work.Right - width)),
+            Y = Math.Clamp(position.Y, work.Top, Math.Max(work.Top, work.Bottom - height)),
+        };
+    }
+
+    private static int Width(PopupWindowNative.Rect rect) => rect.Right - rect.Left;
+
+    private static int Height(PopupWindowNative.Rect rect) => rect.Bottom - rect.Top;
+
+    internal static bool IsEmpty(PopupWindowNative.Rect rect) =>
+        rect.Right <= rect.Left || rect.Bottom <= rect.Top;
+}