ole32: Remove an unnecessary special case in StorageBaseImpl_CopyTo.
[wine] / dlls / user32 / 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "wine/winuser16.h"
22 #include "wownt32.h"
23 #include "winerror.h"
24 #include "win.h"
25 #include "user_private.h"
26 #include "wine/debug.h"
27
28 WINE_DEFAULT_DEBUG_CHANNEL(msg);
29
30 DWORD USER16_AlertableWait = 0;
31
32 static LRESULT cwp_hook_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
33                                   LRESULT *result, void *arg )
34 {
35     CWPSTRUCT cwp;
36
37     cwp.hwnd    = hwnd;
38     cwp.message = msg;
39     cwp.wParam  = wp;
40     cwp.lParam  = lp;
41     *result = 0;
42     return HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp, FALSE );
43 }
44
45 static LRESULT send_message_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
46                                       LRESULT *result, void *arg )
47 {
48     *result = SendMessageA( hwnd, msg, wp, lp );
49     return *result;
50 }
51
52 static LRESULT post_message_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
53                                       LRESULT *result, void *arg )
54 {
55     *result = 0;
56     return PostMessageA( hwnd, msg, wp, lp );
57 }
58
59 static LRESULT post_thread_message_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
60                                              LRESULT *result, void *arg )
61 {
62     DWORD_PTR tid = (DWORD_PTR)arg;
63     *result = 0;
64     return PostThreadMessageA( tid, msg, wp, lp );
65 }
66
67 static LRESULT get_message_callback( HWND16 hwnd, UINT16 msg, WPARAM16 wp, LPARAM lp,
68                                      LRESULT *result, void *arg )
69 {
70     MSG16 *msg16 = arg;
71
72     msg16->hwnd    = hwnd;
73     msg16->message = msg;
74     msg16->wParam  = wp;
75     msg16->lParam  = lp;
76     *result = 0;
77     return 0;
78 }
79
80 static LRESULT defdlg_proc_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
81                                      LRESULT *result, void *arg )
82 {
83     *result = DefDlgProcA( hwnd, msg, wp, lp );
84     return *result;
85 }
86
87
88 /***********************************************************************
89  *              SendMessage  (USER.111)
90  */
91 LRESULT WINAPI SendMessage16( HWND16 hwnd16, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
92 {
93     LRESULT result;
94     HWND hwnd = WIN_Handle32( hwnd16 );
95
96     if (hwnd != HWND_BROADCAST && WIN_IsCurrentThread(hwnd))
97     {
98         /* call 16-bit window proc directly */
99         WNDPROC16 winproc;
100
101         /* first the WH_CALLWNDPROC hook */
102         if (HOOK_IsHooked( WH_CALLWNDPROC ))
103             WINPROC_CallProc16To32A( cwp_hook_callback, hwnd16, msg, wparam, lparam, &result, NULL );
104
105         if (!(winproc = (WNDPROC16)GetWindowLong16( hwnd16, GWLP_WNDPROC ))) return 0;
106
107         SPY_EnterMessage( SPY_SENDMESSAGE16, hwnd, msg, wparam, lparam );
108         result = CallWindowProc16( winproc, hwnd16, msg, wparam, lparam );
109         SPY_ExitMessage( SPY_RESULT_OK16, hwnd, msg, result, wparam, lparam );
110     }
111     else  /* map to 32-bit unicode for inter-thread/process message */
112     {
113         WINPROC_CallProc16To32A( send_message_callback, hwnd16, msg, wparam, lparam, &result, NULL );
114     }
115     return result;
116 }
117
118
119 /***********************************************************************
120  *              PostMessage  (USER.110)
121  */
122 BOOL16 WINAPI PostMessage16( HWND16 hwnd, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
123 {
124     LRESULT unused;
125     return WINPROC_CallProc16To32A( post_message_callback, hwnd, msg, wparam, lparam, &unused, NULL );
126 }
127
128
129 /***********************************************************************
130  *              PostAppMessage (USER.116)
131  */
132 BOOL16 WINAPI PostAppMessage16( HTASK16 hTask, UINT16 msg, WPARAM16 wparam, LPARAM lparam )
133 {
134     LRESULT unused;
135     DWORD_PTR tid = HTASK_32( hTask );
136
137     if (!tid) return FALSE;
138     return WINPROC_CallProc16To32A( post_thread_message_callback, 0, msg, wparam, lparam,
139                                     &unused, (void *)tid );
140 }
141
142
143 /***********************************************************************
144  *              InSendMessage  (USER.192)
145  */
146 BOOL16 WINAPI InSendMessage16(void)
147 {
148     return InSendMessage();
149 }
150
151
152 /***********************************************************************
153  *              ReplyMessage  (USER.115)
154  */
155 void WINAPI ReplyMessage16( LRESULT result )
156 {
157     ReplyMessage( result );
158 }
159
160
161 /***********************************************************************
162  *              PeekMessage32 (USER.819)
163  */
164 BOOL16 WINAPI PeekMessage32_16( MSG32_16 *msg16, HWND16 hwnd16,
165                                 UINT16 first, UINT16 last, UINT16 flags,
166                                 BOOL16 wHaveParamHigh )
167 {
168     MSG msg;
169     LRESULT unused;
170     HWND hwnd = WIN_Handle32( hwnd16 );
171
172     if(USER16_AlertableWait)
173         MsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, MWMO_ALERTABLE );
174     if (!PeekMessageA( &msg, hwnd, first, last, flags )) return FALSE;
175
176     msg16->msg.time    = msg.time;
177     msg16->msg.pt.x    = (INT16)msg.pt.x;
178     msg16->msg.pt.y    = (INT16)msg.pt.y;
179     if (wHaveParamHigh) msg16->wParamHigh = HIWORD(msg.wParam);
180     WINPROC_CallProc32ATo16( get_message_callback, msg.hwnd, msg.message, msg.wParam, msg.lParam,
181                              &unused, &msg16->msg );
182     return TRUE;
183 }
184
185
186 /***********************************************************************
187  *              DefWindowProc (USER.107)
188  */
189 LRESULT WINAPI DefWindowProc16( HWND16 hwnd16, UINT16 msg, WPARAM16 wParam, LPARAM lParam )
190 {
191     LRESULT result;
192     HWND hwnd = WIN_Handle32( hwnd16 );
193
194     SPY_EnterMessage( SPY_DEFWNDPROC16, hwnd, msg, wParam, lParam );
195
196     switch(msg)
197     {
198     case WM_NCCREATE:
199         {
200             CREATESTRUCT16 *cs16 = MapSL(lParam);
201             CREATESTRUCTA cs32;
202
203             cs32.lpCreateParams = ULongToPtr(cs16->lpCreateParams);
204             cs32.hInstance      = HINSTANCE_32(cs16->hInstance);
205             cs32.hMenu          = HMENU_32(cs16->hMenu);
206             cs32.hwndParent     = WIN_Handle32(cs16->hwndParent);
207             cs32.cy             = cs16->cy;
208             cs32.cx             = cs16->cx;
209             cs32.y              = cs16->y;
210             cs32.x              = cs16->x;
211             cs32.style          = cs16->style;
212             cs32.dwExStyle      = cs16->dwExStyle;
213             cs32.lpszName       = MapSL(cs16->lpszName);
214             cs32.lpszClass      = MapSL(cs16->lpszClass);
215             result = DefWindowProcA( hwnd, msg, wParam, (LPARAM)&cs32 );
216         }
217         break;
218
219     case WM_NCCALCSIZE:
220         {
221             RECT16 *rect16 = MapSL(lParam);
222             RECT rect32;
223
224             rect32.left    = rect16->left;
225             rect32.top     = rect16->top;
226             rect32.right   = rect16->right;
227             rect32.bottom  = rect16->bottom;
228
229             result = DefWindowProcA( hwnd, msg, wParam, (LPARAM)&rect32 );
230
231             rect16->left   = rect32.left;
232             rect16->top    = rect32.top;
233             rect16->right  = rect32.right;
234             rect16->bottom = rect32.bottom;
235         }
236         break;
237
238     case WM_WINDOWPOSCHANGING:
239     case WM_WINDOWPOSCHANGED:
240         {
241             WINDOWPOS16 *pos16 = MapSL(lParam);
242             WINDOWPOS pos32;
243
244             pos32.hwnd             = WIN_Handle32(pos16->hwnd);
245             pos32.hwndInsertAfter  = WIN_Handle32(pos16->hwndInsertAfter);
246             pos32.x                = pos16->x;
247             pos32.y                = pos16->y;
248             pos32.cx               = pos16->cx;
249             pos32.cy               = pos16->cy;
250             pos32.flags            = pos16->flags;
251
252             result = DefWindowProcA( hwnd, msg, wParam, (LPARAM)&pos32 );
253
254             pos16->hwnd            = HWND_16(pos32.hwnd);
255             pos16->hwndInsertAfter = HWND_16(pos32.hwndInsertAfter);
256             pos16->x               = pos32.x;
257             pos16->y               = pos32.y;
258             pos16->cx              = pos32.cx;
259             pos16->cy              = pos32.cy;
260             pos16->flags           = pos32.flags;
261         }
262         break;
263
264     case WM_GETTEXT:
265     case WM_SETTEXT:
266         result = DefWindowProcA( hwnd, msg, wParam, (LPARAM)MapSL(lParam) );
267         break;
268
269     default:
270         result = DefWindowProcA( hwnd, msg, wParam, lParam );
271         break;
272     }
273
274     SPY_ExitMessage( SPY_RESULT_DEFWND16, hwnd, msg, result, wParam, lParam );
275     return result;
276 }
277
278
279 /***********************************************************************
280  *              DefDlgProc (USER.308)
281  */
282 LRESULT WINAPI DefDlgProc16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam )
283 {
284     LRESULT result;
285     WINPROC_CallProc16To32A( defdlg_proc_callback, hwnd, msg, wParam, lParam, &result, 0 );
286     return result;
287 }
288
289
290 /***********************************************************************
291  *              PeekMessage  (USER.109)
292  */
293 BOOL16 WINAPI PeekMessage16( MSG16 *msg, HWND16 hwnd,
294                              UINT16 first, UINT16 last, UINT16 flags )
295 {
296     return PeekMessage32_16( (MSG32_16 *)msg, hwnd, first, last, flags, FALSE );
297 }
298
299
300 /***********************************************************************
301  *              GetMessage32  (USER.820)
302  */
303 BOOL16 WINAPI GetMessage32_16( MSG32_16 *msg16, HWND16 hwnd16, UINT16 first,
304                                UINT16 last, BOOL16 wHaveParamHigh )
305 {
306     MSG msg;
307     LRESULT unused;
308     HWND hwnd = WIN_Handle32( hwnd16 );
309
310     if(USER16_AlertableWait)
311         MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, 0, MWMO_ALERTABLE );
312     GetMessageA( &msg, hwnd, first, last );
313     msg16->msg.time    = msg.time;
314     msg16->msg.pt.x    = (INT16)msg.pt.x;
315     msg16->msg.pt.y    = (INT16)msg.pt.y;
316     if (wHaveParamHigh) msg16->wParamHigh = HIWORD(msg.wParam);
317     WINPROC_CallProc32ATo16( get_message_callback, msg.hwnd, msg.message, msg.wParam, msg.lParam,
318                              &unused, &msg16->msg );
319
320     TRACE( "message %04x, hwnd %p, filter(%04x - %04x)\n",
321            msg16->msg.message, hwnd, first, last );
322
323     return msg16->msg.message != WM_QUIT;
324 }
325
326
327 /***********************************************************************
328  *              GetMessage  (USER.108)
329  */
330 BOOL16 WINAPI GetMessage16( MSG16 *msg, HWND16 hwnd, UINT16 first, UINT16 last )
331 {
332     return GetMessage32_16( (MSG32_16 *)msg, hwnd, first, last, FALSE );
333 }
334
335
336 /***********************************************************************
337  *              TranslateMessage32 (USER.821)
338  */
339 BOOL16 WINAPI TranslateMessage32_16( const MSG32_16 *msg, BOOL16 wHaveParamHigh )
340 {
341     MSG msg32;
342
343     msg32.hwnd    = WIN_Handle32( msg->msg.hwnd );
344     msg32.message = msg->msg.message;
345     msg32.wParam  = MAKEWPARAM( msg->msg.wParam, wHaveParamHigh ? msg->wParamHigh : 0 );
346     msg32.lParam  = msg->msg.lParam;
347     return TranslateMessage( &msg32 );
348 }
349
350
351 /***********************************************************************
352  *              TranslateMessage (USER.113)
353  */
354 BOOL16 WINAPI TranslateMessage16( const MSG16 *msg )
355 {
356     return TranslateMessage32_16( (const MSG32_16 *)msg, FALSE );
357 }
358
359
360 /***********************************************************************
361  *              DispatchMessage (USER.114)
362  */
363 LONG WINAPI DispatchMessage16( const MSG16* msg )
364 {
365     WND * wndPtr;
366     WNDPROC16 winproc;
367     LONG retval;
368     HWND hwnd = WIN_Handle32( msg->hwnd );
369
370       /* Process timer messages */
371     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
372     {
373         if (msg->lParam)
374             return CallWindowProc16( (WNDPROC16)msg->lParam, msg->hwnd,
375                                      msg->message, msg->wParam, GetTickCount() );
376     }
377
378     if (!(wndPtr = WIN_GetPtr( hwnd )))
379     {
380         if (msg->hwnd) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
381         return 0;
382     }
383     if (wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP)
384     {
385         if (IsWindow( hwnd )) SetLastError( ERROR_MESSAGE_SYNC_ONLY );
386         else SetLastError( ERROR_INVALID_WINDOW_HANDLE );
387         return 0;
388     }
389     winproc = WINPROC_GetProc16( wndPtr->winproc, wndPtr->flags & WIN_ISUNICODE );
390     WIN_ReleasePtr( wndPtr );
391
392     SPY_EnterMessage( SPY_DISPATCHMESSAGE16, hwnd, msg->message, msg->wParam, msg->lParam );
393     retval = CallWindowProc16( winproc, msg->hwnd, msg->message, msg->wParam, msg->lParam );
394     SPY_ExitMessage( SPY_RESULT_OK16, hwnd, msg->message, retval, msg->wParam, msg->lParam );
395
396     return retval;
397 }
398
399
400 /***********************************************************************
401  *              DispatchMessage32 (USER.822)
402  */
403 LONG WINAPI DispatchMessage32_16( const MSG32_16 *msg16, BOOL16 wHaveParamHigh )
404 {
405     if (wHaveParamHigh == FALSE)
406         return DispatchMessage16( &msg16->msg );
407     else
408     {
409         MSG msg;
410
411         msg.hwnd    = WIN_Handle32( msg16->msg.hwnd );
412         msg.message = msg16->msg.message;
413         msg.wParam  = MAKEWPARAM( msg16->msg.wParam, msg16->wParamHigh );
414         msg.lParam  = msg16->msg.lParam;
415         msg.time    = msg16->msg.time;
416         msg.pt.x    = msg16->msg.pt.x;
417         msg.pt.y    = msg16->msg.pt.y;
418         return DispatchMessageA( &msg );
419     }
420 }
421
422
423 /***********************************************************************
424  *              IsDialogMessage (USER.90)
425  */
426 BOOL16 WINAPI IsDialogMessage16( HWND16 hwndDlg, MSG16 *msg16 )
427 {
428     MSG msg;
429     HWND hwndDlg32;
430
431     msg.hwnd  = WIN_Handle32(msg16->hwnd);
432     hwndDlg32 = WIN_Handle32(hwndDlg);
433
434     switch(msg16->message)
435     {
436     case WM_KEYDOWN:
437     case WM_CHAR:
438     case WM_SYSCHAR:
439         msg.message = msg16->message;
440         msg.wParam  = msg16->wParam;
441         msg.lParam  = msg16->lParam;
442         return IsDialogMessageA( hwndDlg32, &msg );
443     }
444
445     if ((hwndDlg32 != msg.hwnd) && !IsChild( hwndDlg32, msg.hwnd )) return FALSE;
446     TranslateMessage16( msg16 );
447     DispatchMessage16( msg16 );
448     return TRUE;
449 }
450
451
452 /***********************************************************************
453  *              MsgWaitForMultipleObjects  (USER.640)
454  */
455 DWORD WINAPI MsgWaitForMultipleObjects16( DWORD count, CONST HANDLE *handles,
456                                           BOOL wait_all, DWORD timeout, DWORD mask )
457 {
458     return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
459                                         wait_all ? MWMO_WAITALL : 0 );
460 }
461
462
463 /**********************************************************************
464  *              SetDoubleClickTime (USER.20)
465  */
466 void WINAPI SetDoubleClickTime16( UINT16 interval )
467 {
468     SetDoubleClickTime( interval );
469 }
470
471
472 /**********************************************************************
473  *              GetDoubleClickTime (USER.21)
474  */
475 UINT16 WINAPI GetDoubleClickTime16(void)
476 {
477     return GetDoubleClickTime();
478 }
479
480
481 /***********************************************************************
482  *              PostQuitMessage (USER.6)
483  */
484 void WINAPI PostQuitMessage16( INT16 exitCode )
485 {
486     PostQuitMessage( exitCode );
487 }
488
489
490 /**********************************************************************
491  *              GetKeyState (USER.106)
492  */
493 INT16 WINAPI GetKeyState16(INT16 vkey)
494 {
495     return GetKeyState(vkey);
496 }
497
498
499 /**********************************************************************
500  *              GetKeyboardState (USER.222)
501  */
502 BOOL WINAPI GetKeyboardState16( LPBYTE state )
503 {
504     return GetKeyboardState( state );
505 }
506
507
508 /**********************************************************************
509  *              SetKeyboardState (USER.223)
510  */
511 BOOL WINAPI SetKeyboardState16( LPBYTE state )
512 {
513     return SetKeyboardState( state );
514 }
515
516
517 /***********************************************************************
518  *              SetMessageQueue (USER.266)
519  */
520 BOOL16 WINAPI SetMessageQueue16( INT16 size )
521 {
522     return SetMessageQueue( size );
523 }
524
525
526 /***********************************************************************
527  *              UserYield (USER.332)
528  */
529 void WINAPI UserYield16(void)
530 {
531     MSG msg;
532     PeekMessageW( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE );
533 }
534
535
536 /***********************************************************************
537  *              GetQueueStatus (USER.334)
538  */
539 DWORD WINAPI GetQueueStatus16( UINT16 flags )
540 {
541     return GetQueueStatus( flags );
542 }
543
544
545 /***********************************************************************
546  *              GetInputState (USER.335)
547  */
548 BOOL16 WINAPI GetInputState16(void)
549 {
550     return GetInputState();
551 }
552
553
554 /**********************************************************************
555  *           TranslateAccelerator      (USER.178)
556  */
557 INT16 WINAPI TranslateAccelerator16( HWND16 hwnd, HACCEL16 hAccel, LPMSG16 msg )
558 {
559     MSG msg32;
560
561     if (!msg) return 0;
562     msg32.message = msg->message;
563     /* msg32.hwnd not used */
564     msg32.wParam  = msg->wParam;
565     msg32.lParam  = msg->lParam;
566     return TranslateAcceleratorW( WIN_Handle32(hwnd), HACCEL_32(hAccel), &msg32 );
567 }
568
569
570 /**********************************************************************
571  *              TranslateMDISysAccel (USER.451)
572  */
573 BOOL16 WINAPI TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg )
574 {
575     if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
576     {
577         MSG msg32;
578         msg32.hwnd    = WIN_Handle32(msg->hwnd);
579         msg32.message = msg->message;
580         msg32.wParam  = msg->wParam;
581         msg32.lParam  = msg->lParam;
582         /* MDICLIENTINFO is still the same for win32 and win16 ... */
583         return TranslateMDISysAccel( WIN_Handle32(hwndClient), &msg32 );
584     }
585     return 0;
586 }