hotkey.cs

破解的飞信源代码

namespace Imps.Client.Utils
{
    using Imps.Client.Utils.Win32;
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Windows.Forms;

    public class HotKey
    {
        private static List<HotKey> _invalidHotKeys;
        private uint _mod;
        private static Dictionary<uint, string> _specialKeys = new Dictionary<uint, string>();
        private uint _vk;
        public const uint NoneKeyLParam = 3;

        static HotKey()
        {
            _specialKeys.Add(0x6b, "Num +");
            _specialKeys.Add(0x6a, "Num *");
            _specialKeys.Add(0xba, ";");
            _specialKeys.Add(220, @"\");
            _specialKeys.Add(0xde, "'");
            _specialKeys.Add(0xdd, "]");
            _specialKeys.Add(0xc0, ".");
            _specialKeys.Add(190, ".");
            _specialKeys.Add(0xdb, "[");
            _specialKeys.Add(0xbc, ",");
            _specialKeys.Add(0xbf, "/");
            _specialKeys.Add(0xbb, "=");
            _specialKeys.Add(0xbd, "-");
            _specialKeys.Add(0x6f, "Num /");
            _specialKeys.Add(110, "Num Del");
            _specialKeys.Add(0x6d, "Num -");
            _specialKeys.Add(0x60, "Num 0");
            _specialKeys.Add(0x61, "Num 1");
            _specialKeys.Add(0x62, "Num 2");
            _specialKeys.Add(0x63, "Num 3");
            _specialKeys.Add(100, "Num 4");
            _specialKeys.Add(0x65, "Num 5");
            _specialKeys.Add(0x66, "Num 6");
            _specialKeys.Add(0x67, "Num 7");
            _specialKeys.Add(0x68, "Num 8");
            _specialKeys.Add(0x69, "Num 9");
            _invalidHotKeys = new List<HotKey>();
            _invalidHotKeys.AddRange(new HotKey[] { new HotKey(Keys.A, Keys.Control), new HotKey(Keys.C, Keys.Control), new HotKey(Keys.F, Keys.Control), new HotKey(Keys.H, Keys.Control), new HotKey(Keys.N, Keys.Control), new HotKey(Keys.O, Keys.Control), new HotKey(Keys.P, Keys.Control), new HotKey(Keys.S, Keys.Control), new HotKey(Keys.V, Keys.Control), new HotKey(Keys.Y, Keys.Control), new HotKey(Keys.X, Keys.Control), new HotKey(Keys.Z, Keys.Control), new HotKey(Keys.Delete, Keys.Alt | Keys.Control) });
            _invalidHotKeys.Sort(new HotKeyComparer());
        }

        public HotKey() : this(3)
        {
        }

        public HotKey(uint lParam)
        {
            uint vk = lParam >> 0x10;
            uint mod = lParam & 0xffff;
            this.Init(vk, mod);
        }

        public HotKey(uint vkValue, uint modifiersValue) : this(vkValue, modifiersValue, false)
        {
        }

        public HotKey(Keys vk, Keys modifiers) : this((uint) vk, (uint) modifiers, false)
        {
        }

        public HotKey(uint vkValue, uint modifiersValue, bool win)
        {
            uint mod = 0;
            if ((modifiersValue & 0x40000) != 0)
            {
                mod |= 1;
            }
            if ((modifiersValue & 0x20000) != 0)
            {
                mod |= 2;
            }
            if ((modifiersValue & 0x10000) != 0)
            {
                mod |= 4;
            }
            if (win)
            {
                mod |= 8;
            }
            this.Init(vkValue, mod);
        }

        public HotKey(Keys vk, Keys modifiers, bool win) : this((uint) vk, (uint) modifiers, win)
        {
        }

        public override bool Equals(object obj)
        {
            if (obj is HotKey)
            {
                HotKey key = (HotKey) obj;
                if (key._mod == this._mod)
                {
                    return (key._vk == this._vk);
                }
            }
            return false;
        }

        public override int GetHashCode()
        {
            return (this._vk.GetHashCode() & this._mod.GetHashCode());
        }

        private void Init(uint vk, uint mod)
        {
            this._mod = mod;
            if (((vk < 0x21) || (vk == 0x5b)) || (vk == 0x5c))
            {
                this._vk = 0;
            }
            else
            {
                this._vk = vk;
            }
        }

        public bool Register(IntPtr hWnd, int id)
        {
            if (this.IsValid)
            {
                return Imps.Client.Utils.Win32.NativeMethods.RegisterHotKey(hWnd, id, this.ModValue, this.KeyValue);
            }
            return false;
        }

        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            if (this.Win)
            {
                builder.Append("Win + ");
            }
            if (this.Control)
            {
                builder.Append("Ctrl + ");
            }
            if (this.Alt)
            {
                builder.Append("Alt + ");
            }
            if (this.Shift)
            {
                builder.Append("Shif + ");
            }
            if (this.VirtualKey != Keys.None)
            {
                builder.Append(this.VkString);
            }
            return builder.ToString();
        }

        public static bool Unregister(IntPtr hWnd, int id)
        {
            return Imps.Client.Utils.Win32.NativeMethods.UnregisterHotKey(hWnd, id);
        }

        public bool Alt
        {
            get
            {
                return ((this._mod & 1) != 0);
            }
        }

        public bool Control
        {
            get
            {
                return ((this._mod & 2) != 0);
            }
        }

        public bool IsValid
        {
            get
            {
                if ((((this._vk == 0) || (this._mod == 0)) || (this._mod == 4)) || ((this._mod == 1) && ((this._mod != 1) || ((this._vk >= 0x41) && (this._vk <= 90)))))
                {
                    return false;
                }
                return (_invalidHotKeys.BinarySearch(this, new HotKeyComparer()) < 0);
            }
        }

        public uint KeyValue
        {
            get
            {
                return this._vk;
            }
        }

        public uint LParam
        {
            get
            {
                if (this.IsValid)
                {
                    return ((this._vk << 0x10) | this._mod);
                }
                return 3;
            }
        }

        public Keys Modifiers
        {
            get
            {
                uint num = 0;
                if ((this._mod & 2) != 0)
                {
                    num |= 0x20000;
                }
                if ((this._mod & 1) != 0)
                {
                    num |= 0x40000;
                }
                if ((this._mod & 4) != 0)
                {
                    num |= 0x10000;
                }
                return (Keys) num;
            }
        }

        public uint ModValue
        {
            get
            {
                return this._mod;
            }
        }

        public bool Shift
        {
            get
            {
                return ((this._mod & 4) != 0);
            }
        }

        public Keys VirtualKey
        {
            get
            {
                return (Keys) this._vk;
            }
        }

        public string VkString
        {
            get
            {
                if (this.KeyValue == 0)
                {
                    return string.Empty;
                }
                if (((this.KeyValue >= 0x30) && (this.KeyValue <= 0x39)) || ((this.KeyValue >= 0x41) && (this.KeyValue <= 90)))
                {
                    char keyValue = (char) this.KeyValue;
                    return keyValue.ToString();
                }
                if (_specialKeys.ContainsKey(this.KeyValue))
                {
                    return _specialKeys.get_Item(this.KeyValue);
                }
                return ((Keys) this.KeyValue).ToString();
            }
        }

        public bool Win
        {
            get
            {
                return ((this._mod & 8) != 0);
            }
        }

        private class HotKeyComparer : IComparer<HotKey>
        {
            public int Compare(HotKey x, HotKey y)
            {
                if (x._mod == y._mod)
                {
                    return (int) (x._vk - y._vk);
                }
                return (int) (x._mod - y._mod);
            }
        }
    }
}