2019-6-5-WPF-拼音输入法

2022-08-04 11:53:32

原文:2019-6-5-WPF-拼音输入法

title	author	date	CreateTime	categories
WPF 拼音输入法	lindexi	2019-6-5 17:6:58 +0800	2018-4-30 11:5:18 +0800	输入法 WPF

本文来告诉大家如何使用 WPF 来写一个输入法，使用的方式是钩子。

实际上本文是在使用一个好用的软件希沃白板的时候发现在里面很难输入拼音来做课堂活动。

因为现在没有找到一个软件可以用来输入拼音的，快速的输入。输入音调是比较难的，所以我就重新做了一个输入法。

在yswenli的帮助，使用了yswenli/Wenli.IEM 方法做了一个输入法。

键盘

如果要做一个输入法，可以使用很多方法，本文使用的是全局 hook 的方式，需要注意，这个方式很容易让 360 杀掉。

注册钩子的方法很简单，只需要一个函数

        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);

关于 HookProc 请看代码

        public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);

所以简单的注册一个钩子只需要三行代码

                var keyboardHookProcedure = new HookProc(KeyboardHookProc);

                var hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, keyboardHookProcedure, GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);

                private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
                {
                	// 如果你要算括号就有很多行
                }

那么拿到了 hook 可以如何使用，下面来告诉大家如何解析信息

解析键盘

解析的方式微软有说到，因为很简单，只需要定义一个结构，请看代码。定义的结构需要是这样的，不要去优化。

        [StructLayout(LayoutKind.Sequential)]
        public class KeyboardHookStruct
        {
            public int vkCode;  //定一个虚拟键码。该代码必须有一个价值的范围1至254
            public int scanCode; // 指定的硬件扫描码的关键
            public int flags;  // 键标志
            public int time; // 指定的时间戳记的这个讯息
            public int dwExtraInfo; // 指定额外信息相关的信息
        }

从参数就可以拿到，因为参数是指针，需要Marshal.PtrToStructure来拿到

 KeyboardHookStruct myKeyboardHookStruct = (KeyboardHookStruct) Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));

现在通过这个方法就可以拿到键盘的输入。

获得按键

虽然已经解析了，但是现在还是不知道用户按键是哪个。需要通过下面的方法转换，首先引用 WinForm ，因为定义在 WinForm 有，而且下面发送消息也是需要通过。

右击引用，点击程序集、框架，就可以看到 System.Windows.Forms ，请看图片

引用了之后就可以使用下面的方法拿到按键

Keys keyData = (System.Windows.Forms.Keys) myKeyboardHookStruct.vkCode;

尝试点一下，是不是就可以看到对应的值？

有了按键，那么下面如何写一个输入法就是需要使用了对应的算法了，如果想使用微软提供的算法，请看C# 输入法，我是需要用来输入拼音。所以下面来告诉大家如何从用户按键拿到用户想要的输入。

输入流向

虽然已经拿到了按键，但是拿到的按键还是需要转换字符串才可以处理

var key = keyData.ToString().ToLower();

现在的 key 就是一个字符串，在输入拼音，用户想的是快速的输入，而不是不停复制粘贴，对于普通的字符输入是可以直接输入，但是对于āáǎ的输入就无法直接输入的。

我看到一位老师是在记事本写了下面代码

āáǎà
ēéěè
īíǐì
ōóǒò
ūúǔù
ǖǘǚǜ

需要哪个就去复制哪个，如写 yùn 就需要输入 y 然后复制一下ù，然后写 n ，这样想输入连续的拼音是很慢的。

所以对于a,e,i,o,u,v才需要输入法转换，对于其他的就直接输入就好了。

那么如何让用户的按键无法直接输入到对应的程序，就需要使用下面的函数

        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(int idHook, int nCode, Int32 wParam, IntPtr lParam);

使用这个函数就可以通过信息钩子继续下一个钩子，在 private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam) 大家也看到有一个返回值，通过这个返回值可以告诉系统，是不是要把这个消息传给下一个程序。

