IPluginHotkey Interface for Global Hotkey & Window Hotkey / Support Rename File & Folder by Hotkey or Context Menu

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -6,10 +6,12 @@
 using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Windows.Input;
 using CommunityToolkit.Mvvm.DependencyInjection;
 using Flow.Launcher.Core.ExternalPlugins;
 using Flow.Launcher.Infrastructure;
 using Flow.Launcher.Infrastructure.DialogJump;
+using Flow.Launcher.Infrastructure.Hotkey;
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
 using Flow.Launcher.Plugin.SharedCommands;
@@ -29,6 +31,8 @@ public static class PluginManager
         public static readonly HashSet<PluginPair> GlobalPlugins = new();
         public static readonly Dictionary<string, PluginPair> NonGlobalPlugins = new();
 
+        public static Action<PluginHotkeyChangedEvent> PluginHotkeyChanged { get; set; }
+
         // We should not initialize API in static constructor because it will create another API instance
         private static IPublicAPI api = null;
         private static IPublicAPI API => api ??= Ioc.Default.GetRequiredService<IPublicAPI>();
@@ -40,6 +44,10 @@ public static class PluginManager
         private static IEnumerable<PluginPair> _homePlugins;
         private static IEnumerable<PluginPair> _resultUpdatePlugin;
         private static IEnumerable<PluginPair> _translationPlugins;
+        private static IEnumerable<PluginPair> _hotkeyPlugins;
+
+        private static readonly Dictionary<PluginPair, List<BasePluginHotkey>> _pluginHotkeyInfo = new();
+        private static readonly Dictionary<HotkeyModel, List<(PluginMetadata, SearchWindowPluginHotkey)>> _windowPluginHotkeys = new();
 
         private static readonly List<DialogJumpExplorerPair> _dialogJumpExplorerPlugins = new();
         private static readonly List<DialogJumpDialogPair> _dialogJumpDialogPlugins = new();
@@ -190,6 +198,7 @@ public static void LoadPlugins(PluginsSettings settings)
             _homePlugins = GetPluginsForInterface<IAsyncHomeQuery>();
             _resultUpdatePlugin = GetPluginsForInterface<IResultUpdated>();
             _translationPlugins = GetPluginsForInterface<IPluginI18n>();
+            _hotkeyPlugins = GetPluginsForInterface<IPluginHotkey>();
 
             // Initialize Dialog Jump plugin pairs
             foreach (var pair in GetPluginsForInterface<IDialogJumpExplorer>())
@@ -277,6 +286,10 @@ public static async Task InitializePluginsAsync()
 
             await Task.WhenAll(InitTasks);
 
+            InitializePluginHotkeyInfo();
+            Settings.UpdatePluginHotkeyInfo(GetPluginHotkeyInfo());
+            InitializeWindowPluginHotkeys();
+
             foreach (var plugin in AllPlugins)
             {
                 // set distinct on each plugin's action keywords helps only firing global(*) and action keywords once where a plugin
@@ -485,6 +498,11 @@ public static IList<PluginPair> GetTranslationPlugins()
             return _translationPlugins.Where(p => !PluginModified(p.Metadata.ID)).ToList();
         }
 
+        public static IList<PluginPair> GetHotkeyPlugins()
+        {
+            return _hotkeyPlugins.Where(p => !PluginModified(p.Metadata.ID)).ToList();
+        }
+
         public static List<Result> GetContextMenusForPlugin(Result result)
         {
             var results = new List<Result>();
@@ -529,6 +547,131 @@ public static IList<DialogJumpDialogPair> GetDialogJumpDialogs()
             return _dialogJumpDialogPlugins.Where(p => !PluginModified(p.Metadata.ID)).ToList();
         }
 
