详解 QT 源码之 Qt 事件机制原理

移动开发
本文介绍的是 QT 源码之 Qt 事件机制原理,解决在用Qt写Gui程序的时候,出现的问题,先来看本文.

QT 源码之 Qt 事件机制原理是本文要介绍的内容,在用Qt写Gui程序的时候,在main函数里面最后依据都是app.exec();很多书上对这句的解释是,使 Qt 程序进入消息循环。下面我们就到exec()函数内部,来看一下他的实现原理。
Let's go!
首先来到QTDIR\src\corelib\kernel\qcoreapplication.cpp

  1. int QCoreApplication::exec()  
  2. {  
  3.     if (!QCoreApplicationPrivate::checkInstance("exec"))  
  4.         return -1;  
  5.     //获取线程数据  
  6.     QThreadData *threadData = self->d_func()->threadData;  
  7.     //判断是否在主线程创建  
  8.     if (threadData != QThreadData::current()) {  
  9.         qWarning("%s::exec: Must be called from the main thread", self->metaObject()->className());  
  10.         return -1;  
  11.     }  
  12.     //判断eventLoop是否已经创建  
  13.     if (!threadData->eventLoops.isEmpty()) {  
  14.         qWarning("QCoreApplication::exec: The event loop is already running");  
  15.         return -1;  
  16.     }  
  17.     threadData->quitNow = false;  
  18.     QEventLoop eventLoop;  
  19.     self->d_func()->in_exec = true;  
  20.     //创建eventLoop  
  21.     int returnCode = eventLoop.exec();  
  22.     threadData->quitNow = false;  
  23.     if (self) {  
  24.         self->d_func()->in_exec = false;  
  25.         //退出程序  
  26.         emit self->aboutToQuit();  
  27.         sendPostedEvents(0, QEvent::DeferredDelete);  
  28.     }  
  29.     return returnCode;  
  30. }  
  31. 再来到qeventloop.cpp中。  
  32. int QEventLoop::exec(ProcessEventsFlags flags)  
  33. {  
  34.     Q_D(QEventLoop);  
  35.     if (d->threadData->quitNow)  
  36.         return -1;  
  37.     //已经调用过exec了。  
  38.     if (d->inExec) {  
  39.         qWarning("QEventLoop::exec: instance %p has already called exec()", this);  
  40.         return -1;  
  41.     }  
  42.     d->inExec = true;  
  43.     d->exit = false;  
  44.     ++d->threadData->loopLevel;  
  45.     //将事件类对象压入线程结构体中  
  46.     d->threadData->eventLoops.push(this);  
  47.     // remove posted quit events when entering a new event loop  
  48.     // 这句不用翻译了把!  
  49.     if (qApp->thread() == thread())  
  50.         QCoreApplication::removePostedEvents(qApp, QEvent::Quit);  
  51. #if defined(QT_NO_EXCEPTIONS)  
  52.     while (!d->exit)  
  53.         //这里才是关键,我们还要继续跟踪进去。  
  54.         processEvents(flags | WaitForMoreEvents);  
  55. #else  
  56.     try {  
  57.         while (!d->exit)  
  58.             processEvents(flags | WaitForMoreEvents);  
  59.     } catch (...) {  
  60.         //如果使用了EXCEPTION,则继续对下一条时间进行处理。  
  61.         qWarning("Qt has caught an exception thrown from an event handler. Throwing\n"  
  62.                  "exceptions from an event handler is not supported in Qt. You must\n"  
  63.                  "reimplement QApplication::notify() and catch all exceptions there.\n");  
  64.         throw;  
  65.     }  
  66. #endif  
  67.     //退出eventloop前,将时间对象从线程结构中取出。  
  68.     QEventLoop *eventLoop = d->threadData->eventLoops.pop();  
  69.     Q_ASSERT_X(eventLoop == this, "QEventLoop::exec()", "internal error");  
  70.     Q_UNUSED(eventLoop); // --release warning  
  71.  
  72.     d->inExec = false;  
  73.     --d->threadData->loopLevel;  
  74.     //退出事件循环。  
  75.     return d->returnCode;  
  76. }  
  77.  
  78. 来到了processEvents函数:  
  79. bool QEventLoop::processEvents(ProcessEventsFlags flags)  
  80. {  
  81.     Q_D(QEventLoop);  
  82.     //判断事件分派器是否为空。  
  83.     if (!d->threadData->eventDispatcher)  
  84.         return false;  
  85.     if (flags & DeferredDeletion)  
  86.         QCoreApplication::sendPostedEvents(0, QEvent::DeferredDelete);  
  87.     //调用不同平台下的事件分派器来处理事件。  
  88.     return d->threadData->eventDispatcher->processEvents(flags);  
  89. }  
  90. processEvents是在QAbstractEventDispatcher类中定义的纯虚方法。在QEventDispatcherWin32类有processEvents的实现。  
  91. bool QEventDispatcherWin32::processEvents(QEventLoop::ProcessEventsFlags flags)  
  92. {  
  93.     Q_D(QEventDispatcherWin32);  
  94.     //内部数据创建。registerClass注册窗口类,createwindow创建窗体。  
  95.     //注册socket notifiers,启动所有的normal timers  
  96.     if (!d->internalHwnd)  
  97.         createInternalHwnd();  
  98.     d->interrupt = false;  
  99.     emit awake();  
  100.  
  101.     bool canWait;  
  102.     bool retVal = false;  
  103.     do {  
  104.         QCoreApplicationPrivate::sendPostedEvents(0, 0, d->threadData);  
  105.         DWORD waitRet = 0;  
  106.         HANDLE pHandles[MAXIMUM_WAIT_OBJECTS - 1];  
  107.         QVarLengthArray<MSG> processedTimers;  
  108.         while (!d->interrupt) {  
  109.             DWORD nCount = d->winEventNotifierList.count();  
  110.             Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);  
  111.             MSG msg;  
  112.             bool haveMessage;  
  113.             if (!(flags & QEventLoop::ExcludeUserInputEvents) && !d->queuedUserInputEvents.isEmpty()) {  
  114.                 // process queued user input events处理用户输入事件,放入队列中。  
  115.                 haveMessage = true;  
  116.                 msg = d->queuedUserInputEvents.takeFirst();  
  117.             } else if(!(flags & QEventLoop::ExcludeSocketNotifiers) && !d->queuedSocketEvents.isEmpty()) {  
  118.                 // process queued socket events  处理socket事件,放入队列中。  
  119.                 haveMessage = true;  
  120.                 msg = d->queuedSocketEvents.takeFirst();  
  121.             } else {  
  122.                 //从消息队列中取消息,同PeekMessage  
  123.                 haveMessage = winPeekMessage(&msg, 0, 0, 0, PM_REMOVE);  
  124.                 if (haveMessage && (flags & QEventLoop::ExcludeUserInputEvents)  
  125.                     && ((msg.message >= WM_KEYFIRST  
  126.                          && msg.message <= WM_KEYLAST)  
  127.                         || (msg.message >= WM_MOUSEFIRST  
  128.                             && msg.message <= WM_MOUSELAST)  
  129.                         || msg.message == WM_MOUSEWHEEL)) {  
  130.                     // queue user input events for later processing  
  131.                     haveMessage = false;  
  132.                     d->queuedUserInputEvents.append(msg);  
  133.                 }  
  134.                 if (haveMessage && (flags & QEventLoop::ExcludeSocketNotifiers)  
  135.                     && (msg.message == WM_USER && msg.hwnd == d->internalHwnd)) {  
  136.                     // queue socket events for later processing  
  137.                     haveMessage = false;  
  138.                     d->queuedSocketEvents.append(msg);  
  139.                 }  
  140.             }  
  141.             if (!haveMessage) {  
  142.                 // no message - check for signalled objects  
  143.                 for (int i=0; i<(int)nCount; i++)  
  144.                     pHandles[i] = d->winEventNotifierList.at(i)->handle();  
  145.                 //注册signal--slot。  
  146.                 waitRet = MsgWaitForMultipleObjectsEx(nCount, pHandles, 0, QS_ALLINPUT, MWMO_ALERTABLE);  
  147.                 if ((haveMessage = (waitRet == WAIT_OBJECT_0 + nCount))) {  
  148.                     // a new message has arrived, process it  
  149.                     continue;  
  150.                 }  
  151.             }  
  152.             //事件队列中有事件需要处理。  
  153.             if (haveMessage) {   
  154.                 //处理timer事件  
  155.                 if (msg.message == WM_TIMER) {  
  156.                     // avoid live-lock by keeping track of the timers we've already sent  
  157.                     bool found = false;  
  158.                     for (int i = 0; !found && i < processedTimers.count(); ++i) {  
  159.                         const MSG processed = processedTimers.constData()[i];  
  160.                         found = (processed.wParam == msg.wParam && processed.hwnd == msg.hwnd && processed.lParam == msg.lParam);  
  161.                     }  
  162.                     if (found)  
  163.                         continue;  
  164.                     processedTimers.append(msg);  
  165.                 } else if (msg.message == WM_QUIT) {  
  166.                     if (QCoreApplication::instance())  
  167.                         QCoreApplication::instance()->quit();  
  168.                     return false;  
  169.                 }  
  170.                 //消息分发处理。  
  171.                 if (!filterEvent(&msg)) {  
  172.                     TranslateMessage(&msg);  
  173.                     QT_WA({  
  174.                         DispatchMessage(&msg);  
  175.                     } , {  
  176.                         DispatchMessageA(&msg);  
  177.                     });  
  178.                 }  
  179.             } else if (waitRet >= WAIT_OBJECT_0 && waitRet < WAIT_OBJECT_0 + nCount) {  
  180.                 //处理signal--slot  
  181.                 d->activateEventNotifier(d->winEventNotifierList.at(waitRet - WAIT_OBJECT_0));  
  182.             } else {  
  183.                 // nothing todo so break  
  184.                 break;  
  185.             }  
  186.             retVal = true;  
  187.         }  
  188.         // still nothing - wait for message or signalled objects  
  189.         QThreadData *ddata = d->threadData;  
  190.         canWait = (!retVal  
  191.                    && data->canWait  
  192.                    && !d->interrupt  
  193.                    && (flags & QEventLoop::WaitForMoreEvents));  
  194.         if (canWait) {  
  195.             DWORD nCount = d->winEventNotifierList.count();  
  196.             Q_ASSERT(nCount < MAXIMUM_WAIT_OBJECTS - 1);  
  197.             for (int i=0; i<(int)nCount; i++)  
  198.                 pHandles[i] = d->winEventNotifierList.at(i)->handle();  
  199.             emit aboutToBlock();  
  200.             waitRet = MsgWaitForMultipleObjectsEx(nCount, pHandles, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE);  
  201.             emit awake();  
  202.             if (waitRet >= WAIT_OBJECT_0 && waitRet < WAIT_OBJECT_0 + nCount) {  
  203.                 d->activateEventNotifier(d->winEventNotifierList.at(waitRet - WAIT_OBJECT_0));  
  204.                 retVal = true;  
  205.             }  
  206.         }  
  207.     } while (canWait);  
  208.     return retVal;  

