Support quick switch window position

Jack251970 · Jack251970 · commit b72077bd3370 · 2025-04-20T11:47:08.000+08:00
diff --git a/Flow.Launcher.Infrastructure/QuickSwitch/QuickSwitch.cs b/Flow.Launcher.Infrastructure/QuickSwitch/QuickSwitch.cs
@@ -28,6 +28,8 @@ public static class QuickSwitch
 
         public static Action HideQuickSwitchWindow { get; set; } = null;
 
+        public static QuickSwitchWindowPositions QuickSwitchWindowPosition { get; private set; }
+
         #endregion
 
         #region Private Fields
@@ -62,10 +64,10 @@ public static class QuickSwitch
         // Note: Here we do not start & stop the timer beacause when there are many dialog windows
         // Unhooking and hooking will take too much time which can make window position weird
         // So we start & stop the timer when we find a file dialog window
-        /*private static HWINEVENTHOOK _moveSizeHook = HWINEVENTHOOK.Null;
+        /*private static HWINEVENTHOOK _moveSizeHook = HWINEVENTHOOK.Null;*/
 
-        private static HWND _hookedDialogWindowHandle = HWND.Null;
-        private static readonly object _hookedDialogWindowHandleLock = new();*/
+        private static HWND _currentDialogWindowHandle = HWND.Null;
+        private static readonly object _currentDialogWindowHandleLock = new();
 
         private static bool _initialized = false;
         private static bool _enabled = false;
@@ -85,6 +87,9 @@ public static void InitializeQuickSwitch()
             _dragMoveTimer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(10) };
             _dragMoveTimer.Tick += (s, e) => InvokeUpdateQuickSwitchWindow();
 
+            // Initialize quick switch window position
+            QuickSwitchWindowPosition = _settings.QuickSwitchWindowPosition;
+
             _initialized = true;
         }
 
@@ -240,18 +245,35 @@ private static unsafe void InvokeShowQuickSwitchWindow()
             // Show quick switch window
             if (_settings.ShowQuickSwitchWindow)
             {
+                lock (_currentDialogWindowHandleLock)
+                {
+                    var currentDialogWindowChanged = _currentDialogWindowHandle == HWND.Null ||
+                        _currentDialogWindowHandle != _dialogWindowHandle;
+
+                    if (currentDialogWindowChanged)
+                    {
+                        // Save quick switch window position for one file dialog
+                        QuickSwitchWindowPosition = _settings.QuickSwitchWindowPosition;
+                    }
+
+                    _currentDialogWindowHandle = _dialogWindowHandle;
+                }
+
                 ShowQuickSwitchWindow?.Invoke(_dialogWindowHandle.Value);
-                _dragMoveTimer?.Start();
+                if (QuickSwitchWindowPosition == QuickSwitchWindowPositions.UnderDialog)
+                {
+                    _dragMoveTimer?.Start();
+                }
 
                 // Note: Here we do not start & stop the timer beacause when there are many dialog windows
                 // Unhooking and hooking will take too much time which can make window position weird
                 // So we start & stop the timer when we find a file dialog window
-                /*lock (_hookedDialogWindowHandleLock)
+                /*lock (_currentDialogWindowHandleLock)
                 {
-                    var needHook = _hookedDialogWindowHandle == HWND.Null ||
-                        _hookedDialogWindowHandle != _dialogWindowHandle;
+                    var currentDialogWindowChanged = _currentDialogWindowHandle == HWND.Null ||
+                        _currentDialogWindowHandle != _dialogWindowHandle;
 
-                    if (needHook)
+                    if (currentDialogWindowChanged)
                     {
                         if (!_moveSizeHook.IsNull)
                         {
@@ -271,8 +293,6 @@ private static unsafe void InvokeShowQuickSwitchWindow()
                             threadId,
                             PInvoke.WINEVENT_OUTOFCONTEXT);
                     }
-
-                    _hookedDialogWindowHandle = _dialogWindowHandle;
                 }*/
             }
         }
