程序博客网 > 手机设置网络共享

Qt事件处理机制

来源：互联网 发布：手机设置网络共享 编辑：程序博客网 时间：2024/06/02 07:29
 

本篇来介绍Qt 事件处理机制 。深入了解事件处理系统对于每个学习Qt人来说非常重要，可以说，Qt是以事件驱动的UI工具集。 大家熟知Signals/Slots在多线程的实现也依赖于Qt的事件处理机制。

在Qt中，事件被封装成一个个对象，所有的事件均继承自抽象类QEvent. 接下来依次谈谈Qt中有谁来产生、分发、接受和处理事件：

1、谁来产生事件： 最容易想到的是我们的输入设备，比如键盘、鼠标产生的

keyPressEvent，keyReleaseEvent，mousePressEvent，mouseReleaseEvent事件（他们被封装成QMouseEvent和QKeyEvent），这些事件来自于底层的操作系统，它们以异步的形式通知Qt事件处理系统，后文会仔细道来。当然Qt自己也会产生很多事件，比如QObject::startTimer()会触发QTimerEvent. 用户的程序可还以自己定制事件。

2、谁来接受和处理事件：答案是QObject。在Qt的内省机制剖析一文已经介绍QObject 类是整个Qt对象模型的心脏，事件处理机制是QObject三大职责（内存管理、内省(intropection)与事件处理制）之一。任何一个想要接受并处理事件的对象均须继承自QObject，可以选择重载QObject::event()函数或事件的处理权转给父类。

3、谁来负责分发事件：对于non-GUI的Qt程序，是由QCoreApplication负责将QEvent分发给QObject的子类-Receiver. 对于Qt GUI程序，由QApplication来负责。