小结:关于详解 QT 源码之 Qt 事件机制原理的内容介绍完了,基本属于代码实现的内容,最后希望本文对你有帮助!

责任编辑:zhaolei 来源: 互联网
相关推荐

2011-06-23 14:40:13

Qt 信号

2011-06-23 13:38:27

QT 元对象 信号

2011-06-23 11:16:39

Qt Excel

2011-07-01 14:14:34

Qt 事件

2011-07-01 14:20:59

Qt 事件

2011-06-23 15:32:05

Qt Windows消息

2011-06-28 16:18:24

Qt QObject

2011-06-23 13:25:42

QT 源码 窗口

2011-06-23 15:10:39

Qt 窗体

2011-06-29 16:14:59

Qt 事件 过滤器

2011-07-05 18:40:19

QT 信号 机制

2011-07-05 18:32:52

QT 信号 机制

2011-06-29 17:20:20

Qt 内存 QOBJECT

2021-08-17 13:41:11

AndroidView事件

2021-09-01 06:48:16

AndroidGlide缓存

2011-07-04 14:50:49

QT Event 事件

2011-06-23 14:27:48

QT QLibrary 动态库

2011-08-29 14:59:26

QtEvent事件

2011-07-01 15:04:49

Qt 内省

2011-06-24 17:38:09

Qt 坐标 事件
点赞
收藏

51CTO技术栈公众号