Merge PR #15: Add hotkey support for Windows Snap Assist & PowerToys FancyZones

- WindowMonitor detects maximize via keyboard shortcuts (Win+Up, Snap, FancyZones)
- Deferred maximize with MoveSizeEnd event + 200ms fallback timer
- All pending-maximize state serialized on UI thread (concurrency-safe)
- FullScreenManager: untrack after successful restore, ShowWindow(SW_SHOWNORMAL)
- Hot-path Trace logging trimmed for production performance

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: shanselman

src/MaximizeToVirtualDesktop/FullScreenManager.cs

@@ -218,8 +218,7 @@ public void Restore(IntPtr hwnd)
 
         Trace.WriteLine($"FullScreenManager: Restoring window {hwnd} from temp desktop {entry.TempDesktopId}");
 
-        // Untrack this window
-        _tracker.Untrack(hwnd);
+        // Untrack will be performed after successful restore
 
         var origDesktop = _vds.FindDesktop(entry.OriginalDesktopId);
         try
@@ -229,6 +228,8 @@ public void Restore(IntPtr hwnd)
             {
                 var placement = entry.OriginalPlacement;
                 NativeMethods.SetWindowPlacement(hwnd, ref placement);
+                // Ensure the window is shown in its normal (not maximized) state
+                NativeMethods.ShowWindow(hwnd, (int)NativeMethods.SW_SHOWNORMAL);
             }
 
             // Move window back to original desktop
@@ -258,6 +259,8 @@ public void Restore(IntPtr hwnd)
             _vds.RemoveDesktop(entry.TempDesktop);
             Marshal.ReleaseComObject(entry.TempDesktop);
         }
+      
+        _tracker.Untrack(hwnd);
 
         // Set focus on the restored window
         if (NativeMethods.IsWindow(hwnd))

src/MaximizeToVirtualDesktop/SettingsDialog.cs

@@ -63,15 +63,15 @@ public SettingsDialog(AppSettings settings)
         y += grpPin.Height + 12;
 
         // Behavior group
-        var grpBehavior = new GroupBox { Text = "Behavior", Location = new Point(margin, y), Size = new Size(grpW, 80) };
+        var grpBehavior = new GroupBox { Text = "Behavior", Location = new Point(margin, y), Size = new Size(grpW, 100) };
         Controls.Add(grpBehavior);
+        // Existing checkbox for InvertShiftClick
         _chkInvertShiftClick = new CheckBox
         {
-            Text = "Always maximize to virtual desktop on click\r\n" +
-                   "(Shift+Click performs a normal maximize instead)",
+            Text = "Shift+Click performs a normal maximize instead",
             AutoSize = true,
             Checked = settings.InvertShiftClick,
-            Location = new Point(10, 28),
+            Location = new Point(10, 48),
         };
         grpBehavior.Controls.Add(_chkInvertShiftClick);
         y += grpBehavior.Height + 12;

src/MaximizeToVirtualDesktop/TrayApplication.cs

@@ -48,7 +48,7 @@ public TrayApplication()
         _vds = new VirtualDesktopService();
         _tracker = new FullScreenTracker();
         _manager = new FullScreenManager(_vds, _tracker);
-        _monitor = new WindowMonitor(_manager, _tracker, this);
+        _monitor = new WindowMonitor(_manager, _tracker, this, _settings);
         _mouseHook = new MaximizeButtonHook(_manager, this, _settings);
 
         // System tray icon

src/MaximizeToVirtualDesktop/WindowMonitor.cs

@@ -1,4 +1,6 @@
 using System.Diagnostics;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using MaximizeToVirtualDesktop.Interop;
 
 namespace MaximizeToVirtualDesktop;
@@ -12,23 +14,30 @@ internal sealed class WindowMonitor : IDisposable
     private readonly FullScreenManager _manager;
     private readonly FullScreenTracker _tracker;
     private readonly Control _syncControl;