如果返回的是 0 那么就是告诉系统，这个 hook 不处理，你需要把消息发给其他的程序。如果返回不是0 ，那么就是告诉系统，这个我处理了，其他的程序不能收到。

输入法判断用户输入的是 [a,z] [0,9] 告诉系统，不要发给其他的程序。

那么如果用户输入的不是 a,e,i,o,u,v 也就是可以直接给其他程序，这时怎么做？

实际上不管用户输入的是什么，只要发给其他程序都需要使用这个方法

System.Windows.Forms.SendKeys.SendWait(string str)

通过这个方法就会把 str 发送给当前用户输入的程序。

算法

现在可以拿到了全部的输入，而且知道了如何把转换的值发送给用户，大概一个输入法就是需要这两个。

如果从用户的输入知道用户需要的什么就是算法，下面使用的方法很简单。

判断用户输入的是不是a,e,i,o,u,v，发现不是就直接发送输入。如果是就不发送任何输入，让用户选需要的是哪个

这是我把它显示出来，代码还需要一个属性，表示当前是不是存在用户没有选的字符。如果存在，下一次输入的是[0,9]就是用户选的字符，因为只要5个可以选，对于大于5和0的就直接发送输入。当前对于现在很多输入法，都是按空格选第一个，这里也是需要判断用户输入的是不是空格。

在开发的时候发现还有很多的细节，不过这些我就不在这里告诉大家，我把代码放在下面，大家看一下。

我把程序放在论坛，可以点击快速在课堂活动输入拼音下载

