1 捕获键盘

(1) 在头文件中声明

  1. typedef struct HOTKEYINFORMATION {
  2.     int identification; //标识
  3.     unsigned long childevent; //事件子程序
  4.     int normalkey; //普通键
  5.     int functionkey; //功能键
  6.     int otherkey; //其他键
  7.     BYTE keystate; //键状态
  8.     bool state; //状态
  9.     bool directlytrigger;//直接触发
  10. }HKI;
  11. void MonitorHotkeyThreads();
  12. int MonitorTheHotkey(DWORD Event, int keycode, int functionstate = 0, int otherkey  = 0, int period = 10, bool directlytrigger = false);

(2) 在cpp中定义

  1. vector<HKI> HotKeyInformation;
  2. void MonitorHotkeyThreads()
  3. {
  4.        DWORD TempEvent;
  5.        int tempidentification, tempvalue, BYTETemp;
  6.        short cachstate[256];
  7.        for (int i = 0; i < 255; ++i)
  8.        {
  9.               cachstate[i] = 251; //防检测
  10.               cachstate[i] = GetAsyncKeyState(i);
  11.        }
  12.        for (vector<HKI>::iterator it = HotKeyInformation.begin(); it !=  HotKeyInformation.end(); ++it)
  13.        {
  14.               if (it->identification)
  15.               {
  16.                      BYTETemp = (BYTE)it->normalkey;
  17.                      BYTETemp = cachstate[BYTETemp];
  18.                      if (BYTETemp == 0) //无状态
  19.                      {
  20.                            if (it->keystate == 1)
  21.                            {
  22.                                   it->keystate = 2;
  23.                            }
  24.                            else
  25.                            {
  26.                                   it->keystate = 0;
  27.                                   continue; //如果啥键也没有按一直做状态判断循环
  28.                            }
  29.                      }
  30.                      if (BYTETemp < 0) //按下状态
  31.                      {
  32.                            if (it->keystate == 0)
  33.                            {
  34.                                   it->keystate = 1;
  35.                            }
  36.                            if (it->normalkey < 0)
  37.                            {
  38.                                   continue;
  39.                            }
  40.                      }
  41.                      /*监视热键_信息 [i].功能键 ＝ 选择 (缓存键状态 [18] ＜ 0, 1, 0)  ＋ 选择 (缓存键状态 [17] ＜ 0, 2, 0) ＋ 选择 (缓存键状态 [16] ＜ 0, 4, 0) ＋ 选择 (缓存键状态 [91] ＜ 0, 8, 0))*/
  42.                      if (it->keystate > 0 && it->keystate != 88)
  43.                      {
  44.                            it->keystate = 88;
  45.                            tempvalue = (cachstate[18] < 0 ? 1 : 0) +  (cachstate[17] < 0 ? 2 : 0) + (cachstate[16] < 0 ? 4 : 0) + (cachstate[91] < 0 ? 8  : 0);
  46.                            if (tempvalue == it->functionkey)
  47.                            {
  48.                                   if (it->otherkey != 0)
  49.                                   {
  50.                                          BYTETemp = (BYTE)abs(it->otherkey);
  51.                                          if (cachstate[BYTETemp] >= 0)
  52.                                          {
  53.                                                 continue;
  54.                                          }
  55.                                   }
  56.                                   TempEvent = it->childevent;
  57.                                   tempidentification = it->identification;
  58.                                   if (it->directlytrigger)
  59.                                   {
  60.                                          CallWindowProc((WNDPROC)TempEvent,  (HWND)tempidentification, 0, 0, 0);
  61.                                   }
  62.                                   else
  63.                                   {
  64.                                          HANDLE handle =  (HANDLE)_beginthreadex(nullptr, 0, (_beginthreadex_proc_type)TempEvent, nullptr,  0, nullptr);
  65.                                          CloseHandle(handle);
  66.                                   }
  67.                            }
  68.                      }
  69.               }
  70.        }
  71. }
  73. int MonitorTheHotkey(DWORD Event, int keycode, int functionstate /*= 0*/, int  otherkey /*= 0*/, int period /*= 10*/, bool directlytrigger /*= false*/)
  74. {
  75.        HKI TempHotKeyInformation;
  76.        if ((BYTE)keycode <= 0)
  77.        {
  78.               return 0;
  79.        }
  80.        for (vector<HKI>::iterator it = HotKeyInformation.begin(); it !=  HotKeyInformation.end(); ++it)
  81.        {
  82.               if (it->normalkey == keycode && it->functionkey == functionstate &&  it->otherkey == otherkey)
  83.               {
  84.                      it->childevent = Event;
  85.                      it->directlytrigger = directlytrigger;
  86.                      if (it->identification != 0)
  87.                      {
  88.                            return it->identification;
  89.                      }
  90.                      it->identification = (it - HotKeyInformation.begin()) +  1000001;
  91.                      return it->identification;
  92.               }
  93.        }
  94.        TempHotKeyInformation.childevent = Event;
  95.        TempHotKeyInformation.normalkey = keycode;
  96.        TempHotKeyInformation.functionkey = functionstate;
  97.        TempHotKeyInformation.otherkey = otherkey;
  98.        TempHotKeyInformation.directlytrigger = directlytrigger;
  99.        TempHotKeyInformation.identification = HotKeyInformation.size() + 1000001;
  100.        HotKeyInformation.push_back(TempHotKeyInformation);//将临时的加入里面
  101.        if (TempHotKeyInformation.identification == 1000001)
  102.        {
  103.               SetTimer(NULL, 661, period, (TIMERPROC)MonitorHotkeyThreads);
  104.        }
  105.        return TempHotKeyInformation.identification;
  106. }

