?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
advapi32: Convert the service list to a standard list.
[wine/wine64.git] / dlls / user32 / winproc.c
blob59d432d2dcd000ca97cad8dd7ccb6ffc35cbc6d8
1 /*
2 * Window procedure callbacks
3 *
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1996 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdarg.h>
27 #include <string.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "wownt32.h"
32 #include "wine/winbase16.h"
33 #include "wine/winuser16.h"
34 #include "controls.h"
35 #include "win.h"
36 #include "winproc.h"
37 #include "user_private.h"
38 #include "dde.h"
39 #include "winternl.h"
40 #include "wine/unicode.h"
41 #include "wine/debug.h"
42
43 WINE_DECLARE_DEBUG_CHANNEL(msg);
44 WINE_DECLARE_DEBUG_CHANNEL(relay);
45 WINE_DEFAULT_DEBUG_CHANNEL(win);
46
47 typedef struct tagWINDOWPROC
48 {
49 WNDPROC16 proc16; /* 16-bit window proc */
50 WNDPROC procA; /* ASCII window proc */
51 WNDPROC procW; /* Unicode window proc */
52 } WINDOWPROC;
53
54 #define WINPROC_HANDLE (~0UL >> 16)
55 #define MAX_WINPROCS 8192
56
57 static WINDOWPROC winproc_array[MAX_WINPROCS];
58 static UINT winproc_used;
59
60 static CRITICAL_SECTION winproc_cs;
61 static CRITICAL_SECTION_DEBUG critsect_debug =
62 {
63 0, 0, &winproc_cs,
64 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
65 0, 0, { (DWORD_PTR)(__FILE__ ": winproc_cs") }
66 };
67 static CRITICAL_SECTION winproc_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
68
69 static inline void *get_buffer( void *static_buffer, size_t size, size_t need )
70 {
71 if (size >= need) return static_buffer;
72 return HeapAlloc( GetProcessHeap(), 0, need );
73 }
74
75 static inline void free_buffer( void *static_buffer, void *buffer )
76 {
77 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
78 }
79
80 /* find an existing winproc for a given 16-bit function and type */
81 /* FIXME: probably should do something more clever than a linear search */
82 static inline WINDOWPROC *find_winproc16( WNDPROC16 func )
83 {
84 unsigned int i;
85
86 for (i = 0; i < winproc_used; i++)
87 {
88 if (winproc_array[i].proc16 == func) return &winproc_array[i];
89 }
90 return NULL;
91 }
92
93 /* find an existing winproc for a given function and type */
94 /* FIXME: probably should do something more clever than a linear search */
95 static inline WINDOWPROC *find_winproc( WNDPROC funcA, WNDPROC funcW )
96 {
97 unsigned int i;
98
99 for (i = 0; i < winproc_used; i++)
100 {
101 if (funcA && winproc_array[i].procA != funcA) continue;
102 if (funcW && winproc_array[i].procW != funcW) continue;
103 return &winproc_array[i];
104 }
105 return NULL;
106 }
107
108 /* return the window proc for a given handle, or NULL for an invalid handle */
109 static inline WINDOWPROC *handle_to_proc( WNDPROC handle )
110 {
111 UINT index = LOWORD(handle);
112 if ((ULONG_PTR)handle >> 16 != WINPROC_HANDLE) return NULL;
113 if (index >= winproc_used) return NULL;
114 return &winproc_array[index];
115 }
116
117 /* create a handle for a given window proc */
118 static inline WNDPROC proc_to_handle( WINDOWPROC *proc )
119 {
120 return (WNDPROC)(ULONG_PTR)((proc - winproc_array) | (WINPROC_HANDLE << 16));
121 }
122
123 /* allocate and initialize a new winproc */
124 static inline WINDOWPROC *alloc_winproc( WNDPROC funcA, WNDPROC funcW )
125 {
126 WINDOWPROC *proc;
127
128 /* check if the function is already a win proc */
129 if (funcA && (proc = handle_to_proc( funcA ))) return proc;
130 if (funcW && (proc = handle_to_proc( funcW ))) return proc;
131 if (!funcA && !funcW) return NULL;
132
133 EnterCriticalSection( &winproc_cs );
134
135 /* check if we already have a winproc for that function */
136 if (!(proc = find_winproc( funcA, funcW )))
137 {
138 if (winproc_used < MAX_WINPROCS)
139 {
140 proc = &winproc_array[winproc_used++];
141 proc->procA = funcA;
142 proc->procW = funcW;
143 TRACE( "allocated %p for %p/%p (%d/%d used)\n",
144 proc_to_handle(proc), funcA, funcW, winproc_used, MAX_WINPROCS );
145 }
146 else FIXME( "too many winprocs, cannot allocate one for %p/%p\n", funcA, funcW );
147 }
148 else TRACE( "reusing %p for %p/%p\n", proc_to_handle(proc), funcA, funcW );
149
150 LeaveCriticalSection( &winproc_cs );
151 return proc;
152 }
153
154
155 #ifdef __i386__
156
157 #include "pshpack1.h"
158
159 /* Window procedure 16-to-32-bit thunk */
160 typedef struct
161 {
162 BYTE popl_eax; /* popl %eax (return address) */
163 BYTE pushl_func; /* pushl $proc */
164 WINDOWPROC *proc;
165 BYTE pushl_eax; /* pushl %eax */
166 BYTE ljmp; /* ljmp relay*/
167 DWORD relay_offset; /* __wine_call_wndproc */
168 WORD relay_sel;
169 } WINPROC_THUNK;
170
171 #include "poppack.h"
172
173 #define MAX_THUNKS (0x10000 / sizeof(WINPROC_THUNK))
174
175 static WINPROC_THUNK *thunk_array;
176 static UINT thunk_selector;
177 static UINT thunk_used;
178
179 /* return the window proc for a given handle, or NULL for an invalid handle */
180 static inline WINDOWPROC *handle16_to_proc( WNDPROC16 handle )
181 {
182 if (HIWORD(handle) == thunk_selector)
183 {
184 UINT index = LOWORD(handle) / sizeof(WINPROC_THUNK);
185 /* check alignment */
186 if (index * sizeof(WINPROC_THUNK) != LOWORD(handle)) return NULL;
187 /* check array limits */
188 if (index >= thunk_used) return NULL;
189 return thunk_array[index].proc;
190 }
191 return handle_to_proc( (WNDPROC)handle );
192 }
193
194 /* allocate a 16-bit thunk for an existing window proc */
195 static WNDPROC16 alloc_win16_thunk( WINDOWPROC *proc )
196 {
197 static FARPROC16 relay;
198 UINT i;
199
200 if (proc->proc16) return proc->proc16;
201
202 EnterCriticalSection( &winproc_cs );
203
204 if (!thunk_array) /* allocate the array and its selector */
205 {
206 LDT_ENTRY entry;
207
208 if (!(thunk_selector = wine_ldt_alloc_entries(1))) goto done;
209 if (!(thunk_array = VirtualAlloc( NULL, MAX_THUNKS * sizeof(WINPROC_THUNK), MEM_COMMIT,
210 PAGE_EXECUTE_READWRITE ))) goto done;
211 wine_ldt_set_base( &entry, thunk_array );
212 wine_ldt_set_limit( &entry, MAX_THUNKS * sizeof(WINPROC_THUNK) - 1 );
213 wine_ldt_set_flags( &entry, WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
214 wine_ldt_set_entry( thunk_selector, &entry );
215 relay = GetProcAddress16( GetModuleHandle16("user"), "__wine_call_wndproc" );
216 }
217
218 /* check if it already exists */
219 for (i = 0; i < thunk_used; i++) if (thunk_array[i].proc == proc) break;
220
221 if (i == thunk_used) /* create a new one */
222 {
223 WINPROC_THUNK *thunk;
224
225 if (thunk_used >= MAX_THUNKS) goto done;
226 thunk = &thunk_array[thunk_used++];
227 thunk->popl_eax = 0x58; /* popl %eax */
228 thunk->pushl_func = 0x68; /* pushl $proc */
229 thunk->proc = proc;
230 thunk->pushl_eax = 0x50; /* pushl %eax */
231 thunk->ljmp = 0xea; /* ljmp relay*/
232 thunk->relay_offset = OFFSETOF(relay);
233 thunk->relay_sel = SELECTOROF(relay);
234 }
235 proc->proc16 = (WNDPROC16)MAKESEGPTR( thunk_selector, i * sizeof(WINPROC_THUNK) );
236 done:
237 LeaveCriticalSection( &winproc_cs );
238 return proc->proc16;
239 }
240
241 #else /* __i386__ */
242
243 static inline WINDOWPROC *handle16_to_proc( WNDPROC16 handle )
244 {
245 return handle_to_proc( (WNDPROC)handle );
246 }
247
248 static inline WNDPROC16 alloc_win16_thunk( WINDOWPROC *proc )
249 {
250 return 0;
251 }
252
253 #endif /* __i386__ */
254
255
256 #ifdef __i386__
257 /* Some window procedures modify register they shouldn't, or are not
258 * properly declared stdcall; so we need a small assembly wrapper to
259 * call them. */
260 extern LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
261 WPARAM wParam, LPARAM lParam );
262 __ASM_GLOBAL_FUNC( WINPROC_wrapper,
263 "pushl %ebp\n\t"
264 "movl %esp,%ebp\n\t"
265 "pushl %edi\n\t"
266 "pushl %esi\n\t"
267 "pushl %ebx\n\t"
268 "subl $12,%esp\n\t"
269 "pushl 24(%ebp)\n\t"
270 "pushl 20(%ebp)\n\t"
271 "pushl 16(%ebp)\n\t"
272 "pushl 12(%ebp)\n\t"
273 "movl 8(%ebp),%eax\n\t"
274 "call *%eax\n\t"
275 "leal -12(%ebp),%esp\n\t"
276 "popl %ebx\n\t"
277 "popl %esi\n\t"
278 "popl %edi\n\t"
279 "leave\n\t"
280 "ret" )
281 #else
282 static inline LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
283 WPARAM wParam, LPARAM lParam )
284 {
285 return proc( hwnd, msg, wParam, lParam );
286 }
287 #endif /* __i386__ */
288
289 static void RECT16to32( const RECT16 *from, RECT *to )
290 {
291 to->left = from->left;
292 to->top = from->top;
293 to->right = from->right;
294 to->bottom = from->bottom;
295 }
296
297 static void RECT32to16( const RECT *from, RECT16 *to )
298 {
299 to->left = from->left;
300 to->top = from->top;
301 to->right = from->right;
302 to->bottom = from->bottom;
303 }
304
305 static void MINMAXINFO32to16( const MINMAXINFO *from, MINMAXINFO16 *to )
306 {
307 to->ptReserved.x = from->ptReserved.x;
308 to->ptReserved.y = from->ptReserved.y;
309 to->ptMaxSize.x = from->ptMaxSize.x;
310 to->ptMaxSize.y = from->ptMaxSize.y;
311 to->ptMaxPosition.x = from->ptMaxPosition.x;
312 to->ptMaxPosition.y = from->ptMaxPosition.y;
313 to->ptMinTrackSize.x = from->ptMinTrackSize.x;
314 to->ptMinTrackSize.y = from->ptMinTrackSize.y;
315 to->ptMaxTrackSize.x = from->ptMaxTrackSize.x;
316 to->ptMaxTrackSize.y = from->ptMaxTrackSize.y;
317 }
318
319 static void MINMAXINFO16to32( const MINMAXINFO16 *from, MINMAXINFO *to )
320 {
321 to->ptReserved.x = from->ptReserved.x;
322 to->ptReserved.y = from->ptReserved.y;
323 to->ptMaxSize.x = from->ptMaxSize.x;
324 to->ptMaxSize.y = from->ptMaxSize.y;
325 to->ptMaxPosition.x = from->ptMaxPosition.x;
326 to->ptMaxPosition.y = from->ptMaxPosition.y;
327 to->ptMinTrackSize.x = from->ptMinTrackSize.x;
328 to->ptMinTrackSize.y = from->ptMinTrackSize.y;
329 to->ptMaxTrackSize.x = from->ptMaxTrackSize.x;
330 to->ptMaxTrackSize.y = from->ptMaxTrackSize.y;
331 }
332
333 static void WINDOWPOS32to16( const WINDOWPOS* from, WINDOWPOS16* to )
334 {
335 to->hwnd = HWND_16(from->hwnd);
336 to->hwndInsertAfter = HWND_16(from->hwndInsertAfter);
337 to->x = from->x;
338 to->y = from->y;
339 to->cx = from->cx;
340 to->cy = from->cy;
341 to->flags = from->flags;
342 }
343
344 static void WINDOWPOS16to32( const WINDOWPOS16* from, WINDOWPOS* to )
345 {
346 to->hwnd = WIN_Handle32(from->hwnd);
347 to->hwndInsertAfter = (from->hwndInsertAfter == (HWND16)-1) ?
348 HWND_TOPMOST : WIN_Handle32(from->hwndInsertAfter);
349 to->x = from->x;
350 to->y = from->y;
351 to->cx = from->cx;
352 to->cy = from->cy;
353 to->flags = from->flags;
354 }
355
356 /* The strings are not copied */
357 static void CREATESTRUCT32Ato16( const CREATESTRUCTA* from, CREATESTRUCT16* to )
358 {
359 to->lpCreateParams = (SEGPTR)from->lpCreateParams;
360 to->hInstance = HINSTANCE_16(from->hInstance);
361 to->hMenu = HMENU_16(from->hMenu);
362 to->hwndParent = HWND_16(from->hwndParent);
363 to->cy = from->cy;
364 to->cx = from->cx;
365 to->y = from->y;
366 to->x = from->x;
367 to->style = from->style;
368 to->dwExStyle = from->dwExStyle;
369 }
370
371 static void CREATESTRUCT16to32A( const CREATESTRUCT16* from, CREATESTRUCTA *to )
372
373 {
374 to->lpCreateParams = (LPVOID)from->lpCreateParams;
375 to->hInstance = HINSTANCE_32(from->hInstance);
376 to->hMenu = HMENU_32(from->hMenu);
377 to->hwndParent = WIN_Handle32(from->hwndParent);
378 to->cy = from->cy;
379 to->cx = from->cx;
380 to->y = from->y;
381 to->x = from->x;
382 to->style = from->style;
383 to->dwExStyle = from->dwExStyle;
384 to->lpszName = MapSL(from->lpszName);
385 to->lpszClass = MapSL(from->lpszClass);
386 }
387
388 /* The strings are not copied */
389 static void MDICREATESTRUCT32Ato16( const MDICREATESTRUCTA* from, MDICREATESTRUCT16* to )
390 {
391 to->hOwner = HINSTANCE_16(from->hOwner);
392 to->x = from->x;
393 to->y = from->y;
394 to->cx = from->cx;
395 to->cy = from->cy;
396 to->style = from->style;
397 to->lParam = from->lParam;
398 }
399
400 static void MDICREATESTRUCT16to32A( const MDICREATESTRUCT16* from, MDICREATESTRUCTA *to )
401 {
402 to->hOwner = HINSTANCE_32(from->hOwner);
403 to->x = from->x;
404 to->y = from->y;
405 to->cx = from->cx;
406 to->cy = from->cy;
407 to->style = from->style;
408 to->lParam = from->lParam;
409 to->szTitle = MapSL(from->szTitle);
410 to->szClass = MapSL(from->szClass);
411 }
412
413 static WPARAM map_wparam_char_AtoW( WPARAM wParam, DWORD len )
414 {
415 CHAR ch[2];
416 WCHAR wch;
417
418 ch[0] = (wParam >> 8);
419 ch[1] = wParam & 0xff;
420 if (len > 1 && ch[0])
421 RtlMultiByteToUnicodeN( &wch, sizeof(wch), NULL, ch, 2 );
422 else
423 RtlMultiByteToUnicodeN( &wch, sizeof(wch), NULL, ch + 1, 1 );
424 return MAKEWPARAM( wch, HIWORD(wParam) );
425 }
426
427 static WPARAM map_wparam_char_WtoA( WPARAM wParam, DWORD len )
428 {
429 WCHAR wch = wParam;
430 BYTE ch[2];
431
432 RtlUnicodeToMultiByteN( (LPSTR)ch, len, &len, &wch, sizeof(wch) );
433 if (len == 2)
434 return MAKEWPARAM( (ch[0] << 8) | ch[1], HIWORD(wParam) );
435 else
436 return MAKEWPARAM( ch[0], HIWORD(wParam) );
437 }
438
439 /* call a 32-bit window procedure */
440 static LRESULT call_window_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result, void *arg )
441 {
442 WNDPROC proc = arg;
443
444 USER_CheckNotLock();
445
446 hwnd = WIN_GetFullHandle( hwnd );
447 if (TRACE_ON(relay))
448 DPRINTF( "%04x:Call window proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
449 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp );
450
451 *result = WINPROC_wrapper( proc, hwnd, msg, wp, lp );
452
453 if (TRACE_ON(relay))
454 DPRINTF( "%04x:Ret window proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx) retval=%08lx\n",
455 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp, *result );
456 return *result;
457 }
458
459 /* call a 32-bit dialog procedure */
460 static LRESULT call_dialog_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result, void *arg )
461 {
462 WNDPROC proc = arg;
463 LRESULT ret;
464
465 USER_CheckNotLock();
466
467 hwnd = WIN_GetFullHandle( hwnd );
468 if (TRACE_ON(relay))
469 DPRINTF( "%04x:Call dialog proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
470 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp );
471
472 ret = WINPROC_wrapper( proc, hwnd, msg, wp, lp );
473 *result = GetWindowLongPtrW( hwnd, DWLP_MSGRESULT );
474
475 if (TRACE_ON(relay))
476 DPRINTF( "%04x:Ret dialog proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx) retval=%08lx result=%08lx\n",
477 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp, ret, *result );
478 return ret;
479 }
480
481 /* call a 16-bit window procedure */
482 static LRESULT call_window_proc16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
483 LRESULT *result, void *arg )
484 {
485 WNDPROC16 proc = arg;
486 CONTEXT86 context;
487 size_t size = 0;
488 struct
489 {
490 WORD params[5];
491 union
492 {
493 CREATESTRUCT16 cs16;
494 DRAWITEMSTRUCT16 dis16;
495 COMPAREITEMSTRUCT16 cis16;
496 } u;
497 } args;
498
499 USER_CheckNotLock();
500
501 /* Window procedures want ax = hInstance, ds = es = ss */
502
503 memset(&context, 0, sizeof(context));
504 context.SegDs = context.SegEs = SELECTOROF(NtCurrentTeb()->WOW32Reserved);
505 context.SegFs = wine_get_fs();
506 context.SegGs = wine_get_gs();
507 if (!(context.Eax = GetWindowWord( HWND_32(hwnd), GWLP_HINSTANCE ))) context.Eax = context.SegDs;
508 context.SegCs = SELECTOROF(proc);
509 context.Eip = OFFSETOF(proc);
510 context.Ebp = OFFSETOF(NtCurrentTeb()->WOW32Reserved) + (WORD)&((STACK16FRAME*)0)->bp;
511
512 if (lParam)
513 {
514 /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
515 work if structures passed in lParam are placed in the stack/data
516 segment. Programmers easily make the mistake of converting lParam
517 to a near rather than a far pointer, since Windows apparently
518 allows this. We copy the structures to the 16 bit stack; this is
519 ugly but makes these programs work. */
520 switch (msg)
521 {
522 case WM_CREATE:
523 case WM_NCCREATE:
524 size = sizeof(CREATESTRUCT16); break;
525 case WM_DRAWITEM:
526 size = sizeof(DRAWITEMSTRUCT16); break;
527 case WM_COMPAREITEM:
528 size = sizeof(COMPAREITEMSTRUCT16); break;
529 }
530 if (size)
531 {
532 memcpy( &args.u, MapSL(lParam), size );
533 lParam = PtrToUlong(NtCurrentTeb()->WOW32Reserved) - size;
534 }
535 }
536
537 args.params[4] = hwnd;
538 args.params[3] = msg;
539 args.params[2] = wParam;
540 args.params[1] = HIWORD(lParam);
541 args.params[0] = LOWORD(lParam);
542 WOWCallback16Ex( 0, WCB16_REGS, sizeof(args.params) + size, &args, (DWORD *)&context );
543 *result = MAKELONG( LOWORD(context.Eax), LOWORD(context.Edx) );
544 return *result;
545 }
546
547 /* call a 16-bit dialog procedure */
548 static LRESULT call_dialog_proc16( HWND16 hwnd, UINT16 msg, WPARAM16 wp, LPARAM lp,
549 LRESULT *result, void *arg )
550 {
551 LRESULT ret = call_window_proc16( hwnd, msg, wp, lp, result, arg );
552 *result = GetWindowLongPtrW( WIN_Handle32(hwnd), DWLP_MSGRESULT );
553 return LOWORD(ret);
554 }
555
556 /* helper callback for 32W->16 conversion */
557 static LRESULT call_window_proc_Ato16( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
558 LRESULT *result, void *arg )
559 {
560 return WINPROC_CallProc32ATo16( call_window_proc16, hwnd, msg, wp, lp, result, arg );
561 }
562
563 /* helper callback for 32W->16 conversion */
564 static LRESULT call_dialog_proc_Ato16( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
565 LRESULT *result, void *arg )
566 {
567 return WINPROC_CallProc32ATo16( call_dialog_proc16, hwnd, msg, wp, lp, result, arg );
568 }
569
570 /* helper callback for 16->32W conversion */
571 static LRESULT call_window_proc_AtoW( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
572 LRESULT *result, void *arg )
573 {
574 return WINPROC_CallProcAtoW( call_window_proc, hwnd, msg, wp, lp, result, arg );
575 }
576
577 /* helper callback for 16->32W conversion */
578 static LRESULT call_dialog_proc_AtoW( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
579 LRESULT *result, void *arg )
580 {
581 return WINPROC_CallProcAtoW( call_dialog_proc, hwnd, msg, wp, lp, result, arg );
582 }
583
584
585 /**********************************************************************
586 * WINPROC_GetProc16
587 *
588 * Get a window procedure pointer that can be passed to the Windows program.
589 */
590 WNDPROC16 WINPROC_GetProc16( WNDPROC proc, BOOL unicode )
591 {
592 WINDOWPROC *ptr;
593
594 if (unicode) ptr = alloc_winproc( NULL, proc );
595 else ptr = alloc_winproc( proc, NULL );
596
597 if (!ptr) return 0;
598 return alloc_win16_thunk( ptr );
599 }
600
601
602 /**********************************************************************
603 * WINPROC_GetProc
604 *
605 * Get a window procedure pointer that can be passed to the Windows program.
606 */
607 WNDPROC WINPROC_GetProc( WNDPROC proc, BOOL unicode )
608 {
609 WINDOWPROC *ptr = handle_to_proc( proc );
610
611 if (!ptr) return proc;
612 if (unicode)
613 {
614 if (ptr->procW) return ptr->procW;
615 return proc;
616 }
617 else
618 {
619 if (ptr->procA) return ptr->procA;
620 return proc;
621 }
622 }
623
624
625 /**********************************************************************
626 * WINPROC_AllocProc16
627 *
628 * Allocate a window procedure for a window or class.
629 *
630 * Note that allocated winprocs are never freed; the idea is that even if an app creates a
631 * lot of windows, it will usually only have a limited number of window procedures, so the
632 * array won't grow too large, and this way we avoid the need to track allocations per window.
633 */
634 WNDPROC WINPROC_AllocProc16( WNDPROC16 func )
635 {
636 WINDOWPROC *proc;
637
638 if (!func) return NULL;
639
640 /* check if the function is already a win proc */
641 if (!(proc = handle16_to_proc( func )))
642 {
643 EnterCriticalSection( &winproc_cs );
644
645 /* then check if we already have a winproc for that function */
646 if (!(proc = find_winproc16( func )))
647 {
648 if (winproc_used < MAX_WINPROCS)
649 {
650 proc = &winproc_array[winproc_used++];
651 proc->proc16 = func;
652 TRACE( "allocated %p for %p/16-bit (%d/%d used)\n",
653 proc_to_handle(proc), func, winproc_used, MAX_WINPROCS );
654 }
655 else FIXME( "too many winprocs, cannot allocate one for 16-bit %p\n", func );
656 }
657 else TRACE( "reusing %p for %p/16-bit\n", proc_to_handle(proc), func );
658
659 LeaveCriticalSection( &winproc_cs );
660 }
661 return proc_to_handle( proc );
662 }
663
664
665 /**********************************************************************
666 * WINPROC_AllocProc
667 *
668 * Allocate a window procedure for a window or class.
669 *
670 * Note that allocated winprocs are never freed; the idea is that even if an app creates a
671 * lot of windows, it will usually only have a limited number of window procedures, so the
672 * array won't grow too large, and this way we avoid the need to track allocations per window.
673 */
674 WNDPROC WINPROC_AllocProc( WNDPROC funcA, WNDPROC funcW )
675 {
676 WINDOWPROC *proc;
677
678 if (!(proc = alloc_winproc( funcA, funcW ))) return NULL;
679 return proc_to_handle( proc );
680 }
681
682
683 /**********************************************************************
684 * WINPROC_IsUnicode
685 *
686 * Return the window procedure type, or the default value if not a winproc handle.
687 */
688 BOOL WINPROC_IsUnicode( WNDPROC proc, BOOL def_val )
689 {
690 WINDOWPROC *ptr = handle_to_proc( proc );
691
692 if (!ptr) return def_val;
693 if (ptr->procA && ptr->procW) return def_val; /* can be both */
694 return (ptr->procW != NULL);
695 }
696
697
698 /**********************************************************************
699 * WINPROC_TestLBForStr
700 *
701 * Return TRUE if the lparam is a string
702 */
703 static inline BOOL WINPROC_TestLBForStr( HWND hwnd, UINT msg )
704 {
705 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
706 if (msg <= CB_MSGMAX)
707 return (!(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) || (style & CBS_HASSTRINGS));
708 else
709 return (!(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) || (style & LBS_HASSTRINGS));
710
711 }
712
713
714 static UINT_PTR convert_handle_16_to_32(HANDLE16 src, unsigned int flags)
715 {
716 HANDLE dst;
717 UINT sz = GlobalSize16(src);
718 LPSTR ptr16, ptr32;
719
720 if (!(dst = GlobalAlloc(flags, sz)))
721 return 0;
722 ptr16 = GlobalLock16(src);
723 ptr32 = GlobalLock(dst);
724 if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr32, ptr16, sz);
725 GlobalUnlock16(src);
726 GlobalUnlock(dst);
727
728 return (UINT_PTR)dst;
729 }
730
731 static HANDLE16 convert_handle_32_to_16(UINT_PTR src, unsigned int flags)
732 {
733 HANDLE16 dst;
734 UINT sz = GlobalSize((HANDLE)src);
735 LPSTR ptr16, ptr32;
736
737 if (!(dst = GlobalAlloc16(flags, sz)))
738 return 0;
739 ptr32 = GlobalLock((HANDLE)src);
740 ptr16 = GlobalLock16(dst);
741 if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr16, ptr32, sz);
742 GlobalUnlock((HANDLE)src);
743 GlobalUnlock16(dst);
744
745 return dst;
746 }
747
748
749 /**********************************************************************
750 * WINPROC_CallProcAtoW
751 *
752 * Call a window procedure, translating args from Ansi to Unicode.
753 */
754 LRESULT WINPROC_CallProcAtoW( winproc_callback_t callback, HWND hwnd, UINT msg, WPARAM wParam,
755 LPARAM lParam, LRESULT *result, void *arg )
756 {
757 LRESULT ret = 0;
758
759 TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
760 hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
761
762 switch(msg)
763 {
764 case WM_NCCREATE:
765 case WM_CREATE:
766 {
767 WCHAR *ptr, buffer[512];
768 CREATESTRUCTA *csA = (CREATESTRUCTA *)lParam;
769 CREATESTRUCTW csW = *(CREATESTRUCTW *)csA;
770 MDICREATESTRUCTW mdi_cs;
771 DWORD name_lenA = 0, name_lenW = 0, class_lenA = 0, class_lenW = 0;
772
773 if (HIWORD(csA->lpszClass))
774 {
775 class_lenA = strlen(csA->lpszClass) + 1;
776 RtlMultiByteToUnicodeSize( &class_lenW, csA->lpszClass, class_lenA );
777 }
778 if (HIWORD(csA->lpszName))
779 {
780 name_lenA = strlen(csA->lpszName) + 1;
781 RtlMultiByteToUnicodeSize( &name_lenW, csA->lpszName, name_lenA );
782 }
783
784 if (!(ptr = get_buffer( buffer, sizeof(buffer), class_lenW + name_lenW ))) break;
785
786 if (class_lenW)
787 {
788 csW.lpszClass = ptr;
789 RtlMultiByteToUnicodeN( ptr, class_lenW, NULL, csA->lpszClass, class_lenA );
790 }
791 if (name_lenW)
792 {
793 csW.lpszName = ptr + class_lenW/sizeof(WCHAR);
794 RtlMultiByteToUnicodeN( ptr + class_lenW/sizeof(WCHAR), name_lenW, NULL,
795 csA->lpszName, name_lenA );
796 }
797
798 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
799 {
800 mdi_cs = *(MDICREATESTRUCTW *)csA->lpCreateParams;
801 mdi_cs.szTitle = csW.lpszName;
802 mdi_cs.szClass = csW.lpszClass;
803 csW.lpCreateParams = &mdi_cs;
804 }
805
806 ret = callback( hwnd, msg, wParam, (LPARAM)&csW, result, arg );
807 free_buffer( buffer, ptr );
808 }
809 break;
810
811 case WM_MDICREATE:
812 {
813 WCHAR *ptr, buffer[512];
814 DWORD title_lenA = 0, title_lenW = 0, class_lenA = 0, class_lenW = 0;
815 MDICREATESTRUCTA *csA = (MDICREATESTRUCTA *)lParam;
816 MDICREATESTRUCTW csW;
817
818 memcpy( &csW, csA, sizeof(csW) );
819
820 if (HIWORD(csA->szTitle))
821 {
822 title_lenA = strlen(csA->szTitle) + 1;
823 RtlMultiByteToUnicodeSize( &title_lenW, csA->szTitle, title_lenA );
824 }
825 if (HIWORD(csA->szClass))
826 {
827 class_lenA = strlen(csA->szClass) + 1;
828 RtlMultiByteToUnicodeSize( &class_lenW, csA->szClass, class_lenA );
829 }
830
831 if (!(ptr = get_buffer( buffer, sizeof(buffer), title_lenW + class_lenW ))) break;
832
833 if (title_lenW)
834 {
835 csW.szTitle = ptr;
836 RtlMultiByteToUnicodeN( ptr, title_lenW, NULL, csA->szTitle, title_lenA );
837 }
838 if (class_lenW)
839 {
840 csW.szClass = ptr + title_lenW/sizeof(WCHAR);
841 RtlMultiByteToUnicodeN( ptr + title_lenW/sizeof(WCHAR), class_lenW, NULL,
842 csA->szClass, class_lenA );
843 }
844 ret = callback( hwnd, msg, wParam, (LPARAM)&csW, result, arg );
845 free_buffer( buffer, ptr );
846 }
847 break;
848
849 case WM_GETTEXT:
850 case WM_ASKCBFORMATNAME:
851 {
852 WCHAR *ptr, buffer[512];
853 LPSTR str = (LPSTR)lParam;
854 DWORD len = wParam * sizeof(WCHAR);
855
856 if (!(ptr = get_buffer( buffer, sizeof(buffer), len ))) break;
857 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
858 if (wParam)
859 {
860 len = 0;
861 if (*result)
862 RtlUnicodeToMultiByteN( str, wParam - 1, &len, ptr, strlenW(ptr) * sizeof(WCHAR) );
863 str[len] = 0;
864 *result = len;
865 }
866 free_buffer( buffer, ptr );
867 }
868 break;
869
870 case LB_ADDSTRING:
871 case LB_INSERTSTRING:
872 case LB_FINDSTRING:
873 case LB_FINDSTRINGEXACT:
874 case LB_SELECTSTRING:
875 case CB_ADDSTRING:
876 case CB_INSERTSTRING:
877 case CB_FINDSTRING:
878 case CB_FINDSTRINGEXACT:
879 case CB_SELECTSTRING:
880 if (!lParam || !WINPROC_TestLBForStr( hwnd, msg ))
881 {
882 ret = callback( hwnd, msg, wParam, lParam, result, arg );
883 break;
884 }
885 /* fall through */
886 case WM_SETTEXT:
887 case WM_WININICHANGE:
888 case WM_DEVMODECHANGE:
889 case CB_DIR:
890 case LB_DIR:
891 case LB_ADDFILE:
892 case EM_REPLACESEL:
893 if (!lParam) ret = callback( hwnd, msg, wParam, lParam, result, arg );
894 else
895 {
896 WCHAR *ptr, buffer[512];
897 LPCSTR strA = (LPCSTR)lParam;
898 DWORD lenW, lenA = strlen(strA) + 1;
899
900 RtlMultiByteToUnicodeSize( &lenW, strA, lenA );
901 if ((ptr = get_buffer( buffer, sizeof(buffer), lenW )))
902 {
903 RtlMultiByteToUnicodeN( ptr, lenW, NULL, strA, lenA );
904 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
905 free_buffer( buffer, ptr );
906 }
907 }
908 break;
909
910 case LB_GETTEXT:
911 case CB_GETLBTEXT:
912 if (lParam && WINPROC_TestLBForStr( hwnd, msg ))
913 {
914 WCHAR buffer[512]; /* FIXME: fixed sized buffer */
915
916 ret = callback( hwnd, msg, wParam, (LPARAM)buffer, result, arg );
917 if (*result >= 0)
918 {
919 DWORD len;
920 RtlUnicodeToMultiByteN( (LPSTR)lParam, ~0u, &len,
921 buffer, (strlenW(buffer) + 1) * sizeof(WCHAR) );
922 *result = len - 1;
923 }
924 }
925 else ret = callback( hwnd, msg, wParam, lParam, result, arg );
926 break;
927
928 case EM_GETLINE:
929 {
930 WCHAR *ptr, buffer[512];
931 WORD len = *(WORD *)lParam;
932
933 if (!(ptr = get_buffer( buffer, sizeof(buffer), len * sizeof(WCHAR) ))) break;
934 *((WORD *)ptr) = len; /* store the length */
935 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
936 if (*result)
937 {
938 DWORD reslen;
939 RtlUnicodeToMultiByteN( (LPSTR)lParam, len, &reslen, ptr, *result * sizeof(WCHAR) );
940 if (reslen < len) ((LPSTR)lParam)[reslen] = 0;
941 *result = reslen;
942 }
943 free_buffer( buffer, ptr );
944 }
945 break;
946
947 case WM_GETDLGCODE:
948 if (lParam)
949 {
950 MSG newmsg = *(MSG *)lParam;
951 switch(newmsg.message)
952 {
953 case WM_CHAR:
954 case WM_DEADCHAR:
955 case WM_SYSCHAR:
956 case WM_SYSDEADCHAR:
957 newmsg.wParam = map_wparam_char_AtoW( newmsg.wParam, 1 );
958 break;
959 case WM_IME_CHAR:
960 newmsg.wParam = map_wparam_char_AtoW( newmsg.wParam, 2 );
961 break;
962 }
963 ret = callback( hwnd, msg, wParam, (LPARAM)&newmsg, result, arg );
964 }
965 else ret = callback( hwnd, msg, wParam, lParam, result, arg );
966 break;
967
968 case WM_CHARTOITEM:
969 case WM_MENUCHAR:
970 case WM_CHAR:
971 case WM_DEADCHAR:
972 case WM_SYSCHAR:
973 case WM_SYSDEADCHAR:
974 case EM_SETPASSWORDCHAR:
975 ret = callback( hwnd, msg, map_wparam_char_AtoW(wParam,1), lParam, result, arg );
976 break;
977
978 case WM_IME_CHAR:
979 ret = callback( hwnd, msg, map_wparam_char_AtoW(wParam,2), lParam, result, arg );
980 break;
981
982 case WM_GETTEXTLENGTH:
983 case CB_GETLBTEXTLEN:
984 case LB_GETTEXTLEN:
985 ret = callback( hwnd, msg, wParam, lParam, result, arg );
986 if (*result >= 0)
987 {
988 WCHAR *ptr, buffer[512];
989 LRESULT tmp;
990 DWORD len = *result + 1;
991 /* Determine respective GETTEXT message */
992 UINT msgGetText = (msg == WM_GETTEXTLENGTH) ? WM_GETTEXT :
993 ((msg == CB_GETLBTEXTLEN) ? CB_GETLBTEXT : LB_GETTEXT);
994 /* wParam differs between the messages */
995 WPARAM wp = (msg == WM_GETTEXTLENGTH) ? len : wParam;
996
997 if (!(ptr = get_buffer( buffer, sizeof(buffer), len * sizeof(WCHAR) ))) break;
998
999 if (callback == call_window_proc) /* FIXME: hack */
1000 callback( hwnd, msgGetText, wp, (LPARAM)ptr, &tmp, arg );
1001 else
1002 tmp = SendMessageW( hwnd, msgGetText, wp, (LPARAM)ptr );
1003 RtlUnicodeToMultiByteSize( &len, ptr, tmp * sizeof(WCHAR) );
1004 *result = len;
1005 free_buffer( buffer, ptr );
1006 }
1007 break;
1008
1009 case WM_PAINTCLIPBOARD:
1010 case WM_SIZECLIPBOARD:
1011 FIXME_(msg)( "message %s (0x%x) needs translation, please report\n",
1012 SPY_GetMsgName(msg, hwnd), msg );
1013 break;
1014
1015 default:
1016 ret = callback( hwnd, msg, wParam, lParam, result, arg );
1017 break;
1018 }
1019 return ret;
1020 }
1021
1022
1023 /**********************************************************************
1024 * WINPROC_CallProcWtoA
1025 *
1026 * Call a window procedure, translating args from Unicode to Ansi.
1027 */
1028 static LRESULT WINPROC_CallProcWtoA( winproc_callback_t callback, HWND hwnd, UINT msg, WPARAM wParam,
1029 LPARAM lParam, LRESULT *result, void *arg )
1030 {
1031 LRESULT ret = 0;
1032
1033 TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
1034 hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
1035
1036 switch(msg)
1037 {
1038 case WM_NCCREATE:
1039 case WM_CREATE:
1040 { /* csW->lpszName and csW->lpszClass are NOT supposed to be atoms
1041 * at this point.
1042 */
1043 char buffer[1024], *cls, *name;
1044 CREATESTRUCTW *csW = (CREATESTRUCTW *)lParam;
1045 CREATESTRUCTA csA = *(CREATESTRUCTA *)csW;
1046 MDICREATESTRUCTA mdi_cs;
1047 DWORD name_lenA, name_lenW, class_lenA, class_lenW;
1048
1049 class_lenW = strlenW(csW->lpszClass) * sizeof(WCHAR);
1050 RtlUnicodeToMultiByteSize(&class_lenA, csW->lpszClass, class_lenW);
1051
1052 if (csW->lpszName)
1053 {
1054 name_lenW = strlenW(csW->lpszName) * sizeof(WCHAR);
1055 RtlUnicodeToMultiByteSize(&name_lenA, csW->lpszName, name_lenW);
1056 }
1057 else
1058 name_lenW = name_lenA = 0;
1059
1060 if (!(cls = get_buffer( buffer, sizeof(buffer), class_lenA + name_lenA + 2 ))) break;
1061
1062 RtlUnicodeToMultiByteN(cls, class_lenA, NULL, csW->lpszClass, class_lenW);
1063 cls[class_lenA] = 0;
1064 csA.lpszClass = cls;
1065
1066 if (csW->lpszName)
1067 {
1068 name = cls + class_lenA + 1;
1069 RtlUnicodeToMultiByteN(name, name_lenA, NULL, csW->lpszName, name_lenW);
1070 name[name_lenA] = 0;
1071 csA.lpszName = name;
1072 }
1073
1074 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
1075 {
1076 mdi_cs = *(MDICREATESTRUCTA *)csW->lpCreateParams;
1077 mdi_cs.szTitle = csA.lpszName;
1078 mdi_cs.szClass = csA.lpszClass;
1079 csA.lpCreateParams = &mdi_cs;
1080 }
1081
1082 ret = callback( hwnd, msg, wParam, (LPARAM)&csA, result, arg );
1083 free_buffer( buffer, cls );
1084 }
1085 break;
1086
1087 case WM_GETTEXT:
1088 case WM_ASKCBFORMATNAME:
1089 {
1090 char *ptr, buffer[512];
1091 DWORD len = wParam * 2;
1092
1093 if (!(ptr = get_buffer( buffer, sizeof(buffer), len ))) break;
1094 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
1095 if (len)
1096 {
1097 if (*result)
1098 {
1099 RtlMultiByteToUnicodeN( (LPWSTR)lParam, wParam*sizeof(WCHAR), &len, ptr, strlen(ptr)+1 );
1100 *result = len/sizeof(WCHAR) - 1; /* do not count terminating null */
1101 }
1102 ((LPWSTR)lParam)[*result] = 0;
1103 }
1104 free_buffer( buffer, ptr );
1105 }
1106 break;
1107
1108 case LB_ADDSTRING:
1109 case LB_INSERTSTRING:
1110 case LB_FINDSTRING:
1111 case LB_FINDSTRINGEXACT:
1112 case LB_SELECTSTRING:
1113 case CB_ADDSTRING:
1114 case CB_INSERTSTRING:
1115 case CB_FINDSTRING:
1116 case CB_FINDSTRINGEXACT:
1117 case CB_SELECTSTRING:
1118 if (!lParam || !WINPROC_TestLBForStr( hwnd, msg ))
1119 {
1120 ret = callback( hwnd, msg, wParam, lParam, result, arg );
1121 break;
1122 }
1123 /* fall through */
1124 case WM_SETTEXT:
1125 case WM_WININICHANGE:
1126 case WM_DEVMODECHANGE:
1127 case CB_DIR:
1128 case LB_DIR:
1129 case LB_ADDFILE:
1130 case EM_REPLACESEL:
1131 if (!lParam) ret = callback( hwnd, msg, wParam, lParam, result, arg );
1132 else
1133 {
1134 char *ptr, buffer[512];
1135 LPCWSTR strW = (LPCWSTR)lParam;
1136 DWORD lenA, lenW = (strlenW(strW) + 1) * sizeof(WCHAR);
1137
1138 RtlUnicodeToMultiByteSize( &lenA, strW, lenW );
1139 if ((ptr = get_buffer( buffer, sizeof(buffer), lenA )))
1140 {
1141 RtlUnicodeToMultiByteN( ptr, lenA, NULL, strW, lenW );
1142 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
1143 free_buffer( buffer, ptr );
1144 }
1145 }
1146 break;
1147
1148 case WM_MDICREATE:
1149 {
1150 char *ptr, buffer[1024];
1151 DWORD title_lenA = 0, title_lenW = 0, class_lenA = 0, class_lenW = 0;
1152 MDICREATESTRUCTW *csW = (MDICREATESTRUCTW *)lParam;
1153 MDICREATESTRUCTA csA;
1154
1155 memcpy( &csA, csW, sizeof(csA) );
1156
1157 if (HIWORD(csW->szTitle))
1158 {
1159 title_lenW = (strlenW(csW->szTitle) + 1) * sizeof(WCHAR);
1160 RtlUnicodeToMultiByteSize( &title_lenA, csW->szTitle, title_lenW );
1161 }
1162 if (HIWORD(csW->szClass))
1163 {
1164 class_lenW = (strlenW(csW->szClass) + 1) * sizeof(WCHAR);
1165 RtlUnicodeToMultiByteSize( &class_lenA, csW->szClass, class_lenW );
1166 }
1167
1168 if (!(ptr = get_buffer( buffer, sizeof(buffer), title_lenA + class_lenA ))) break;
1169
1170 if (title_lenA)
1171 {
1172 RtlUnicodeToMultiByteN( ptr, title_lenA, NULL, csW->szTitle, title_lenW );
1173 csA.szTitle = ptr;
1174 }
1175 if (class_lenA)
1176 {
1177 RtlUnicodeToMultiByteN( ptr + title_lenA, class_lenA, NULL, csW->szClass, class_lenW );
1178 csA.szClass = ptr + title_lenA;
1179 }
1180 ret = callback( hwnd, msg, wParam, (LPARAM)&csA, result, arg );
1181 free_buffer( buffer, ptr );
1182 }
1183 break;
1184
1185 case LB_GETTEXT:
1186 case CB_GETLBTEXT:
1187 if (lParam && WINPROC_TestLBForStr( hwnd, msg ))
1188 {
1189 char buffer[512]; /* FIXME: fixed sized buffer */
1190
1191 ret = callback( hwnd, msg, wParam, (LPARAM)buffer, result, arg );
1192 if (*result >= 0)
1193 {
1194 DWORD len;
1195 RtlMultiByteToUnicodeN( (LPWSTR)lParam, ~0u, &len, buffer, strlen(buffer) + 1 );
1196 *result = len / sizeof(WCHAR) - 1;
1197 }
1198 }
1199 else ret = callback( hwnd, msg, wParam, lParam, result, arg );
1200 break;
1201
1202 case EM_GETLINE:
1203 {
1204 char *ptr, buffer[512];
1205 WORD len = *(WORD *)lParam;
1206
1207 if (!(ptr = get_buffer( buffer, sizeof(buffer), len * 2 ))) break;
1208 *((WORD *)ptr) = len * 2; /* store the length */
1209 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
1210 if (*result)
1211 {
1212 DWORD reslen;
1213 RtlMultiByteToUnicodeN( (LPWSTR)lParam, len*sizeof(WCHAR), &reslen, ptr, *result );
1214 *result = reslen / sizeof(WCHAR);
1215 if (*result < len) ((LPWSTR)lParam)[*result] = 0;
1216 }
1217 free_buffer( buffer, ptr );
1218 }
1219 break;
1220
1221 case WM_GETDLGCODE:
1222 if (lParam)
1223 {
1224 MSG newmsg = *(MSG *)lParam;
1225 switch(newmsg.message)
1226 {
1227 case WM_CHAR:
1228 case WM_DEADCHAR:
1229 case WM_SYSCHAR:
1230 case WM_SYSDEADCHAR:
1231 newmsg.wParam = map_wparam_char_WtoA( newmsg.wParam, 1 );
1232 break;
1233 case WM_IME_CHAR:
1234 newmsg.wParam = map_wparam_char_WtoA( newmsg.wParam, 2 );
1235 break;
1236 }
1237 ret = callback( hwnd, msg, wParam, (LPARAM)&newmsg, result, arg );
1238 }
1239 else ret = callback( hwnd, msg, wParam, lParam, result, arg );
1240 break;
1241
1242 case WM_CHARTOITEM:
1243 case WM_MENUCHAR:
1244 case WM_CHAR:
1245 case WM_DEADCHAR:
1246 case WM_SYSCHAR:
1247 case WM_SYSDEADCHAR:
1248 case EM_SETPASSWORDCHAR:
1249 ret = callback( hwnd, msg, map_wparam_char_WtoA(wParam,1), lParam, result, arg );
1250 break;
1251
1252 case WM_IME_CHAR:
1253 ret = callback( hwnd, msg, map_wparam_char_WtoA(wParam,2), lParam, result, arg );
1254 break;
1255
1256 case WM_PAINTCLIPBOARD:
1257 case WM_SIZECLIPBOARD:
1258 FIXME_(msg)( "message %s (%04x) needs translation, please report\n",
1259 SPY_GetMsgName(msg, hwnd), msg );
1260 break;
1261
1262 default:
1263 ret = callback( hwnd, msg, wParam, lParam, result, arg );
1264 break;
1265 }
1266
1267 return ret;
1268 }
1269
1270
1271 /**********************************************************************
1272 * WINPROC_CallProc16To32A
1273 */
1274 LRESULT WINPROC_CallProc16To32A( winproc_callback_t callback, HWND16 hwnd, UINT16 msg,
1275 WPARAM16 wParam, LPARAM lParam, LRESULT *result, void *arg )
1276 {
1277 LRESULT ret = 0;
1278 HWND hwnd32 = WIN_Handle32( hwnd );
1279
1280 TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
1281 hwnd32, SPY_GetMsgName(msg, hwnd32), wParam, lParam);
1282
1283 switch(msg)
1284 {
1285 case WM_NCCREATE:
1286 case WM_CREATE:
1287 {
1288 CREATESTRUCT16 *cs16 = MapSL(lParam);
1289 CREATESTRUCTA cs;
1290 MDICREATESTRUCTA mdi_cs;
1291
1292 CREATESTRUCT16to32A( cs16, &cs );
1293 if (GetWindowLongW(hwnd32, GWL_EXSTYLE) & WS_EX_MDICHILD)
1294 {
1295 MDICREATESTRUCT16 *mdi_cs16 = MapSL(cs16->lpCreateParams);
1296 MDICREATESTRUCT16to32A(mdi_cs16, &mdi_cs);
1297 cs.lpCreateParams = &mdi_cs;
1298 }
1299 ret = callback( hwnd32, msg, wParam, (LPARAM)&cs, result, arg );
1300 CREATESTRUCT32Ato16( &cs, cs16 );
1301 }
1302 break;
1303 case WM_MDICREATE:
1304 {
1305 MDICREATESTRUCT16 *cs16 = MapSL(lParam);
1306 MDICREATESTRUCTA cs;
1307
1308 MDICREATESTRUCT16to32A( cs16, &cs );
1309 ret = callback( hwnd32, msg, wParam, (LPARAM)&cs, result, arg );
1310 MDICREATESTRUCT32Ato16( &cs, cs16 );
1311 }
1312 break;
1313 case WM_MDIACTIVATE:
1314 if (lParam)
1315 ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32( HIWORD(lParam) ),
1316 (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
1317 else /* message sent to MDI client */
1318 ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1319 break;
1320 case WM_MDIGETACTIVE:
1321 {
1322 BOOL maximized = FALSE;
1323 ret = callback( hwnd32, msg, wParam, (LPARAM)&maximized, result, arg );
1324 *result = MAKELRESULT( LOWORD(*result), maximized );
1325 }
1326 break;
1327 case WM_MDISETMENU:
1328 ret = callback( hwnd32, wParam ? WM_MDIREFRESHMENU : WM_MDISETMENU,
1329 (WPARAM)HMENU_32(LOWORD(lParam)), (LPARAM)HMENU_32(HIWORD(lParam)),
1330 result, arg );
1331 break;
1332 case WM_GETMINMAXINFO:
1333 {
1334 MINMAXINFO16 *mmi16 = MapSL(lParam);
1335 MINMAXINFO mmi;
1336
1337 MINMAXINFO16to32( mmi16, &mmi );
1338 ret = callback( hwnd32, msg, wParam, (LPARAM)&mmi, result, arg );
1339 MINMAXINFO32to16( &mmi, mmi16 );
1340 }
1341 break;
1342 case WM_WINDOWPOSCHANGING:
1343 case WM_WINDOWPOSCHANGED:
1344 {
1345 WINDOWPOS16 *winpos16 = MapSL(lParam);
1346 WINDOWPOS winpos;
1347
1348 WINDOWPOS16to32( winpos16, &winpos );
1349 ret = callback( hwnd32, msg, wParam, (LPARAM)&winpos, result, arg );
1350 WINDOWPOS32to16( &winpos, winpos16 );
1351 }
1352 break;
1353 case WM_NCCALCSIZE:
1354 {
1355 NCCALCSIZE_PARAMS16 *nc16 = MapSL(lParam);
1356 NCCALCSIZE_PARAMS nc;
1357 WINDOWPOS winpos;
1358
1359 RECT16to32( &nc16->rgrc[0], &nc.rgrc[0] );
1360 if (wParam)
1361 {
1362 RECT16to32( &nc16->rgrc[1], &nc.rgrc[1] );
1363 RECT16to32( &nc16->rgrc[2], &nc.rgrc[2] );
1364 WINDOWPOS16to32( MapSL(nc16->lppos), &winpos );
1365 nc.lppos = &winpos;
1366 }
1367 ret = callback( hwnd32, msg, wParam, (LPARAM)&nc, result, arg );
1368 RECT32to16( &nc.rgrc[0], &nc16->rgrc[0] );
1369 if (wParam)
1370 {
1371 RECT32to16( &nc.rgrc[1], &nc16->rgrc[1] );
1372 RECT32to16( &nc.rgrc[2], &nc16->rgrc[2] );
1373 WINDOWPOS32to16( &winpos, MapSL(nc16->lppos) );
1374 }
1375 }
1376 break;
1377 case WM_COMPAREITEM:
1378 {
1379 COMPAREITEMSTRUCT16* cis16 = MapSL(lParam);
1380 COMPAREITEMSTRUCT cis;
1381 cis.CtlType = cis16->CtlType;
1382 cis.CtlID = cis16->CtlID;
1383 cis.hwndItem = WIN_Handle32( cis16->hwndItem );
1384 cis.itemID1 = cis16->itemID1;
1385 cis.itemData1 = cis16->itemData1;
1386 cis.itemID2 = cis16->itemID2;
1387 cis.itemData2 = cis16->itemData2;
1388 cis.dwLocaleId = 0; /* FIXME */
1389 ret = callback( hwnd32, msg, wParam, (LPARAM)&cis, result, arg );
1390 }
1391 break;
1392 case WM_DELETEITEM:
1393 {
1394 DELETEITEMSTRUCT16* dis16 = MapSL(lParam);
1395 DELETEITEMSTRUCT dis;
1396 dis.CtlType = dis16->CtlType;
1397 dis.CtlID = dis16->CtlID;
1398 dis.hwndItem = WIN_Handle32( dis16->hwndItem );
1399 dis.itemData = dis16->itemData;
1400 ret = callback( hwnd32, msg, wParam, (LPARAM)&dis, result, arg );
1401 }
1402 break;
1403 case WM_MEASUREITEM:
1404 {
1405 MEASUREITEMSTRUCT16* mis16 = MapSL(lParam);
1406 MEASUREITEMSTRUCT mis;
1407 mis.CtlType = mis16->CtlType;
1408 mis.CtlID = mis16->CtlID;
1409 mis.itemID = mis16->itemID;
1410 mis.itemWidth = mis16->itemWidth;
1411 mis.itemHeight = mis16->itemHeight;
1412 mis.itemData = mis16->itemData;
1413 ret = callback( hwnd32, msg, wParam, (LPARAM)&mis, result, arg );
1414 mis16->itemWidth = (UINT16)mis.itemWidth;
1415 mis16->itemHeight = (UINT16)mis.itemHeight;
1416 }
1417 break;
1418 case WM_DRAWITEM:
1419 {
1420 DRAWITEMSTRUCT16* dis16 = MapSL(lParam);
1421 DRAWITEMSTRUCT dis;
1422 dis.CtlType = dis16->CtlType;
1423 dis.CtlID = dis16->CtlID;
1424 dis.itemID = dis16->itemID;
1425 dis.itemAction = dis16->itemAction;
1426 dis.itemState = dis16->itemState;
1427 dis.hwndItem = (dis.CtlType == ODT_MENU) ? (HWND)HMENU_32(dis16->hwndItem)
1428 : WIN_Handle32( dis16->hwndItem );
1429 dis.hDC = HDC_32(dis16->hDC);
1430 dis.itemData = dis16->itemData;
1431 dis.rcItem.left = dis16->rcItem.left;
1432 dis.rcItem.top = dis16->rcItem.top;
1433 dis.rcItem.right = dis16->rcItem.right;
1434 dis.rcItem.bottom = dis16->rcItem.bottom;
1435 ret = callback( hwnd32, msg, wParam, (LPARAM)&dis, result, arg );
1436 }
1437 break;
1438 case WM_COPYDATA:
1439 {
1440 COPYDATASTRUCT16 *cds16 = MapSL(lParam);
1441 COPYDATASTRUCT cds;
1442 cds.dwData = cds16->dwData;
1443 cds.cbData = cds16->cbData;
1444 cds.lpData = MapSL(cds16->lpData);
1445 ret = callback( hwnd32, msg, wParam, (LPARAM)&cds, result, arg );
1446 }
1447 break;
1448 case WM_GETDLGCODE:
1449 if (lParam)
1450 {
1451 MSG16 *msg16 = MapSL(lParam);
1452 MSG msg32;
1453 msg32.hwnd = WIN_Handle32( msg16->hwnd );
1454 msg32.message = msg16->message;
1455 msg32.wParam = msg16->wParam;
1456 msg32.lParam = msg16->lParam;
1457 msg32.time = msg16->time;
1458 msg32.pt.x = msg16->pt.x;
1459 msg32.pt.y = msg16->pt.y;
1460 ret = callback( hwnd32, msg, wParam, (LPARAM)&msg32, result, arg );
1461 }
1462 else
1463 ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1464 break;
1465 case WM_NEXTMENU:
1466 {
1467 MDINEXTMENU next;
1468 next.hmenuIn = (HMENU)lParam;
1469 next.hmenuNext = 0;
1470 next.hwndNext = 0;
1471 ret = callback( hwnd32, msg, wParam, (LPARAM)&next, result, arg );
1472 *result = MAKELONG( HMENU_16(next.hmenuNext), HWND_16(next.hwndNext) );
1473 }
1474 break;
1475 case WM_ACTIVATE:
1476 case WM_CHARTOITEM:
1477 case WM_COMMAND:
1478 case WM_VKEYTOITEM:
1479 ret = callback( hwnd32, msg, MAKEWPARAM( wParam, HIWORD(lParam) ),
1480 (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
1481 break;
1482 case WM_HSCROLL:
1483 case WM_VSCROLL:
1484 ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
1485 (LPARAM)WIN_Handle32( HIWORD(lParam) ), result, arg );
1486 break;
1487 case WM_CTLCOLOR:
1488 if (HIWORD(lParam) <= CTLCOLOR_STATIC)
1489 ret = callback( hwnd32, WM_CTLCOLORMSGBOX + HIWORD(lParam),
1490 (WPARAM)HDC_32(wParam), (LPARAM)WIN_Handle32( LOWORD(lParam) ),
1491 result, arg );
1492 break;
1493 case WM_GETTEXT:
1494 case WM_SETTEXT:
1495 case WM_WININICHANGE:
1496 case WM_DEVMODECHANGE:
1497 case WM_ASKCBFORMATNAME:
1498 case WM_NOTIFY:
1499 ret = callback( hwnd32, msg, wParam, (LPARAM)MapSL(lParam), result, arg );
1500 break;
1501 case WM_MENUCHAR:
1502 ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
1503 (LPARAM)HMENU_32(HIWORD(lParam)), result, arg );
1504 break;
1505 case WM_MENUSELECT:
1506 if((LOWORD(lParam) & MF_POPUP) && (LOWORD(lParam) != 0xFFFF))
1507 {
1508 HMENU hmenu = HMENU_32(HIWORD(lParam));
1509 UINT pos = MENU_FindSubMenu( &hmenu, HMENU_32(wParam) );
1510 if (pos == 0xffff) pos = 0; /* NO_SELECTED_ITEM */
1511 wParam = pos;
1512 }
1513 ret = callback( hwnd32, msg, MAKEWPARAM( wParam, LOWORD(lParam) ),
1514 (LPARAM)HMENU_32(HIWORD(lParam)), result, arg );
1515 break;
1516 case WM_PARENTNOTIFY:
1517 if ((wParam == WM_CREATE) || (wParam == WM_DESTROY))
1518 ret = callback( hwnd32, msg, MAKEWPARAM( wParam, HIWORD(lParam) ),
1519 (LPARAM)WIN_Handle32( LOWORD(lParam) ), result, arg );
1520 else
1521 ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1522 break;
1523 case WM_ACTIVATEAPP:
1524 /* We need this when SetActiveWindow sends a Sendmessage16() to
1525 * a 32bit window. Might be superflous with 32bit interprocess
1526 * message queues. */
1527 if (lParam) lParam = HTASK_32(lParam);
1528 ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1529 break;
1530 case WM_DDE_INITIATE:
1531 case WM_DDE_TERMINATE:
1532 case WM_DDE_UNADVISE:
1533 case WM_DDE_REQUEST:
1534 ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
1535 break;
1536 case WM_DDE_ADVISE:
1537 case WM_DDE_DATA:
1538 case WM_DDE_POKE:
1539 {
1540 HANDLE16 lo16 = LOWORD(lParam);
1541 UINT_PTR lo32 = 0;
1542 if (lo16 && !(lo32 = convert_handle_16_to_32(lo16, GMEM_DDESHARE))) break;
1543 lParam = PackDDElParam( msg, lo32, HIWORD(lParam) );
1544 ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
1545 }
1546 break; /* FIXME don't know how to free allocated memory (handle) !! */
1547 case WM_DDE_ACK:
1548 {
1549 UINT_PTR lo = LOWORD(lParam);
1550 UINT_PTR hi = HIWORD(lParam);
1551 int flag = 0;
1552 char buf[2];
1553
1554 if (GlobalGetAtomNameA(hi, buf, 2) > 0) flag |= 1;
1555 if (GlobalSize16(hi) != 0) flag |= 2;
1556 switch (flag)
1557 {
1558 case 0:
1559 if (hi)
1560 {
1561 MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
1562 hi = 0;
1563 }
1564 break;
1565 case 1:
1566 break; /* atom, nothing to do */
1567 case 3:
1568 MESSAGE("DDE_ACK: %lx both atom and handle... choosing handle\n", hi);
1569 /* fall thru */
1570 case 2:
1571 hi = convert_handle_16_to_32(hi, GMEM_DDESHARE);
1572 break;
1573 }
1574 lParam = PackDDElParam( WM_DDE_ACK, lo, hi );
1575 ret = callback( hwnd32, msg, (WPARAM)WIN_Handle32(wParam), lParam, result, arg );
1576 }
1577 break; /* FIXME don't know how to free allocated memory (handle) !! */
1578 case WM_DDE_EXECUTE:
1579 lParam = convert_handle_16_to_32( lParam, GMEM_DDESHARE );
1580 ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1581 break; /* FIXME don't know how to free allocated memory (handle) !! */
1582 case WM_PAINTCLIPBOARD:
1583 case WM_SIZECLIPBOARD:
1584 FIXME_(msg)( "message %04x needs translation\n", msg );
1585 break;
1586 default:
1587 ret = callback( hwnd32, msg, wParam, lParam, result, arg );
1588 break;
1589 }
1590 return ret;
1591 }
1592
1593
1594 /**********************************************************************
1595 * __wine_call_wndproc (USER.1010)
1596 */
1597 LRESULT WINAPI __wine_call_wndproc( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
1598 WINDOWPROC *proc )
1599 {
1600 LRESULT result;
1601
1602 if (proc->procA)
1603 WINPROC_CallProc16To32A( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
1604 else
1605 WINPROC_CallProc16To32A( call_window_proc_AtoW, hwnd, msg, wParam, lParam, &result, proc->procW );
1606 return result;
1607 }
1608
1609
1610 /**********************************************************************
1611 * WINPROC_CallProc32ATo16
1612 *
1613 * Call a 16-bit window procedure, translating the 32-bit args.
1614 */
1615 LRESULT WINPROC_CallProc32ATo16( winproc_callback16_t callback, HWND hwnd, UINT msg,
1616 WPARAM wParam, LPARAM lParam, LRESULT *result, void *arg )
1617 {
1618 LRESULT ret = 0;
1619
1620 TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
1621 hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
1622
1623 switch(msg)
1624 {
1625 case WM_NCCREATE:
1626 case WM_CREATE:
1627 {
1628 CREATESTRUCTA *cs32 = (CREATESTRUCTA *)lParam;
1629 CREATESTRUCT16 cs;
1630 MDICREATESTRUCT16 mdi_cs16;
1631 BOOL mdi_child = (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD);
1632
1633 CREATESTRUCT32Ato16( cs32, &cs );
1634 cs.lpszName = MapLS( cs32->lpszName );
1635 cs.lpszClass = MapLS( cs32->lpszClass );
1636
1637 if (mdi_child)
1638 {
1639 MDICREATESTRUCTA *mdi_cs = (MDICREATESTRUCTA *)cs32->lpCreateParams;
1640 MDICREATESTRUCT32Ato16( mdi_cs, &mdi_cs16 );
1641 mdi_cs16.szTitle = MapLS( mdi_cs->szTitle );
1642 mdi_cs16.szClass = MapLS( mdi_cs->szClass );
1643 cs.lpCreateParams = MapLS( &mdi_cs16 );
1644 }
1645 lParam = MapLS( &cs );
1646 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1647 UnMapLS( lParam );
1648 UnMapLS( cs.lpszName );
1649 UnMapLS( cs.lpszClass );
1650 if (mdi_child)
1651 {
1652 UnMapLS( cs.lpCreateParams );
1653 UnMapLS( mdi_cs16.szTitle );
1654 UnMapLS( mdi_cs16.szClass );
1655 }
1656 }
1657 break;
1658 case WM_MDICREATE:
1659 {
1660 MDICREATESTRUCTA *cs32 = (MDICREATESTRUCTA *)lParam;
1661 MDICREATESTRUCT16 cs;
1662
1663 MDICREATESTRUCT32Ato16( cs32, &cs );
1664 cs.szTitle = MapLS( cs32->szTitle );
1665 cs.szClass = MapLS( cs32->szClass );
1666 lParam = MapLS( &cs );
1667 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1668 UnMapLS( lParam );
1669 UnMapLS( cs.szTitle );
1670 UnMapLS( cs.szClass );
1671 }
1672 break;
1673 case WM_MDIACTIVATE:
1674 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_MDICHILD)
1675 ret = callback( HWND_16(hwnd), msg, ((HWND)lParam == hwnd),
1676 MAKELPARAM( LOWORD(lParam), LOWORD(wParam) ), result, arg );
1677 else
1678 ret = callback( HWND_16(hwnd), msg, HWND_16( (HWND)wParam ), 0, result, arg );
1679 break;
1680 case WM_MDIGETACTIVE:
1681 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1682 if (lParam) *(BOOL *)lParam = (BOOL16)HIWORD(*result);
1683 *result = (LRESULT)WIN_Handle32( LOWORD(*result) );
1684 break;
1685 case WM_MDISETMENU:
1686 ret = callback( HWND_16(hwnd), msg, (lParam == 0),
1687 MAKELPARAM( LOWORD(wParam), LOWORD(lParam) ), result, arg );
1688 break;
1689 case WM_GETMINMAXINFO:
1690 {
1691 MINMAXINFO *mmi32 = (MINMAXINFO *)lParam;
1692 MINMAXINFO16 mmi;
1693
1694 MINMAXINFO32to16( mmi32, &mmi );
1695 lParam = MapLS( &mmi );
1696 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1697 UnMapLS( lParam );
1698 MINMAXINFO16to32( &mmi, mmi32 );
1699 }
1700 break;
1701 case WM_NCCALCSIZE:
1702 {
1703 NCCALCSIZE_PARAMS *nc32 = (NCCALCSIZE_PARAMS *)lParam;
1704 NCCALCSIZE_PARAMS16 nc;
1705 WINDOWPOS16 winpos;
1706
1707 RECT32to16( &nc32->rgrc[0], &nc.rgrc[0] );
1708 if (wParam)
1709 {
1710 RECT32to16( &nc32->rgrc[1], &nc.rgrc[1] );
1711 RECT32to16( &nc32->rgrc[2], &nc.rgrc[2] );
1712 WINDOWPOS32to16( nc32->lppos, &winpos );
1713 nc.lppos = MapLS( &winpos );
1714 }
1715 lParam = MapLS( &nc );
1716 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1717 UnMapLS( lParam );
1718 RECT16to32( &nc.rgrc[0], &nc32->rgrc[0] );
1719 if (wParam)
1720 {
1721 RECT16to32( &nc.rgrc[1], &nc32->rgrc[1] );
1722 RECT16to32( &nc.rgrc[2], &nc32->rgrc[2] );
1723 WINDOWPOS16to32( &winpos, nc32->lppos );
1724 UnMapLS( nc.lppos );
1725 }
1726 }
1727 break;
1728 case WM_WINDOWPOSCHANGING:
1729 case WM_WINDOWPOSCHANGED:
1730 {
1731 WINDOWPOS *winpos32 = (WINDOWPOS *)lParam;
1732 WINDOWPOS16 winpos;
1733
1734 WINDOWPOS32to16( winpos32, &winpos );
1735 lParam = MapLS( &winpos );
1736 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1737 UnMapLS( lParam );
1738 WINDOWPOS16to32( &winpos, winpos32 );
1739 }
1740 break;
1741 case WM_COMPAREITEM:
1742 {
1743 COMPAREITEMSTRUCT *cis32 = (COMPAREITEMSTRUCT *)lParam;
1744 COMPAREITEMSTRUCT16 cis;
1745 cis.CtlType = cis32->CtlType;
1746 cis.CtlID = cis32->CtlID;
1747 cis.hwndItem = HWND_16( cis32->hwndItem );
1748 cis.itemID1 = cis32->itemID1;
1749 cis.itemData1 = cis32->itemData1;
1750 cis.itemID2 = cis32->itemID2;
1751 cis.itemData2 = cis32->itemData2;
1752 lParam = MapLS( &cis );
1753 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1754 UnMapLS( lParam );
1755 }
1756 break;
1757 case WM_DELETEITEM:
1758 {
1759 DELETEITEMSTRUCT *dis32 = (DELETEITEMSTRUCT *)lParam;
1760 DELETEITEMSTRUCT16 dis;
1761 dis.CtlType = dis32->CtlType;
1762 dis.CtlID = dis32->CtlID;
1763 dis.itemID = dis32->itemID;
1764 dis.hwndItem = (dis.CtlType == ODT_MENU) ? (HWND16)LOWORD(dis32->hwndItem)
1765 : HWND_16( dis32->hwndItem );
1766 dis.itemData = dis32->itemData;
1767 lParam = MapLS( &dis );
1768 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1769 UnMapLS( lParam );
1770 }
1771 break;
1772 case WM_DRAWITEM:
1773 {
1774 DRAWITEMSTRUCT *dis32 = (DRAWITEMSTRUCT *)lParam;
1775 DRAWITEMSTRUCT16 dis;
1776 dis.CtlType = dis32->CtlType;
1777 dis.CtlID = dis32->CtlID;
1778 dis.itemID = dis32->itemID;
1779 dis.itemAction = dis32->itemAction;
1780 dis.itemState = dis32->itemState;
1781 dis.hwndItem = HWND_16( dis32->hwndItem );
1782 dis.hDC = HDC_16(dis32->hDC);
1783 dis.itemData = dis32->itemData;
1784 dis.rcItem.left = dis32->rcItem.left;
1785 dis.rcItem.top = dis32->rcItem.top;
1786 dis.rcItem.right = dis32->rcItem.right;
1787 dis.rcItem.bottom = dis32->rcItem.bottom;
1788 lParam = MapLS( &dis );
1789 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1790 UnMapLS( lParam );
1791 }
1792 break;
1793 case WM_MEASUREITEM:
1794 {
1795 MEASUREITEMSTRUCT *mis32 = (MEASUREITEMSTRUCT *)lParam;
1796 MEASUREITEMSTRUCT16 mis;
1797 mis.CtlType = mis32->CtlType;
1798 mis.CtlID = mis32->CtlID;
1799 mis.itemID = mis32->itemID;
1800 mis.itemWidth = mis32->itemWidth;
1801 mis.itemHeight = mis32->itemHeight;
1802 mis.itemData = mis32->itemData;
1803 lParam = MapLS( &mis );
1804 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1805 UnMapLS( lParam );
1806 mis32->itemWidth = mis.itemWidth;
1807 mis32->itemHeight = mis.itemHeight;
1808 }
1809 break;
1810 case WM_COPYDATA:
1811 {
1812 COPYDATASTRUCT *cds32 = (COPYDATASTRUCT *)lParam;
1813 COPYDATASTRUCT16 cds;
1814
1815 cds.dwData = cds32->dwData;
1816 cds.cbData = cds32->cbData;
1817 cds.lpData = MapLS( cds32->lpData );
1818 lParam = MapLS( &cds );
1819 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1820 UnMapLS( lParam );
1821 UnMapLS( cds.lpData );
1822 }
1823 break;
1824 case WM_GETDLGCODE:
1825 if (lParam)
1826 {
1827 MSG *msg32 = (MSG *)lParam;
1828 MSG16 msg16;
1829
1830 msg16.hwnd = HWND_16( msg32->hwnd );
1831 msg16.message = msg32->message;
1832 msg16.wParam = msg32->wParam;
1833 msg16.lParam = msg32->lParam;
1834 msg16.time = msg32->time;
1835 msg16.pt.x = msg32->pt.x;
1836 msg16.pt.y = msg32->pt.y;
1837 lParam = MapLS( &msg16 );
1838 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1839 UnMapLS( lParam );
1840 }
1841 else
1842 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1843 break;
1844 case WM_NEXTMENU:
1845 {
1846 MDINEXTMENU *next = (MDINEXTMENU *)lParam;
1847 ret = callback( HWND_16(hwnd), msg, wParam, (LPARAM)next->hmenuIn, result, arg );
1848 next->hmenuNext = HMENU_32( LOWORD(*result) );
1849 next->hwndNext = WIN_Handle32( HIWORD(*result) );
1850 *result = 0;
1851 }
1852 break;
1853 case WM_GETTEXT:
1854 case WM_ASKCBFORMATNAME:
1855 wParam = min( wParam, 0xff80 ); /* Must be < 64K */
1856 /* fall through */
1857 case WM_NOTIFY:
1858 case WM_SETTEXT:
1859 case WM_WININICHANGE:
1860 case WM_DEVMODECHANGE:
1861 lParam = MapLS( (void *)lParam );
1862 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1863 UnMapLS( lParam );
1864 break;
1865 case WM_ACTIVATE:
1866 case WM_CHARTOITEM:
1867 case WM_COMMAND:
1868 case WM_VKEYTOITEM:
1869 ret = callback( HWND_16(hwnd), msg, wParam, MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ),
1870 result, arg );
1871 break;
1872 case WM_HSCROLL:
1873 case WM_VSCROLL:
1874 ret = callback( HWND_16(hwnd), msg, wParam, MAKELPARAM( HIWORD(wParam), (HWND16)lParam ),
1875 result, arg );
1876 break;
1877 case WM_CTLCOLORMSGBOX:
1878 case WM_CTLCOLOREDIT:
1879 case WM_CTLCOLORLISTBOX:
1880 case WM_CTLCOLORBTN:
1881 case WM_CTLCOLORDLG:
1882 case WM_CTLCOLORSCROLLBAR:
1883 case WM_CTLCOLORSTATIC:
1884 ret = callback( HWND_16(hwnd), WM_CTLCOLOR, wParam,
1885 MAKELPARAM( (HWND16)lParam, msg - WM_CTLCOLORMSGBOX ), result, arg );
1886 break;
1887 case WM_MENUSELECT:
1888 if(HIWORD(wParam) & MF_POPUP)
1889 {
1890 HMENU hmenu;
1891 if ((HIWORD(wParam) != 0xffff) || lParam)
1892 {
1893 if ((hmenu = GetSubMenu( (HMENU)lParam, LOWORD(wParam) )))
1894 {
1895 ret = callback( HWND_16(hwnd), msg, HMENU_16(hmenu),
1896 MAKELPARAM( HIWORD(wParam), (HMENU16)lParam ), result, arg );
1897 break;
1898 }
1899 }
1900 }
1901 /* fall through */
1902 case WM_MENUCHAR:
1903 ret = callback( HWND_16(hwnd), msg, wParam,
1904 MAKELPARAM( HIWORD(wParam), (HMENU16)lParam ), result, arg );
1905 break;
1906 case WM_PARENTNOTIFY:
1907 if ((LOWORD(wParam) == WM_CREATE) || (LOWORD(wParam) == WM_DESTROY))
1908 ret = callback( HWND_16(hwnd), msg, wParam,
1909 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ), result, arg );
1910 else
1911 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1912 break;
1913 case WM_ACTIVATEAPP:
1914 ret = callback( HWND_16(hwnd), msg, wParam, HTASK_16( (HANDLE)lParam ), result, arg );
1915 break;
1916 case WM_PAINT:
1917 if (IsIconic( hwnd ) && GetClassLongPtrW( hwnd, GCLP_HICON ))
1918 ret = callback( HWND_16(hwnd), WM_PAINTICON, 1, lParam, result, arg );
1919 else
1920 ret = callback( HWND_16(hwnd), WM_PAINT, wParam, lParam, result, arg );
1921 break;
1922 case WM_ERASEBKGND:
1923 if (IsIconic( hwnd ) && GetClassLongPtrW( hwnd, GCLP_HICON )) msg = WM_ICONERASEBKGND;
1924 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1925 break;
1926 case WM_DDE_INITIATE:
1927 case WM_DDE_TERMINATE:
1928 case WM_DDE_UNADVISE:
1929 case WM_DDE_REQUEST:
1930 ret = callback( HWND_16(hwnd), msg, HWND_16((HWND)wParam), lParam, result, arg );
1931 break;
1932 case WM_DDE_ADVISE:
1933 case WM_DDE_DATA:
1934 case WM_DDE_POKE:
1935 {
1936 UINT_PTR lo32, hi;
1937 HANDLE16 lo16 = 0;
1938
1939 UnpackDDElParam( msg, lParam, &lo32, &hi );
1940 if (lo32 && !(lo16 = convert_handle_32_to_16(lo32, GMEM_DDESHARE))) break;
1941 ret = callback( HWND_16(hwnd), msg, HWND_16((HWND)wParam),
1942 MAKELPARAM(lo16, hi), result, arg );
1943 }
1944 break; /* FIXME don't know how to free allocated memory (handle) !! */
1945 case WM_DDE_ACK:
1946 {
1947 UINT_PTR lo, hi;
1948 int flag = 0;
1949 char buf[2];
1950
1951 UnpackDDElParam( msg, lParam, &lo, &hi );
1952
1953 if (GlobalGetAtomNameA((ATOM)hi, buf, sizeof(buf)) > 0) flag |= 1;
1954 if (GlobalSize((HANDLE)hi) != 0) flag |= 2;
1955 switch (flag)
1956 {
1957 case 0:
1958 if (hi)
1959 {
1960 MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
1961 hi = 0;
1962 }
1963 break;
1964 case 1:
1965 break; /* atom, nothing to do */
1966 case 3:
1967 MESSAGE("DDE_ACK: %lx both atom and handle... choosing handle\n", hi);
1968 /* fall thru */
1969 case 2:
1970 hi = convert_handle_32_to_16(hi, GMEM_DDESHARE);
1971 break;
1972 }
1973 ret = callback( HWND_16(hwnd), msg, HWND_16((HWND)wParam),
1974 MAKELPARAM(lo, hi), result, arg );
1975 }
1976 break; /* FIXME don't know how to free allocated memory (handle) !! */
1977 case WM_DDE_EXECUTE:
1978 lParam = convert_handle_32_to_16(lParam, GMEM_DDESHARE);
1979 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
1980 break; /* FIXME don't know how to free allocated memory (handle) !! */
1981 case SBM_SETRANGE:
1982 ret = callback( HWND_16(hwnd), SBM_SETRANGE16, 0, MAKELPARAM(wParam, lParam), result, arg );
1983 break;
1984 case SBM_GETRANGE:
1985 ret = callback( HWND_16(hwnd), SBM_GETRANGE16, wParam, lParam, result, arg );
1986 *(LPINT)wParam = LOWORD(*result);
1987 *(LPINT)lParam = HIWORD(*result);
1988 break;
1989 case BM_GETCHECK:
1990 case BM_SETCHECK:
1991 case BM_GETSTATE:
1992 case BM_SETSTATE:
1993 case BM_SETSTYLE:
1994 ret = callback( HWND_16(hwnd), msg + BM_GETCHECK16 - BM_GETCHECK, wParam, lParam, result, arg );
1995 break;
1996 case EM_GETSEL:
1997 case EM_GETRECT:
1998 case EM_SETRECT:
1999 case EM_SETRECTNP:
2000 case EM_SCROLL:
2001 case EM_LINESCROLL:
2002 case EM_SCROLLCARET:
2003 case EM_GETMODIFY:
2004 case EM_SETMODIFY:
2005 case EM_GETLINECOUNT:
2006 case EM_LINEINDEX:
2007 case EM_SETHANDLE:
2008 case EM_GETHANDLE:
2009 case EM_GETTHUMB:
2010 case EM_LINELENGTH:
2011 case EM_REPLACESEL:
2012 case EM_GETLINE:
2013 case EM_LIMITTEXT:
2014 case EM_CANUNDO:
2015 case EM_UNDO:
2016 case EM_FMTLINES:
2017 case EM_LINEFROMCHAR:
2018 case EM_SETTABSTOPS:
2019 case EM_SETPASSWORDCHAR:
2020 case EM_EMPTYUNDOBUFFER:
2021 case EM_GETFIRSTVISIBLELINE:
2022 case EM_SETREADONLY:
2023 case EM_SETWORDBREAKPROC:
2024 case EM_GETWORDBREAKPROC:
2025 case EM_GETPASSWORDCHAR:
2026 ret = callback( HWND_16(hwnd), msg + EM_GETSEL16 - EM_GETSEL, wParam, lParam, result, arg );
2027 break;
2028 case EM_SETSEL:
2029 ret = callback( HWND_16(hwnd), EM_SETSEL16, 0, MAKELPARAM( wParam, lParam ), result, arg );
2030 break;
2031 case LB_CARETOFF:
2032 case LB_CARETON:
2033 case LB_DELETESTRING:
2034 case LB_GETANCHORINDEX:
2035 case LB_GETCARETINDEX:
2036 case LB_GETCOUNT:
2037 case LB_GETCURSEL:
2038 case LB_GETHORIZONTALEXTENT:
2039 case LB_GETITEMDATA:
2040 case LB_GETITEMHEIGHT:
2041 case LB_GETSEL:
2042 case LB_GETSELCOUNT:
2043 case LB_GETTEXTLEN:
2044 case LB_GETTOPINDEX:
2045 case LB_RESETCONTENT:
2046 case LB_SELITEMRANGE:
2047 case LB_SELITEMRANGEEX:
2048 case LB_SETANCHORINDEX:
2049 case LB_SETCARETINDEX:
2050 case LB_SETCOLUMNWIDTH:
2051 case LB_SETCURSEL:
2052 case LB_SETHORIZONTALEXTENT:
2053 case LB_SETITEMDATA:
2054 case LB_SETITEMHEIGHT:
2055 case LB_SETSEL:
2056 case LB_SETTOPINDEX:
2057 ret = callback( HWND_16(hwnd), msg + LB_ADDSTRING16 - LB_ADDSTRING, wParam, lParam, result, arg );
2058 break;
2059 case LB_ADDSTRING:
2060 case LB_FINDSTRING:
2061 case LB_FINDSTRINGEXACT:
2062 case LB_INSERTSTRING:
2063 case LB_SELECTSTRING:
2064 case LB_GETTEXT:
2065 case LB_DIR:
2066 case LB_ADDFILE:
2067 lParam = MapLS( (LPSTR)lParam );
2068 ret = callback( HWND_16(hwnd), msg + LB_ADDSTRING16 - LB_ADDSTRING, wParam, lParam, result, arg );
2069 UnMapLS( lParam );
2070 break;
2071 case LB_GETSELITEMS:
2072 {
2073 INT *items32 = (INT *)lParam;
2074 INT16 *items, buffer[512];
2075 unsigned int i;
2076
2077 wParam = min( wParam, 0x7f80 ); /* Must be < 64K */
2078 if (!(items = get_buffer( buffer, sizeof(buffer), wParam * sizeof(INT16) ))) break;
2079 lParam = MapLS( items );
2080 ret = callback( HWND_16(hwnd), LB_GETSELITEMS16, wParam, lParam, result, arg );
2081 UnMapLS( lParam );
2082 for (i = 0; i < wParam; i++) items32[i] = items[i];
2083 free_buffer( buffer, items );
2084 }
2085 break;
2086 case LB_SETTABSTOPS:
2087 if (wParam)
2088 {
2089 INT *stops32 = (INT *)lParam;
2090 INT16 *stops, buffer[512];
2091 unsigned int i;
2092
2093 wParam = min( wParam, 0x7f80 ); /* Must be < 64K */
2094 if (!(stops = get_buffer( buffer, sizeof(buffer), wParam * sizeof(INT16) ))) break;
2095 for (i = 0; i < wParam; i++) stops[i] = stops32[i];
2096 lParam = MapLS( stops );
2097 ret = callback( HWND_16(hwnd), LB_SETTABSTOPS16, wParam, lParam, result, arg );
2098 UnMapLS( lParam );
2099 free_buffer( buffer, stops );
2100 }
2101 else ret = callback( HWND_16(hwnd), LB_SETTABSTOPS16, wParam, lParam, result, arg );
2102 break;
2103 case CB_DELETESTRING:
2104 case CB_GETCOUNT:
2105 case CB_GETLBTEXTLEN:
2106 case CB_LIMITTEXT:
2107 case CB_RESETCONTENT:
2108 case CB_SETEDITSEL:
2109 case CB_GETCURSEL:
2110 case CB_SETCURSEL:
2111 case CB_SHOWDROPDOWN:
2112 case CB_SETITEMDATA:
2113 case CB_SETITEMHEIGHT:
2114 case CB_GETITEMHEIGHT:
2115 case CB_SETEXTENDEDUI:
2116 case CB_GETEXTENDEDUI:
2117 case CB_GETDROPPEDSTATE:
2118 ret = callback( HWND_16(hwnd), msg + CB_GETEDITSEL16 - CB_GETEDITSEL, wParam, lParam, result, arg );
2119 break;
2120 case CB_GETEDITSEL:
2121 ret = callback( HWND_16(hwnd), CB_GETEDITSEL16, wParam, lParam, result, arg );
2122 if (wParam) *((PUINT)(wParam)) = LOWORD(*result);
2123 if (lParam) *((PUINT)(lParam)) = HIWORD(*result); /* FIXME: substract 1? */
2124 break;
2125 case CB_ADDSTRING:
2126 case CB_FINDSTRING:
2127 case CB_FINDSTRINGEXACT:
2128 case CB_INSERTSTRING:
2129 case CB_SELECTSTRING:
2130 case CB_DIR:
2131 case CB_GETLBTEXT:
2132 lParam = MapLS( (LPSTR)lParam );
2133 ret = callback( HWND_16(hwnd), msg + CB_GETEDITSEL16 - CB_GETEDITSEL, wParam, lParam, result, arg );
2134 UnMapLS( lParam );
2135 break;
2136 case LB_GETITEMRECT:
2137 case CB_GETDROPPEDCONTROLRECT:
2138 {
2139 RECT *r32 = (RECT *)lParam;
2140 RECT16 rect;
2141 lParam = MapLS( &rect );
2142 ret = callback( HWND_16(hwnd),
2143 (msg == LB_GETITEMRECT) ? LB_GETITEMRECT16 : CB_GETDROPPEDCONTROLRECT16,
2144 wParam, lParam, result, arg );
2145 UnMapLS( lParam );
2146 RECT16to32( &rect, r32 );
2147 }
2148 break;
2149 case WM_PAINTCLIPBOARD:
2150 case WM_SIZECLIPBOARD:
2151 FIXME_(msg)( "message %04x needs translation\n", msg );
2152 break;
2153 /* the following messages should not be sent to 16-bit apps */
2154 case WM_SIZING:
2155 case WM_MOVING:
2156 case WM_CAPTURECHANGED:
2157 case WM_STYLECHANGING:
2158 case WM_STYLECHANGED:
2159 break;
2160 default:
2161 ret = callback( HWND_16(hwnd), msg, wParam, lParam, result, arg );
2162 break;
2163 }
2164 return ret;
2165 }
2166
2167
2168 /**********************************************************************
2169 * CallWindowProc (USER.122)
2170 */
2171 LRESULT WINAPI CallWindowProc16( WNDPROC16 func, HWND16 hwnd, UINT16 msg,
2172 WPARAM16 wParam, LPARAM lParam )
2173 {
2174 WINDOWPROC *proc;
2175 LRESULT result;
2176
2177 if (!func) return 0;
2178
2179 if (!(proc = handle16_to_proc( func )))
2180 call_window_proc16( hwnd, msg, wParam, lParam, &result, func );
2181 else if (proc->procA)
2182 WINPROC_CallProc16To32A( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
2183 else if (proc->procW)
2184 WINPROC_CallProc16To32A( call_window_proc_AtoW, hwnd, msg, wParam, lParam, &result, proc->procW );
2185 else
2186 call_window_proc16( hwnd, msg, wParam, lParam, &result, proc->proc16 );
2187
2188 return result;
2189 }
2190
2191
2192 /**********************************************************************
2193 * CallWindowProcA (USER32.@)
2194 *
2195 * The CallWindowProc() function invokes the windows procedure _func_,
2196 * with _hwnd_ as the target window, the message specified by _msg_, and
2197 * the message parameters _wParam_ and _lParam_.
2198 *
2199 * Some kinds of argument conversion may be done, I'm not sure what.
2200 *
2201 * CallWindowProc() may be used for windows subclassing. Use
2202 * SetWindowLong() to set a new windows procedure for windows of the
2203 * subclass, and handle subclassed messages in the new windows
2204 * procedure. The new windows procedure may then use CallWindowProc()
2205 * with _func_ set to the parent class's windows procedure to dispatch
2206 * the message to the superclass.
2207 *
2208 * RETURNS
2209 *
2210 * The return value is message dependent.
2211 *
2212 * CONFORMANCE
2213 *
2214 * ECMA-234, Win32
2215 */
2216 LRESULT WINAPI CallWindowProcA(
2217 WNDPROC func, /* [in] window procedure */
2218 HWND hwnd, /* [in] target window */
2219 UINT msg, /* [in] message */
2220 WPARAM wParam, /* [in] message dependent parameter */
2221 LPARAM lParam /* [in] message dependent parameter */
2222 ) {
2223 WINDOWPROC *proc;
2224 LRESULT result;
2225
2226 if (!func) return 0;
2227
2228 if (!(proc = handle_to_proc( func )))
2229 call_window_proc( hwnd, msg, wParam, lParam, &result, func );
2230 else if (proc->procA)
2231 call_window_proc( hwnd, msg, wParam, lParam, &result, proc->procA );
2232 else if (proc->procW)
2233 WINPROC_CallProcAtoW( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procW );
2234 else
2235 WINPROC_CallProc32ATo16( call_window_proc16, hwnd, msg, wParam, lParam, &result, proc->proc16 );
2236 return result;
2237 }
2238
2239
2240 /**********************************************************************
2241 * CallWindowProcW (USER32.@)
2242 *
2243 * See CallWindowProcA.
2244 */
2245 LRESULT WINAPI CallWindowProcW( WNDPROC func, HWND hwnd, UINT msg,
2246 WPARAM wParam, LPARAM lParam )
2247 {
2248 WINDOWPROC *proc;
2249 LRESULT result;
2250
2251 if (!func) return 0;
2252
2253 if (!(proc = handle_to_proc( func )))
2254 call_window_proc( hwnd, msg, wParam, lParam, &result, func );
2255 else if (proc->procW)
2256 call_window_proc( hwnd, msg, wParam, lParam, &result, proc->procW );
2257 else if (proc->procA)
2258 WINPROC_CallProcWtoA( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
2259 else
2260 WINPROC_CallProcWtoA( call_window_proc_Ato16, hwnd, msg, wParam, lParam, &result, proc->proc16 );
2261 return result;
2262 }
2263
2264
2265 /**********************************************************************
2266 * WINPROC_CallDlgProc16
2267 */
2268 INT_PTR WINPROC_CallDlgProc16( DLGPROC16 func, HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam )
2269 {
2270 WINDOWPROC *proc;
2271 LRESULT result;
2272 INT_PTR ret;
2273
2274 if (!func) return 0;
2275
2276 if (!(proc = handle16_to_proc( (WNDPROC16)func )))
2277 {
2278 ret = call_dialog_proc16( hwnd, msg, wParam, lParam, &result, func );
2279 }
2280 else if (proc->procA)
2281 {
2282 ret = WINPROC_CallProc16To32A( call_dialog_proc, hwnd, msg, wParam, lParam,
2283 &result, proc->procA );
2284 SetWindowLongPtrW( WIN_Handle32(hwnd), DWLP_MSGRESULT, result );
2285 }
2286 else if (proc->procW)
2287 {
2288 ret = WINPROC_CallProc16To32A( call_dialog_proc_AtoW, hwnd, msg, wParam, lParam,
2289 &result, proc->procW );
2290 SetWindowLongPtrW( WIN_Handle32(hwnd), DWLP_MSGRESULT, result );
2291 }
2292 else
2293 {
2294 ret = call_dialog_proc16( hwnd, msg, wParam, lParam, &result, proc->proc16 );
2295 }
2296 return ret;
2297 }
2298
2299
2300 /**********************************************************************
2301 * WINPROC_CallDlgProcA
2302 */
2303 INT_PTR WINPROC_CallDlgProcA( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
2304 {
2305 WINDOWPROC *proc;
2306 LRESULT result;
2307 INT_PTR ret;
2308
2309 if (!func) return 0;
2310
2311 if (!(proc = handle_to_proc( (WNDPROC)func )))
2312 ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
2313 else if (proc->procA)
2314 ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, proc->procA );
2315 else if (proc->procW)
2316 {
2317 ret = WINPROC_CallProcAtoW( call_dialog_proc, hwnd, msg, wParam, lParam, &result, proc->procW );
2318 SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
2319 }
2320 else
2321 {
2322 ret = WINPROC_CallProc32ATo16( call_dialog_proc16, hwnd, msg, wParam, lParam, &result, proc->proc16 );
2323 SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
2324 }
2325 return ret;
2326 }
2327
2328
2329 /**********************************************************************
2330 * WINPROC_CallDlgProcW
2331 */
2332 INT_PTR WINPROC_CallDlgProcW( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
2333 {
2334 WINDOWPROC *proc;
2335 LRESULT result;
2336 INT_PTR ret;
2337
2338 if (!func) return 0;
2339
2340 if (!(proc = handle_to_proc( (WNDPROC)func )))
2341 ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
2342 else if (proc->procW)
2343 ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, proc->procW );
2344 else if (proc->procA)
2345 {
2346 ret = WINPROC_CallProcWtoA( call_dialog_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
2347 SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
2348 }
2349 else
2350 {
2351 ret = WINPROC_CallProcWtoA( call_dialog_proc_Ato16, hwnd, msg, wParam, lParam, &result, proc->proc16 );
2352 SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
2353 }
2354 return ret;
2355 }