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