updated the branch

src/Shared/HandyControl_Shared/Tools/GlobalShortcut.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.Windows;
 using System.Windows.Input;
 using HandyControl.Data;
@@ -9,28 +10,39 @@ namespace HandyControl.Tools
 {
     public class GlobalShortcut
     {
-        private static readonly HashSet<InputBindingCollection> InputBindingCollectionSet = new HashSet<InputBindingCollection>();
+        private static ObservableCollection<KeyBinding> KeyBindingCollection;
+
+        private static readonly Dictionary<string, KeyBinding> CommandDic = new Dictionary<string, KeyBinding>();
+
+        private static void KeyboardHook_KeyDown(object sender, KeyboardHookEventArgs e) => HitTest(e.Key);
 
         static GlobalShortcut()
         {
-            KeyboardHook.KeyDown += KeyboardHook_KeyDown;
-            KeyboardHook.Start();
-        }
 
-        private static void KeyboardHook_KeyDown(object sender, KeyboardHookEventArgs e) => HitTest(e.Key);
+            KeyboardHook.KeyDown += KeyboardHook_KeyDown;
+        }
 
         private static void HitTest(Key key)
         {
             if (IsModifierKey(key)) return;
 
-            var keyBindings = InputBindingCollectionSet
-                .SelectMany(inputBindingCollection => inputBindingCollection.OfType<KeyBinding>())
-                .Where(keyBinding => keyBinding.Key != Key.None && keyBinding.Modifiers == Keyboard.Modifiers && keyBinding.Key == key);
-            keyBindings.ToList().ForEach(keyBinding =>
+            var modifierKeys = Keyboard.Modifiers;
+            var keyStr = modifierKeys != ModifierKeys.None ? $"{modifierKeys.ToString()}, {key.ToString()}" : key.ToString();
+            ExecuteCommand(keyStr);
+        }
+
+        private static void ExecuteCommand(string key)
+        {
+            if (string.IsNullOrEmpty(key)) return;
+            if (CommandDic.ContainsKey(key))
             {
-                if (keyBinding.Command?.CanExecute(keyBinding.CommandParameter) == true)
-                    keyBinding.Command?.Execute(keyBinding.CommandParameter);
-            });
+                var keyBinding = CommandDic[key];
+                var command = keyBinding.Command;
+                if (command != null && command.CanExecute(keyBinding.CommandParameter))
+                {
+                    command.Execute(keyBinding.CommandParameter);
+                }
+            }
         }
 
         private static bool IsModifierKey(Key key)
@@ -39,25 +51,76 @@ namespace HandyControl.Tools
                    key == Key.RightCtrl || key == Key.RightAlt || key == Key.RightShift || key == Key.RWin;
         }
 
-        [Obsolete]
+        [Obsolete("pls use Host attach property instead of Init method")]
         public static void Init(DependencyObject host)
         {
+            CommandDic.Clear();
+
+            if (host == null) return;
+
+            KeyBindingCollection = GetKeyBindings(host);
+            if (KeyBindingCollection == null || KeyBindingCollection.Count == 0) return;
+
+            AddKeyBindings(KeyBindingCollection);
+
+            KeyboardHook.Start();
         }
 
+        private static void AddKeyBindings(IEnumerable<KeyBinding> keyBindings)
+        {
+            foreach (var item in keyBindings)
+            {
+                if (item.Key == Key.None) continue;
+
+                if (item.Modifiers == ModifierKeys.None)
+                {
+                    CommandDic[item.Key.ToString()] = item;
+                }
+                else
+                {
+                    var keyStr = $"{item.Modifiers.ToString()}, {item.Key.ToString()}";
+                    CommandDic[keyStr] = item;
+                }
+            }
+        }
+
+        public static readonly DependencyProperty HostProperty = DependencyProperty.RegisterAttached(
+            "Host", typeof(bool), typeof(GlobalShortcut), new PropertyMetadata(ValueBoxes.FalseBox, OnHostChanged));
+
+        private static void OnHostChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            if (DesignerHelper.IsInDesignMode) return;
+
+            if (KeyBindingCollection != null)
+            {
+                KeyBindingCollection.CollectionChanged -= KeyBindingCollection_CollectionChanged;
+            }
+            KeyBindingCollection = GetKeyBindings(d);
+            if (KeyBindingCollection != null)
+            {
+                KeyBindingCollection.CollectionChanged += KeyBindingCollection_CollectionChanged;
+            }
+        }
+
+        private static void KeyBindingCollection_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            AddKeyBindings(KeyBindingCollection);
+            KeyboardHook.Start();
+        }
+
+        public static void SetHost(DependencyObject element, bool value)
+            => element.SetValue(HostProperty, value);
+
+        public static bool GetHost(DependencyObject element)
+            => (bool) element.GetValue(HostProperty);
+
         public static readonly DependencyProperty KeyBindingsProperty = DependencyProperty.RegisterAttached(
-            "KeyBindings", typeof(InputBindingCollection), typeof(GlobalShortcut), new PropertyMetadata(new InputBindingCollection()), OnValidateValue);
+            "KeyBindings", typeof(ObservableCollection<KeyBinding>), typeof(GlobalShortcut), new PropertyMetadata(new ObservableCollection<KeyBinding>()));
 
-        private static bool OnValidateValue(object value)
-        {
-            if (value is InputBindingCollection inputBindingCollection && !InputBindingCollectionSet.Contains(inputBindingCollection))
-                InputBindingCollectionSet.Add(inputBindingCollection);
-            return true;
-        }
-
-        public static void SetKeyBindings(DependencyObject element, InputBindingCollection value)
+        public static void SetKeyBindings(DependencyObject element, ObservableCollection<KeyBinding> value)
             => element.SetValue(KeyBindingsProperty, value);
 
-        public static InputBindingCollection GetKeyBindings(DependencyObject element)
-            => (InputBindingCollection)element.GetValue(KeyBindingsProperty);
+        public static ObservableCollection<KeyBinding> GetKeyBindings(DependencyObject element)
+            => (ObservableCollection<KeyBinding>) element.GetValue(KeyBindingsProperty);
     }
 }