接下来，将通过对代码的解析来看看QT是利用event loop从事件队列中获取用户输入事件，又是如何将事件转义成QEvents，并分发给相应的QObject处理。

  1. #include <QApplication>     
  2. #include "widget.h"     
  3. //Section 1     
  4. int main(int argc, char *argv[])     
  5. {     
  6.     QApplication app(argc, argv);     
  7.     Widget window;  // Widget 继承自QWidget     
  8.     window.show();     
  9.     return app.exec(); // 进入Qpplication事件循环，见section 2     
  10. }     
  11. // Section 2:      
  12. int QApplication::exec()     
  13. {     
  14.    //skip codes     
  15.    //简单的交给QCoreApplication来处理事件循环=〉section 3     
  16.    return QCoreApplication::exec();     
  17. }     
  18. // Section 3     
  19. int QCoreApplication::exec()     
  20. {     
  21.     //得到当前Thread数据     
  22.     QThreadData *threadData = self->d_func()->threadData;     
  23.     if (threadData != QThreadData::current()) {     
  24.         qWarning("%s::exec: Must be called from the main thread", self->metaObject()->className());     
  25.         return -1;     
  26.     }     
  27.     //检查event loop是否已经创建     
  28.     if (!threadData->eventLoops.isEmpty()) {     
  29.         qWarning("QCoreApplication::exec: The event loop is already running");     
  30.         return -1;     
  31.     }     
  32.     ...     
  33.     QEventLoop eventLoop;     
  34.     self->d_func()->in_exec = true;     
  35.     self->d_func()->aboutToQuitEmitted = false;     
  36.     //委任QEventLoop 处理事件队列循环 ==> Section 4     
  37.     int returnCode = eventLoop.exec();     
  38.     ....     
  39.     }     
  40.     return returnCode;     
  41. }     
  42. // Section 4     
  43. int QEventLoop::exec(ProcessEventsFlags flags)     
  44. {     
  45.    //这里的实现代码不少，最为重要的是以下几行     
  46.    Q_D(QEventLoop); // 访问QEventloop私有类实例d     
  47.         try {     
  48.         //只要没有遇见exit，循环派发事件     
  49.         while (!d->exit)     
  50.             processEvents(flags | WaitForMoreEvents | EventLoopExec);     
  51.     } catch (...) {}     
  52. }     
  53. // Section 5     
  54. bool QEventLoop::processEvents(ProcessEventsFlags flags)     
  55. {     
  56.     Q_D(QEventLoop);     
  57.     if (!d->threadData->eventDispatcher)     
  58.         return false;     
  59.     if (flags & DeferredDeletion)     
  60.         QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);     
  61.     //将事件派发给与平台相关的QAbstractEventDispatcher子类 =>Section 6     
  62.     return d->threadData->eventDispatcher->processEvents(flags);     
  63. }    
  64. #include <QApplication> 
  65. #include "widget.h"  
  66. //Section 1  
  67. int main(int argc, char *argv[])  
  68. {  
  69.     QApplication app(argc, argv);  
  70.     Widget window;  // Widget 继承自QWidget  
  71.     window.show();  
  72.     return app.exec(); // 进入Qpplication事件循环，见section 2  
  73. }  
  74. // Section 2:   
  75. int QApplication::exec()  
  76. {  
  77.    //skip codes  
  78.    //简单的交给QCoreApplication来处理事件循环=〉section 3  
  79.    return QCoreApplication::exec();  
  80. }  
  81. // Section 3  
  82. int QCoreApplication::exec()  
  83. {  
  84.     //得到当前Thread数据  
  85.     QThreadData *threadData = self->d_func()->threadData;  
  86.     if (threadData != QThreadData::current()) {  
  87.         qWarning("%s::exec: Must be called from the main thread", self->metaObject()->className());  
  88.         return -1;  
  89.     }  
  90.     //检查event loop是否已经创建  
  91.     if (!threadData->eventLoops.isEmpty()) {  
  92.         qWarning("QCoreApplication::exec: The event loop is already running");  
  93.         return -1;  
  94.     }  
  95.     ...  
  96.     QEventLoop eventLoop;  
  97.     self->d_func()->in_exec = true;  
  98.     self->d_func()->aboutToQuitEmitted = false;  
  99.     //委任QEventLoop 处理事件队列循环 ==> Section 4  
  100.     int returnCode = eventLoop.exec();  
  101.     ....  
  102.     }  
  103.     return returnCode;  
  104. }  
  105. // Section 4  
  106. int QEventLoop::exec(ProcessEventsFlags flags)  
  107. {  
  108.    //这里的实现代码不少，最为重要的是以下几行  
  109.    Q_D(QEventLoop); // 访问QEventloop私有类实例d  
  110.         try {  
  111.         //只要没有遇见exit，循环派发事件  
  112.         while (!d->exit)  
  113.             processEvents(flags | WaitForMoreEvents | EventLoopExec);  
  114.     } catch (...) {}  
  115. }  
  116. // Section 5  
  117. bool QEventLoop::processEvents(ProcessEventsFlags flags)  
  118. {  
  119.     Q_D(QEventLoop);  
  120.     if (!d->threadData->eventDispatcher)  
  121.         return false;  
  122.     if (flags & DeferredDeletion)  
  123.         QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);  
  124.     //将事件派发给与平台相关的QAbstractEventDispatcher子类 =>Section 6  
  125.     return d->threadData->eventDispatcher->processEvents(flags);  
  126. }  
  127.    
  128. // Section 6，QTDIR\src\corelib\kernel\qeventdispatcher_win.cpp     
  129. // 这段代码是完成与windows平台相关的windows c++。 以跨平台著称的Qt同时也提供了对Symiban,Unix等平台的消息派发支持     
  130. // 其事现分别封装在QEventDispatcherSymbian和QEventDispatcherUNIX     
  131. // QEventDispatcherWin32派生自QAbstractEventDispatcher.     
  132. bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)     
  133. {     
  134.     Q_D(QEventDispatcherWin32);     
  135.     if (!d->internalHwnd)     
  136.         createInternalHwnd();     
  137.     d->interrupt = false;     
  138.     emit awake();     
  139.     bool canWait;     
  140.     bool retVal = false;     
  141.     bool seenWM_QT_SENDPOSTEDEVENTS = false;     
  142.     bool needWM_QT_SENDPOSTEDEVENTS = false;     
  143.     do {     
  144.         DWORD waitRet = 0;     
  145.         HANDLE pHandles[MAXIMUM_WAIT_OBJECTS - 1];     
  146.         QVarLengthArray<MSG> processedTimers;     
  147.         while (!d->interrupt) {     
  148.             DWORD nCount = d->winEventNotifierList.count();     
  149.             Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);     
  150.             MSG msg;     
  151.             bool haveMessage;     
  152.             if (!(flags & QEventLoop::ExcludeUserInputEvents) && !d->queuedUserInputEvents.isEmpty()) {     
  153.                 // process queued user input events     
  154.                 haveMessage = true;     
  155.                 //从处理用户输入队列中取出一条事件     
  156.                 msg = d->queuedUserInputEvents.takeFirst();     
  157.             } else if(!(flags & QEventLoop::ExcludeSocketNotifiers) && !d->queuedSocketEvents.isEmpty()) {     
  158.                 // 从处理socket队列中取出一条事件     
  159.                 haveMessage = true;     
  160.                 msg = d->queuedSocketEvents.takeFirst();     
  161.             } else {     
  162.                 haveMessage = PeekMessage(&msg, 0, 0, 0, PM_REMOVE);     
  163.                 if (haveMessage && (flags & QEventLoop::ExcludeUserInputEvents)     
  164.                     && ((msg.message >= WM_KEYFIRST     
  165.                          && msg.message <= WM_KEYLAST)     
  166.                         || (msg.message >= WM_MOUSEFIRST     
  167.                             && msg.message <= WM_MOUSELAST)     
  168.                         || msg.message == WM_MOUSEWHEEL     
  169.                         || msg.message == WM_MOUSEHWHEEL     
  170.                         || msg.message == WM_TOUCH     
  171. #ifndef QT_NO_GESTURES     
  172.                         || msg.message == WM_GESTURE     
  173.                         || msg.message == WM_GESTURENOTIFY     
  174. #endif     
  175.                         || msg.message == WM_CLOSE)) {     
  176.                     // 用户输入事件入队列，待以后处理     
  177.                     haveMessage = false;     
  178.                     d->queuedUserInputEvents.append(msg);     
  179.                 }     
  180.                 if (haveMessage && (flags & QEventLoop::ExcludeSocketNotifiers)     
  181.                     && (msg.message == WM_QT_SOCKETNOTIFIER && msg.hwnd == d->internalHwnd)) {     
  182.                     // socket 事件入队列，待以后处理     
  183.                     haveMessage = false;     
  184.                     d->queuedSocketEvents.append(msg);     
  185.                 }     
  186.             }     
  187.             ....     
  188.                 if (!filterEvent(&msg)) {     
  189.                     TranslateMessage(&msg);     
  190.                     //将事件打包成message调用Windows API派发出去     
  191.                        //分发一个消息给窗口程序。消息被分发到回调函数，将消息传递给windows系统，windows处理完毕，会调用回调函数 => section 7                         
  192.                   DispatchMessage(&msg);     
  193.                 }     
  194.             }                  
  195.         }     
  196.     } while (canWait);     
  197.       ...     
  198.     return retVal;     
  199. }    
  200. // Section 6，QTDIR\src\corelib\kernel\qeventdispatcher_win.cpp  
  201. // 这段代码是完成与windows平台相关的windows c++。 以跨平台著称的Qt同时也提供了对Symiban,Unix等平台的消息派发支持  
  202. // 其事现分别封装在QEventDispatcherSymbian和QEventDispatcherUNIX  
  203. // QEventDispatcherWin32派生自QAbstractEventDispatcher.  
  204. bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)  
  205. {  
  206.     Q_D(QEventDispatcherWin32);  
  207.     if (!d->internalHwnd)  
  208.         createInternalHwnd();  
  209.     d->interrupt = false;  
  210.     emit awake();  
  211.     bool canWait;  
  212.     bool retVal = false;  
  213.     bool seenWM_QT_SENDPOSTEDEVENTS = false;  
  214.     bool needWM_QT_SENDPOSTEDEVENTS = false;  
  215.     do {  
  216.         DWORD waitRet = 0;  
  217.         HANDLE pHandles[MAXIMUM_WAIT_OBJECTS - 1];  
  218.         QVarLengthArray<MSG> processedTimers;  
  219.         while (!d->interrupt) {  
  220.             DWORD nCount = d->winEventNotifierList.count();  
  221.             Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);  
  222.             MSG msg;  
  223.             bool haveMessage;  
  224.             if (!(flags & QEventLoop::ExcludeUserInputEvents) && !d->queuedUserInputEvents.isEmpty()) {  
  225.                 // process queued user input events  
  226.                 haveMessage = true;  
  227.                 //从处理用户输入队列中取出一条事件  
  228.                 msg = d->queuedUserInputEvents.takeFirst();  
  229.             } else if(!(flags & QEventLoop::ExcludeSocketNotifiers) && !d->queuedSocketEvents.isEmpty()) {  
  230.                 // 从处理socket队列中取出一条事件  
  231.                 haveMessage = true;  
  232.                 msg = d->queuedSocketEvents.takeFirst();  
  233.             } else {  
  234.                 haveMessage = PeekMessage(&msg, 0, 0, 0, PM_REMOVE);  
  235.                 if (haveMessage && (flags & QEventLoop::ExcludeUserInputEvents)  
  236.                     && ((msg.message >= WM_KEYFIRST  
  237.                          && msg.message <= WM_KEYLAST)  
  238.                         || (msg.message >= WM_MOUSEFIRST  
  239.                             && msg.message <= WM_MOUSELAST)  
  240.                         || msg.message == WM_MOUSEWHEEL  
  241.                         || msg.message == WM_MOUSEHWHEEL  
  242.                         || msg.message == WM_TOUCH  
  243. #ifndef QT_NO_GESTURES  
  244.                         || msg.message == WM_GESTURE  
  245.                         || msg.message == WM_GESTURENOTIFY  
  246. #endif  
  247.                         || msg.message == WM_CLOSE)) {  
  248.                     // 用户输入事件入队列，待以后处理  
  249.                     haveMessage = false;  
  250.                     d->queuedUserInputEvents.append(msg);  
  251.                 }  
  252.                 if (haveMessage && (flags & QEventLoop::ExcludeSocketNotifiers)  
  253.                     && (msg.message == WM_QT_SOCKETNOTIFIER && msg.hwnd == d->internalHwnd)) {  
  254.                     // socket 事件入队列，待以后处理  
  255.                     haveMessage = false;  
  256.                     d->queuedSocketEvents.append(msg);  
  257.                 }  
  258.             }  
  259.             ....  
  260.                 if (!filterEvent(&msg)) {  
  261.                     TranslateMessage(&msg);  
  262.                     //将事件打包成message调用Windows API派发出去  
  263.                        //分发一个消息给窗口程序。消息被分发到回调函数，将消息传递给windows系统，windows处理完毕，会调用回调函数 => section 7                      
  264.                   DispatchMessage(&msg);  
  265.                 }  
  266.             }               
  267.         }  
  268.     } while (canWait);  
  269.       ...  
  270.     return retVal;  
  271. }   
  272.  
  273. // Section 7 windows窗口回调函数 定义在QTDIR\src\gui\kernel\qapplication_win.cpp     
  274. extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)     
  275. {     
  276.    ...     
  277.    //将消息重新封装成QEvent的子类QMouseEvent ==> Section 8     
  278.     result = widget->translateMouseEvent(msg);         
  279.    ...     
  280. }     
  281.      
  282. // Section 7 windows窗口回调函数 定义在QTDIR\src\gui\kernel\qapplication_win.cpp  
  283. extern "C" LRESULT QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)  
  284. {  
  285.    ...  
  286.    //将消息重新封装成QEvent的子类QMouseEvent ==> Section 8  
  287.     result = widget->translateMouseEvent(msg);      
  288.    ...  
  289. }

