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

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -10,6 +10,7 @@
 using Flow.Launcher.Core.Resource;
 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;
@@ -31,14 +32,22 @@ public static class PluginManager
         private static readonly ConcurrentDictionary<string, PluginPair> _globalPlugins = [];
         private static readonly ConcurrentDictionary<string, PluginPair> _nonGlobalPlugins = [];
 
+        public static event Action<PluginHotkeyChangedEvent> PluginHotkeyChanged;
+        public static event Action<PluginPair> PluginHotkeyInitialized;
+
         private static PluginsSettings Settings;
         private static readonly ConcurrentBag<string> ModifiedPlugins = [];
 
         private static readonly ConcurrentBag<PluginPair> _contextMenuPlugins = [];
         private static readonly ConcurrentBag<PluginPair> _homePlugins = [];
         private static readonly ConcurrentBag<PluginPair> _translationPlugins = [];
+        private static readonly ConcurrentBag<PluginPair> _hotkeyPlugins = [];
         private static readonly ConcurrentBag<PluginPair> _externalPreviewPlugins = [];
 
+        private static readonly Lock _pluginHotkeyInfoUpdateLock = new();
+        private static readonly ConcurrentDictionary<PluginPair, List<BasePluginHotkey>> _pluginHotkeyInfo = [];
+        private static readonly ConcurrentDictionary<HotkeyModel, ConcurrentBag<(PluginMetadata, SearchWindowPluginHotkey)>> _windowPluginHotkeys = [];
+
         /// <summary>
         /// Directories that will hold Flow Launcher plugin directory
         /// </summary>
@@ -302,6 +311,9 @@ public static async Task InitializePluginsAsync(IResultUpdateRegister register)
                 // Add plugin to Dialog Jump plugin list after the plugin is initialized
                 DialogJump.InitializeDialogJumpPlugin(pair);
 
+                // Check and initialize plugin hotkeys after the plugin is initialized
+                CheckPluginHotkeys(pair);
+
                 // Add plugin to lists after the plugin is initialized
                 AddPluginToLists(pair);
             }));
@@ -359,6 +371,22 @@ private static void AddPluginToLists(PluginPair pair)
             _allInitializedPlugins.TryAdd(pair.Metadata.ID, pair);
         }
 
+        private static void CheckPluginHotkeys(PluginPair pair)
+        {
+            if (pair.Plugin is IPluginHotkey)
+            {
+                InitializePluginHotkeyInfo(pair);
+                // Since settings cannot be changed concurrently, we must use a lock here
+                lock (_pluginHotkeyInfoUpdateLock)
+                {
+                    Settings.UpdatePluginHotkeyInfo(GetPluginHotkeyInfo(pair.Metadata.ID));
+                }
+                InitializeWindowPluginHotkey(pair);
+                _hotkeyPlugins.Add(pair);
+                PluginHotkeyInitialized?.Invoke(pair);
+            }
+        }
+
         #endregion
 
         #region Validate & Query Plugins
@@ -586,6 +614,11 @@ public static List<PluginPair> GetTranslationPlugins()
             return [.. _translationPlugins.Where(p => !PluginModified(p.Metadata.ID))];
         }
 
+        public static List<PluginPair> GetHotkeyPlugins()
+        {
+            return [.. _hotkeyPlugins.Where(p => !PluginModified(p.Metadata.ID))];
+        }
+
         #endregion
 
         #region Update Metadata & Get Plugin
@@ -791,6 +824,175 @@ public static void RemoveActionKeyword(string id, string oldActionkeyword)
 
         #endregion
 
