Merge pull request #1561 from Flow-Launcher/rightclicked

Refactor KeyBinding Commands

Author: jjw24

Flow.Launcher/ViewModel/MainViewModel.cs

@@ -77,7 +77,6 @@ public MainViewModel(Settings settings)
             _userSelectedRecord = _userSelectedRecordStorage.Load();
             _topMostRecord = _topMostRecordStorage.Load();
 
-            InitializeKeyCommands();
 
             ContextMenu = new ResultsViewModel(Settings)
             {
@@ -167,160 +166,164 @@ private void RegisterResultsUpdatedEvent()
             }
         }
 
+        [RelayCommand]
+        private async Task ReloadPluginDataAsync()
+        {
+            Hide();
 
-
-        private void InitializeKeyCommands()
+            await PluginManager.ReloadDataAsync().ConfigureAwait(false);
+            Notification.Show(InternationalizationManager.Instance.GetTranslation("success"), InternationalizationManager.Instance.GetTranslation("completedSuccessfully"));
+        }
+        [RelayCommand]
+        private void LoadHistory()
         {
-            EscCommand = new RelayCommand(_ =>
+            if (SelectedIsFromQueryResults())
             {
-                if (!SelectedIsFromQueryResults())
-                {
-                    SelectedResults = Results;
-                }
-                else
-                {
-                    Hide();
-                }
-            });
-
-            ClearQueryCommand = new RelayCommand(_ =>
+                SelectedResults = History;
+                History.SelectedIndex = _history.Items.Count - 1;
+            }
+            else
             {
-                if (!string.IsNullOrEmpty(QueryText))
-                {
-                    ChangeQueryText(string.Empty);
-
-                    // Push Event to UI SystemQuery has changed
-                    //OnPropertyChanged(nameof(SystemQueryText));
-                }
-            });
-
-            SelectNextItemCommand = new RelayCommand(_ => { SelectedResults.SelectNextResult(); });
-
-            SelectPrevItemCommand = new RelayCommand(_ => { SelectedResults.SelectPrevResult(); });
-
-            SelectNextPageCommand = new RelayCommand(_ => { SelectedResults.SelectNextPage(); });
+                SelectedResults = Results;
+            }
+        }
+        [RelayCommand]
+        private void LoadContextMenu()
+        {
+            if (SelectedIsFromQueryResults())
+            {
+                // 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
+                if (SelectedResults.SelectedItem != null)
+                    SelectedResults = ContextMenu;
+            }
+            else
+            {
+                SelectedResults = Results;
+            }
+        }
+        [RelayCommand]
+        private void Backspace(object index)
+        {
+            var query = QueryBuilder.Build(QueryText.Trim(), PluginManager.NonGlobalPlugins);
 
-            SelectPrevPageCommand = new RelayCommand(_ => { SelectedResults.SelectPrevPage(); });
+            // GetPreviousExistingDirectory does not require trailing '\', otherwise will return empty string
+            var path = FilesFolders.GetPreviousExistingDirectory((_) => true, query.Search.TrimEnd('\\'));
 
-            SelectFirstResultCommand = new RelayCommand(_ => SelectedResults.SelectFirstResult());
+            var actionKeyword = string.IsNullOrEmpty(query.ActionKeyword) ? string.Empty : $"{query.ActionKeyword} ";
 
-            StartHelpCommand = new RelayCommand(_ =>
-            {
-                PluginManager.API.OpenUrl("https://github.com/Flow-Launcher/Flow.Launcher/wiki/Flow-Launcher/");
-            });
-            OpenSettingCommand = new RelayCommand(_ => { App.API.OpenSettingDialog(); });
-            OpenResultCommand = new AsyncRelayCommand(async _ =>
+            ChangeQueryText($"{actionKeyword}{path}");
+        }
+        [RelayCommand]
+        private void AutocompleteQuery()
+        {
+            var result = SelectedResults.SelectedItem?.Result;
+            if (result != null && SelectedIsFromQueryResults()) // SelectedItem returns null if selection is empty.
             {
-                var results = SelectedResults;
+                var autoCompleteText = result.Title;
 
-                var result = results.SelectedItem?.Result;
-                if (result == null)
+                if (!string.IsNullOrEmpty(result.AutoCompleteText))
                 {
-                    return;
+                    autoCompleteText = result.AutoCompleteText;
                 }
-                var hideWindow = await result.ExecuteAsync(new ActionContext
-                {
-                    SpecialKeyState = GlobalHotkey.CheckModifiers()
-                }).ConfigureAwait(false);
-
-                if (hideWindow)
+                else if (!string.IsNullOrEmpty(SelectedResults.SelectedItem?.QuerySuggestionText))
                 {
-                    Hide();
+                    autoCompleteText = SelectedResults.SelectedItem.QuerySuggestionText;
                 }
 
-                if (SelectedIsFromQueryResults())
+                var specialKeyState = GlobalHotkey.CheckModifiers();
+                if (specialKeyState.ShiftPressed)
                 {
-                    _userSelectedRecord.Add(result);
-                    _history.Add(result.OriginQuery.RawQuery);
+                    autoCompleteText = result.SubTitle;
                 }
-                else
-                {
-                    SelectedResults = Results;
-                }
-            });
 
-            AutocompleteQueryCommand = new RelayCommand(_ =>
+                ChangeQueryText(autoCompleteText);
+            }
+        }
+        [RelayCommand]
+        private async Task OpenResultAsync(string index)
+        {
+            var results = SelectedResults;
+            if (index is not null)
+            {
+                results.SelectedIndex = int.Parse(index);
+            }
+            var result = results.SelectedItem?.Result;
+            if (result == null)
             {
-                var result = SelectedResults.SelectedItem?.Result;
-                if (result != null && SelectedIsFromQueryResults()) // SelectedItem returns null if selection is empty.
+                return;
+            }
+            var hideWindow = await result.ExecuteAsync(new ActionContext
                 {
-                    var autoCompleteText = result.Title;
-
-                    if (!string.IsNullOrEmpty(result.AutoCompleteText))
-                    {
-                        autoCompleteText = result.AutoCompleteText;
-                    }
-                    else if (!string.IsNullOrEmpty(SelectedResults.SelectedItem?.QuerySuggestionText))
-                    {
-                        autoCompleteText = SelectedResults.SelectedItem.QuerySuggestionText;
-                    }
-
-                    var specialKeyState = GlobalHotkey.CheckModifiers();
-                    if (specialKeyState.ShiftPressed)
-                    {
-                        autoCompleteText = result.SubTitle;
-                    }
-
-                    ChangeQueryText(autoCompleteText);
-                }
-            });
+                    SpecialKeyState = GlobalHotkey.CheckModifiers()
+                })
+                .ConfigureAwait(false);
 
