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

		/// <summary>
		/// Initializes a new instance of the <see cref="Xwt.KeyEventArgs"/> class.
		/// </summary>
		/// <param name="key">The key.</param>
		/// <param name="modifiers">The modifier keys.</param>
		/// <param name="isRepeat">the key has been pressed more then once.</param>
		/// <param name="timestamp">The timestamp of the key event.</param>
		public KeyEventArgs (Key key, ModifierKeys modifiers, bool isRepeat, long timestamp)
		{
			this.Key = key;
			this.Modifiers = modifiers;
			this.IsRepeat = isRepeat;
			this.Timestamp = timestamp;
		}

        public static KeyInput ConvertToKeyInput(Key key, ModifierKeys modifierKeys)
        {
            var modKeys = ConvertToKeyModifiers(modifierKeys);
            var tuple = TryConvertToKeyInput(key);
            if (tuple == null)
            {
                return new KeyInput(Char.MinValue, modKeys);
            }

            if ((modKeys & KeyModifiers.Shift) == 0)
            {
                var temp = tuple.Item1;
                return new KeyInput(temp.Char, temp.Key, modKeys);
            }

            // The shift flag is tricky.  There is no good API available to translate a virtualKey
            // with an additional modifier.  Instead we define the core set of keys we care about,
            // map them to a virtualKey + ModifierKeys tuple.  We then consult this map here to see
            // if we can appropriately "shift" the KeyInput value
            //
            // This feels like a very hackish solution and I'm actively seeking a better, more thorough
            // one

            var ki = tuple.Item1;
            var virtualKey = tuple.Item2;
            var found = MappedCoreChars.FirstOrDefault(x => x.Item2 == virtualKey && KeyModifiers.Shift == x.Item3);
            if (found == null)
            {
                return new KeyInput(ki.Char, modKeys);
            }
            else
            {
                return new KeyInput(found.Item1, modKeys);
            }
        }

        public void KeyPushed(string key, ModifierKeys mod)
        {
            if (key == "space")
            {
                InputLine += " ";
            }
            else if (key == "return")
            {
                SendMessage();
            }
            else if (key == "backspace")
            {
                InputLine = InputLine.Remove(InputLine.Length - 1);
            }
            else if (key == "tab")
            {
                InputLine += "    ";
                Console.WriteLine(InputLine);
            }
            // Avoid unhandled special caracters 
            else if (key.Length == 1)
            {
                if (mod == ModifierKeys.Caps || mod == ModifierKeys.ShiftKeys)
                    key.ToUpper();

                InputLine += key;
            }
        }

 public void RegisterHotkey(ModifierKeys keyModifier, Keys hotkey)
 {
     HotkeySettings.Default.ModifierKey = keyModifier;
     HotkeySettings.Default.Key = hotkey;
     HotkeySettings.Default.Save();
     Register();
 }

 private void OnRunHotKeyPressed(Key key, ModifierKeys modifier)
 {
     if (state.IsConfigurationOpened)
         navigator.OpenConfiguration();
     else
         navigator.OpenMain();
 }