+        public static IDictionary<PluginPair, List<BasePluginHotkey>> GetPluginHotkeyInfo()
+        {
+            return _pluginHotkeyInfo.Where(p => !PluginModified(p.Key.Metadata.ID))
+                                    .ToDictionary(p => p.Key, p => p.Value);
+        }
+
+        public static IDictionary<HotkeyModel, List<(PluginMetadata Metadata, SearchWindowPluginHotkey SearchWindowPluginHotkey)>> GetWindowPluginHotkeys()
+        {
+            // Here we do not need to check PluginModified since we will check it in hotkey events
+            return _windowPluginHotkeys.ToDictionary(p => p.Key, p => p.Value);
+        }
+
+        public static void UpdatePluginHotkeyInfoTranslations()
+        {
+            foreach (var plugin in GetHotkeyPlugins())
+            {
+                var newHotkeys = ((IPluginHotkey)plugin.Plugin).GetPluginHotkeys();
+                if (_pluginHotkeyInfo.TryGetValue(plugin, out var oldHotkeys))
+                {
+                    foreach (var newHotkey in newHotkeys)
+                    {
+                        if (oldHotkeys.FirstOrDefault(h => h.Id == newHotkey.Id) is BasePluginHotkey pluginHotkey)
+                        {
+                            pluginHotkey.Name = newHotkey.Name;
+                            pluginHotkey.Description = newHotkey.Description;
+                        }
+                        else
+                        {
+                            oldHotkeys.Add(newHotkey);
+                        }
+                    }
+                }
+                else
+                {
+                    _pluginHotkeyInfo.Add(plugin, newHotkeys);
+                }
+            }
+        }
+
+        private static void InitializePluginHotkeyInfo()
+        {
+            foreach (var plugin in GetHotkeyPlugins())
+            {
+                var hotkeys = ((IPluginHotkey)plugin.Plugin).GetPluginHotkeys();
+                _pluginHotkeyInfo.Add(plugin, hotkeys);
+            }
+        }
+
+        private static void InitializeWindowPluginHotkeys()
+        {
+            foreach (var info in GetPluginHotkeyInfo())
+            {
+                var pluginPair = info.Key;
+                var hotkeyInfo = info.Value;
+                var metadata = pluginPair.Metadata;
+                foreach (var hotkey in hotkeyInfo)
+                {
+                    if (hotkey.HotkeyType == HotkeyType.SearchWindow && hotkey is SearchWindowPluginHotkey searchWindowHotkey)
+                    {
+                        var hotkeySetting = metadata.PluginHotkeys.Find(h => h.Id == hotkey.Id)?.Hotkey ?? hotkey.DefaultHotkey;
+                        var hotkeyModel = new HotkeyModel(hotkeySetting);
+                        if (!_windowPluginHotkeys.TryGetValue(hotkeyModel, out var list))
+                        {
+                            list = new List<(PluginMetadata, SearchWindowPluginHotkey)>();
+                            _windowPluginHotkeys[hotkeyModel] = list;
+                        }
+                        list.Add((pluginPair.Metadata, searchWindowHotkey));
+                    }
+                }
+            }
+        }
+
+        public static void ChangePluginHotkey(PluginMetadata plugin, GlobalPluginHotkey pluginHotkey, HotkeyModel newHotkey)
+        {
+            var oldHotkeyItem = plugin.PluginHotkeys.First(h => h.Id == pluginHotkey.Id);
+            var settingHotkeyItem = Settings.GetPluginSettings(plugin.ID).pluginHotkeys.First(h => h.Id == pluginHotkey.Id);
+            var oldHotkeyStr = settingHotkeyItem.Hotkey;
+            var oldHotkey = new HotkeyModel(oldHotkeyStr);
+            var newHotkeyStr = newHotkey.ToString();
+
+            // Update hotkey in plugin metadata & setting
+            oldHotkeyItem.Hotkey = newHotkeyStr;
+            settingHotkeyItem.Hotkey = newHotkeyStr;
+
+            PluginHotkeyChanged?.Invoke(new PluginHotkeyChangedEvent(oldHotkey, newHotkey, plugin, pluginHotkey));
+        }
+
+        public static void ChangePluginHotkey(PluginMetadata plugin, SearchWindowPluginHotkey pluginHotkey, HotkeyModel newHotkey)
+        {
+            var oldHotkeyItem = plugin.PluginHotkeys.First(h => h.Id == pluginHotkey.Id);
+            var settingHotkeyItem = Settings.GetPluginSettings(plugin.ID).pluginHotkeys.First(h => h.Id == pluginHotkey.Id);
+            var oldHotkeyStr = settingHotkeyItem.Hotkey;
+            var converter = new KeyGestureConverter();
+            var oldHotkey = new HotkeyModel(oldHotkeyStr);
+            var newHotkeyStr = newHotkey.ToString();
+
+            // Update hotkey in plugin metadata & setting
+            oldHotkeyItem.Hotkey = newHotkeyStr;
+            settingHotkeyItem.Hotkey = newHotkeyStr;
+
+            // Update window plugin hotkey dictionary
+            var oldHotkeyModels = _windowPluginHotkeys[oldHotkey];
+            _windowPluginHotkeys[oldHotkey] = oldHotkeyModels.Where(x => x.Item1.ID != plugin.ID || x.Item2.Id != pluginHotkey.Id).ToList();
+            if (_windowPluginHotkeys[oldHotkey].Count == 0)
+            {
+                _windowPluginHotkeys.Remove(oldHotkey);
+            }
+
+            if (_windowPluginHotkeys.TryGetValue(newHotkey, out var newHotkeyModels))
+            {
+                var newList = newHotkeyModels.ToList();
+                newList.Add((plugin, pluginHotkey));
+                _windowPluginHotkeys[newHotkey] = newList;
+            }
+            else
+            {
+                _windowPluginHotkeys[newHotkey] = new List<(PluginMetadata, SearchWindowPluginHotkey)>()
+                {
+                    (plugin, pluginHotkey)
+                };
+            }
+
+            PluginHotkeyChanged?.Invoke(new PluginHotkeyChangedEvent(oldHotkey, newHotkey, plugin, pluginHotkey));
+        }
+
         public static bool ActionKeywordRegistered(string actionKeyword)
         {
             // this method is only checking for action keywords (defined as not '*') registration
@@ -826,5 +969,28 @@ internal static async Task<bool> UninstallPluginAsync(PluginMetadata plugin, boo
         }
 
         #endregion
+
+        #region Class
+
+        public class PluginHotkeyChangedEvent
+        {
+            public HotkeyModel NewHotkey { get; }
+
+            public HotkeyModel OldHotkey { get; }
+
+            public PluginMetadata Metadata { get; }
+
+            public BasePluginHotkey PluginHotkey { get; }
+
+            public PluginHotkeyChangedEvent(HotkeyModel oldHotkey, HotkeyModel newHotkey, PluginMetadata metadata, BasePluginHotkey pluginHotkey)
+            {
+                OldHotkey = oldHotkey;
+                NewHotkey = newHotkey;
+                Metadata = metadata;
+                PluginHotkey = pluginHotkey;
+            }
+        }
+
+        #endregion
     }
 }

