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