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

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -6,9 +6,11 @@
 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.Hotkey;
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
 using Flow.Launcher.Plugin.SharedCommands;
@@ -26,11 +28,16 @@
 
         private static IEnumerable<PluginPair> _contextMenuPlugins;
         private static IEnumerable<PluginPair> _homePlugins;
+        private static IEnumerable<PluginPair> _resultUpdatePlugin;
+        private static IEnumerable<PluginPair> _translationPlugins;
+        private static IEnumerable<PluginPair> _hotkeyPlugins;
 
         public static List<PluginPair> AllPlugins { get; private set; }
         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>();
@@ -39,6 +46,9 @@
         private static List<PluginMetadata> _metadatas;
         private static readonly List<string> _modifiedPlugins = new();
 
+        private static readonly Dictionary<PluginPair, List<BasePluginHotkey>> _pluginHotkeyInfo = new();
+        private static readonly Dictionary<HotkeyModel, List<(PluginMetadata, SearchWindowPluginHotkey)>> _windowPluginHotkeys = new();
+
         /// <summary>
         /// Directories that will hold Flow Launcher plugin directory
         /// </summary>
@@ -111,7 +121,7 @@
             await Task.WhenAll(AllPlugins.Select(plugin => plugin.Plugin switch
             {
                 IReloadable p => Task.Run(p.ReloadData),
                 IAsyncReloadable p => p.ReloadDataAsync(),
                 _ => Task.CompletedTask,
             }).ToArray());
         }
@@ -173,12 +183,18 @@
         /// <param name="settings"></param>
         public static void LoadPlugins(PluginsSettings settings)
         {
             _metadatas = PluginConfig.Parse(Directories);
             Settings = settings;
             Settings.UpdatePluginSettings(_metadatas);
             AllPlugins = PluginsLoader.Plugins(_metadatas, Settings);
             // Since dotnet plugins need to get assembly name first, we should update plugin directory after loading plugins
             UpdatePluginDirectory(_metadatas);
+            // Initialize plugin enumerable after all plugins are initialized
+            _contextMenuPlugins = GetPluginsForInterface<IContextMenu>();
+            _homePlugins = GetPluginsForInterface<IAsyncHomeQuery>();
+            _resultUpdatePlugin = GetPluginsForInterface<IResultUpdated>();
+            _translationPlugins = GetPluginsForInterface<IPluginI18n>();
+            _hotkeyPlugins = GetPluginsForInterface<IPluginHotkey>();
         }
 
         private static void UpdatePluginDirectory(List<PluginMetadata> metadatas)
@@ -248,8 +264,9 @@
 
             await Task.WhenAll(InitTasks);
 
-            _contextMenuPlugins = GetPluginsForInterface<IContextMenu>();
-            _homePlugins = GetPluginsForInterface<IAsyncHomeQuery>();
+            InitializePluginHotkeyInfo();
+            Settings.UpdatePluginHotkeyInfo(GetPluginHotkeyInfo());
+            InitializeWindowPluginHotkeys();
 
             foreach (var plugin in AllPlugins)
             {
@@ -409,7 +426,7 @@
             return AllPlugins.FirstOrDefault(o => o.Metadata.ID == id);
         }
 
-        public static IEnumerable<PluginPair> GetPluginsForInterface<T>() where T : IFeatures
+        private static IEnumerable<PluginPair> GetPluginsForInterface<T>() where T : IFeatures
         {
             // Handle scenario where this is called before all plugins are instantiated, e.g. language change on startup
             return AllPlugins?.Where(p => p.Plugin is T) ?? Array.Empty<PluginPair>();
@@ -449,6 +466,140 @@
             return _homePlugins.Any(p => p.Metadata.ID == id);
         }
 
+        public static IList<PluginPair> GetResultUpdatePlugin()
+        {
+            return _resultUpdatePlugin.Where(p => !PluginModified(p.Metadata.ID)).ToList();
+        }
+
+        public static IList<PluginPair> GetTranslationPlugins()
+        {
+            // Here we still return the modified plugins to update the possible string resources
+            return _translationPlugins.ToList();
+        }
+
+        public static Dictionary<PluginPair, List<BasePluginHotkey>> GetPluginHotkeyInfo()
+        {
+            return _pluginHotkeyInfo;
+        }
+
+        public static Dictionary<HotkeyModel, List<(PluginMetadata Metadata, SearchWindowPluginHotkey SearchWindowPluginHotkey)>> GetWindowPluginHotkeys()
+        {
+            return _windowPluginHotkeys;
+        }
+
+        public static void UpdatePluginHotkeyInfoTranslations()
+        {
+            foreach (var plugin in _hotkeyPlugins)
+            {
+                var newHotkeys = ((IPluginHotkey)plugin.Plugin).GetPuginHotkeys();
+                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 _hotkeyPlugins)
+            {
+                var hotkeys = ((IPluginHotkey)plugin.Plugin).GetPuginHotkeys();
+                _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
@@ -712,5 +863,28 @@
         }
 
         #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

@@ -21,7 +21,7 @@
 
         // 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>();
 
         private const string Folder = "Languages";
         private const string DefaultLanguageCode = "en";
@@ -74,7 +74,7 @@
 
         private void AddPluginLanguageDirectories()
         {
-            foreach (var plugin in PluginManager.GetPluginsForInterface<IPluginI18n>())
+            foreach (var plugin in PluginManager.GetTranslationPlugins())
             {
                 var location = Assembly.GetAssembly(plugin.Plugin.GetType()).Location;
                 var dir = Path.GetDirectoryName(location);
@@ -278,7 +278,8 @@
 
         private void UpdatePluginMetadataTranslations()
         {
-            foreach (var p in PluginManager.GetPluginsForInterface<IPluginI18n>())
+            // Update plugin metadata name & description
+            foreach (var p in PluginManager.GetTranslationPlugins())
             {
                 if (p.Plugin is not IPluginI18n pluginI18N) return;
                 try
@@ -292,6 +293,9 @@
                     API.LogException(ClassName, $"Failed for <{p.Metadata.Name}>", e);
                 }
             }
+
+            // Update plugin hotkey name & description
+            PluginManager.UpdatePluginHotkeyInfoTranslations();
         }
 
         private static string LanguageFile(string folder, string language)

Flow.Launcher.Infrastructure/Hotkey/HotkeyModel.cs

@@ -49,6 +49,10 @@ public ModifierKeys ModifierKeys
             }
         }
 
+        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 @@ private void Parse(string hotkeyString)
             }
         }
 
-        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))
             {

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; }
 }