Flow.Launcher.Core/Resource/Internationalization.cs

@@ -365,6 +365,9 @@ public static void UpdatePluginMetadataTranslations()
                     API.LogException(ClassName, $"Failed for <{p.Metadata.Name}>", e);
                 }
             }
+
+            // Update plugin hotkey name & description
+            PluginManager.UpdatePluginHotkeyInfoTranslations();
         }
 
         #endregion

Flow.Launcher.Infrastructure/DialogJump/DialogJump.cs

@@ -9,10 +9,10 @@
 using Flow.Launcher.Infrastructure.DialogJump.Models;
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
-using NHotkey;
 using Windows.Win32;
 using Windows.Win32.Foundation;
 using Windows.Win32.UI.Accessibility;
+using CommunityToolkit.Mvvm.Input;
 
 namespace Flow.Launcher.Infrastructure.DialogJump
 {
@@ -162,22 +162,22 @@
                 }
                 if (!_locationChangeHook.IsNull)
                 {
                     PInvoke.UnhookWinEvent(_locationChangeHook);
                     _locationChangeHook = HWINEVENTHOOK.Null;
                 }
                 if (!_destroyChangeHook.IsNull)
                 {
                     PInvoke.UnhookWinEvent(_destroyChangeHook);
                     _destroyChangeHook = HWINEVENTHOOK.Null;
                 }
                 if (!_hideChangeHook.IsNull)
                 {
                     PInvoke.UnhookWinEvent(_hideChangeHook);
                     _hideChangeHook = HWINEVENTHOOK.Null;
                 }
                 if (!_dialogEndChangeHook.IsNull)
                 {
                     PInvoke.UnhookWinEvent(_dialogEndChangeHook);
                     _dialogEndChangeHook = HWINEVENTHOOK.Null;
                 }
 
