MiniGUI事件传递机制分析
前言
这段时间学习了一下MiniGUI中的事件传递机制，包括从内核驱动上报事件到MiniGUI分发事件这一整条通路，在嵌入式平台上，获取触摸事件可以使用tslib框架，通过tslib获取到事件之后，会把消息保存在桌面消息队列中，然后进一步分发到应用消息队列，我会在这篇文章中详细说明
1. IAL初始化流程
IAL全拼是Input Abstract Layer，也就是输入抽象层，在MiniGUI中抽象了很多输入设备，比如tslibial、ipaqh3600ial、consoleial和nexusial等等，本文以tslibial为例进行说明
首先看一下初始化流程图，有一个初步的印象
整个MiniGUI的初始化会调用到InitGUI()函数中，本文主要关注IAL初始化相关的代码
/* libminigui-gpl-3.2/src/kernel/init.c */
int GUIAPI InitGUI (int args, const char *agr[])
{
/*...*/
/*初始化应用窗口默认事件处理进程*/
__mg_def_proc[0] = PreDefMainWinProc;
/*初始化应用对话框默认事件处理进程*/
__mg_def_proc[1] = PreDefDialogProc;
/*初始化应用控件窗口默认事件处理进程*/
__mg_def_proc[2] = PreDefControlProc;
/*...*/
/*初始化输入引擎*/
if(!mg_InitLWEvent()) {
fprintf(stderr, "KERNEL>InitGUI: Low level event initialization failure!\n");
goto failure1;
}
/*...*/
/*创建桌面接受消息线程*/
if (!SystemThreads()) {
fprintf (stderr, "KERNEL>InitGUI: Init system threads failure!\n");
goto failure;
}
/*...*/
}
static BOOL SystemThreads(void)
{
/*...*/
/*这里以MiniGUI-Threads模式为例*/
/*创建桌面接受消息线程，会初始化桌面消息队列和一个while循环去取消息*/
pthread_create (&__mg_desktop, NULL, DesktopMain, &wait);
/*...*/
/*创建接受内核上报事件线程，会等待内核事件，如果有事件则解析并上报*/
pthread_create (&__mg_parsor, NULL, EventLoop, &wait);
/*...*/
}
/* libminigui-gpl-3.2/src/kernel/event.c */
BOOL mg_InitLWEvent (void)
{
/*获取双击最小事件间隔，可以配置MiniGUI.cfg中的dblclicktime字段，默认300*/
GetDblclickTime ();
/*获取超时时间，可以配置MiniGUI.cfg中的timeoutusec字段，默认300000，该值是每一次循环获取事件的最大等待时间*/
GetTimeout ();
/*初始化具体的输入引擎*/
if (mg_InitIAL ())
return FALSE;
/*重置鼠标按键状态*/
ResetMouseEvent();
ResetKeyEvent();
return TRUE;
}
/* libminigui-gpl-3.2/src/ial/ial.c */
int mg_InitIAL (void)
{
/*...*/
/*会解析MiniGUI.cfg中的ial_engine、mdev和mtype字段，判断使用哪种输入引擎*/
/*IAL_InitInput会最终调用到具体的输入引擎中，tslibial会调用到InitTSLibInput函数*/
if (!IAL_InitInput (__mg_cur_input, mdev, mtype)) {
fprintf (stderr, "IAL: Init IAL engine failure.\n");
return ERR_INPUT_ENGINE;
}
/*...*/
}
上面写到会创建桌面接受消息线程，因为用的是MiniGUI-Threads模式，所以在desktop-ths.c中
/* libminigui-gpl-3.2/src/kernel/desktop-ths.c */
void* DesktopMain (void* data)
{
/*...*/
/*__mg_dsk_msg_queue就是桌面消息队列了，默认DEF_MSGQUEUE_LEN是16，也就是最多保存16个消息*/
if (!(__mg_dsk_msg_queue = mg_InitMsgQueueThisThread ()) ) {
_MG_PRINTF ("KERNEL>Desktop: mg_InitMsgQueueThisThread failure!\n");
return NULL;
}
/*...*/
/*开启一个while循环，调用GetMessage，指定HWND_DESKTOP，每次从__mg_dsk_msg_queue队列中取一个消息*/
while (GetMessage(&Msg, HWND_DESKTOP)) {
/*...*/
/*如果取到消息的话，就把消息丢给桌面事件处理函数进行分发，具体怎么分发，下节详解*/
lRet = DesktopWinProc (HWND_DESKTOP,
Msg.message, Msg.wParam, Msg.lParam);
/*...*/
}
/*...*/
}
2. 内核事件上报流程
在初始化的时候，开启了一个接受并解析内核事件的线程EventLoop，这一小节重点分析改函数，先看图
EventLoop函数中，主要是一个while循环，IAL_WaitEvent会调用到输入引擎的wait_event函数中去等待内核事件
/* libminigui-gpl-3.2/src/kernel/init.c */
static void* EventLoop (void* data)
{
LWEVENT lwe;
int event;
lwe.data.me.x = 0; lwe.data.me.y = 0;
sem_post ((sem_t*)data);
while (__mg_quiting_stage > _MG_QUITING_STAGE_EVENT) {
/*等待内核上报事件，__mg_event_timeout是等待超时时间，在超时时间内没有事件的话会再次进入while循环*/
event = IAL_WaitEvent (IAL_MOUSEEVENT | IAL_KEYEVENT, 0,
NULL, NULL, NULL, (void*)&__mg_event_timeout);
if (event < 0) {
continue;
}
lwe.status = 0L;
lwe.data.me.status = 0;
/*鼠标事件，kernel_GetLWEvent主要是获取上报的坐标值，和判断是否双击*/
if (event & IAL_MOUSEEVENT && kernel_GetLWEvent (IAL_MOUSEEVENT, &lwe))
ParseEvent (&lwe);
lwe.status = 0L;
lwe.data.ke.status = 0;
/*键盘事件*/
if (event & IAL_KEYEVENT && kernel_GetLWEvent (IAL_KEYEVENT, &lwe))
ParseEvent (&lwe);
if (event == 0 && kernel_GetLWEvent (0, &lwe))
ParseEvent (&lwe);
}
/* printf("Quit from EventLoop()\n"); */
return NULL;
}
/* libminigui-gpl-3.2/src/kernel/event.c */
BOOL kernel_GetLWEvent (int event, PLWEVENT lwe)
{
/*...*/
if (event & IAL_MOUSEEVENT) {
/*更新点击的坐标，会调到输入引擎的mouse_update函数中*/
if (!IAL_UpdateMouse ())
event &= ~IAL_MOUSEEVENT;
}
if (event & IAL_KEYEVENT) {
if ((nr_keys = IAL_UpdateKeyboard ()) == 0)
event &= ~IAL_KEYEVENT;
}
/*...*/
/*判断是单击还是双击*/
if ( !(oldbutton & IAL_MOUSE_LEFTBUTTON) &&
(button & IAL_MOUSE_LEFTBUTTON) )
{
license_on_input();
interval = __mg_timer_counter - time1;
if (interval <= dblclicktime)
me->event = ME_LEFTDBLCLICK;
else
me->event = ME_LEFTDOWN;
time1 = __mg_timer_counter;
goto mouseret;
}
/*...*/
}
重要的函数ParseEvent，里面会根据事件类型，上报MSG_KEYDOWN、MSG_KEYUP、MSG_MOUSEMOVE、MSG_LBUTTONDOWN、MSG_LBUTTONUP和MSG_LBUTTONDBLCLK等等事件
/* libminigui-gpl-3.2/src/kernel/init.c */
static void ParseEvent (PLWEVENT lwe)
{
/*...*/
/*根据事件类型进行赋值*/
else if(lwe->type == LWETYPE_MOUSE) {
Msg.wParam = me->status;
Msg.lParam = MAKELONG (me->x, me->y);
switch (me->event) {
case ME_MOVED:
Msg.message = MSG_MOUSEMOVE;
break;
case ME_LEFTDOWN:
Msg.message = MSG_LBUTTONDOWN;
scrolltime = __mg_timer_counter;
scrollX = me->x;
scrollY = me->y;
flingX = me->x;
flingY = me->y;
break;
case ME_LEFTUP:
Msg.message = MSG_LBUTTONUP;
break;
case ME_LEFTDBLCLICK:
Msg.message = MSG_LBUTTONDBLCLK;
break;
case ME_RIGHTDOWN:
Msg.message = MSG_RBUTTONDOWN;
break;
case ME_RIGHTUP:
Msg.message = MSG_RBUTTONUP;
break;
case ME_RIGHTDBLCLICK:
Msg.message = MSG_RBUTTONDBLCLK;
break;
}
/*...*/
/*把消息保存到桌面消息队列中，QueueDeskMessage展开是kernel_QueueMessage (__mg_dsk_msg_queue, msg)；*/
/*__mg_dsk_msg_queue就是在初始化的时候创建的桌面消息队列*/
QueueDeskMessage (&Msg);
}
下面看看是怎么把消息存到消息队列中的，在MiniGUI中通过记录readpos和writepos，判断是否有新消息，当写入一个消息writepos就加1，读了一个消息readpos就加1，如果readpos和writepos相等就表示没有消息，默认消息队列一次最多存16条消息，由DEF_MSGQUEUE_LEN宏控制，消息满了的话就会丢弃
/* libminigui-gpl-3.2/src/kernel/message.c */
BOOL kernel_QueueMessage (PMSGQUEUE msg_que, PMSG msg)
{
/*...*/
if (msg->message == MSG_MOUSEMOVE
|| msg->message == MSG_NCMOUSEMOVE
|| msg->message == MSG_DT_MOUSEMOVE) {
int readpos = msg_que->readpos;
PMSG a_msg, last_msg = NULL;
/*如果有新消息的话*/
while (readpos != msg_que->writepos) {
a_msg = msg_que->msg + readpos;
/*检查是否是重复的消息，如果是的话就把这次的消息覆盖上一次的消息*/
if (a_msg->message == msg->message
&& a_msg->wParam == msg->wParam
&& a_msg->hwnd == msg->hwnd) {
last_msg = a_msg;
}
readpos ++;
readpos %= msg_que->len;
}
if (last_msg) {
/*覆盖上一次消息*/
last_msg->lParam = msg->lParam;
last_msg->time = msg->time;
goto ret;
}
}
/*...*/
/*把消息写入队列中，writepos加1，超过最大数之后就归零*/
msg_que->msg [msg_que->writepos] = *msg;
msg_que->writepos++;
msg_que->writepos %= msg_que->len;
}
3. 桌面获取事件流程
在初始化的时候，开启了一个获取消息的线程DesktopMain，话不多说，上图
主要是一个while循环去取消息，GetMessage最终会调用到PeekMessageEx函数，取完消息就移除消息
/* libminigui-gpl-3.2/src/kernel/desktop-ths.c */
void* DesktopMain (void* data)
{
/*...*/
/*开启一个while循环，调用GetMessage，指定HWND_DESKTOP，每次从__mg_dsk_msg_queue队列中取一个消息*/
while (GetMessage(&Msg, HWND_DESKTOP)) {
/*...*/
/*如果取到消息的话，就把消息丢给桌面事件处理函数进行分发*/
lRet = DesktopWinProc (HWND_DESKTOP,
Msg.message, Msg.wParam, Msg.lParam);
/*...*/
}
}
/* libminigui-gpl-3.2/src/kernel/message.c */
BOOL PeekMessageEx (PMSG pMsg, HWND hWnd, UINT nMsgFilterMin, UINT nMsgFilterMax,
BOOL bWait, UINT uRemoveMsg)
{
/*...*/
/*如果是QS_POSTMSG类型的消息*/
if (pMsgQueue->dwState & QS_POSTMSG) {
/*如果有新消息*/
if (pMsgQueue->readpos != pMsgQueue->writepos) {
/*取到消息*/
*pMsg = pMsgQueue->msg[pMsgQueue->readpos];
SET_PADD (NULL);
if (IS_MSG_WANTED(pMsg->message)) {
CheckCapturedMouseMessage (pMsg);
/*如果需要移除消息，把readpos加1就可以了*/
if (uRemoveMsg == PM_REMOVE) {
pMsgQueue->readpos++;
pMsgQueue->readpos %= pMsgQueue->len;
}
UNLOCK_MSGQ (pMsgQueue);
return TRUE;
}
}
else
pMsgQueue->dwState &= ~QS_POSTMSG;
}
/*...*/
}
下面重点说一下获取消息后怎么发送消息给应用，主要说明点击事件的传递
/* libminigui-gpl-3.2/src/kernel/desktop-comm.c */
LRESULT DesktopWinProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
/*...*/
/*如果是鼠标事件，最后调用MouseMessageHandler函数进行处理*/
if (message >= MSG_FIRSTMOUSEMSG && message <= MSG_LASTMOUSEMSG) {
/*...*/
#ifdef _MGHAVE_MENU
if (sg_ptmi) {
if (PopupMenuTrackProc (sg_ptmi, message, x, y))
return MouseMessageHandler (message, flags, x, y);
}
else
#endif
return MouseMessageHandler (message, flags, x, y);
}
}
static LRESULT MouseMessageHandler (UINT message, WPARAM flags, int x, int y)
{
/*...*/
/*获取需要接受事件的应用窗口句柄*/
pCtrlPtrIn = gui_GetMainWindowPtrUnderPoint (x, y);
/**/
switch (message) {
case MSG_MOUSEMOVE:
/*在MSG_LBUTTONDOWN的时候，_mgs_button_down_main_window被赋值好了
*所以把MSG_MOUSEMOVE加上MSG_DT_MOUSEOFF偏移发送给应用窗口*/
if (_mgs_button_down_main_window) {
PostMessage ((HWND)_mgs_button_down_main_window,
message + MSG_DT_MOUSEOFF,
flags, MAKELONG (x, y));
}
break;
case MSG_LBUTTONDOWN:
case MSG_RBUTTONDOWN:
if (_mgs_button_down_main_window) {
PostMessage ((HWND)_mgs_button_down_main_window,
message + MSG_DT_MOUSEOFF,
flags, MAKELONG (x, y));
}
else if (pUnderPointer) {
/*...*/
/*把MSG_LBUTTONDOWN加上MSG_DT_MOUSEOFF偏移，然后发送给应用窗口*/
PostMessage ((HWND)pUnderPointer, message + MSG_DT_MOUSEOFF,
flags, MAKELONG (x, y));
/*把应用窗口句柄赋值给_mgs_button_down_main_window*/
_mgs_button_down_main_window = pUnderPointer;
}
break;
case MSG_LBUTTONUP:
case MSG_RBUTTONUP:
/*...*/
/*把MSG_LBUTTONUP加上MSG_DT_MOUSEOFF偏移，发送给应用窗口*/
if (_mgs_button_down_main_window) {
PostMessage ((HWND)_mgs_button_down_main_window,
message + MSG_DT_MOUSEOFF,
flags, MAKELONG (x, y));
if (!(_mgs_down_buttons & DOWN_BUTTON_ANY)) {
/*_mgs_button_down_main_window赋值为NULL，等待下一次down和up事件来临*/
_mgs_button_down_main_window = NULL;
_mgs_down_buttons = DOWN_BUTTON_NONE;
}
}
break;
/*...*/
}
4. 应用获取事件流程
多窗口的应用，有一个while (GetMessage(&Msg, hMainWnd))就可以了，不需要每个窗口都去while，上一小节已经说过，会获取需要接受事件的应用窗口句柄然后进行事件分发，典型创建窗口代码如下
int MiniGUIMain(int argc, const char* argv[])
{
int i = 0;
MSG Msg;
HWND hMainWnd;
MAINWINCREATE CreateInfo;
/*...*/
/*CreateMainWindow里面会创建应用消息队列*/
hMainWnd = CreateMainWindow(&CreateInfo);
if (hMainWnd == HWND_INVALID) {
return -1;
}
ShowWindow(hMainWnd, SW_SHOWNORMAL);
/*开启一个while循环，循环获取应用消息队列里的消息*/
while (GetMessage(&Msg, hMainWnd)) {
/*把击键消息转换为MSG_CHAR消息*/
TranslateMessage(&Msg);
/*把消息发往目标窗口的窗口过程*/
DispatchMessage(&Msg);
}
MainWindowThreadCleanup(hMainWnd);
return 0;
}
GetMessage上一小节已经说过，这一小节主要讲解DispatchMessage的作用，先看一下图
/* libminigui-gpl-3.2/src/kernel/message.c */
LRESULT GUIAPI DispatchMessage (PMSG pMsg)
{
/*...*/
/*获取应用窗口消息处理函数*/
if (!(WndProc = GetWndProc (pMsg->hwnd)))
return -1;
/*调用应用窗口消息处理函数，这也就是我们写应用的时候，为什么消息处理函数被调用的原因了*/
lRet = WndProc (pMsg->hwnd, pMsg->message, pMsg->wParam, pMsg->lParam);
/*...*/
}
典型的应用窗口消息处理函数
static int AcitvityMainWinProc(HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
static int point_count = 0;
switch (message) {
case MSG_CREATE:
break;
case MSG_PAINT: {
HDC hdc;
hdc = BeginPaint(hWnd);
SetBrushColor(hdc, PIXEL_red);
FillBox(hdc, m_point.x, m_point.y, 20, 20);
EndPaint(hWnd, hdc);
return 0;
}
case MSG_LBUTTONDOWN:
point_count = 1;
break;
case MSG_MOUSEMOVE:
point_count++;
break;
case MSG_LBUTTONUP:
point_count++;
InvalidateRect(hWnd, NULL, TRUE);
break;
case MSG_CLOSE: {
DestroyMainWindow(hWnd);
PostQuitMessage(hWnd);
return 0;
}
}
/*如果应用没有处理消息，则调用默认的消息处理函数*/
return DefaultMainWinProc(hWnd, message, wParam, lParam);
}
上一小节说过，MSG_LBUTTONDOWN等消息是加上了MSG_DT_MOUSEOFF偏移的，并不是我们想要的MSG_LBUTTONDOWN消息，那来看看DefaultMainWinProc是怎么处理的吧，其实是一个宏，指向一个函数
/*__mg_def_proc[0]在MiniGUI初始化的时候赋值为PreDefMainWinProc函数*/
#define DefaultMainWinProc (__mg_def_proc[0])
/* libminigui-gpl-3.2/src/gui/window.c */
LRESULT PreDefMainWinProc (HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
PMAINWIN pWin = (PMAINWIN)hWnd;
/*不同的消息，会进入不同的函数中处理，加上MSG_DT_MOUSEOFF偏移的会进入DefaultDTMouseMsgHandler函数中*/
if (message > MSG_DT_MOUSEOFF && message <= MSG_DT_RBUTTONDBLCLK)
return DefaultDTMouseMsgHandler(pWin, message,
wParam, LOSWORD (lParam), HISWORD (lParam));
else if (message >= MSG_FIRSTMOUSEMSG && message <= MSG_NCMOUSEOFF)
return DefaultMouseMsgHandler(pWin, message,
wParam, LOSWORD (lParam), HISWORD (lParam));
else if (message > MSG_NCMOUSEOFF && message <= MSG_LASTMOUSEMSG)
return DefaultNCMouseMsgHandler(pWin, message,
(int)wParam, LOSWORD (lParam), HISWORD (lParam));
/*...*/
return 0;
}
static LRESULT DefaultDTMouseMsgHandler (PMAINWIN pWin, UINT message,
WPARAM flags, int x, int y)
{
/*...*/
/*可以看到，会把消息减去MSG_DT_MOUSEOFF偏移，然后在PostMessage把消息发送到应用消息队列中
*下一次GetMessage就可以取到真正的消息了*/
switch (message) {
case MSG_DT_MOUSEMOVE:
/*...*/
case MSG_DT_LBUTTONDBLCLK:
case MSG_DT_RBUTTONDBLCLK:
if (hc_mainwin == HT_CLIENT) {
PostMessage((HWND)pWin,
message + (MSG_NCMOUSEOFF - MSG_DT_MOUSEOFF),
hc_mainwin, MAKELONG (x, y));
PostMessage((HWND)pWin,
message - MSG_DT_MOUSEOFF,
flags, MAKELONG (cx, cy));
}
break;
case MSG_DT_LBUTTONDOWN:
case MSG_DT_RBUTTONDOWN:
if (hc_mainwin != HT_CLIENT) {
/*...*/
}
else
{
PostMessage((HWND)pWin,
message - MSG_DT_MOUSEOFF,
flags, MAKELONG(cx, cy));
}
break;
case MSG_DT_LBUTTONUP:
case MSG_DT_RBUTTONUP:
if (hc_mainwin == HT_CLIENT) {
PostMessage((HWND)pWin,
message - MSG_DT_MOUSEOFF,
flags, MAKELONG(cx, cy));
}
break;
}
}
如果应用的消息处理线程MSG_LBUTTONDOWN是break，不是return的话，则还会调用DefaultMainWinProc，最终还会调用DefaultMouseMsgHandler，把消息传递到窗口的控件里，这里不再详细描述
5. 总结
在MiniGUI中，事件大概就是这样一个传递流程，经过一段时间的学习，对MiniGUI的框架更加了解了一些，做一些定制化的功能也更加容易，接下来还有MiniGUI绘图机制的分析和双缓冲解决切线的优化