-
+    private readonly AppSettings _settings;
     private IntPtr _locationChangeHook;
     private IntPtr _destroyHook;
     private bool _disposed;
 
     // Must be stored as fields to prevent GC collection of the delegate
     private readonly NativeMethods.WinEventProc _locationChangeProc;
     private readonly NativeMethods.WinEventProc _destroyProc;
+    private readonly NativeMethods.WinEventProc _moveSizeEndProc;
+    private IntPtr _moveSizeEndHook;
+    // Track windows that have been maximized but need to wait for resize end
+    // Access to this set must happen only on the UI thread.
+    private readonly HashSet<IntPtr> _pendingMaximize = new();
 
-    public WindowMonitor(FullScreenManager manager, FullScreenTracker tracker, Control syncControl)
+    public WindowMonitor(FullScreenManager manager, FullScreenTracker tracker, Control syncControl, AppSettings settings)
     {
         _manager = manager;
         _tracker = tracker;
         _syncControl = syncControl;
+        _settings = settings;
 
         _locationChangeProc = OnLocationChange;
         _destroyProc = OnDestroy;
+        _moveSizeEndProc = OnMoveSizeEnd;
     }
 
     public void Start()
@@ -42,6 +51,13 @@ public void Start()
             IntPtr.Zero, _locationChangeProc,
             0, 0, NativeMethods.WINEVENT_OUTOFCONTEXT);
 
