碼上快樂

相關內容    簡體    繁體

QT全局熱鍵的實現

本文轉載自   查看原文   2016-07-28 09:26   1831 

QT全局熱鍵的實現

1、加載庫

 
 
 
         
    
  
  
  
          
  1.  QT += gui widgets
    2.

2、加載頭文件

 
 
 
         
    
  
  
  
          
  1. #include"MyGlobalShortCut.h"
    2. 
  
  
  
          
  2. ````
    3. 
  
  
  
          
  3. 3、在main函數添加
    4. 
  
  
  
          
  4. ```C++
    5. 
  
  
  
          
  5.  MyGlobalShortCut *shortcut = new MyGlobalShortCut("Ctrl+F9",&m);
    6. 
  
  
  
          
  6.  QObject::connect(shortcut,SIGNAL(activated()),&m,SLOT(activated()));
    7.

4、添加SLOT頭文件

 
 
 
         
    
  
  
  
          
  1. public slots:
    2. 
  
  
  
          
  2.  void activated();
    3.

5、添加SLOT源文件

 
 
 
         
    
  
  
  
          
  1. void MyDialog::activated()
    2. 
  
  
  
          
  2. {
    3. 
  
  
  
          
  3.  qDebug()<<"2222";
    4. 
  
  
  
          
  4.  QMessageBox::warning(NULL,"ok","OK...OK");
    5. 
  
  
  
          
  5. }
    6.

全局熱鍵實現文件

MyGlobalShortCut.h

 
 
 
         
    
  
  
  
          
    2. 
  
  
  
          
  2. // Qt 升級到5.x版本后
    3. 
  
  
  
          
  3. // QAbstractEventDispatcher 中函數發生變動
    4. 
  
  
  
          
  4. // 導致libqxt庫中的qxtGlobalShortcut掛掉
    5. 
  
  
  
          
  5. // 參考qxtGlobalShortcut寫了一個全局熱鍵類
    6. 
  
  
  
          
  6. // 用法與qxtGlobalShortcut一致
    7. 
  
  
  
          
  7. // 在 Win8.1 + Qt5.11 下能正常使用
    8. 
  
  
  
          
  8. // by 迷路君 2014.03.27
    9. 
  
  
  
          
    10. 
  
  
  
          
  10. #pragma once
    11. 
  
  
  
          
  11. #include <QApplication>
    12. 
  
  
  
          
  12. #include <windows.h>
    13. 
  
  
  
          
  13. #include <MyWinEventFilter.h>
    14. 
  
  
  
          
  14. #include <QKeySequence>
    15. 
  
  
  
          
  15. #include <QHash>
    16. 
  
  
  
          
    17. 
  
  
  
          
  17. class MyGlobalShortCut : public QObject
    18. 
  
  
  
          
  18. {
    19. 
  
  
  
          
  19.  Q_OBJECT
    20. 
  
  
  
          
  20. public:
    21. 
  
  
  
          
    22. 
  
  
  
          
    23. 
  
  
  
          
  23.  MyGlobalShortCut(QString key,QObject* app);
    24. 
  
  
  
          
  24.  ~MyGlobalShortCut();
    25. 
  
  
  
          
  25.  void activateShortcut();
    26. 
  
  
  
          
  26.  bool registerHotKey();
    27. 
  
  
  
          
  27.  bool unregisterHotKey();
    28. 
  
  
  
          
  28.  QHash<QPair<quint32, quint32>, MyGlobalShortCut*> shortcuts;
    29. 
  
  
  
          
  29. private:
    30. 
  
  
  
          
  30.  QApplication *m_app;
    31. 
  
  
  
          
  31.  MyWinEventFilter *m_filter;
    32. 
  
  
  
          
  32.  QKeySequence m_key;
    33. 
  
  
  
          
  33.  Qt::Key key;
    34. 
  
  
  
          
  34.  Qt::KeyboardModifiers mods;
    35. 
  
  
  
          
  35.  static quint32 nativeKeycode(Qt::Key keycode);
    36. 
  
  
  
          
  36.  static quint32 nativeModifiers(Qt::KeyboardModifiers modifiers);
    37. 
  
  
  
          
  37. signals:
    38. 
  
  
  
          
  38.  void activated();
    39. 
  
  
  
          
    40. 
  
  
  
          
  40. };
    41.

MyGlobalShortCut.cpp

 
 
 
         
    
  
  
  
          
  1. #include "MyGlobalShortCut.h"
    2. 
  
  
  
          
    3. 
  
  
  
          
  3. MyGlobalShortCut::~MyGlobalShortCut()
    4. 
  
  
  
          
  4. {
    5. 
  
  
  
          
  5.  unregisterHotKey();
    6. 
  
  
  
          
  6. }
    7. 
  
  
  
          
  7. MyGlobalShortCut::MyGlobalShortCut(QString key, QObject *app)
    8. 
  
  
  
          
  8. {
    9. 
  
  
  
          
  9.  m_key = QKeySequence(key);
    10. 
  
  
  
          
  10.  m_filter = new MyWinEventFilter(this);
    11. 
  
  
  
          
  11.  m_app->installNativeEventFilter(m_filter);
    12. 
  
  
  
          
    13. 
  
  
  
          
    14. 
  
  
  
          
  14.  registerHotKey();
    15. 
  
  
  
          
  15. }
    16. 
  
  
  
          
    17. 
  
  
  
          
  17. void MyGlobalShortCut::activateShortcut()
    18. 
  
  
  
          
  18. {
    19. 
  
  
  
          
  19.  emit activated();
    20. 
  
  
  
          
  20. }
    21. 
  
  
  
          
  21. bool MyGlobalShortCut::registerHotKey()
    22. 
  
  
  
          
  22. {
    23. 
  
  
  
          
  23.  Qt::KeyboardModifiers allMods = Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier | Qt::MetaModifier;
    24. 
  
  
  
          
  24.  key = (m_key.isEmpty() ? Qt::Key(0) : Qt::Key((m_key[0] ^ allMods) & m_key[0]));
    25. 
  
  
  
          
  25.  mods = m_key.isEmpty() ? Qt::KeyboardModifiers(0) : Qt::KeyboardModifiers(m_key[0] & allMods);
    26. 
  
  
  
          
  26.  const quint32 nativeKey = nativeKeycode(key);
    27. 
  
  
  
          
  27.  const quint32 nativeMods = nativeModifiers(mods);
    28. 
  
  
  
          
    29. 
  
  
  
          
  29.  shortcuts.insert(qMakePair(nativeKey, nativeMods),this);
    30. 
  
  
  
          
  30.  return RegisterHotKey(0, nativeMods ^ nativeKey, nativeMods, nativeKey);
    31. 
  
  
  
          
    32. 
  
  
  
          
  32. }
    33. 
  
  
  
          
  33. bool MyGlobalShortCut::unregisterHotKey()
    34. 
  
  
  
          
  34. {
    35. 
  
  
  
          
  35.  return UnregisterHotKey(0, (quint32)nativeModifiers(mods) ^ (quint32)nativeKeycode(key));
    36. 
  
  
  
          
  36. }
    37. 
  
  
  
          
  37. quint32 MyGlobalShortCut::nativeKeycode(Qt::Key key)
    38. 
  
  
  
          
  38. {
    39. 
  
  
  
          
  39.  switch (key)
    40. 
  
  
  
          
  40.  {
    41. 
  
  
  
          
  41.  case Qt::Key_Escape:
    42. 
  
  
  
          
  42.  return VK_ESCAPE;
    43. 
  
  
  
          
  43.  case Qt::Key_Tab:
    44. 
  
  
  
          
  44.  case Qt::Key_Backtab:
    45. 
  
  
  
          
  45.  return VK_TAB;
    46. 
  
  
  
          
  46.  case Qt::Key_Backspace:
    47. 
  
  
  
          
  47.  return VK_BACK;
    48. 
  
  
  
          
  48.  case Qt::Key_Return:
    49. 
  
  
  
          
  49.  case Qt::Key_Enter:
    50. 
  
  
  
          
  50.  return VK_RETURN;
    51. 
  
  
  
          
  51.  case Qt::Key_Insert:
    52. 
  
  
  
          
  52.  return VK_INSERT;
    53. 
  
  
  
          
  53.  case Qt::Key_Delete:
    54. 
  
  
  
          
  54.  return VK_DELETE;
    55. 
  
  
  
          
  55.  case Qt::Key_Pause:
    56. 
  
  
  
          
  56.  return VK_PAUSE;
    57. 
  
  
  
          
  57.  case Qt::Key_Print:
    58. 
  
  
  
          
  58.  return VK_PRINT;
    59. 
  
  
  
          
  59.  case Qt::Key_Clear:
    60. 
  
  
  
          
  60.  return VK_CLEAR;
    61. 
  
  
  
          
  61.  case Qt::Key_Home:
    62. 
  
  
  
          
  62.  return VK_HOME;
    63. 
  
  
  
          
  63.  case Qt::Key_End:
    64. 
  
  
  
          
  64.  return VK_END;
    65. 
  
  
  
          
  65.  case Qt::Key_Left:
    66. 
  
  
  
          
  66.  return VK_LEFT;
    67. 
  
  
  
          
  67.  case Qt::Key_Up:
    68. 
  
  
  
          
  68.  return VK_UP;
    69. 
  
  
  
          
  69.  case Qt::Key_Right:
    70. 
  
  
  
          
  70.  return VK_RIGHT;
    71. 
  
  
  
          
  71.  case Qt::Key_Down:
    72. 
  
  
  
          
  72.  return VK_DOWN;
    73. 
  
  
  
          
  73.  case Qt::Key_PageUp:
    74. 
  
  
  
          
  74.  return VK_PRIOR;
    75. 
  
  
  
          
  75.  case Qt::Key_PageDown:
    76. 
  
  
  
          
  76.  return VK_NEXT;
    77. 
  
  
  
          
  77.  case Qt::Key_F1:
    78. 
  
  
  
          
  78.  return VK_F1;
    79. 
  
  
  
          
  79.  case Qt::Key_F2:
    80. 
  
  
  
          
  80.  return VK_F2;
    81. 
  
  
  
          
  81.  case Qt::Key_F3:
    82. 
  
  
  
          
  82.  return VK_F3;
    83. 
  
  
  
          
  83.  case Qt::Key_F4:
    84. 
  
  
  
          
  84.  return VK_F4;
    85. 
  
  
  
          
  85.  case Qt::Key_F5:
    86. 
  
  
  
          
  86.  return VK_F5;
    87. 
  
  
  
          
  87.  case Qt::Key_F6:
    88. 
  
  
  
          
  88.  return VK_F6;
    89. 
  
  
  
          
  89.  case Qt::Key_F7:
    90. 
  
  
  
          
  90.  return VK_F7;
    91. 
  
  
  
          
  91.  case Qt::Key_F8:
    92. 
  
  
  
          
  92.  return VK_F8;
    93. 
  
  
  
          
  93.  case Qt::Key_F9:
    94. 
  
  
  
          
  94.  return VK_F9;
    95. 
  
  
  
          
  95.  case Qt::Key_F10:
    96. 
  
  
  
          
  96.  return VK_F10;
    97. 
  
  
  
          
  97.  case Qt::Key_F11:
    98. 
  
  
  
          
  98.  return VK_F11;
    99. 
  
  
  
          
  99.  case Qt::Key_F12:
    100. 
  
  
  
          
  100.  return VK_F12;
    101. 
  
  
  
          
  101.  case Qt::Key_F13:
    102. 
  
  
  
          
  102.  return VK_F13;
    103. 
  
  
  
          
  103.  case Qt::Key_F14:
    104. 
  
  
  
          
  104.  return VK_F14;
    105. 
  
  
  
          
  105.  case Qt::Key_F15:
    106. 
  
  
  
          
  106.  return VK_F15;
    107. 
  
  
  
          
  107.  case Qt::Key_F16:
    108. 
  
  
  
          
  108.  return VK_F16;
    109. 
  
  
  
          
  109.  case Qt::Key_F17:
    110. 
  
  
  
          
  110.  return VK_F17;
    111. 
  
  
  
          
  111.  case Qt::Key_F18:
    112. 
  
  
  
          
  112.  return VK_F18;
    113. 
  
  
  
          
  113.  case Qt::Key_F19:
    114. 
  
  
  
          
  114.  return VK_F19;
    115. 
  
  
  
          
  115.  case Qt::Key_F20:
    116. 
  
  
  
          
  116.  return VK_F20;
    117. 
  
  
  
          
  117.  case Qt::Key_F21:
    118. 
  
  
  
          
  118.  return VK_F21;
    119. 
  
  
  
          
  119.  case Qt::Key_F22:
    120. 
  
  
  
          
  120.  return VK_F22;
    121. 
  
  
  
          
  121.  case Qt::Key_F23:
    122. 
  
  
  
          
  122.  return VK_F23;
    123. 
  
  
  
          
  123.  case Qt::Key_F24:
    124. 
  
  
  
          
  124.  return VK_F24;
    125. 
  
  
  
          
  125.  case Qt::Key_Space:
    126. 
  
  
  
          
  126.  return VK_SPACE;
    127. 
  
  
  
          
  127.  case Qt::Key_Asterisk:
    128. 
  
  
  
          
  128.  return VK_MULTIPLY;
    129. 
  
  
  
          
  129.  case Qt::Key_Plus:
    130. 
  
  
  
          
  130.  return VK_ADD;
    131. 
  
  
  
          
  131.  case Qt::Key_Comma:
    132. 
  
  
  
          
  132.  return VK_SEPARATOR;
    133. 
  
  
  
          
  133.  case Qt::Key_Minus:
    134. 
  
  
  
          
  134.  return VK_SUBTRACT;
    135. 
  
  
  
          
  135.  case Qt::Key_Slash:
    136. 
  
  
  
          
  136.  return VK_DIVIDE;
    137. 
  
  
  
          
    138. 
  
  
  
          
  138.  // numbers
    139. 
  
  
  
          
  139.  case Qt::Key_0:
    140. 
  
  
  
          
  140.  case Qt::Key_1:
    141. 
  
  
  
          
  141.  case Qt::Key_2:
    142. 
  
  
  
          
  142.  case Qt::Key_3:
    143. 
  
  
  
          
  143.  case Qt::Key_4:
    144. 
  
  
  
          
  144.  case Qt::Key_5:
    145. 
  
  
  
          
  145.  case Qt::Key_6:
    146. 
  
  
  
          
  146.  case Qt::Key_7:
    147. 
  
  
  
          
  147.  case Qt::Key_8:
    148. 
  
  
  
          
  148.  case Qt::Key_9:
    149. 
  
  
  
          
  149.  return key;
    150. 
  
  
  
          
    151. 
  
  
  
          
  151.  // letters
    152. 
  
  
  
          
  152.  case Qt::Key_A:
    153. 
  
  
  
          
  153.  case Qt::Key_B:
    154. 
  
  
  
          
  154.  case Qt::Key_C:
    155. 
  
  
  
          
  155.  case Qt::Key_D:
    156. 
  
  
  
          
  156.  case Qt::Key_E:
    157. 
  
  
  
          
  157.  case Qt::Key_F:
    158. 
  
  
  
          
  158.  case Qt::Key_G:
    159. 
  
  
  
          
  159.  case Qt::Key_H:
    160. 
  
  
  
          
  160.  case Qt::Key_I:
    161. 
  
  
  
          
  161.  case Qt::Key_J:
    162. 
  
  
  
          
  162.  case Qt::Key_K:
    163. 
  
  
  
          
  163.  case Qt::Key_L:
    164. 
  
  
  
          
  164.  case Qt::Key_M:
    165. 
  
  
  
          
  165.  case Qt::Key_N:
    166. 
  
  
  
          
  166.  case Qt::Key_O:
    167. 
  
  
  
          
  167.  case Qt::Key_P:
    168. 
  
  
  
          
  168.  case Qt::Key_Q:
    169. 
  
  
  
          
  169.  case Qt::Key_R:
    170. 
  
  
  
          
  170.  case Qt::Key_S:
    171. 
  
  
  
          
  171.  case Qt::Key_T:
    172. 
  
  
  
          
  172.  case Qt::Key_U:
    173. 
  
  
  
          
  173.  case Qt::Key_V:
    174. 
  
  
  
          
  174.  case Qt::Key_W:
    175. 
  
  
  
          
  175.  case Qt::Key_X:
    176. 
  
  
  
          
  176.  case Qt::Key_Y:
    177. 
  
  
  
          
  177.  case Qt::Key_Z:
    178. 
  
  
  
          
  178.  return key;
    179. 
  
  
  
          
    180. 
  
  
  
          
  180.  default:
    181. 
  
  
  
          
  181.  return 0;
    182. 
  
  
  
          
  182.  }
    183. 
  
  
  
          
  183. }
    184. 
  
  
  
          
  184. quint32 MyGlobalShortCut::nativeModifiers(Qt::KeyboardModifiers modifiers)
    185. 
  
  
  
          
  185. {
    186. 
  
  
  
          
  186.  // MOD_ALT, MOD_CONTROL, (MOD_KEYUP), MOD_SHIFT, MOD_WIN
    187. 
  
  
  
          
  187.  quint32 native = 0;
    188. 
  
  
  
          
  188.  if (modifiers & Qt::ShiftModifier)
    189. 
  
  
  
          
  189.  native |= MOD_SHIFT;
    190. 
  
  
  
          
  190.  if (modifiers & Qt::ControlModifier)
    191. 
  
  
  
          
  191.  native |= MOD_CONTROL;
    192. 
  
  
  
          
  192.  if (modifiers & Qt::AltModifier)
    193. 
  
  
  
          
  193.  native |= MOD_ALT;
    194. 
  
  
  
          
  194.  if (modifiers & Qt::MetaModifier)
    195. 
  
  
  
          
  195.  native |= MOD_WIN;
    196. 
  
  
  
          
  196.  // TODO: resolve these?
    197. 
  
  
  
          
  197.  //if (modifiers & Qt::KeypadModifier)
    198. 
  
  
  
          
  198.  //if (modifiers & Qt::GroupSwitchModifier)
    199. 
  
  
  
          
  199.  return native;
    200. 
  
  
  
          
  200. }
    201.

MyWinEventFilter.h

 
 
 
         
    
  
  
  
          
  1. #pragma once
    2. 
  
  
  
          
  2. #include <QAbstractNativeEventFilter>
    3. 
  
  
  
          
    4. 
  
  
  
          
  4. class MyGlobalShortCut;
    5. 
  
  
  
          
    6. 
  
  
  
          
  6. class MyWinEventFilter : public QAbstractNativeEventFilter
    7. 
  
  
  
          
  7. {
    8. 
  
  
  
          
  8. public:
    9. 
  
  
  
          
  9.  MyWinEventFilter(MyGlobalShortCut *shortcut);
    10. 
  
  
  
          
  10.  ~MyWinEventFilter();
    11. 
  
  
  
          
  11.  virtual bool nativeEventFilter(const QByteArray &eventType, void *message, long *);
    12. 
  
  
  
          
  12. private:
    13. 
  
  
  
          
  13.  MyGlobalShortCut *m_shortcut;
    14. 
  
  
  
          
  14. };
    15.

MyWinEventFilter.cpp

 
 
 
         
    
  
  
  
          
  1. #include <MyWinEventFilter.h>
    2. 
  
  
  
          
  2. #include <MyGlobalShortCut.h>
    3. 
  
  
  
          
    4. 
  
  
  
          
    5. 
  
  
  
          
  5. MyWinEventFilter::~MyWinEventFilter()
    6. 
  
  
  
          
  6. {
    7. 
  
  
  
          
    8. 
  
  
  
          
  8. }
    9. 
  
  
  
          
    10. 
  
  
  
          
  10. MyWinEventFilter::MyWinEventFilter(MyGlobalShortCut *shortcut)
    11. 
  
  
  
          
  11.  : m_shortcut(shortcut)
    12. 
  
  
  
          
  12. {
    13. 
  
  
  
          
    14. 
  
  
  
          
  14. }
    15. 
  
  
  
          
    16. 
  
  
  
          
    17. 
  
  
  
          
  17. bool MyWinEventFilter::nativeEventFilter(const QByteArray &eventType, void *message, long *)
    18. 
  
  
  
          
  18. {
    19. 
  
  
  
          
  19.  if(eventType == "windows_generic_MSG")
    20. 
  
  
  
          
  20.  {
    21. 
  
  
  
          
  21.  MSG *msg = static_cast<MSG *>(message);
    22. 
  
  
  
          
  22.  if(msg->message == WM_HOTKEY)
    23. 
  
  
  
          
  23.  {
    24. 
  
  
  
          
  24. // if(msg->wParam == VK_F10)
    25. 
  
  
  
          
  25. // {
    26. 
  
  
  
          
  26. // m_shortcut->activateShortcut();
    27. 
  
  
  
          
  27. // return true;
    28. 
  
  
  
          
  28. // }
    29. 
  
  
  
          
  29.  const quint32 keycode = HIWORD(msg->lParam);
    30. 
  
  
  
          
  30.  const quint32 modifiers = LOWORD(msg->lParam);
    31. 
  
  
  
          
  31.  bool res = m_shortcut->shortcuts.value(qMakePair(keycode, modifiers));
    32. 
  
  
  
          
  32.  if(res)
    33. 
  
  
  
          
  33.  {
    34. 
  
  
  
          
  34.  m_shortcut ->activateShortcut();
    35. 
  
  
  
          
  35.  return true;
    36. 
  
  
  
          
  36.  }
    37. 
  
  
  
          
  37.  }
    38. 
  
  
  
          
    39. 
  
  
  
          
  39.  }
    40. 
  
  
  
          
  40.  return false;
    41. 
  
  
  
          
  41. }
    42.





免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 Qt5全局熱鍵-QxtGlobalShortcut Qt全局熱鍵(windows篇) C# 實現全局監視熱鍵( 鍵盤按下事件) Java設置全局熱鍵——第三方包jintellitype實現 C# 全局熱鍵 Delphi全局熱鍵的注冊 Qt5全局熱鍵第三方庫qxtglobalshortcut5使用 c# 注冊全局熱鍵 C#實現全局快捷鍵(系統熱鍵)響應(轉) C# 全局熱鍵設置 與 窗體熱鍵設置
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM