minigui 时钟

libminigui-1.6.8 配置为线程版
 
minigui定时器的创建、销毁及定时器消息MSG_TIMER的传递
 
1 、时钟初始化
 
在minigui的初始化期间，调用函数__mg_timer_init（）对时钟进行初始化。
 
src/kernel/timer.c  line 136-162

136. static void* TimerEntry (void* data)
137. {
138.     if (!InitTimer ()) {
139.         fprintf (stderr, "TIMER: Init Timer failure!/n"); 
140. #ifndef __NOUNIX__ 
141.         exit (1); 
142. #endif 
143.         return NULL;
144.     }
145.     sem_post ((sem_t*)data);
147.     __mg_os_timer_loop ();
149.     return NULL;
150. }
152. int __mg_timer_init (void)
153. {
154.     sem_t wait;
156.     sem_init (&wait, 0, 0);
157.     pthread_create (&__mg_timer, NULL, TimerEntry, &wait);
158.     sem_wait (&wait);
159.     sem_destroy (&wait);
161.     return 0;
162. }

函数__mg_timer_init（）主要负责创建一个线程，来执行函数TimerEntry( )。在TimerEntry()函数中会通过InitTimer调用函数InstallIntervalTimer( )初始化系统时钟。
 
src/kernel/timer.c line 184-210

184. BOOL InstallIntervalTimer (void)
185. {
186.     struct itimerval timerv;
187.     struct sigaction siga;
188.     
189.     sigaction (SIGALRM, NULL, &old_alarm_handler);
191.     siga = old_alarm_handler;
192.     siga.sa_handler = (void(*)(int))__mg_timer_action;
193.     siga.sa_flags = SA_RESTART;
194.     sigaction (SIGALRM, &siga, NULL);
196.     timerv.it_interval.tv_sec = 0; 
197. #if defined(__uClinux__) && defined(_STAND_ALONE) 
198.     timerv.it_interval.tv_usec = 100000;     // 100 ms 
199. #else 
200.     timerv.it_interval.tv_usec = 10000;     // 10 ms 
201. #endif 
202.     timerv.it_value = timerv.it_interval;
204.     if (setitimer (ITIMER_REAL, &timerv, &old_timer) == -1) {
205.         TIMER_LOG_SYS ("setitimer call failed!/n");
206.         return FALSE;
207.     }
209.     return TRUE;
210. }

这里将时钟的时间间隔设置为10ms。也就是每10ms会向系统发送一次信号SIGALRM。这个信号的处理函数是__mg_timer_action()，通过sigaction (SIGALRM, &siga, NULL);和siga.sa_handler = (void(*)(int))__mg_timer_action;这两行设定。到此，系统时钟已经初始化好了。
 
2 、创建定时器
 
minigui定时器的创建由函数SetTimer (HWND hWnd, int id, unsigned int speed)完成，这个函数主要初始化一个TIMER数据结构，然后向桌面线程发送添加时钟的消息并传递这个定时器数据结构。
 
src/include/timer.h  line 28-34 

28. typedef struct _timer {
29.     HWND    hWnd;
30.     int     id;
31.     unsigned int speed;
32.     unsigned int count;
33. }TIMER;
34. typedef TIMER* PTIMER;

 
src/kernel/timer.c  line 537-546

537. BOOL GUIAPI SetTimer (HWND hWnd, int id, unsigned int speed)
538. {
539.     TIMER timer;
541.     timer.hWnd = hWnd;
542.     timer.id = id;
543.     timer.speed = speed;
545.     return SendMessage (HWND_DESKTOP, MSG_ADDTIMER, 0, (LPARAM)&timer);
546. }

桌面线程是在初始化时创建的，这个线程执行函数DesktopMain().

 
src/kernel/desktop.c line 144-197

 

144. void* DesktopMain(void* data)
145. {
146.     MSG Msg;
148.     /* init message queue of desktop thread */
149.     if ( !(__mg_dsk_threadinfo = InitThreadInfo()) ) {
150.         fprintf (stderr, "DESKTOP: Init Thread Info error!/n");
151.         return NULL;
152.     }
153.     __mg_dsk_msgs = __mg_dsk_threadinfo->pMsgQueue;
154.     __mg_desktop = __mg_dsk_threadinfo->th;
156.     /* init desktop window */
157.     if (!initDesktopWindow()) return NULL;
158.     __mg_dsk_threadinfo->pMainWin = __mg_dsk_win;
160.     DesktopWinProc (HWND_DESKTOP, MSG_STARTSESSION, 0, 0);
161.     PostMessage (HWND_DESKTOP, MSG_ERASEDESKTOP, 0, 0);
163.     /* desktop thread is ready now */
164.     sem_post ((sem_t*)data);
166.     /* process messages of desktop thread */
167.     while (GetMessage(&Msg, HWND_DESKTOP)) {
168.         int iRet = 0; 
170. #ifdef _TRACE_MSG 
171.         fprintf (stderr, "Message, %s: hWnd: %#x, wP: %#x, lP: %#lx. %s/n",
172.             Message2Str (Msg.message),
173.             Msg.hwnd,
174.             Msg.wParam,
175.             Msg.lParam,
176.             Msg.pAdd?"Sync":"Normal"); 
177. #endif 
179.         iRet = DesktopWinProc(HWND_DESKTOP, Msg.message, Msg.wParam, Msg.lParam);
181.         if (Msg.pAdd) // this is a sync message. 
182.         {
183.             PSYNCMSG pSyncMsg = (PSYNCMSG)(Msg.pAdd);
184.             pSyncMsg->retval = iRet;
185.             sem_post(&pSyncMsg->sem_handle);
186.         } 
188. #ifdef _TRACE_MSG 
189.         fprintf (stderr, "Message, %s done, return value: %#x/n",
190.             Message2Str (Msg.message), iRet); 
191. #endif 
192.     }
194.     freeDesktopWindow ();
195.     FreeThreadInfo (__mg_dsk_threadinfo);
196.     return NULL;
197. }

 这个线程中有一个消息循环（line 167-192）会获得添加定时器的消息MSG_ADDTIMER，并调用其回调函数进行处理,
 
