git.oblomov.eu Git - wine/blob - windows/message.c

   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 "wine/winbase16.h"
  14 #include "message.h"
  15 #include "winerror.h"
  16 #include "win.h"
  17 #include "sysmetrics.h"
  18 #include "heap.h"
  19 #include "hook.h"
  20 #include "input.h"
  21 #include "spy.h"
  22 #include "winpos.h"
  23 #include "dde.h"
  24 #include "queue.h"
  25 #include "winproc.h"
  26 #include "task.h"
  27 #include "process.h"
  28 #include "thread.h"
  29 #include "options.h"
  30 #include "struct32.h"
  31 #include "debugtools.h"
  32
  33 DECLARE_DEBUG_CHANNEL(key)
  34 DECLARE_DEBUG_CHANNEL(msg)
  35 DECLARE_DEBUG_CHANNEL(sendmsg)
  36
  37 #define WM_NCMOUSEFIRST         WM_NCMOUSEMOVE
  38 #define WM_NCMOUSELAST          WM_NCMBUTTONDBLCLK
  39
  40
  41 typedef enum { SYSQ_MSG_ABANDON, SYSQ_MSG_SKIP,
  42                SYSQ_MSG_ACCEPT, SYSQ_MSG_CONTINUE } SYSQ_STATUS;
  43
  44 extern HQUEUE16 hCursorQueue;                    /* queue.c */
  45
  46 DWORD MSG_WineStartTicks; /* Ticks at Wine startup */
  47
  48 static UINT doubleClickSpeed = 452;
  49
  50 /***********************************************************************
  51  *           MSG_CheckFilter
  52  */
  53 BOOL MSG_CheckFilter(DWORD uMsg, DWORD first, DWORD last)
  54 {
  55    if( first || last )
  56        return (uMsg >= first && uMsg <= last);
  57    return TRUE;
  58 }
  59
  60 /***********************************************************************
  61  *           MSG_SendParentNotify
  62  *
  63  * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
  64  * the window has the WS_EX_NOPARENTNOTIFY style.
  65  */
  66 static void MSG_SendParentNotify(WND* wndPtr, WORD event, WORD idChild, LPARAM lValue)
  67 {
  68 #define lppt ((LPPOINT16)&lValue)
  69
  70     /* pt has to be in the client coordinates of the parent window */
  71     WND *tmpWnd = WIN_LockWndPtr(wndPtr);
  72
  73     MapWindowPoints16( 0, tmpWnd->hwndSelf, lppt, 1 );
  74     while (tmpWnd)
  75     {
  76         if (!(tmpWnd->dwStyle & WS_CHILD) || (tmpWnd->dwExStyle & WS_EX_NOPARENTNOTIFY))
  77     {
  78             WIN_ReleaseWndPtr(tmpWnd);
  79             break;
  80         }
  81         lppt->x += tmpWnd->rectClient.left;
  82         lppt->y += tmpWnd->rectClient.top;
  83         WIN_UpdateWndPtr(&tmpWnd,tmpWnd->parent);
  84         SendMessageA( tmpWnd->hwndSelf, WM_PARENTNOTIFY,
  85                         MAKEWPARAM( event, idChild ), lValue );
  86     }
  87
  88 #undef lppt
  89 }
  90
  91
  92 /***********************************************************************
  93  *           MSG_TranslateMouseMsg
  94  *
  95  * Translate an mouse hardware event into a real mouse message.
  96  * Return value indicates whether the translated message must be passed
  97  * to the user, left in the queue, or skipped entirely (in this case
  98  * HIWORD contains hit test code).
  99  */
 100 static DWORD MSG_TranslateMouseMsg( HWND hTopWnd, DWORD first, DWORD last,
 101                                     MSG *msg, BOOL remove, WND* pWndScope )
 102 {
 103     static DWORD   dblclk_time_limit = 0;
 104     static UINT16     clk_message = 0;
 105     static HWND16     clk_hwnd = 0;
 106     static POINT16    clk_pos = { 0, 0 };
 107
 108     WND *pWnd;
 109     HWND hWnd;
 110     INT16 ht, hittest, sendSC = 0;
 111     UINT message = msg->message;
 112     POINT16 screen_pt, pt;
 113     HANDLE16 hQ = GetFastQueue16();
 114     MESSAGEQUEUE *queue = (MESSAGEQUEUE *)QUEUE_Lock(hQ);
 115     BOOL eatMsg = FALSE;
 116     BOOL mouseClick = ((message == WM_LBUTTONDOWN) ||
 117                          (message == WM_RBUTTONDOWN) ||
 118                          (message == WM_MBUTTONDOWN))?1:0;
 119     SYSQ_STATUS ret = 0;
 120     DWORD retvalue;
 121
 122       /* Find the window */
 123
 124     CONV_POINT32TO16( &msg->pt, &pt );
 125
 126     ht = hittest = HTCLIENT;
 127     hWnd = GetCapture();
 128     if( !hWnd )
 129     {
 130         ht = hittest = WINPOS_WindowFromPoint( pWndScope, pt, &pWnd );
 131         if( !pWnd ) pWnd = WIN_GetDesktop();
 132         else WIN_LockWndPtr(pWnd);
 133         hWnd = pWnd->hwndSelf;
 134         sendSC = 1;
 135     }
 136     else
 137     {
 138         pWnd = WIN_FindWndPtr(hWnd);
 139         if (queue)
 140             ht = PERQDATA_GetCaptureInfo( queue->pQData );
 141     }
 142
 143         /* stop if not the right queue */
 144
 145     if (pWnd->hmemTaskQ != hQ)
 146     {
 147         /* Not for the current task */
 148         if (queue) QUEUE_ClearWakeBit( queue, QS_MOUSE );
 149         /* Wake up the other task */
 150         QUEUE_Unlock( queue );
 151         queue = (MESSAGEQUEUE *)QUEUE_Lock( pWnd->hmemTaskQ );
 152         if (queue) QUEUE_SetWakeBit( queue, QS_MOUSE );
 153
 154         QUEUE_Unlock( queue );
 155         retvalue = SYSQ_MSG_ABANDON;
 156         goto END;
 157     }
 158
 159         /* check if hWnd is within hWndScope */
 160
 161     if( hTopWnd && hWnd != hTopWnd )
 162         if( !IsChild(hTopWnd, hWnd) )
 163         {
 164             QUEUE_Unlock( queue );
 165             retvalue = SYSQ_MSG_CONTINUE;
 166             goto END;
 167         }
 168
 169     if( mouseClick )
 170     {
 171         /* translate double clicks -
 172          * note that ...MOUSEMOVEs can slip in between
 173          * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
 174
 175         if( pWnd->class->style & CS_DBLCLKS || ht != HTCLIENT )
 176         {
 177            if ((message == clk_message) && (hWnd == clk_hwnd) &&
 178                (msg->time - dblclk_time_limit < doubleClickSpeed) &&
 179                (abs(msg->pt.x - clk_pos.x) < SYSMETRICS_CXDOUBLECLK/2) &&
 180                (abs(msg->pt.y - clk_pos.y) < SYSMETRICS_CYDOUBLECLK/2))
 181            {
 182               message += (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
 183               mouseClick++;   /* == 2 */
 184            }
 185         }
 186     }
 187     screen_pt = pt;
 188
 189     if (hittest != HTCLIENT)
 190     {
 191         message += WM_NCMOUSEMOVE - WM_MOUSEMOVE;
 192         msg->wParam = hittest;
 193     }
 194     else ScreenToClient16( hWnd, &pt );
 195
 196         /* check message filter */
 197
 198     if (!MSG_CheckFilter(message, first, last))
 199     {
 200         QUEUE_Unlock(queue);
 201         retvalue = SYSQ_MSG_CONTINUE;
 202         goto END;
 203     }
 204
 205     hCursorQueue = queue->self;
 206     QUEUE_Unlock(queue);
 207
 208
 209         /* call WH_MOUSE */
 210
 211     if (HOOK_IsHooked( WH_MOUSE ))
 212     {
 213         MOUSEHOOKSTRUCT16 *hook = SEGPTR_NEW(MOUSEHOOKSTRUCT16);
 214         if( hook )
 215         {
 216             hook->pt           = screen_pt;
 217             hook->hwnd         = hWnd;
 218             hook->wHitTestCode = hittest;
 219             hook->dwExtraInfo  = 0;
 220             ret = HOOK_CallHooks16( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
 221                                     message, (LPARAM)SEGPTR_GET(hook) );
 222             SEGPTR_FREE(hook);
 223         }
 224         if( ret )
 225         {
 226             retvalue = MAKELONG((INT16)SYSQ_MSG_SKIP, hittest);
 227             goto END;
 228     }
 229
 230     }
 231
 232
 233     if ((hittest == HTERROR) || (hittest == HTNOWHERE))
 234         eatMsg = sendSC = 1;
 235     else if( remove && mouseClick )
 236     {
 237         HWND hwndTop = WIN_GetTopParent( hWnd );
 238
 239         if( mouseClick == 1 )
 240         {
 241             /* set conditions */
 242             dblclk_time_limit = msg->time;
 243                clk_message = msg->message;
 244                clk_hwnd = hWnd;
 245                clk_pos = screen_pt;
 246         } else
 247             /* got double click - zero them out */
 248             dblclk_time_limit = clk_hwnd = 0;
 249
 250         if( sendSC )
 251         {
 252             /* Send the WM_PARENTNOTIFY,
 253              * note that even for double/nonclient clicks
 254              * notification message is still WM_L/M/RBUTTONDOWN.
 255              */
 256
 257             MSG_SendParentNotify( pWnd, msg->message & 0xffff, 0, MAKELPARAM(screen_pt.x, screen_pt.y) );
 258
 259             /* Activate the window if needed */
 260
 261             if (hWnd != GetActiveWindow() && hWnd != GetDesktopWindow())
 262             {
 263                 LONG ret = SendMessageA( hWnd, WM_MOUSEACTIVATE, hwndTop,
 264                                           MAKELONG( hittest, message ) );
 265
 266                 if ((ret == MA_ACTIVATEANDEAT) || (ret == MA_NOACTIVATEANDEAT))
 267                          eatMsg = TRUE;
 268
 269                 if (((ret == MA_ACTIVATE) || (ret == MA_ACTIVATEANDEAT))
 270                       && hwndTop != GetActiveWindow() )
 271                       if (!WINPOS_SetActiveWindow( hwndTop, TRUE , TRUE ))
 272                          eatMsg = TRUE;
 273             }
 274         }
 275     } else sendSC = (remove && sendSC);
 276
 277      /* Send the WM_SETCURSOR message */
 278
 279     if (sendSC)
 280         SendMessageA( hWnd, WM_SETCURSOR, hWnd,
 281                        MAKELONG( hittest, message ));
 282     if (eatMsg)
 283     {
 284         retvalue = MAKELONG( (UINT16)SYSQ_MSG_SKIP, hittest);
 285         goto END;
 286     }
 287
 288     msg->hwnd    = hWnd;
 289     msg->message = message;
 290     msg->lParam  = MAKELONG( pt.x, pt.y );
 291     retvalue = SYSQ_MSG_ACCEPT;
 292 END:
 293     WIN_ReleaseWndPtr(pWnd);
 294
 295     return retvalue;
 296 }
 297
 298
 299 /***********************************************************************
 300  *           MSG_TranslateKbdMsg
 301  *
 302  * Translate an keyboard hardware event into a real message.
 303  */
 304 static DWORD MSG_TranslateKbdMsg( HWND hTopWnd, DWORD first, DWORD last,
 305                                   MSG *msg, BOOL remove )
 306 {
 307     WORD message = msg->message;
 308     HWND hWnd = GetFocus();
 309     WND *pWnd;
 310
 311       /* Should check Ctrl-Esc and PrintScreen here */
 312
 313     if (!hWnd)
 314     {
 315           /* Send the message to the active window instead,  */
 316           /* translating messages to their WM_SYS equivalent */
 317
 318         hWnd = GetActiveWindow();
 319
 320         if( message < WM_SYSKEYDOWN )
 321             message += WM_SYSKEYDOWN - WM_KEYDOWN;
 322     }
 323     pWnd = WIN_FindWndPtr( hWnd );
 324     if (pWnd && (pWnd->hmemTaskQ != GetFastQueue16()))
 325     {
 326         /* Not for the current task */
 327         MESSAGEQUEUE *queue = (MESSAGEQUEUE *)QUEUE_Lock( GetFastQueue16() );
 328         if (queue) QUEUE_ClearWakeBit( queue, QS_KEY );
 329         QUEUE_Unlock( queue );
 330
 331         /* Wake up the other task */
 332         queue = (MESSAGEQUEUE *)QUEUE_Lock( pWnd->hmemTaskQ );
 333         if (queue) QUEUE_SetWakeBit( queue, QS_KEY );
 334         QUEUE_Unlock( queue );
 335         WIN_ReleaseWndPtr(pWnd);
 336         return SYSQ_MSG_ABANDON;
 337     }
 338     WIN_ReleaseWndPtr(pWnd);
 339
 340     if (hTopWnd && hWnd != hTopWnd)
 341         if (!IsChild(hTopWnd, hWnd)) return SYSQ_MSG_CONTINUE;
 342     if (!MSG_CheckFilter(message, first, last)) return SYSQ_MSG_CONTINUE;
 343
 344     msg->hwnd = hWnd;
 345     msg->message = message;
 346
 347     return (HOOK_CallHooks16( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
 348                               LOWORD (msg->wParam), msg->lParam )
 349             ? SYSQ_MSG_SKIP : SYSQ_MSG_ACCEPT);
 350 }
 351
 352
 353 /***********************************************************************
 354  *           MSG_JournalRecordMsg
 355  *
 356  * Build an EVENTMSG structure and call JOURNALRECORD hook
 357  */
 358 static void MSG_JournalRecordMsg( MSG *msg )
 359 {
 360     EVENTMSG *event = (EVENTMSG *) HeapAlloc(SystemHeap, 0, sizeof(EVENTMSG));
 361     if (!event) return;
 362     event->message = msg->message;
 363     event->time = msg->time;
 364     if ((msg->message >= WM_KEYFIRST) && (msg->message <= WM_KEYLAST))
 365     {
 366         event->paramL = (msg->wParam & 0xFF) | (HIWORD(msg->lParam) << 8);
 367         event->paramH = msg->lParam & 0x7FFF;
 368         if (HIWORD(msg->lParam) & 0x0100)
 369             event->paramH |= 0x8000;               /* special_key - bit */
 370         HOOK_CallHooksA( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)event );
 371     }
 372     else if ((msg->message >= WM_MOUSEFIRST) && (msg->message <= WM_MOUSELAST))
 373     {
 374         event->paramL = LOWORD(msg->lParam);       /* X pos */
 375         event->paramH = HIWORD(msg->lParam);       /* Y pos */
 376         ClientToScreen16( msg->hwnd, (LPPOINT16)&event->paramL );
 377         HOOK_CallHooksA( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)event );
 378     }
 379     else if ((msg->message >= WM_NCMOUSEFIRST) &&
 380              (msg->message <= WM_NCMOUSELAST))
 381     {
 382         event->paramL = LOWORD(msg->lParam);       /* X pos */
 383         event->paramH = HIWORD(msg->lParam);       /* Y pos */
 384         event->message += WM_MOUSEMOVE-WM_NCMOUSEMOVE;/* give no info about NC area */
 385         HOOK_CallHooksA( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)event );
 386     }
 387
 388     HeapFree(SystemHeap, 0, event);
 389 }
 390
 391 /***********************************************************************
 392  *          MSG_JournalPlayBackMsg
 393  *
 394  * Get an EVENTMSG struct via call JOURNALPLAYBACK hook function
 395  */
 396 static int MSG_JournalPlayBackMsg(void)
 397 {
 398  EVENTMSG *tmpMsg;
 399  long wtime,lParam,wParam;
 400  WORD keyDown,i,result=0;
 401
 402  if ( HOOK_IsHooked( WH_JOURNALPLAYBACK ) )
 403  {
 404   tmpMsg = (EVENTMSG *) HeapAlloc(SystemHeap, 0, sizeof(EVENTMSG));
 405   if (!tmpMsg) return result;
 406
 407   wtime=HOOK_CallHooksA( WH_JOURNALPLAYBACK, HC_GETNEXT, 0,
 408                            (LPARAM) tmpMsg );
 409   /*  TRACE(msg,"Playback wait time =%ld\n",wtime); */
 410   if (wtime<=0)
 411   {
 412    wtime=0;
 413    if ((tmpMsg->message>= WM_KEYFIRST) && (tmpMsg->message <= WM_KEYLAST))
 414    {
 415      wParam=tmpMsg->paramL & 0xFF;
 416      lParam=MAKELONG(tmpMsg->paramH&0x7ffff,tmpMsg->paramL>>8);
 417      if (tmpMsg->message == WM_KEYDOWN || tmpMsg->message == WM_SYSKEYDOWN)
 418      {
 419        for (keyDown=i=0; i<256 && !keyDown; i++)
 420           if (InputKeyStateTable[i] & 0x80)
 421             keyDown++;
 422        if (!keyDown)
 423          lParam |= 0x40000000;
 424        AsyncKeyStateTable[wParam]=InputKeyStateTable[wParam] |= 0x80;
 425      }
 426      else                                       /* WM_KEYUP, WM_SYSKEYUP */
 427      {
 428        lParam |= 0xC0000000;
 429        AsyncKeyStateTable[wParam]=InputKeyStateTable[wParam] &= ~0x80;
 430      }
 431      if (InputKeyStateTable[VK_MENU] & 0x80)
 432        lParam |= 0x20000000;
 433      if (tmpMsg->paramH & 0x8000)              /*special_key bit*/
 434        lParam |= 0x01000000;
 435      hardware_event( tmpMsg->message & 0xffff, LOWORD(wParam), lParam,
 436                      0, 0, tmpMsg->time, 0 );
 437    }
 438    else
 439    {
 440     if ((tmpMsg->message>= WM_MOUSEFIRST) && (tmpMsg->message <= WM_MOUSELAST))
 441     {
 442      switch (tmpMsg->message)
 443      {
 444       case WM_LBUTTONDOWN:
 445           MouseButtonsStates[0]=AsyncMouseButtonsStates[0]=TRUE;break;
 446       case WM_LBUTTONUP:
 447           MouseButtonsStates[0]=AsyncMouseButtonsStates[0]=FALSE;break;
 448       case WM_MBUTTONDOWN:
 449           MouseButtonsStates[1]=AsyncMouseButtonsStates[1]=TRUE;break;
 450       case WM_MBUTTONUP:
 451           MouseButtonsStates[1]=AsyncMouseButtonsStates[1]=FALSE;break;
 452       case WM_RBUTTONDOWN:
 453           MouseButtonsStates[2]=AsyncMouseButtonsStates[2]=TRUE;break;
 454       case WM_RBUTTONUP:
 455           MouseButtonsStates[2]=AsyncMouseButtonsStates[2]=FALSE;break;
 456      }
 457      AsyncKeyStateTable[VK_LBUTTON]= InputKeyStateTable[VK_LBUTTON] = MouseButtonsStates[0] ? 0x80 : 0;
 458      AsyncKeyStateTable[VK_MBUTTON]= InputKeyStateTable[VK_MBUTTON] = MouseButtonsStates[1] ? 0x80 : 0;
 459      AsyncKeyStateTable[VK_RBUTTON]= InputKeyStateTable[VK_RBUTTON] = MouseButtonsStates[2] ? 0x80 : 0;
 460      SetCursorPos(tmpMsg->paramL,tmpMsg->paramH);
 461      lParam=MAKELONG(tmpMsg->paramL,tmpMsg->paramH);
 462      wParam=0;
 463      if (MouseButtonsStates[0]) wParam |= MK_LBUTTON;
 464      if (MouseButtonsStates[1]) wParam |= MK_MBUTTON;
 465      if (MouseButtonsStates[2]) wParam |= MK_RBUTTON;
 466      hardware_event( tmpMsg->message & 0xffff, LOWORD (wParam), lParam,
 467                      tmpMsg->paramL, tmpMsg->paramH, tmpMsg->time, 0 );
 468     }
 469    }
 470    HOOK_CallHooksA( WH_JOURNALPLAYBACK, HC_SKIP, 0,
 471                       (LPARAM) tmpMsg);
 472   }
 473   else
 474   {
 475
 476     if( tmpMsg->message == WM_QUEUESYNC )
 477         if (HOOK_IsHooked( WH_CBT ))
 478             HOOK_CallHooksA( WH_CBT, HCBT_QS, 0, 0L);
 479
 480     result= QS_MOUSE | QS_KEY; /* ? */
 481   }
 482   HeapFree(SystemHeap, 0, tmpMsg);
 483  }
 484  return result;
 485 }
 486
 487 /***********************************************************************
 488  *           MSG_PeekHardwareMsg
 489  *
 490  * Peek for a hardware message matching the hwnd and message filters.
 491  */
 492 static BOOL MSG_PeekHardwareMsg( MSG *msg, HWND hwnd, DWORD first, DWORD last,
 493                                    BOOL remove )
 494 {
 495     /* FIXME: should deal with MSG32 instead of MSG16 */
 496
 497     DWORD status = SYSQ_MSG_ACCEPT;
 498     MESSAGEQUEUE *sysMsgQueue = QUEUE_GetSysQueue();
 499     int kbd_msg;
 500     QMSG *nextqmsg, *qmsg = 0;
 501
 502     /* FIXME: there has to be a better way to do this */
 503     joySendMessages();
 504
 505     EnterCriticalSection(&sysMsgQueue->cSection);
 506
 507     qmsg = sysMsgQueue->firstMsg;
 508
 509     /* If the queue is empty, attempt to fill it */
 510     if (!sysMsgQueue->msgCount && THREAD_IsWin16( THREAD_Current() )
 511                                && EVENT_Pending())
 512     {
 513         LeaveCriticalSection(&sysMsgQueue->cSection);
 514         EVENT_WaitNetEvent( FALSE, TRUE );
 515         EnterCriticalSection(&sysMsgQueue->cSection);
 516     }
 517
 518     for ( kbd_msg = 0; qmsg; qmsg = nextqmsg)
 519     {
 520
 521         *msg = qmsg->msg;
 522
 523         nextqmsg = qmsg->nextMsg;
 524
 525           /* Translate message */
 526
 527         if ((msg->message >= WM_MOUSEFIRST) && (msg->message <= WM_MOUSELAST))
 528         {
 529
 530             HWND hWndScope = (HWND)qmsg->extraInfo;
 531             WND *tmpWnd = (Options.managed && IsWindow(hWndScope) )
 532                            ? WIN_FindWndPtr(hWndScope) : WIN_GetDesktop();
 533
 534             status = MSG_TranslateMouseMsg(hwnd, first, last, msg, remove,tmpWnd );
 535             kbd_msg = 0;
 536
 537             WIN_ReleaseWndPtr(tmpWnd);
 538
 539         }
 540         else if ((msg->message >= WM_KEYFIRST) && (msg->message <= WM_KEYLAST))
 541         {
 542             status = MSG_TranslateKbdMsg(hwnd, first, last, msg, remove);
 543             kbd_msg = 1;
 544         }
 545         else /* Non-standard hardware event */
 546         {
 547             HARDWAREHOOKSTRUCT16 *hook;
 548             if ((hook = SEGPTR_NEW(HARDWAREHOOKSTRUCT16)))
 549             {
 550                 BOOL ret;
 551                 hook->hWnd     = msg->hwnd;
 552                 hook->wMessage = msg->message & 0xffff;
 553                 hook->wParam   = LOWORD (msg->wParam);
 554                 hook->lParam   = msg->lParam;
 555                 ret = HOOK_CallHooks16( WH_HARDWARE,
 556                                         remove ? HC_ACTION : HC_NOREMOVE,
 557                                         0, (LPARAM)SEGPTR_GET(hook) );
 558                 SEGPTR_FREE(hook);
 559                 if (ret)
 560                 {
 561                     QUEUE_RemoveMsg( sysMsgQueue, qmsg );
 562                     continue;
 563                 }
 564                 status = SYSQ_MSG_ACCEPT;
 565             }
 566         }
 567
 568         switch (LOWORD(status))
 569         {
 570            case SYSQ_MSG_ACCEPT:
 571                 break;
 572
 573            case SYSQ_MSG_SKIP:
 574                 if (HOOK_IsHooked( WH_CBT ))
 575                 {
 576                    if( kbd_msg )
 577                        HOOK_CallHooks16( WH_CBT, HCBT_KEYSKIPPED,
 578                                          LOWORD (msg->wParam), msg->lParam );
 579                    else
 580                    {
 581                        MOUSEHOOKSTRUCT16 *hook = SEGPTR_NEW(MOUSEHOOKSTRUCT16);
 582                        if (hook)
 583                        {
 584                            CONV_POINT32TO16( &msg->pt,&hook->pt );
 585                            hook->hwnd         = msg->hwnd;
 586                            hook->wHitTestCode = HIWORD(status);
 587                            hook->dwExtraInfo  = 0;
 588                            HOOK_CallHooks16( WH_CBT, HCBT_CLICKSKIPPED ,msg->message & 0xffff,
 589                                           (LPARAM)SEGPTR_GET(hook) );
 590                            SEGPTR_FREE(hook);
 591                        }
 592                    }
 593                 }
 594
 595                 if (remove)
 596                     QUEUE_RemoveMsg( sysMsgQueue, qmsg );
 597                 /* continue */
 598
 599            case SYSQ_MSG_CONTINUE:
 600                 continue;
 601
 602            case SYSQ_MSG_ABANDON:
 603                LeaveCriticalSection(&sysMsgQueue->cSection);
 604                 return FALSE;
 605         }
 606
 607         if (remove)
 608         {
 609             if (HOOK_IsHooked( WH_JOURNALRECORD )) MSG_JournalRecordMsg( msg );
 610             QUEUE_RemoveMsg( sysMsgQueue, qmsg );
 611         }
 612         LeaveCriticalSection(&sysMsgQueue->cSection);
 613         return TRUE;
 614     }
 615     LeaveCriticalSection(&sysMsgQueue->cSection);
 616     return FALSE;
 617 }
 618
 619
 620 /**********************************************************************
 621  *           SetDoubleClickTime16   (USER.20)
 622  */
 623 void WINAPI SetDoubleClickTime16( UINT16 interval )
 624 {
 625     SetDoubleClickTime( interval );
 626 }
 627
 628
 629 /**********************************************************************
 630  *           SetDoubleClickTime32   (USER32.480)
 631  */
 632 BOOL WINAPI SetDoubleClickTime( UINT interval )
 633 {
 634     doubleClickSpeed = interval ? interval : 500;
 635     return TRUE;
 636 }
 637
 638
 639 /**********************************************************************
 640  *           GetDoubleClickTime16   (USER.21)
 641  */
 642 UINT16 WINAPI GetDoubleClickTime16(void)
 643 {
 644     return doubleClickSpeed;
 645 }
 646
 647
 648 /**********************************************************************
 649  *           GetDoubleClickTime32   (USER32.239)
 650  */
 651 UINT WINAPI GetDoubleClickTime(void)
 652 {
 653     return doubleClickSpeed;
 654 }
 655
 656
 657 /***********************************************************************
 658  *           MSG_SendMessageInterThread
 659  *
 660  * Implementation of an inter-task SendMessage.
 661  * Return values:
 662  *    0 if error or timeout
 663  *    1 if successflul
 664  */
 665 static LRESULT MSG_SendMessageInterThread( HQUEUE16 hDestQueue,
 666                                            HWND hwnd, UINT msg,
 667                                            WPARAM wParam, LPARAM lParam,
 668                                            DWORD timeout, WORD flags,
 669                                            LRESULT *pRes)
 670 {
 671     MESSAGEQUEUE *queue, *destQ;
 672     SMSG         *smsg;
 673     LRESULT      retVal = 1;
 674     int          iWndsLocks;
 675
 676     *pRes = 0;
 677
 678     if (IsTaskLocked16() || !IsWindow(hwnd))
 679         return 0;
 680
 681     /* create a SMSG structure to hold SendMessage() parameters */
 682     if (! (smsg = (SMSG *) HeapAlloc( SystemHeap, 0, sizeof(SMSG) )) )
 683         return 0;
 684     if (!(queue = (MESSAGEQUEUE*)QUEUE_Lock( GetFastQueue16() ))) return 0;
 685
 686     if (!(destQ = (MESSAGEQUEUE*)QUEUE_Lock( hDestQueue )))
 687     {
 688         QUEUE_Unlock( queue );
 689         return 0;
 690     }
 691
 692     TRACE_(sendmsg)("SM: %s [%04x] (%04x -> %04x)\n",
 693                     SPY_GetMsgName(msg), msg, queue->self, hDestQueue );
 694
 695     /* fill up SMSG structure */
 696     smsg->hWnd = hwnd;
 697     smsg->msg = msg;
 698     smsg->wParam = wParam;
 699     smsg->lParam = lParam;
 700
 701     smsg->lResult = 0;
 702     smsg->hSrcQueue = GetFastQueue16();
 703     smsg->hDstQueue = hDestQueue;
 704     smsg->flags = flags;
 705
 706     /* add smsg struct in the processing SM list of the source queue */
 707     QUEUE_AddSMSG(queue, SM_PROCESSING_LIST, smsg);
 708
 709     /* add smsg struct in the pending list of the destination queue */
 710     if (QUEUE_AddSMSG(destQ, SM_PENDING_LIST, smsg) == FALSE)
 711         return 0;
 712
 713     iWndsLocks = WIN_SuspendWndsLock();
 714
 715     /* force destination task to run next, if 16 bit threads */
 716     if ( THREAD_IsWin16(THREAD_Current()) && THREAD_IsWin16(destQ->thdb) )
 717         DirectedYield16( destQ->thdb->teb.htask16 );
 718
 719     /* wait for the result, note that 16-bit apps almost always get out of
 720      * DirectedYield() with SMSG_HAVE_RESULT flag already set */
 721
 722     while ( TRUE )
 723     {
 724         /*
 725          * The sequence is crucial to avoid deadlock situations:
 726          * - first, we clear the QS_SMRESULT bit
 727          * - then, we check the SMSG_HAVE_RESULT bit
 728          * - only if this isn't set, we enter the wait state.
 729          *
 730          * As the receiver first sets the SMSG_HAVE_RESULT and then wakes us,
 731          * we are guaranteed that -should we now clear the QS_SMRESULT that
 732          * was signalled already by the receiver- we will not start waiting.
 733          */
 734
 735         if ( smsg->flags & SMSG_HAVE_RESULT )
 736         {
 737 got:
 738              *pRes = smsg->lResult;
 739              TRACE_(sendmsg)("smResult = %08x\n", (unsigned)*pRes );
 740              break;
 741         }
 742
 743         QUEUE_ClearWakeBit( queue, QS_SMRESULT );
 744
 745         if ( smsg->flags & SMSG_HAVE_RESULT )
 746              goto got;
 747
 748         if(  QUEUE_WaitBits( QS_SMRESULT, timeout ) == 0 )
 749         {
 750              /* return with timeout */
 751              SetLastError( 0 );
 752              retVal = 0;
 753              break;
 754         }
 755     }
 756     WIN_RestoreWndsLock(iWndsLocks);
 757
 758     /* remove the smsg from the processingg list of the source queue */
 759     QUEUE_RemoveSMSG( queue, SM_PROCESSING_LIST, smsg );
 760
 761     /* Note: the destination thread is in charge of removing the smsg from
 762        the pending list */
 763
 764     /* In the case of an early reply (or a timeout), sender thread will
 765        released the smsg structure if the receiver thread is done
 766        (SMSG_RECEIVED set). If the receiver thread isn't done,
 767        SMSG_RECEIVER_CLEANS_UP flag is set, and it will be the receiver
 768        responsability to released smsg */
 769         EnterCriticalSection( &queue->cSection );
 770
 771         if (smsg->flags & SMSG_RECEIVED)
 772             HeapFree(SystemHeap, 0, smsg);
 773         else
 774             smsg->flags |= SMSG_RECEIVER_CLEANS;
 775
 776         LeaveCriticalSection( &queue->cSection );
 777
 778
 779     QUEUE_Unlock( queue );
 780     QUEUE_Unlock( destQ );
 781
 782     TRACE_(sendmsg)("done!\n");
 783     return retVal;
 784 }
 785
 786
 787 /***********************************************************************
 788  *           ReplyMessage16   (USER.115)
 789  */
 790 void WINAPI ReplyMessage16( LRESULT result )
 791 {
 792     ReplyMessage( result );
 793 }
 794
 795 /***********************************************************************
 796  *           ReplyMessage   (USER.115)
 797  */
 798 BOOL WINAPI ReplyMessage( LRESULT result )
 799 {
 800     MESSAGEQUEUE *senderQ = 0;
 801     MESSAGEQUEUE *queue = 0;
 802     SMSG         *smsg;
 803     BOOL       ret = FALSE;
 804
 805     if (!(queue = (MESSAGEQUEUE*)QUEUE_Lock( GetFastQueue16() )))
 806         return FALSE;
 807
 808     TRACE_(sendmsg)("ReplyMessage, queue %04x\n", queue->self);
 809
 810
 811     if (    !(smsg = queue->smWaiting)
 812          || !(senderQ = QUEUE_Lock( smsg->hSrcQueue )) )
 813         goto ReplyMessageEnd;
 814
 815     if ( !(smsg->flags & SMSG_ALREADY_REPLIED) )
 816     {
 817         /* This is the first reply, so pass result to sender */
 818
 819         TRACE_(sendmsg)("\trpm: smResult = %08lx\n", (long) result );
 820
 821         EnterCriticalSection(&senderQ->cSection);
 822
 823         smsg->lResult = result;
 824         smsg->flags |= SMSG_ALREADY_REPLIED;
 825
 826         /* check if it's an early reply (called by the application) or
 827            a regular reply (called by ReceiveMessage) */
 828         if ( !(smsg->flags & SMSG_SENDING_REPLY) )
 829             smsg->flags |= SMSG_EARLY_REPLY;
 830
 831         smsg->flags |= SMSG_HAVE_RESULT;
 832
 833         LeaveCriticalSection(&senderQ->cSection);
 834
 835         /* tell the sending task that its reply is ready */
 836         QUEUE_SetWakeBit( senderQ, QS_SMRESULT );
 837
 838         /* switch directly to sending task (16 bit thread only) */
 839         if ( THREAD_IsWin16( THREAD_Current() ) && THREAD_IsWin16( senderQ->thdb ) )
 840             DirectedYield16( senderQ->thdb->teb.htask16 );
 841
 842         ret = TRUE;
 843     }
 844
 845     if (smsg->flags & SMSG_SENDING_REPLY)
 846     {
 847         /* remove msg from the waiting list, since this  is the last
 848           ReplyMessage */
 849         QUEUE_RemoveSMSG( queue, SM_WAITING_LIST, smsg );
 850
 851         EnterCriticalSection(&senderQ->cSection);
 852
 853         /* tell the sender we're all done with smsg structure */
 854         smsg->flags |= SMSG_RECEIVED;
 855
 856         /* sender will set SMSG_RECEIVER_CLEANS_UP if it wants the
 857          receiver to clean up smsg, it could only happens when there is
 858          an early reply or a timeout */
 859         if ( smsg->flags & SMSG_RECEIVER_CLEANS )
 860         {
 861             TRACE_(sendmsg)("Receiver cleans up!\n" );
 862             HeapFree( SystemHeap, 0, smsg );
 863         }
 864
 865         LeaveCriticalSection(&senderQ->cSection);
 866     }
 867
 868 ReplyMessageEnd:
 869     if ( senderQ )
 870     QUEUE_Unlock( senderQ );
 871     if ( queue )
 872     QUEUE_Unlock( queue );
 873
 874     return ret;
 875 }
 876
 877 /***********************************************************************
 878  *           MSG_PeekMessage
 879  */
 880 static BOOL MSG_PeekMessage( LPMSG msg, HWND hwnd, DWORD first, DWORD last,
 881                                WORD flags, BOOL peek )
 882 {
 883     int mask;
 884     MESSAGEQUEUE *msgQueue;
 885     HQUEUE16 hQueue;
 886     POINT16 pt16;
 887     int iWndsLocks;
 888
 889 #ifdef CONFIG_IPC
 890     DDE_TestDDE(hwnd);  /* do we have dde handling in the window ?*/
 891     DDE_GetRemoteMessage();
 892 #endif  /* CONFIG_IPC */
 893
 894     mask = QS_POSTMESSAGE | QS_SENDMESSAGE;  /* Always selected */
 895     if (first || last)
 896     {
 897         if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
 898         if ( ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) ||
 899              ((first <= WM_NCMOUSELAST) && (last >= WM_NCMOUSEFIRST)) ) mask |= QS_MOUSE;
 900         if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
 901         if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
 902         if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
 903     }
 904     else mask |= QS_MOUSE | QS_KEY | QS_TIMER | QS_PAINT;
 905
 906     if (IsTaskLocked16()) flags |= PM_NOYIELD;
 907
 908     /* Never yield on Win32 threads */
 909     if (!THREAD_IsWin16(THREAD_Current())) flags |= PM_NOYIELD;
 910
 911     iWndsLocks = WIN_SuspendWndsLock();
 912
 913     while(1)
 914     {
 915         QMSG *qmsg;
 916
 917         hQueue   = GetFastQueue16();
 918         msgQueue = (MESSAGEQUEUE *)QUEUE_Lock( hQueue );
 919         if (!msgQueue)
 920         {
 921             WIN_RestoreWndsLock(iWndsLocks);
 922             return FALSE;
 923         }
 924         msgQueue->changeBits = 0;
 925
 926         /* First handle a message put by SendMessage() */
 927
 928         while (msgQueue->wakeBits & QS_SENDMESSAGE)
 929             QUEUE_ReceiveMessage( msgQueue );
 930
 931         /* Now handle a WM_QUIT message */
 932
 933         if (msgQueue->wPostQMsg &&
 934            (!first || WM_QUIT >= first) &&
 935            (!last || WM_QUIT <= last) )
 936         {
 937             msg->hwnd    = hwnd;
 938             msg->message = WM_QUIT;
 939             msg->wParam  = msgQueue->wExitCode;
 940             msg->lParam  = 0;
 941             if (flags & PM_REMOVE) msgQueue->wPostQMsg = 0;
 942             break;
 943         }
 944
 945         /* Now find a normal message */
 946
 947         if (((msgQueue->wakeBits & mask) & QS_POSTMESSAGE) &&
 948             ((qmsg = QUEUE_FindMsg( msgQueue, hwnd, first, last )) != 0))
 949         {
 950             *msg = qmsg->msg;
 951
 952             msgQueue->GetMessageTimeVal      = msg->time;
 953             CONV_POINT32TO16(&msg->pt, &pt16);
 954             msgQueue->GetMessagePosVal       = *(DWORD *)&pt16;
 955             msgQueue->GetMessageExtraInfoVal = qmsg->extraInfo;
 956
 957             if (flags & PM_REMOVE) QUEUE_RemoveMsg( msgQueue, qmsg );
 958             break;
 959         }
 960
 961         msgQueue->changeBits |= MSG_JournalPlayBackMsg();
 962
 963         /* Now find a hardware event */
 964
 965         if (((msgQueue->wakeBits & mask) & (QS_MOUSE | QS_KEY)) &&
 966             MSG_PeekHardwareMsg( msg, hwnd, first, last, flags & PM_REMOVE ))
 967         {
 968             /* Got one */
 969             msgQueue->GetMessageTimeVal      = msg->time;
 970             CONV_POINT32TO16(&msg->pt, &pt16);
 971             msgQueue->GetMessagePosVal       = *(DWORD *)&pt16;
 972             msgQueue->GetMessageExtraInfoVal = 0;  /* Always 0 for now */
 973             break;
 974         }
 975
 976         /* Check again for SendMessage */
 977
 978         while (msgQueue->wakeBits & QS_SENDMESSAGE)
 979             QUEUE_ReceiveMessage( msgQueue );
 980
 981         /* Now find a WM_PAINT message */
 982
 983         if ((msgQueue->wakeBits & mask) & QS_PAINT)
 984         {
 985             WND* wndPtr;
 986             msg->hwnd = WIN_FindWinToRepaint( hwnd , hQueue );
 987             msg->message = WM_PAINT;
 988             msg->wParam = 0;
 989             msg->lParam = 0;
 990
 991             if ((wndPtr = WIN_FindWndPtr(msg->hwnd)))
 992             {
 993                 if( wndPtr->dwStyle & WS_MINIMIZE &&
 994                     wndPtr->class->hIcon )
 995                 {
 996                     msg->message = WM_PAINTICON;
 997                     msg->wParam = 1;
 998                 }
 999
1000                 if( !hwnd || msg->hwnd == hwnd || IsChild16(hwnd,msg->hwnd) )
1001                 {
1002                     if( wndPtr->flags & WIN_INTERNAL_PAINT && !wndPtr->hrgnUpdate)
1003                     {
1004                         wndPtr->flags &= ~WIN_INTERNAL_PAINT;
1005                         QUEUE_DecPaintCount( hQueue );
1006                     }
1007                     WIN_ReleaseWndPtr(wndPtr);
1008                     break;
1009                 }
1010                 WIN_ReleaseWndPtr(wndPtr);
1011             }
1012         }
1013
1014         /* Check for timer messages, but yield first */
1015
1016         if (!(flags & PM_NOYIELD))
1017         {
1018             UserYield16();
1019             while (msgQueue->wakeBits & QS_SENDMESSAGE)
1020                 QUEUE_ReceiveMessage( msgQueue );
1021         }
1022         if ((msgQueue->wakeBits & mask) & QS_TIMER)
1023         {
1024             if (TIMER_GetTimerMsg(msg, hwnd, hQueue, flags & PM_REMOVE)) break;
1025         }
1026
1027         if (peek)
1028         {
1029             if (!(flags & PM_NOYIELD)) UserYield16();
1030
1031             QUEUE_Unlock( msgQueue );
1032             WIN_RestoreWndsLock(iWndsLocks);
1033             return FALSE;
1034         }
1035         msgQueue->wakeMask = mask;
1036         QUEUE_WaitBits( mask, INFINITE );
1037         QUEUE_Unlock( msgQueue );
1038     }
1039
1040     WIN_RestoreWndsLock(iWndsLocks);
1041
1042     /* instead of unlocking queue for every break condition, all break
1043        condition will fall here */
1044     QUEUE_Unlock( msgQueue );
1045
1046       /* We got a message */
1047     if (flags & PM_REMOVE)
1048     {
1049         WORD message = msg->message;
1050
1051         if (message == WM_KEYDOWN || message == WM_SYSKEYDOWN)
1052         {
1053             BYTE *p = &QueueKeyStateTable[msg->wParam & 0xff];
1054
1055             if (!(*p & 0x80))
1056                 *p ^= 0x01;
1057             *p |= 0x80;
1058         }
1059         else if (message == WM_KEYUP || message == WM_SYSKEYUP)
1060             QueueKeyStateTable[msg->wParam & 0xff] &= ~0x80;
1061     }
1062
1063     if (peek)
1064         return TRUE;
1065
1066     else
1067         return (msg->message != WM_QUIT);
1068 }
1069
1070 /***********************************************************************
1071  *           MSG_InternalGetMessage
1072  *
1073  * GetMessage() function for internal use. Behave like GetMessage(),
1074  * but also call message filters and optionally send WM_ENTERIDLE messages.
1075  * 'hwnd' must be the handle of the dialog or menu window.
1076  * 'code' is the message filter value (MSGF_??? codes).
1077  */
1078 BOOL MSG_InternalGetMessage( MSG *msg, HWND hwnd, HWND hwndOwner,
1079                                WPARAM code, WORD flags, BOOL sendIdle )
1080 {
1081     for (;;)
1082     {
1083         if (sendIdle)
1084         {
1085             if (!MSG_PeekMessage( msg, 0, 0, 0, flags, TRUE ))
1086             {
1087                   /* No message present -> send ENTERIDLE and wait */
1088                 if (IsWindow(hwndOwner))
1089                     SendMessageA( hwndOwner, WM_ENTERIDLE,
1090                                    code, (LPARAM)hwnd );
1091                 MSG_PeekMessage( msg, 0, 0, 0, flags, FALSE );
1092             }
1093         }
1094         else  /* Always wait for a message */
1095             MSG_PeekMessage( msg, 0, 0, 0, flags, FALSE );
1096
1097         /* Call message filters */
1098
1099         if (HOOK_IsHooked( WH_SYSMSGFILTER ) || HOOK_IsHooked( WH_MSGFILTER ))
1100         {
1101             MSG *pmsg = HeapAlloc( SystemHeap, 0, sizeof(MSG) );
1102             if (pmsg)
1103             {
1104                 BOOL ret;
1105                 *pmsg = *msg;
1106                 ret = (HOOK_CallHooksA( WH_SYSMSGFILTER, code, 0,
1107                                           (LPARAM) pmsg ) ||
1108                        HOOK_CallHooksA( WH_MSGFILTER, code, 0,
1109                                           (LPARAM) pmsg ));
1110
1111                 HeapFree( SystemHeap, 0, pmsg );
1112                 if (ret)
1113                 {
1114                     /* Message filtered -> remove it from the queue */
1115                     /* if it's still there. */
1116                     if (!(flags & PM_REMOVE))
1117                         MSG_PeekMessage( msg, 0, 0, 0, PM_REMOVE, TRUE );
1118                     continue;
1119                 }
1120             }
1121         }
1122
1123         return (msg->message != WM_QUIT);
1124     }
1125 }
1126
1127
1128 /***********************************************************************
1129  *           PeekMessage16   (USER.109)
1130  */
1131 BOOL16 WINAPI PeekMessage16( LPMSG16 lpmsg, HWND16 hwnd, UINT16 first,
1132                              UINT16 last, UINT16 flags )
1133 {
1134     MSG msg32;
1135     BOOL16 ret;
1136     ret = PeekMessageA(&msg32, hwnd, first, last, flags);
1137     STRUCT32_MSG32to16(&msg32, lpmsg);
1138     return ret;
1139 }
1140
1141 /***********************************************************************
1142  *         WIN16_PeekMessage32   (USER.819)
1143  */
1144 BOOL16 WINAPI PeekMessage32_16( LPMSG16_32 lpmsg16_32, HWND16 hwnd,
1145                UINT16 first, UINT16 last, UINT16 flags, BOOL16 wHaveParamHigh )
1146 {
1147     if (wHaveParamHigh == FALSE)
1148     {
1149         lpmsg16_32->wParamHigh = 0;
1150         return PeekMessage16(&(lpmsg16_32->msg), hwnd, first, last, flags);
1151     }
1152     else
1153     {
1154         MSG msg32;
1155         BOOL16 ret;
1156
1157         ret = (BOOL16)PeekMessageA(&msg32, (HWND)hwnd,
1158                                    (UINT)first, (UINT)last, (UINT)flags);
1159         lpmsg16_32->msg.hwnd    = msg32.hwnd;
1160         lpmsg16_32->msg.message = msg32.message;
1161         lpmsg16_32->msg.wParam  = LOWORD(msg32.wParam);
1162         lpmsg16_32->msg.lParam  = msg32.lParam;
1163         lpmsg16_32->msg.time    = msg32.time;
1164         lpmsg16_32->msg.pt.x    = (INT16)msg32.pt.x;
1165         lpmsg16_32->msg.pt.y    = (INT16)msg32.pt.y;
1166         lpmsg16_32->wParamHigh  = HIWORD(msg32.wParam);
1167         return ret;
1168     }
1169 }
1170
1171
1172 /***********************************************************************
1173  *         PeekMessageA
1174  */
1175 BOOL WINAPI PeekMessageA( LPMSG lpmsg, HWND hwnd,
1176                               UINT min,UINT max,UINT wRemoveMsg)
1177 {
1178     return MSG_PeekMessage( lpmsg, hwnd, min, max, wRemoveMsg, TRUE );
1179 }
1180
1181 /***********************************************************************
1182  *         PeekMessageW             Check queue for messages
1183  *
1184  * Checks for a message in the thread's queue, filtered as for
1185  * GetMessage(). Returns immediately whether a message is available
1186  * or not.
1187  *
1188  * Whether a retrieved message is removed from the queue is set by the
1189  * _wRemoveMsg_ flags, which should be one of the following values:
1190  *
1191  *    PM_NOREMOVE    Do not remove the message from the queue.
1192  *
1193  *    PM_REMOVE      Remove the message from the queue.
1194  *
1195  * In addition, PM_NOYIELD may be combined into _wRemoveMsg_ to
1196  * request that the system not yield control during PeekMessage();
1197  * however applications may not rely on scheduling behavior.
1198  *
1199  * RETURNS
1200  *
1201  *  Nonzero if a message is available and is retrieved, zero otherwise.
1202  *
1203  * CONFORMANCE
1204  *
1205  * ECMA-234, Win32
1206  *
1207  */
1208 BOOL WINAPI PeekMessageW(
1209   LPMSG lpmsg,    /* buffer to receive message */
1210   HWND hwnd,      /* restrict to messages for hwnd */
1211   UINT min,       /* minimum message to receive */
1212   UINT max,       /* maximum message to receive */
1213   UINT wRemoveMsg /* removal flags */
1214 )
1215 {
1216         BOOL bRet = PeekMessageA(lpmsg,hwnd,min,max,wRemoveMsg);
1217         if (bRet)
1218             FIXME_(sendmsg)("(%s) unicode<->ascii\n", SPY_GetMsgName(lpmsg->message));
1219         return bRet;
1220 }
1221
1222 /***********************************************************************
1223  *           GetMessage16   (USER.108)
1224  */
1225 BOOL16 WINAPI GetMessage16( SEGPTR msg, HWND16 hwnd, UINT16 first, UINT16 last)
1226 {
1227     BOOL ret;
1228     MSG16 *lpmsg = (MSG16 *)PTR_SEG_TO_LIN(msg);
1229     MSG msg32;
1230
1231     ret = GetMessageA( &msg32, hwnd, first, last );
1232
1233     STRUCT32_MSG32to16( &msg32, lpmsg );
1234
1235     TRACE_(msg)("message %04x, hwnd %04x, filter(%04x - %04x)\n", lpmsg->message,
1236                                                                  hwnd, first, last );
1237
1238     return ret;
1239 }
1240
1241 /***********************************************************************
1242  *          WIN16_GetMessage32   (USER.820)
1243  */
1244 BOOL16 WINAPI GetMessage32_16( SEGPTR msg16_32, HWND16 hWnd, UINT16 first,
1245                      UINT16 last, BOOL16 wHaveParamHigh )
1246 {
1247     MSG32_16 *lpmsg16_32 = (MSG32_16 *)PTR_SEG_TO_LIN(msg16_32);
1248
1249     if (wHaveParamHigh == FALSE) /* normal GetMessage16 call */
1250     {
1251
1252         lpmsg16_32->wParamHigh = 0; /* you never know... */
1253         /* WARNING: msg16_32->msg has to be the first variable in the struct */
1254         return GetMessage16(msg16_32, hWnd, first, last);
1255     }
1256     else
1257     {
1258         MSG msg32;
1259         BOOL16 ret;
1260
1261         ret = (BOOL16)GetMessageA(&msg32, hWnd, first, last);
1262         lpmsg16_32->msg.hwnd    = msg32.hwnd;
1263         lpmsg16_32->msg.message = msg32.message;
1264         lpmsg16_32->msg.wParam  = LOWORD(msg32.wParam);
1265         lpmsg16_32->msg.lParam  = msg32.lParam;
1266         lpmsg16_32->msg.time    = msg32.time;
1267         lpmsg16_32->msg.pt.x    = (INT16)msg32.pt.x;
1268         lpmsg16_32->msg.pt.y    = (INT16)msg32.pt.y;
1269         lpmsg16_32->wParamHigh  = HIWORD(msg32.wParam);
1270         return ret;
1271     }
1272 }
1273
1274 /***********************************************************************
1275  *          GetMessage32A   (USER32.270)
1276  */
1277 BOOL WINAPI GetMessageA(MSG* lpmsg,HWND hwnd,UINT min,UINT max)
1278 {
1279     MSG_PeekMessage( lpmsg, hwnd, min, max, PM_REMOVE, FALSE );
1280
1281     TRACE_(msg)("message %04x, hwnd %04x, filter(%04x - %04x)\n", lpmsg->message,
1282           hwnd, min, max );
1283
1284     HOOK_CallHooksA( WH_GETMESSAGE, HC_ACTION, 0, (LPARAM)lpmsg );
1285
1286     return (lpmsg->message != WM_QUIT);
1287 }
1288
1289 /***********************************************************************
1290  *          GetMessage32W   (USER32.274) Retrieve next message
1291  *
1292  * GetMessage retrieves the next event from the calling thread's
1293  * queue and deposits it in *lpmsg.
1294  *
1295  * If _hwnd_ is not NULL, only messages for window _hwnd_ and its
1296  * children as specified by IsChild() are retrieved. If _hwnd_ is NULL
1297  * all application messages are retrieved.
1298  *
1299  * _min_ and _max_ specify the range of messages of interest. If
1300  * min==max==0, no filtering is performed. Useful examples are
1301  * WM_KEYFIRST and WM_KEYLAST to retrieve keyboard input, and
1302  * WM_MOUSEFIRST and WM_MOUSELAST to retrieve mouse input.
1303  *
1304  * WM_PAINT messages are not removed from the queue; they remain until
1305  * processed. Other messages are removed from the queue.
1306  *
1307  * RETURNS
1308  *
1309  * -1 on error, 0 if message is WM_QUIT, nonzero otherwise.
1310  *
1311  * CONFORMANCE
1312  *
1313  * ECMA-234, Win32
1314  *
1315  */
1316 BOOL WINAPI GetMessageW(
1317   MSG* lpmsg, /* buffer to receive message */
1318   HWND hwnd,  /* restrict to messages for hwnd */
1319   UINT min,   /* minimum message to receive */
1320   UINT max    /* maximum message to receive */
1321 )
1322 {
1323     BOOL bRet = GetMessageA(lpmsg, hwnd, min, max);
1324     if (bRet)
1325         FIXME_(sendmsg)("(%s) unicode<->ascii\n", SPY_GetMsgName(lpmsg->message));
1326     return bRet;
1327
1328 }
1329
1330
1331 /***********************************************************************
1332  *           PostMessage16   (USER.110)
1333  */
1334 BOOL16 WINAPI PostMessage16( HWND16 hwnd, UINT16 message, WPARAM16 wParam,
1335                              LPARAM lParam )
1336 {
1337     return (BOOL16) PostMessageA( hwnd, message, wParam, lParam );
1338 }
1339
1340
1341 /***********************************************************************
1342  *           PostMessage32A   (USER32.419)
1343  */
1344 BOOL WINAPI PostMessageA( HWND hwnd, UINT message, WPARAM wParam,
1345                               LPARAM lParam )
1346 {
1347     MSG       msg;
1348     WND         *wndPtr;
1349     BOOL      retvalue;
1350
1351     msg.hwnd    = hwnd;
1352     msg.message = message;
1353     msg.wParam  = wParam;
1354     msg.lParam  = lParam;
1355     msg.time    = GetTickCount();
1356     msg.pt.x    = 0;
1357     msg.pt.y    = 0;
1358
1359 #ifdef CONFIG_IPC
1360     if (DDE_PostMessage(&msg))
1361        return TRUE;
1362 #endif  /* CONFIG_IPC */
1363
1364     if (hwnd == HWND_BROADCAST)
1365     {
1366         WND *pDesktop = WIN_GetDesktop();
1367         TRACE_(msg)("HWND_BROADCAST !\n");
1368
1369         for (wndPtr=WIN_LockWndPtr(pDesktop->child); wndPtr; WIN_UpdateWndPtr(&wndPtr,wndPtr->next))
1370         {
1371             if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
1372             {
1373                 TRACE_(msg)("BROADCAST Message to hWnd=%04x m=%04X w=%04X l=%08lX !\n",
1374                             wndPtr->hwndSelf, message, wParam, lParam);
1375                 PostMessageA( wndPtr->hwndSelf, message, wParam, lParam );
1376             }
1377         }
1378         WIN_ReleaseDesktop();
1379         TRACE_(msg)("End of HWND_BROADCAST !\n");
1380         return TRUE;
1381     }
1382
1383     wndPtr = WIN_FindWndPtr( hwnd );
1384     if (!wndPtr || !wndPtr->hmemTaskQ)
1385     {
1386         retvalue = FALSE;
1387         goto END;
1388     }
1389
1390     retvalue = QUEUE_AddMsg( wndPtr->hmemTaskQ, &msg, 0 );
1391 END:
1392     WIN_ReleaseWndPtr(wndPtr);
1393     return retvalue;
1394 }
1395
1396
1397 /***********************************************************************
1398  *           PostMessage32W   (USER32.420)
1399  */
1400 BOOL WINAPI PostMessageW( HWND hwnd, UINT message, WPARAM wParam,
1401                               LPARAM lParam )
1402 {
1403   FIXME_(sendmsg)("(%s) unicode<->ascii\n", SPY_GetMsgName(message));
1404   return PostMessageA( hwnd, message, wParam, lParam );
1405 }
1406
1407
1408 /***********************************************************************
1409  *           PostAppMessage16   (USER.116)
1410  */
1411 BOOL16 WINAPI PostAppMessage16( HTASK16 hTask, UINT16 message, WPARAM16 wParam,
1412                                 LPARAM lParam )
1413 {
1414     MSG msg;
1415
1416     if (GetTaskQueue16(hTask) == 0) return FALSE;
1417     msg.hwnd    = 0;
1418     msg.message = message;
1419     msg.wParam  = wParam;
1420     msg.lParam  = lParam;
1421     msg.time    = GetTickCount();
1422     msg.pt.x    = 0;
1423     msg.pt.y    = 0;
1424
1425     return QUEUE_AddMsg( GetTaskQueue16(hTask), &msg, 0 );
1426 }
1427
1428 /************************************************************************
1429  *           MSG_CallWndProcHook32
1430  */
1431 static void  MSG_CallWndProcHook( LPMSG pmsg, BOOL bUnicode )
1432 {
1433    CWPSTRUCT cwp;
1434
1435    cwp.lParam = pmsg->lParam;
1436    cwp.wParam = pmsg->wParam;
1437    cwp.message = pmsg->message;
1438    cwp.hwnd = pmsg->hwnd;
1439
1440    if (bUnicode) HOOK_CallHooksW(WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp);
1441    else HOOK_CallHooksA( WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp );
1442
1443    pmsg->lParam = cwp.lParam;
1444    pmsg->wParam = cwp.wParam;
1445    pmsg->message = cwp.message;
1446    pmsg->hwnd = cwp.hwnd;
1447 }
1448
1449
1450 /***********************************************************************
1451  *           MSG_SendMessage
1452  *
1453  * return values: 0 if timeout occurs
1454  *                1 otherwise
1455  */
1456 LRESULT MSG_SendMessage( HWND hwnd, UINT msg, WPARAM wParam,
1457                          LPARAM lParam, DWORD timeout, WORD flags,
1458                          LRESULT *pRes)
1459 {
1460     WND * wndPtr = 0;
1461     WND **list, **ppWnd;
1462     LRESULT ret = 1;
1463
1464     *pRes = 0;
1465
1466     if (hwnd == HWND_BROADCAST)
1467     {
1468         *pRes = 1;
1469
1470         if (!(list = WIN_BuildWinArray( WIN_GetDesktop(), 0, NULL )))
1471         {
1472             WIN_ReleaseDesktop();
1473             return 1;
1474         }
1475         WIN_ReleaseDesktop();
1476
1477         TRACE_(msg)("HWND_BROADCAST !\n");
1478         for (ppWnd = list; *ppWnd; ppWnd++)
1479         {
1480             WIN_UpdateWndPtr(&wndPtr,*ppWnd);
1481             if (!IsWindow(wndPtr->hwndSelf)) continue;
1482             if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
1483             {
1484                 TRACE_(msg)("BROADCAST Message to hWnd=%04x m=%04X w=%04lX l=%08lX !\n",
1485                             wndPtr->hwndSelf, msg, (DWORD)wParam, lParam);
1486                 MSG_SendMessage( wndPtr->hwndSelf, msg, wParam, lParam,
1487                                timeout, flags, pRes);
1488             }
1489         }
1490         WIN_ReleaseWndPtr(wndPtr);
1491         WIN_ReleaseWinArray(list);
1492         TRACE_(msg)("End of HWND_BROADCAST !\n");
1493         return 1;
1494     }
1495
1496     if (HOOK_IsHooked( WH_CALLWNDPROC ))
1497     {
1498         if (flags & SMSG_UNICODE)
1499             MSG_CallWndProcHook( (LPMSG)&hwnd, TRUE);
1500         else if (flags & SMSG_WIN32)
1501             MSG_CallWndProcHook( (LPMSG)&hwnd, FALSE);
1502         else
1503         {
1504         LPCWPSTRUCT16 pmsg;
1505
1506         if ((pmsg = SEGPTR_NEW(CWPSTRUCT16)))
1507         {
1508                 pmsg->hwnd   = hwnd & 0xffff;
1509                 pmsg->message= msg & 0xffff;
1510                 pmsg->wParam = wParam & 0xffff;
1511             pmsg->lParam = lParam;
1512             HOOK_CallHooks16( WH_CALLWNDPROC, HC_ACTION, 1,
1513                               (LPARAM)SEGPTR_GET(pmsg) );
1514             hwnd   = pmsg->hwnd;
1515             msg    = pmsg->message;
1516             wParam = pmsg->wParam;
1517             lParam = pmsg->lParam;
1518             SEGPTR_FREE( pmsg );
1519         }
1520     }
1521     }
1522
1523     if (!(wndPtr = WIN_FindWndPtr( hwnd )))
1524     {
1525         WARN_(msg)("invalid hwnd %04x\n", hwnd );
1526         return 0;
1527     }
1528     if (QUEUE_IsExitingQueue(wndPtr->hmemTaskQ))
1529     {
1530         ret = 0;  /* Don't send anything if the task is dying */
1531         goto END;
1532     }
1533     if (flags & SMSG_WIN32)
1534         SPY_EnterMessage( SPY_SENDMESSAGE, hwnd, msg, wParam, lParam );
1535     else
1536     SPY_EnterMessage( SPY_SENDMESSAGE16, hwnd, msg, wParam, lParam );
1537
1538     if (wndPtr->hmemTaskQ != GetFastQueue16())
1539         ret = MSG_SendMessageInterThread( wndPtr->hmemTaskQ, hwnd, msg,
1540                                           wParam, lParam, timeout, flags, pRes );
1541     else
1542     {
1543         /* Call the right CallWindowProc flavor */
1544         if (flags & SMSG_UNICODE)
1545             *pRes = CallWindowProcW( (WNDPROC)wndPtr->winproc,
1546                                      hwnd, msg, wParam, lParam );
1547         else if (flags & SMSG_WIN32)
1548             *pRes = CallWindowProcA( (WNDPROC)wndPtr->winproc,
1549                                 hwnd, msg, wParam, lParam );
1550         else
1551             *pRes = CallWindowProc16( (WNDPROC16)wndPtr->winproc,
1552                                     (HWND16) hwnd, (UINT16) msg,
1553                                     (WPARAM16) wParam, lParam );
1554     }
1555
1556     if (flags & SMSG_WIN32)
1557         SPY_ExitMessage( SPY_RESULT_OK, hwnd, msg, ret );
1558     else
1559     SPY_ExitMessage( SPY_RESULT_OK16, hwnd, msg, ret );
1560 END:
1561     WIN_ReleaseWndPtr(wndPtr);
1562     return ret;
1563 }
1564
1565
1566 /***********************************************************************
1567  *           SendMessage16   (USER.111)
1568  */
1569 LRESULT WINAPI SendMessage16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam,
1570                               LPARAM lParam)
1571 {
1572     LRESULT res;
1573 #ifdef CONFIG_IPC
1574     MSG16 DDE_msg = { hwnd, msg, wParam, lParam };
1575     if (DDE_SendMessage(&DDE_msg)) return TRUE;
1576 #endif  /* CONFIG_IPC */
1577
1578     MSG_SendMessage(hwnd, msg, wParam, lParam, INFINITE, 0, &res);
1579
1580     return res;
1581 }
1582
1583
1584
1585 /**********************************************************************
1586  *           PostThreadMessage32A    (USER32.422)
1587  *
1588  * BUGS
1589  *
1590  *  Thread-local message queues are not supported.
1591  *
1592  */
1593 BOOL WINAPI PostThreadMessageA(DWORD idThread , UINT message,
1594                                    WPARAM wParam, LPARAM lParam )
1595 {
1596     MSG msg;
1597     HQUEUE16 hQueue;
1598
1599     if ((hQueue = GetThreadQueue16(idThread)) == 0)
1600         return FALSE;
1601
1602     msg.hwnd    = 0;
1603     msg.message = message;
1604     msg.wParam  = wParam;
1605     msg.lParam  = lParam;
1606     msg.time    = GetTickCount();
1607     msg.pt.x    = 0;
1608     msg.pt.y    = 0;
1609
1610     return QUEUE_AddMsg( hQueue, &msg, 0 );
1611 }
1612
1613 /**********************************************************************
1614  *           PostThreadMessage32W    (USER32.423)
1615  *
1616  * BUGS
1617  *
1618  *  Thread-local message queues are not supported.
1619  *
1620  */
1621 BOOL WINAPI PostThreadMessageW(DWORD idThread , UINT message,
1622                                    WPARAM wParam, LPARAM lParam )
1623 {
1624    FIXME_(sendmsg)("(%s) unicode<->ascii\n",SPY_GetMsgName(message));
1625    return PostThreadMessageA(idThread, message, wParam, lParam);
1626 }
1627
1628 /***********************************************************************
1629  *           SendMessage32A   (USER32.454)
1630  */
1631 LRESULT WINAPI SendMessageA( HWND hwnd, UINT msg, WPARAM wParam,
1632                                LPARAM lParam )
1633         {
1634     LRESULT res;
1635
1636     MSG_SendMessage(hwnd, msg, wParam, lParam, INFINITE,
1637                     SMSG_WIN32, &res);
1638
1639     return res;
1640 }
1641
1642
1643 /***********************************************************************
1644  *           SendMessage32W   (USER32.459)  Send Window Message
1645  *
1646  *  Sends a message to the window procedure of the specified window.
1647  *  SendMessage() will not return until the called window procedure
1648  *  either returns or calls ReplyMessage().
1649  *
1650  *  Use PostMessage() to send message and return immediately. A window
1651  *  procedure may use InSendMessage() to detect
1652  *  SendMessage()-originated messages.
1653  *
1654  *  Applications which communicate via HWND_BROADCAST may use
1655  *  RegisterWindowMessage() to obtain a unique message to avoid conflicts
1656  *  with other applications.
1657  *
1658  * CONFORMANCE
1659  *
1660  *  ECMA-234, Win32
1661  */
1662 LRESULT WINAPI SendMessageW(
1663   HWND hwnd,    /* Window to send message to. If HWND_BROADCAST,
1664                  the message will be sent to all top-level windows. */
1665
1666   UINT msg,      /* message */
1667   WPARAM wParam, /* message parameter */
1668   LPARAM lParam    /* additional message parameter */
1669 ) {
1670     LRESULT res;
1671
1672     MSG_SendMessage(hwnd, msg, wParam, lParam, INFINITE,
1673                     SMSG_WIN32 | SMSG_UNICODE, &res);
1674
1675     return res;
1676 }
1677
1678
1679 /***********************************************************************
1680  *           SendMessageTimeout16    (not a WINAPI)
1681  */
1682 LRESULT WINAPI SendMessageTimeout16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam,
1683                                      LPARAM lParam, UINT16 flags,
1684                                      UINT16 timeout, LPWORD resultp)
1685 {
1686     LRESULT ret;
1687     LRESULT msgRet;
1688
1689     /* FIXME: need support for SMTO_BLOCK */
1690
1691     ret = MSG_SendMessage(hwnd, msg, wParam, lParam, timeout, 0, &msgRet);
1692     *resultp = (WORD) msgRet;
1693     return ret;
1694 }
1695
1696
1697 /***********************************************************************
1698  *           SendMessageTimeoutA   (USER32.457)
1699  */
1700 LRESULT WINAPI SendMessageTimeoutA( HWND hwnd, UINT msg, WPARAM wParam,
1701                                       LPARAM lParam, UINT flags,
1702                                       UINT timeout, LPDWORD resultp)
1703 {
1704     LRESULT ret;
1705     LRESULT msgRet;
1706
1707     /* FIXME: need support for SMTO_BLOCK */
1708
1709     ret = MSG_SendMessage(hwnd, msg, wParam, lParam, timeout, SMSG_WIN32,
1710                           &msgRet);
1711
1712     *resultp = (DWORD) msgRet;
1713     return ret;
1714 }
1715
1716
1717 /***********************************************************************
1718  *           SendMessageTimeoutW   (USER32.458)
1719  */
1720 LRESULT WINAPI SendMessageTimeoutW( HWND hwnd, UINT msg, WPARAM wParam,
1721                                       LPARAM lParam, UINT flags,
1722                                       UINT timeout, LPDWORD resultp)
1723 {
1724     LRESULT ret;
1725     LRESULT msgRet;
1726
1727     /* FIXME: need support for SMTO_BLOCK */
1728
1729     ret = MSG_SendMessage(hwnd, msg, wParam, lParam, timeout,
1730                           SMSG_WIN32 | SMSG_UNICODE, &msgRet);
1731
1732     *resultp = (DWORD) msgRet;
1733     return ret;
1734 }
1735
1736
1737 /***********************************************************************
1738  *  WaitMessage    (USER.112) (USER32.578)  Suspend thread pending messages
1739  *
1740  * WaitMessage() suspends a thread until events appear in the thread's
1741  * queue.
1742  *
1743  * BUGS
1744  *
1745  * Is supposed to return BOOL under Win32.
1746  *
1747  * Thread-local message queues are not supported.
1748  *
1749  * CONFORMANCE
1750  *
1751  * ECMA-234, Win32
1752  *
1753  */
1754 void WINAPI WaitMessage( void )
1755 {
1756     QUEUE_WaitBits( QS_ALLINPUT, INFINITE );
1757 }
1758
1759 /***********************************************************************
1760  *           MsgWaitForMultipleObjects    (USER32.400)
1761  */
1762 DWORD WINAPI MsgWaitForMultipleObjects( DWORD nCount, HANDLE *pHandles,
1763                                         BOOL fWaitAll, DWORD dwMilliseconds,
1764                                         DWORD dwWakeMask )
1765 {
1766     DWORD i;
1767     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
1768     DWORD ret;
1769
1770     HQUEUE16 hQueue = GetFastQueue16();
1771     MESSAGEQUEUE *msgQueue = (MESSAGEQUEUE *)QUEUE_Lock( hQueue );
1772     if (!msgQueue) return WAIT_FAILED;
1773
1774     if (nCount > MAXIMUM_WAIT_OBJECTS-1)
1775     {
1776         SetLastError( ERROR_INVALID_PARAMETER );
1777         QUEUE_Unlock( msgQueue );
1778         return WAIT_FAILED;
1779     }
1780
1781     msgQueue->changeBits = 0;
1782     msgQueue->wakeMask = dwWakeMask;
1783
1784     if (THREAD_IsWin16(THREAD_Current()))
1785     {
1786       /*
1787        * This is a temporary solution to a big problem.
1788        * You see, the main thread of all Win32 programs is created as a 16 bit
1789        * task. This means that if you want on an event using Win32 synchronization
1790        * methods, the 16 bit scheduler is stopped and things might just stop happening.
1791        * This implements a semi-busy loop that checks the handles to wait on and
1792        * also the message queue. When either one is ready, the wait function returns.
1793        *
1794        * This will all go away when the real Win32 threads are implemented for all
1795        * the threads of an applications. Including the main thread.
1796        */
1797       DWORD curTime = GetCurrentTime();
1798
1799       do
1800       {
1801         /*
1802          * Check the handles in the list.
1803          */
1804         ret = WaitForMultipleObjects(nCount, pHandles, fWaitAll, 5L);
1805
1806         /*
1807          * If the handles have been triggered, return.
1808          */
1809         if (ret != WAIT_TIMEOUT)
1810           break;
1811
1812         /*
1813          * Then, let the 16 bit scheduler do it's thing.
1814          */
1815         Yield16();
1816
1817         /*
1818          * If a message matching the wait mask has arrived, return.
1819          */
1820         if (msgQueue->changeBits & dwWakeMask)
1821         {
1822           ret = nCount;
1823           break;
1824         }
1825
1826         /*
1827          * And continue doing this until we hit the timeout.
1828          */
1829       } while ((dwMilliseconds == INFINITE) || (GetCurrentTime()-curTime < dwMilliseconds) );
1830     }
1831     else
1832     {
1833     /* Add the thread event to the handle list */
1834       for (i = 0; i < nCount; i++)
1835         handles[i] = pHandles[i];
1836     handles[nCount] = msgQueue->hEvent;
1837
1838     EVENT_Pending();
1839
1840     ret = WaitForMultipleObjects( nCount+1, handles, fWaitAll, dwMilliseconds );
1841     }
1842
1843     QUEUE_Unlock( msgQueue );
1844
1845     return ret;
1846 }
1847
1848
1849
1850 struct accent_char
1851 {
1852     BYTE ac_accent;
1853     BYTE ac_char;
1854     BYTE ac_result;
1855 };
1856
1857 static const struct accent_char accent_chars[] =
1858 {
1859 /* A good idea should be to read /usr/X11/lib/X11/locale/iso8859-x/Compose */
1860     {'`', 'A', '\300'},  {'`', 'a', '\340'},
1861     {'\'', 'A', '\301'}, {'\'', 'a', '\341'},
1862     {'^', 'A', '\302'},  {'^', 'a', '\342'},
1863     {'~', 'A', '\303'},  {'~', 'a', '\343'},
1864     {'"', 'A', '\304'},  {'"', 'a', '\344'},
1865     {'O', 'A', '\305'},  {'o', 'a', '\345'},
1866     {'0', 'A', '\305'},  {'0', 'a', '\345'},
1867     {'A', 'A', '\305'},  {'a', 'a', '\345'},
1868     {'A', 'E', '\306'},  {'a', 'e', '\346'},
1869     {',', 'C', '\307'},  {',', 'c', '\347'},
1870     {'`', 'E', '\310'},  {'`', 'e', '\350'},
1871     {'\'', 'E', '\311'}, {'\'', 'e', '\351'},
1872     {'^', 'E', '\312'},  {'^', 'e', '\352'},
1873     {'"', 'E', '\313'},  {'"', 'e', '\353'},
1874     {'`', 'I', '\314'},  {'`', 'i', '\354'},
1875     {'\'', 'I', '\315'}, {'\'', 'i', '\355'},
1876     {'^', 'I', '\316'},  {'^', 'i', '\356'},
1877     {'"', 'I', '\317'},  {'"', 'i', '\357'},
1878     {'-', 'D', '\320'},  {'-', 'd', '\360'},
1879     {'~', 'N', '\321'},  {'~', 'n', '\361'},
1880     {'`', 'O', '\322'},  {'`', 'o', '\362'},
1881     {'\'', 'O', '\323'}, {'\'', 'o', '\363'},
1882     {'^', 'O', '\324'},  {'^', 'o', '\364'},
1883     {'~', 'O', '\325'},  {'~', 'o', '\365'},
1884     {'"', 'O', '\326'},  {'"', 'o', '\366'},
1885     {'/', 'O', '\330'},  {'/', 'o', '\370'},
1886     {'`', 'U', '\331'},  {'`', 'u', '\371'},
1887     {'\'', 'U', '\332'}, {'\'', 'u', '\372'},
1888     {'^', 'U', '\333'},  {'^', 'u', '\373'},
1889     {'"', 'U', '\334'},  {'"', 'u', '\374'},
1890     {'\'', 'Y', '\335'}, {'\'', 'y', '\375'},
1891     {'T', 'H', '\336'},  {'t', 'h', '\376'},
1892     {'s', 's', '\337'},  {'"', 'y', '\377'},
1893     {'s', 'z', '\337'},  {'i', 'j', '\377'},
1894         /* iso-8859-2 uses this */
1895     {'<', 'L', '\245'},  {'<', 'l', '\265'},    /* caron */
1896     {'<', 'S', '\251'},  {'<', 's', '\271'},
1897     {'<', 'T', '\253'},  {'<', 't', '\273'},
1898     {'<', 'Z', '\256'},  {'<', 'z', '\276'},
1899     {'<', 'C', '\310'},  {'<', 'c', '\350'},
1900     {'<', 'E', '\314'},  {'<', 'e', '\354'},
1901     {'<', 'D', '\317'},  {'<', 'd', '\357'},
1902     {'<', 'N', '\322'},  {'<', 'n', '\362'},
1903     {'<', 'R', '\330'},  {'<', 'r', '\370'},
1904     {';', 'A', '\241'},  {';', 'a', '\261'},    /* ogonek */
1905     {';', 'E', '\312'},  {';', 'e', '\332'},
1906     {'\'', 'Z', '\254'}, {'\'', 'z', '\274'},   /* acute */
1907     {'\'', 'R', '\300'}, {'\'', 'r', '\340'},
1908     {'\'', 'L', '\305'}, {'\'', 'l', '\345'},
1909     {'\'', 'C', '\306'}, {'\'', 'c', '\346'},
1910     {'\'', 'N', '\321'}, {'\'', 'n', '\361'},
1911 /*  collision whith S, from iso-8859-9 !!! */
1912     {',', 'S', '\252'},  {',', 's', '\272'},    /* cedilla */
1913     {',', 'T', '\336'},  {',', 't', '\376'},
1914     {'.', 'Z', '\257'},  {'.', 'z', '\277'},    /* dot above */
1915     {'/', 'L', '\243'},  {'/', 'l', '\263'},    /* slash */
1916     {'/', 'D', '\320'},  {'/', 'd', '\360'},
1917     {'(', 'A', '\303'},  {'(', 'a', '\343'},    /* breve */
1918     {'\275', 'O', '\325'}, {'\275', 'o', '\365'},       /* double acute */
1919     {'\275', 'U', '\334'}, {'\275', 'u', '\374'},
1920     {'0', 'U', '\332'},  {'0', 'u', '\372'},    /* ring above */
1921         /* iso-8859-3 uses this */
1922     {'/', 'H', '\241'},  {'/', 'h', '\261'},    /* slash */
1923     {'>', 'H', '\246'},  {'>', 'h', '\266'},    /* circumflex */
1924     {'>', 'J', '\254'},  {'>', 'j', '\274'},
1925     {'>', 'C', '\306'},  {'>', 'c', '\346'},
1926     {'>', 'G', '\330'},  {'>', 'g', '\370'},
1927     {'>', 'S', '\336'},  {'>', 's', '\376'},
1928 /*  collision whith G( from iso-8859-9 !!!   */
1929     {'(', 'G', '\253'},  {'(', 'g', '\273'},    /* breve */
1930     {'(', 'U', '\335'},  {'(', 'u', '\375'},
1931 /*  collision whith I. from iso-8859-3 !!!   */
1932     {'.', 'I', '\251'},  {'.', 'i', '\271'},    /* dot above */
1933     {'.', 'C', '\305'},  {'.', 'c', '\345'},
1934     {'.', 'G', '\325'},  {'.', 'g', '\365'},
1935         /* iso-8859-4 uses this */
1936     {',', 'R', '\243'},  {',', 'r', '\263'},    /* cedilla */
1937     {',', 'L', '\246'},  {',', 'l', '\266'},
1938     {',', 'G', '\253'},  {',', 'g', '\273'},
1939     {',', 'N', '\321'},  {',', 'n', '\361'},
1940     {',', 'K', '\323'},  {',', 'k', '\363'},
1941     {'~', 'I', '\245'},  {'~', 'i', '\265'},    /* tilde */
1942     {'-', 'E', '\252'},  {'-', 'e', '\272'},    /* macron */
1943     {'-', 'A', '\300'},  {'-', 'a', '\340'},
1944     {'-', 'I', '\317'},  {'-', 'i', '\357'},
1945     {'-', 'O', '\322'},  {'-', 'o', '\362'},
1946     {'-', 'U', '\336'},  {'-', 'u', '\376'},
1947     {'/', 'T', '\254'},  {'/', 't', '\274'},    /* slash */
1948     {'.', 'E', '\314'},  {'.', 'e', '\344'},    /* dot above */
1949     {';', 'I', '\307'},  {';', 'i', '\347'},    /* ogonek */
1950     {';', 'U', '\331'},  {';', 'u', '\371'},
1951         /* iso-8859-9 uses this */
1952         /* iso-8859-9 has really bad choosen G( S, and I. as they collide
1953          * whith the same letters on other iso-8859-x (that is they are on
1954          * different places :-( ), if you use turkish uncomment these and
1955          * comment out the lines in iso-8859-2 and iso-8859-3 sections
1956          * FIXME: should be dynamic according to chosen language
1957          *        if/when Wine has turkish support.
1958          */
1959 /*  collision whith G( from iso-8859-3 !!!   */
1960 /*  {'(', 'G', '\320'},  {'(', 'g', '\360'}, */ /* breve */
1961 /*  collision whith S, from iso-8859-2 !!! */
1962 /*  {',', 'S', '\336'},  {',', 's', '\376'}, */ /* cedilla */
1963 /*  collision whith I. from iso-8859-3 !!!   */
1964 /*  {'.', 'I', '\335'},  {'.', 'i', '\375'}, */ /* dot above */
1965 };
1966
1967
1968 /***********************************************************************
1969  *           MSG_DoTranslateMessage
1970  *
1971  * Implementation of TranslateMessage.
1972  *
1973  * TranslateMessage translates virtual-key messages into character-messages,
1974  * as follows :
1975  * WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or WM_DEADCHAR message.
1976  * ditto replacing WM_* with WM_SYS*
1977  * This produces WM_CHAR messages only for keys mapped to ASCII characters
1978  * by the keyboard driver.
1979  */
1980 static BOOL MSG_DoTranslateMessage( UINT message, HWND hwnd,
1981                                       WPARAM wParam, LPARAM lParam )
1982 {
1983     static int dead_char;
1984     BYTE wp[2];
1985
1986     if (message != WM_MOUSEMOVE && message != WM_TIMER)
1987         TRACE_(msg)("(%s, %04X, %08lX)\n",
1988                      SPY_GetMsgName(message), wParam, lParam );
1989     if(message >= WM_KEYFIRST && message <= WM_KEYLAST)
1990         TRACE_(key)("(%s, %04X, %08lX)\n",
1991                      SPY_GetMsgName(message), wParam, lParam );
1992
1993     if ((message != WM_KEYDOWN) && (message != WM_SYSKEYDOWN))  return FALSE;
1994
1995     TRACE_(key)("Translating key %04X, scancode %04X\n",
1996                  wParam, HIWORD(lParam) );
1997
1998     /* FIXME : should handle ToAscii yielding 2 */
1999     switch (ToAscii(wParam, HIWORD(lParam),
2000                       QueueKeyStateTable,(LPWORD)wp, 0))
2001     {
2002     case 1 :
2003         message = (message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
2004         /* Should dead chars handling go in ToAscii ? */
2005         if (dead_char)
2006         {
2007             int i;
2008
2009             if (wp[0] == ' ') wp[0] =  dead_char;
2010             if (dead_char == 0xa2) dead_char = '(';
2011             else if (dead_char == 0xa8) dead_char = '"';
2012             else if (dead_char == 0xb2) dead_char = ';';
2013             else if (dead_char == 0xb4) dead_char = '\'';
2014             else if (dead_char == 0xb7) dead_char = '<';
2015             else if (dead_char == 0xb8) dead_char = ',';
2016             else if (dead_char == 0xff) dead_char = '.';
2017             for (i = 0; i < sizeof(accent_chars)/sizeof(accent_chars[0]); i++)
2018                 if ((accent_chars[i].ac_accent == dead_char) &&
2019                     (accent_chars[i].ac_char == wp[0]))
2020                 {
2021                     wp[0] = accent_chars[i].ac_result;
2022                     break;
2023                 }
2024             dead_char = 0;
2025         }
2026         TRACE_(key)("1 -> PostMessage(%s)\n", SPY_GetMsgName(message));
2027         PostMessage16( hwnd, message, wp[0], lParam );
2028         return TRUE;
2029
2030     case -1 :
2031         message = (message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
2032         dead_char = wp[0];
2033         TRACE_(key)("-1 -> PostMessage(%s)\n",
2034                      SPY_GetMsgName(message));
2035         PostMessage16( hwnd, message, wp[0], lParam );
2036         return TRUE;
2037     }
2038     return FALSE;
2039 }
2040
2041
2042 /***********************************************************************
2043  *           TranslateMessage16   (USER.113)
2044  */
2045 BOOL16 WINAPI TranslateMessage16( const MSG16 *msg )
2046 {
2047     return MSG_DoTranslateMessage( msg->message, msg->hwnd,
2048                                    msg->wParam, msg->lParam );
2049 }
2050
2051
2052 /***********************************************************************
2053  *           WIN16_TranslateMessage32   (USER.821)
2054  */
2055 BOOL16 WINAPI TranslateMessage32_16( const MSG32_16 *msg, BOOL16 wHaveParamHigh )
2056 {
2057     WPARAM wParam;
2058
2059     if (wHaveParamHigh)
2060         wParam = MAKELONG(msg->msg.wParam, msg->wParamHigh);
2061     else
2062         wParam = (WPARAM)msg->msg.wParam;
2063
2064     return MSG_DoTranslateMessage( msg->msg.message, msg->msg.hwnd,
2065                                    wParam, msg->msg.lParam );
2066 }
2067
2068 /***********************************************************************
2069  *           TranslateMessage32   (USER32.556)
2070  */
2071 BOOL WINAPI TranslateMessage( const MSG *msg )
2072 {
2073     return MSG_DoTranslateMessage( msg->message, msg->hwnd,
2074                                    msg->wParam, msg->lParam );
2075 }
2076
2077
2078 /***********************************************************************
2079  *           DispatchMessage16   (USER.114)
2080  */
2081 LONG WINAPI DispatchMessage16( const MSG16* msg )
2082 {
2083     WND * wndPtr;
2084     LONG retval;
2085     int painting;
2086
2087       /* Process timer messages */
2088     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
2089     {
2090         if (msg->lParam)
2091         {
2092             return CallWindowProc16( (WNDPROC16)msg->lParam, msg->hwnd,
2093                                    msg->message, msg->wParam, GetTickCount() );
2094         }
2095     }
2096
2097     if (!msg->hwnd) return 0;
2098     if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
2099     if (!wndPtr->winproc)
2100     {
2101         retval = 0;
2102         goto END;
2103     }
2104     painting = (msg->message == WM_PAINT);
2105     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
2106
2107     SPY_EnterMessage( SPY_DISPATCHMESSAGE16, msg->hwnd, msg->message,
2108                       msg->wParam, msg->lParam );
2109     retval = CallWindowProc16( (WNDPROC16)wndPtr->winproc,
2110                                msg->hwnd, msg->message,
2111                                msg->wParam, msg->lParam );
2112     SPY_ExitMessage( SPY_RESULT_OK16, msg->hwnd, msg->message, retval );
2113
2114     WIN_ReleaseWndPtr(wndPtr);
2115     wndPtr = WIN_FindWndPtr(msg->hwnd);
2116     if (painting && wndPtr &&
2117         (wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
2118     {
2119         ERR_(msg)("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
2120             msg->hwnd);
2121         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
2122         /* Validate the update region to avoid infinite WM_PAINT loop */
2123         ValidateRect( msg->hwnd, NULL );
2124     }
2125 END:
2126     WIN_ReleaseWndPtr(wndPtr);
2127     return retval;
2128 }
2129
2130
2131 /***********************************************************************
2132  *           WIN16_DispatchMessage32   (USER.822)
2133  */
2134 LONG WINAPI DispatchMessage32_16( const MSG32_16* lpmsg16_32, BOOL16 wHaveParamHigh )
2135 {
2136     if (wHaveParamHigh == FALSE)
2137         return DispatchMessage16(&(lpmsg16_32->msg));
2138     else
2139     {
2140         MSG msg;
2141
2142         msg.hwnd = lpmsg16_32->msg.hwnd;
2143         msg.message = lpmsg16_32->msg.message;
2144         msg.wParam = MAKELONG(lpmsg16_32->msg.wParam, lpmsg16_32->wParamHigh);
2145         msg.lParam = lpmsg16_32->msg.lParam;
2146         msg.time = lpmsg16_32->msg.time;
2147         msg.pt.x = (INT)lpmsg16_32->msg.pt.x;
2148         msg.pt.y = (INT)lpmsg16_32->msg.pt.y;
2149         return DispatchMessageA(&msg);
2150     }
2151 }
2152
2153 /***********************************************************************
2154  *           DispatchMessage32A   (USER32.141)
2155  */
2156 LONG WINAPI DispatchMessageA( const MSG* msg )
2157 {
2158     WND * wndPtr;
2159     LONG retval;
2160     int painting;
2161
2162       /* Process timer messages */
2163     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
2164     {
2165         if (msg->lParam)
2166         {
2167 /*            HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
2168             return CallWindowProcA( (WNDPROC)msg->lParam, msg->hwnd,
2169                                    msg->message, msg->wParam, GetTickCount() );
2170         }
2171     }
2172
2173     if (!msg->hwnd) return 0;
2174     if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
2175     if (!wndPtr->winproc)
2176     {
2177         retval = 0;
2178         goto END;
2179     }
2180     painting = (msg->message == WM_PAINT);
2181     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
2182 /*    HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
2183
2184     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
2185                       msg->wParam, msg->lParam );
2186     retval = CallWindowProcA( (WNDPROC)wndPtr->winproc,
2187                                 msg->hwnd, msg->message,
2188                                 msg->wParam, msg->lParam );
2189     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval );
2190
2191     WIN_ReleaseWndPtr(wndPtr);
2192     wndPtr = WIN_FindWndPtr(msg->hwnd);
2193
2194     if (painting && wndPtr &&
2195         (wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
2196     {
2197         ERR_(msg)("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
2198             msg->hwnd);
2199         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
2200         /* Validate the update region to avoid infinite WM_PAINT loop */
2201         ValidateRect( msg->hwnd, NULL );
2202     }
2203 END:
2204     WIN_ReleaseWndPtr(wndPtr);
2205     return retval;
2206 }
2207
2208
2209 /***********************************************************************
2210  *           DispatchMessage32W   (USER32.142)     Process Message
2211  *
2212  * Process the message specified in the structure *_msg_.
2213  *
2214  * If the lpMsg parameter points to a WM_TIMER message and the
2215  * parameter of the WM_TIMER message is not NULL, the lParam parameter
2216  * points to the function that is called instead of the window
2217  * procedure.
2218  *
2219  * The message must be valid.
2220  *
2221  * RETURNS
2222  *
2223  *   DispatchMessage() returns the result of the window procedure invoked.
2224  *
2225  * CONFORMANCE
2226  *
2227  *   ECMA-234, Win32
2228  *
2229  */
2230 LONG WINAPI DispatchMessageW( const MSG* msg )
2231 {
2232     WND * wndPtr;
2233     LONG retval;
2234     int painting;
2235
2236       /* Process timer messages */
2237     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
2238     {
2239         if (msg->lParam)
2240         {
2241 /*            HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
2242             return CallWindowProcW( (WNDPROC)msg->lParam, msg->hwnd,
2243                                    msg->message, msg->wParam, GetTickCount() );
2244         }
2245     }
2246
2247     if (!msg->hwnd) return 0;
2248     if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
2249     if (!wndPtr->winproc)
2250     {
2251         retval = 0;
2252         goto END;
2253     }
2254     painting = (msg->message == WM_PAINT);
2255     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
2256 /*    HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
2257
2258     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
2259                       msg->wParam, msg->lParam );
2260     retval = CallWindowProcW( (WNDPROC)wndPtr->winproc,
2261                                 msg->hwnd, msg->message,
2262                                 msg->wParam, msg->lParam );
2263     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval );
2264
2265     WIN_ReleaseWndPtr(wndPtr);
2266     wndPtr = WIN_FindWndPtr(msg->hwnd);
2267
2268     if (painting && wndPtr &&
2269         (wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
2270     {
2271         ERR_(msg)("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
2272             msg->hwnd);
2273         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
2274         /* Validate the update region to avoid infinite WM_PAINT loop */
2275         ValidateRect( msg->hwnd, NULL );
2276     }
2277 END:
2278     WIN_ReleaseWndPtr(wndPtr);
2279     return retval;
2280 }
2281
2282
2283 /***********************************************************************
2284  *           RegisterWindowMessage16   (USER.118)
2285  */
2286 WORD WINAPI RegisterWindowMessage16( SEGPTR str )
2287 {
2288     TRACE_(msg)("%08lx\n", (DWORD)str );
2289     return GlobalAddAtom16( str );
2290 }
2291
2292
2293 /***********************************************************************
2294  *           RegisterWindowMessage32A   (USER32.437)
2295  */
2296 WORD WINAPI RegisterWindowMessageA( LPCSTR str )
2297 {
2298     TRACE_(msg)("%s\n", str );
2299     return GlobalAddAtomA( str );
2300 }
2301
2302
2303 /***********************************************************************
2304  *           RegisterWindowMessage32W   (USER32.438)
2305  */
2306 WORD WINAPI RegisterWindowMessageW( LPCWSTR str )
2307 {
2308     TRACE_(msg)("%p\n", str );
2309     return GlobalAddAtomW( str );
2310 }
2311
2312
2313 /***********************************************************************
2314  *           GetTickCount   (USER.13) (KERNEL32.299)  System Time
2315  * Returns the number of milliseconds, modulo 2^32, since the start
2316  * of the current session.
2317  *
2318  * CONFORMANCE
2319  *
2320  * ECMA-234, Win32
2321  */
2322 DWORD WINAPI GetTickCount(void)
2323 {
2324     struct timeval t;
2325     gettimeofday( &t, NULL );
2326     /* make extremely compatible: granularity is 25 msec */
2327     return ((t.tv_sec * 1000) + (t.tv_usec / 25000) * 25) - MSG_WineStartTicks;
2328 }
2329
2330
2331 /***********************************************************************
2332  *           GetCurrentTime16    (USER.15)
2333  *
2334  * (effectively identical to GetTickCount)
2335  */
2336 DWORD WINAPI GetCurrentTime16(void)
2337 {
2338     return GetTickCount();
2339 }
2340
2341
2342 /***********************************************************************
2343  *           InSendMessage16    (USER.192)
2344  */
2345 BOOL16 WINAPI InSendMessage16(void)
2346 {
2347     return InSendMessage();
2348 }
2349
2350
2351 /***********************************************************************
2352  *           InSendMessage32    (USER32.320)
2353  */
2354 BOOL WINAPI InSendMessage(void)
2355 {
2356     MESSAGEQUEUE *queue;
2357     BOOL ret;
2358
2359     if (!(queue = (MESSAGEQUEUE *)QUEUE_Lock( GetFastQueue16() )))
2360         return 0;
2361     ret = (BOOL)queue->smWaiting;
2362
2363     QUEUE_Unlock( queue );
2364     return ret;
2365 }
2366
2367 /***********************************************************************
2368  *           BroadcastSystemMessage    (USER32.12)
2369  */
2370 LONG WINAPI BroadcastSystemMessage(
2371         DWORD dwFlags,LPDWORD recipients,UINT uMessage,WPARAM wParam,
2372         LPARAM lParam
2373 ) {
2374         FIXME_(sendmsg)("(%08lx,%08lx,%08x,%08x,%08lx): stub!\n",
2375               dwFlags,*recipients,uMessage,wParam,lParam
2376         );
2377         return 0;
2378 }
2379
2380 /***********************************************************************
2381  *           SendNotifyMessageA    (USER32.460)
2382  * FIXME
2383  *  The message sended with PostMessage has to be put in the queue
2384  *  with a higher priority as the other "Posted" messages.
2385  *  QUEUE_AddMsg has to be modifyed.
2386  */
2387 BOOL WINAPI SendNotifyMessageA(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
2388 {       BOOL ret = TRUE;
2389         FIXME_(msg)("(%04x,%08x,%08x,%08lx) not complete\n",
2390               hwnd, msg, wParam, lParam);
2391
2392         if ( GetCurrentThreadId() == GetWindowThreadProcessId ( hwnd, NULL))
2393         {       ret=SendMessageA ( hwnd, msg, wParam, lParam );
2394         }
2395         else
2396         {       PostMessageA ( hwnd, msg, wParam, lParam );
2397         }
2398         return ret;
2399 }
2400
2401 /***********************************************************************
2402  *           SendNotifyMessageW    (USER32.461)
2403  * FIXME
2404  *  The message sended with PostMessage has to be put in the queue
2405  *  with a higher priority as the other "Posted" messages.
2406  *  QUEUE_AddMsg has to be modifyed.
2407  */
2408 BOOL WINAPI SendNotifyMessageW(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
2409 {       BOOL ret = TRUE;
2410         FIXME_(msg)("(%04x,%08x,%08x,%08lx) not complete\n",
2411               hwnd, msg, wParam, lParam);
2412
2413         if ( GetCurrentThreadId() == GetWindowThreadProcessId ( hwnd, NULL))
2414         {       ret=SendMessageW ( hwnd, msg, wParam, lParam );
2415         }
2416         else
2417         {       PostMessageW ( hwnd, msg, wParam, lParam );
2418         }
2419         return ret;
2420 }
2421
2422 /***********************************************************************
2423  *           SendMessageCallback32A
2424  * FIXME: It's like PostMessage. The callback gets called when the message
2425  * is processed. We have to modify the message processing for a exact
2426  * implementation...
2427  */
2428 BOOL WINAPI SendMessageCallbackA(
2429         HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,
2430         FARPROC lpResultCallBack,DWORD dwData)
2431 {
2432         FIXME_(msg)("(0x%04x,0x%04x,0x%08x,0x%08lx,%p,0x%08lx),stub!\n",
2433                 hWnd,Msg,wParam,lParam,lpResultCallBack,dwData);
2434         if ( hWnd == HWND_BROADCAST)
2435         {       PostMessageA( hWnd, Msg, wParam, lParam);
2436                 FIXME_(msg)("Broadcast: Callback will not be called!\n");
2437                 return TRUE;
2438         }
2439         (lpResultCallBack)( hWnd, Msg, dwData, SendMessageA ( hWnd, Msg, wParam, lParam ));
2440                 return TRUE;
2441 }
2442 /***********************************************************************
2443  *           SendMessageCallback32W
2444  * FIXME: It's like PostMessage. The callback gets called when the message
2445  * is processed. We have to modify the message processing for a exact
2446  * implementation...
2447  */
2448 BOOL WINAPI SendMessageCallbackW(
2449         HWND hWnd,UINT Msg,WPARAM wParam,LPARAM lParam,
2450         FARPROC lpResultCallBack,DWORD dwData)
2451 {
2452         FIXME_(msg)("(0x%04x,0x%04x,0x%08x,0x%08lx,%p,0x%08lx),stub!\n",
2453                 hWnd,Msg,wParam,lParam,lpResultCallBack,dwData);
2454         if ( hWnd == HWND_BROADCAST)
2455         {       PostMessageW( hWnd, Msg, wParam, lParam);
2456                 FIXME_(msg)("Broadcast: Callback will not be called!\n");
2457                 return TRUE;
2458         }
2459         (lpResultCallBack)( hWnd, Msg, dwData, SendMessageA ( hWnd, Msg, wParam, lParam ));
2460                 return TRUE;
2461 }