dlls/user/msg16.c

   1 /*
   2  * 16-bit messaging support
   3  *
   4  * Copyright 2001 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 "wine/winuser16.h"
  22 #include "wownt32.h"
  23 #include "winerror.h"
  24 #include "message.h"
  25 #include "thread.h"
  26 #include "win.h"
  27 #include "winproc.h"
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(msg);
  31
  32 DWORD USER16_AlertableWait = 0;
  33
  34 /***********************************************************************
  35  *              SendMessage  (USER.111)
  36  */
  37 LRESULT WINAPI SendMessage16( HWND16 hwnd16, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
  38 {
  39     LRESULT result;
  40     UINT msg32;
  41     WPARAM wparam32;
  42     HWND hwnd = WIN_Handle32( hwnd16 );
  43
  44     if (hwnd != HWND_BROADCAST && WIN_IsCurrentThread(hwnd))
  45     {
  46         /* call 16-bit window proc directly */
  47         WNDPROC16 winproc;
  48
  49         /* first the WH_CALLWNDPROC hook */
  50         if (HOOK_IsHooked( WH_CALLWNDPROC ))
  51         {
  52             LPARAM lparam32 = lparam;
  53
  54             if (WINPROC_MapMsg16To32A( hwnd, msg, wparam, &msg32, &wparam32, &lparam32 ) != -1)
  55             {
  56                 CWPSTRUCT cwp;
  57
  58                 cwp.hwnd    = hwnd;
  59                 cwp.message = msg32;
  60                 cwp.wParam  = wparam32;
  61                 cwp.lParam  = lparam32;
  62                 HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp, FALSE );
  63                 WINPROC_UnmapMsg16To32A( hwnd, msg32, wparam32, lparam32, 0 );
  64                 /* FIXME: should reflect changes back into the message we send */
  65             }
  66         }
  67
  68         if (!(winproc = (WNDPROC16)GetWindowLong16( hwnd16, GWL_WNDPROC ))) return 0;
  69
  70         SPY_EnterMessage( SPY_SENDMESSAGE16, hwnd, msg, wparam, lparam );
  71         result = CallWindowProc16( (WNDPROC16)winproc, hwnd16, msg, wparam, lparam );
  72         SPY_ExitMessage( SPY_RESULT_OK16, hwnd, msg, result, wparam, lparam );
  73     }
  74     else  /* map to 32-bit unicode for inter-thread/process message */
  75     {
  76         if (WINPROC_MapMsg16To32W( hwnd, msg, wparam, &msg32, &wparam32, &lparam ) == -1)
  77             return 0;
  78         result = WINPROC_UnmapMsg16To32W( hwnd, msg32, wparam32, lparam,
  79                                           SendMessageW( hwnd, msg32, wparam32, lparam ) );
  80     }
  81     return result;
  82 }
  83
  84
  85 /***********************************************************************
  86  *              PostMessage  (USER.110)
  87  */
  88 BOOL16 WINAPI PostMessage16( HWND16 hwnd16, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
  89 {
  90     WPARAM wparam32;
  91     UINT msg32;
  92     HWND hwnd = WIN_Handle32( hwnd16 );
  93
  94     switch (WINPROC_MapMsg16To32W( hwnd, msg, wparam, &msg32, &wparam32, &lparam ))
  95     {
  96     case 0:
  97         return PostMessageW( hwnd, msg32, wparam32, lparam );
  98     case 1:
  99         ERR( "16-bit message 0x%04x contains pointer, cannot post\n", msg );
 100         return FALSE;
 101     default:
 102         return FALSE;
 103     }
 104 }
 105
 106
 107 /***********************************************************************
 108  *              PostAppMessage (USER.116)
 109  */
 110 BOOL16 WINAPI PostAppMessage16( HTASK16 hTask, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
 111 {
 112     WPARAM wparam32;
 113     UINT msg32;
 114     DWORD tid = HTASK_32( hTask );
 115     if (!tid) return FALSE;
 116
 117     switch (WINPROC_MapMsg16To32W( 0, msg, wparam, &msg32, &wparam32, &lparam ))
 118     {
 119     case 0:
 120         return PostThreadMessageW( tid, msg32, wparam32, lparam );
 121     case 1:
 122         ERR( "16-bit message %x contains pointer, cannot post\n", msg );
 123         return FALSE;
 124     default:
 125         return FALSE;
 126     }
 127 }
 128
 129
 130 /***********************************************************************
 131  *              InSendMessage  (USER.192)
 132  */
 133 BOOL16 WINAPI InSendMessage16(void)
 134 {
 135     return InSendMessage();
 136 }
 137
 138
 139 /***********************************************************************
 140  *              ReplyMessage  (USER.115)
 141  */
 142 void WINAPI ReplyMessage16( LRESULT result )
 143 {
 144     ReplyMessage( result );
 145 }
 146
 147
 148 /***********************************************************************
 149  *              PeekMessage32 (USER.819)
 150  */
 151 BOOL16 WINAPI PeekMessage32_16( MSG32_16 *msg16, HWND16 hwnd16,
 152                                 UINT16 first, UINT16 last, UINT16 flags,
 153                                 BOOL16 wHaveParamHigh )
 154 {
 155     MSG msg;
 156     HWND hwnd = WIN_Handle32( hwnd16 );
 157
 158     if(USER16_AlertableWait)
 159         MsgWaitForMultipleObjectsEx( 0, NULL, 1, 0, MWMO_ALERTABLE );
 160     if (!PeekMessageW( &msg, hwnd, first, last, flags )) return FALSE;
 161
 162     msg16->msg.hwnd    = HWND_16( msg.hwnd );
 163     msg16->msg.lParam  = msg.lParam;
 164     msg16->msg.time    = msg.time;
 165     msg16->msg.pt.x    = (INT16)msg.pt.x;
 166     msg16->msg.pt.y    = (INT16)msg.pt.y;
 167     if (wHaveParamHigh) msg16->wParamHigh = HIWORD(msg.wParam);
 168
 169     return (WINPROC_MapMsg32WTo16( msg.hwnd, msg.message, msg.wParam,
 170                                    &msg16->msg.message, &msg16->msg.wParam,
 171                                    &msg16->msg.lParam ) != -1);
 172 }
 173
 174
 175 /***********************************************************************
 176  *              PeekMessage  (USER.109)
 177  */
 178 BOOL16 WINAPI PeekMessage16( MSG16 *msg, HWND16 hwnd,
 179                              UINT16 first, UINT16 last, UINT16 flags )
 180 {
 181     return PeekMessage32_16( (MSG32_16 *)msg, hwnd, first, last, flags, FALSE );
 182 }
 183
 184
 185 /***********************************************************************
 186  *              GetMessage32  (USER.820)
 187  */
 188 BOOL16 WINAPI GetMessage32_16( MSG32_16 *msg16, HWND16 hwnd16, UINT16 first,
 189                                UINT16 last, BOOL16 wHaveParamHigh )
 190 {
 191     MSG msg;
 192     HWND hwnd = WIN_Handle32( hwnd16 );
 193
 194     do
 195     {
 196         if(USER16_AlertableWait)
 197             MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, 0, MWMO_ALERTABLE );
 198         GetMessageW( &msg, hwnd, first, last );
 199         msg16->msg.hwnd    = HWND_16( msg.hwnd );
 200         msg16->msg.lParam  = msg.lParam;
 201         msg16->msg.time    = msg.time;
 202         msg16->msg.pt.x    = (INT16)msg.pt.x;
 203         msg16->msg.pt.y    = (INT16)msg.pt.y;
 204         if (wHaveParamHigh) msg16->wParamHigh = HIWORD(msg.wParam);
 205     }
 206     while (WINPROC_MapMsg32WTo16( msg.hwnd, msg.message, msg.wParam,
 207                                   &msg16->msg.message, &msg16->msg.wParam,
 208                                   &msg16->msg.lParam ) == -1);
 209
 210     TRACE( "message %04x, hwnd %p, filter(%04x - %04x)\n",
 211            msg16->msg.message, hwnd, first, last );
 212
 213     return msg16->msg.message != WM_QUIT;
 214 }
 215
 216
 217 /***********************************************************************
 218  *              GetMessage  (USER.108)
 219  */
 220 BOOL16 WINAPI GetMessage16( MSG16 *msg, HWND16 hwnd, UINT16 first, UINT16 last )
 221 {
 222     return GetMessage32_16( (MSG32_16 *)msg, hwnd, first, last, FALSE );
 223 }
 224
 225
 226 /***********************************************************************
 227  *              TranslateMessage32 (USER.821)
 228  */
 229 BOOL16 WINAPI TranslateMessage32_16( const MSG32_16 *msg, BOOL16 wHaveParamHigh )
 230 {
 231     MSG msg32;
 232
 233     msg32.hwnd    = WIN_Handle32( msg->msg.hwnd );
 234     msg32.message = msg->msg.message;
 235     msg32.wParam  = MAKEWPARAM( msg->msg.wParam, wHaveParamHigh ? msg->wParamHigh : 0 );
 236     msg32.lParam  = msg->msg.lParam;
 237     return TranslateMessage( &msg32 );
 238 }
 239
 240
 241 /***********************************************************************
 242  *              TranslateMessage (USER.113)
 243  */
 244 BOOL16 WINAPI TranslateMessage16( const MSG16 *msg )
 245 {
 246     return TranslateMessage32_16( (MSG32_16 *)msg, FALSE );
 247 }
 248
 249
 250 /***********************************************************************
 251  *              DispatchMessage (USER.114)
 252  */
 253 LONG WINAPI DispatchMessage16( const MSG16* msg )
 254 {
 255     WND * wndPtr;
 256     WNDPROC16 winproc;
 257     LONG retval;
 258     int painting;
 259     HWND hwnd = WIN_Handle32( msg->hwnd );
 260
 261       /* Process timer messages */
 262     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
 263     {
 264         if (msg->lParam)
 265         {
 266             /* before calling window proc, verify whether timer is still valid;
 267                there's a slim chance that the application kills the timer
 268                between GetMessage and DispatchMessage API calls */
 269             if (!TIMER_IsTimerValid(hwnd, (UINT) msg->wParam, (WNDPROC)msg->lParam))
 270                 return 0; /* invalid winproc */
 271
 272             return CallWindowProc16( (WNDPROC16)msg->lParam, msg->hwnd,
 273                                      msg->message, msg->wParam, GetTickCount() );
 274         }
 275     }
 276
 277     if (!(wndPtr = WIN_GetPtr( hwnd )))
 278     {
 279         if (msg->hwnd) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 280         return 0;
 281     }
 282     if (wndPtr == WND_OTHER_PROCESS)
 283     {
 284         if (IsWindow( hwnd ))
 285             ERR( "cannot dispatch msg to other process window %p\n", hwnd );
 286         SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 287         return 0;
 288     }
 289
 290     if (!(winproc = (WNDPROC16)wndPtr->winproc))
 291     {
 292         WIN_ReleasePtr( wndPtr );
 293         return 0;
 294     }
 295     painting = (msg->message == WM_PAINT);
 296     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
 297     WIN_ReleasePtr( wndPtr );
 298
 299     SPY_EnterMessage( SPY_DISPATCHMESSAGE16, hwnd, msg->message, msg->wParam, msg->lParam );
 300     retval = CallWindowProc16( winproc, msg->hwnd, msg->message, msg->wParam, msg->lParam );
 301     SPY_ExitMessage( SPY_RESULT_OK16, hwnd, msg->message, retval, msg->wParam, msg->lParam );
 302
 303     if (painting && (wndPtr = WIN_GetPtr( hwnd )) && (wndPtr != WND_OTHER_PROCESS))
 304     {
 305         BOOL validate = ((wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate);
 306         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
 307         WIN_ReleasePtr( wndPtr );
 308         if (validate)
 309         {
 310             ERR( "BeginPaint not called on WM_PAINT for hwnd %p!\n", hwnd );
 311             /* Validate the update region to avoid infinite WM_PAINT loop */
 312             RedrawWindow( hwnd, NULL, 0,
 313                           RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
 314         }
 315     }
 316     return retval;
 317 }
 318
 319
 320 /***********************************************************************
 321  *              DispatchMessage32 (USER.822)
 322  */
 323 LONG WINAPI DispatchMessage32_16( const MSG32_16 *msg16, BOOL16 wHaveParamHigh )
 324 {
 325     if (wHaveParamHigh == FALSE)
 326         return DispatchMessage16( &msg16->msg );
 327     else
 328     {
 329         MSG msg;
 330
 331         msg.hwnd    = WIN_Handle32( msg16->msg.hwnd );
 332         msg.message = msg16->msg.message;
 333         msg.wParam  = MAKEWPARAM( msg16->msg.wParam, msg16->wParamHigh );
 334         msg.lParam  = msg16->msg.lParam;
 335         msg.time    = msg16->msg.time;
 336         msg.pt.x    = msg16->msg.pt.x;
 337         msg.pt.y    = msg16->msg.pt.y;
 338         return DispatchMessageA( &msg );
 339     }
 340 }
 341
 342
 343 /***********************************************************************
 344  *              IsDialogMessage (USER.90)
 345  */
 346 BOOL16 WINAPI IsDialogMessage16( HWND16 hwndDlg, MSG16 *msg16 )
 347 {
 348     MSG msg;
 349
 350     switch(msg16->message)
 351     {
 352     case WM_KEYDOWN:
 353     case WM_CHAR:
 354     case WM_SYSCHAR:
 355         msg.hwnd   = WIN_Handle32(msg16->hwnd);
 356         msg.lParam = msg16->lParam;
 357         WINPROC_MapMsg16To32W( msg.hwnd, msg16->message, msg16->wParam,
 358                                &msg.message, &msg.wParam, &msg.lParam );
 359         /* these messages don't need an unmap */
 360         return IsDialogMessageW( WIN_Handle32(hwndDlg), &msg );
 361     }
 362     TranslateMessage16( msg16 );
 363     DispatchMessage16( msg16 );
 364     return TRUE;
 365 }
 366
 367
 368 /***********************************************************************
 369  *              MsgWaitForMultipleObjects  (USER.640)
 370  */
 371 DWORD WINAPI MsgWaitForMultipleObjects16( DWORD count, CONST HANDLE *handles,
 372                                           BOOL wait_all, DWORD timeout, DWORD mask )
 373 {
 374     return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
 375                                         wait_all ? MWMO_WAITALL : 0 );
 376 }
 377
 378
 379 /**********************************************************************
 380  *              SetDoubleClickTime (USER.20)
 381  */
 382 void WINAPI SetDoubleClickTime16( UINT16 interval )
 383 {
 384     SetDoubleClickTime( interval );
 385 }
 386
 387
 388 /**********************************************************************
 389  *              GetDoubleClickTime (USER.21)
 390  */
 391 UINT16 WINAPI GetDoubleClickTime16(void)
 392 {
 393     return GetDoubleClickTime();
 394 }
 395
 396
 397 /***********************************************************************
 398  *              PostQuitMessage (USER.6)
 399  */
 400 void WINAPI PostQuitMessage16( INT16 exitCode )
 401 {
 402     PostQuitMessage( exitCode );
 403 }
 404
 405
 406 /**********************************************************************
 407  *              GetKeyState (USER.106)
 408  */
 409 INT16 WINAPI GetKeyState16(INT16 vkey)
 410 {
 411     return GetKeyState(vkey);
 412 }
 413
 414
 415 /**********************************************************************
 416  *              GetKeyboardState (USER.222)
 417  */
 418 BOOL WINAPI GetKeyboardState16( LPBYTE state )
 419 {
 420     return GetKeyboardState( state );
 421 }
 422
 423
 424 /**********************************************************************
 425  *              SetKeyboardState (USER.223)
 426  */
 427 BOOL WINAPI SetKeyboardState16( LPBYTE state )
 428 {
 429     return SetKeyboardState( state );
 430 }
 431
 432
 433 /***********************************************************************
 434  *              SetMessageQueue (USER.266)
 435  */
 436 BOOL16 WINAPI SetMessageQueue16( INT16 size )
 437 {
 438     return SetMessageQueue( size );
 439 }
 440
 441
 442 /***********************************************************************
 443  *              GetQueueStatus (USER.334)
 444  */
 445 DWORD WINAPI GetQueueStatus16( UINT16 flags )
 446 {
 447     return GetQueueStatus( flags );
 448 }
 449
 450
 451 /***********************************************************************
 452  *              GetInputState (USER.335)
 453  */
 454 BOOL16 WINAPI GetInputState16(void)
 455 {
 456     return GetInputState();
 457 }
 458
 459
 460 /**********************************************************************
 461  *           TranslateAccelerator      (USER.178)
 462  */
 463 INT16 WINAPI TranslateAccelerator16( HWND16 hwnd, HACCEL16 hAccel, LPMSG16 msg )
 464 {
 465     MSG msg32;
 466
 467     if (!msg) return 0;
 468     msg32.message = msg->message;
 469     /* msg32.hwnd not used */
 470     msg32.wParam  = msg->wParam;
 471     msg32.lParam  = msg->lParam;
 472     return TranslateAccelerator( WIN_Handle32(hwnd), HACCEL_32(hAccel), &msg32 );
 473 }
 474
 475
 476 /**********************************************************************
 477  *              TranslateMDISysAccel (USER.451)
 478  */
 479 BOOL16 WINAPI TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg )
 480 {
 481     if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
 482     {
 483         MSG msg32;
 484         msg32.hwnd    = WIN_Handle32(msg->hwnd);
 485         msg32.message = msg->message;
 486         msg32.wParam  = msg->wParam;
 487         msg32.lParam  = msg->lParam;
 488         /* MDICLIENTINFO is still the same for win32 and win16 ... */
 489         return TranslateMDISysAccel( WIN_Handle32(hwndClient), &msg32 );
 490     }
 491     return 0;
 492 }