C# ModifierKeys类代码示例

 public KeyAssign(Key key, ModifierKeys modifiers, IEnumerable<KeyAssignActionDescription> actions, bool handlePreview = false)
 {
     Key = key;
     Modifiers = modifiers;
     HandlePreview = handlePreview;
     Actions = actions.ToArray();
 }

        public void AddKeyBinding(ICommand command, object param, Key key, ModifierKeys modifierKeys = ModifierKeys.None)
        {
            Contract.Requires(command != null);

            var binding = new KeyBinding(key, modifierKeys);
            m_keyBindings.Add(binding, new CommandParamPair(command, param));
        }

 protected override void OnLoading()
 {
   base.OnLoading();
   var element = Controller.Element;
   _modifiersKeys = MouseWheel.GetVScrollModifiers(element);
   MouseWheel.VScrollModifiersProperty.AddValueChanged(element, OnModifierKeysYChanged);
 }

 public HotKey(int id, Key key, ModifierKeys modifiers)
 {
     this.id = id;
     this.key = key;
     this.modifiers = modifiers;
     this.actions = new List<Action>();
 }

        public static void HookHotKey(Window window, Key key,
            ModifierKeys modifiers, int keyId, EventHandler hookHandler)
        {

            HwndSourceHook hook = delegate(IntPtr hwnd, int msg, IntPtr wParam,
                IntPtr lParam, ref bool handled)
            {

                if (msg == HotKeyHelper.WM_HOTKEY)
                {
                    // TODO: parse out the lParam to see if it is actually the one registered
                    // see http://msdn.microsoft.com/en-us/library/ms646279(VS.85).aspx

                    hookHandler(window, EventArgs.Empty);
                    handled = true;
                }
                return IntPtr.Zero;
            };

            HwndSource source = PresentationSource.FromVisual(window) as HwndSource;
            if (source == null)
            {
                throw new ApplicationException("window doesn't have a source yet. Did you wait till after the SourceInitialized event?");
            }
            source.AddHook(hook);

            RegisterHotKey(window, key, modifiers, keyId);
        }

 /// <summary>
 /// Регистрация хоткея в системе
 /// </summary>
 /// <param name="modifier">Модификатор хоткея.</param>
 /// <param name="key">Клавиша хоткея.</param>
 public void RegisterHotKey(ModifierKeys modifier, Keys key)
 {
     _currentId = _currentId + 1;
     if (!NativeMethods.RegisterHotKey(_window.Handle, _currentId, (uint)modifier, (uint)key)) {
         throw new InvalidOperationException("Couldn’t register the hot key.");
     }
 }

 public void Select(ModifierKeys modifierKey, ICollection<ITreeItem> rootTreeItems, ITreeItem newSelectedItem, ITreeItem oldSelectedItem)
 {
     switch (modifierKey)
     {
         case ModifierKeys.Shift:
             if(_previousSelectionWasShift)
             {
                 _rangeSelector.Select(rootTreeItems, newSelectedItem, _previousShiftSelection);
             }
             else
             {
                 _rangeSelector.Select(rootTreeItems, newSelectedItem, oldSelectedItem);
                 _previousShiftSelection = oldSelectedItem;
             }
             _previousSelectionWasShift = true;
             break;
         case ModifierKeys.Control:
             _previousSelectionWasShift = false;
             _inverseSelector.Select(rootTreeItems, newSelectedItem);
             break;
         default:
             _previousSelectionWasShift = false;
             _nullSelector.Select(rootTreeItems, newSelectedItem);
             break;
     }
 }

        /// <summary>
        /// Try and get the KeyInput which corresponds to the given Key and modifiers
        /// TODO: really think about this method
        /// </summary>
        internal bool TryGetKeyInput(Key key, ModifierKeys modifierKeys, out KeyInput keyInput)
        {
            // First just check and see if there is a direct mapping
            var keyType = new KeyType(key, modifierKeys);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                return true;
            }

            // Next consider only the shift key part of the requested modifier.  We can
            // re-apply the original modifiers later
            keyType = new KeyType(key, modifierKeys & ModifierKeys.Shift);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                // Reapply the modifiers
                keyInput = KeyInputUtil.ChangeKeyModifiers(keyInput, ConvertToKeyModifiers(modifierKeys));
                return true;
            }

            // Last consider it without any modifiers and reapply
            keyType = new KeyType(key, ModifierKeys.None);
            if (_cache.TryGetValue(keyType, out keyInput))
            {
                // Reapply the modifiers
                keyInput = KeyInputUtil.ChangeKeyModifiers(keyInput, ConvertToKeyModifiers(modifierKeys));
                return true;
            }

            return false;
        }

        /// <summary>
        /// Determines whether the event arguments match the specified key combination.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="modifierKeys">The modifier keys.</param>
        /// <returns>True if the event arguments match the specified key combination, otherwise false.</returns>
        public bool Match(Key key, ModifierKeys modifierKeys = ModifierKeys.None)
        {
            if (this.Key == key)
            {
                if (key == Keyboard.LeftControl || key == Keyboard.RightControl)
                {
                    return (this.ModifierKeys | ModifierKeys.Control) == (modifierKeys | ModifierKeys.Control);
                }

                if (key == Keyboard.LeftAlt || key == Keyboard.RightAlt)
                {
                    return (this.ModifierKeys | ModifierKeys.Alt) == (modifierKeys | ModifierKeys.Alt);
                }

                if (key == Keyboard.LeftShift || key == Keyboard.RightShift)
                {
                    return (this.ModifierKeys | ModifierKeys.Shift) == (modifierKeys | ModifierKeys.Shift);
                }

                if (key == Keyboard.LeftWindows || key == Keyboard.RightWindows)
                {
                    return (this.ModifierKeys | ModifierKeys.Windows) == (modifierKeys | ModifierKeys.Windows);
                }

                return this.ModifierKeys == modifierKeys;
            }

            return false;
        }

		KeyDescriptor (SpecialKey specialKey, char keyChar, ModifierKeys modifierKeys, object nativeKeyChar)
		{
			SpecialKey = specialKey;
			KeyChar = keyChar;
			ModifierKeys = modifierKeys;
			NativeKeyChar = nativeKeyChar;
		}

        public int RegisterHotKey(ModifierKeys mods, Keys key)
        {
            if (!RegisterHotKey(_window.Handle, ++_currentId, (uint) mods, (uint) key))
                throw new Exception("Key register failed");

            return _currentId;
        }

 public void SaveKeys(ModifierKeys[] modifiers, Key key, ref String to)
 {
     String s = "";
     modifiers.ToList().ForEach(k => s += k.ToString() + "+");
     s += key.ToString();
     to = s;
 }

        public static Tuple<Keys, ModifierKeys> ConvertFromString(string keysString)
        {
            Keys mainKey = new Keys();
            ModifierKeys modKeys = new ModifierKeys();

            var keys = keysString.Split('+');
            foreach (string keyString in keys)
            {
                Keys key = (Keys)(new KeysConverter()).ConvertFromString(keyString);
                if (key == Keys.Alt || key == Keys.LWin || key == Keys.Shift || key == Keys.Control)
                {
                    switch (key)
                    {
                        case Keys.Alt: modKeys = modKeys | ModifierKeys.Alt; break;
                        case Keys.LWin: modKeys = modKeys | ModifierKeys.Win; break;
                        case Keys.Shift: modKeys = modKeys | ModifierKeys.Shift; break;
                        case Keys.Control: modKeys = modKeys | ModifierKeys.Control; break;
                    }
                }
                else
                {
                    mainKey = key;
                }
            }
            return new Tuple<Keys, ModifierKeys>(mainKey, (ModifierKeys)modKeys);
        }

        void PanicKey_PreviewKeyDown(object sender, KeyEventArgs e)
        {
            e.Handled = true;

            var rKey = e.Key;
            switch (rKey)
            {
                case Key.LWin:
                case Key.RWin:
                case Key.NumLock:
                case Key.LeftShift:
                case Key.RightShift:
                case Key.LeftCtrl:
                case Key.RightCtrl:
                case Key.LeftAlt:
                case Key.RightAlt:
                    return;
            }

            if (r_OldKey == rKey && r_OldModifierKeys == Keyboard.Modifiers)
                return;

            r_OldKey = rKey;
            r_OldModifierKeys = Keyboard.Modifiers;

            Preference.Instance.Other.PanicKey.UpdateKey((int)Keyboard.Modifiers, KeyInterop.VirtualKeyFromKey(rKey));
        }

 public VertexSelectedEventArgs(VertexControl vc, MouseButtonEventArgs e, ModifierKeys keys)
     : base()
 {
     VertexControl = vc;
     MouseArgs = e;
     Modifiers = keys;
 }