+        #region Plugin Hotkey
+
+        private static void InitializePluginHotkeyInfo(PluginPair pair)
+        {
+            var plugin = (IPluginHotkey)pair.Plugin;
+            var hotkeys = plugin.GetPluginHotkeys();
+            _pluginHotkeyInfo.TryAdd(pair, hotkeys);
+        }
+
+        private static void InitializeWindowPluginHotkey(PluginPair pair)
+        {
+            foreach (var info in GetPluginHotkeyInfo(pair.Metadata.ID))
+            {
+                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 = [];
+                            _windowPluginHotkeys[hotkeyModel] = list;
+                        }
+                        list.Add((pluginPair.Metadata, searchWindowHotkey));
+                    }
+                }
+            }
+        }
+
+        public static Dictionary<PluginPair, List<BasePluginHotkey>> GetPluginHotkeyInfo(string id = null)
+        {
+            if (id == null)
+            {
+                // Return all plugin hotkey info except those from modified plugins
+                return _pluginHotkeyInfo.Where(p => !PluginModified(p.Key.Metadata.ID))
+                    .ToDictionary(p => p.Key, p => p.Value);
+            }
+            else
+            {
+                // Return plugin hotkey info for specified plugin id
+                return _pluginHotkeyInfo.Where(p => p.Key.Metadata.ID == id)
+                    .ToDictionary(p => p.Key, p => p.Value);
+            }
+        }
+
+        public static Dictionary<HotkeyModel, ConcurrentBag<(PluginMetadata Metadata, SearchWindowPluginHotkey SearchWindowPluginHotkey)>> GetWindowPluginHotkeys(string id = null)
+        {
+            // Here we do not need to check PluginModified since we will check it in hotkey events
+            if (id == null)
+            {
+                // Return all window plugin hotkeys
+                return _windowPluginHotkeys.ToDictionary(p => p.Key, p => p.Value);
+            }
+            else
+            {
+                // Return window plugin hotkeys for specified plugin id
+                // If one HotkeyModel is already included by other plugins, it will be removed so that HotkeyMapper will not register this Window hotkey duplicately
+                var windowPluginHotkeys = new Dictionary<HotkeyModel, ConcurrentBag<(PluginMetadata Metadata, SearchWindowPluginHotkey SearchWindowPluginHotkey)>>();
+                foreach (var key in _windowPluginHotkeys)
+                {
+                    // Check if all items in the list are from the specified plugin
+                    if (key.Value.All(x => x.Item1.ID == id))
+                    {
+                        // We must use the reference of this ConcurrentBag so that it can be updated in the next
+                        windowPluginHotkeys[key.Key] = key.Value;
+                    }
+                }
+                return windowPluginHotkeys;
+            }
+        }
+
+        public static void UpdatePluginHotkeyInfoTranslations(PluginPair pair)
+        {
+            var newHotkeys = ((IPluginHotkey)pair.Plugin).GetPluginHotkeys();
+            if (_pluginHotkeyInfo.TryGetValue(pair, 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.TryAdd(pair, newHotkeys);
+            }
+        }
+
+        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 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)];
+            if (_windowPluginHotkeys[oldHotkey].IsEmpty)
+            {
+                _windowPluginHotkeys.TryRemove(oldHotkey, out var _);
+            }
+
+            if (_windowPluginHotkeys.TryGetValue(newHotkey, out var newHotkeyModels))
+            {
+                var newList = newHotkeyModels.ToList();
+                newList.Add((plugin, pluginHotkey));
+                _windowPluginHotkeys[newHotkey] = [.. newList];
+            }
+            else
+            {
+                _windowPluginHotkeys[newHotkey] =
+                [
+                    (plugin, pluginHotkey)
+                ];
+            }
+
+            PluginHotkeyChanged?.Invoke(new PluginHotkeyChangedEvent(oldHotkey, newHotkey, plugin, pluginHotkey));
+        }
+
+        #region Class
+
+        public class PluginHotkeyChangedEvent(HotkeyModel oldHotkey, HotkeyModel newHotkey,
+            PluginMetadata metadata, BasePluginHotkey pluginHotkey)
+        {
+            public HotkeyModel NewHotkey { get; } = newHotkey;
+
+            public HotkeyModel OldHotkey { get; } = oldHotkey;
+
+            public PluginMetadata Metadata { get; } = metadata;
+
+            public BasePluginHotkey PluginHotkey { get; } = pluginHotkey;
+        }
+
+        #endregion
+
+        #endregion
+
         #region Plugin Install & Uninstall & Update
 
         #region Private Functions

Flow.Launcher.Core/Resource/Internationalization.cs

@@ -368,6 +368,11 @@ public static void UpdatePluginMetadataTranslations()
                 {
                     p.Metadata.Name = pluginI18N.GetTranslatedPluginTitle();
                     p.Metadata.Description = pluginI18N.GetTranslatedPluginDescription();
+                    if (p.Plugin is IPluginHotkey)
+                    {
+                        // Update plugin hotkey name & description
+                        PluginManager.UpdatePluginHotkeyInfoTranslations(p);
+                    }
                     pluginI18N.OnCultureInfoChanged(CultureInfo.CurrentCulture);
                 }
                 catch (Exception e)
@@ -385,6 +390,11 @@ public static void UpdatePluginMetadataTranslation(PluginPair p)
             {
                 p.Metadata.Name = pluginI18N.GetTranslatedPluginTitle();
                 p.Metadata.Description = pluginI18N.GetTranslatedPluginDescription();
+                if (p.Plugin is IPluginHotkey)
+                {
+                    // Update plugin hotkey name & description
+                    PluginManager.UpdatePluginHotkeyInfoTranslations(p);
+                }
                 pluginI18N.OnCultureInfoChanged(CultureInfo.CurrentCulture);
             }
             catch (Exception e)

Flow.Launcher.Infrastructure/DialogJump/DialogJump.cs

@@ -1,19 +1,19 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Threading;
 using CommunityToolkit.Mvvm.DependencyInjection;
+using CommunityToolkit.Mvvm.Input;
 using Flow.Launcher.Infrastructure.Logger;
 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 System.Collections.Concurrent;
 
 namespace Flow.Launcher.Infrastructure.DialogJump
 {
@@ -173,22 +173,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;
                 }
 
@@ -329,7 +329,7 @@
                         if (PublicApi.Instance.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;
@@ -464,10 +464,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; }
 }