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

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