源代码请看

       public MainWindow()
        {
            InitializeComponent();
            Loaded += MainWindow_Loaded;
            DataContext = this;
            Topmost = true;
        }

        private void HideVexogzPybnj()
        {
            LdefkgzYclfeufwx.Visibility = Visibility.Visible;
            KqhRst.Visibility = Visibility.Hidden;
        }

        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            HideVexogzPybnj();

            App.KeyBordHook.KeyUpEvent += KeyBordHook_KeyUpEvent;
            App.KeyBordHook.OnSpaced += KeyBordHook_OnSpaced;
            App.KeyBordHook.OnBacked += KeyBordHook_OnBacked;
        }

        private void KeyBordHook_OnBacked()
        {
            if (!_yuanyin)
            {
                _key = "";
                App.KeyBordHook.IsStarted = false;
                return;
            }

            _yuanyin = false;
            HideVexogzPybnj();
        }

        private void KeyBordHook_OnSpaced(int choose)
        {
            if (choose > 0)
            {
                choose = choose - 1;
            }

            if (choose < 5)
            {
                if (_yuanyin)
                {
                    App.KeyBordHook.Send(_yuanyinList[_key][choose].ToString());
                    _yuanyin = false;
                    HideVexogzPybnj();
                    return;
                }
            }

            App.KeyBordHook.IsStarted = false;
        }

        private void KeyBordHook_KeyUpEvent(object sender, System.Windows.Forms.Keys e)
        {
            var key = e.ToString().ToLower();

            List<string> yuanyin = "a,e,i,o,u,v".Split(‘,‘).ToList();

            if (yuanyin.Any(temp => temp == key))
            {
                if (_yuanyin)
                {
                    App.KeyBordHook.Send(_key);
                }
                _key = key;
                ShowDvfarVawmkezbi(_yuanyinList[key]);
                _yuanyin = true;
            }
            else
            {
                if (_yuanyin && !string.IsNullOrEmpty(_key))
                {
                    _yuanyin = false;
                    App.KeyBordHook.Send(_yuanyinList[_key][4].ToString());
                    _key = "";
                    HideVexogzPybnj();
                }

                App.KeyBordHook.Send(key);
            }
        }


        private string _key;
        private bool _yuanyin;

        private void ShowDvfarVawmkezbi(string str)
        {
            StringBuilder temp = new StringBuilder();
            for (var i = 0; i < str.Length; i++)
            {
                temp.Append((i + 1) + "." + str[i] + "    ");
            }

            Key = temp.ToString();

            KqhRst.Visibility = Visibility.Visible;
            LdefkgzYclfeufwx.Visibility = Visibility.Hidden;
        }

        public static readonly DependencyProperty KeyProperty = DependencyProperty.Register(
            nameof(Key), typeof(string), typeof(MainWindow), new PropertyMetadata(default(string)));

        public string Key
        {
            get => (string) GetValue(KeyProperty);
            set => SetValue(KeyProperty, value);
        }

        private readonly Dictionary<string, string> _yuanyinList = new Dictionary<string, string>()
        {
            {"a","āáǎàa" },
            {"e","ēéěèe" },
            {"i","īíǐìi" },
            {"o","ōóǒòo" },
            {"u","ūúǔùu" },
            {"v","ǖǘǚǜü" },
        };

    class KeyboardHook
    {

        #region win32
        public delegate int HookProc(int nCode, Int32 wParam, IntPtr lParam);
        static int hKeyboardHook = 0; //声明键盘钩子处理的初始值
        public const int WH_KEYBOARD_LL = 13;   //线程键盘钩子监听鼠标消息设为2，全局键盘监听鼠标消息设为13
        HookProc KeyboardHookProcedure; //声明KeyboardHookProcedure作为HookProc类型

        //键盘结构
        [StructLayout(LayoutKind.Sequential)]
        public class KeyboardHookStruct
        {
            public int vkCode;  //定一个虚拟键码。该代码必须有一个价值的范围1至254
            public int scanCode; // 指定的硬件扫描码的关键
            public int flags;  // 键标志
            public int time; // 指定的时间戳记的这个讯息
            public int dwExtraInfo; // 指定额外信息相关的信息
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct INPUT
        {
            public InputType dwType;
            public KEYBDINPUT ki;
        }
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct KEYBDINPUT
        {
            public Int16 wVk;
            public Int16 wScan;
            public KEYEVENTF dwFlags;
            public Int32 time;
            public IntPtr dwExtraInfo;
        }

        public enum KEYEVENTF
        {
            EXTENDEDKEY = 1,
            KEYUP = 2,
            UNICODE = 4,
            SCANCODE = 8,
        }

        //使用此功能，安装了一个钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);


        //调用此函数卸载钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern bool UnhookWindowsHookEx(int idHook);


        //使用此功能，通过信息钩子继续下一个钩子
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern int CallNextHookEx(int idHook, int nCode, Int32 wParam, IntPtr lParam);


        // 取得当前线程编号（线程钩子需要用到）
        [DllImport("kernel32.dll")]
        static extern int GetCurrentThreadId();


        //使用WINDOWS API函数代替获取当前实例的函数,防止钩子失效
        [DllImport("kernel32.dll")]
        public static extern IntPtr GetModuleHandle(string name);




        private const int WM_KEYDOWN = 0x100;//KEYDOWN
        private const int WM_KEYUP = 0x101;//KEYUP
        private const int WM_SYSKEYDOWN = 0x104;//SYSKEYDOWN
        private const int WM_SYSKEYUP = 0x105;//SYSKEYUP

        //ToAscii职能的转换指定的虚拟键码和键盘状态的相应字符或字符
        [DllImport("user32")]
        public static extern int ToAscii(int uVirtKey, //[in] 指定虚拟关键代码进行翻译。
            int uScanCode, // [in] 指定的硬件扫描码的关键须翻译成英文。高阶位的这个值设定的关键，如果是（不压）
            byte[] lpbKeyState, // [in] 指针，以256字节数组，包含当前键盘的状态。每个元素（字节）的数组包含状态的一个关键。如果高阶位的字节是一套，关键是下跌（按下）。在低比特，如果设置表明，关键是对切换。在此功能，只有肘位的CAPS LOCK键是相关的。在切换状态的NUM个锁和滚动锁定键被忽略。
            byte[] lpwTransKey, // [out] 指针的缓冲区收到翻译字符或字符。
            int fuState); // [in] Specifies whether a menu is active. This parameter must be 1 if a menu is active, or 0 otherwise.

        //获取按键的状态
        [DllImport("user32")]
        public static extern int GetKeyboardState(byte[] pbKeyState);


        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        private static extern short GetKeyState(int vKey);

        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        private static extern short GetAsyncKeyState(int vKey);

        [DllImport("user32.dll")]
        internal static extern uint SendInput(uint nInputs,
            [MarshalAs(UnmanagedType.LPArray), In] INPUT[] pInputs,
            int cbSize);

        #endregion


        public event EventHandler<Keys> KeyUpEvent;
        public event Action<int> OnSpaced;
        public event Action OnBacked;
        public event Action<int> OnPaged;

        public void Start()
        {
            // 安装键盘钩子
            if (hKeyboardHook == 0)
            {
                KeyboardHookProcedure = new HookProc(KeyboardHookProc);

                hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProcedure, GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);

                //如果SetWindowsHookEx失败
                if (hKeyboardHook == 0)
                {
                    Stop();
                    throw new Exception("安装键盘钩子失败");
                }
            }
        }
        public void Stop()
        {
            bool retKeyboard = true;


            if (hKeyboardHook != 0)
            {
                retKeyboard = UnhookWindowsHookEx(hKeyboardHook);
                hKeyboardHook = 0;
            }

            if (!retKeyboard)
            {
                throw new Exception("卸载钩子失败！");
            }
        }

        public void Send(string msg)
        {
            if (!string.IsNullOrEmpty(msg))
            {
                Stop();
                SendKeys.SendWait(msg);
                Start();
            }
        }

        bool isLocked = true;

        public bool IsStarted { set; get; }

        /// <summary>
        /// 按键处理
        /// </summary>
        /// <param name="nCode"></param>
        /// <param name="wParam"></param>
        /// <param name="lParam"></param>
        /// <returns>如果返回1，则结束消息，这个消息到此为止，不再传递。如果返回0或调用CallNextHookEx函数则消息出了这个钩子继续往下传递，也就是传给消息真正的接受者</returns>
        private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
        {
            // 侦听键盘事件
            if (nCode >= 0 && wParam == 0x0100)
            {
                KeyboardHookStruct myKeyboardHookStruct = (KeyboardHookStruct) Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));

                if (myKeyboardHookStruct.vkCode == 27)
                {
                    Environment.Exit(1);
                }

                #region
                if (isLocked)
                {
                    #region page
                    if (myKeyboardHookStruct.vkCode == 33)
                    {
                        OnPaged?.Invoke(-1);
                    }
                    if (myKeyboardHookStruct.vkCode == 34)
                    {
                        OnPaged?.Invoke(1);
                    }
                    #endregion

                    if (IsStarted && myKeyboardHookStruct.vkCode >= 48 && myKeyboardHookStruct.vkCode <= 57)
                    {
                        var c = int.Parse(((char) myKeyboardHookStruct.vkCode).ToString());
                        OnSpaced?.Invoke(c);
                        IsStarted = false;
                        return 1;
                    }
                    if (IsStarted && myKeyboardHookStruct.vkCode == 8)
                    {
                        OnBacked?.Invoke();

                        return IsStarted ? 1 : 0;
                    }
                    if ((myKeyboardHookStruct.vkCode >= 65 && myKeyboardHookStruct.vkCode <= 90) || myKeyboardHookStruct.vkCode == 32)
                    {
                        if (myKeyboardHookStruct.vkCode >= 65 && myKeyboardHookStruct.vkCode <= 90)
                        {
                            Keys keyData = (Keys) myKeyboardHookStruct.vkCode;
                            KeyUpEvent?.Invoke(this, keyData);
                            IsStarted = true;
                        }
                        if (myKeyboardHookStruct.vkCode == 32)
                        {
                            IsStarted = true;
                            OnSpaced?.Invoke(0);
                        }
                        return IsStarted ? 1 : 0;
                    }
                    else
                    {
                        return 0;
                    }
                }
                #endregion
            }
            return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
        }
    }

参见：C# 输入法

2019-6-5-WPF-拼音输入法

码农公寓

键盘

解析键盘

获得按键

输入流向

算法

相关文章