+        // EVENT_SYSTEM_MOVESIZEEND fires after a window finishes moving or resizing (including maximize via shortcuts)
+        _moveSizeEndHook = NativeMethods.SetWinEventHook(
+            NativeMethods.EVENT_SYSTEM_MOVESIZEEND,
+            NativeMethods.EVENT_SYSTEM_MOVESIZEEND,
+            IntPtr.Zero, _moveSizeEndProc,
+            0, 0, NativeMethods.WINEVENT_OUTOFCONTEXT);
+
         // EVENT_OBJECT_DESTROY fires when a window is closed
         _destroyHook = NativeMethods.SetWinEventHook(
             NativeMethods.EVENT_OBJECT_DESTROY,
@@ -64,16 +80,97 @@ private void OnLocationChange(IntPtr hWinEventHook, uint eventType, IntPtr hwnd,
     {
         // Only care about top-level window changes (OBJID_WINDOW)
         if (idObject != NativeMethods.OBJID_WINDOW || idChild != 0) return;
-        if (!_tracker.IsTracked(hwnd)) return;
 
-        // Check if window is still maximized
+        // If the window is already tracked, check if it is being restored (i.e., no longer maximized)
+        if (_tracker.IsTracked(hwnd))
+        {
+            var placement = NativeMethods.WINDOWPLACEMENT.Default;
+            if (NativeMethods.GetWindowPlacement(hwnd, ref placement))
+            {
+                if (placement.showCmd != NativeMethods.SW_MAXIMIZE)
+                {
+                    Trace.WriteLine($"WindowMonitor: Tracked window {hwnd} restored via location change.");
+                    MarshalToUiThread(() => _manager.Restore(hwnd));
+                    return;
+                }
+            }
+            // Still maximized; let MoveSizeEnd handle pending maximize.
+            return;
+        }
+
+        // Not tracked yet: check for a new maximize event (including via shortcut)
+        var newPlacement = NativeMethods.WINDOWPLACEMENT.Default;
+        if (!NativeMethods.GetWindowPlacement(hwnd, ref newPlacement)) return;
+        if (newPlacement.showCmd != NativeMethods.SW_MAXIMIZE) return;
+
+        bool shiftHeld = (NativeMethods.GetAsyncKeyState(NativeMethods.VK_SHIFT) & 0x8000) != 0;
+        bool triggerVirtualDesktop = _settings.InvertShiftClick ? !shiftHeld : shiftHeld;
+        if (triggerVirtualDesktop)
+        {
+            // Defer maximization until after the resize operation completes
+            MarshalToUiThread(() =>
+            {
+                if (_pendingMaximize.Add(hwnd))
+                {
+                    Trace.WriteLine($"WindowMonitor: Queued maximize for window {hwnd} after resize end.");
+                    // Schedule a fallback in case MoveSizeEnd does not fire (e.g., keyboard shortcut)
+                    _ = Task.Run(async () =>
+                    {
+                        await Task.Delay(200);
+                        // Marshal the check/remove back onto the UI thread
+                        MarshalToUiThread(() =>
+                        {
+                            if (_pendingMaximize.Contains(hwnd))
+                            {
+                                _pendingMaximize.Remove(hwnd);
+                                var placement = NativeMethods.WINDOWPLACEMENT.Default;
+                                bool isMaximized = NativeMethods.GetWindowPlacement(hwnd, ref placement) && placement.showCmd == NativeMethods.SW_MAXIMIZE;
+                                if (isMaximized)
+                                {
+                                    Trace.WriteLine($"WindowMonitor: Fallback processing for pending maximize window {hwnd}.");
+                                    _manager.MaximizeToDesktop(hwnd);
+                                }
+                                else
+                                {
+                                    Trace.WriteLine($"WindowMonitor: Fallback detected restore for pending window {hwnd}.");
+                                    _manager.Restore(hwnd);
+                                }
+                            }
+                        });
+                    });
+                }
+            });
+        }
+    }
+
+    private async void OnMoveSizeEnd(IntPtr hWinEventHook, uint eventType, IntPtr hwnd,
+        int idObject, int idChild, uint idEventThread, uint dwmsEventTime)
+    {
+        // Only care about top-level window changes (OBJID_WINDOW)
+        if (idObject != NativeMethods.OBJID_WINDOW || idChild != 0) return;
+
+        // If this window was pending maximize, handle it now
+        bool wasPending = false;
+        if (!_syncControl.IsDisposed && _syncControl.IsHandleCreated)
+        {
+            wasPending = (bool)_syncControl.Invoke(new Func<bool>(() => _pendingMaximize.Remove(hwnd)));
+        }
+        if (wasPending)
+        {
+            Trace.WriteLine($"WindowMonitor: MoveSizeEnd triggered for pending maximize window {hwnd}.");
+            MarshalToUiThread(() => _manager.MaximizeToDesktop(hwnd));
+            return;
+        }
+
+        // Handle only tracked windows that are being restored (not maximized)
+        if (!_tracker.IsTracked(hwnd)) return;
         var placement = NativeMethods.WINDOWPLACEMENT.Default;
         if (!NativeMethods.GetWindowPlacement(hwnd, ref placement)) return;
-
-        if (placement.showCmd != NativeMethods.SW_SHOWMAXIMIZED)
+        Trace.WriteLine($"WindowMonitor: MoveSizeEnd: tracked window {hwnd} showCmd={placement.showCmd}.");
+        if (placement.showCmd != NativeMethods.SW_MAXIMIZE)
         {
-            // Window was un-maximized — restore it
-            Trace.WriteLine($"WindowMonitor: Tracked window {hwnd} un-maximized, restoring.");
+            Trace.WriteLine($"WindowMonitor: Tracked window {hwnd} un-maximized via move/size, restoring.");
+            await Task.Delay(100);
             MarshalToUiThread(() => _manager.Restore(hwnd));
         }
     }
@@ -117,6 +214,11 @@ public void Dispose()
             NativeMethods.UnhookWinEvent(_destroyHook);
             _destroyHook = IntPtr.Zero;
         }
+        if (_moveSizeEndHook != IntPtr.Zero)
+        {
+            NativeMethods.UnhookWinEvent(_moveSizeEndHook);
+            _moveSizeEndHook = IntPtr.Zero;
+        }
 
         Trace.WriteLine("WindowMonitor: Disposed.");
     }