从Section 1~Section7， Qt进入QApplication的event loop，经过层层委任，最终QEventloop的processEvent将通过与平台相关的QAbstractEventDispatcher的子类QEventDispatcherWin32获得用户的用户输入事件，并将其打包成message后，通过标准Windows API ，把消息传递给了Windows OS，Windows OS得到通知后回调QtWndProc, 至此事件的分发与处理完成了一半的路程。

小结：Qt 事件处理机制 （上篇）的内容介绍完了，在下文中，我们将进一步讨论当我们收到来在Windows的回调后，事件又是怎么一步步打包成QEvent并通过QApplication分发给最终事件的接受和处理者QObject::event.请继续看Qt 事件处理机制 （下篇）。最后希望本文能帮你解决问题！

继续我们上一篇文章继续介绍，Qt 事件处理机制 （上篇） 介绍了Qt框架的事件处理机制：事件的产生、分发、接受和处理，并以视窗系统鼠标点击QWidget为例，对代码进行了剖析，向大家分析了Qt框架如何通过Event Loop处理进入处理消息队列循环，如何一步一步委派给平台相关的函数获取、打包用户输入事件交给视窗系统处理，函数调用栈如下：

  1. main(int, char **)   
  2. QApplication::exec()   
  3. QCoreApplication::exec()   
  4. QEventLoop::exec(ProcessEventsFlags )   
  5. QEventLoop::processEvents(ProcessEventsFlags )   
  6. QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags)

