?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 961023
[wine/multimedia.git] / windows / message.c
blob3e5f253cee9e432a32b04f7023061b1678eb7358
1 /*
2 * Message queues related functions
3 *
4 * Copyright 1993, 1994 Alexandre Julliard
5 */
6
7 #include <stdlib.h>
8 #include <string.h>
9 #include <ctype.h>
10 #include <sys/time.h>
11 #include <sys/types.h>
12
13 #include "message.h"
14 #include "win.h"
15 #include "gdi.h"
16 #include "sysmetrics.h"
17 #include "heap.h"
18 #include "hook.h"
19 #include "spy.h"
20 #include "winpos.h"
21 #include "atom.h"
22 #include "dde.h"
23 #include "queue.h"
24 #include "winproc.h"
25 #include "stddebug.h"
26 /* #define DEBUG_MSG */
27 #include "debug.h"
28
29 #define WM_NCMOUSEFIRST WM_NCMOUSEMOVE
30 #define WM_NCMOUSELAST WM_NCMBUTTONDBLCLK
31
32 #define HWND_BROADCAST16 ((HWND16)0xffff)
33 #define HWND_BROADCAST32 ((HWND32)0xffffffff)
34
35 #define ASCII_CHAR_HACK 0x0800
36
37 typedef enum { SYSQ_MSG_ABANDON, SYSQ_MSG_SKIP, SYSQ_MSG_ACCEPT } SYSQ_STATUS;
38
39 extern WPARAM16 lastEventChar; /* event.c */
40 extern BOOL MouseButtonsStates[3];
41 extern BOOL AsyncMouseButtonsStates[3];
42 extern BYTE KeyStateTable[256];
43 extern BYTE AsyncKeyStateTable[256];
44
45 extern MESSAGEQUEUE *pCursorQueue; /* queue.c */
46 extern MESSAGEQUEUE *pActiveQueue;
47
48 DWORD MSG_WineStartTicks; /* Ticks at Wine startup */
49
50 static WORD doubleClickSpeed = 452;
51 static INT32 debugSMRL = 0; /* intertask SendMessage() recursion level */
52
53 /***********************************************************************
54 * MSG_TranslateMouseMsg
55 *
56 * Translate an mouse hardware event into a real mouse message.
57 * Return value indicates whether the translated message must be passed
58 * to the user.
59 * Actions performed:
60 * - Find the window for this message.
61 * - Translate button-down messages in double-clicks.
62 * - Send the WM_NCHITTEST message to find where the cursor is.
63 * - Activate the window if needed.
64 * - Translate the message into a non-client message, or translate
65 * the coordinates to client coordinates.
66 * - Send the WM_SETCURSOR message.
67 */
68 static SYSQ_STATUS MSG_TranslateMouseMsg( MSG16 *msg, BOOL remove )
69 {
70 WND *pWnd;
71 BOOL eatMsg = FALSE;
72 INT16 hittest;
73 MOUSEHOOKSTRUCT16 *hook;
74 BOOL32 ret;
75 static DWORD lastClickTime = 0;
76 static WORD lastClickMsg = 0;
77 static POINT16 lastClickPos = { 0, 0 };
78 POINT16 pt = msg->pt;
79 MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16(GetTaskQueue(0));
80
81 BOOL mouseClick = ((msg->message == WM_LBUTTONDOWN) ||
82 (msg->message == WM_RBUTTONDOWN) ||
83 (msg->message == WM_MBUTTONDOWN));
84
85 /* Find the window */
86
87 if ((msg->hwnd = GetCapture16()) != 0)
88 {
89 BOOL32 ret;
90
91 ScreenToClient16( msg->hwnd, &pt );
92 msg->lParam = MAKELONG( pt.x, pt.y );
93 /* No need to further process the message */
94
95 if (!HOOK_GetHook( WH_MOUSE, GetTaskQueue(0)) ||
96 !(hook = SEGPTR_NEW(MOUSEHOOKSTRUCT16)))
97 return SYSQ_MSG_ACCEPT;
98 hook->pt = msg->pt;
99 hook->hwnd = msg->hwnd;
100 hook->wHitTestCode = HTCLIENT;
101 hook->dwExtraInfo = 0;
102 ret = !HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
103 msg->message, (LPARAM)SEGPTR_GET(hook));
104 SEGPTR_FREE(hook);
105 return ret ? SYSQ_MSG_ACCEPT : SYSQ_MSG_SKIP ;
106 }
107
108 hittest = WINPOS_WindowFromPoint( msg->pt, &pWnd );
109 if (pWnd->hmemTaskQ != GetTaskQueue(0))
110 {
111 /* Not for the current task */
112 if (queue) QUEUE_ClearWakeBit( queue, QS_MOUSE );
113 /* Wake up the other task */
114 queue = (MESSAGEQUEUE *)GlobalLock16( pWnd->hmemTaskQ );
115 if (queue) QUEUE_SetWakeBit( queue, QS_MOUSE );
116 return SYSQ_MSG_ABANDON;
117 }
118 pCursorQueue = queue;
119 msg->hwnd = pWnd->hwndSelf;
120
121 if ((hittest != HTERROR) && mouseClick)
122 {
123 HWND hwndTop = WIN_GetTopParent( msg->hwnd );
124
125 /* Send the WM_PARENTNOTIFY message */
126
127 WIN_SendParentNotify( msg->hwnd, msg->message, 0,
128 MAKELPARAM( msg->pt.x, msg->pt.y ) );
129
130 /* Activate the window if needed */
131
132 if (msg->hwnd != GetActiveWindow() &&
133 msg->hwnd != GetDesktopWindow16())
134 {
135 LONG ret = SendMessage16( msg->hwnd, WM_MOUSEACTIVATE, hwndTop,
136 MAKELONG( hittest, msg->message ) );
137
138 if ((ret == MA_ACTIVATEANDEAT) || (ret == MA_NOACTIVATEANDEAT))
139 eatMsg = TRUE;
140
141 if (((ret == MA_ACTIVATE) || (ret == MA_ACTIVATEANDEAT))
142 && hwndTop != GetActiveWindow() )
143 WINPOS_SetActiveWindow( hwndTop, TRUE , TRUE );
144 }
145 }
146
147 /* Send the WM_SETCURSOR message */
148
149 SendMessage16( msg->hwnd, WM_SETCURSOR, (WPARAM16)msg->hwnd,
150 MAKELONG( hittest, msg->message ));
151 if (eatMsg) return SYSQ_MSG_SKIP;
152
153 /* Check for double-click */
154
155 if (mouseClick)
156 {
157 BOOL dbl_click = FALSE;
158
159 if ((msg->message == lastClickMsg) &&
160 (msg->time - lastClickTime < doubleClickSpeed) &&
161 (abs(msg->pt.x - lastClickPos.x) < SYSMETRICS_CXDOUBLECLK/2) &&
162 (abs(msg->pt.y - lastClickPos.y) < SYSMETRICS_CYDOUBLECLK/2))
163 dbl_click = TRUE;
164
165 if (dbl_click && (hittest == HTCLIENT))
166 {
167 /* Check whether window wants the double click message. */
168 dbl_click = (pWnd->class->style & CS_DBLCLKS) != 0;
169 }
170
171 if (dbl_click) switch(msg->message)
172 {
173 case WM_LBUTTONDOWN: msg->message = WM_LBUTTONDBLCLK; break;
174 case WM_RBUTTONDOWN: msg->message = WM_RBUTTONDBLCLK; break;
175 case WM_MBUTTONDOWN: msg->message = WM_MBUTTONDBLCLK; break;
176 }
177
178 if (remove)
179 {
180 lastClickTime = msg->time;
181 lastClickMsg = msg->message;
182 lastClickPos = msg->pt;
183 }
184 }
185
186 /* Build the translated message */
187
188 if (hittest == HTCLIENT)
189 ScreenToClient16( msg->hwnd, &pt );
190 else
191 {
192 msg->wParam = hittest;
193 msg->message += WM_NCLBUTTONDOWN - WM_LBUTTONDOWN;
194 }
195 msg->lParam = MAKELONG( pt.x, pt.y );
196
197 /* Call the WH_MOUSE hook */
198
199 if (!HOOK_GetHook( WH_MOUSE, GetTaskQueue(0)) ||
200 !(hook = SEGPTR_NEW(MOUSEHOOKSTRUCT16)))
201 return SYSQ_MSG_ACCEPT;
202
203 hook->pt = msg->pt;
204 hook->hwnd = msg->hwnd;
205 hook->wHitTestCode = hittest;
206 hook->dwExtraInfo = 0;
207 ret = !HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
208 msg->message, (LPARAM)SEGPTR_GET(hook) );
209 SEGPTR_FREE(hook);
210 return ret ? SYSQ_MSG_ACCEPT : SYSQ_MSG_SKIP;
211 }
212
213
214 /***********************************************************************
215 * MSG_TranslateKeyboardMsg
216 *
217 * Translate an keyboard hardware event into a real message.
218 * Return value indicates whether the translated message must be passed
219 * to the user.
220 */
221 static SYSQ_STATUS MSG_TranslateKeyboardMsg( MSG16 *msg, BOOL remove )
222 {
223 WND *pWnd;
224
225 /* Should check Ctrl-Esc and PrintScreen here */
226
227 msg->hwnd = GetFocus16();
228 if (!msg->hwnd)
229 {
230 /* Send the message to the active window instead, */
231 /* translating messages to their WM_SYS equivalent */
232
233 msg->hwnd = GetActiveWindow();
234
235 if( msg->message < WM_SYSKEYDOWN )
236 msg->message += WM_SYSKEYDOWN - WM_KEYDOWN;
237 }
238 pWnd = WIN_FindWndPtr( msg->hwnd );
239 if (pWnd && (pWnd->hmemTaskQ != GetTaskQueue(0)))
240 {
241 /* Not for the current task */
242 MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) );
243 if (queue) QUEUE_ClearWakeBit( queue, QS_KEY );
244 /* Wake up the other task */
245 queue = (MESSAGEQUEUE *)GlobalLock16( pWnd->hmemTaskQ );
246 if (queue) QUEUE_SetWakeBit( queue, QS_KEY );
247 return SYSQ_MSG_ABANDON;
248 }
249 return (HOOK_CallHooks( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
250 msg->wParam, msg->lParam ))
251 ? SYSQ_MSG_SKIP : SYSQ_MSG_ACCEPT;
252 }
253
254
255 /***********************************************************************
256 * MSG_JournalRecordMsg
257 *
258 * Build an EVENTMSG structure and call JOURNALRECORD hook
259 */
260 static void MSG_JournalRecordMsg( MSG16 *msg )
261 {
262 EVENTMSG16 *event = SEGPTR_NEW(EVENTMSG16);
263 if (!event) return;
264 event->message = msg->message;
265 event->time = msg->time;
266 if ((msg->message >= WM_KEYFIRST) && (msg->message <= WM_KEYLAST))
267 {
268 event->paramL = (msg->wParam & 0xFF) | (HIWORD(msg->lParam) << 8);
269 event->paramH = msg->lParam & 0x7FFF;
270 if (HIWORD(msg->lParam) & 0x0100)
271 event->paramH |= 0x8000; /* special_key - bit */
272 HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0,
273 (LPARAM)SEGPTR_GET(event) );
274 }
275 else if ((msg->message >= WM_MOUSEFIRST) && (msg->message <= WM_MOUSELAST))
276 {
277 event->paramL = LOWORD(msg->lParam); /* X pos */
278 event->paramH = HIWORD(msg->lParam); /* Y pos */
279 ClientToScreen16( msg->hwnd, (LPPOINT16)&event->paramL );
280 HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0,
281 (LPARAM)SEGPTR_GET(event) );
282 }
283 else if ((msg->message >= WM_NCMOUSEFIRST) &&
284 (msg->message <= WM_NCMOUSELAST))
285 {
286 event->paramL = LOWORD(msg->lParam); /* X pos */
287 event->paramH = HIWORD(msg->lParam); /* Y pos */
288 event->message += WM_MOUSEMOVE-WM_NCMOUSEMOVE;/* give no info about NC area */
289 HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0,
290 (LPARAM)SEGPTR_GET(event) );
291 }
292 SEGPTR_FREE(event);
293 }
294
295 /*****************************************************************
296 * MSG_JournalPlayBackIsAscii
297 */
298 static BOOL MSG_JournalPlayBackIsAscii(WPARAM16 wParam)
299 {
300 return ((wParam>VK_HELP && wParam<VK_F1) ||
301 wParam == VK_SPACE ||
302 wParam == VK_ESCAPE ||
303 wParam == VK_RETURN ||
304 wParam == VK_TAB ||
305 wParam == VK_BACK);
306 }
307
308
309 /***********************************************************************
310 * MSG_JournalPlayBackMsg
311 *
312 * Get an EVENTMSG struct via call JOURNALPAYBACK hook function
313 */
314 static int MSG_JournalPlayBackMsg(void)
315 {
316 EVENTMSG16 *tmpMsg;
317 long wtime,lParam;
318 WORD keyDown,i,wParam,result=0;
319
320 if ( HOOK_GetHook(WH_JOURNALPLAYBACK, 0) )
321 {
322 tmpMsg = SEGPTR_NEW(EVENTMSG16);
323 wtime=HOOK_CallHooks( WH_JOURNALPLAYBACK, HC_GETNEXT, 0, (LPARAM)SEGPTR_GET(tmpMsg));
324 /* dprintf_msg(stddeb,"Playback wait time =%ld\n",wtime); */
325 if (wtime<=0)
326 {
327 wtime=0;
328 if ((tmpMsg->message>= WM_KEYFIRST) && (tmpMsg->message <= WM_KEYLAST))
329 {
330 wParam=tmpMsg->paramL & 0xFF;
331 lParam=MAKELONG(tmpMsg->paramH&0x7ffff,tmpMsg->paramL>>8);
332 if (tmpMsg->message == WM_KEYDOWN || tmpMsg->message == WM_SYSKEYDOWN)
333 {
334 for (keyDown=i=0; i<256 && !keyDown; i++)
335 if (KeyStateTable[i] & 0x80)
336 keyDown++;
337 if (!keyDown)
338 lParam |= 0x40000000;
339 AsyncKeyStateTable[wParam]=KeyStateTable[wParam] |= 0x80;
340 if (MSG_JournalPlayBackIsAscii(wParam))
341 {
342 lastEventChar= wParam; /* control TranslateMessage() */
343 lParam |= (LONG)((LONG)ASCII_CHAR_HACK*0x10000L);
344
345 if (!(KeyStateTable[VK_SHIFT] & 0x80) &&
346 !(KeyStateTable[VK_CAPITAL] & 0x80))
347 lastEventChar= tolower(lastEventChar);
348 if (KeyStateTable[VK_CONTROL] & 0x80)
349 lastEventChar&=0x1f;
350 }
351 }
352 else /* WM_KEYUP, WM_SYSKEYUP */
353 {
354 lParam |= 0xC0000000;
355 AsyncKeyStateTable[wParam]=KeyStateTable[wParam] &= ~0x80;
356 }
357 if (KeyStateTable[VK_MENU] & 0x80)
358 lParam |= 0x20000000;
359 if (tmpMsg->paramH & 0x8000) /*special_key bit*/
360 lParam |= 0x01000000;
361 hardware_event( tmpMsg->message, wParam, lParam,0, 0, tmpMsg->time, 0 );
362 }
363 else
364 {
365 if ((tmpMsg->message>= WM_MOUSEFIRST) && (tmpMsg->message <= WM_MOUSELAST))
366 {
367 switch (tmpMsg->message)
368 {
369 case WM_LBUTTONDOWN:MouseButtonsStates[0]=AsyncMouseButtonsStates[0]=1;break;
370 case WM_LBUTTONUP: MouseButtonsStates[0]=AsyncMouseButtonsStates[0]=0;break;
371 case WM_MBUTTONDOWN:MouseButtonsStates[1]=AsyncMouseButtonsStates[1]=1;break;
372 case WM_MBUTTONUP: MouseButtonsStates[1]=AsyncMouseButtonsStates[1]=0;break;
373 case WM_RBUTTONDOWN:MouseButtonsStates[2]=AsyncMouseButtonsStates[2]=1;break;
374 case WM_RBUTTONUP: MouseButtonsStates[2]=AsyncMouseButtonsStates[2]=0;break;
375 }
376 AsyncKeyStateTable[VK_LBUTTON]= KeyStateTable[VK_LBUTTON] = MouseButtonsStates[0] << 8;
377 AsyncKeyStateTable[VK_MBUTTON]= KeyStateTable[VK_MBUTTON] = MouseButtonsStates[1] << 8;
378 AsyncKeyStateTable[VK_RBUTTON]= KeyStateTable[VK_RBUTTON] = MouseButtonsStates[2] << 8;
379 SetCursorPos(tmpMsg->paramL,tmpMsg->paramH);
380 lParam=MAKELONG(tmpMsg->paramL,tmpMsg->paramH);
381 wParam=0;
382 if (MouseButtonsStates[0]) wParam |= MK_LBUTTON;
383 if (MouseButtonsStates[1]) wParam |= MK_MBUTTON;
384 if (MouseButtonsStates[2]) wParam |= MK_RBUTTON;
385 hardware_event( tmpMsg->message, wParam, lParam,
386 tmpMsg->paramL, tmpMsg->paramH, tmpMsg->time, 0 );
387 }
388 }
389 HOOK_CallHooks( WH_JOURNALPLAYBACK, HC_SKIP, 0, (LPARAM)SEGPTR_GET(tmpMsg));
390 }
391 else
392 result= QS_MOUSE | QS_KEY;
393 SEGPTR_FREE(tmpMsg);
394 }
395 return result;
396 }
397
398 /***********************************************************************
399 * MSG_PeekHardwareMsg
400 *
401 * Peek for a hardware message matching the hwnd and message filters.
402 */
403 static BOOL MSG_PeekHardwareMsg( MSG16 *msg, HWND hwnd, WORD first, WORD last,
404 BOOL remove )
405 {
406 SYSQ_STATUS status = SYSQ_MSG_ACCEPT;
407 MESSAGEQUEUE *sysMsgQueue = QUEUE_GetSysQueue();
408 int i, pos = sysMsgQueue->nextMessage;
409
410 /* If the queue is empty, attempt to fill it */
411 if (!sysMsgQueue->msgCount && XPending(display))
412 EVENT_WaitXEvent( FALSE, FALSE );
413
414 for (i = 0; i < sysMsgQueue->msgCount; i++, pos++)
415 {
416 if (pos >= sysMsgQueue->queueSize) pos = 0;
417 *msg = sysMsgQueue->messages[pos].msg;
418
419 /* Translate message; return FALSE immediately on SYSQ_MSG_ABANDON */
420
421 if ((msg->message >= WM_MOUSEFIRST) && (msg->message <= WM_MOUSELAST))
422 {
423 if ((status = MSG_TranslateMouseMsg(msg,remove)) == SYSQ_MSG_ABANDON)
424 return FALSE;
425 }
426 else if ((msg->message >= WM_KEYFIRST) && (msg->message <= WM_KEYLAST))
427 {
428 if ((status = MSG_TranslateKeyboardMsg(msg,remove)) == SYSQ_MSG_ABANDON)
429 return FALSE;
430 }
431 else /* Non-standard hardware event */
432 {
433 HARDWAREHOOKSTRUCT16 *hook;
434 if ((hook = SEGPTR_NEW(HARDWAREHOOKSTRUCT16)))
435 {
436 BOOL32 ret;
437 hook->hWnd = msg->hwnd;
438 hook->wMessage = msg->message;
439 hook->wParam = msg->wParam;
440 hook->lParam = msg->lParam;
441 ret = HOOK_CallHooks( WH_HARDWARE,
442 remove ? HC_ACTION : HC_NOREMOVE,
443 0, (LPARAM)SEGPTR_GET(hook) );
444 SEGPTR_FREE(hook);
445 status = ret ? SYSQ_MSG_SKIP : SYSQ_MSG_ACCEPT;
446 }
447 }
448
449 if (status == SYSQ_MSG_SKIP)
450 {
451 if (remove) QUEUE_RemoveMsg( sysMsgQueue, pos );
452 /* FIXME: call CBT_CLICKSKIPPED from here */
453 continue;
454 }
455
456 /* Check message against filters */
457
458 if (hwnd && (msg->hwnd != hwnd)) continue;
459 if ((first || last) &&
460 ((msg->message < first) || (msg->message > last))) continue;
461 if (remove)
462 {
463 if (HOOK_GetHook( WH_JOURNALRECORD, GetTaskQueue(0) ))
464 MSG_JournalRecordMsg( msg );
465 QUEUE_RemoveMsg( sysMsgQueue, pos );
466 }
467 return TRUE;
468 }
469 return FALSE;
470 }
471
472
473 /**********************************************************************
474 * SetDoubleClickTime (USER.20)
475 */
476 void SetDoubleClickTime( WORD interval )
477 {
478 doubleClickSpeed = interval ? interval : 500;
479 }
480
481
482 /**********************************************************************
483 * GetDoubleClickTime (USER.21)
484 */
485 WORD GetDoubleClickTime()
486 {
487 return doubleClickSpeed;
488 }
489
490
491 /***********************************************************************
492 * MSG_SendMessage
493 *
494 * Implementation of an inter-task SendMessage.
495 */
496 static LRESULT MSG_SendMessage( HQUEUE16 hDestQueue, HWND hwnd, UINT msg,
497 WPARAM16 wParam, LPARAM lParam )
498 {
499 INT32 prevSMRL = debugSMRL;
500 QSMCTRL qCtrl = { 0, 1};
501 MESSAGEQUEUE *queue, *destQ;
502
503 if (!(queue = (MESSAGEQUEUE*)GlobalLock16( GetTaskQueue(0) ))) return 0;
504 if (!(destQ = (MESSAGEQUEUE*)GlobalLock16( hDestQueue ))) return 0;
505
506 if (IsTaskLocked() || !IsWindow(hwnd)) return 0;
507
508 debugSMRL+=4;
509 dprintf_sendmsg(stddeb,"%*sSM: %s [%04x] (%04x -> %04x)\n",
510 prevSMRL, "", SPY_GetMsgName(msg), msg, queue->self, hDestQueue );
511
512 if( !(queue->wakeBits & QS_SMPARAMSFREE) )
513 {
514 dprintf_sendmsg(stddeb,"\tIntertask SendMessage: sleeping since unreplied SendMessage pending\n");
515 queue->changeBits &= ~QS_SMPARAMSFREE;
516 QUEUE_WaitBits( QS_SMPARAMSFREE );
517 }
518
519 /* resume sending */
520
521 queue->hWnd = hwnd;
522 queue->msg = msg;
523 queue->wParam = wParam;
524 queue->lParam = lParam;
525 queue->hPrevSendingTask = destQ->hSendingTask;
526 destQ->hSendingTask = GetTaskQueue(0);
527
528 queue->wakeBits &= ~QS_SMPARAMSFREE;
529
530 dprintf_sendmsg(stddeb,"%*ssm: smResultInit = %08x\n", prevSMRL, "", (unsigned)&qCtrl);
531
532 queue->smResultInit = &qCtrl;
533
534 QUEUE_SetWakeBit( destQ, QS_SENDMESSAGE );
535
536 /* perform task switch and wait for the result */
537
538 while( qCtrl.bPending )
539 {
540 if (!(queue->wakeBits & QS_SMRESULT))
541 {
542 queue->changeBits &= ~QS_SMRESULT;
543 DirectedYield( destQ->hTask );
544 QUEUE_WaitBits( QS_SMRESULT );
545 dprintf_sendmsg(stddeb,"\tsm: have result!\n");
546 }
547 /* got something */
548
549 dprintf_sendmsg(stddeb,"%*ssm: smResult = %08x\n", prevSMRL, "", (unsigned)queue->smResult );
550
551 queue->smResult->lResult = queue->SendMessageReturn;
552 queue->smResult->bPending = FALSE;
553 queue->wakeBits &= ~QS_SMRESULT;
554
555 if( queue->smResult != &qCtrl )
556 dprintf_msg(stddeb,"%*ssm: weird scenes inside the goldmine!\n", prevSMRL, "");
557 }
558 queue->smResultInit = NULL;
559
560 dprintf_sendmsg(stddeb,"%*sSM: [%04x] returning %08lx\n", prevSMRL, "", msg, qCtrl.lResult);
561 debugSMRL-=4;
562
563 return qCtrl.lResult;
564 }
565
566
567 /***********************************************************************
568 * ReplyMessage (USER.115)
569 */
570 void ReplyMessage( LRESULT result )
571 {
572 MESSAGEQUEUE *senderQ;
573 MESSAGEQUEUE *queue;
574
575 if (!(queue = (MESSAGEQUEUE*)GlobalLock16( GetTaskQueue(0) ))) return;
576
577 dprintf_msg(stddeb,"ReplyMessage, queue %04x\n", queue->self);
578
579 while( (senderQ = (MESSAGEQUEUE*)GlobalLock16( queue->InSendMessageHandle)))
580 {
581 dprintf_msg(stddeb,"\trpm: replying to %04x (%04x -> %04x)\n",
582 queue->msg, queue->self, senderQ->self);
583
584 if( queue->wakeBits & QS_SENDMESSAGE )
585 {
586 QUEUE_ReceiveMessage( queue );
587 continue; /* ReceiveMessage() already called us */
588 }
589
590 if(!(senderQ->wakeBits & QS_SMRESULT) ) break;
591 OldYield();
592 }
593 if( !senderQ ) { dprintf_msg(stddeb,"\trpm: done\n"); return; }
594
595 senderQ->SendMessageReturn = result;
596 dprintf_msg(stddeb,"\trpm: smResult = %08x, result = %08lx\n",
597 (unsigned)queue->smResultCurrent, result );
598
599 senderQ->smResult = queue->smResultCurrent;
600 queue->InSendMessageHandle = 0;
601
602 QUEUE_SetWakeBit( senderQ, QS_SMRESULT );
603 DirectedYield( queue->hSendingTask );
604 }
605
606
607 /***********************************************************************
608 * MSG_PeekMessage
609 */
610 static BOOL MSG_PeekMessage( LPMSG16 msg, HWND hwnd, WORD first, WORD last,
611 WORD flags, BOOL peek )
612 {
613 int pos, mask;
614 MESSAGEQUEUE *msgQueue;
615 HQUEUE16 hQueue;
616
617 #ifdef CONFIG_IPC
618 DDE_TestDDE(hwnd); /* do we have dde handling in the window ?*/
619 DDE_GetRemoteMessage();
620 #endif /* CONFIG_IPC */
621
622 mask = QS_POSTMESSAGE | QS_SENDMESSAGE; /* Always selected */
623 if (first || last)
624 {
625 /* MSWord gets stuck if we do not check for nonclient mouse messages */
626
627 if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
628 if ( ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) ||
629 ((first <= WM_NCMOUSELAST) && (last >= WM_NCMOUSEFIRST)) ) mask |= QS_MOUSE;
630 if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
631 if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
632 if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
633 }
634 else mask |= QS_MOUSE | QS_KEY | QS_TIMER | QS_PAINT;
635
636 if (IsTaskLocked()) flags |= PM_NOYIELD;
637
638 while(1)
639 {
640 hQueue = GetTaskQueue(0);
641 msgQueue = (MESSAGEQUEUE *)GlobalLock16( hQueue );
642 if (!msgQueue) return FALSE;
643 msgQueue->changeBits = 0;
644
645 /* First handle a message put by SendMessage() */
646
647 if (msgQueue->wakeBits & QS_SENDMESSAGE)
648 QUEUE_ReceiveMessage( msgQueue );
649
650 /* Now handle a WM_QUIT message
651 *
652 * FIXME: PostQuitMessage() should post WM_QUIT and
653 * set QS_POSTMESSAGE wakebit instead of this.
654 */
655
656 if (msgQueue->wPostQMsg &&
657 (!first || WM_QUIT >= first) &&
658 (!last || WM_QUIT <= last) )
659 {
660 msg->hwnd = hwnd;
661 msg->message = WM_QUIT;
662 msg->wParam = msgQueue->wExitCode;
663 msg->lParam = 0;
664 break;
665 }
666
667 /* Now find a normal message */
668
669 if (((msgQueue->wakeBits & mask) & QS_POSTMESSAGE) &&
670 ((pos = QUEUE_FindMsg( msgQueue, hwnd, first, last )) != -1))
671 {
672 QMSG *qmsg = &msgQueue->messages[pos];
673 *msg = qmsg->msg;
674 msgQueue->GetMessageTimeVal = msg->time;
675 msgQueue->GetMessagePosVal = *(DWORD *)&msg->pt;
676 msgQueue->GetMessageExtraInfoVal = qmsg->extraInfo;
677
678 if (flags & PM_REMOVE) QUEUE_RemoveMsg( msgQueue, pos );
679 break;
680 }
681
682 msgQueue->changeBits |= MSG_JournalPlayBackMsg();
683
684 /* Now find a hardware event */
685
686 if (((msgQueue->wakeBits & mask) & (QS_MOUSE | QS_KEY)) &&
687 MSG_PeekHardwareMsg( msg, hwnd, first, last, flags & PM_REMOVE ))
688 {
689 /* Got one */
690 msgQueue->GetMessageTimeVal = msg->time;
691 msgQueue->GetMessagePosVal = *(DWORD *)&msg->pt;
692 msgQueue->GetMessageExtraInfoVal = 0; /* Always 0 for now */
693 break;
694 }
695
696 /* Check again for SendMessage */
697
698 if (msgQueue->wakeBits & QS_SENDMESSAGE)
699 QUEUE_ReceiveMessage( msgQueue );
700
701 /* Now find a WM_PAINT message */
702
703 if ((msgQueue->wakeBits & mask) & QS_PAINT)
704 {
705 WND* wndPtr;
706 msg->hwnd = WIN_FindWinToRepaint( hwnd , hQueue );
707 msg->message = WM_PAINT;
708 msg->wParam = 0;
709 msg->lParam = 0;
710
711 if ((wndPtr = WIN_FindWndPtr(msg->hwnd)))
712 {
713 if( wndPtr->dwStyle & WS_MINIMIZE &&
714 wndPtr->class->hIcon )
715 {
716 msg->message = WM_PAINTICON;
717 msg->wParam = 1;
718 }
719
720 if( !hwnd || msg->hwnd == hwnd || IsChild(hwnd,msg->hwnd) )
721 {
722 if( wndPtr->flags & WIN_INTERNAL_PAINT && !wndPtr->hrgnUpdate)
723 {
724 wndPtr->flags &= ~WIN_INTERNAL_PAINT;
725 QUEUE_DecPaintCount( hQueue );
726 }
727 break;
728 }
729 }
730 }
731
732 /* Check for timer messages, but yield first */
733
734 if (!(flags & PM_NOYIELD))
735 {
736 UserYield();
737 if (msgQueue->wakeBits & QS_SENDMESSAGE)
738 QUEUE_ReceiveMessage( msgQueue );
739 }
740 if ((msgQueue->wakeBits & mask) & QS_TIMER)
741 {
742 if (TIMER_GetTimerMsg(msg, hwnd, hQueue, flags & PM_REMOVE)) break;
743 }
744
745 if (peek)
746 {
747 if (!(flags & PM_NOYIELD)) UserYield();
748 return FALSE;
749 }
750 msgQueue->wakeMask = mask;
751 QUEUE_WaitBits( mask );
752 }
753
754 /* We got a message */
755 if (peek) return TRUE;
756 else return (msg->message != WM_QUIT);
757 }
758
759
760 /***********************************************************************
761 * MSG_InternalGetMessage
762 *
763 * GetMessage() function for internal use. Behave like GetMessage(),
764 * but also call message filters and optionally send WM_ENTERIDLE messages.
765 * 'hwnd' must be the handle of the dialog or menu window.
766 * 'code' is the message filter value (MSGF_??? codes).
767 */
768 BOOL32 MSG_InternalGetMessage( MSG16 *msg, HWND32 hwnd, HWND32 hwndOwner,
769 WPARAM32 code, WORD flags, BOOL32 sendIdle )
770 {
771 for (;;)
772 {
773 if (sendIdle)
774 {
775 if (!MSG_PeekMessage( msg, 0, 0, 0, flags, TRUE ))
776 {
777 /* No message present -> send ENTERIDLE and wait */
778 if (IsWindow(hwndOwner))
779 SendMessage16( hwndOwner, WM_ENTERIDLE,
780 code, (LPARAM)hwnd );
781 MSG_PeekMessage( msg, 0, 0, 0, flags, FALSE );
782 }
783 }
784 else /* Always wait for a message */
785 MSG_PeekMessage( msg, 0, 0, 0, flags, FALSE );
786
787 /* Call message filters */
788
789 if (HOOK_GetHook( WH_SYSMSGFILTER, GetTaskQueue(0) ) ||
790 HOOK_GetHook( WH_MSGFILTER, GetTaskQueue(0) ))
791 {
792 MSG16 *pmsg = SEGPTR_NEW(MSG16);
793 if (pmsg)
794 {
795 BOOL32 ret;
796 *pmsg = *msg;
797 ret = ((BOOL16)HOOK_CallHooks( WH_SYSMSGFILTER, code, 0,
798 (LPARAM)SEGPTR_GET(pmsg) ) ||
799 (BOOL16)HOOK_CallHooks( WH_MSGFILTER, code, 0,
800 (LPARAM)SEGPTR_GET(pmsg) ));
801 SEGPTR_FREE(pmsg);
802 if (ret)
803 {
804 /* Message filtered -> remove it from the queue */
805 /* if it's still there. */
806 if (!(flags & PM_REMOVE))
807 MSG_PeekMessage( msg, 0, 0, 0, PM_REMOVE, TRUE );
808 continue;
809 }
810 }
811 }
812
813 return (msg->message != WM_QUIT);
814 }
815 }
816
817
818 /***********************************************************************
819 * PeekMessage16 (USER.109)
820 */
821 BOOL16 PeekMessage16( LPMSG16 msg, HWND16 hwnd, UINT16 first,
822 UINT16 last, UINT16 flags )
823 {
824 return MSG_PeekMessage( msg, hwnd, first, last, flags, TRUE );
825 }
826
827
828 /***********************************************************************
829 * GetMessage (USER.108)
830 */
831 BOOL GetMessage( SEGPTR msg, HWND hwnd, UINT first, UINT last )
832 {
833 MSG16 *lpmsg = (MSG16 *)PTR_SEG_TO_LIN(msg);
834 MSG_PeekMessage( lpmsg,
835 hwnd, first, last, PM_REMOVE, FALSE );
836
837 dprintf_msg(stddeb,"message %04x, hwnd %04x, filter(%04x - %04x)\n", lpmsg->message,
838 hwnd, first, last );
839 HOOK_CallHooks( WH_GETMESSAGE, HC_ACTION, 0, (LPARAM)msg );
840 return (lpmsg->message != WM_QUIT);
841 }
842
843
844 /***********************************************************************
845 * PostMessage (USER.110)
846 */
847 BOOL PostMessage( HWND hwnd, WORD message, WORD wParam, LONG lParam )
848 {
849 MSG16 msg;
850 WND *wndPtr;
851
852 msg.hwnd = hwnd;
853 msg.message = message;
854 msg.wParam = wParam;
855 msg.lParam = lParam;
856 msg.time = GetTickCount();
857 msg.pt.x = 0;
858 msg.pt.y = 0;
859
860 #ifdef CONFIG_IPC
861 if (DDE_PostMessage(&msg))
862 return TRUE;
863 #endif /* CONFIG_IPC */
864
865 if (hwnd == HWND_BROADCAST16)
866 {
867 dprintf_msg(stddeb,"PostMessage // HWND_BROADCAST !\n");
868 for (wndPtr = WIN_GetDesktop()->child; wndPtr; wndPtr = wndPtr->next)
869 {
870 if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
871 {
872 dprintf_msg(stddeb,"BROADCAST Message to hWnd=%04x m=%04X w=%04X l=%08lX !\n",
873 wndPtr->hwndSelf, message, wParam, lParam);
874 PostMessage( wndPtr->hwndSelf, message, wParam, lParam );
875 }
876 }
877 dprintf_msg(stddeb,"PostMessage // End of HWND_BROADCAST !\n");
878 return TRUE;
879 }
880
881 wndPtr = WIN_FindWndPtr( hwnd );
882 if (!wndPtr || !wndPtr->hmemTaskQ) return FALSE;
883
884 return QUEUE_AddMsg( wndPtr->hmemTaskQ, &msg, 0 );
885 }
886
887 /***********************************************************************
888 * PostAppMessage16 (USER.116)
889 */
890 BOOL16 PostAppMessage16( HTASK16 hTask, UINT16 message, WPARAM16 wParam,
891 LPARAM lParam )
892 {
893 MSG16 msg;
894
895 if (GetTaskQueue(hTask) == 0) return FALSE;
896 msg.hwnd = 0;
897 msg.message = message;
898 msg.wParam = wParam;
899 msg.lParam = lParam;
900 msg.time = GetTickCount();
901 msg.pt.x = 0;
902 msg.pt.y = 0;
903
904 return QUEUE_AddMsg( GetTaskQueue(hTask), &msg, 0 );
905 }
906
907
908 /***********************************************************************
909 * SendMessage16 (USER.111)
910 */
911 LRESULT SendMessage16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam)
912 {
913 WND * wndPtr;
914 LRESULT ret;
915
916 #ifdef CONFIG_IPC
917 MSG16 DDE_msg = { hwnd, msg, wParam, lParam };
918 if (DDE_SendMessage(&DDE_msg)) return TRUE;
919 #endif /* CONFIG_IPC */
920
921 if (hwnd == HWND_BROADCAST16)
922 {
923 dprintf_msg(stddeb,"SendMessage // HWND_BROADCAST !\n");
924 for (wndPtr = WIN_GetDesktop()->child; wndPtr; wndPtr = wndPtr->next)
925 {
926 if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
927 {
928 dprintf_msg(stddeb,"BROADCAST Message to hWnd=%04x m=%04X w=%04lX l=%08lX !\n",
929 wndPtr->hwndSelf, msg, (DWORD)wParam, lParam);
930 SendMessage16( wndPtr->hwndSelf, msg, wParam, lParam );
931 }
932 }
933 dprintf_msg(stddeb,"SendMessage // End of HWND_BROADCAST !\n");
934 return TRUE;
935 }
936
937 if (HOOK_GetHook( WH_CALLWNDPROC, GetTaskQueue(0) ))
938 {
939 struct msgstruct
940 {
941 LPARAM lParam;
942 WPARAM16 wParam;
943 UINT16 wMsg;
944 HWND16 hWnd;
945 } *pmsg;
946
947 if ((pmsg = SEGPTR_NEW(struct msgstruct)))
948 {
949 pmsg->hWnd = hwnd;
950 pmsg->wMsg = msg;
951 pmsg->wParam = wParam;
952 pmsg->lParam = lParam;
953 HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 1,
954 (LPARAM)SEGPTR_GET(pmsg) );
955 hwnd = pmsg->hWnd;
956 msg = pmsg->wMsg;
957 wParam = pmsg->wParam;
958 lParam = pmsg->lParam;
959 SEGPTR_FREE( pmsg );
960 }
961 }
962
963 if (!(wndPtr = WIN_FindWndPtr( hwnd )))
964 {
965 fprintf( stderr, "SendMessage16: invalid hwnd %04x\n", hwnd );
966 return 0;
967 }
968 if (QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ))
969 return 0; /* Don't send anything if the task is dying */
970 if (wndPtr->hmemTaskQ != GetTaskQueue(0))
971 return MSG_SendMessage( wndPtr->hmemTaskQ, hwnd, msg, wParam, lParam );
972
973 SPY_EnterMessage( SPY_SENDMESSAGE16, hwnd, msg, wParam, lParam );
974 ret = CallWindowProc16( (WNDPROC16)wndPtr->winproc,
975 hwnd, msg, wParam, lParam );
976 SPY_ExitMessage( SPY_RESULT_OK16, hwnd, msg, ret );
977 return ret;
978 }
979
980
981 /***********************************************************************
982 * SendMessage32A (USER32.453)
983 */
984 LRESULT SendMessage32A(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
985 {
986 WND * wndPtr;
987 LRESULT ret;
988
989 if (hwnd == HWND_BROADCAST32)
990 {
991 for (wndPtr = WIN_GetDesktop()->child; wndPtr; wndPtr = wndPtr->next)
992 {
993 /* FIXME: should use something like EnumWindows here */
994 if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
995 SendMessage32A( wndPtr->hwndSelf, msg, wParam, lParam );
996 }
997 return TRUE;
998 }
999
1000 /* FIXME: call hooks */
1001
1002 if (!(wndPtr = WIN_FindWndPtr( hwnd )))
1003 {
1004 fprintf( stderr, "SendMessage32A: invalid hwnd %08x\n", hwnd );
1005 return 0;
1006 }
1007
1008 if (WINPROC_GetProcType( wndPtr->winproc ) == WIN_PROC_16)
1009 {
1010 /* Use SendMessage16 for now to get hooks right */
1011 UINT16 msg16;
1012 WPARAM16 wParam16;
1013 if (WINPROC_MapMsg32ATo16( msg, wParam, &msg16, &wParam16, &lParam ) == -1)
1014 return 0;
1015 ret = SendMessage16( hwnd, msg16, wParam16, lParam );
1016 WINPROC_UnmapMsg32ATo16( msg16, wParam16, lParam );
1017 return ret;
1018 }
1019
1020 if (QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ))
1021 return 0; /* Don't send anything if the task is dying */
1022
1023 if (wndPtr->hmemTaskQ != GetTaskQueue(0))
1024 {
1025 fprintf( stderr, "SendMessage32A: intertask message not supported\n" );
1026 return 0;
1027 }
1028
1029 SPY_EnterMessage( SPY_SENDMESSAGE32, hwnd, msg, wParam, lParam );
1030 ret = CallWindowProc32A( (WNDPROC32)wndPtr->winproc,
1031 hwnd, msg, wParam, lParam );
1032 SPY_ExitMessage( SPY_RESULT_OK32, hwnd, msg, ret );
1033 return ret;
1034 }
1035
1036
1037 /***********************************************************************
1038 * SendMessage32W (USER32.458)
1039 */
1040 LRESULT SendMessage32W(HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam)
1041 {
1042 WND * wndPtr;
1043 LRESULT ret;
1044
1045 if (hwnd == HWND_BROADCAST32)
1046 {
1047 for (wndPtr = WIN_GetDesktop()->child; wndPtr; wndPtr = wndPtr->next)
1048 {
1049 /* FIXME: should use something like EnumWindows here */
1050 if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
1051 SendMessage32W( wndPtr->hwndSelf, msg, wParam, lParam );
1052 }
1053 return TRUE;
1054 }
1055
1056 /* FIXME: call hooks */
1057
1058 if (!(wndPtr = WIN_FindWndPtr( hwnd )))
1059 {
1060 fprintf( stderr, "SendMessage32W: invalid hwnd %08x\n", hwnd );
1061 return 0;
1062 }
1063 if (QUEUE_IsDoomedQueue(wndPtr->hmemTaskQ))
1064 return 0; /* Don't send anything if the task is dying */
1065 if (wndPtr->hmemTaskQ != GetTaskQueue(0))
1066 {
1067 fprintf( stderr, "SendMessage32W: intertask message not supported\n" );
1068 return 0;
1069 }
1070
1071 SPY_EnterMessage( SPY_SENDMESSAGE32, hwnd, msg, wParam, lParam );
1072 ret = CallWindowProc32W( (WNDPROC32)wndPtr->winproc,
1073 hwnd, msg, wParam, lParam );
1074 SPY_ExitMessage( SPY_RESULT_OK32, hwnd, msg, ret );
1075 return ret;
1076 }
1077
1078
1079 /***********************************************************************
1080 * WaitMessage (USER.112)
1081 */
1082 void WaitMessage( void )
1083 {
1084 QUEUE_WaitBits( QS_ALLINPUT );
1085 }
1086
1087
1088 /***********************************************************************
1089 * TranslateMessage (USER.113)
1090 *
1091 * This should call ToAscii but it is currently broken
1092 */
1093
1094
1095 BOOL TranslateMessage( LPMSG16 msg )
1096 {
1097 UINT message = msg->message;
1098 /* BYTE wparam[2]; */
1099
1100 if ((message == WM_KEYDOWN) || (message == WM_KEYUP) ||
1101 (message == WM_SYSKEYDOWN) || (message == WM_SYSKEYUP))
1102 {
1103 dprintf_msg(stddeb, "Translating key %04x, scancode %04x\n", msg->wParam,
1104 HIWORD(msg->lParam) );
1105
1106 if( HIWORD(msg->lParam) & ASCII_CHAR_HACK )
1107
1108 /* if( ToAscii( msg->wParam, HIWORD(msg->lParam), (LPSTR)&KeyStateTable,
1109 wparam, 0 ) )
1110 */
1111 {
1112 message += 2 - (message & 0x0001);
1113
1114 PostMessage( msg->hwnd, message, lastEventChar, msg->lParam );
1115
1116 return TRUE;
1117 }
1118 }
1119 return FALSE;
1120 }
1121
1122
1123 /***********************************************************************
1124 * DispatchMessage (USER.114)
1125 */
1126 LONG DispatchMessage( const MSG16* msg )
1127 {
1128 WND * wndPtr;
1129 LONG retval;
1130 int painting;
1131
1132 /* Process timer messages */
1133 if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
1134 {
1135 if (msg->lParam)
1136 {
1137 /* HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1138 return CallWindowProc16( (WNDPROC16)msg->lParam, msg->hwnd,
1139 msg->message, msg->wParam, GetTickCount() );
1140 }
1141 }
1142
1143 if (!msg->hwnd) return 0;
1144 if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
1145 if (!wndPtr->winproc) return 0;
1146 painting = (msg->message == WM_PAINT);
1147 if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
1148 /* HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1149
1150 SPY_EnterMessage( SPY_DISPATCHMESSAGE16, msg->hwnd, msg->message,
1151 msg->wParam, msg->lParam );
1152 retval = CallWindowProc16( (WNDPROC16)wndPtr->winproc,
1153 msg->hwnd, msg->message,
1154 msg->wParam, msg->lParam );
1155 SPY_ExitMessage( SPY_RESULT_OK16, msg->hwnd, msg->message, retval );
1156
1157 if (painting && (wndPtr = WIN_FindWndPtr( msg->hwnd )) &&
1158 (wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
1159 {
1160 fprintf(stderr, "BeginPaint not called on WM_PAINT for hwnd %04x!\n",
1161 msg->hwnd);
1162 wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
1163 /* Validate the update region to avoid infinite WM_PAINT loop */
1164 ValidateRect32( msg->hwnd, NULL );
1165 }
1166 return retval;
1167 }
1168
1169
1170 /***********************************************************************
1171 * RegisterWindowMessage16 (USER.118)
1172 */
1173 WORD RegisterWindowMessage16( SEGPTR str )
1174 {
1175 dprintf_msg(stddeb, "RegisterWindowMessage16: %08lx\n", (DWORD)str );
1176 return GlobalAddAtom16( str );
1177 }
1178
1179
1180 /***********************************************************************
1181 * RegisterWindowMessage32A (USER32.436)
1182 */
1183 WORD RegisterWindowMessage32A( LPCSTR str )
1184 {
1185 dprintf_msg(stddeb, "RegisterWindowMessage32A: %s\n", str );
1186 return GlobalAddAtom32A( str );
1187 }
1188
1189
1190 /***********************************************************************
1191 * RegisterWindowMessage32W (USER32.437)
1192 */
1193 WORD RegisterWindowMessage32W( LPCWSTR str )
1194 {
1195 dprintf_msg(stddeb, "RegisterWindowMessage32W: %p\n", str );
1196 return GlobalAddAtom32W( str );
1197 }
1198
1199
1200 /***********************************************************************
1201 * GetTickCount (USER.13) (KERNEL32.299)
1202 */
1203 DWORD GetTickCount(void)
1204 {
1205 struct timeval t;
1206 gettimeofday( &t, NULL );
1207 return ((t.tv_sec * 1000) + (t.tv_usec / 1000)) - MSG_WineStartTicks;
1208 }
1209
1210
1211 /***********************************************************************
1212 * GetCurrentTime (USER.15)
1213 *
1214 * (effectively identical to GetTickCount)
1215 */
1216 DWORD GetCurrentTime(void)
1217 {
1218 return GetTickCount();
1219 }
1220
1221
1222 /***********************************************************************
1223 * InSendMessage (USER.192)
1224 */
1225 BOOL InSendMessage()
1226 {
1227 MESSAGEQUEUE *queue;
1228
1229 if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) )))
1230 return 0;
1231 return (BOOL)queue->InSendMessageHandle;
1232 }
Maarten's multimedia branch