Improve code quality

Jack251970 · Jack251970 · commit acf3a279c83e · 2025-03-26T10:07:35.000+08:00
diff --git a/Flow.Launcher/MainWindow.xaml.cs b/Flow.Launcher/MainWindow.xaml.cs
@@ -296,7 +296,7 @@ private void OnKeyDown(object sender, KeyEventArgs e)
                     e.Handled = true;
                     break;
                 case Key.Right:
-                    if (_viewModel.SelectedIsFromQueryResults()
+                    if (_viewModel.QueryResultsSelected()
                         && QueryTextBox.CaretIndex == QueryTextBox.Text.Length
                         && !string.IsNullOrEmpty(QueryTextBox.Text))
                     {
@@ -306,7 +306,7 @@ private void OnKeyDown(object sender, KeyEventArgs e)
 
                     break;
                 case Key.Left:
-                    if (!_viewModel.SelectedIsFromQueryResults() && QueryTextBox.CaretIndex == 0)
+                    if (!_viewModel.QueryResultsSelected() && QueryTextBox.CaretIndex == 0)
                     {
                         _viewModel.EscCommand.Execute(null);
                         e.Handled = true;
@@ -316,7 +316,7 @@ private void OnKeyDown(object sender, KeyEventArgs e)
                 case Key.Back:
                     if (specialKeyState.CtrlPressed)
                     {
-                        if (_viewModel.SelectedIsFromQueryResults()
+                        if (_viewModel.QueryResultsSelected()
                             && QueryTextBox.Text.Length > 0
                             && QueryTextBox.CaretIndex == QueryTextBox.Text.Length)
                         {
diff --git a/Flow.Launcher/ViewModel/MainViewModel.cs b/Flow.Launcher/ViewModel/MainViewModel.cs
@@ -164,7 +164,7 @@ public MainViewModel()
                     case nameof(Results.SelectedItem):
                         _selectedItemFromQueryResults = true;
                         PreviewSelectedItem = Results.SelectedItem;
-                        UpdatePreview();
+                        _ = UpdatePreviewAsync();
                         break;
                 }
             };
@@ -176,7 +176,7 @@ public MainViewModel()
                     case nameof(History.SelectedItem):
                         _selectedItemFromQueryResults = false;
                         PreviewSelectedItem = History.SelectedItem;
-                        UpdatePreview();
+                        _ = UpdatePreviewAsync();
                         break;
                 }
             };
@@ -280,7 +280,7 @@ private async Task ReloadPluginDataAsync()
         [RelayCommand]
         private void LoadHistory()
         {
-            if (SelectedIsFromQueryResults())
+            if (QueryResultsSelected())
             {
                 SelectedResults = History;
                 History.SelectedIndex = _history.Items.Count - 1;
@@ -294,7 +294,7 @@ private void LoadHistory()
         [RelayCommand]
         public void ReQuery()
         {
-            if (SelectedIsFromQueryResults())
+            if (QueryResultsSelected())
             {
                 _ = QueryResultsAsync(isReQuery: true);
             }
@@ -335,7 +335,7 @@ public void ForwardHistory()
         [RelayCommand]
         private void LoadContextMenu()
         {
-            if (SelectedIsFromQueryResults())
+            if (QueryResultsSelected())
             {
                 // When switch to ContextMenu from QueryResults, but no item being chosen, should do nothing
                 // i.e. Shift+Enter/Ctrl+O right after Alt + Space should do nothing
@@ -365,7 +365,7 @@ private void Backspace(object index)
         private void AutocompleteQuery()
         {
             var result = SelectedResults.SelectedItem?.Result;
-            if (result != null && SelectedIsFromQueryResults()) // SelectedItem returns null if selection is empty.
+            if (result != null && QueryResultsSelected()) // SelectedItem returns null if selection is empty.
             {
                 var autoCompleteText = result.Title;
 
@@ -417,7 +417,7 @@ private async Task OpenResultAsync(string index)
             })
             .ConfigureAwait(false);
 
-            if (SelectedIsFromQueryResults())
+            if (QueryResultsSelected())
             {
                 _userSelectedRecord.Add(result);
                 // origin query is null when user select the context menu item directly of one item from query list
@@ -496,7 +496,7 @@ private void SelectPrevItem()
         {
             if (_history.Items.Count > 0
                 && QueryText == string.Empty
-                && SelectedIsFromQueryResults())
+                && QueryResultsSelected())
             {
                 lastHistoryIndex = 1;
                 ReverseHistory();
@@ -516,7 +516,7 @@ private void SelectNextItem()
         [RelayCommand]
         private void Esc()
         {
-            if (!SelectedIsFromQueryResults())
+            if (!QueryResultsSelected())
             {
                 SelectedResults = Results;
             }
@@ -528,7 +528,7 @@ private void Esc()
 
         public void BackToQueryResults()
         {
-            if (!SelectedIsFromQueryResults())
+            if (!QueryResultsSelected())
             {
                 SelectedResults = Results;
             }
@@ -662,11 +662,11 @@ private ResultsViewModel SelectedResults
             get => _selectedResults;
             set
             {
-                var isReturningFromQueryResults = SelectedIsFromQueryResults();
+                var isReturningFromQueryResults = QueryResultsSelected();
                 var isReturningFromContextMenu = ContextMenuSelected();
                 var isReturningFromHistory = HistorySelected();
                 _selectedResults = value;
-                if (SelectedIsFromQueryResults())
+                if (QueryResultsSelected())
                 {
                     Results.Visibility = Visibility.Visible;
                     ContextMenu.Visibility = Visibility.Collapsed;
@@ -871,9 +871,9 @@ public bool InternalPreviewVisible
         // This is not a reliable indicator of whether external preview is visible due to the
         // ability of manually closing/exiting the external preview program which, does not inform flow that
         // preview is no longer available.
-        public bool ExternalPreviewVisible { get; set; } = false;
+        public bool ExternalPreviewVisible { get; private set; }
 
-        private void ShowPreview()
+        private async Task ShowPreviewAsync()
         {
             var useExternalPreview = PluginManager.UseExternalPreview();
 
@@ -884,13 +884,15 @@ when CanExternalPreviewSelectedResult(out var path):
                     // Internal preview may still be on when user switches to external
                     if (InternalPreviewVisible)
                         HideInternalPreview();
-                    OpenExternalPreview(path);
+
+                    _ = OpenExternalPreviewAsync(path);
                     break;
 
                 case true
                     when !CanExternalPreviewSelectedResult(out var _):
                     if (ExternalPreviewVisible)
-                        CloseExternalPreview();
+                        await CloseExternalPreviewAsync();
+
                     ShowInternalPreview();
                     break;
 
@@ -903,7 +905,7 @@ when CanExternalPreviewSelectedResult(out var path):
         private void HidePreview()
         {
             if (PluginManager.UseExternalPreview())
-                CloseExternalPreview();
+                _ = CloseExternalPreviewAsync();
 
             if (InternalPreviewVisible)
                 HideInternalPreview();
@@ -918,25 +920,25 @@ private void TogglePreview()
             }
             else
             {
-                ShowPreview();
+                _ = ShowPreviewAsync();
             }
         }
 
-        private void OpenExternalPreview(string path, bool sendFailToast = true)
+        private async Task OpenExternalPreviewAsync(string path, bool sendFailToast = true)
         {
-            _ = PluginManager.OpenExternalPreviewAsync(path, sendFailToast).ConfigureAwait(false);
+            await PluginManager.OpenExternalPreviewAsync(path, sendFailToast).ConfigureAwait(false);
             ExternalPreviewVisible = true;
         }
 
-        private void CloseExternalPreview()
+        private async Task CloseExternalPreviewAsync()
         {
-            _ = PluginManager.CloseExternalPreviewAsync().ConfigureAwait(false);
+            await PluginManager.CloseExternalPreviewAsync().ConfigureAwait(false);
             ExternalPreviewVisible = false;
         }
 
-        private static void SwitchExternalPreview(string path, bool sendFailToast = true)
+        private static async Task SwitchExternalPreviewAsync(string path, bool sendFailToast = true)
         {
-            _ = PluginManager.SwitchExternalPreviewAsync(path,sendFailToast).ConfigureAwait(false);
+            await PluginManager.SwitchExternalPreviewAsync(path, sendFailToast).ConfigureAwait(false);
         }
 
         private void ShowInternalPreview()
@@ -956,45 +958,41 @@ public void ResetPreview()
             {
                 case true
                     when PluginManager.AllowAlwaysPreview() && CanExternalPreviewSelectedResult(out var path):
-                    OpenExternalPreview(path);
+                    _ = OpenExternalPreviewAsync(path);
                     break;
-
                 case true:
                     ShowInternalPreview();
                     break;
-
                 case false:
                     HidePreview();
                     break;
             }
         }
 
-        private void UpdatePreview()
+        private async Task UpdatePreviewAsync()
         {
             switch (PluginManager.UseExternalPreview())
             {
                 case true
                     when CanExternalPreviewSelectedResult(out var path):
                     if (ExternalPreviewVisible)
                     {
-                        SwitchExternalPreview(path, false);
+                        _ = SwitchExternalPreviewAsync(path, false);
                     }
                     else if (InternalPreviewVisible)
                     {
                         HideInternalPreview();
-                        OpenExternalPreview(path);
+                        _ = OpenExternalPreviewAsync(path);
                     }
                     break;
-
                 case true
                     when !CanExternalPreviewSelectedResult(out var _):
                     if (ExternalPreviewVisible)
                     {
-                        CloseExternalPreview();
+                        await CloseExternalPreviewAsync();
                         ShowInternalPreview();
                     }
                     break;
-
                 case false
                     when InternalPreviewVisible:
                     PreviewSelectedItem?.LoadPreviewImage();
@@ -1004,17 +1002,23 @@ when CanExternalPreviewSelectedResult(out var path):
 
         private bool CanExternalPreviewSelectedResult(out string path)
         {
-            path = PreviewSelectedItem == Results.SelectedItem ? Results.SelectedItem?.Result?.Preview.FilePath : string.Empty;
+            path = QueryResultsPreviewed() ? Results.SelectedItem?.Result?.Preview.FilePath : string.Empty;
             return !string.IsNullOrEmpty(path);
         }
+        
+        private bool QueryResultsPreviewed()
+        {
+            var previewed = PreviewSelectedItem == Results.SelectedItem;
+            return previewed;
+        }
 
         #endregion
 
         #region Query
 
         public void Query(bool isReQuery = false)
         {
-            if (SelectedIsFromQueryResults())
+            if (QueryResultsSelected())
             {
                 _ = QueryResultsAsync(isReQuery);
             }
@@ -1382,7 +1386,7 @@ private static Result ContextMenuPluginInfo(string id)
             return menu;
         }
 
-        internal bool SelectedIsFromQueryResults()
+        internal bool QueryResultsSelected()
         {
             var selected = SelectedResults == Results;
             return selected;
@@ -1447,10 +1451,10 @@ public async void Hide()
 
             if (ExternalPreviewVisible)
             {
-                CloseExternalPreview();
+                await CloseExternalPreviewAsync();
             }
 
-            if (!SelectedIsFromQueryResults())
+            if (!QueryResultsSelected())
             {
                 SelectedResults = Results;
             }
@@ -1460,10 +1464,7 @@ public async void Hide()
             {
                 ChangeQueryText(string.Empty);
                 await Task.Delay(1); // Wait for one frame to ensure UI reflects changes
-                Application.Current.Dispatcher.Invoke(() =>
-                {
-                    Application.Current.MainWindow.UpdateLayout(); // Force UI update
-                });
+                Application.Current.Dispatcher.Invoke(Application.Current.MainWindow.UpdateLayout); // Force UI update
             }
 
             switch (Settings.LastQueryMode)

Original file line number	Diff line number	Diff line change
`@@ -296,7 +296,7 @@ private void OnKeyDown(object sender, KeyEventArgs e)`
`296`	`296`	`e.Handled = true;`
`297`	`297`	`break;`
`298`	`298`	`case Key.Right:`
`299`		`- if (_viewModel.SelectedIsFromQueryResults()`
	`299`	`+ if (_viewModel.QueryResultsSelected()`
`300`	`300`	`&& QueryTextBox.CaretIndex == QueryTextBox.Text.Length`
`301`	`301`	`&& !string.IsNullOrEmpty(QueryTextBox.Text))`
`302`	`302`	`{`
`@@ -306,7 +306,7 @@ private void OnKeyDown(object sender, KeyEventArgs e)`
`306`	`306`
`307`	`307`	`break;`
`308`	`308`	`case Key.Left:`
`309`		`- if (!_viewModel.SelectedIsFromQueryResults() && QueryTextBox.CaretIndex == 0)`
	`309`	`+ if (!_viewModel.QueryResultsSelected() && QueryTextBox.CaretIndex == 0)`
`310`	`310`	`{`
`311`	`311`	`_viewModel.EscCommand.Execute(null);`
`312`	`312`	`e.Handled = true;`
`@@ -316,7 +316,7 @@ private void OnKeyDown(object sender, KeyEventArgs e)`
`316`	`316`	`case Key.Back:`
`317`	`317`	`if (specialKeyState.CtrlPressed)`
`318`	`318`	`{`
`319`		`- if (_viewModel.SelectedIsFromQueryResults()`
	`319`	`+ if (_viewModel.QueryResultsSelected()`
`320`	`320`	`&& QueryTextBox.Text.Length > 0`
`321`	`321`	`&& QueryTextBox.CaretIndex == QueryTextBox.Text.Length)`
`322`	`322`	`{`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ public MainViewModel()`
`164`	`164`	`case nameof(Results.SelectedItem):`
`165`	`165`	`_selectedItemFromQueryResults = true;`
`166`	`166`	`PreviewSelectedItem = Results.SelectedItem;`
`167`		`- UpdatePreview();`
	`167`	`+ _ = UpdatePreviewAsync();`
`168`	`168`	`break;`
`169`	`169`	`}`
`170`	`170`	`};`
`@@ -176,7 +176,7 @@ public MainViewModel()`
`176`	`176`	`case nameof(History.SelectedItem):`
`177`	`177`	`_selectedItemFromQueryResults = false;`
`178`	`178`	`PreviewSelectedItem = History.SelectedItem;`
`179`		`- UpdatePreview();`
	`179`	`+ _ = UpdatePreviewAsync();`
`180`	`180`	`break;`
`181`	`181`	`}`
`182`	`182`	`};`
`@@ -280,7 +280,7 @@ private async Task ReloadPluginDataAsync()`
`280`	`280`	`[RelayCommand]`
`281`	`281`	`private void LoadHistory()`
`282`	`282`	`{`
`283`		`- if (SelectedIsFromQueryResults())`
	`283`	`+ if (QueryResultsSelected())`
`284`	`284`	`{`
`285`	`285`	`SelectedResults = History;`
`286`	`286`	`History.SelectedIndex = _history.Items.Count - 1;`
`@@ -294,7 +294,7 @@ private void LoadHistory()`
`294`	`294`	`[RelayCommand]`
`295`	`295`	`public void ReQuery()`
`296`	`296`	`{`
`297`		`- if (SelectedIsFromQueryResults())`
	`297`	`+ if (QueryResultsSelected())`
`298`	`298`	`{`
`299`	`299`	`_ = QueryResultsAsync(isReQuery: true);`
`300`	`300`	`}`
`@@ -335,7 +335,7 @@ public void ForwardHistory()`
`335`	`335`	`[RelayCommand]`
`336`	`336`	`private void LoadContextMenu()`
`337`	`337`	`{`
`338`		`- if (SelectedIsFromQueryResults())`
	`338`	`+ if (QueryResultsSelected())`
`339`	`339`	`{`
`340`	`340`	`// When switch to ContextMenu from QueryResults, but no item being chosen, should do nothing`
`341`	`341`	`// i.e. Shift+Enter/Ctrl+O right after Alt + Space should do nothing`
`@@ -365,7 +365,7 @@ private void Backspace(object index)`
`365`	`365`	`private void AutocompleteQuery()`
`366`	`366`	`{`
`367`	`367`	`var result = SelectedResults.SelectedItem?.Result;`
`368`		`- if (result != null && SelectedIsFromQueryResults()) // SelectedItem returns null if selection is empty.`
	`368`	`+ if (result != null && QueryResultsSelected()) // SelectedItem returns null if selection is empty.`
`369`	`369`	`{`
`370`	`370`	`var autoCompleteText = result.Title;`
`371`	`371`
`@@ -417,7 +417,7 @@ private async Task OpenResultAsync(string index)`
`417`	`417`	`})`
`418`	`418`	`.ConfigureAwait(false);`
`419`	`419`
`420`		`- if (SelectedIsFromQueryResults())`
	`420`	`+ if (QueryResultsSelected())`
`421`	`421`	`{`
`422`	`422`	`_userSelectedRecord.Add(result);`
`423`	`423`	`// origin query is null when user select the context menu item directly of one item from query list`
`@@ -496,7 +496,7 @@ private void SelectPrevItem()`
`496`	`496`	`{`
`497`	`497`	`if (_history.Items.Count > 0`
`498`	`498`	`&& QueryText == string.Empty`
`499`		`- && SelectedIsFromQueryResults())`
	`499`	`+ && QueryResultsSelected())`
`500`	`500`	`{`
`501`	`501`	`lastHistoryIndex = 1;`
`502`	`502`	`ReverseHistory();`
`@@ -516,7 +516,7 @@ private void SelectNextItem()`
`516`	`516`	`[RelayCommand]`
`517`	`517`	`private void Esc()`
`518`	`518`	`{`
`519`		`- if (!SelectedIsFromQueryResults())`
	`519`	`+ if (!QueryResultsSelected())`
`520`	`520`	`{`
`521`	`521`	`SelectedResults = Results;`
`522`	`522`	`}`
`@@ -528,7 +528,7 @@ private void Esc()`
`528`	`528`
`529`	`529`	`public void BackToQueryResults()`
`530`	`530`	`{`
`531`		`- if (!SelectedIsFromQueryResults())`
	`531`	`+ if (!QueryResultsSelected())`
`532`	`532`	`{`
`533`	`533`	`SelectedResults = Results;`
`534`	`534`	`}`
`@@ -662,11 +662,11 @@ private ResultsViewModel SelectedResults`
`662`	`662`	`get => _selectedResults;`
`663`	`663`	`set`
`664`	`664`	`{`
`665`		`- var isReturningFromQueryResults = SelectedIsFromQueryResults();`
	`665`	`+ var isReturningFromQueryResults = QueryResultsSelected();`
`666`	`666`	`var isReturningFromContextMenu = ContextMenuSelected();`
`667`	`667`	`var isReturningFromHistory = HistorySelected();`
`668`	`668`	`_selectedResults = value;`
`669`		`- if (SelectedIsFromQueryResults())`
	`669`	`+ if (QueryResultsSelected())`
`670`	`670`	`{`
`671`	`671`	`Results.Visibility = Visibility.Visible;`
`672`	`672`	`ContextMenu.Visibility = Visibility.Collapsed;`
`@@ -871,9 +871,9 @@ public bool InternalPreviewVisible`
`871`	`871`	`// This is not a reliable indicator of whether external preview is visible due to the`
`872`	`872`	`// ability of manually closing/exiting the external preview program which, does not inform flow that`
`873`	`873`	`// preview is no longer available.`
`874`		`- public bool ExternalPreviewVisible { get; set; } = false;`
	`874`	`+ public bool ExternalPreviewVisible { get; private set; }`
`875`	`875`
`876`		`- private void ShowPreview()`
	`876`	`+ private async Task ShowPreviewAsync()`
`877`	`877`	`{`
`878`	`878`	`var useExternalPreview = PluginManager.UseExternalPreview();`
`879`	`879`
`@@ -884,13 +884,15 @@ when CanExternalPreviewSelectedResult(out var path):`
`884`	`884`	`// Internal preview may still be on when user switches to external`
`885`	`885`	`if (InternalPreviewVisible)`
`886`	`886`	`HideInternalPreview();`
`887`		`- OpenExternalPreview(path);`
	`887`	`+`
	`888`	`+ _ = OpenExternalPreviewAsync(path);`
`888`	`889`	`break;`
`889`	`890`
`890`	`891`	`case true`
`891`	`892`	`when !CanExternalPreviewSelectedResult(out var _):`
`892`	`893`	`if (ExternalPreviewVisible)`
`893`		`- CloseExternalPreview();`
	`894`	`+ await CloseExternalPreviewAsync();`
	`895`	`+`
`894`	`896`	`ShowInternalPreview();`
`895`	`897`	`break;`
`896`	`898`
`@@ -903,7 +905,7 @@ when CanExternalPreviewSelectedResult(out var path):`
`903`	`905`	`private void HidePreview()`
`904`	`906`	`{`
`905`	`907`	`if (PluginManager.UseExternalPreview())`
`906`		`- CloseExternalPreview();`
	`908`	`+ _ = CloseExternalPreviewAsync();`
`907`	`909`
`908`	`910`	`if (InternalPreviewVisible)`
`909`	`911`	`HideInternalPreview();`
`@@ -918,25 +920,25 @@ private void TogglePreview()`
`918`	`920`	`}`
`919`	`921`	`else`
`920`	`922`	`{`
`921`		`- ShowPreview();`
	`923`	`+ _ = ShowPreviewAsync();`
`922`	`924`	`}`
`923`	`925`	`}`
`924`	`926`
`925`		`- private void OpenExternalPreview(string path, bool sendFailToast = true)`
	`927`	`+ private async Task OpenExternalPreviewAsync(string path, bool sendFailToast = true)`
`926`	`928`	`{`
`927`		`- _ = PluginManager.OpenExternalPreviewAsync(path, sendFailToast).ConfigureAwait(false);`
	`929`	`+ await PluginManager.OpenExternalPreviewAsync(path, sendFailToast).ConfigureAwait(false);`
`928`	`930`	`ExternalPreviewVisible = true;`
`929`	`931`	`}`
`930`	`932`
`931`		`- private void CloseExternalPreview()`
	`933`	`+ private async Task CloseExternalPreviewAsync()`
`932`	`934`	`{`
`933`		`- _ = PluginManager.CloseExternalPreviewAsync().ConfigureAwait(false);`
	`935`	`+ await PluginManager.CloseExternalPreviewAsync().ConfigureAwait(false);`
`934`	`936`	`ExternalPreviewVisible = false;`
`935`	`937`	`}`
`936`	`938`
`937`		`- private static void SwitchExternalPreview(string path, bool sendFailToast = true)`
	`939`	`+ private static async Task SwitchExternalPreviewAsync(string path, bool sendFailToast = true)`
`938`	`940`	`{`
`939`		`- _ = PluginManager.SwitchExternalPreviewAsync(path,sendFailToast).ConfigureAwait(false);`
	`941`	`+ await PluginManager.SwitchExternalPreviewAsync(path, sendFailToast).ConfigureAwait(false);`
`940`	`942`	`}`
`941`	`943`
`942`	`944`	`private void ShowInternalPreview()`
`@@ -956,45 +958,41 @@ public void ResetPreview()`
`956`	`958`	`{`
`957`	`959`	`case true`
`958`	`960`	`when PluginManager.AllowAlwaysPreview() && CanExternalPreviewSelectedResult(out var path):`
`959`		`- OpenExternalPreview(path);`
	`961`	`+ _ = OpenExternalPreviewAsync(path);`
`960`	`962`	`break;`
`961`		`-`
`962`	`963`	`case true:`
`963`	`964`	`ShowInternalPreview();`
`964`	`965`	`break;`
`965`		`-`
`966`	`966`	`case false:`
`967`	`967`	`HidePreview();`
`968`	`968`	`break;`
`969`	`969`	`}`
`970`	`970`	`}`
`971`	`971`
`972`		`- private void UpdatePreview()`
	`972`	`+ private async Task UpdatePreviewAsync()`
`973`	`973`	`{`
`974`	`974`	`switch (PluginManager.UseExternalPreview())`
`975`	`975`	`{`
`976`	`976`	`case true`
`977`	`977`	`when CanExternalPreviewSelectedResult(out var path):`
`978`	`978`	`if (ExternalPreviewVisible)`
`979`	`979`	`{`
`980`		`- SwitchExternalPreview(path, false);`
	`980`	`+ _ = SwitchExternalPreviewAsync(path, false);`
`981`	`981`	`}`
`982`	`982`	`else if (InternalPreviewVisible)`
`983`	`983`	`{`
`984`	`984`	`HideInternalPreview();`
`985`		`- OpenExternalPreview(path);`
	`985`	`+ _ = OpenExternalPreviewAsync(path);`
`986`	`986`	`}`
`987`	`987`	`break;`
`988`		`-`
`989`	`988`	`case true`
`990`	`989`	`when !CanExternalPreviewSelectedResult(out var _):`
`991`	`990`	`if (ExternalPreviewVisible)`
`992`	`991`	`{`
`993`		`- CloseExternalPreview();`
	`992`	`+ await CloseExternalPreviewAsync();`
`994`	`993`	`ShowInternalPreview();`
`995`	`994`	`}`
`996`	`995`	`break;`
`997`		`-`
`998`	`996`	`case false`
`999`	`997`	`when InternalPreviewVisible:`
`1000`	`998`	`PreviewSelectedItem?.LoadPreviewImage();`
`@@ -1004,17 +1002,23 @@ when CanExternalPreviewSelectedResult(out var path):`
`1004`	`1002`
`1005`	`1003`	`private bool CanExternalPreviewSelectedResult(out string path)`
`1006`	`1004`	`{`
`1007`		`- path = PreviewSelectedItem == Results.SelectedItem ? Results.SelectedItem?.Result?.Preview.FilePath : string.Empty;`
	`1005`	`+ path = QueryResultsPreviewed() ? Results.SelectedItem?.Result?.Preview.FilePath : string.Empty;`
`1008`	`1006`	`return !string.IsNullOrEmpty(path);`
`1009`	`1007`	`}`
	`1008`	`+`
	`1009`	`+ private bool QueryResultsPreviewed()`
	`1010`	`+ {`
	`1011`	`+ var previewed = PreviewSelectedItem == Results.SelectedItem;`
	`1012`	`+ return previewed;`
	`1013`	`+ }`
`1010`	`1014`
`1011`	`1015`	`#endregion`
`1012`	`1016`
`1013`	`1017`	`#region Query`
`1014`	`1018`
`1015`	`1019`	`public void Query(bool isReQuery = false)`
`1016`	`1020`	`{`
`1017`		`- if (SelectedIsFromQueryResults())`
	`1021`	`+ if (QueryResultsSelected())`
`1018`	`1022`	`{`
`1019`	`1023`	`_ = QueryResultsAsync(isReQuery);`
`1020`	`1024`	`}`
`@@ -1382,7 +1386,7 @@ private static Result ContextMenuPluginInfo(string id)`
`1382`	`1386`	`return menu;`
`1383`	`1387`	`}`
`1384`	`1388`
`1385`		`- internal bool SelectedIsFromQueryResults()`
	`1389`	`+ internal bool QueryResultsSelected()`
`1386`	`1390`	`{`
`1387`	`1391`	`var selected = SelectedResults == Results;`
`1388`	`1392`	`return selected;`
`@@ -1447,10 +1451,10 @@ public async void Hide()`
`1447`	`1451`
`1448`	`1452`	`if (ExternalPreviewVisible)`
`1449`	`1453`	`{`
`1450`		`- CloseExternalPreview();`
	`1454`	`+ await CloseExternalPreviewAsync();`
`1451`	`1455`	`}`
`1452`	`1456`
`1453`		`- if (!SelectedIsFromQueryResults())`
	`1457`	`+ if (!QueryResultsSelected())`
`1454`	`1458`	`{`
`1455`	`1459`	`SelectedResults = Results;`
`1456`	`1460`	`}`
`@@ -1460,10 +1464,7 @@ public async void Hide()`
`1460`	`1464`	`{`
`1461`	`1465`	`ChangeQueryText(string.Empty);`
`1462`	`1466`	`await Task.Delay(1); // Wait for one frame to ensure UI reflects changes`
`1463`		`- Application.Current.Dispatcher.Invoke(() =>`
`1464`		`- {`
`1465`		`- Application.Current.MainWindow.UpdateLayout(); // Force UI update`
`1466`		`- });`
	`1467`	`+ Application.Current.Dispatcher.Invoke(Application.Current.MainWindow.UpdateLayout); // Force UI update`
`1467`	`1468`	`}`
`1468`	`1469`
`1469`	`1470`	`switch (Settings.LastQueryMode)`