-            BackspaceCommand = new RelayCommand(index =>
+            if (hideWindow)
             {
-                var query = QueryBuilder.Build(QueryText.Trim(), PluginManager.NonGlobalPlugins);
+                Hide();
+            }
 
-                // GetPreviousExistingDirectory does not require trailing '\', otherwise will return empty string
-                var path = FilesFolders.GetPreviousExistingDirectory((_) => true, query.Search.TrimEnd('\\'));
+            if (SelectedIsFromQueryResults())
+            {
+                _userSelectedRecord.Add(result);
+                _history.Add(result.OriginQuery.RawQuery);
+            }
+            else
+            {
+                SelectedResults = Results;
+            }
+        }
+        [RelayCommand]
+        private void OpenSetting()
+        {
+            App.API.OpenSettingDialog();
+        }
 
-                var actionKeyword = string.IsNullOrEmpty(query.ActionKeyword) ? string.Empty : $"{query.ActionKeyword} ";
+        [RelayCommand]
+        private void SelectHelp()
+        {
+            PluginManager.API.OpenUrl("https://www.flowlauncher.com/docs/#/usage-tips");
+        }
 
-                ChangeQueryText($"{actionKeyword}{path}");
-            });
+        [RelayCommand]
+        private void SelectFirstResult()
+        {
+            SelectedResults.SelectFirstResult();
+        }
+        [RelayCommand]
+        private void SelectPrevPage()
+        {
+            SelectedResults.SelectPrevPage();
+        }
 