(3) 在窗口构造函数中加入
MonitorTheHotkey((DWORD)HTK_RUN_Event, VK_HOME); // 捕获HOME热键

2 Qt注册全局热键

(注: 如果用的是静态编绎的Qt库, 则注册的热键无效)
1 添加user32.lib(用Vs时可跳过此步, 用Qt Creator需要在pro中加入)
image.png

2 注册全局热键
image.png

3 添加nativeEvent函数来接收系统消息
image.png

4 扩展, 更改热键

  1. connect(ui.HTKE_RUN, &QKeySequenceEdit::keySequenceChanged, [=](const QKeySequence  &keySequence) {
  2.               QKeySequence Key_RUN = ui.HTKE_RUN->keySequence();
  3.               qDebug() << Key_RUN;
  4.               QString str = Key_RUN.toString();
  5.               qDebug() << str;
  6.               QStringList strLst = str.split('+');
  7.               QString str_MOD, str_VK = NULL;
  8.               if (strLst[0].compare("Ctrl") == 0)
  9.               {
  10.                      str_MOD = MOD_CONTROL;
  11.                      str_VK = strLst[1];
  12.               }
  13. });

5 扩展,添加热键事件

  1. bool KingHonor::nativeEvent(const QByteArray & eventType, void * message, long *  result)
  2. {
  3.        if (eventType == "windows_generic_MSG")
  4.        {
  5.               MSG* pMsg = reinterpret_cast<MSG*>(message);
  6.               if (pMsg->message == WM_HOTKEY)
  7.               {
  8.                      if (pMsg->wParam == HTK_RUN)
  9.                      {
  10.                            qDebug() << "------------HTK_RUN 被按下-----------";
  11.                            HTK_RUN_Event();
  12.                      }
  13.                      else if (pMsg->wParam == HTK_STOP)
  14.                      {
  15.                            qDebug() << "------------HTK_STOP 被按下------------";
  16.                            HTK_STOP_Event();
  17.                      }
  18.                      else if (pMsg->wParam == HTK_END)
  19.                      {
  20.                            qDebug() << "------------HTK_END 被按下------------";
  21.                            HTK_END_Event();
  22.                      }
  23.               }
  24.        }
  25.        return QWidget::nativeEvent(eventType, message, result);
  26. }