本文将介绍Qt app在视窗系统回调后，事件又是怎么一步步通过QApplication分发给最终事件的接受和处理者QWidget::event, （QWidget继承Object,重载其虚函数event)，以下所有的讨论都将嵌入在源码之中。

  1. QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) bool QETWidget::translateMouseEvent(const MSG &msg)   
  2. bool QApplicationPrivate::sendMouseEvent(...)   
  3. inline bool QCoreApplication::sendSpontaneousEvent(QObject *receiver, QEvent *event)   
  4. bool QCoreApplication::notifyInternal(QObject *receiver, QEvent *event)   
  5. bool QApplication::notify(QObject *receiver, QEvent *e)   
  6. bool QApplicationPrivate::notify_helper(QObject *receiver, QEvent * e)   
  7. bool QWidget::event(QEvent *event)   
  8.  
  9. // (续上文Section 7) Section 2-1：     
  10. QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)      
  11. {     
  12.    ...     
  13.    //检查message是否属于Qt可转义的鼠标事件     
  14.    if (qt_is_translatable_mouse_event(message)) {     
  15.         if (QApplication::activePopupWidget() != 0) {                 
  16.             POINT curPos = msg.pt;     
  17.             //取得鼠标点击坐标所在的QWidget指针，它指向我们在main创建的widget实例     
  18.             QWidget* w = QApplication::widgetAt(curPos.x, curPos.y);     
  19.             if (w)     
  20.                 widget = (QETWidget*)w;     
  21.         }     
  22.         if (!qt_tabletChokeMouse) {     
  23.             //对，就在这里。Windows的回调函数将鼠标事件分发回给了Qt Widget      
  24.             // => Section 2-2     
  25.             result = widget->translateMouseEvent(msg);            
  26.      ...     
  27. }     
  28. // Section 2-2  $QTDIR\src\gui\kernel\qapplication_win.cpp     
  29. //该函数所在与Windows平台相关，主要职责就是把已windows格式打包的鼠标事件解包、翻译成QApplication可识别的QMouseEvent,QWidget.     
  30. bool QETWidget::translateMouseEvent(const MSG &msg)     
  31. {     
  32.      //.. 这里很长的代码给以忽略       
  33.       // 让我们看一下sendMouseEvent的声明     
  34.      // widget是事件的接受者； e是封装好的QMouseEvent     
  35.      // ==> Section 2-3     
  36.      res = QApplicationPrivate::sendMouseEvent(widget, &e, alienWidget, this, &qt_button_down, qt_last_mouse_receiver);     
  37. }     
  38. // Section 2-3 $QTDIR\src\gui\kernel\qapplication.cpp     
  39. bool QApplicationPrivate::sendMouseEvent(QWidget *receiver, QMouseEvent *event,     
  40.                                          QWidget *alienWidget, QWidget *nativeWidget,     
  41.                                          QWidget **buttonDown, QPointer<QWidget> &lastMouseReceiver,     
  42.                                          bool spontaneous)     
  43. {     
  44.      //至此与平台相关代码处理完毕     
  45.      //MouseEvent默认的发送方式是spontaneous, 所以将执行sendSpontaneousEvent。 sendSpontaneousEvent() 与 sendEvent的代码实现几乎相同，
  46.                    除了将QEvent的属性spontaneous标记不同。 这里是解释什么spontaneous事件：如果事件由应用程序之外产生的，比如一个系统事件。 
  47.                显然MousePress事件是由视窗系统产生的一个的事件（详见上文Section 1~ Section 7),因此它是   spontaneous事件     
  48.        
  49.     if (spontaneous)     
  50.         result = QApplication::sendSpontaneousEvent(receiver, event);  ==〉Section 2-4     
  51.     else    
  52.         result = QApplication::sendEvent(receiver, event);     
  53. }    
  54. // (续上文Section 7) Section 2-1：  
  55. QT_WIN_CALLBACK QtWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)   
  56. {  
  57.    ...  
  58.    //检查message是否属于Qt可转义的鼠标事件  
  59.    if (qt_is_translatable_mouse_event(message)) {  
  60.         if (QApplication::activePopupWidget() != 0) {              
  61.             POINT curPos = msg.pt;  
  62.             //取得鼠标点击坐标所在的QWidget指针，它指向我们在main创建的widget实例  
  63.             QWidget* w = QApplication::widgetAt(curPos.x, curPos.y);  
  64.             if (w)  
  65.                 widget = (QETWidget*)w;  
  66.         }  
  67.         if (!qt_tabletChokeMouse) {  
  68.             //对，就在这里。Windows的回调函数将鼠标事件分发回给了Qt Widget   
  69.             // => Section 2-2  
  70.             result = widget->translateMouseEvent(msg);         
  71.      ...  
  72. }  
  73. // Section 2-2  $QTDIR\src\gui\kernel\qapplication_win.cpp  
  74. //该函数所在与Windows平台相关，主要职责就是把已windows格式打包的鼠标事件解包、翻译成QApplication可识别的QMouseEvent,QWidget.  
  75. bool QETWidget::translateMouseEvent(const MSG &msg)  
  76. {  
  77.      //.. 这里很长的代码给以忽略    
  78.       // 让我们看一下sendMouseEvent的声明  
  79.      // widget是事件的接受者； e是封装好的QMouseEvent  
  80.      // ==> Section 2-3  
  81.      res = QApplicationPrivate::sendMouseEvent(widget, &e, alienWidget, this, &qt_button_down, qt_last_mouse_receiver);  
  82. }  
  83. // Section 2-3 $QTDIR\src\gui\kernel\qapplication.cpp  
  84. bool QApplicationPrivate::sendMouseEvent(QWidget *receiver, QMouseEvent *event,  
  85.                                          QWidget *alienWidget, QWidget *nativeWidget,  
  86.                                          QWidget **buttonDown, QPointer<QWidget> &lastMouseReceiver,  
  87.                                          bool spontaneous)  
  88. {  
  89.      //至此与平台相关代码处理完毕  
  90.      //MouseEvent默认的发送方式是spontaneous, 所以将执行sendSpontaneousEvent。 sendSpontaneousEvent() 与 sendEvent的代码实现几乎相同，
  91.                         除了将QEvent的属性spontaneous标记不同。 这里是解释什么spontaneous事件：如果事件由应用程序之外产生的，比如一个系统事件。 
  92.                      显然MousePress事件是由视窗系统产生的一个的事件（详见上文Section 1~ Section 7),因此它是spontaneous事件  
  93.     if (spontaneous)  
  94.         result = QApplication::sendSpontaneousEvent(receiver, event);  ==〉Section 2-4  
  95.     else  
  96.         result = QApplication::sendEvent(receiver, event);  
  97. } 

  1. // Section 2-4 C:\Qt\4.7.1-Vs\src\corelib\kernel\qcoreapplication.h     
  2. inline bool QCoreApplication::sendSpontaneousEvent(QObject *receiver, QEvent *event)     
  3. {      
  4.     //将event标记为自发事件     
  5.      //进一步调用 2-5 QCoreApplication::notifyInternal     
  6.     if (event) event->spont = true; return self ? self->notifyInternal(receiver, event) : false;      
  7. }     
  8. // Section 2-5:  $QTDIR\gui\kernel\qapplication.cpp     
  9. bool QCoreApplication::notifyInternal(QObject *receiver, QEvent *event)     
  10. {     
  11.          
  12.     // 几行代码对于Qt Jambi (QT Java绑定版本） 和QSA (QT Script for Application)的支持     
  13.      ...     
  14.      // 以下代码主要意图为Qt强制事件只能够发送给当前线程里的对象，也就是说receiver->d_func()->threadData应该等于QThreadData::current()。
  15.                                           注意，跨线程的事件需要借助Event Loop来派发     
  16.      QObjectPrivate *d = receiver->d_func();     
  17.     QThreadData *threadData = d->threadData;     
  18.     ++threadData->loopLevel;     
  19.     bool returnValue;     
  20.     QT_TRY {     
  21.         //哇，终于来到大名鼎鼎的函数QCoreApplication::nofity()了 ==> Section 2-6     
  22.         returnValue = notify(receiver, event);     
  23.     } QT_CATCH (...) {     
  24.         --threadData->loopLevel;     
  25.         QT_RETHROW;     
  26.     }     
  27. }     
  28. // Section 2-6:  $QTDIR\gui\kernel\qapplication.cpp     
  29. // QCoreApplication::notify和它的重载函数QApplication::notify在Qt的派发过程中起到核心的作用，Qt的官方文档时这样说的：
  30.                                                        任何线程的任何对象的所有事件在发送时都会调用notify函数。     
  31. bool QApplication::notify(QObject *receiver, QEvent *e)     
  32. {     
  33.    //代码很长，最主要的是一个大大的Switch,Case     
  34.    ..     
  35.    switch ( e->type())     
  36.    {     
  37.     ...     
  38.     case QEvent::MouseButtonPress:     
  39.     case QEvent::MouseButtonRelease:     
  40.     case QEvent::MouseButtonDblClick:     
  41.     case QEvent::MouseMove:     
  42.      ...     
  43.         //让自己私有类(d是私有类的句柄）来进一步处理 ==> Section 2-7     
  44.         res = d->notify_helper(w, w == receiver ? mouse : &me);     
  45.         e->spont = false;     
  46.         break;     
  47.     }     
  48.     ...     
  49. }     
  50. // Section 2-7:  $QTDIR\gui\kernel\qapplication.cpp     
  51. bool QApplicationPrivate::notify_helper(QObject *receiver, QEvent * e)     
  52. {     
  53.     ...     
  54.     // 向事件过滤器发送该事件，这里介绍一下Event Filters. 事件过滤器是一个接受即将发送给目标对象所有事件的对象。     
  55.    //如代码所示它开始处理事件在目标对象行动之前。过滤器的QObject::eventFilter（）实现被调用，能接受或者丢弃过滤，
  56.                          允许或者拒绝事件的更进一步的处理。如果所有的事件过滤器允许更进一步的事件处理，事件将被发送到目标对象本身。
  57.                          如果他们中的一个停止处理，目标和任何后来的事件过滤器不能看到任何事件。     
  58.     if (sendThroughObjectEventFilters(receiver, e))     
  59.         return true;     
  60.      // 递交事件给receiver  => Section 2-8     
  61.     bool consumed = receiver->event(e);     
  62.     e->spont = false;     
  63. }     
  64. // Section 2-8  $QTDIR\gui\kernel\qwidget.cpp     
  65. // QApplication通过notify及其私有类notify_helper,将事件最终派发给了QObject的子类- QWidget.     
  66. bool QWidget::event(QEvent *event)     
  67. {     
  68.     ...     
  69.     switch(event->type()) {     
  70.     case QEvent::MouseButtonPress:     
  71.         // Don't reset input context here. Whether reset or not is     
  72.         // a responsibility of input method. reset() will be     
  73.         // called by mouseHandler() of input method if necessary     
  74.         // via mousePressEvent() of text widgets.     
  75. #if 0     
  76.         resetInputContext();     
  77. #endif     
  78.         //mousePressEvent是虚函数，QWidget的子类可以通过重载重新定义mousePress事件的行为     
  79.         mousePressEvent((QMouseEvent*)event);     
  80.         break;        
  81. }

小结：Qt 事件处理机制 （下篇）的内容介绍完了，希望本文对你 有所帮助！更多相关资料请参考编辑推荐！

 

手机设置网络共享 手机设置网络共享
原创粉丝点击
热门IT博客
php校园新闻发布系统php校园新闻发布系统
快速排序算法 图解快速排序算法 图解
php json encode
淘宝上手机解锁可靠吗
欠淘宝信用贷款
身份证被盗用开淘宝店
sudo yum 找不到命令
手机淘宝 装修日记
you are a lover 知乎
腾讯java面试题
freebsd 11 安装软件
1908大军阀知乎
淘宝网旧报纸
知乎 王家卫 章子怡
plc编程入门百度云
购买的淘宝店铺靠谱吗
淘宝前100名半价怎么抢
紧急救援数据恢复
linux命令查看用户信息
java 7 32位 xp
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 五加皮别名 五加皮怎么吃 致中和五加皮价格 五加皮汤 中药材五加皮 刺五加 五加皮 五加皮白酒 五加皮刺五加 五加皮散 五加皮的功效与作用 中药五加皮的功效与作用 五夹皮 刺五加树苗 刺五加价格 刺五加小苗 刺五加原浆价格 刺五加的价格 刺五加种苗 刺五加茶叶 刺五加多少钱一斤 刺五加生产厂家 刺五加脑灵液价格 刺五加哪里有卖 刺五加脑灵液 刺五加精膏 刺五加胶囊 刺五加颗粒 刺五加 价格 刺五加苗价格 南五加皮 刺五加原浆 刺五加基地 刺五加功效 刺五加育雏宝 刺五加收购价格 刺五加浸膏 刺五加的功效 刺五加红茶 刺五加市场价格 凉拌刺五加 刺五加种植

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里