-            LoadContextMenuCommand = new RelayCommand(_ =>
-            {
-                if (SelectedIsFromQueryResults())
-                {
-                    // 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
-                    if (SelectedResults.SelectedItem != null)
-                        SelectedResults = ContextMenu;
-                }
-                else
-                {
-                    SelectedResults = Results;
-                }
-            });
+        [RelayCommand]
+        private void SelectNextPage()
+        {
+            SelectedResults.SelectNextPage();
+        }
+        [RelayCommand]
+        private void SelectPrevItem()
+        {
+            SelectedResults.SelectPrevResult();
+        }
+        [RelayCommand]
+        private void SelectNextItem()
+        {
+            SelectedResults.SelectNextResult();
+        }
 
-            LoadHistoryCommand = new RelayCommand(_ =>
+        [RelayCommand]
+        private void Esc()
+        {
+            if (!SelectedIsFromQueryResults())
             {
-                if (SelectedIsFromQueryResults())
-                {
-                    SelectedResults = History;
-                    History.SelectedIndex = _history.Items.Count - 1;
-                }
-                else
-                {
-                    SelectedResults = Results;
-                }
-            });
-
-            ReloadPluginDataCommand = new RelayCommand(_ =>
+                SelectedResults = Results;
+            }
+            else
             {
                 Hide();
-
-                _ = PluginManager
-                    .ReloadDataAsync()
-                    .ContinueWith(_ =>
-                        Application.Current.Dispatcher.Invoke(() =>
-                        {
-                            Notification.Show(
-                                InternationalizationManager.Instance.GetTranslation("success"),
-                                InternationalizationManager.Instance.GetTranslation("completedSuccessfully")
-                            );
-                        }), TaskScheduler.Default)
-                    .ConfigureAwait(false);
-            });
+            }
         }
 
         #endregion
@@ -416,6 +419,7 @@ private void DecreaseMaxResult()
         /// but we don't want to move cursor to end when query is updated from TextBox
         /// </summary>
         /// <param name="queryText"></param>
+        /// <param name="reQuery">Force query even when Query Text doesn't change</param>
         public void ChangeQueryText(string queryText, bool reQuery = false)
         {
             if (QueryText != queryText)
@@ -494,25 +498,6 @@ public double MainWindowWidth
 
         public string PluginIconPath { get; set; } = null;
 
-        public ICommand EscCommand { get; set; }
-        public ICommand BackspaceCommand { get; set; }
-        public ICommand SelectNextItemCommand { get; set; }
-        public ICommand SelectPrevItemCommand { get; set; }
-        public ICommand SelectNextPageCommand { get; set; }
-        public ICommand SelectPrevPageCommand { get; set; }
-        public ICommand SelectFirstResultCommand { get; set; }
-        public ICommand StartHelpCommand { get; set; }
-        public ICommand LoadContextMenuCommand { get; set; }
-        public ICommand LoadHistoryCommand { get; set; }
-        public ICommand OpenResultCommand { get; set; }
-        public ICommand OpenSettingCommand { get; set; }
-        public ICommand ReloadPluginDataCommand { get; set; }
-        public ICommand ClearQueryCommand { get; private set; }
-
-        public ICommand CopyToClipboard { get; set; }
-
-        public ICommand AutocompleteQueryCommand { get; set; }
-
         public string OpenResultCommandModifiers { get; private set; }
 
         public string Image => Constant.QueryTextBoxIconImagePath;