src/kernel/desktop-comm.c line 3104-3117

3104.         case MSG_ADDTIMER: 
3105. #ifdef _LITE_VERSION 
3106. #ifdef _STAND_ALONE 
3107.             if (sg_old_counter == 0)
3108.                 sg_old_counter = __mg_timer_counter; 
3109. #else 
3110.             if (sg_old_counter == 0)
3111.                 sg_old_counter = SHAREDRES_TIMER_COUNTER; 
3112. #endif 
3113. #endif 
3114.             return AddTimer (((PTIMER)lParam)->hWnd,
3115.                       ((PTIMER)lParam)->id,
3116.                       ((PTIMER)lParam)->speed);
3117.         break;

在处理消息MSG_ADDTIMER时，主要是调用函数AddTimer（）,在定时器结构数组timerstr[]中添加一个定时器结构。

 
src/kernel/timer.c line 311-386 

311. BOOL AddTimer (HWND hWnd, int id, unsigned int speed)
312. { 
313. #if 0 
314.     sigset_t sa_mask; 
315. #endif 
317.     int i;
318.     PMAINWIN pWin;
319.     PMSGQUEUE pMsgQueue;
320.     int slot;
322.     if (!(pWin = GetMainWindowPtrOfControl (hWnd))) return FALSE; 
324. #if 0 
325.     // block SIGALRM temporarily 
326.     sigemptyset (&sa_mask);
327.     sigaddset (&sa_mask, SIGALRM);
328.     pthread_sigmask (SIG_BLOCK, &sa_mask, NULL); 
329. #endif 
331.     pMsgQueue = pWin->pMessages;
332.     // Is there a empty timer slot? 
333.     for (slot=0; slot<DEF_NR_TIMERS; slot++) {
334.         if ((pMsgQueue->TimerMask >> slot) & 0x01)
335.             break;
336.     }
337.     if (slot == DEF_NR_TIMERS) goto badret;
339.     for (i=0; i<MAX_TIMERS; i++)
340.         if (timerstr[i] != NULL)
341.             if (timerstr[i]->hWnd == hWnd && timerstr[i]->id == id)
342.                 goto badret;
344.     for (i=0; i<MAX_TIMERS; i++)
345.         if (timerstr[i] == NULL)
346.             break;
348.     if (i == MAX_TIMERS)
349.         goto badret ;
351.     timerstr[i] = malloc (sizeof (TIMER)); 
353. #if _TIMER_UNIT_10MS 
354.     timerstr[i]->speed = speed; 
355. #else 
356.     timerstr[i]->speed = (1000<<7)/speed; 
357. #endif 
358.     timerstr[i]->hWnd = hWnd;
359.     timerstr[i]->id = id;
360.     timerstr[i]->count = 0;
362.     pMsgQueue->TimerOwner[slot] = hWnd;
363.     pMsgQueue->TimerID[slot] = id;
364.     pMsgQueue->TimerMask &= ~(0x01 << slot); 
366. #if 0 
367.     // unblock SIGALRM 
368.     pthread_sigmask (SIG_UNBLOCK, &sa_mask, NULL); 
369. #endif 
371. #if defined(_LITE_VERSION) && !defined(_STAND_ALONE) 
372.     if (!mgIsServer)
373.         set_select_timeout (USEC_10MS * speed); 
374. #endif 
376.     return TRUE;
377.     
378. badret: 
380. #if 0 
381.     // unblock SIGALRM 
382.     pthread_sigmask (SIG_UNBLOCK, &sa_mask, NULL); 
383. #endif 
385.     return FALSE;
386. }

 
3 、定时器消息的传递 

 
前面在时钟初始化的最后提到，SIGALRM信号的处理函数是__mg_timer_action。现在看看这个函数都做了哪些事情
 
src/kernel/timer.c line 75-93 