@@ -289,19 +309,19 @@ private static void InvokeResetQuickSwitchWindow()
             ResetQuickSwitchWindow?.Invoke();
             _dragMoveTimer?.Stop();
 
-            // Note: Here we do not start & stop the timer beacause when there are many dialog windows
-            // Unhooking and hooking will take too much time which can make window position weird
-            // So we start & stop the timer when we find a file dialog window
-            /*lock (_hookedDialogWindowHandleLock)
+            lock (_currentDialogWindowHandleLock)
             {
-                if (!_moveSizeHook.IsNull)
+                // Note: Here we do not start & stop the timer beacause when there are many dialog windows
+                // Unhooking and hooking will take too much time which can make window position weird
+                // So we start & stop the timer when we find a file dialog window
+                /*if (!_moveSizeHook.IsNull)
                 {
                     PInvoke.UnhookWinEvent(_moveSizeHook);
                     _moveSizeHook = HWINEVENTHOOK.Null;
-                }
+                }*/
 
-                _hookedDialogWindowHandle = HWND.Null;
-            }*/
+                _currentDialogWindowHandle = HWND.Null;
+            }
         }
 
         private static void InvokeHideQuickSwitchWindow()
@@ -375,7 +395,6 @@ uint dwmsEventTime
             else if (hwnd == _mainWindowHandle)
             {
                 // Nothing to do
-                Log.Debug(ClassName, $"Quick Switch Window: {hwnd}");
             }
             else
             {
@@ -730,6 +749,9 @@ public static void Dispose()
                 PInvoke.UnhookWinEvent(_locationChangeHook);
                 _locationChangeHook = HWINEVENTHOOK.Null;
             }