@@ -318,7 +318,7 @@
                         if (API.PluginModified(explorer.Metadata.ID) || // Plugin is modified
                             explorer.Metadata.Disabled) continue; // Plugin is disabled
 
                         var explorerWindow = explorer.Plugin.CheckExplorerWindow(hWnd);
                         if (explorerWindow != null)
                         {
                             _dialogJumpExplorers[explorer] = explorerWindow;
@@ -453,10 +453,15 @@
 
         #endregion
 
-        #region Hotkey
+        #region Hotkey Command
 
-        public static void OnToggleHotkey(object sender, HotkeyEventArgs args)
+        private static RelayCommand _dialogJumpCommand;
+        public static IRelayCommand DialogJumpCommand => _dialogJumpCommand ??= new RelayCommand(OnToggleHotkey);
+
+        private static void OnToggleHotkey()
         {
+            if (!_settings.EnableDialogJump) return;
+
             _ = Task.Run(async () =>
             {
                 try

Flow.Launcher.Infrastructure/Hotkey/HotkeyModel.cs

@@ -49,6 +49,10 @@
             }
         }
 
+        public readonly bool IsEmpty => CharKey == Key.None && !Alt && !Shift && !Win && !Ctrl;
+
+        public static HotkeyModel Empty => new();
+
         public HotkeyModel(string hotkeyString)
         {
             Parse(hotkeyString);
@@ -117,12 +121,22 @@
             }
         }
 
-        public override string ToString()
+        public bool Equals(HotkeyModel other)
+        {
+            return CharKey == other.CharKey && ModifierKeys == other.ModifierKeys;
+        }
+
+        public KeyGesture ToKeyGesture()
+        {
+            return new KeyGesture(CharKey, ModifierKeys);
+        }
+
+        public override readonly string ToString()
         {
             return string.Join(" + ", EnumerateDisplayKeys());
         }
 
-        public IEnumerable<string> EnumerateDisplayKeys()
+        public readonly IEnumerable<string> EnumerateDisplayKeys()
         {
             if (Ctrl && CharKey is not (Key.LeftCtrl or Key.RightCtrl))
             {
@@ -155,9 +169,9 @@
         /// <summary>
         /// Validate hotkey
         /// </summary>
-        /// <param name="validateKeyGestrue">Try to validate hotkey as a KeyGesture.</param>
+        /// <param name="validateKeyGesture">Try to validate hotkey as a KeyGesture.</param>
         /// <returns></returns>
-        public bool Validate(bool validateKeyGestrue = false)
+        public bool Validate(bool validateKeyGesture = false)
         {
             switch (CharKey)
             {
@@ -167,12 +181,12 @@
                 case Key.RightCtrl:
                 case Key.LeftShift:
                 case Key.RightShift:
                 case Key.LWin:
                 case Key.RWin:
                 case Key.None:
                     return false;
                 default:
-                    if (validateKeyGestrue)
+                    if (validateKeyGesture)
                     {
                         try
                         {

Flow.Launcher.Infrastructure/Hotkey/IHotkeySettings.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.ObjectModel;
 
 namespace Flow.Launcher.Infrastructure.Hotkey;
 
@@ -13,5 +13,5 @@ public interface IHotkeySettings
     /// A list of hotkeys that have already been registered. The dialog will display these hotkeys and provide a way to
     /// unregister them.
     /// </summary>
-    public List<RegisteredHotkeyData> RegisteredHotkeys { get; }
+    public ObservableCollection<RegisteredHotkeyData> RegisteredHotkeys { get; }
 }