75. static void __mg_timer_action (void *data)
76. { 
77. #if defined(_LITE_VERSION) && !defined(_STAND_ALONE) 
78.     SHAREDRES_TIMER_COUNTER += 1; 
79. #else 
81. #if defined(__uClinux__) && defined(_STAND_ALONE) 
82.     __mg_timer_counter += 10; 
83. #else 
84.     __mg_timer_counter ++; 
85. #endif 
87. #endif 
89. #ifndef _LITE_VERSION 
90.     // alert desktop 
91.     AlertDesktopTimerEvent (); 
92. #endif 
93. }

首先将__mg_timer_counter加1，然后调用AlertDesktopTimerEvent()通知桌面线程过去了一个时钟间隔，
 
src/kernel/message.c line 195-199

195. void AlertDesktopTimerEvent (void)
196. {
197.     __mg_dsk_msgs->dwState |= 0x01;
198.     POST_MSGQ(__mg_dsk_msgs); 
199. }

 
注意这里通过 __mg_dsk_msgs->dwState |= 0x01; 标识消息队列中有了一个定时器消息。在桌面线程的消息循环中会检测这个标记
 
src/kernel/message.c line 571-586 

571. if (pMsgQueue->dwState & QS_TIMER && IS_MSG_WANTED(MSG_TIMER)) { 
572. #ifndef _LITE_VERSION 
573.         if (hWnd == HWND_DESKTOP) {
574.             pMsg->hwnd = hWnd;
575.             pMsg->message = MSG_TIMER;
576.             pMsg->wParam = 0;
577.             pMsg->lParam = 0;
578.             SET_PADD (NULL);
580.             if (uRemoveMsg == PM_REMOVE) {
581.                 pMsgQueue->dwState &= ~0x01;
582.             }
583.             UNLOCK_MSGQ (pMsgQueue);
584.             return 1;
585.         } 
586. #endif 
587.        ……

 
可以看到，这段代码的开头就对状态标志进行检测，QS_TIMR这window.h中定义
 
include/window.h line 1667 

1677. ＃define QS_TIMER    0x0000FFFF

这样就可以检测到AlertDesktopTimerEvent函数中设置的标志位。然后将这个消息放到一个消息数据结构中，发送给相应的消息处理函数。桌面线程的消息处理函数是DesktopWinProc，在desktop-comm.c文件中定义
 
src/kernel/desktop.c line 3243-3248 

3243.             DispatchTimerMessage (1);
3245.             if (__mg_timer_counter % 10 != 0)
3246.                 break;
3248.             uCounter += 100;

  
这段代码就是处理MSG_TIMER消息的，它调用了函数DispatchTimerMessage（），
 
src/kernel/timer.c line 273-309 

273. void DispatchTimerMessage (unsigned int inter)
274. {
275.     PMAINWIN pWin;
276.     PMSGQUEUE pMsgQueue;
277.     int i, slot;
279.     for ( i=0; i<MAX_TIMERS; i++ ) {
280.         if ( timerstr[i] ) { 
281. #if _TIMER_UNIT_10MS 
282.             timerstr[i]->count += inter; 
283. #else 
284.             timerstr[i]->count += 1<<7; 
285. #endif 
286.             if ( timerstr[i]->count >= timerstr[i]->speed ) {
288.                 pWin = GetMainWindowPtrOfControl (timerstr[i]->hWnd);
289.                 if (pWin == NULL) continue;
291.                 pMsgQueue = pWin->pMessages;
293.                 LOCK_MSGQ (pMsgQueue);
294.                 /* optimization: save slot in timerstr[i] */
295.                 for (slot=0; slot<DEF_NR_TIMERS; slot++) {
296.                     if (pMsgQueue->TimerID[slot] == timerstr[i]->id
297.                         && pMsgQueue->TimerOwner[slot] == timerstr[i]->hWnd)
298.                         break;
299.                 }
300.                 if (slot != DEF_NR_TIMERS) {
301.                     SetMsgQueueTimerFlag (pMsgQueue, slot);
302.                 }
303.                 UNLOCK_MSGQ (pMsgQueue);
304.                 
305.                 timerstr[i]->count -= timerstr[i]->speed;
306.             }
307.         }
308.     }
309. }

 
在创建定时器（SetTimer (HWND hWnd, int id, unsigned int speed)）时，传递的参数speed就是这个定时的长度有多少个时钟时间间隔，每个时间间隔是10ms。这个在初始化时钟时设置好的。在上的函数中先将时钟间隔计数的值加上传递进来的时间间隔数(line 282).然后与对应的speed进行比较，如果达到或超过这个间隔数就在对应的窗口消息队列标记中添加标记(line 301). 
  

在创建定时器（SetTimer (HWND hWnd, int id, unsigned int speed)）时，传递的参数hWnd就是想要获得定时器消息的那个窗口，在把定时器消息放到这个窗口的消息队列后，就可以由它的消息循环获得定时器消息MSG_TIMER了。注意，MSG_TIMER对应的wParam是定时器的id。如果同时有几个定时器发送MSG_TIMER消息，通过这个id可判断来自哪个定时器，以便做出相应处理。