+            // Note: Here we do not start & stop the timer beacause when there are many dialog windows
+            // Unhooking and hooking will take too much time which can make window position weird
+            // So we start & stop the timer when we find a file dialog window
             /*if (!_moveSizeHook.IsNull)
             {
                 PInvoke.UnhookWinEvent(_moveSizeHook);
diff --git a/Flow.Launcher/MainWindow.xaml.cs b/Flow.Launcher/MainWindow.xaml.cs
@@ -196,7 +196,7 @@ private async void OnLoaded(object sender, RoutedEventArgs e)
                                 if (_viewModel.MainWindowVisibilityStatus)
                                 {
                                     // Play sound effect before activing the window
-                                    if (_settings.UseSound && !_viewModel.IsQuickSwitch)
+                                    if (_settings.UseSound && !_viewModel.IsQuickSwitchWindowUnderDialog())
                                     {
                                         SoundPlay();
                                     }
@@ -219,7 +219,7 @@ private async void OnLoaded(object sender, RoutedEventArgs e)
                                     QueryTextBox.Focus();
 
                                     // Play window animation
-                                    if (_settings.UseAnimation && !_viewModel.IsQuickSwitch)
+                                    if (_settings.UseAnimation && !_viewModel.IsQuickSwitchWindowUnderDialog())
                                     {
                                         WindowAnimation();
                                     }
@@ -326,7 +326,7 @@ private void OnClosed(object sender, EventArgs e)
 
         private void OnLocationChanged(object sender, EventArgs e)
         {
-            if (_viewModel.IsQuickSwitch)
+            if (_viewModel.IsQuickSwitchWindowUnderDialog())
             {
                 return;
             }
@@ -340,7 +340,7 @@ private void OnLocationChanged(object sender, EventArgs e)
 
         private async void OnDeactivated(object sender, EventArgs e)
         {
-            if (_viewModel.IsQuickSwitch)
+            if (_viewModel.IsQuickSwitchWindowUnderDialog())
             {
                 return;
             }
@@ -483,7 +483,7 @@ private async void OnContextMenusForSettingsClick(object sender, RoutedEventArgs
 
         private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
         {
-            if (_viewModel.IsQuickSwitch)
+            if (_viewModel.IsQuickSwitchWindowUnderDialog())
             {
                 return IntPtr.Zero;
             }
@@ -669,7 +669,7 @@ private void UpdateNotifyIconText()
 
         public void UpdatePosition()
         {
-            if (_viewModel.IsQuickSwitch)
+            if (_viewModel.IsQuickSwitchWindowUnderDialog())
             {
                 UpdateQuickSwitchPosition();
             }
@@ -1170,8 +1170,8 @@ private void InitializeQuickSwitch()
 
         private void UpdateQuickSwitchPosition()
         {
-            if (_viewModel.DialogWindowHandle == nint.Zero ||
-                !_viewModel.MainWindowVisibilityStatus) return;
+            if (_viewModel.DialogWindowHandle == nint.Zero || !_viewModel.MainWindowVisibilityStatus) return;
+            if (!_viewModel.IsQuickSwitchWindowUnderDialog()) return;
 
             // Get dialog window rect
             var result = Win32Helper.GetWindowRect(_viewModel.DialogWindowHandle, out var window);
diff --git a/Flow.Launcher/ViewModel/MainViewModel.cs b/Flow.Launcher/ViewModel/MainViewModel.cs
@@ -1593,32 +1593,39 @@ public bool ShouldIgnoreHotkeys()
 
         #region Quick Switch
 
-        public bool IsQuickSwitch { get; private set; } = false;
         public nint DialogWindowHandle { get; private set; } = nint.Zero;
-        
+
+        private bool IsQuickSwitch { get; set; } = false;
+
+        private static QuickSwitchWindowPositions QuickSwitchWindowPosition => QuickSwitch.QuickSwitchWindowPosition;
+
         private bool PreviousMainWindowVisibilityStatus { get; set; }
-        private bool ResetWindowOnNextShow { get; set; } = false;
 
         public void InitializeVisibilityStatus(bool visibilityStatus)
         {
             PreviousMainWindowVisibilityStatus = visibilityStatus;
         }
 
+        public bool IsQuickSwitchWindowUnderDialog()
+        {
+            return IsQuickSwitch && QuickSwitchWindowPosition == QuickSwitchWindowPositions.UnderDialog;
+        }
+
 #pragma warning disable VSTHRD100 // Avoid async void methods
 
         public async void SetupQuickSwitch(nint handle)
         {
             if (handle == nint.Zero) return;
 
             // Only set flag & reset window once for one file dialog
-            var needReset = false;
+            var dialogWindowHandleChanged = false;
             if (DialogWindowHandle != handle)
             {
                 PreviousMainWindowVisibilityStatus = MainWindowVisibilityStatus;
                 DialogWindowHandle = handle;
                 IsQuickSwitch = true;
 
-                needReset = true;
+                dialogWindowHandleChanged = true;
 
                 // Wait for a while to make sure the dialog is shown
                 // If don't give a time, Positioning will be weird
@@ -1630,27 +1637,34 @@ public async void SetupQuickSwitch(nint handle)
 
             if (MainWindowVisibilityStatus)
             {
-                // Only update the position
-                if (PreviousMainWindowVisibilityStatus)
+                if (dialogWindowHandleChanged)
                 {
+                    // Only update the position
                     Application.Current?.Dispatcher.Invoke(() =>
                     {
                         (Application.Current?.MainWindow as MainWindow).UpdatePosition();
                     });
 
-                    if (needReset)
-                    {
-                        _ = ResetWindowAsync();
-                    }
+                    _ = ResetWindowAsync();
                 }
             }
             else
             {
-                Show();
+                if (QuickSwitchWindowPosition == QuickSwitchWindowPositions.UnderDialog)
+                {
+                    Show();
 
-                if (needReset)
+                    if (dialogWindowHandleChanged)
+                    {
+                        _ = ResetWindowAsync();
+                    }
+                }
+                else
                 {
-                    _ = ResetWindowAsync();
+                    if (dialogWindowHandleChanged)
+                    {
+                        _ = ResetWindowAsync();
+                    }
                 }
             }
         }
@@ -1692,7 +1706,7 @@ public async void ResetQuickSwitch()
                 }
                 else
                 {
-                    ResetWindowOnNextShow = true;
+                    _ = ResetWindowAsync();
                 }
             }
         }
@@ -1703,9 +1717,12 @@ public void HideQuickSwitch()
         {
             if (DialogWindowHandle != nint.Zero)
             {
-                if (MainWindowVisibilityStatus)
+                if (QuickSwitchWindowPosition == QuickSwitchWindowPositions.UnderDialog)
                 {
-                    Hide();
+                    if (MainWindowVisibilityStatus)
+                    {
+                        Hide();
+                    }
                 }
             }
         }
@@ -1773,12 +1790,6 @@ public void Show()
             {
                 Win32Helper.SwitchToEnglishKeyboardLayout(true);
             }
-
-            if (ResetWindowOnNextShow)
-            {
-                ResetWindowOnNextShow = false;
-                _ = ResetWindowAsync();
-            }
         }
 
         public async void Hide(bool reset = true)

Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ private async void OnLoaded(object sender, RoutedEventArgs e)`
`196`	`196`	`if (_viewModel.MainWindowVisibilityStatus)`
`197`	`197`	`{`
`198`	`198`	`// Play sound effect before activing the window`
`199`		`- if (_settings.UseSound && !_viewModel.IsQuickSwitch)`
	`199`	`+ if (_settings.UseSound && !_viewModel.IsQuickSwitchWindowUnderDialog())`
`200`	`200`	`{`
`201`	`201`	`SoundPlay();`
`202`	`202`	`}`
`@@ -219,7 +219,7 @@ private async void OnLoaded(object sender, RoutedEventArgs e)`
`219`	`219`	`QueryTextBox.Focus();`
`220`	`220`
`221`	`221`	`// Play window animation`
`222`		`- if (_settings.UseAnimation && !_viewModel.IsQuickSwitch)`
	`222`	`+ if (_settings.UseAnimation && !_viewModel.IsQuickSwitchWindowUnderDialog())`
`223`	`223`	`{`
`224`	`224`	`WindowAnimation();`
`225`	`225`	`}`
`@@ -326,7 +326,7 @@ private void OnClosed(object sender, EventArgs e)`
`326`	`326`
`327`	`327`	`private void OnLocationChanged(object sender, EventArgs e)`
`328`	`328`	`{`
`329`		`- if (_viewModel.IsQuickSwitch)`
	`329`	`+ if (_viewModel.IsQuickSwitchWindowUnderDialog())`
`330`	`330`	`{`
`331`	`331`	`return;`
`332`	`332`	`}`
`@@ -340,7 +340,7 @@ private void OnLocationChanged(object sender, EventArgs e)`
`340`	`340`
`341`	`341`	`private async void OnDeactivated(object sender, EventArgs e)`
`342`	`342`	`{`
`343`		`- if (_viewModel.IsQuickSwitch)`
	`343`	`+ if (_viewModel.IsQuickSwitchWindowUnderDialog())`
`344`	`344`	`{`
`345`	`345`	`return;`
`346`	`346`	`}`
`@@ -483,7 +483,7 @@ private async void OnContextMenusForSettingsClick(object sender, RoutedEventArgs`
`483`	`483`
`484`	`484`	`private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)`
`485`	`485`	`{`
`486`		`- if (_viewModel.IsQuickSwitch)`
	`486`	`+ if (_viewModel.IsQuickSwitchWindowUnderDialog())`
`487`	`487`	`{`
`488`	`488`	`return IntPtr.Zero;`
`489`	`489`	`}`
`@@ -669,7 +669,7 @@ private void UpdateNotifyIconText()`
`669`	`669`
`670`	`670`	`public void UpdatePosition()`
`671`	`671`	`{`
`672`		`- if (_viewModel.IsQuickSwitch)`
	`672`	`+ if (_viewModel.IsQuickSwitchWindowUnderDialog())`
`673`	`673`	`{`
`674`	`674`	`UpdateQuickSwitchPosition();`
`675`	`675`	`}`
`@@ -1170,8 +1170,8 @@ private void InitializeQuickSwitch()`
`1170`	`1170`
`1171`	`1171`	`private void UpdateQuickSwitchPosition()`
`1172`	`1172`	`{`
`1173`		`- if (_viewModel.DialogWindowHandle == nint.Zero \|\|`
`1174`		`- !_viewModel.MainWindowVisibilityStatus) return;`
	`1173`	`+ if (_viewModel.DialogWindowHandle == nint.Zero \|\| !_viewModel.MainWindowVisibilityStatus) return;`
	`1174`	`+ if (!_viewModel.IsQuickSwitchWindowUnderDialog()) return;`
`1175`	`1175`
`1176`	`1176`	`// Get dialog window rect`
`1177`	`1177`	`var result = Win32Helper.GetWindowRect(_viewModel.DialogWindowHandle, out var window);`
Original file line number	Diff line number	Diff line change
`@@ -1593,32 +1593,39 @@ public bool ShouldIgnoreHotkeys()`
`1593`	`1593`
`1594`	`1594`	`#region Quick Switch`
`1595`	`1595`
`1596`		`- public bool IsQuickSwitch { get; private set; } = false;`
`1597`	`1596`	`public nint DialogWindowHandle { get; private set; } = nint.Zero;`
`1598`		`-`
	`1597`	`+`
	`1598`	`+ private bool IsQuickSwitch { get; set; } = false;`
	`1599`	`+`
	`1600`	`+ private static QuickSwitchWindowPositions QuickSwitchWindowPosition => QuickSwitch.QuickSwitchWindowPosition;`
	`1601`	`+`
`1599`	`1602`	`private bool PreviousMainWindowVisibilityStatus { get; set; }`
`1600`		`- private bool ResetWindowOnNextShow { get; set; } = false;`
`1601`	`1603`
`1602`	`1604`	`public void InitializeVisibilityStatus(bool visibilityStatus)`
`1603`	`1605`	`{`
`1604`	`1606`	`PreviousMainWindowVisibilityStatus = visibilityStatus;`
`1605`	`1607`	`}`
`1606`	`1608`
	`1609`	`+ public bool IsQuickSwitchWindowUnderDialog()`
	`1610`	`+ {`
	`1611`	`+ return IsQuickSwitch && QuickSwitchWindowPosition == QuickSwitchWindowPositions.UnderDialog;`
	`1612`	`+ }`
	`1613`	`+`
`1607`	`1614`	`#pragma warning disable VSTHRD100 // Avoid async void methods`
`1608`	`1615`
`1609`	`1616`	`public async void SetupQuickSwitch(nint handle)`
`1610`	`1617`	`{`
`1611`	`1618`	`if (handle == nint.Zero) return;`
`1612`	`1619`
`1613`	`1620`	`// Only set flag & reset window once for one file dialog`
`1614`		`- var needReset = false;`
	`1621`	`+ var dialogWindowHandleChanged = false;`
`1615`	`1622`	`if (DialogWindowHandle != handle)`
`1616`	`1623`	`{`
`1617`	`1624`	`PreviousMainWindowVisibilityStatus = MainWindowVisibilityStatus;`
`1618`	`1625`	`DialogWindowHandle = handle;`
`1619`	`1626`	`IsQuickSwitch = true;`
`1620`	`1627`
`1621`		`- needReset = true;`
	`1628`	`+ dialogWindowHandleChanged = true;`
`1622`	`1629`
`1623`	`1630`	`// Wait for a while to make sure the dialog is shown`
`1624`	`1631`	`// If don't give a time, Positioning will be weird`
`@@ -1630,27 +1637,34 @@ public async void SetupQuickSwitch(nint handle)`
`1630`	`1637`
`1631`	`1638`	`if (MainWindowVisibilityStatus)`
`1632`	`1639`	`{`
`1633`		`- // Only update the position`
`1634`		`- if (PreviousMainWindowVisibilityStatus)`
	`1640`	`+ if (dialogWindowHandleChanged)`
`1635`	`1641`	`{`
	`1642`	`+ // Only update the position`
`1636`	`1643`	`Application.Current?.Dispatcher.Invoke(() =>`
`1637`	`1644`	`{`
`1638`	`1645`	`(Application.Current?.MainWindow as MainWindow).UpdatePosition();`
`1639`	`1646`	`});`
`1640`	`1647`
`1641`		`- if (needReset)`
`1642`		`- {`
`1643`		`- _ = ResetWindowAsync();`
`1644`		`- }`
	`1648`	`+ _ = ResetWindowAsync();`
`1645`	`1649`	`}`
`1646`	`1650`	`}`
`1647`	`1651`	`else`
`1648`	`1652`	`{`
`1649`		`- Show();`
	`1653`	`+ if (QuickSwitchWindowPosition == QuickSwitchWindowPositions.UnderDialog)`
	`1654`	`+ {`
	`1655`	`+ Show();`
`1650`	`1656`
`1651`		`- if (needReset)`
	`1657`	`+ if (dialogWindowHandleChanged)`
	`1658`	`+ {`
	`1659`	`+ _ = ResetWindowAsync();`
	`1660`	`+ }`
	`1661`	`+ }`
	`1662`	`+ else`
`1652`	`1663`	`{`
`1653`		`- _ = ResetWindowAsync();`
	`1664`	`+ if (dialogWindowHandleChanged)`
	`1665`	`+ {`
	`1666`	`+ _ = ResetWindowAsync();`
	`1667`	`+ }`
`1654`	`1668`	`}`
`1655`	`1669`	`}`
`1656`	`1670`	`}`
`@@ -1692,7 +1706,7 @@ public async void ResetQuickSwitch()`
`1692`	`1706`	`}`
`1693`	`1707`	`else`
`1694`	`1708`	`{`
`1695`		`- ResetWindowOnNextShow = true;`
	`1709`	`+ _ = ResetWindowAsync();`
`1696`	`1710`	`}`
`1697`	`1711`	`}`
`1698`	`1712`	`}`
`@@ -1703,9 +1717,12 @@ public void HideQuickSwitch()`
`1703`	`1717`	`{`
`1704`	`1718`	`if (DialogWindowHandle != nint.Zero)`
`1705`	`1719`	`{`
`1706`		`- if (MainWindowVisibilityStatus)`
	`1720`	`+ if (QuickSwitchWindowPosition == QuickSwitchWindowPositions.UnderDialog)`
`1707`	`1721`	`{`
`1708`		`- Hide();`
	`1722`	`+ if (MainWindowVisibilityStatus)`
	`1723`	`+ {`
	`1724`	`+ Hide();`
	`1725`	`+ }`
`1709`	`1726`	`}`
`1710`	`1727`	`}`
`1711`	`1728`	`}`
`@@ -1773,12 +1790,6 @@ public void Show()`
`1773`	`1790`	`{`
`1774`	`1791`	`Win32Helper.SwitchToEnglishKeyboardLayout(true);`
`1775`	`1792`	`}`
`1776`		`-`
`1777`		`- if (ResetWindowOnNextShow)`
`1778`		`- {`
`1779`		`- ResetWindowOnNextShow = false;`
`1780`		`- _ = ResetWindowAsync();`
`1781`		`- }`
`1782`	`1793`	`}`
`1783`	`1794`
`1784`	`1795`	`public async void Hide(bool reset = true)`