windows/message.c

   1 /*
   2  * Message queues related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <ctype.h>
  24 #include <sys/time.h>
  25 #include <sys/types.h>
  26
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "message.h"
  31 #include "winerror.h"
  32 #include "wine/server.h"
  33 #include "win.h"
  34 #include "heap.h"
  35 #include "hook.h"
  36 #include "input.h"
  37 #include "spy.h"
  38 #include "winpos.h"
  39 #include "dde.h"
  40 #include "queue.h"
  41 #include "winproc.h"
  42 #include "user.h"
  43 #include "thread.h"
  44 #include "task.h"
  45 #include "controls.h"
  46 #include "wine/debug.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(msg);
  49 WINE_DECLARE_DEBUG_CHANNEL(key);
  50
  51 #define WM_NCMOUSEFIRST         WM_NCMOUSEMOVE
  52 #define WM_NCMOUSELAST          WM_NCMBUTTONDBLCLK
  53
  54 static BYTE QueueKeyStateTable[256];
  55
  56
  57 /***********************************************************************
  58  *           is_keyboard_message
  59  */
  60 inline static BOOL is_keyboard_message( UINT message )
  61 {
  62     return (message >= WM_KEYFIRST && message <= WM_KEYLAST);
  63 }
  64
  65
  66 /***********************************************************************
  67  *           is_mouse_message
  68  */
  69 inline static BOOL is_mouse_message( UINT message )
  70 {
  71     return ((message >= WM_NCMOUSEFIRST && message <= WM_NCMOUSELAST) ||
  72             (message >= WM_MOUSEFIRST && message <= WM_MOUSELAST));
  73 }
  74
  75
  76 /***********************************************************************
  77  *           check_message_filter
  78  */
  79 inline static BOOL check_message_filter( const MSG *msg, HWND hwnd, UINT first, UINT last )
  80 {
  81     if (hwnd)
  82     {
  83         if (msg->hwnd != hwnd && !IsChild( hwnd, msg->hwnd )) return FALSE;
  84     }
  85     if (first || last)
  86     {
  87        return (msg->message >= first && msg->message <= last);
  88     }
  89     return TRUE;
  90 }
  91
  92
  93 /***********************************************************************
  94  *           process_sent_messages
  95  *
  96  * Process all pending sent messages.
  97  */
  98 inline static void process_sent_messages(void)
  99 {
 100     MSG msg;
 101     MSG_peek_message( &msg, 0, 0, 0, GET_MSG_REMOVE | GET_MSG_SENT_ONLY );
 102 }
 103
 104
 105 /***********************************************************************
 106  *           queue_hardware_message
 107  *
 108  * store a hardware message in the thread queue
 109  */
 110 static void queue_hardware_message( MSG *msg, ULONG_PTR extra_info, enum message_type type )
 111 {
 112     SERVER_START_REQ( send_message )
 113     {
 114         req->type   = type;
 115         req->id     = (void *)GetWindowThreadProcessId( msg->hwnd, NULL );
 116         req->win    = msg->hwnd;
 117         req->msg    = msg->message;
 118         req->wparam = msg->wParam;
 119         req->lparam = msg->lParam;
 120         req->x      = msg->pt.x;
 121         req->y      = msg->pt.y;
 122         req->time   = msg->time;
 123         req->info   = extra_info;
 124         req->timeout = 0;
 125         wine_server_call( req );
 126     }
 127     SERVER_END_REQ;
 128 }
 129
 130
 131 /***********************************************************************
 132  *           update_queue_key_state
 133  */
 134 static void update_queue_key_state( UINT msg, WPARAM wp )
 135 {
 136     BOOL down = FALSE;
 137
 138     switch (msg)
 139     {
 140     case WM_LBUTTONDOWN:
 141         down = TRUE;
 142         /* fall through */
 143     case WM_LBUTTONUP:
 144         wp = VK_LBUTTON;
 145         break;
 146     case WM_MBUTTONDOWN:
 147         down = TRUE;
 148         /* fall through */
 149     case WM_MBUTTONUP:
 150         wp = VK_MBUTTON;
 151         break;
 152     case WM_RBUTTONDOWN:
 153         down = TRUE;
 154         /* fall through */
 155     case WM_RBUTTONUP:
 156         wp = VK_RBUTTON;
 157         break;
 158     case WM_KEYDOWN:
 159     case WM_SYSKEYDOWN:
 160         down = TRUE;
 161         /* fall through */
 162     case WM_KEYUP:
 163     case WM_SYSKEYUP:
 164         wp = wp & 0xff;
 165         break;
 166     }
 167     if (down)
 168     {
 169         BYTE *p = &QueueKeyStateTable[wp];
 170         if (!(*p & 0x80)) *p ^= 0x01;
 171         *p |= 0x80;
 172     }
 173     else QueueKeyStateTable[wp] &= ~0x80;
 174 }
 175
 176
 177 /***********************************************************************
 178  *           MSG_SendParentNotify
 179  *
 180  * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
 181  * the window has the WS_EX_NOPARENTNOTIFY style.
 182  */
 183 static void MSG_SendParentNotify( HWND hwnd, WORD event, WORD idChild, POINT pt )
 184 {
 185     /* pt has to be in the client coordinates of the parent window */
 186     MapWindowPoints( 0, hwnd, &pt, 1 );
 187     for (;;)
 188     {
 189         HWND parent;
 190
 191         if (!(GetWindowLongA( hwnd, GWL_STYLE ) & WS_CHILD)) break;
 192         if (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY) break;
 193         if (!(parent = GetParent(hwnd))) break;
 194         MapWindowPoints( hwnd, parent, &pt, 1 );
 195         hwnd = parent;
 196         SendMessageA( hwnd, WM_PARENTNOTIFY,
 197                       MAKEWPARAM( event, idChild ), MAKELPARAM( pt.x, pt.y ) );
 198     }
 199 }
 200
 201
 202 /***********************************************************************
 203  *          MSG_JournalPlayBackMsg
 204  *
 205  * Get an EVENTMSG struct via call JOURNALPLAYBACK hook function
 206  */
 207 void MSG_JournalPlayBackMsg(void)
 208 {
 209     EVENTMSG tmpMsg;
 210     MSG msg;
 211     LRESULT wtime;
 212     int keyDown,i;
 213
 214     if (!HOOK_IsHooked( WH_JOURNALPLAYBACK )) return;
 215
 216     wtime=HOOK_CallHooksA( WH_JOURNALPLAYBACK, HC_GETNEXT, 0, (LPARAM)&tmpMsg );
 217     /*  TRACE(msg,"Playback wait time =%ld\n",wtime); */
 218     if (wtime<=0)
 219     {
 220         wtime=0;
 221         msg.message = tmpMsg.message;
 222         msg.hwnd    = tmpMsg.hwnd;
 223         msg.time    = tmpMsg.time;
 224         if ((tmpMsg.message >= WM_KEYFIRST) && (tmpMsg.message <= WM_KEYLAST))
 225         {
 226             msg.wParam  = tmpMsg.paramL & 0xFF;
 227             msg.lParam  = MAKELONG(tmpMsg.paramH&0x7ffff,tmpMsg.paramL>>8);
 228             if (tmpMsg.message == WM_KEYDOWN || tmpMsg.message == WM_SYSKEYDOWN)
 229             {
 230                 for (keyDown=i=0; i<256 && !keyDown; i++)
 231                     if (InputKeyStateTable[i] & 0x80)
 232                         keyDown++;
 233                 if (!keyDown)
 234                     msg.lParam |= 0x40000000;
 235                 InputKeyStateTable[msg.wParam] |= 0x80;
 236                 AsyncKeyStateTable[msg.wParam] |= 0x80;
 237             }
 238             else                                       /* WM_KEYUP, WM_SYSKEYUP */
 239             {
 240                 msg.lParam |= 0xC0000000;
 241                 InputKeyStateTable[msg.wParam] &= ~0x80;
 242             }
 243             if (InputKeyStateTable[VK_MENU] & 0x80)
 244                 msg.lParam |= 0x20000000;
 245             if (tmpMsg.paramH & 0x8000)              /*special_key bit*/
 246                 msg.lParam |= 0x01000000;
 247
 248             msg.pt.x = msg.pt.y = 0;
 249             queue_hardware_message( &msg, 0, MSG_HARDWARE_RAW );
 250         }
 251         else if ((tmpMsg.message>= WM_MOUSEFIRST) && (tmpMsg.message <= WM_MOUSELAST))
 252         {
 253             switch (tmpMsg.message)
 254             {
 255             case WM_LBUTTONDOWN:
 256                 InputKeyStateTable[VK_LBUTTON] |= 0x80;
 257                 AsyncKeyStateTable[VK_LBUTTON] |= 0x80;
 258                 break;
 259             case WM_LBUTTONUP:
 260                 InputKeyStateTable[VK_LBUTTON] &= ~0x80;
 261                 break;
 262             case WM_MBUTTONDOWN:
 263                 InputKeyStateTable[VK_MBUTTON] |= 0x80;
 264                 AsyncKeyStateTable[VK_MBUTTON] |= 0x80;
 265                 break;
 266             case WM_MBUTTONUP:
 267                 InputKeyStateTable[VK_MBUTTON] &= ~0x80;
 268                 break;
 269             case WM_RBUTTONDOWN:
 270                 InputKeyStateTable[VK_RBUTTON] |= 0x80;
 271                 AsyncKeyStateTable[VK_RBUTTON] |= 0x80;
 272                 break;
 273             case WM_RBUTTONUP:
 274                 InputKeyStateTable[VK_RBUTTON] &= ~0x80;
 275                 break;
 276             }
 277             SetCursorPos(tmpMsg.paramL,tmpMsg.paramH);
 278             msg.lParam=MAKELONG(tmpMsg.paramL,tmpMsg.paramH);
 279             msg.wParam=0;
 280             if (InputKeyStateTable[VK_LBUTTON] & 0x80) msg.wParam |= MK_LBUTTON;
 281             if (InputKeyStateTable[VK_MBUTTON] & 0x80) msg.wParam |= MK_MBUTTON;
 282             if (InputKeyStateTable[VK_RBUTTON] & 0x80) msg.wParam |= MK_RBUTTON;
 283
 284             msg.pt.x = tmpMsg.paramL;
 285             msg.pt.y = tmpMsg.paramH;
 286             queue_hardware_message( &msg, 0, MSG_HARDWARE_RAW );
 287         }
 288         HOOK_CallHooksA( WH_JOURNALPLAYBACK, HC_SKIP, 0, (LPARAM)&tmpMsg);
 289     }
 290     else
 291     {
 292         if( tmpMsg.message == WM_QUEUESYNC )
 293             if (HOOK_IsHooked( WH_CBT ))
 294                 HOOK_CallHooksA( WH_CBT, HCBT_QS, 0, 0L);
 295     }
 296 }
 297
 298
 299 /***********************************************************************
 300  *          process_raw_keyboard_message
 301  *
 302  * returns TRUE if the contents of 'msg' should be passed to the application
 303  */
 304 static BOOL process_raw_keyboard_message( MSG *msg, ULONG_PTR extra_info )
 305 {
 306     if (!(msg->hwnd = GetFocus()))
 307     {
 308         /* Send the message to the active window instead,  */
 309         /* translating messages to their WM_SYS equivalent */
 310         msg->hwnd = GetActiveWindow();
 311         if (msg->message < WM_SYSKEYDOWN) msg->message += WM_SYSKEYDOWN - WM_KEYDOWN;
 312     }
 313
 314     if (HOOK_IsHooked( WH_JOURNALRECORD ))
 315     {
 316         EVENTMSG event;
 317
 318         event.message = msg->message;
 319         event.hwnd    = msg->hwnd;
 320         event.time    = msg->time;
 321         event.paramL  = (msg->wParam & 0xFF) | (HIWORD(msg->lParam) << 8);
 322         event.paramH  = msg->lParam & 0x7FFF;
 323         if (HIWORD(msg->lParam) & 0x0100) event.paramH |= 0x8000; /* special_key - bit */
 324         HOOK_CallHooksA( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event );
 325     }
 326
 327     /* if we are going to throw away the message, update the queue state now */
 328     if (!msg->hwnd) update_queue_key_state( msg->message, msg->wParam );
 329
 330     return (msg->hwnd != 0);
 331 }
 332
 333
 334 /***********************************************************************
 335  *          process_cooked_keyboard_message
 336  *
 337  * returns TRUE if the contents of 'msg' should be passed to the application
 338  */
 339 static BOOL process_cooked_keyboard_message( MSG *msg, BOOL remove )
 340 {
 341     if (remove)
 342     {
 343         update_queue_key_state( msg->message, msg->wParam );
 344
 345         /* Handle F1 key by sending out WM_HELP message */
 346         if ((msg->message == WM_KEYUP) &&
 347             (msg->wParam == VK_F1) &&
 348             (msg->hwnd != GetDesktopWindow()) &&
 349             !MENU_IsMenuActive())
 350         {
 351             HELPINFO hi;
 352             hi.cbSize = sizeof(HELPINFO);
 353             hi.iContextType = HELPINFO_WINDOW;
 354             hi.iCtrlId = GetWindowLongA( msg->hwnd, GWL_ID );
 355             hi.hItemHandle = msg->hwnd;
 356             hi.dwContextId = GetWindowContextHelpId( msg->hwnd );
 357             hi.MousePos = msg->pt;
 358             SendMessageA(msg->hwnd, WM_HELP, 0, (LPARAM)&hi);
 359         }
 360     }
 361
 362     if (HOOK_CallHooksA( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
 363                          LOWORD(msg->wParam), msg->lParam ))
 364     {
 365         /* skip this message */
 366         HOOK_CallHooksA( WH_CBT, HCBT_KEYSKIPPED, LOWORD(msg->wParam), msg->lParam );
 367         return FALSE;
 368     }
 369     return TRUE;
 370 }
 371
 372
 373 /***********************************************************************
 374  *          process_raw_mouse_message
 375  *
 376  * returns TRUE if the contents of 'msg' should be passed to the application
 377  */
 378 static BOOL process_raw_mouse_message( MSG *msg, ULONG_PTR extra_info )
 379 {
 380     static MSG clk_msg;
 381
 382     POINT pt;
 383     INT ht, hittest;
 384
 385     /* find the window to dispatch this mouse message to */
 386
 387     hittest = HTCLIENT;
 388     if (!(msg->hwnd = PERQDATA_GetCaptureWnd( &ht )))
 389     {
 390         /* If no capture HWND, find window which contains the mouse position.
 391          * Also find the position of the cursor hot spot (hittest) */
 392         HWND hWndScope = (HWND)extra_info;
 393
 394         if (!IsWindow(hWndScope)) hWndScope = 0;
 395         if (!(msg->hwnd = WINPOS_WindowFromPoint( hWndScope, msg->pt, &hittest )))
 396             msg->hwnd = GetDesktopWindow();
 397         ht = hittest;
 398     }
 399
 400     if (HOOK_IsHooked( WH_JOURNALRECORD ))
 401     {
 402         EVENTMSG event;
 403         event.message = msg->message;
 404         event.time    = msg->time;
 405         event.hwnd    = msg->hwnd;
 406         event.paramL  = msg->pt.x;
 407         event.paramH  = msg->pt.y;
 408         HOOK_CallHooksA( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event );
 409     }
 410
 411     /* translate double clicks */
 412
 413     if ((msg->message == WM_LBUTTONDOWN) ||
 414         (msg->message == WM_RBUTTONDOWN) ||
 415         (msg->message == WM_MBUTTONDOWN))
 416     {
 417         BOOL update = TRUE;
 418         /* translate double clicks -
 419          * note that ...MOUSEMOVEs can slip in between
 420          * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
 421
 422         if (GetClassLongA( msg->hwnd, GCL_STYLE ) & CS_DBLCLKS || ht != HTCLIENT )
 423         {
 424            if ((msg->message == clk_msg.message) &&
 425                (msg->hwnd == clk_msg.hwnd) &&
 426                (msg->time - clk_msg.time < GetDoubleClickTime()) &&
 427                (abs(msg->pt.x - clk_msg.pt.x) < GetSystemMetrics(SM_CXDOUBLECLK)/2) &&
 428                (abs(msg->pt.y - clk_msg.pt.y) < GetSystemMetrics(SM_CYDOUBLECLK)/2))
 429            {
 430                msg->message += (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
 431                clk_msg.message = 0;
 432                update = FALSE;
 433            }
 434         }
 435         /* update static double click conditions */
 436         if (update) clk_msg = *msg;
 437     }
 438
 439     pt = msg->pt;
 440     /* Note: windows has no concept of a non-client wheel message */
 441     if (hittest != HTCLIENT && msg->message != WM_MOUSEWHEEL)
 442     {
 443         msg->message += WM_NCMOUSEMOVE - WM_MOUSEMOVE;
 444         msg->wParam = hittest;
 445     }
 446     else ScreenToClient( msg->hwnd, &pt );
 447     msg->lParam = MAKELONG( pt.x, pt.y );
 448     return TRUE;
 449 }
 450
 451
 452 /***********************************************************************
 453  *          process_cooked_mouse_message
 454  *
 455  * returns TRUE if the contents of 'msg' should be passed to the application
 456  */
 457 static BOOL process_cooked_mouse_message( MSG *msg, ULONG_PTR extra_info, BOOL remove )
 458 {
 459     INT hittest = HTCLIENT;
 460     UINT raw_message = msg->message;
 461     BOOL eatMsg;
 462
 463     if (msg->message >= WM_NCMOUSEFIRST && msg->message <= WM_NCMOUSELAST)
 464     {
 465         raw_message += WM_MOUSEFIRST - WM_NCMOUSEFIRST;
 466         hittest = msg->wParam;
 467     }
 468     if (raw_message == WM_LBUTTONDBLCLK ||
 469         raw_message == WM_RBUTTONDBLCLK ||
 470         raw_message == WM_MBUTTONDBLCLK)
 471     {
 472         raw_message += WM_LBUTTONDOWN - WM_LBUTTONDBLCLK;
 473     }
 474
 475     if (remove) update_queue_key_state( raw_message, 0 );
 476
 477     if (HOOK_IsHooked( WH_MOUSE ))
 478     {
 479         MOUSEHOOKSTRUCT hook;
 480         hook.pt           = msg->pt;
 481         hook.hwnd         = msg->hwnd;
 482         hook.wHitTestCode = hittest;
 483         hook.dwExtraInfo  = extra_info;
 484         if (HOOK_CallHooksA( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
 485                              msg->message, (LPARAM)&hook ))
 486         {
 487             hook.pt           = msg->pt;
 488             hook.hwnd         = msg->hwnd;
 489             hook.wHitTestCode = hittest;
 490             hook.dwExtraInfo  = extra_info;
 491             HOOK_CallHooksA( WH_CBT, HCBT_CLICKSKIPPED, msg->message, (LPARAM)&hook );
 492             return FALSE;
 493         }
 494     }
 495
 496     if ((hittest == HTERROR) || (hittest == HTNOWHERE))
 497     {
 498         SendMessageA( msg->hwnd, WM_SETCURSOR, msg->hwnd, MAKELONG( hittest, raw_message ));
 499         return FALSE;
 500     }
 501
 502     if (!remove || GetCapture()) return TRUE;
 503
 504     eatMsg = FALSE;
 505
 506     if ((raw_message == WM_LBUTTONDOWN) ||
 507         (raw_message == WM_RBUTTONDOWN) ||
 508         (raw_message == WM_MBUTTONDOWN))
 509     {
 510         HWND hwndTop = GetAncestor( msg->hwnd, GA_ROOT );
 511
 512         /* Send the WM_PARENTNOTIFY,
 513          * note that even for double/nonclient clicks
 514          * notification message is still WM_L/M/RBUTTONDOWN.
 515          */
 516         MSG_SendParentNotify( msg->hwnd, raw_message, 0, msg->pt );
 517
 518         /* Activate the window if needed */
 519
 520         if (msg->hwnd != GetActiveWindow() && hwndTop != GetDesktopWindow())
 521         {
 522             LONG ret = SendMessageA( msg->hwnd, WM_MOUSEACTIVATE, hwndTop,
 523                                      MAKELONG( hittest, raw_message ) );
 524
 525             switch(ret)
 526             {
 527             case MA_NOACTIVATEANDEAT:
 528                 eatMsg = TRUE;
 529                 /* fall through */
 530             case MA_NOACTIVATE:
 531                 break;
 532             case MA_ACTIVATEANDEAT:
 533                 eatMsg = TRUE;
 534                 /* fall through */
 535             case MA_ACTIVATE:
 536             case 0:
 537                 if (hwndTop != GetForegroundWindow() )
 538                 {
 539                     if (!WINPOS_SetActiveWindow( hwndTop, TRUE , TRUE ))
 540                         eatMsg = TRUE;
 541                 }
 542                 break;
 543             default:
 544                 WARN( "unknown WM_MOUSEACTIVATE code %ld\n", ret );
 545                 break;
 546             }
 547         }
 548     }
 549
 550     /* send the WM_SETCURSOR message */
 551
 552     /* Windows sends the normal mouse message as the message parameter
 553        in the WM_SETCURSOR message even if it's non-client mouse message */
 554     SendMessageA( msg->hwnd, WM_SETCURSOR, msg->hwnd, MAKELONG( hittest, raw_message ));
 555
 556     return !eatMsg;
 557 }
 558
 559
 560 /***********************************************************************
 561  *          process_hardware_message
 562  *
 563  * returns TRUE if the contents of 'msg' should be passed to the application
 564  */
 565 BOOL MSG_process_raw_hardware_message( MSG *msg, ULONG_PTR extra_info, HWND hwnd_filter,
 566                                        UINT first, UINT last, BOOL remove )
 567 {
 568     if (is_keyboard_message( msg->message ))
 569     {
 570         if (!process_raw_keyboard_message( msg, extra_info )) return FALSE;
 571     }
 572     else if (is_mouse_message( msg->message ))
 573     {
 574         if (!process_raw_mouse_message( msg, extra_info )) return FALSE;
 575     }
 576     else
 577     {
 578         ERR( "unknown message type %x\n", msg->message );
 579         return FALSE;
 580     }
 581
 582     /* check destination thread and filters */
 583     if (!check_message_filter( msg, hwnd_filter, first, last ) ||
 584         !WIN_IsCurrentThread( msg->hwnd ))
 585     {
 586         /* queue it for later, or for another thread */
 587         queue_hardware_message( msg, extra_info, MSG_HARDWARE_COOKED );
 588         return FALSE;
 589     }
 590
 591     /* save the message in the cooked queue if we didn't want to remove it */
 592     if (!remove) queue_hardware_message( msg, extra_info, MSG_HARDWARE_COOKED );
 593     return TRUE;
 594 }
 595
 596
 597 /***********************************************************************
 598  *          MSG_process_cooked_hardware_message
 599  *
 600  * returns TRUE if the contents of 'msg' should be passed to the application
 601  */
 602 BOOL MSG_process_cooked_hardware_message( MSG *msg, ULONG_PTR extra_info, BOOL remove )
 603 {
 604     if (is_keyboard_message( msg->message ))
 605         return process_cooked_keyboard_message( msg, remove );
 606
 607     if (is_mouse_message( msg->message ))
 608         return process_cooked_mouse_message( msg, extra_info, remove );
 609
 610     ERR( "unknown message type %x\n", msg->message );
 611     return FALSE;
 612 }
 613
 614
 615 /**********************************************************************
 616  *              GetKeyState (USER.106)
 617  */
 618 INT16 WINAPI GetKeyState16(INT16 vkey)
 619 {
 620     return GetKeyState(vkey);
 621 }
 622
 623
 624 /**********************************************************************
 625  *              GetKeyState (USER32.@)
 626  *
 627  * An application calls the GetKeyState function in response to a
 628  * keyboard-input message.  This function retrieves the state of the key
 629  * at the time the input message was generated.  (SDK 3.1 Vol 2. p 390)
 630  */
 631 SHORT WINAPI GetKeyState(INT vkey)
 632 {
 633     INT retval;
 634
 635     if (vkey >= 'a' && vkey <= 'z') vkey += 'A' - 'a';
 636     retval = ((WORD)(QueueKeyStateTable[vkey] & 0x80) << 8 ) | (QueueKeyStateTable[vkey] & 0x01);
 637     /* TRACE(key, "(0x%x) -> %x\n", vkey, retval); */
 638     return retval;
 639 }
 640
 641
 642 /**********************************************************************
 643  *              GetKeyboardState (USER.222)
 644  *              GetKeyboardState (USER32.@)
 645  *
 646  * An application calls the GetKeyboardState function in response to a
 647  * keyboard-input message.  This function retrieves the state of the keyboard
 648  * at the time the input message was generated.  (SDK 3.1 Vol 2. p 387)
 649  */
 650 BOOL WINAPI GetKeyboardState(LPBYTE lpKeyState)
 651 {
 652     TRACE_(key)("(%p)\n", lpKeyState);
 653     if (lpKeyState) memcpy(lpKeyState, QueueKeyStateTable, 256);
 654     return TRUE;
 655 }
 656
 657
 658 /**********************************************************************
 659  *              SetKeyboardState (USER.223)
 660  *              SetKeyboardState (USER32.@)
 661  */
 662 BOOL WINAPI SetKeyboardState(LPBYTE lpKeyState)
 663 {
 664     TRACE_(key)("(%p)\n", lpKeyState);
 665     if (lpKeyState) memcpy(QueueKeyStateTable, lpKeyState, 256);
 666     return TRUE;
 667 }
 668
 669
 670 /***********************************************************************
 671  *              WaitMessage (USER.112) Suspend thread pending messages
 672  *              WaitMessage (USER32.@) Suspend thread pending messages
 673  *
 674  * WaitMessage() suspends a thread until events appear in the thread's
 675  * queue.
 676  */
 677 BOOL WINAPI WaitMessage(void)
 678 {
 679     return (MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, QS_ALLINPUT, 0 ) != WAIT_FAILED);
 680 }
 681
 682
 683 /***********************************************************************
 684  *              MsgWaitForMultipleObjectsEx   (USER32.@)
 685  */
 686 DWORD WINAPI MsgWaitForMultipleObjectsEx( DWORD count, CONST HANDLE *pHandles,
 687                                           DWORD timeout, DWORD mask, DWORD flags )
 688 {
 689     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
 690     DWORD i, ret;
 691     MESSAGEQUEUE *msgQueue;
 692
 693     if (count > MAXIMUM_WAIT_OBJECTS-1)
 694     {
 695         SetLastError( ERROR_INVALID_PARAMETER );
 696         return WAIT_FAILED;
 697     }
 698
 699     if (!(msgQueue = QUEUE_Current())) return WAIT_FAILED;
 700
 701     /* set the queue mask */
 702     SERVER_START_REQ( set_queue_mask )
 703     {
 704         req->wake_mask    = (flags & MWMO_INPUTAVAILABLE) ? mask : 0;
 705         req->changed_mask = mask;
 706         req->skip_wait    = 0;
 707         wine_server_call( req );
 708     }
 709     SERVER_END_REQ;
 710
 711     /* Add the thread event to the handle list */
 712     for (i = 0; i < count; i++) handles[i] = pHandles[i];
 713     handles[count] = msgQueue->server_queue;
 714
 715
 716     if (USER_Driver.pMsgWaitForMultipleObjectsEx)
 717     {
 718         ret = USER_Driver.pMsgWaitForMultipleObjectsEx( count+1, handles, timeout, mask, flags );
 719         if (ret == count+1) ret = count; /* pretend the msg queue is ready */
 720     }
 721     else
 722         ret = WaitForMultipleObjectsEx( count+1, handles, flags & MWMO_WAITALL,
 723                                         timeout, flags & MWMO_ALERTABLE );
 724     return ret;
 725 }
 726
 727
 728 /***********************************************************************
 729  *              MsgWaitForMultipleObjects (USER32.@)
 730  */
 731 DWORD WINAPI MsgWaitForMultipleObjects( DWORD count, CONST HANDLE *handles,
 732                                         BOOL wait_all, DWORD timeout, DWORD mask )
 733 {
 734     return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
 735                                         wait_all ? MWMO_WAITALL : 0 );
 736 }
 737
 738
 739 /***********************************************************************
 740  *              WaitForInputIdle (USER32.@)
 741  */
 742 DWORD WINAPI WaitForInputIdle( HANDLE hProcess, DWORD dwTimeOut )
 743 {
 744     DWORD start_time, elapsed, ret;
 745     HANDLE idle_event = -1;
 746
 747     SERVER_START_REQ( wait_input_idle )
 748     {
 749         req->handle = hProcess;
 750         req->timeout = dwTimeOut;
 751         if (!(ret = wine_server_call_err( req ))) idle_event = reply->event;
 752     }
 753     SERVER_END_REQ;
 754     if (ret) return WAIT_FAILED;  /* error */
 755     if (!idle_event) return 0;  /* no event to wait on */
 756
 757     start_time = GetTickCount();
 758     elapsed = 0;
 759
 760     TRACE("waiting for %x\n", idle_event );
 761     do
 762     {
 763         ret = MsgWaitForMultipleObjects ( 1, &idle_event, FALSE, dwTimeOut - elapsed, QS_SENDMESSAGE );
 764         switch (ret)
 765         {
 766         case WAIT_OBJECT_0+1:
 767             process_sent_messages();
 768             break;
 769         case WAIT_TIMEOUT:
 770         case WAIT_FAILED:
 771             TRACE("timeout or error\n");
 772             return ret;
 773         default:
 774             TRACE("finished\n");
 775             return 0;
 776         }
 777         if (dwTimeOut != INFINITE)
 778         {
 779             elapsed = GetTickCount() - start_time;
 780             if (elapsed > dwTimeOut)
 781                 break;
 782         }
 783     }
 784     while (1);
 785
 786     return WAIT_TIMEOUT;
 787 }
 788
 789
 790 /***********************************************************************
 791  *              UserYield (USER.332)
 792  *              UserYield16 (USER32.@)
 793  */
 794 void WINAPI UserYield16(void)
 795 {
 796    DWORD count;
 797
 798     /* Handle sent messages */
 799     process_sent_messages();
 800
 801     /* Yield */
 802     ReleaseThunkLock(&count);
 803     if (count)
 804     {
 805         RestoreThunkLock(count);
 806         /* Handle sent messages again */
 807         process_sent_messages();
 808     }
 809 }
 810
 811
 812 struct accent_char
 813 {
 814     BYTE ac_accent;
 815     BYTE ac_char;
 816     BYTE ac_result;
 817 };
 818
 819 static const struct accent_char accent_chars[] =
 820 {
 821 /* A good idea should be to read /usr/X11/lib/X11/locale/iso8859-x/Compose */
 822     {'`', 'A', '\300'},  {'`', 'a', '\340'},
 823     {'\'', 'A', '\301'}, {'\'', 'a', '\341'},
 824     {'^', 'A', '\302'},  {'^', 'a', '\342'},
 825     {'~', 'A', '\303'},  {'~', 'a', '\343'},
 826     {'"', 'A', '\304'},  {'"', 'a', '\344'},
 827     {'O', 'A', '\305'},  {'o', 'a', '\345'},
 828     {'0', 'A', '\305'},  {'0', 'a', '\345'},
 829     {'A', 'A', '\305'},  {'a', 'a', '\345'},
 830     {'A', 'E', '\306'},  {'a', 'e', '\346'},
 831     {',', 'C', '\307'},  {',', 'c', '\347'},
 832     {'`', 'E', '\310'},  {'`', 'e', '\350'},
 833     {'\'', 'E', '\311'}, {'\'', 'e', '\351'},
 834     {'^', 'E', '\312'},  {'^', 'e', '\352'},
 835     {'"', 'E', '\313'},  {'"', 'e', '\353'},
 836     {'`', 'I', '\314'},  {'`', 'i', '\354'},
 837     {'\'', 'I', '\315'}, {'\'', 'i', '\355'},
 838     {'^', 'I', '\316'},  {'^', 'i', '\356'},
 839     {'"', 'I', '\317'},  {'"', 'i', '\357'},
 840     {'-', 'D', '\320'},  {'-', 'd', '\360'},
 841     {'~', 'N', '\321'},  {'~', 'n', '\361'},
 842     {'`', 'O', '\322'},  {'`', 'o', '\362'},
 843     {'\'', 'O', '\323'}, {'\'', 'o', '\363'},
 844     {'^', 'O', '\324'},  {'^', 'o', '\364'},
 845     {'~', 'O', '\325'},  {'~', 'o', '\365'},
 846     {'"', 'O', '\326'},  {'"', 'o', '\366'},
 847     {'/', 'O', '\330'},  {'/', 'o', '\370'},
 848     {'`', 'U', '\331'},  {'`', 'u', '\371'},
 849     {'\'', 'U', '\332'}, {'\'', 'u', '\372'},
 850     {'^', 'U', '\333'},  {'^', 'u', '\373'},
 851     {'"', 'U', '\334'},  {'"', 'u', '\374'},
 852     {'\'', 'Y', '\335'}, {'\'', 'y', '\375'},
 853     {'T', 'H', '\336'},  {'t', 'h', '\376'},
 854     {'s', 's', '\337'},  {'"', 'y', '\377'},
 855     {'s', 'z', '\337'},  {'i', 'j', '\377'},
 856         /* iso-8859-2 uses this */
 857     {'<', 'L', '\245'},  {'<', 'l', '\265'},    /* caron */
 858     {'<', 'S', '\251'},  {'<', 's', '\271'},
 859     {'<', 'T', '\253'},  {'<', 't', '\273'},
 860     {'<', 'Z', '\256'},  {'<', 'z', '\276'},
 861     {'<', 'C', '\310'},  {'<', 'c', '\350'},
 862     {'<', 'E', '\314'},  {'<', 'e', '\354'},
 863     {'<', 'D', '\317'},  {'<', 'd', '\357'},
 864     {'<', 'N', '\322'},  {'<', 'n', '\362'},
 865     {'<', 'R', '\330'},  {'<', 'r', '\370'},
 866     {';', 'A', '\241'},  {';', 'a', '\261'},    /* ogonek */
 867     {';', 'E', '\312'},  {';', 'e', '\332'},
 868     {'\'', 'Z', '\254'}, {'\'', 'z', '\274'},   /* acute */
 869     {'\'', 'R', '\300'}, {'\'', 'r', '\340'},
 870     {'\'', 'L', '\305'}, {'\'', 'l', '\345'},
 871     {'\'', 'C', '\306'}, {'\'', 'c', '\346'},
 872     {'\'', 'N', '\321'}, {'\'', 'n', '\361'},
 873 /*  collision whith S, from iso-8859-9 !!! */
 874     {',', 'S', '\252'},  {',', 's', '\272'},    /* cedilla */
 875     {',', 'T', '\336'},  {',', 't', '\376'},
 876     {'.', 'Z', '\257'},  {'.', 'z', '\277'},    /* dot above */
 877     {'/', 'L', '\243'},  {'/', 'l', '\263'},    /* slash */
 878     {'/', 'D', '\320'},  {'/', 'd', '\360'},
 879     {'(', 'A', '\303'},  {'(', 'a', '\343'},    /* breve */
 880     {'\275', 'O', '\325'}, {'\275', 'o', '\365'},       /* double acute */
 881     {'\275', 'U', '\334'}, {'\275', 'u', '\374'},
 882     {'0', 'U', '\332'},  {'0', 'u', '\372'},    /* ring above */
 883         /* iso-8859-3 uses this */
 884     {'/', 'H', '\241'},  {'/', 'h', '\261'},    /* slash */
 885     {'>', 'H', '\246'},  {'>', 'h', '\266'},    /* circumflex */
 886     {'>', 'J', '\254'},  {'>', 'j', '\274'},
 887     {'>', 'C', '\306'},  {'>', 'c', '\346'},
 888     {'>', 'G', '\330'},  {'>', 'g', '\370'},
 889     {'>', 'S', '\336'},  {'>', 's', '\376'},
 890 /*  collision whith G( from iso-8859-9 !!!   */
 891     {'(', 'G', '\253'},  {'(', 'g', '\273'},    /* breve */
 892     {'(', 'U', '\335'},  {'(', 'u', '\375'},
 893 /*  collision whith I. from iso-8859-3 !!!   */
 894     {'.', 'I', '\251'},  {'.', 'i', '\271'},    /* dot above */
 895     {'.', 'C', '\305'},  {'.', 'c', '\345'},
 896     {'.', 'G', '\325'},  {'.', 'g', '\365'},
 897         /* iso-8859-4 uses this */
 898     {',', 'R', '\243'},  {',', 'r', '\263'},    /* cedilla */
 899     {',', 'L', '\246'},  {',', 'l', '\266'},
 900     {',', 'G', '\253'},  {',', 'g', '\273'},
 901     {',', 'N', '\321'},  {',', 'n', '\361'},
 902     {',', 'K', '\323'},  {',', 'k', '\363'},
 903     {'~', 'I', '\245'},  {'~', 'i', '\265'},    /* tilde */
 904     {'-', 'E', '\252'},  {'-', 'e', '\272'},    /* macron */
 905     {'-', 'A', '\300'},  {'-', 'a', '\340'},
 906     {'-', 'I', '\317'},  {'-', 'i', '\357'},
 907     {'-', 'O', '\322'},  {'-', 'o', '\362'},
 908     {'-', 'U', '\336'},  {'-', 'u', '\376'},
 909     {'/', 'T', '\254'},  {'/', 't', '\274'},    /* slash */
 910     {'.', 'E', '\314'},  {'.', 'e', '\344'},    /* dot above */
 911     {';', 'I', '\307'},  {';', 'i', '\347'},    /* ogonek */
 912     {';', 'U', '\331'},  {';', 'u', '\371'},
 913         /* iso-8859-9 uses this */
 914         /* iso-8859-9 has really bad choosen G( S, and I. as they collide
 915          * whith the same letters on other iso-8859-x (that is they are on
 916          * different places :-( ), if you use turkish uncomment these and
 917          * comment out the lines in iso-8859-2 and iso-8859-3 sections
 918          * FIXME: should be dynamic according to chosen language
 919          *        if/when Wine has turkish support.
 920          */
 921 /*  collision whith G( from iso-8859-3 !!!   */
 922 /*  {'(', 'G', '\320'},  {'(', 'g', '\360'}, */ /* breve */
 923 /*  collision whith S, from iso-8859-2 !!! */
 924 /*  {',', 'S', '\336'},  {',', 's', '\376'}, */ /* cedilla */
 925 /*  collision whith I. from iso-8859-3 !!!   */
 926 /*  {'.', 'I', '\335'},  {'.', 'i', '\375'}, */ /* dot above */
 927 };
 928
 929
 930 /***********************************************************************
 931  *              TranslateMessage (USER32.@)
 932  *
 933  * Implementation of TranslateMessage.
 934  *
 935  * TranslateMessage translates virtual-key messages into character-messages,
 936  * as follows :
 937  * WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or WM_DEADCHAR message.
 938  * ditto replacing WM_* with WM_SYS*
 939  * This produces WM_CHAR messages only for keys mapped to ASCII characters
 940  * by the keyboard driver.
 941  */
 942 BOOL WINAPI TranslateMessage( const MSG *msg )
 943 {
 944     static int dead_char;
 945     UINT message;
 946     WCHAR wp[2];
 947
 948     if (msg->message >= WM_KEYFIRST && msg->message <= WM_KEYLAST)
 949         TRACE_(key)("(%s, %04X, %08lX)\n",
 950                     SPY_GetMsgName(msg->message, msg->hwnd), msg->wParam, msg->lParam );
 951
 952     if ((msg->message != WM_KEYDOWN) && (msg->message != WM_SYSKEYDOWN)) return FALSE;
 953
 954     TRACE_(key)("Translating key %s (%04x), scancode %02x\n",
 955                  SPY_GetVKeyName(msg->wParam), msg->wParam, LOBYTE(HIWORD(msg->lParam)));
 956
 957     /* FIXME : should handle ToUnicode yielding 2 */
 958     switch (ToUnicode(msg->wParam, HIWORD(msg->lParam), QueueKeyStateTable, wp, 2, 0))
 959     {
 960     case 1:
 961         message = (msg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
 962         /* Should dead chars handling go in ToAscii ? */
 963         if (dead_char)
 964         {
 965             int i;
 966
 967             if (wp[0] == ' ') wp[0] =  dead_char;
 968             if (dead_char == 0xa2) dead_char = '(';
 969             else if (dead_char == 0xa8) dead_char = '"';
 970             else if (dead_char == 0xb2) dead_char = ';';
 971             else if (dead_char == 0xb4) dead_char = '\'';
 972             else if (dead_char == 0xb7) dead_char = '<';
 973             else if (dead_char == 0xb8) dead_char = ',';
 974             else if (dead_char == 0xff) dead_char = '.';
 975             for (i = 0; i < sizeof(accent_chars)/sizeof(accent_chars[0]); i++)
 976                 if ((accent_chars[i].ac_accent == dead_char) &&
 977                     (accent_chars[i].ac_char == wp[0]))
 978                 {
 979                     wp[0] = accent_chars[i].ac_result;
 980                     break;
 981                 }
 982             dead_char = 0;
 983         }
 984         TRACE_(key)("1 -> PostMessage(%s)\n", SPY_GetMsgName(message, msg->hwnd));
 985         PostMessageW( msg->hwnd, message, wp[0], msg->lParam );
 986         return TRUE;
 987
 988     case -1:
 989         message = (msg->message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
 990         dead_char = wp[0];
 991         TRACE_(key)("-1 -> PostMessage(%s)\n", SPY_GetMsgName(message, msg->hwnd));
 992         PostMessageW( msg->hwnd, message, wp[0], msg->lParam );
 993         return TRUE;
 994     }
 995     return FALSE;
 996 }
 997
 998
 999 /***********************************************************************
1000  *              DispatchMessageA (USER32.@)
1001  */
1002 LONG WINAPI DispatchMessageA( const MSG* msg )
1003 {
1004     WND * wndPtr;
1005     LONG retval;
1006     int painting;
1007     WNDPROC winproc;
1008
1009       /* Process timer messages */
1010     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
1011     {
1012         if (msg->lParam)
1013         {
1014 /*            HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1015
1016             /* before calling window proc, verify whether timer is still valid;
1017                there's a slim chance that the application kills the timer
1018                between GetMessage and DispatchMessage API calls */
1019             if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (HWINDOWPROC) msg->lParam))
1020                 return 0; /* invalid winproc */
1021
1022             return CallWindowProcA( (WNDPROC)msg->lParam, msg->hwnd,
1023                                    msg->message, msg->wParam, GetTickCount() );
1024         }
1025     }
1026
1027     if (!(wndPtr = WIN_GetPtr( msg->hwnd )))
1028     {
1029         if (msg->hwnd) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1030         return 0;
1031     }
1032     if (wndPtr == WND_OTHER_PROCESS)
1033     {
1034         if (IsWindow( msg->hwnd ))
1035             ERR( "cannot dispatch msg to other process window %x\n", msg->hwnd );
1036         SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1037         return 0;
1038     }
1039     if (!(winproc = wndPtr->winproc))
1040     {
1041         WIN_ReleasePtr( wndPtr );
1042         return 0;
1043     }
1044     painting = (msg->message == WM_PAINT);
1045     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
1046     WIN_ReleasePtr( wndPtr );
1047 /*    hook_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1048
1049     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
1050                       msg->wParam, msg->lParam );
1051     retval = CallWindowProcA( winproc, msg->hwnd, msg->message,
1052                               msg->wParam, msg->lParam );
1053     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
1054                      msg->wParam, msg->lParam );
1055
1056     if (painting && (wndPtr = WIN_GetPtr( msg->hwnd )) && (wndPtr != WND_OTHER_PROCESS))
1057     {
1058         BOOL validate = ((wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate);
1059         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
1060         WIN_ReleasePtr( wndPtr );
1061         if (validate)
1062         {
1063             ERR( "BeginPaint not called on WM_PAINT for hwnd %04x!\n", msg->hwnd );
1064             /* Validate the update region to avoid infinite WM_PAINT loop */
1065             RedrawWindow( msg->hwnd, NULL, 0,
1066                           RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
1067         }
1068     }
1069     return retval;
1070 }
1071
1072
1073 /***********************************************************************
1074  *              DispatchMessageW (USER32.@) Process Message
1075  *
1076  * Process the message specified in the structure *_msg_.
1077  *
1078  * If the lpMsg parameter points to a WM_TIMER message and the
1079  * parameter of the WM_TIMER message is not NULL, the lParam parameter
1080  * points to the function that is called instead of the window
1081  * procedure.
1082  *
1083  * The message must be valid.
1084  *
1085  * RETURNS
1086  *
1087  *   DispatchMessage() returns the result of the window procedure invoked.
1088  *
1089  * CONFORMANCE
1090  *
1091  *   ECMA-234, Win32
1092  *
1093  */
1094 LONG WINAPI DispatchMessageW( const MSG* msg )
1095 {
1096     WND * wndPtr;
1097     LONG retval;
1098     int painting;
1099     WNDPROC winproc;
1100
1101       /* Process timer messages */
1102     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
1103     {
1104         if (msg->lParam)
1105         {
1106 /*            HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1107
1108             /* before calling window proc, verify whether timer is still valid;
1109                there's a slim chance that the application kills the timer
1110                between GetMessage and DispatchMessage API calls */
1111             if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (HWINDOWPROC) msg->lParam))
1112                 return 0; /* invalid winproc */
1113
1114             return CallWindowProcW( (WNDPROC)msg->lParam, msg->hwnd,
1115                                    msg->message, msg->wParam, GetTickCount() );
1116         }
1117     }
1118
1119     if (!(wndPtr = WIN_GetPtr( msg->hwnd )))
1120     {
1121         if (msg->hwnd) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1122         return 0;
1123     }
1124     if (wndPtr == WND_OTHER_PROCESS)
1125     {
1126         if (IsWindow( msg->hwnd ))
1127             ERR( "cannot dispatch msg to other process window %x\n", msg->hwnd );
1128         SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1129         return 0;
1130     }
1131     if (!(winproc = wndPtr->winproc))
1132     {
1133         WIN_ReleasePtr( wndPtr );
1134         return 0;
1135     }
1136     painting = (msg->message == WM_PAINT);
1137     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
1138     WIN_ReleasePtr( wndPtr );
1139 /*    HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1140
1141     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
1142                       msg->wParam, msg->lParam );
1143     retval = CallWindowProcW( winproc, msg->hwnd, msg->message,
1144                               msg->wParam, msg->lParam );
1145     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
1146                      msg->wParam, msg->lParam );
1147
1148     if (painting && (wndPtr = WIN_GetPtr( msg->hwnd )) && (wndPtr != WND_OTHER_PROCESS))
1149     {
1150         BOOL validate = ((wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate);
1151         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
1152         WIN_ReleasePtr( wndPtr );
1153         if (validate)
1154         {
1155             ERR( "BeginPaint not called on WM_PAINT for hwnd %04x!\n", msg->hwnd );
1156             /* Validate the update region to avoid infinite WM_PAINT loop */
1157             RedrawWindow( msg->hwnd, NULL, 0,
1158                           RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
1159         }
1160     }
1161     return retval;
1162 }
1163
1164
1165 /***********************************************************************
1166  *              RegisterWindowMessage (USER.118)
1167  *              RegisterWindowMessageA (USER32.@)
1168  */
1169 WORD WINAPI RegisterWindowMessageA( LPCSTR str )
1170 {
1171     TRACE("%s\n", str );
1172     return GlobalAddAtomA( str );
1173 }
1174
1175
1176 /***********************************************************************
1177  *              RegisterWindowMessageW (USER32.@)
1178  */
1179 WORD WINAPI RegisterWindowMessageW( LPCWSTR str )
1180 {
1181     TRACE("%p\n", str );
1182     return GlobalAddAtomW( str );
1183 }
1184
1185
1186 /***********************************************************************
1187  *              BroadcastSystemMessage (USER32.@)
1188  */
1189 LONG WINAPI BroadcastSystemMessage(
1190         DWORD dwFlags,LPDWORD recipients,UINT uMessage,WPARAM wParam,
1191         LPARAM lParam
1192 ) {
1193         FIXME("(%08lx,%08lx,%08x,%08x,%08lx): stub!\n",
1194               dwFlags,*recipients,uMessage,wParam,lParam
1195         );
1196         return 0;
1197 }