3 pyqt注册全局热键

  1. import win32con
  2. import ctypes
  3. import ctypes.wintypes
  4. from threading import Thread,activeCount, enumerate
  5. from time import sleep,time
  7. class Hotkey(Thread):
  8.     user32 = ctypes.windll.user32
  9.     hkey_list = {}
  10.     hkey_flags = {} #按下
  11.     hkey_running = {} #启停
  12.     _reg_list = {} #待注册热键信息
  14.     def regiskey(self, hwnd=None, flagid=0, fnkey=win32con.MOD_ALT, vkey=win32con.VK_F9): # 注册热键，默认一个alt+F9
  15.         return self.user32.RegisterHotKey(hwnd, flagid, fnkey, vkey)
  17.     def get_reginfo(self):
  18.         return self._reg_list
  20.     def get_id(self,func):
  21.         self_id = None
  22.         for id in self.get_reginfo():
  23.             if self.get_reginfo()[id]["func"] == func:
  24.                 self_id = id
  25.                 break
  26.         if self_id:
  27.             self.hkey_running[self_id] = True
  28.         return self_id
  30.     def get_running_state(self,self_id):
  31.         if self.hkey_running.get(self_id):
  32.             return self.hkey_running[self_id]
  33.         else:
  34.             return False
  36.     def reg(self,key,func,args=None):
  37.         id = int(str(round(time()*10))[-6:])
  38.         fnkey = key[0]
  39.         vkey = key[1]
  40.         info = {
  41.             "fnkey":fnkey,
  42.             "vkey":vkey,
  43.             "func":func,
  44.             "args":args
  45.         }
  46.         self._reg_list[id] = info
  47.         # print(info) #这里待注册的信息
  48.         sleep(0.1)
  49.         return id
  51.     def fast_reg(self,id,key = (0,win32con.VK_HOME),func = lambda:print('热键注册开始')):
  52.         if not self.regiskey(None, id, key[0], key[1]):
  53.             print("热键注册失败")
  54.             return None
  55.         self.hkey_list[id] = func
  56.         self.hkey_flags[id] = False
  57.         return id
  59.     def callback(self):
  60.         def inner(self = self):
  61.             for flag in self.hkey_flags:
  62.                 self.hkey_flags[flag] = False
  64.             while True:
  65.                 for id, func in self.hkey_list.items():
  66.                     if self.hkey_flags[id]:
  67.                         args = self._reg_list[id]["args"]
  68.                         if args:
  69.                             # print(args)    #这里打印传入给注册函数的参数
  70.                             thread_it(func,*args)
  71.                         else:
  72.                             thread_it(func)
  73.                         self.hkey_flags[id] = False
  74.         return inner
  76.     def run(self):
  77.         for id in self._reg_list:
  78.             reg_info = self._reg_list[id]
  79.             fnkey = reg_info["fnkey"]
  80.             vkey = reg_info["vkey"]
  81.             func = reg_info["func"]
  82.             self.fast_reg(id,(fnkey, vkey), func)
  84.         fn = self.callback()
  85.         thread_it(fn) # 启动监听热键按下线程
  87.         try:
  88.             msg = ctypes.wintypes.MSG()
  89.             while True:
  90.                 if self.user32.GetMessageA(ctypes.byref(msg), None, 0, 0) != 0:
  91.                     if msg.message == win32con.WM_HOTKEY:
  92.                         if msg.wParam in self.hkey_list:
  93.                             self.hkey_flags[msg.wParam] = True
  94.                     self.user32.TranslateMessage(ctypes.byref(msg))
  95.                     self.user32.DispatchMessageA(ctypes.byref(msg))
  96.         finally:
  97.             for id in self.hkey_list:
  98.                 self.user32.UnregisterHotKey(None, id)
  100. def thread_it(func, *args):
  101.     t = Thread(target=func, args=args)
  102.     t.setDaemon(True)
  103.     t.start()
  105. def jump(func,hotkey):
  106.     self_id = hotkey.get_id(func)
  107.     while hotkey.get_running_state(self_id):
  108.         print(f"{self_id : } 你正在1秒1次的跳动")
  109.         sleep(1)
  111. def stop_jump(start_id,hotkey):
  112.     hotkey.hkey_running[start_id] = False
  113.     print(f"{start_id} 即将停止")
  114.     sleep(1)
  115.     print(f'当前线程列表:{activeCount()}', enumerate())
  117. def main():
  118.     hotkey = Hotkey()
  119.     start_id = hotkey.reg(key = (win32con.MOD_ALT,win32con.VK_HOME),func=jump,args=(jump,hotkey)) #alt home键 开始
  120.     hotkey.reg(key = (0,win32con.VK_END),func=stop_jump,args=(start_id,hotkey)) #alt end键 结束
  121.     hotkey.start() #启动热键主线程
  123.     print(f"当前总线程数量:{activeCount()}")
  124.     print('当前线程列表:', enumerate())
  125.     print('热键注册初始化完毕，尝试按组合键alt+Home 或者单键END看效果')
  127. if __name__ == '__main__':
  128.     main()