?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
We should always allocate in NdrConformantStringUnmarshal if the
[wine.git] / dlls / user / winproc.c
blobff5ceaf72cd38a7758173d9c363d9c4ec573147e
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26 #include <string.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.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 #ifdef __i386__
48
49 #include "pshpack1.h"
50
51 /* Window procedure 16-to-32-bit thunk */
52 typedef struct
53 {
54 BYTE popl_eax; /* popl %eax (return address) */
55 BYTE pushl_func; /* pushl $proc */
56 WNDPROC proc;
57 BYTE pushl_eax; /* pushl %eax */
58 BYTE ljmp; /* ljmp relay*/
59 DWORD relay_offset; /* __wine_call_wndproc_32A/W */
60 WORD relay_sel;
61 } WINPROC_THUNK_FROM16;
62
63 /* Window procedure 32-to-16-bit thunk */
64 typedef struct
65 {
66 BYTE popl_eax; /* popl %eax (return address) */
67 BYTE pushl_func; /* pushl $proc */
68 WNDPROC16 proc;
69 BYTE pushl_eax; /* pushl %eax */
70 BYTE jmp; /* jmp relay (relative jump)*/
71 void (*relay)(); /* WINPROC_CallProc32ATo16() */
72 } WINPROC_THUNK_FROM32;
73
74 /* Simple jmp to call 32-bit procedure directly */
75 typedef struct
76 {
77 BYTE jmp; /* jmp proc (relative jump) */
78 WNDPROC proc;
79 } WINPROC_JUMP;
80
81 #include "poppack.h"
82
83 #else /* __i386__ */
84
85 typedef struct
86 {
87 WNDPROC proc;
88 } WINPROC_THUNK_FROM16;
89
90 typedef struct
91 {
92 WNDPROC16 proc;
93 } WINPROC_THUNK_FROM32;
94
95 typedef struct
96 {
97 WNDPROC proc;
98 } WINPROC_JUMP;
99
100 #endif /* __i386__ */
101
102 typedef union
103 {
104 WINPROC_THUNK_FROM16 t_from16;
105 WINPROC_THUNK_FROM32 t_from32;
106 } WINPROC_THUNK;
107
108 typedef struct tagWINDOWPROC
109 {
110 WINPROC_THUNK thunk; /* Thunk */
111 WINPROC_JUMP jmp; /* Jump */
112 BYTE type; /* Function type */
113 } WINDOWPROC;
114
115 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND hwnd,
116 UINT msg, WPARAM wParam,
117 LPARAM lParam );
118 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND hwnd,
119 UINT msg, WPARAM wParam,
120 LPARAM lParam );
121
122 #define MAX_WINPROCS (0x10000 / sizeof(WINDOWPROC))
123
124 static WINDOWPROC winproc_array[MAX_WINPROCS];
125 static UINT winproc_used;
126
127 static CRITICAL_SECTION winproc_cs;
128 static CRITICAL_SECTION_DEBUG critsect_debug =
129 {
130 0, 0, &winproc_cs,
131 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
132 0, 0, { (DWORD_PTR)(__FILE__ ": winproc_cs") }
133 };
134 static CRITICAL_SECTION winproc_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
135
136 static BOOL is_valid_winproc( WINDOWPROC *proc )
137 {
138 /* check alignment */
139 if (((BYTE *)proc - (BYTE *)winproc_array) % sizeof(*proc)) return FALSE;
140 /* check array limits */
141 if (proc < winproc_array || proc >= winproc_array + winproc_used) return FALSE;
142 return (proc->type != WIN_PROC_INVALID);
143 }
144
145 /* find an existing winproc for a given function and type */
146 /* FIXME: probably should do something more clever than a linear search */
147 static inline WINDOWPROC *find_winproc( WNDPROC func, WINDOWPROCTYPE type )
148 {
149 unsigned int i;
150
151 if (type == WIN_PROC_16)
152 {
153 for (i = 0; i < winproc_used; i++)
154 {
155 if (winproc_array[i].type == type &&
156 winproc_array[i].thunk.t_from32.proc == (WNDPROC16)func)
157 return &winproc_array[i];
158 }
159 }
160 else
161 {
162 for (i = 0; i < winproc_used; i++)
163 {
164 if (winproc_array[i].type == type &&
165 winproc_array[i].thunk.t_from16.proc == func)
166 return &winproc_array[i];
167 }
168 }
169 return NULL;
170 }
171
172 /* initialize a new winproc */
173 static inline void set_winproc( WINDOWPROC *proc, WNDPROC func, WINDOWPROCTYPE type )
174 {
175 #ifdef __i386__
176 static FARPROC16 relay_32A, relay_32W;
177
178 switch(type)
179 {
180 case WIN_PROC_16:
181 proc->thunk.t_from32.popl_eax = 0x58; /* popl %eax */
182 proc->thunk.t_from32.pushl_func = 0x68; /* pushl $proc */
183 proc->thunk.t_from32.proc = (WNDPROC16)func;
184 proc->thunk.t_from32.pushl_eax = 0x50; /* pushl %eax */
185 proc->thunk.t_from32.jmp = 0xe9; /* jmp relay*/
186 proc->thunk.t_from32.relay = /* relative jump */
187 (void(*)())((DWORD)WINPROC_CallProc32ATo16 -
188 (DWORD)(&proc->thunk.t_from32.relay + 1));
189 break;
190 case WIN_PROC_32A:
191 if (!relay_32A) relay_32A = GetProcAddress16( GetModuleHandle16("user"),
192 "__wine_call_wndproc_32A" );
193 proc->thunk.t_from16.popl_eax = 0x58; /* popl %eax */
194 proc->thunk.t_from16.pushl_func = 0x68; /* pushl $proc */
195 proc->thunk.t_from16.proc = func;
196 proc->thunk.t_from16.pushl_eax = 0x50; /* pushl %eax */
197 proc->thunk.t_from16.ljmp = 0xea; /* ljmp relay*/
198 proc->thunk.t_from16.relay_offset = OFFSETOF(relay_32A);
199 proc->thunk.t_from16.relay_sel = SELECTOROF(relay_32A);
200 proc->jmp.jmp = 0xe9;
201 /* Fixup relative jump */
202 proc->jmp.proc = (WNDPROC)((DWORD)func - (DWORD)(&proc->jmp.proc + 1));
203 break;
204 case WIN_PROC_32W:
205 if (!relay_32W) relay_32W = GetProcAddress16( GetModuleHandle16("user"),
206 "__wine_call_wndproc_32W" );
207 proc->thunk.t_from16.popl_eax = 0x58; /* popl %eax */
208 proc->thunk.t_from16.pushl_func = 0x68; /* pushl $proc */
209 proc->thunk.t_from16.proc = func;
210 proc->thunk.t_from16.pushl_eax = 0x50; /* pushl %eax */
211 proc->thunk.t_from16.ljmp = 0xea; /* ljmp relay*/
212 proc->thunk.t_from16.relay_offset = OFFSETOF(relay_32W);
213 proc->thunk.t_from16.relay_sel = SELECTOROF(relay_32W);
214 proc->jmp.jmp = 0xe9;
215 /* Fixup relative jump */
216 proc->jmp.proc = (WNDPROC)((char *)func - (char *)(&proc->jmp.proc + 1));
217 break;
218 default:
219 /* Should not happen */
220 break;
221 }
222 #else /* __i386__ */
223 switch(type)
224 {
225 case WIN_PROC_16:
226 proc->thunk.t_from32.proc = (WNDPROC16)func;
227 break;
228 case WIN_PROC_32A:
229 case WIN_PROC_32W:
230 proc->thunk.t_from16.proc = func;
231 break;
232 default:
233 /* Should not happen */
234 break;
235 }
236 #endif /* __i386__ */
237
238 proc->type = type;
239 }
240
241 static WORD get_winproc_selector(void)
242 {
243 static LONG winproc_selector;
244 WORD ret;
245
246 if (!(ret = winproc_selector))
247 {
248 LDT_ENTRY entry;
249 WORD sel = wine_ldt_alloc_entries(1);
250 wine_ldt_set_base( &entry, winproc_array );
251 wine_ldt_set_limit( &entry, sizeof(winproc_array) - 1 );
252 wine_ldt_set_flags( &entry, WINE_LDT_FLAGS_CODE | WINE_LDT_FLAGS_32BIT );
253 wine_ldt_set_entry( sel, &entry );
254 if (!(ret = InterlockedCompareExchange( &winproc_selector, sel, 0 ))) ret = sel;
255 else wine_ldt_free_entries( sel, 1 ); /* somebody beat us to it */
256 }
257 return ret;
258 }
259
260
261 #ifdef __i386__
262 /* Some window procedures modify register they shouldn't, or are not
263 * properly declared stdcall; so we need a small assembly wrapper to
264 * call them. */
265 extern LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
266 WPARAM wParam, LPARAM lParam );
267 __ASM_GLOBAL_FUNC( WINPROC_wrapper,
268 "pushl %ebp\n\t"
269 "movl %esp,%ebp\n\t"
270 "pushl %edi\n\t"
271 "pushl %esi\n\t"
272 "pushl %ebx\n\t"
273 "subl $12,%esp\n\t"
274 "pushl 24(%ebp)\n\t"
275 "pushl 20(%ebp)\n\t"
276 "pushl 16(%ebp)\n\t"
277 "pushl 12(%ebp)\n\t"
278 "movl 8(%ebp),%eax\n\t"
279 "call *%eax\n\t"
280 "leal -12(%ebp),%esp\n\t"
281 "popl %ebx\n\t"
282 "popl %esi\n\t"
283 "popl %edi\n\t"
284 "leave\n\t"
285 "ret" );
286 #else
287 static inline LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
288 WPARAM wParam, LPARAM lParam )
289 {
290 return proc( hwnd, msg, wParam, lParam );
291 }
292 #endif /* __i386__ */
293
294
295 static void MINMAXINFO32to16( const MINMAXINFO *from, MINMAXINFO16 *to )
296 {
297 to->ptReserved.x = from->ptReserved.x;
298 to->ptReserved.y = from->ptReserved.y;
299 to->ptMaxSize.x = from->ptMaxSize.x;
300 to->ptMaxSize.y = from->ptMaxSize.y;
301 to->ptMaxPosition.x = from->ptMaxPosition.x;
302 to->ptMaxPosition.y = from->ptMaxPosition.y;
303 to->ptMinTrackSize.x = from->ptMinTrackSize.x;
304 to->ptMinTrackSize.y = from->ptMinTrackSize.y;
305 to->ptMaxTrackSize.x = from->ptMaxTrackSize.x;
306 to->ptMaxTrackSize.y = from->ptMaxTrackSize.y;
307 }
308
309 static void MINMAXINFO16to32( const MINMAXINFO16 *from, MINMAXINFO *to )
310 {
311 to->ptReserved.x = from->ptReserved.x;
312 to->ptReserved.y = from->ptReserved.y;
313 to->ptMaxSize.x = from->ptMaxSize.x;
314 to->ptMaxSize.y = from->ptMaxSize.y;
315 to->ptMaxPosition.x = from->ptMaxPosition.x;
316 to->ptMaxPosition.y = from->ptMaxPosition.y;
317 to->ptMinTrackSize.x = from->ptMinTrackSize.x;
318 to->ptMinTrackSize.y = from->ptMinTrackSize.y;
319 to->ptMaxTrackSize.x = from->ptMaxTrackSize.x;
320 to->ptMaxTrackSize.y = from->ptMaxTrackSize.y;
321 }
322
323 static void WINDOWPOS32to16( const WINDOWPOS* from, WINDOWPOS16* to )
324 {
325 to->hwnd = HWND_16(from->hwnd);
326 to->hwndInsertAfter = HWND_16(from->hwndInsertAfter);
327 to->x = from->x;
328 to->y = from->y;
329 to->cx = from->cx;
330 to->cy = from->cy;
331 to->flags = from->flags;
332 }
333
334 static void WINDOWPOS16to32( const WINDOWPOS16* from, WINDOWPOS* to )
335 {
336 to->hwnd = WIN_Handle32(from->hwnd);
337 to->hwndInsertAfter = (from->hwndInsertAfter == (HWND16)-1) ?
338 HWND_TOPMOST : WIN_Handle32(from->hwndInsertAfter);
339 to->x = from->x;
340 to->y = from->y;
341 to->cx = from->cx;
342 to->cy = from->cy;
343 to->flags = from->flags;
344 }
345
346 /* The strings are not copied */
347 static void CREATESTRUCT32Ato16( const CREATESTRUCTA* from, CREATESTRUCT16* to )
348 {
349 to->lpCreateParams = (SEGPTR)from->lpCreateParams;
350 to->hInstance = HINSTANCE_16(from->hInstance);
351 to->hMenu = HMENU_16(from->hMenu);
352 to->hwndParent = HWND_16(from->hwndParent);
353 to->cy = from->cy;
354 to->cx = from->cx;
355 to->y = from->y;
356 to->x = from->x;
357 to->style = from->style;
358 to->dwExStyle = from->dwExStyle;
359 }
360
361 static void CREATESTRUCT16to32A( const CREATESTRUCT16* from, CREATESTRUCTA *to )
362
363 {
364 to->lpCreateParams = (LPVOID)from->lpCreateParams;
365 to->hInstance = HINSTANCE_32(from->hInstance);
366 to->hMenu = HMENU_32(from->hMenu);
367 to->hwndParent = WIN_Handle32(from->hwndParent);
368 to->cy = from->cy;
369 to->cx = from->cx;
370 to->y = from->y;
371 to->x = from->x;
372 to->style = from->style;
373 to->dwExStyle = from->dwExStyle;
374 }
375
376 /* The strings are not copied */
377 static void MDICREATESTRUCT32Ato16( const MDICREATESTRUCTA* from, MDICREATESTRUCT16* to )
378 {
379 to->hOwner = HINSTANCE_16(from->hOwner);
380 to->x = from->x;
381 to->y = from->y;
382 to->cx = from->cx;
383 to->cy = from->cy;
384 to->style = from->style;
385 to->lParam = from->lParam;
386 }
387
388 static void MDICREATESTRUCT16to32A( const MDICREATESTRUCT16* from, MDICREATESTRUCTA *to )
389 {
390 to->hOwner = HINSTANCE_32(from->hOwner);
391 to->x = from->x;
392 to->y = from->y;
393 to->cx = from->cx;
394 to->cy = from->cy;
395 to->style = from->style;
396 to->lParam = from->lParam;
397 }
398
399 /**********************************************************************
400 * WINPROC_CallWndProc32
401 *
402 * Call a 32-bit WndProc.
403 */
404 static LRESULT WINPROC_CallWndProc( WNDPROC proc, HWND hwnd, UINT msg,
405 WPARAM wParam, LPARAM lParam )
406 {
407 LRESULT retvalue;
408
409 USER_CheckNotLock();
410
411 hwnd = WIN_GetFullHandle( hwnd );
412 if (TRACE_ON(relay))
413 DPRINTF( "%04lx:Call window proc %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
414 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam );
415
416 retvalue = WINPROC_wrapper( proc, hwnd, msg, wParam, lParam );
417
418 if (TRACE_ON(relay))
419 DPRINTF( "%04lx:Ret window proc %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx) retval=%08lx\n",
420 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam, retvalue );
421 return retvalue;
422 }
423
424 /***********************************************************************
425 * WINPROC_CallWndProc16
426 *
427 * Call a 16-bit window procedure
428 */
429 static LRESULT WINAPI WINPROC_CallWndProc16( WNDPROC16 proc, HWND16 hwnd,
430 UINT16 msg, WPARAM16 wParam,
431 LPARAM lParam )
432 {
433 CONTEXT86 context;
434 size_t size = 0;
435 struct
436 {
437 WORD params[5];
438 union
439 {
440 CREATESTRUCT16 cs16;
441 DRAWITEMSTRUCT16 dis16;
442 COMPAREITEMSTRUCT16 cis16;
443 } u;
444 } args;
445
446 USER_CheckNotLock();
447
448 /* Window procedures want ax = hInstance, ds = es = ss */
449
450 memset(&context, 0, sizeof(context));
451 context.SegDs = context.SegEs = SELECTOROF(NtCurrentTeb()->WOW32Reserved);
452 context.SegFs = wine_get_fs();
453 context.SegGs = wine_get_gs();
454 if (!(context.Eax = GetWindowWord( HWND_32(hwnd), GWLP_HINSTANCE ))) context.Eax = context.SegDs;
455 context.SegCs = SELECTOROF(proc);
456 context.Eip = OFFSETOF(proc);
457 context.Ebp = OFFSETOF(NtCurrentTeb()->WOW32Reserved) + (WORD)&((STACK16FRAME*)0)->bp;
458
459 if (lParam)
460 {
461 /* Some programs (eg. the "Undocumented Windows" examples, JWP) only
462 work if structures passed in lParam are placed in the stack/data
463 segment. Programmers easily make the mistake of converting lParam
464 to a near rather than a far pointer, since Windows apparently
465 allows this. We copy the structures to the 16 bit stack; this is
466 ugly but makes these programs work. */
467 switch (msg)
468 {
469 case WM_CREATE:
470 case WM_NCCREATE:
471 size = sizeof(CREATESTRUCT16); break;
472 case WM_DRAWITEM:
473 size = sizeof(DRAWITEMSTRUCT16); break;
474 case WM_COMPAREITEM:
475 size = sizeof(COMPAREITEMSTRUCT16); break;
476 }
477 if (size)
478 {
479 memcpy( &args.u, MapSL(lParam), size );
480 lParam = (SEGPTR)NtCurrentTeb()->WOW32Reserved - size;
481 }
482 }
483
484 args.params[4] = hwnd;
485 args.params[3] = msg;
486 args.params[2] = wParam;
487 args.params[1] = HIWORD(lParam);
488 args.params[0] = LOWORD(lParam);
489 WOWCallback16Ex( 0, WCB16_REGS, sizeof(args.params) + size, &args, (DWORD *)&context );
490 return MAKELONG( LOWORD(context.Eax), LOWORD(context.Edx) );
491 }
492
493
494 /**********************************************************************
495 * WINPROC_GetPtr
496 *
497 * Return a pointer to the win proc.
498 */
499 static WINDOWPROC *WINPROC_GetPtr( WNDPROC handle )
500 {
501 BYTE *ptr;
502 WINDOWPROC *proc;
503
504 /* ptr cannot be < 64K */
505 if (!HIWORD(handle)) return NULL;
506
507 /* Check for a linear pointer */
508
509 ptr = (BYTE *)handle;
510 /* First check if it is the jmp address */
511 proc = (WINDOWPROC *)(ptr - FIELD_OFFSET(WINDOWPROC,jmp));
512 if (is_valid_winproc(proc)) return proc;
513
514 /* Now it must be the thunk address */
515 proc = (WINDOWPROC *)(ptr - FIELD_OFFSET(WINDOWPROC,thunk));
516 if (is_valid_winproc(proc)) return proc;
517
518 /* Check for a segmented pointer */
519
520 if (HIWORD(handle) == get_winproc_selector())
521 {
522 ptr = (BYTE *)winproc_array + LOWORD(handle);
523 /* It must be the thunk address */
524 proc = (WINDOWPROC *)(ptr - FIELD_OFFSET(WINDOWPROC,thunk));
525 if (is_valid_winproc(proc)) return proc;
526 }
527 return NULL;
528 }
529
530
531 /**********************************************************************
532 * WINPROC_GetProc
533 *
534 * Get a window procedure pointer that can be passed to the Windows program.
535 */
536 WNDPROC16 WINPROC_GetProc( WNDPROC proc, WINDOWPROCTYPE type )
537 {
538 WINDOWPROC *ptr = (WINDOWPROC *)proc;
539
540 if (!proc) return NULL;
541 if (type == WIN_PROC_16) /* We want a 16:16 address */
542 {
543 if (ptr->type == WIN_PROC_16)
544 return ptr->thunk.t_from32.proc;
545 else
546 return (WNDPROC16)MAKESEGPTR( get_winproc_selector(),
547 (char *)&ptr->thunk - (char *)winproc_array );
548 }
549 else /* We want a 32-bit address */
550 {
551 if (ptr->type == WIN_PROC_16)
552 return (WNDPROC16)&ptr->thunk;
553 else if (type != ptr->type)
554 /* Have to return the jmp address if types don't match */
555 return (WNDPROC16)&ptr->jmp;
556 else
557 /* Some Win16 programs want to get back the proc they set */
558 return (WNDPROC16)ptr->thunk.t_from16.proc;
559 }
560 }
561
562
563 /**********************************************************************
564 * WINPROC_AllocProc
565 *
566 * Allocate a window procedure for a window or class.
567 *
568 * Note that allocated winprocs are never freed; the idea is that even if an app creates a
569 * lot of windows, it will usually only have a limited number of window procedures, so the
570 * array won't grow too large, and this way we avoid the need to track allocations per window.
571 */
572 WNDPROC WINPROC_AllocProc( WNDPROC func, WINDOWPROCTYPE type )
573 {
574 WINDOWPROC *proc;
575
576 if (!func) return NULL;
577
578 EnterCriticalSection( &winproc_cs );
579
580 /* check if the function is already a win proc */
581 if (!(proc = WINPROC_GetPtr( func )))
582 {
583 /* then check if we already have a winproc for that function */
584 if (!(proc = find_winproc( func, type )))
585 {
586 if (winproc_used >= MAX_WINPROCS)
587 FIXME( "too many winprocs, cannot allocate one for %p/%d\n", func, type );
588 else
589 {
590 proc = &winproc_array[winproc_used++];
591 set_winproc( proc, func, type );
592 TRACE( "allocated %p for %p/%d (%d/%d used)\n",
593 proc, func, type, winproc_used, MAX_WINPROCS );
594 }
595 }
596 else TRACE( "reusing %p for %p/%d\n", proc, func, type );
597 }
598
599 LeaveCriticalSection( &winproc_cs );
600 return (WNDPROC)proc;
601 }
602
603
604 /**********************************************************************
605 * WINPROC_GetProcType
606 *
607 * Return the window procedure type.
608 */
609 WINDOWPROCTYPE WINPROC_GetProcType( WNDPROC proc )
610 {
611 if (!proc) return WIN_PROC_INVALID;
612 return ((WINDOWPROC *)proc)->type;
613 }
614 /**********************************************************************
615 * WINPROC_TestCBForStr
616 *
617 * Return TRUE if the lparam is a string
618 */
619 inline static BOOL WINPROC_TestCBForStr( HWND hwnd )
620 {
621 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
622 return (!(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) || (style & CBS_HASSTRINGS));
623 }
624 /**********************************************************************
625 * WINPROC_TestLBForStr
626 *
627 * Return TRUE if the lparam is a string
628 */
629 inline static BOOL WINPROC_TestLBForStr( HWND hwnd )
630 {
631 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
632 return (!(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) || (style & LBS_HASSTRINGS));
633
634 }
635 /**********************************************************************
636 * WINPROC_MapMsg32ATo32W
637 *
638 * Map a message from Ansi to Unicode.
639 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
640 *
641 * FIXME:
642 * WM_GETTEXT/WM_SETTEXT and static control with SS_ICON style:
643 * the first four bytes are the handle of the icon
644 * when the WM_SETTEXT message has been used to set the icon
645 */
646 INT WINPROC_MapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM *pwparam, LPARAM *plparam )
647 {
648 switch(msg)
649 {
650 case WM_GETTEXT:
651 case WM_ASKCBFORMATNAME:
652 {
653 LPARAM *ptr = HeapAlloc( GetProcessHeap(), 0,
654 *pwparam * sizeof(WCHAR) + sizeof(LPARAM) );
655 if (!ptr) return -1;
656 *ptr++ = *plparam; /* Store previous lParam */
657 *plparam = (LPARAM)ptr;
658 }
659 return 1;
660 /* lparam is string (0-terminated) */
661 case WM_SETTEXT:
662 case WM_WININICHANGE:
663 case WM_DEVMODECHANGE:
664 case CB_DIR:
665 case LB_DIR:
666 case LB_ADDFILE:
667 case EM_REPLACESEL:
668 if (!*plparam) return 0;
669 else
670 {
671 DWORD len = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)*plparam, -1, NULL, 0);
672 WCHAR *buf = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
673 MultiByteToWideChar(CP_ACP, 0, (LPCSTR)*plparam, -1, buf, len);
674 *plparam = (LPARAM)buf;
675 return (*plparam ? 1 : -1);
676 }
677 case WM_GETTEXTLENGTH:
678 case CB_GETLBTEXTLEN:
679 case LB_GETTEXTLEN:
680 return 1; /* need to map result */
681 case WM_NCCREATE:
682 case WM_CREATE:
683 {
684 UNICODE_STRING usBuffer;
685 struct s
686 { CREATESTRUCTW cs; /* new structure */
687 LPCWSTR lpszName; /* allocated Name */
688 LPCWSTR lpszClass; /* allocated Class */
689 };
690
691 struct s *xs = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct s));
692 if (!xs) return -1;
693 xs->cs = *(CREATESTRUCTW *)*plparam;
694 if (HIWORD(xs->cs.lpszName))
695 {
696 RtlCreateUnicodeStringFromAsciiz(&usBuffer,(LPCSTR)xs->cs.lpszName);
697 xs->lpszName = xs->cs.lpszName = usBuffer.Buffer;
698 }
699 if (HIWORD(xs->cs.lpszClass))
700 {
701 RtlCreateUnicodeStringFromAsciiz(&usBuffer,(LPCSTR)xs->cs.lpszClass);
702 xs->lpszClass = xs->cs.lpszClass = usBuffer.Buffer;
703 }
704
705 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
706 {
707 MDICREATESTRUCTW *mdi_cs = HeapAlloc(GetProcessHeap(), 0, sizeof(*mdi_cs));
708 *mdi_cs = *(MDICREATESTRUCTW *)xs->cs.lpCreateParams;
709 if (HIWORD(mdi_cs->szTitle))
710 {
711 RtlCreateUnicodeStringFromAsciiz(&usBuffer, (LPCSTR)mdi_cs->szTitle);
712 mdi_cs->szTitle = usBuffer.Buffer;
713 }
714 if (HIWORD(mdi_cs->szClass))
715 {
716 RtlCreateUnicodeStringFromAsciiz(&usBuffer, (LPCSTR)mdi_cs->szClass);
717 mdi_cs->szClass = usBuffer.Buffer;
718 }
719 xs->cs.lpCreateParams = mdi_cs;
720 }
721
722 *plparam = (LPARAM)xs;
723 }
724 return 1;
725 case WM_MDICREATE:
726 {
727 MDICREATESTRUCTW *cs = HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
728 if (!cs) return -1;
729 *cs = *(MDICREATESTRUCTW *)*plparam;
730 if (HIWORD(cs->szClass))
731 {
732 UNICODE_STRING usBuffer;
733 RtlCreateUnicodeStringFromAsciiz(&usBuffer,(LPCSTR)cs->szClass);
734 cs->szClass = usBuffer.Buffer;
735 }
736 if (HIWORD(cs->szTitle))
737 {
738 UNICODE_STRING usBuffer;
739 RtlCreateUnicodeStringFromAsciiz(&usBuffer,(LPCSTR)cs->szTitle);
740 cs->szTitle = usBuffer.Buffer;
741 }
742 *plparam = (LPARAM)cs;
743 }
744 return 1;
745
746 /* Listbox */
747 case LB_ADDSTRING:
748 case LB_INSERTSTRING:
749 case LB_FINDSTRING:
750 case LB_FINDSTRINGEXACT:
751 case LB_SELECTSTRING:
752 if(!*plparam) return 0;
753 if ( WINPROC_TestLBForStr( hwnd ))
754 {
755 UNICODE_STRING usBuffer;
756 RtlCreateUnicodeStringFromAsciiz(&usBuffer,(LPCSTR)*plparam);
757 *plparam = (LPARAM)usBuffer.Buffer;
758 }
759 return (*plparam ? 1 : -1);
760
761 case LB_GETTEXT: /* FIXME: fixed sized buffer */
762 { if ( WINPROC_TestLBForStr( hwnd ))
763 { LPARAM *ptr = HeapAlloc( GetProcessHeap(), 0, 512 * sizeof(WCHAR) + sizeof(LPARAM) );
764 if (!ptr) return -1;
765 *ptr++ = *plparam; /* Store previous lParam */
766 *plparam = (LPARAM)ptr;
767 }
768 }
769 return 1;
770
771 /* Combobox */
772 case CB_ADDSTRING:
773 case CB_INSERTSTRING:
774 case CB_FINDSTRINGEXACT:
775 case CB_FINDSTRING:
776 case CB_SELECTSTRING:
777 if(!*plparam) return 0;
778 if ( WINPROC_TestCBForStr( hwnd ))
779 {
780 UNICODE_STRING usBuffer;
781 RtlCreateUnicodeStringFromAsciiz(&usBuffer,(LPCSTR)*plparam);
782 *plparam = (LPARAM)usBuffer.Buffer;
783 }
784 return (*plparam ? 1 : -1);
785
786 case CB_GETLBTEXT: /* FIXME: fixed sized buffer */
787 { if ( WINPROC_TestCBForStr( hwnd ))
788 { LPARAM *ptr = HeapAlloc( GetProcessHeap(), 0, 512 * sizeof(WCHAR) + sizeof(LPARAM) );
789 if (!ptr) return -1;
790 *ptr++ = *plparam; /* Store previous lParam */
791 *plparam = (LPARAM)ptr;
792 }
793 }
794 return 1;
795
796 /* Multiline edit */
797 case EM_GETLINE:
798 { WORD len = (WORD)*plparam;
799 LPARAM *ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(WCHAR) );
800 if (!ptr) return -1;
801 *ptr++ = *plparam; /* Store previous lParam */
802 *((WORD *) ptr) = len; /* Store the length */
803 *plparam = (LPARAM)ptr;
804 }
805 return 1;
806
807 case WM_CHARTOITEM:
808 case WM_MENUCHAR:
809 case WM_CHAR:
810 case WM_DEADCHAR:
811 case WM_SYSCHAR:
812 case WM_SYSDEADCHAR:
813 case EM_SETPASSWORDCHAR:
814 {
815 CHAR ch = LOWORD(*pwparam);
816 WCHAR wch;
817 MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
818 *pwparam = MAKEWPARAM( wch, HIWORD(*pwparam) );
819 }
820 return 0;
821
822 case WM_IME_CHAR:
823 {
824 CHAR ch[2];
825 WCHAR wch;
826 ch[0] = (*pwparam >> 8);
827 ch[1] = *pwparam & 0xff;
828 if (ch[0])
829 MultiByteToWideChar(CP_ACP, 0, ch, 2, &wch, 1);
830 else
831 MultiByteToWideChar(CP_ACP, 0, &ch[1], 1, &wch, 1);
832 *pwparam = MAKEWPARAM( wch, HIWORD(*pwparam) );
833 }
834 return 0;
835
836 case WM_PAINTCLIPBOARD:
837 case WM_SIZECLIPBOARD:
838 FIXME_(msg)("message %s (0x%x) needs translation, please report\n", SPY_GetMsgName(msg, hwnd), msg );
839 return -1;
840 default: /* No translation needed */
841 return 0;
842 }
843 }
844
845
846 /**********************************************************************
847 * WINPROC_UnmapMsg32ATo32W
848 *
849 * Unmap a message that was mapped from Ansi to Unicode.
850 */
851 LRESULT WINPROC_UnmapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
852 LRESULT result, WNDPROC dispatch )
853 {
854 switch(msg)
855 {
856 case WM_GETTEXT:
857 case WM_ASKCBFORMATNAME:
858 {
859 LPARAM *ptr = (LPARAM *)lParam - 1;
860 if (!wParam) result = 0;
861 else if (!(result = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1,
862 (LPSTR)*ptr, wParam, NULL, NULL )))
863 {
864 ((LPSTR)*ptr)[wParam-1] = 0;
865 result = wParam - 1;
866 }
867 else result--; /* do not count terminating null */
868 HeapFree( GetProcessHeap(), 0, ptr );
869 }
870 break;
871 case WM_GETTEXTLENGTH:
872 case CB_GETLBTEXTLEN:
873 case LB_GETTEXTLEN:
874 if (result >= 0)
875 {
876 /* Determine respective GETTEXT message */
877 UINT msgGetText =
878 (msg == WM_GETTEXTLENGTH) ? WM_GETTEXT :
879 ((msg == CB_GETLBTEXTLEN) ? CB_GETLBTEXT : LB_GETTEXT);
880 /* wParam differs between the messages */
881 WPARAM wp = (msg == WM_GETTEXTLENGTH) ? (WPARAM)(result + 1) : wParam;
882
883 WCHAR* p = HeapAlloc (GetProcessHeap(), 0, (result + 1) * sizeof(WCHAR));
884
885 if (p)
886 {
887 LRESULT n;
888
889 if (dispatch)
890 n = WINPROC_CallWndProc(dispatch, hwnd, msgGetText, wp, (LPARAM)p);
891 else
892 n = SendMessageW (hwnd, msgGetText, wp, (LPARAM)p);
893
894 result = WideCharToMultiByte( CP_ACP, 0, p, n, NULL, 0, 0, NULL );
895 HeapFree (GetProcessHeap(), 0, p);
896 }
897 }
898 break;
899 case WM_NCCREATE:
900 case WM_CREATE:
901 {
902 struct s
903 { CREATESTRUCTW cs; /* new structure */
904 LPWSTR lpszName; /* allocated Name */
905 LPWSTR lpszClass; /* allocated Class */
906 };
907 struct s *xs = (struct s *)lParam;
908 HeapFree( GetProcessHeap(), 0, xs->lpszName );
909 HeapFree( GetProcessHeap(), 0, xs->lpszClass );
910
911 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
912 {
913 MDICREATESTRUCTW *mdi_cs = (MDICREATESTRUCTW *)xs->cs.lpCreateParams;
914 if (HIWORD(mdi_cs->szTitle))
915 HeapFree(GetProcessHeap(), 0, (LPVOID)mdi_cs->szTitle);
916 if (HIWORD(mdi_cs->szClass))
917 HeapFree(GetProcessHeap(), 0, (LPVOID)mdi_cs->szClass);
918 HeapFree(GetProcessHeap(), 0, mdi_cs);
919 }
920 HeapFree( GetProcessHeap(), 0, xs );
921 }
922 break;
923
924 case WM_MDICREATE:
925 {
926 MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lParam;
927 if (HIWORD(cs->szTitle))
928 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
929 if (HIWORD(cs->szClass))
930 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
931 HeapFree( GetProcessHeap(), 0, cs );
932 }
933 break;
934
935 case WM_SETTEXT:
936 case WM_WININICHANGE:
937 case WM_DEVMODECHANGE:
938 case CB_DIR:
939 case LB_DIR:
940 case LB_ADDFILE:
941 case EM_REPLACESEL:
942 HeapFree( GetProcessHeap(), 0, (void *)lParam );
943 break;
944
945 /* Listbox */
946 case LB_ADDSTRING:
947 case LB_INSERTSTRING:
948 case LB_FINDSTRING:
949 case LB_FINDSTRINGEXACT:
950 case LB_SELECTSTRING:
951 if ( WINPROC_TestLBForStr( hwnd ))
952 HeapFree( GetProcessHeap(), 0, (void *)lParam );
953 break;
954
955 case LB_GETTEXT:
956 if ( WINPROC_TestLBForStr( hwnd ))
957 {
958 LPARAM *ptr = (LPARAM *)lParam - 1;
959 result = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1,
960 (LPSTR)*ptr, 0x7fffffff, NULL, NULL ) - 1;
961 HeapFree( GetProcessHeap(), 0, ptr );
962 }
963 break;
964
965 /* Combobox */
966 case CB_ADDSTRING:
967 case CB_INSERTSTRING:
968 case CB_FINDSTRING:
969 case CB_FINDSTRINGEXACT:
970 case CB_SELECTSTRING:
971 if ( WINPROC_TestCBForStr( hwnd ))
972 HeapFree( GetProcessHeap(), 0, (void *)lParam );
973 break;
974
975 case CB_GETLBTEXT:
976 if ( result < 0) /* CB_ERR and CB_ERRSPACE */
977 {
978 LPARAM *ptr = (LPARAM *)lParam - 1;
979 HeapFree( GetProcessHeap(), 0, ptr );
980 }
981 else if ( WINPROC_TestCBForStr( hwnd ))
982 {
983 LPARAM *ptr = (LPARAM *)lParam - 1;
984 result = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1,
985 (LPSTR)*ptr, 0x7fffffff, NULL, NULL ) - 1;
986 HeapFree( GetProcessHeap(), 0, ptr );
987 }
988 break;
989
990 /* Multiline edit */
991 case EM_GETLINE:
992 {
993 LPARAM * ptr = (LPARAM *)lParam - 1; /* get the old lParam */
994 WORD len = *(WORD *) lParam;
995 result = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, result,
996 (LPSTR)*ptr, len, NULL, NULL );
997 if (result < len) ((LPSTR)*ptr)[result] = 0;
998 HeapFree( GetProcessHeap(), 0, ptr );
999 }
1000 break;
1001 }
1002 return result;
1003 }
1004
1005
1006 /**********************************************************************
1007 * WINPROC_MapMsg32WTo32A
1008 *
1009 * Map a message from Unicode to Ansi.
1010 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1011 */
1012 static INT WINPROC_MapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM *pwparam, LPARAM *plparam )
1013 {
1014 switch(msg)
1015 {
1016 case WM_GETTEXT:
1017 case WM_ASKCBFORMATNAME:
1018 {
1019 LPARAM *ptr = HeapAlloc( GetProcessHeap(), 0, *pwparam + sizeof(LPARAM) );
1020 if (!ptr) return -1;
1021 *ptr++ = *plparam; /* Store previous lParam */
1022 *plparam = (LPARAM)ptr;
1023 }
1024 return 1;
1025
1026 case WM_SETTEXT:
1027 case WM_WININICHANGE:
1028 case WM_DEVMODECHANGE:
1029 case CB_DIR:
1030 case LB_DIR:
1031 case LB_ADDFILE:
1032 case EM_REPLACESEL:
1033 if (*plparam)
1034 {
1035 LPCWSTR str = (LPCWSTR)*plparam;
1036 int len = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, 0, 0);
1037 *plparam = (LPARAM)HeapAlloc(GetProcessHeap(), 0, len);
1038 if (!*plparam) return -1;
1039 WideCharToMultiByte(CP_ACP, 0, str, -1, (LPSTR)*plparam, len, 0, 0);
1040 return 1;
1041 }
1042 return 0;
1043
1044 case WM_MDICREATE:
1045 {
1046 MDICREATESTRUCTA *cs = HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
1047 if (!cs) return -1;
1048 *cs = *(MDICREATESTRUCTA *)*plparam;
1049 if (HIWORD(cs->szTitle))
1050 {
1051 int len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)cs->szTitle, -1, NULL, 0, 0, 0);
1052 LPSTR buf = HeapAlloc(GetProcessHeap(), 0, len);
1053 if (buf) WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)cs->szTitle, -1, buf, len, 0, 0);
1054 cs->szTitle = buf;
1055 }
1056 if (HIWORD(cs->szClass))
1057 {
1058 int len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)cs->szClass, -1, NULL, 0, 0, 0);
1059 LPSTR buf = HeapAlloc(GetProcessHeap(), 0, len);
1060 if (buf) WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)cs->szClass, -1, buf, len, 0, 0);
1061 cs->szClass = buf;
1062 }
1063 *plparam = (LPARAM)cs;
1064 }
1065 return 1;
1066
1067 /* Listbox */
1068 case LB_ADDSTRING:
1069 case LB_INSERTSTRING:
1070 case LB_FINDSTRING:
1071 case LB_FINDSTRINGEXACT:
1072 case LB_SELECTSTRING:
1073 if(!*plparam) return 0;
1074 if ( WINPROC_TestLBForStr( hwnd ))
1075 {
1076 int len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)*plparam, -1, NULL, 0, 0, 0);
1077 LPSTR buf = HeapAlloc(GetProcessHeap(), 0, len);
1078 if (buf) WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)*plparam, -1, buf, len, 0, 0);
1079 *plparam = (LPARAM)buf;
1080 }
1081 return (*plparam ? 1 : -1);
1082
1083 case LB_GETTEXT: /* FIXME: fixed sized buffer */
1084 { if ( WINPROC_TestLBForStr( hwnd ))
1085 { LPARAM *ptr = HeapAlloc( GetProcessHeap(), 0, 512 + sizeof(LPARAM) );
1086 if (!ptr) return -1;
1087 *ptr++ = *plparam; /* Store previous lParam */
1088 *plparam = (LPARAM)ptr;
1089 }
1090 }
1091 return 1;
1092
1093 /* Combobox */
1094 case CB_ADDSTRING:
1095 case CB_INSERTSTRING:
1096 case CB_FINDSTRING:
1097 case CB_FINDSTRINGEXACT:
1098 case CB_SELECTSTRING:
1099 if(!*plparam) return 0;
1100 if ( WINPROC_TestCBForStr( hwnd ))
1101 {
1102 int len = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)*plparam, -1, NULL, 0, 0, 0);
1103 LPSTR buf = HeapAlloc(GetProcessHeap(), 0, len);
1104 if (buf) WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)*plparam, -1, buf, len, 0, 0);
1105 *plparam = (LPARAM)buf;
1106 }
1107 return (*plparam ? 1 : -1);
1108
1109 case CB_GETLBTEXT: /* FIXME: fixed sized buffer */
1110 { if ( WINPROC_TestCBForStr( hwnd ))
1111 { LPARAM *ptr = HeapAlloc( GetProcessHeap(), 0, 512 + sizeof(LPARAM) );
1112 if (!ptr) return -1;
1113 *ptr++ = *plparam; /* Store previous lParam */
1114 *plparam = (LPARAM)ptr;
1115 }
1116 }
1117 return 1;
1118
1119 /* Multiline edit */
1120 case EM_GETLINE:
1121 { WORD len = (WORD)*plparam;
1122 LPARAM *ptr = HeapAlloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(CHAR) );
1123 if (!ptr) return -1;
1124 *ptr++ = *plparam; /* Store previous lParam */
1125 *((WORD *) ptr) = len; /* Store the length */
1126 *plparam = (LPARAM)ptr;
1127 }
1128 return 1;
1129
1130 case WM_CHARTOITEM:
1131 case WM_MENUCHAR:
1132 case WM_CHAR:
1133 case WM_DEADCHAR:
1134 case WM_SYSCHAR:
1135 case WM_SYSDEADCHAR:
1136 case EM_SETPASSWORDCHAR:
1137 {
1138 WCHAR wch = LOWORD(*pwparam);
1139 BYTE ch;
1140 WideCharToMultiByte( CP_ACP, 0, &wch, 1, (LPSTR)&ch, 1, NULL, NULL );
1141 *pwparam = MAKEWPARAM( ch, HIWORD(*pwparam) );
1142 }
1143 return 0;
1144
1145 case WM_IME_CHAR:
1146 {
1147 WCHAR wch = LOWORD(*pwparam);
1148 BYTE ch[2];
1149
1150 if (WideCharToMultiByte( CP_ACP, 0, &wch, 1, (LPSTR)ch, 2, NULL, NULL ) == 2)
1151 *pwparam = MAKEWPARAM( (ch[0] << 8) | ch[1], HIWORD(*pwparam) );
1152 else
1153 *pwparam = MAKEWPARAM( ch[0], HIWORD(*pwparam) );
1154 }
1155 return 0;
1156
1157 case WM_PAINTCLIPBOARD:
1158 case WM_SIZECLIPBOARD:
1159 FIXME_(msg)("message %s (%04x) needs translation, please report\n",SPY_GetMsgName(msg, hwnd),msg );
1160 return -1;
1161 default: /* No translation needed */
1162 return 0;
1163 }
1164 }
1165
1166
1167 /**********************************************************************
1168 * WINPROC_UnmapMsg32WTo32A
1169 *
1170 * Unmap a message that was mapped from Unicode to Ansi.
1171 */
1172 static LRESULT WINPROC_UnmapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, LRESULT result )
1173 {
1174 switch(msg)
1175 {
1176 case WM_GETTEXT:
1177 case WM_ASKCBFORMATNAME:
1178 {
1179 LPARAM *ptr = (LPARAM *)lParam - 1;
1180 if (!wParam) result = 0;
1181 else if (!(result = MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1,
1182 (LPWSTR)*ptr, wParam )))
1183 {
1184 ((LPWSTR)*ptr)[wParam-1] = 0;
1185 result = wParam - 1;
1186 }
1187 else result--; /* do not count terminating null */
1188 HeapFree( GetProcessHeap(), 0, ptr );
1189 }
1190 break;
1191
1192 case WM_SETTEXT:
1193 case WM_WININICHANGE:
1194 case WM_DEVMODECHANGE:
1195 case CB_DIR:
1196 case LB_DIR:
1197 case LB_ADDFILE:
1198 case EM_REPLACESEL:
1199 HeapFree( GetProcessHeap(), 0, (void *)lParam );
1200 break;
1201
1202 case WM_MDICREATE:
1203 {
1204 MDICREATESTRUCTA *cs = (MDICREATESTRUCTA *)lParam;
1205 if (HIWORD(cs->szTitle))
1206 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
1207 if (HIWORD(cs->szClass))
1208 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
1209 HeapFree( GetProcessHeap(), 0, cs );
1210 }
1211 break;
1212
1213 /* Listbox */
1214 case LB_ADDSTRING:
1215 case LB_INSERTSTRING:
1216 case LB_FINDSTRING:
1217 case LB_FINDSTRINGEXACT:
1218 case LB_SELECTSTRING:
1219 if ( WINPROC_TestLBForStr( hwnd ))
1220 HeapFree( GetProcessHeap(), 0, (void *)lParam );
1221 break;
1222
1223 case LB_GETTEXT:
1224 if ( WINPROC_TestLBForStr( hwnd ))
1225 {
1226 LPARAM *ptr = (LPARAM *)lParam - 1;
1227 result = MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, 0x7fffffff ) - 1;
1228 HeapFree( GetProcessHeap(), 0, ptr );
1229 }
1230 break;
1231
1232 /* Combobox */
1233 case CB_ADDSTRING:
1234 case CB_INSERTSTRING:
1235 case CB_FINDSTRING:
1236 case CB_FINDSTRINGEXACT:
1237 case CB_SELECTSTRING:
1238 if ( WINPROC_TestCBForStr( hwnd ))
1239 HeapFree( GetProcessHeap(), 0, (void *)lParam );
1240 break;
1241
1242 case CB_GETLBTEXT:
1243 if ( result < 0) /* CB_ERR and CB_ERRSPACE */
1244 {
1245 LPARAM *ptr = (LPARAM *)lParam - 1;
1246 HeapFree( GetProcessHeap(), 0, ptr );
1247 }
1248 else if ( WINPROC_TestCBForStr( hwnd ))
1249 {
1250 LPARAM *ptr = (LPARAM *)lParam - 1;
1251 result = MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, 0x7fffffff ) - 1;
1252 HeapFree( GetProcessHeap(), 0, ptr );
1253 }
1254 break;
1255
1256 /* Multiline edit */
1257 case EM_GETLINE:
1258 {
1259 LPARAM * ptr = (LPARAM *)lParam - 1; /* get the old lparam */
1260 WORD len = *(WORD *)ptr;
1261 if (len)
1262 {
1263 result = MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, result, (LPWSTR)*ptr, len );
1264 if (result < len) ((LPWSTR)*ptr)[result] = 0;
1265 }
1266 HeapFree( GetProcessHeap(), 0, ptr );
1267 }
1268 break;
1269 }
1270 return result;
1271 }
1272
1273 static UINT convert_handle_16_to_32(HANDLE16 src, unsigned int flags)
1274 {
1275 HANDLE dst;
1276 UINT sz = GlobalSize16(src);
1277 LPSTR ptr16, ptr32;
1278
1279 if (!(dst = GlobalAlloc(flags, sz)))
1280 return 0;
1281 ptr16 = GlobalLock16(src);
1282 ptr32 = GlobalLock(dst);
1283 if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr32, ptr16, sz);
1284 GlobalUnlock16(src);
1285 GlobalUnlock(dst);
1286
1287 return (UINT)dst;
1288 }
1289
1290 /**********************************************************************
1291 * WINPROC_MapMsg16To32A
1292 *
1293 * Map a message from 16- to 32-bit Ansi.
1294 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1295 */
1296 INT WINPROC_MapMsg16To32A( HWND hwnd, UINT16 msg16, WPARAM16 wParam16, UINT *pmsg32,
1297 WPARAM *pwparam32, LPARAM *plparam )
1298 {
1299 *pmsg32 = (UINT)msg16;
1300 *pwparam32 = (WPARAM)wParam16;
1301 switch(msg16)
1302 {
1303 case WM_ACTIVATE:
1304 case WM_CHARTOITEM:
1305 case WM_COMMAND:
1306 case WM_VKEYTOITEM:
1307 *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
1308 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1309 return 0;
1310 case WM_HSCROLL:
1311 case WM_VSCROLL:
1312 *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1313 *plparam = (LPARAM)WIN_Handle32( HIWORD(*plparam) );
1314 return 0;
1315 case WM_CTLCOLOR:
1316 if ( HIWORD(*plparam) > CTLCOLOR_STATIC ) return -1;
1317 *pmsg32 = WM_CTLCOLORMSGBOX + HIWORD(*plparam);
1318 *pwparam32 = (WPARAM)HDC_32(wParam16);
1319 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1320 return 0;
1321 case WM_COMPAREITEM:
1322 {
1323 COMPAREITEMSTRUCT16* cis16 = MapSL(*plparam);
1324 COMPAREITEMSTRUCT *cis = HeapAlloc(GetProcessHeap(), 0, sizeof(*cis));
1325 if (!cis) return -1;
1326 cis->CtlType = cis16->CtlType;
1327 cis->CtlID = cis16->CtlID;
1328 cis->hwndItem = WIN_Handle32( cis16->hwndItem );
1329 cis->itemID1 = cis16->itemID1;
1330 cis->itemData1 = cis16->itemData1;
1331 cis->itemID2 = cis16->itemID2;
1332 cis->itemData2 = cis16->itemData2;
1333 cis->dwLocaleId = 0; /* FIXME */
1334 *plparam = (LPARAM)cis;
1335 }
1336 return 1;
1337 case WM_COPYDATA:
1338 {
1339 PCOPYDATASTRUCT16 pcds16 = MapSL(*plparam);
1340 PCOPYDATASTRUCT pcds = HeapAlloc ( GetProcessHeap(), 0, sizeof(*pcds));
1341 pcds->dwData = pcds16->dwData;
1342 pcds->cbData = pcds16->cbData;
1343 pcds->lpData = MapSL( pcds16->lpData);
1344 *plparam = (LPARAM)pcds;
1345 }
1346 return 1;
1347 case WM_DELETEITEM:
1348 {
1349 DELETEITEMSTRUCT16* dis16 = MapSL(*plparam);
1350 DELETEITEMSTRUCT *dis = HeapAlloc(GetProcessHeap(), 0, sizeof(*dis));
1351 if (!dis) return -1;
1352 dis->CtlType = dis16->CtlType;
1353 dis->CtlID = dis16->CtlID;
1354 dis->hwndItem = WIN_Handle32( dis16->hwndItem );
1355 dis->itemData = dis16->itemData;
1356 *plparam = (LPARAM)dis;
1357 }
1358 return 1;
1359 case WM_MEASUREITEM:
1360 {
1361 MEASUREITEMSTRUCT16* mis16 = MapSL(*plparam);
1362 MEASUREITEMSTRUCT *mis = HeapAlloc(GetProcessHeap(), 0,
1363 sizeof(*mis) + sizeof(LPARAM));
1364 if (!mis) return -1;
1365 mis->CtlType = mis16->CtlType;
1366 mis->CtlID = mis16->CtlID;
1367 mis->itemID = mis16->itemID;
1368 mis->itemWidth = mis16->itemWidth;
1369 mis->itemHeight = mis16->itemHeight;
1370 mis->itemData = mis16->itemData;
1371 *(LPARAM *)(mis + 1) = *plparam; /* Store the previous lParam */
1372 *plparam = (LPARAM)mis;
1373 }
1374 return 1;
1375 case WM_DRAWITEM:
1376 {
1377 DRAWITEMSTRUCT16* dis16 = MapSL(*plparam);
1378 DRAWITEMSTRUCT *dis = HeapAlloc(GetProcessHeap(), 0, sizeof(*dis));
1379 if (!dis) return -1;
1380 dis->CtlType = dis16->CtlType;
1381 dis->CtlID = dis16->CtlID;
1382 dis->itemID = dis16->itemID;
1383 dis->itemAction = dis16->itemAction;
1384 dis->itemState = dis16->itemState;
1385 dis->hwndItem = (dis->CtlType == ODT_MENU) ? (HWND)HMENU_32(dis16->hwndItem)
1386 : WIN_Handle32( dis16->hwndItem );
1387 dis->hDC = HDC_32(dis16->hDC);
1388 dis->itemData = dis16->itemData;
1389 dis->rcItem.left = dis16->rcItem.left;
1390 dis->rcItem.top = dis16->rcItem.top;
1391 dis->rcItem.right = dis16->rcItem.right;
1392 dis->rcItem.bottom = dis16->rcItem.bottom;
1393 *plparam = (LPARAM)dis;
1394 }
1395 return 1;
1396 case WM_GETMINMAXINFO:
1397 {
1398 MINMAXINFO *mmi = HeapAlloc( GetProcessHeap(), 0, sizeof(*mmi) + sizeof(LPARAM));
1399 if (!mmi) return -1;
1400 MINMAXINFO16to32( MapSL(*plparam), mmi );
1401 *(LPARAM *)(mmi + 1) = *plparam; /* Store the previous lParam */
1402 *plparam = (LPARAM)mmi;
1403 }
1404 return 1;
1405 case WM_GETTEXT:
1406 case WM_SETTEXT:
1407 case WM_WININICHANGE:
1408 case WM_DEVMODECHANGE:
1409 case WM_ASKCBFORMATNAME:
1410 *plparam = (LPARAM)MapSL(*plparam);
1411 return 0;
1412 case WM_MDICREATE:
1413 {
1414 MDICREATESTRUCT16 *cs16 = MapSL(*plparam);
1415 MDICREATESTRUCTA *cs = HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) + sizeof(LPARAM) );
1416 if (!cs) return -1;
1417 MDICREATESTRUCT16to32A( cs16, cs );
1418 cs->szTitle = MapSL(cs16->szTitle);
1419 cs->szClass = MapSL(cs16->szClass);
1420 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1421 *plparam = (LPARAM)cs;
1422 }
1423 return 1;
1424 case WM_MDIGETACTIVE:
1425 *plparam = (LPARAM)HeapAlloc( GetProcessHeap(), 0, sizeof(BOOL) );
1426 *(BOOL*)(*plparam) = 0;
1427 return 1;
1428 case WM_MDISETMENU:
1429 if(wParam16) *pmsg32=WM_MDIREFRESHMENU;
1430 *pwparam32 = (WPARAM)HMENU_32(LOWORD(*plparam));
1431 *plparam = (LPARAM)HMENU_32(HIWORD(*plparam));
1432 return 0;
1433 case WM_MENUCHAR:
1434 *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1435 *plparam = (LPARAM)HMENU_32(HIWORD(*plparam));
1436 return 0;
1437 case WM_MENUSELECT:
1438 if((LOWORD(*plparam) & MF_POPUP) && (LOWORD(*plparam) != 0xFFFF))
1439 {
1440 HMENU hmenu=HMENU_32(HIWORD(*plparam));
1441 UINT Pos=MENU_FindSubMenu( &hmenu, HMENU_32(wParam16));
1442 if(Pos==0xFFFF) Pos=0; /* NO_SELECTED_ITEM */
1443 *pwparam32 = MAKEWPARAM( Pos, LOWORD(*plparam) );
1444 }
1445 else *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1446 *plparam = (LPARAM)HMENU_32(HIWORD(*plparam));
1447 return 0;
1448 case WM_MDIACTIVATE:
1449 if( *plparam )
1450 {
1451 *pwparam32 = (WPARAM)WIN_Handle32( HIWORD(*plparam) );
1452 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1453 }
1454 else /* message sent to MDI client */
1455 *pwparam32 = wParam16;
1456 return 0;
1457 case WM_NCCALCSIZE:
1458 {
1459 NCCALCSIZE_PARAMS16 *nc16;
1460 NCCALCSIZE_PARAMS *nc;
1461
1462 nc = HeapAlloc( GetProcessHeap(), 0, sizeof(*nc) + sizeof(LPARAM) );
1463 if (!nc) return -1;
1464 nc16 = MapSL(*plparam);
1465 nc->rgrc[0].left = nc16->rgrc[0].left;
1466 nc->rgrc[0].top = nc16->rgrc[0].top;
1467 nc->rgrc[0].right = nc16->rgrc[0].right;
1468 nc->rgrc[0].bottom = nc16->rgrc[0].bottom;
1469 if (wParam16)
1470 {
1471 nc->lppos = HeapAlloc( GetProcessHeap(), 0, sizeof(*nc->lppos) );
1472 nc->rgrc[1].left = nc16->rgrc[1].left;
1473 nc->rgrc[1].top = nc16->rgrc[1].top;
1474 nc->rgrc[1].right = nc16->rgrc[1].right;
1475 nc->rgrc[1].bottom = nc16->rgrc[1].bottom;
1476 nc->rgrc[2].left = nc16->rgrc[2].left;
1477 nc->rgrc[2].top = nc16->rgrc[2].top;
1478 nc->rgrc[2].right = nc16->rgrc[2].right;
1479 nc->rgrc[2].bottom = nc16->rgrc[2].bottom;
1480 if (nc->lppos) WINDOWPOS16to32( MapSL(nc16->lppos), nc->lppos );
1481 }
1482 *(LPARAM *)(nc + 1) = *plparam; /* Store the previous lParam */
1483 *plparam = (LPARAM)nc;
1484 }
1485 return 1;
1486 case WM_NCCREATE:
1487 case WM_CREATE:
1488 {
1489 CREATESTRUCT16 *cs16 = MapSL(*plparam);
1490 CREATESTRUCTA *cs = HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) + sizeof(LPARAM) );
1491 if (!cs) return -1;
1492 CREATESTRUCT16to32A( cs16, cs );
1493 cs->lpszName = MapSL(cs16->lpszName);
1494 cs->lpszClass = MapSL(cs16->lpszClass);
1495
1496 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
1497 {
1498 MDICREATESTRUCT16 *mdi_cs16;
1499 MDICREATESTRUCTA *mdi_cs = HeapAlloc(GetProcessHeap(), 0, sizeof(*mdi_cs));
1500 if (!mdi_cs)
1501 {
1502 HeapFree(GetProcessHeap(), 0, cs);
1503 return -1;
1504 }
1505 mdi_cs16 = (MDICREATESTRUCT16 *)MapSL(cs16->lpCreateParams);
1506 MDICREATESTRUCT16to32A(mdi_cs16, mdi_cs);
1507 mdi_cs->szTitle = MapSL(mdi_cs16->szTitle);
1508 mdi_cs->szClass = MapSL(mdi_cs16->szClass);
1509
1510 cs->lpCreateParams = mdi_cs;
1511 }
1512 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1513 *plparam = (LPARAM)cs;
1514 }
1515 return 1;
1516 case WM_PARENTNOTIFY:
1517 if ((wParam16 == WM_CREATE) || (wParam16 == WM_DESTROY))
1518 {
1519 *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
1520 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1521 }
1522 return 0;
1523 case WM_WINDOWPOSCHANGING:
1524 case WM_WINDOWPOSCHANGED:
1525 {
1526 WINDOWPOS *wp = HeapAlloc( GetProcessHeap(), 0, sizeof(*wp) + sizeof(LPARAM) );
1527 if (!wp) return -1;
1528 WINDOWPOS16to32( MapSL(*plparam), wp );
1529 *(LPARAM *)(wp + 1) = *plparam; /* Store the previous lParam */
1530 *plparam = (LPARAM)wp;
1531 }
1532 return 1;
1533 case WM_GETDLGCODE:
1534 if (*plparam)
1535 {
1536 LPMSG16 msg16 = MapSL(*plparam);
1537 LPMSG msg32 = HeapAlloc( GetProcessHeap(), 0, sizeof(MSG) );
1538
1539 if (!msg32) return -1;
1540 msg32->hwnd = WIN_Handle32( msg16->hwnd );
1541 msg32->lParam = msg16->lParam;
1542 msg32->time = msg16->time;
1543 msg32->pt.x = msg16->pt.x;
1544 msg32->pt.y = msg16->pt.y;
1545 /* this is right, right? */
1546 if (WINPROC_MapMsg16To32A( msg32->hwnd, msg16->message,msg16->wParam,
1547 &msg32->message,&msg32->wParam,
1548 &msg32->lParam)<0) {
1549 HeapFree( GetProcessHeap(), 0, msg32 );
1550 return -1;
1551 }
1552 *plparam = (LPARAM)msg32;
1553 return 1;
1554 }
1555 else return 0;
1556 case WM_NOTIFY:
1557 *plparam = (LPARAM)MapSL(*plparam);
1558 return 0;
1559 case WM_ACTIVATEAPP:
1560 /* We need this when SetActiveWindow sends a Sendmessage16() to
1561 * a 32bit window. Might be superflous with 32bit interprocess
1562 * message queues. */
1563 if (*plparam) *plparam = HTASK_32( *plparam );
1564 return 0;
1565 case WM_NEXTMENU:
1566 {
1567 MDINEXTMENU *next = HeapAlloc( GetProcessHeap(), 0, sizeof(*next) );
1568 if (!next) return -1;
1569 next->hmenuIn = (HMENU)*plparam;
1570 next->hmenuNext = 0;
1571 next->hwndNext = 0;
1572 *plparam = (LPARAM)next;
1573 return 1;
1574 }
1575 case WM_PAINTCLIPBOARD:
1576 case WM_SIZECLIPBOARD:
1577 FIXME_(msg)("message %04x needs translation\n",msg16 );
1578 return -1;
1579 case WM_DDE_INITIATE:
1580 case WM_DDE_TERMINATE:
1581 case WM_DDE_UNADVISE:
1582 case WM_DDE_REQUEST:
1583 *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1584 return 0;
1585 case WM_DDE_ADVISE:
1586 case WM_DDE_DATA:
1587 case WM_DDE_POKE:
1588 {
1589 HANDLE16 lo16;
1590 ATOM hi;
1591 UINT lo32 = 0;
1592
1593 *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1594 lo16 = LOWORD(*plparam);
1595 hi = HIWORD(*plparam);
1596 if (lo16 && !(lo32 = convert_handle_16_to_32(lo16, GMEM_DDESHARE)))
1597 return -1;
1598 *plparam = PackDDElParam(msg16, lo32, hi);
1599 }
1600 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
1601 case WM_DDE_ACK:
1602 {
1603 UINT lo, hi;
1604 int flag = 0;
1605 char buf[2];
1606
1607 *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1608
1609 lo = LOWORD(*plparam);
1610 hi = HIWORD(*plparam);
1611
1612 if (GlobalGetAtomNameA(hi, buf, 2) > 0) flag |= 1;
1613 if (GlobalSize16(hi) != 0) flag |= 2;
1614 switch (flag)
1615 {
1616 case 0:
1617 if (hi)
1618 {
1619 MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
1620 hi = 0;
1621 }
1622 break;
1623 case 1:
1624 break; /* atom, nothing to do */
1625 case 3:
1626 MESSAGE("DDE_ACK: %x both atom and handle... choosing handle\n", hi);
1627 /* fall thru */
1628 case 2:
1629 hi = convert_handle_16_to_32(hi, GMEM_DDESHARE);
1630 break;
1631 }
1632 *plparam = PackDDElParam(WM_DDE_ACK, lo, hi);
1633 }
1634 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
1635 case WM_DDE_EXECUTE:
1636 *plparam = convert_handle_16_to_32(*plparam, GMEM_DDESHARE);
1637 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
1638 default: /* No translation needed */
1639 return 0;
1640 }
1641 }
1642
1643
1644 /**********************************************************************
1645 * WINPROC_UnmapMsg16To32A
1646 *
1647 * Unmap a message that was mapped from 16- to 32-bit Ansi.
1648 */
1649 LRESULT WINPROC_UnmapMsg16To32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
1650 LRESULT result )
1651 {
1652 switch(msg)
1653 {
1654 case WM_COMPAREITEM:
1655 case WM_DELETEITEM:
1656 case WM_DRAWITEM:
1657 case WM_COPYDATA:
1658 HeapFree( GetProcessHeap(), 0, (LPVOID)lParam );
1659 break;
1660 case WM_MEASUREITEM:
1661 {
1662 MEASUREITEMSTRUCT16 *mis16;
1663 MEASUREITEMSTRUCT *mis = (MEASUREITEMSTRUCT *)lParam;
1664 lParam = *(LPARAM *)(mis + 1);
1665 mis16 = MapSL(lParam);
1666 mis16->itemWidth = (UINT16)mis->itemWidth;
1667 mis16->itemHeight = (UINT16)mis->itemHeight;
1668 HeapFree( GetProcessHeap(), 0, mis );
1669 }
1670 break;
1671 case WM_GETMINMAXINFO:
1672 {
1673 MINMAXINFO *mmi = (MINMAXINFO *)lParam;
1674 lParam = *(LPARAM *)(mmi + 1);
1675 MINMAXINFO32to16( mmi, MapSL(lParam));
1676 HeapFree( GetProcessHeap(), 0, mmi );
1677 }
1678 break;
1679 case WM_MDICREATE:
1680 {
1681 MDICREATESTRUCTA *cs = (MDICREATESTRUCTA *)lParam;
1682 lParam = *(LPARAM *)(cs + 1);
1683 MDICREATESTRUCT32Ato16( cs, MapSL(lParam) );
1684 HeapFree( GetProcessHeap(), 0, cs );
1685 }
1686 break;
1687 case WM_MDIGETACTIVE:
1688 result = MAKELONG( LOWORD(result), (BOOL16)(*(BOOL *)lParam) );
1689 HeapFree( GetProcessHeap(), 0, (BOOL *)lParam );
1690 break;
1691 case WM_NCCALCSIZE:
1692 {
1693 NCCALCSIZE_PARAMS16 *nc16;
1694 NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lParam;
1695 lParam = *(LPARAM *)(nc + 1);
1696 nc16 = MapSL(lParam);
1697 nc16->rgrc[0].left = nc->rgrc[0].left;
1698 nc16->rgrc[0].top = nc->rgrc[0].top;
1699 nc16->rgrc[0].right = nc->rgrc[0].right;
1700 nc16->rgrc[0].bottom = nc->rgrc[0].bottom;
1701 if (wParam)
1702 {
1703 nc16->rgrc[1].left = nc->rgrc[1].left;
1704 nc16->rgrc[1].top = nc->rgrc[1].top;
1705 nc16->rgrc[1].right = nc->rgrc[1].right;
1706 nc16->rgrc[1].bottom = nc->rgrc[1].bottom;
1707 nc16->rgrc[2].left = nc->rgrc[2].left;
1708 nc16->rgrc[2].top = nc->rgrc[2].top;
1709 nc16->rgrc[2].right = nc->rgrc[2].right;
1710 nc16->rgrc[2].bottom = nc->rgrc[2].bottom;
1711 if (nc->lppos)
1712 {
1713 WINDOWPOS32to16( nc->lppos, MapSL(nc16->lppos));
1714 HeapFree( GetProcessHeap(), 0, nc->lppos );
1715 }
1716 }
1717 HeapFree( GetProcessHeap(), 0, nc );
1718 }
1719 break;
1720 case WM_NCCREATE:
1721 case WM_CREATE:
1722 {
1723 CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
1724 lParam = *(LPARAM *)(cs + 1);
1725 CREATESTRUCT32Ato16( cs, MapSL(lParam) );
1726
1727 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
1728 HeapFree(GetProcessHeap(), 0, cs->lpCreateParams);
1729
1730 HeapFree( GetProcessHeap(), 0, cs );
1731 }
1732 break;
1733 case WM_WINDOWPOSCHANGING:
1734 case WM_WINDOWPOSCHANGED:
1735 {
1736 WINDOWPOS *wp = (WINDOWPOS *)lParam;
1737 lParam = *(LPARAM *)(wp + 1);
1738 WINDOWPOS32to16(wp, MapSL(lParam));
1739 HeapFree( GetProcessHeap(), 0, wp );
1740 }
1741 break;
1742 case WM_GETDLGCODE:
1743 if (lParam)
1744 {
1745 LPMSG msg32 = (LPMSG)lParam;
1746
1747 WINPROC_UnmapMsg16To32A( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1748 result);
1749 HeapFree( GetProcessHeap(), 0, msg32 );
1750 }
1751 break;
1752 case WM_NEXTMENU:
1753 {
1754 MDINEXTMENU *next = (MDINEXTMENU *)lParam;
1755 result = MAKELONG( HMENU_16(next->hmenuNext), HWND_16(next->hwndNext) );
1756 HeapFree( GetProcessHeap(), 0, next );
1757 }
1758 break;
1759 }
1760 return result;
1761 }
1762
1763
1764 /**********************************************************************
1765 * WINPROC_MapMsg16To32W
1766 *
1767 * Map a message from 16- to 32-bit Unicode.
1768 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1769 */
1770 INT WINPROC_MapMsg16To32W( HWND hwnd, UINT16 msg16, WPARAM16 wParam16, UINT *pmsg32,
1771 WPARAM *pwparam32, LPARAM *plparam )
1772 {
1773 CHAR ch;
1774 WCHAR wch;
1775
1776 *pmsg32=(UINT)msg16;
1777 *pwparam32 = (WPARAM)wParam16;
1778 switch(msg16)
1779 {
1780 case WM_GETTEXT:
1781 case WM_SETTEXT:
1782 case WM_WININICHANGE:
1783 case WM_DEVMODECHANGE:
1784 case WM_ASKCBFORMATNAME:
1785 *plparam = (LPARAM)MapSL(*plparam);
1786 return WINPROC_MapMsg32ATo32W( hwnd, *pmsg32, pwparam32, plparam );
1787 case WM_GETTEXTLENGTH:
1788 case CB_GETLBTEXTLEN:
1789 case LB_GETTEXTLEN:
1790 return 1; /* need to map result */
1791 case WM_NCCREATE:
1792 case WM_CREATE:
1793 {
1794 CREATESTRUCT16 *cs16 = MapSL(*plparam);
1795 CREATESTRUCTW *cs = HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) + sizeof(LPARAM) );
1796 if (!cs) return -1;
1797 CREATESTRUCT16to32A( cs16, (CREATESTRUCTA *)cs );
1798 cs->lpszName = map_str_16_to_32W(cs16->lpszName);
1799 cs->lpszClass = map_str_16_to_32W(cs16->lpszClass);
1800
1801 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
1802 {
1803 MDICREATESTRUCT16 *mdi_cs16;
1804 MDICREATESTRUCTW *mdi_cs = HeapAlloc(GetProcessHeap(), 0, sizeof(*mdi_cs));
1805 if (!mdi_cs)
1806 {
1807 HeapFree(GetProcessHeap(), 0, cs);
1808 return -1;
1809 }
1810 mdi_cs16 = (MDICREATESTRUCT16 *)MapSL(cs16->lpCreateParams);
1811 MDICREATESTRUCT16to32A(mdi_cs16, (MDICREATESTRUCTA *)mdi_cs);
1812 mdi_cs->szTitle = map_str_16_to_32W(mdi_cs16->szTitle);
1813 mdi_cs->szClass = map_str_16_to_32W(mdi_cs16->szClass);
1814
1815 cs->lpCreateParams = mdi_cs;
1816 }
1817 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1818 *plparam = (LPARAM)cs;
1819 }
1820 return 1;
1821 case WM_MDICREATE:
1822 {
1823 MDICREATESTRUCT16 *cs16 = MapSL(*plparam);
1824 MDICREATESTRUCTW *cs = HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) + sizeof(LPARAM) );
1825 if (!cs) return -1;
1826 MDICREATESTRUCT16to32A( cs16, (MDICREATESTRUCTA *)cs );
1827 cs->szTitle = map_str_16_to_32W(cs16->szTitle);
1828 cs->szClass = map_str_16_to_32W(cs16->szClass);
1829 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1830 *plparam = (LPARAM)cs;
1831 }
1832 return 1;
1833 case WM_GETDLGCODE:
1834 if (*plparam)
1835 {
1836 LPMSG16 msg16 = MapSL(*plparam);
1837 LPMSG msg32 = HeapAlloc( GetProcessHeap(), 0, sizeof(MSG) );
1838
1839 if (!msg32) return -1;
1840 msg32->hwnd = WIN_Handle32( msg16->hwnd );
1841 msg32->lParam = msg16->lParam;
1842 msg32->time = msg16->time;
1843 msg32->pt.x = msg16->pt.x;
1844 msg32->pt.y = msg16->pt.y;
1845 /* this is right, right? */
1846 if (WINPROC_MapMsg16To32W(hwnd, msg16->message,msg16->wParam,
1847 &msg32->message,&msg32->wParam,
1848 &msg32->lParam)<0) {
1849 HeapFree( GetProcessHeap(), 0, msg32 );
1850 return -1;
1851 }
1852 *plparam = (LPARAM)msg32;
1853 return 1;
1854 }
1855 else return 0;
1856
1857 case WM_CHARTOITEM:
1858 ch = wParam16;
1859 MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1860 *pwparam32 = MAKEWPARAM( wch, HIWORD(*plparam) );
1861 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1862 return 0;
1863 case WM_MENUCHAR:
1864 ch = wParam16;
1865 MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1866 *pwparam32 = MAKEWPARAM( wch, LOWORD(*plparam) );
1867 *plparam = (LPARAM)HMENU_32(HIWORD(*plparam));
1868 return 0;
1869 case WM_CHAR:
1870 case WM_DEADCHAR:
1871 case WM_SYSCHAR:
1872 case WM_SYSDEADCHAR:
1873 ch = wParam16;
1874 MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1875 *pwparam32 = wch;
1876 return 0;
1877 case WM_IME_CHAR:
1878 return WINPROC_MapMsg32ATo32W( hwnd, *pmsg32, pwparam32, plparam );
1879
1880 default: /* No Unicode translation needed */
1881 return WINPROC_MapMsg16To32A( hwnd, msg16, wParam16, pmsg32,
1882 pwparam32, plparam );
1883 }
1884 }
1885
1886
1887 /**********************************************************************
1888 * WINPROC_UnmapMsg16To32W
1889 *
1890 * Unmap a message that was mapped from 16- to 32-bit Unicode.
1891 */
1892 LRESULT WINPROC_UnmapMsg16To32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
1893 LRESULT result, WNDPROC dispatch )
1894 {
1895 switch(msg)
1896 {
1897 case WM_GETTEXT:
1898 case WM_SETTEXT:
1899 case WM_GETTEXTLENGTH:
1900 case CB_GETLBTEXTLEN:
1901 case LB_GETTEXTLEN:
1902 case WM_ASKCBFORMATNAME:
1903 return WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam, result, dispatch );
1904 case WM_NCCREATE:
1905 case WM_CREATE:
1906 {
1907 CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
1908 lParam = *(LPARAM *)(cs + 1);
1909 CREATESTRUCT32Ato16( (CREATESTRUCTA *)cs, MapSL(lParam) );
1910 unmap_str_16_to_32W( cs->lpszName );
1911 unmap_str_16_to_32W( cs->lpszClass );
1912
1913 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
1914 {
1915 MDICREATESTRUCTW *mdi_cs = (MDICREATESTRUCTW *)cs->lpCreateParams;
1916 unmap_str_16_to_32W( mdi_cs->szTitle );
1917 unmap_str_16_to_32W( mdi_cs->szClass );
1918 HeapFree(GetProcessHeap(), 0, cs->lpCreateParams);
1919 }
1920 HeapFree( GetProcessHeap(), 0, cs );
1921 }
1922 break;
1923 case WM_MDICREATE:
1924 {
1925 MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lParam;
1926 lParam = *(LPARAM *)(cs + 1);
1927 MDICREATESTRUCT32Ato16( (MDICREATESTRUCTA *)cs, MapSL(lParam) );
1928 unmap_str_16_to_32W( cs->szTitle );
1929 unmap_str_16_to_32W( cs->szClass );
1930 HeapFree( GetProcessHeap(), 0, cs );
1931 }
1932 break;
1933 case WM_GETDLGCODE:
1934 if (lParam)
1935 {
1936 LPMSG msg32 = (LPMSG)lParam;
1937
1938 WINPROC_UnmapMsg16To32W( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1939 result, dispatch );
1940 HeapFree( GetProcessHeap(), 0, msg32 );
1941 }
1942 break;
1943 default:
1944 return WINPROC_UnmapMsg16To32A( hwnd, msg, wParam, lParam, result );
1945 }
1946 return result;
1947 }
1948
1949 static HANDLE16 convert_handle_32_to_16(UINT src, unsigned int flags)
1950 {
1951 HANDLE16 dst;
1952 UINT sz = GlobalSize((HANDLE)src);
1953 LPSTR ptr16, ptr32;
1954
1955 if (!(dst = GlobalAlloc16(flags, sz)))
1956 return 0;
1957 ptr32 = GlobalLock((HANDLE)src);
1958 ptr16 = GlobalLock16(dst);
1959 if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr16, ptr32, sz);
1960 GlobalUnlock((HANDLE)src);
1961 GlobalUnlock16(dst);
1962
1963 return dst;
1964 }
1965
1966
1967 /**********************************************************************
1968 * WINPROC_MapMsg32ATo16
1969 *
1970 * Map a message from 32-bit Ansi to 16-bit.
1971 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1972 */
1973 INT WINPROC_MapMsg32ATo16( HWND hwnd, UINT msg32, WPARAM wParam32,
1974 UINT16 *pmsg16, WPARAM16 *pwparam16,
1975 LPARAM *plparam )
1976 {
1977 *pmsg16 = (UINT16)msg32;
1978 *pwparam16 = (WPARAM16)LOWORD(wParam32);
1979 switch(msg32)
1980 {
1981 case SBM_SETRANGE:
1982 *pmsg16 = SBM_SETRANGE16;
1983 *plparam = MAKELPARAM(wParam32, *plparam);
1984 *pwparam16 = 0;
1985 return 0;
1986
1987 case SBM_GETRANGE:
1988 *pmsg16 = SBM_GETRANGE16;
1989 return 1;
1990
1991 case BM_GETCHECK:
1992 case BM_SETCHECK:
1993 case BM_GETSTATE:
1994 case BM_SETSTATE:
1995 case BM_SETSTYLE:
1996 *pmsg16 = (UINT16)msg32 + (BM_GETCHECK16 - BM_GETCHECK);
1997 return 0;
1998
1999 case EM_GETSEL:
2000 case EM_GETRECT:
2001 case EM_SETRECT:
2002 case EM_SETRECTNP:
2003 case EM_SCROLL:
2004 case EM_LINESCROLL:
2005 case EM_SCROLLCARET:
2006 case EM_GETMODIFY:
2007 case EM_SETMODIFY:
2008 case EM_GETLINECOUNT:
2009 case EM_LINEINDEX:
2010 case EM_SETHANDLE:
2011 case EM_GETHANDLE:
2012 case EM_GETTHUMB:
2013 case EM_LINELENGTH:
2014 case EM_REPLACESEL:
2015 case EM_GETLINE:
2016 case EM_LIMITTEXT:
2017 case EM_CANUNDO:
2018 case EM_UNDO:
2019 case EM_FMTLINES:
2020 case EM_LINEFROMCHAR:
2021 case EM_SETTABSTOPS:
2022 case EM_SETPASSWORDCHAR:
2023 case EM_EMPTYUNDOBUFFER:
2024 case EM_GETFIRSTVISIBLELINE:
2025 case EM_SETREADONLY:
2026 case EM_SETWORDBREAKPROC:
2027 case EM_GETWORDBREAKPROC:
2028 case EM_GETPASSWORDCHAR:
2029 *pmsg16 = (UINT16)msg32 + (EM_GETSEL16 - EM_GETSEL);
2030 return 0;
2031
2032 case LB_CARETOFF:
2033 case LB_CARETON:
2034 case LB_DELETESTRING:
2035 case LB_GETANCHORINDEX:
2036 case LB_GETCARETINDEX:
2037 case LB_GETCOUNT:
2038 case LB_GETCURSEL:
2039 case LB_GETHORIZONTALEXTENT:
2040 case LB_GETITEMDATA:
2041 case LB_GETITEMHEIGHT:
2042 case LB_GETSEL:
2043 case LB_GETSELCOUNT:
2044 case LB_GETTEXTLEN:
2045 case LB_GETTOPINDEX:
2046 case LB_RESETCONTENT:
2047 case LB_SELITEMRANGE:
2048 case LB_SELITEMRANGEEX:
2049 case LB_SETANCHORINDEX:
2050 case LB_SETCARETINDEX:
2051 case LB_SETCOLUMNWIDTH:
2052 case LB_SETCURSEL:
2053 case LB_SETHORIZONTALEXTENT:
2054 case LB_SETITEMDATA:
2055 case LB_SETITEMHEIGHT:
2056 case LB_SETSEL:
2057 case LB_SETTOPINDEX:
2058 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
2059 return 0;
2060 case CB_DELETESTRING:
2061 case CB_GETCOUNT:
2062 case CB_GETLBTEXTLEN:
2063 case CB_LIMITTEXT:
2064 case CB_RESETCONTENT:
2065 case CB_SETEDITSEL:
2066 case CB_GETCURSEL:
2067 case CB_SETCURSEL:
2068 case CB_SHOWDROPDOWN:
2069 case CB_SETITEMDATA:
2070 case CB_SETITEMHEIGHT:
2071 case CB_GETITEMHEIGHT:
2072 case CB_SETEXTENDEDUI:
2073 case CB_GETEXTENDEDUI:
2074 case CB_GETDROPPEDSTATE:
2075 *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL);
2076 return 0;
2077 case CB_GETEDITSEL:
2078 *pmsg16 = CB_GETEDITSEL16;
2079 return 1;
2080
2081 case LB_ADDSTRING:
2082 case LB_FINDSTRING:
2083 case LB_FINDSTRINGEXACT:
2084 case LB_INSERTSTRING:
2085 case LB_SELECTSTRING:
2086 case LB_DIR:
2087 case LB_ADDFILE:
2088 *plparam = (LPARAM)MapLS( (LPSTR)*plparam );
2089 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
2090 return 1;
2091
2092 case CB_ADDSTRING:
2093 case CB_FINDSTRING:
2094 case CB_FINDSTRINGEXACT:
2095 case CB_INSERTSTRING:
2096 case CB_SELECTSTRING:
2097 case CB_DIR:
2098 *plparam = (LPARAM)MapLS( (LPSTR)*plparam );
2099 *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL);
2100 return 1;
2101
2102 case LB_GETITEMRECT:
2103 {
2104 RECT16 *rect = HeapAlloc( GetProcessHeap(), 0, sizeof(RECT16) + sizeof(LPARAM) );
2105 if (!rect) return -1;
2106 *(LPARAM *)(rect + 1) = *plparam; /* Store the previous lParam */
2107 *plparam = MapLS( rect );
2108 }
2109 *pmsg16 = LB_GETITEMRECT16;
2110 return 1;
2111 case LB_GETSELITEMS:
2112 {
2113 LPARAM *items; /* old LPARAM first, then *pwparam16 x INT16 entries */
2114
2115 *pwparam16 = (WPARAM16)min( wParam32, 0x7f80 ); /* Must be < 64K */
2116 if (!(items = HeapAlloc( GetProcessHeap(), 0,
2117 *pwparam16 * sizeof(INT16) + sizeof(LPARAM)))) return -1;
2118 *items++ = *plparam; /* Store the previous lParam */
2119 *plparam = MapLS( items );
2120 }
2121 *pmsg16 = LB_GETSELITEMS16;
2122 return 1;
2123 case LB_SETTABSTOPS:
2124 if (wParam32)
2125 {
2126 INT i;
2127 LPINT16 stops;
2128 *pwparam16 = (WPARAM16)min( wParam32, 0x7f80 ); /* Must be < 64K */
2129 if (!(stops = HeapAlloc( GetProcessHeap(), 0,
2130 *pwparam16 * sizeof(INT16) + sizeof(LPARAM)))) return -1;
2131 for (i = 0; i < *pwparam16; i++) stops[i] = *((LPINT)*plparam+i);
2132 *plparam = MapLS( stops );
2133 return 1;
2134 }
2135 *pmsg16 = LB_SETTABSTOPS16;
2136 return 0;
2137
2138 case CB_GETDROPPEDCONTROLRECT:
2139 {
2140 RECT16 *rect = HeapAlloc( GetProcessHeap(), 0, sizeof(RECT16) + sizeof(LPARAM) );
2141 if (!rect) return -1;
2142 *(LPARAM *)(rect + 1) = *plparam; /* Store the previous lParam */
2143 *plparam = (LPARAM)MapLS(rect);
2144 }
2145 *pmsg16 = CB_GETDROPPEDCONTROLRECT16;
2146 return 1;
2147
2148 case LB_GETTEXT:
2149 *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
2150 *pmsg16 = LB_GETTEXT16;
2151 return 1;
2152
2153 case CB_GETLBTEXT:
2154 *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
2155 *pmsg16 = CB_GETLBTEXT16;
2156 return 1;
2157
2158 case EM_SETSEL:
2159 *pwparam16 = 0;
2160 *plparam = MAKELONG( (INT16)(INT)wParam32, (INT16)*plparam );
2161 *pmsg16 = EM_SETSEL16;
2162 return 0;
2163
2164 case WM_ACTIVATE:
2165 case WM_CHARTOITEM:
2166 case WM_COMMAND:
2167 case WM_VKEYTOITEM:
2168 *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32) );
2169 return 0;
2170 case WM_HSCROLL:
2171 case WM_VSCROLL:
2172 *plparam = MAKELPARAM( HIWORD(wParam32), (HWND16)*plparam );
2173 return 0;
2174 case WM_COPYDATA:
2175 {
2176 PCOPYDATASTRUCT pcds32 = (PCOPYDATASTRUCT) *plparam;
2177 PCOPYDATASTRUCT16 pcds = HeapAlloc( GetProcessHeap(), 0, sizeof( *pcds));
2178 pcds->dwData = pcds32->dwData;
2179 pcds->cbData = pcds32->cbData;
2180 pcds->lpData = MapLS( pcds32->lpData);
2181 *plparam = MapLS( pcds );
2182 }
2183 return 1;
2184 case WM_CTLCOLORMSGBOX:
2185 case WM_CTLCOLOREDIT:
2186 case WM_CTLCOLORLISTBOX:
2187 case WM_CTLCOLORBTN:
2188 case WM_CTLCOLORDLG:
2189 case WM_CTLCOLORSCROLLBAR:
2190 case WM_CTLCOLORSTATIC:
2191 *pmsg16 = WM_CTLCOLOR;
2192 *plparam = MAKELPARAM( (HWND16)*plparam,
2193 (WORD)msg32 - WM_CTLCOLORMSGBOX );
2194 return 0;
2195 case WM_COMPAREITEM:
2196 {
2197 COMPAREITEMSTRUCT *cis32 = (COMPAREITEMSTRUCT *)*plparam;
2198 COMPAREITEMSTRUCT16 *cis = HeapAlloc( GetProcessHeap(), 0, sizeof(COMPAREITEMSTRUCT16));
2199 if (!cis) return -1;
2200 cis->CtlType = (UINT16)cis32->CtlType;
2201 cis->CtlID = (UINT16)cis32->CtlID;
2202 cis->hwndItem = HWND_16( cis32->hwndItem );
2203 cis->itemID1 = (UINT16)cis32->itemID1;
2204 cis->itemData1 = cis32->itemData1;
2205 cis->itemID2 = (UINT16)cis32->itemID2;
2206 cis->itemData2 = cis32->itemData2;
2207 *plparam = MapLS( cis );
2208 }
2209 return 1;
2210 case WM_DELETEITEM:
2211 {
2212 DELETEITEMSTRUCT *dis32 = (DELETEITEMSTRUCT *)*plparam;
2213 DELETEITEMSTRUCT16 *dis = HeapAlloc( GetProcessHeap(), 0, sizeof(DELETEITEMSTRUCT16) );
2214 if (!dis) return -1;
2215 dis->CtlType = (UINT16)dis32->CtlType;
2216 dis->CtlID = (UINT16)dis32->CtlID;
2217 dis->itemID = (UINT16)dis32->itemID;
2218 dis->hwndItem = (dis->CtlType == ODT_MENU) ? (HWND16)LOWORD(dis32->hwndItem)
2219 : HWND_16( dis32->hwndItem );
2220 dis->itemData = dis32->itemData;
2221 *plparam = MapLS( dis );
2222 }
2223 return 1;
2224 case WM_DRAWITEM:
2225 {
2226 DRAWITEMSTRUCT *dis32 = (DRAWITEMSTRUCT *)*plparam;
2227 DRAWITEMSTRUCT16 *dis = HeapAlloc( GetProcessHeap(), 0, sizeof(DRAWITEMSTRUCT16) );
2228 if (!dis) return -1;
2229 dis->CtlType = (UINT16)dis32->CtlType;
2230 dis->CtlID = (UINT16)dis32->CtlID;
2231 dis->itemID = (UINT16)dis32->itemID;
2232 dis->itemAction = (UINT16)dis32->itemAction;
2233 dis->itemState = (UINT16)dis32->itemState;
2234 dis->hwndItem = HWND_16( dis32->hwndItem );
2235 dis->hDC = HDC_16(dis32->hDC);
2236 dis->itemData = dis32->itemData;
2237 dis->rcItem.left = dis32->rcItem.left;
2238 dis->rcItem.top = dis32->rcItem.top;
2239 dis->rcItem.right = dis32->rcItem.right;
2240 dis->rcItem.bottom = dis32->rcItem.bottom;
2241 *plparam = MapLS( dis );
2242 }
2243 return 1;
2244 case WM_MEASUREITEM:
2245 {
2246 MEASUREITEMSTRUCT *mis32 = (MEASUREITEMSTRUCT *)*plparam;
2247 MEASUREITEMSTRUCT16 *mis = HeapAlloc( GetProcessHeap(), 0, sizeof(*mis)+sizeof(LPARAM));
2248 if (!mis) return -1;
2249 mis->CtlType = (UINT16)mis32->CtlType;
2250 mis->CtlID = (UINT16)mis32->CtlID;
2251 mis->itemID = (UINT16)mis32->itemID;
2252 mis->itemWidth = (UINT16)mis32->itemWidth;
2253 mis->itemHeight = (UINT16)mis32->itemHeight;
2254 mis->itemData = mis32->itemData;
2255 *(LPARAM *)(mis + 1) = *plparam; /* Store the previous lParam */
2256 *plparam = MapLS( mis );
2257 }
2258 return 1;
2259 case WM_GETMINMAXINFO:
2260 {
2261 MINMAXINFO16 *mmi = HeapAlloc( GetProcessHeap(), 0, sizeof(*mmi) + sizeof(LPARAM) );
2262 if (!mmi) return -1;
2263 MINMAXINFO32to16( (MINMAXINFO *)*plparam, mmi );
2264 *(LPARAM *)(mmi + 1) = *plparam; /* Store the previous lParam */
2265 *plparam = MapLS( mmi );
2266 }
2267 return 1;
2268 case WM_GETTEXT:
2269 case WM_ASKCBFORMATNAME:
2270 {
2271 LPARAM *str; /* store LPARAM, then *pwparam16 char space */
2272 *pwparam16 = (WPARAM16)min( wParam32, 0xff80 ); /* Must be < 64K */
2273 if (!(str = HeapAlloc( GetProcessHeap(), 0, *pwparam16 + sizeof(LPARAM)))) return -1;
2274 *str++ = *plparam; /* Store the previous lParam */
2275 *plparam = MapLS( str );
2276 }
2277 return 1;
2278 case WM_MDICREATE:
2279 {
2280 MDICREATESTRUCT16 *cs;
2281 MDICREATESTRUCTA *cs32 = (MDICREATESTRUCTA *)*plparam;
2282
2283 if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(MDICREATESTRUCT16) ))) return -1;
2284 MDICREATESTRUCT32Ato16( cs32, cs );
2285 cs->szTitle = MapLS( cs32->szTitle );
2286 cs->szClass = MapLS( cs32->szClass );
2287 *plparam = MapLS( cs );
2288 }
2289 return 1;
2290 case WM_MDIGETACTIVE:
2291 return 1;
2292 case WM_MDISETMENU:
2293 *plparam = MAKELPARAM( (HMENU16)LOWORD(wParam32),
2294 (HMENU16)LOWORD(*plparam) );
2295 *pwparam16 = (*plparam == 0);
2296 return 0;
2297 case WM_MENUSELECT:
2298 if(HIWORD(wParam32) & MF_POPUP)
2299 {
2300 HMENU hmenu;
2301 if (((UINT)HIWORD(wParam32) != 0xFFFF) || (*plparam))
2302 {
2303 if((hmenu = GetSubMenu((HMENU)*plparam, *pwparam16)))
2304 *pwparam16=HMENU_16(hmenu);
2305 }
2306 }
2307 /* fall through */
2308 case WM_MENUCHAR:
2309 *plparam = MAKELPARAM( HIWORD(wParam32), (HMENU16)*plparam );
2310 return 0;
2311 case WM_MDIACTIVATE:
2312 if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_MDICHILD)
2313 {
2314 *pwparam16 = ((HWND)*plparam == hwnd);
2315 *plparam = MAKELPARAM( (HWND16)LOWORD(*plparam),
2316 (HWND16)LOWORD(wParam32) );
2317 }
2318 else
2319 {
2320 *pwparam16 = HWND_16( (HWND)wParam32 );
2321 *plparam = 0;
2322 }
2323 return 0;
2324 case WM_NCCALCSIZE:
2325 {
2326 NCCALCSIZE_PARAMS *nc32 = (NCCALCSIZE_PARAMS *)*plparam;
2327 NCCALCSIZE_PARAMS16 *nc = HeapAlloc( GetProcessHeap(), 0, sizeof(*nc) + sizeof(LPARAM));
2328 if (!nc) return -1;
2329
2330 nc->rgrc[0].left = nc32->rgrc[0].left;
2331 nc->rgrc[0].top = nc32->rgrc[0].top;
2332 nc->rgrc[0].right = nc32->rgrc[0].right;
2333 nc->rgrc[0].bottom = nc32->rgrc[0].bottom;
2334 if (wParam32)
2335 {
2336 WINDOWPOS16 *wp;
2337 nc->rgrc[1].left = nc32->rgrc[1].left;
2338 nc->rgrc[1].top = nc32->rgrc[1].top;
2339 nc->rgrc[1].right = nc32->rgrc[1].right;
2340 nc->rgrc[1].bottom = nc32->rgrc[1].bottom;
2341 nc->rgrc[2].left = nc32->rgrc[2].left;
2342 nc->rgrc[2].top = nc32->rgrc[2].top;
2343 nc->rgrc[2].right = nc32->rgrc[2].right;
2344 nc->rgrc[2].bottom = nc32->rgrc[2].bottom;
2345 if (!(wp = HeapAlloc( GetProcessHeap(), 0, sizeof(WINDOWPOS16) )))
2346 {
2347 HeapFree( GetProcessHeap(), 0, nc );
2348 return -1;
2349 }
2350 WINDOWPOS32to16( nc32->lppos, wp );
2351 nc->lppos = MapLS( wp );
2352 }
2353 *(LPARAM *)(nc + 1) = *plparam; /* Store the previous lParam */
2354 *plparam = MapLS( nc );
2355 }
2356 return 1;
2357 case WM_NCCREATE:
2358 case WM_CREATE:
2359 {
2360 CREATESTRUCT16 *cs;
2361 CREATESTRUCTA *cs32 = (CREATESTRUCTA *)*plparam;
2362
2363 if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(CREATESTRUCT16) ))) return -1;
2364 CREATESTRUCT32Ato16( cs32, cs );
2365 cs->lpszName = MapLS( cs32->lpszName );
2366 cs->lpszClass = MapLS( cs32->lpszClass );
2367
2368 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
2369 {
2370 MDICREATESTRUCT16 *mdi_cs16;
2371 MDICREATESTRUCTA *mdi_cs = (MDICREATESTRUCTA *)cs32->lpCreateParams;
2372 mdi_cs16 = HeapAlloc(GetProcessHeap(), 0, sizeof(*mdi_cs16));
2373 if (!mdi_cs16)
2374 {
2375 HeapFree(GetProcessHeap(), 0, cs);
2376 return -1;
2377 }
2378 MDICREATESTRUCT32Ato16(mdi_cs, mdi_cs16);
2379 mdi_cs16->szTitle = MapLS( mdi_cs->szTitle );
2380 mdi_cs16->szClass = MapLS( mdi_cs->szClass );
2381 cs->lpCreateParams = MapLS( mdi_cs16 );
2382 }
2383 *plparam = MapLS( cs );
2384 }
2385 return 1;
2386 case WM_PARENTNOTIFY:
2387 if ((LOWORD(wParam32)==WM_CREATE) || (LOWORD(wParam32)==WM_DESTROY))
2388 *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32));
2389 /* else nothing to do */
2390 return 0;
2391 case WM_NOTIFY:
2392 *plparam = MapLS( (NMHDR *)*plparam ); /* NMHDR is already 32-bit */
2393 return 1;
2394 case WM_SETTEXT:
2395 case WM_WININICHANGE:
2396 case WM_DEVMODECHANGE:
2397 *plparam = MapLS( (LPSTR)*plparam );
2398 return 1;
2399 case WM_WINDOWPOSCHANGING:
2400 case WM_WINDOWPOSCHANGED:
2401 {
2402 WINDOWPOS16 *wp = HeapAlloc( GetProcessHeap(), 0, sizeof(*wp) + sizeof(LPARAM) );
2403 if (!wp) return -1;
2404 WINDOWPOS32to16( (WINDOWPOS *)*plparam, wp );
2405 *(LPARAM *)(wp + 1) = *plparam; /* Store the previous lParam */
2406 *plparam = MapLS( wp );
2407 }
2408 return 1;
2409 case WM_GETDLGCODE:
2410 if (*plparam) {
2411 LPMSG msg32 = (LPMSG) *plparam;
2412 LPMSG16 msg16 = HeapAlloc( GetProcessHeap(), 0, sizeof(MSG16) );
2413
2414 if (!msg16) return -1;
2415 msg16->hwnd = HWND_16( msg32->hwnd );
2416 msg16->lParam = msg32->lParam;
2417 msg16->time = msg32->time;
2418 msg16->pt.x = msg32->pt.x;
2419 msg16->pt.y = msg32->pt.y;
2420 /* this is right, right? */
2421 if (WINPROC_MapMsg32ATo16(msg32->hwnd,msg32->message,msg32->wParam,
2422 &msg16->message,&msg16->wParam, &msg16->lParam)<0)
2423 {
2424 HeapFree( GetProcessHeap(), 0, msg16 );
2425 return -1;
2426 }
2427 *plparam = MapLS( msg16 );
2428 return 1;
2429 }
2430 return 0;
2431
2432 case WM_ACTIVATEAPP:
2433 if (*plparam) *plparam = HTASK_16( (HANDLE)*plparam );
2434 return 0;
2435 case WM_NEXTMENU:
2436 {
2437 MDINEXTMENU *next = (MDINEXTMENU *)*plparam;
2438 *plparam = (LPARAM)next->hmenuIn;
2439 return 1;
2440 }
2441 case WM_PAINT:
2442 if (IsIconic( hwnd ) && GetClassLongPtrW( hwnd, GCLP_HICON ))
2443 {
2444 *pmsg16 = WM_PAINTICON;
2445 *pwparam16 = 1;
2446 }
2447 return 0;
2448 case WM_ERASEBKGND:
2449 if (IsIconic( hwnd ) && GetClassLongPtrW( hwnd, GCLP_HICON ))
2450 *pmsg16 = WM_ICONERASEBKGND;
2451 return 0;
2452 case WM_PAINTCLIPBOARD:
2453 case WM_SIZECLIPBOARD:
2454 FIXME_(msg)("message %04x needs translation\n", msg32 );
2455 return -1;
2456 /* following messages should not be sent to 16-bit apps */
2457 case WM_SIZING:
2458 case WM_MOVING:
2459 case WM_CAPTURECHANGED:
2460 case WM_STYLECHANGING:
2461 case WM_STYLECHANGED:
2462 return -1;
2463 case WM_DDE_INITIATE:
2464 case WM_DDE_TERMINATE:
2465 case WM_DDE_UNADVISE:
2466 case WM_DDE_REQUEST:
2467 *pwparam16 = HWND_16((HWND)wParam32);
2468 return 0;
2469 case WM_DDE_ADVISE:
2470 case WM_DDE_DATA:
2471 case WM_DDE_POKE:
2472 {
2473 UINT_PTR lo32, hi;
2474 HANDLE16 lo16 = 0;
2475
2476 *pwparam16 = HWND_16((HWND)wParam32);
2477 UnpackDDElParam(msg32, *plparam, &lo32, &hi);
2478 if (lo32 && !(lo16 = convert_handle_32_to_16(lo32, GMEM_DDESHARE)))
2479 return -1;
2480 *plparam = MAKELPARAM(lo16, hi);
2481 }
2482 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
2483 case WM_DDE_ACK:
2484 {
2485 UINT_PTR lo, hi;
2486 int flag = 0;
2487 char buf[2];
2488
2489 *pwparam16 = HWND_16((HWND)wParam32);
2490
2491 UnpackDDElParam(msg32, *plparam, &lo, &hi);
2492
2493 if (GlobalGetAtomNameA((ATOM)hi, buf, sizeof(buf)) > 0) flag |= 1;
2494 if (GlobalSize((HANDLE)hi) != 0) flag |= 2;
2495 switch (flag)
2496 {
2497 case 0:
2498 if (hi)
2499 {
2500 MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
2501 hi = 0;
2502 }
2503 break;
2504 case 1:
2505 break; /* atom, nothing to do */
2506 case 3:
2507 MESSAGE("DDE_ACK: %x both atom and handle... choosing handle\n", hi);
2508 /* fall thru */
2509 case 2:
2510 hi = convert_handle_32_to_16(hi, GMEM_DDESHARE);
2511 break;
2512 }
2513 *plparam = MAKELPARAM(lo, hi);
2514 }
2515 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
2516 case WM_DDE_EXECUTE:
2517 *plparam = convert_handle_32_to_16(*plparam, GMEM_DDESHARE);
2518 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
2519 default: /* No translation needed */
2520 return 0;
2521 }
2522 }
2523
2524
2525 /**********************************************************************
2526 * WINPROC_UnmapMsg32ATo16
2527 *
2528 * Unmap a message that was mapped from 32-bit Ansi to 16-bit.
2529 */
2530 void WINPROC_UnmapMsg32ATo16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
2531 MSGPARAM16* p16 )
2532 {
2533 switch(msg)
2534 {
2535 case SBM_GETRANGE:
2536 *(LPINT)wParam = LOWORD(p16->lResult);
2537 *(LPINT)lParam = HIWORD(p16->lResult);
2538 break;
2539
2540 case LB_ADDFILE:
2541 case LB_ADDSTRING:
2542 case LB_DIR:
2543 case LB_FINDSTRING:
2544 case LB_FINDSTRINGEXACT:
2545 case LB_INSERTSTRING:
2546 case LB_SELECTSTRING:
2547 case LB_GETTEXT:
2548 case CB_ADDSTRING:
2549 case CB_FINDSTRING:
2550 case CB_FINDSTRINGEXACT:
2551 case CB_INSERTSTRING:
2552 case CB_SELECTSTRING:
2553 case CB_DIR:
2554 case CB_GETLBTEXT:
2555 case WM_SETTEXT:
2556 case WM_WININICHANGE:
2557 case WM_DEVMODECHANGE:
2558 UnMapLS( (SEGPTR)p16->lParam );
2559 break;
2560 case LB_SETTABSTOPS:
2561 case WM_COMPAREITEM:
2562 case WM_DELETEITEM:
2563 case WM_DRAWITEM:
2564 {
2565 void *ptr = MapSL( p16->lParam );
2566 UnMapLS( p16->lParam );
2567 HeapFree( GetProcessHeap(), 0, ptr );
2568 }
2569 break;
2570 case WM_COPYDATA:
2571 {
2572 PCOPYDATASTRUCT16 pcds = MapSL( p16->lParam );
2573 UnMapLS( p16->lParam );
2574 UnMapLS( pcds->lpData );
2575 HeapFree( GetProcessHeap(), 0, pcds );
2576 }
2577 break;
2578 case CB_GETDROPPEDCONTROLRECT:
2579 case LB_GETITEMRECT:
2580 {
2581 RECT *r32;
2582 RECT16 *rect = MapSL(p16->lParam);
2583 UnMapLS( p16->lParam );
2584 p16->lParam = *(LPARAM *)(rect + 1);
2585 r32 = (RECT *)p16->lParam;
2586 r32->left = rect->left;
2587 r32->top = rect->top;
2588 r32->right = rect->right;
2589 r32->bottom = rect->bottom;
2590 HeapFree( GetProcessHeap(), 0, rect );
2591 }
2592 break;
2593 case LB_GETSELITEMS:
2594 {
2595 INT i;
2596 LPINT16 items = MapSL(p16->lParam);
2597 UnMapLS( p16->lParam );
2598 p16->lParam = *((LPARAM *)items - 1);
2599 for (i = 0; i < p16->wParam; i++) *((LPINT)(p16->lParam) + i) = items[i];
2600 HeapFree( GetProcessHeap(), 0, (LPARAM *)items - 1 );
2601 }
2602 break;
2603
2604 case CB_GETEDITSEL:
2605 if( wParam )
2606 *((PUINT)(wParam)) = LOWORD(p16->lResult);
2607 if( lParam )
2608 *((PUINT)(lParam)) = HIWORD(p16->lResult); /* FIXME: substract 1? */
2609 break;
2610
2611 case WM_MEASUREITEM:
2612 {
2613 MEASUREITEMSTRUCT16 *mis = MapSL(p16->lParam);
2614 MEASUREITEMSTRUCT *mis32 = *(MEASUREITEMSTRUCT **)(mis + 1);
2615 mis32->itemWidth = mis->itemWidth;
2616 mis32->itemHeight = mis->itemHeight;
2617 UnMapLS( p16->lParam );
2618 HeapFree( GetProcessHeap(), 0, mis );
2619 }
2620 break;
2621 case WM_GETMINMAXINFO:
2622 {
2623 MINMAXINFO16 *mmi = MapSL(p16->lParam);
2624 UnMapLS( p16->lParam );
2625 p16->lParam = *(LPARAM *)(mmi + 1);
2626 MINMAXINFO16to32( mmi, (MINMAXINFO *)(p16->lParam) );
2627 HeapFree( GetProcessHeap(), 0, mmi );
2628 }
2629 break;
2630 case WM_GETTEXT:
2631 case WM_ASKCBFORMATNAME:
2632 {
2633 LPSTR str = MapSL(p16->lParam);
2634 UnMapLS( p16->lParam );
2635 p16->lParam = *((LPARAM *)str - 1);
2636 lstrcpynA( (LPSTR)(p16->lParam), str, p16->wParam );
2637 HeapFree( GetProcessHeap(), 0, (LPARAM *)str - 1 );
2638 }
2639 break;
2640 case WM_MDICREATE:
2641 {
2642 MDICREATESTRUCT16 *cs = MapSL(p16->lParam);
2643 UnMapLS( cs->szTitle );
2644 UnMapLS( cs->szClass );
2645 UnMapLS( p16->lParam );
2646 HeapFree( GetProcessHeap(), 0, cs );
2647 }
2648 break;
2649 case WM_MDIGETACTIVE:
2650 if (lParam) *(BOOL *)lParam = (BOOL16)HIWORD(p16->lResult);
2651 p16->lResult = (LRESULT)WIN_Handle32( LOWORD(p16->lResult) );
2652 break;
2653 case WM_NCCALCSIZE:
2654 {
2655 NCCALCSIZE_PARAMS *nc32;
2656 NCCALCSIZE_PARAMS16 *nc = MapSL(p16->lParam);
2657 UnMapLS( p16->lParam );
2658 p16->lParam = *(LPARAM *)(nc + 1);
2659 nc32 = (NCCALCSIZE_PARAMS *)(p16->lParam);
2660 nc32->rgrc[0].left = nc->rgrc[0].left;
2661 nc32->rgrc[0].top = nc->rgrc[0].top;
2662 nc32->rgrc[0].right = nc->rgrc[0].right;
2663 nc32->rgrc[0].bottom = nc->rgrc[0].bottom;
2664 if (p16->wParam)
2665 {
2666 WINDOWPOS16 *pos = MapSL(nc->lppos);
2667 UnMapLS( nc->lppos );
2668 nc32->rgrc[1].left = nc->rgrc[1].left;
2669 nc32->rgrc[1].top = nc->rgrc[1].top;
2670 nc32->rgrc[1].right = nc->rgrc[1].right;
2671 nc32->rgrc[1].bottom = nc->rgrc[1].bottom;
2672 nc32->rgrc[2].left = nc->rgrc[2].left;
2673 nc32->rgrc[2].top = nc->rgrc[2].top;
2674 nc32->rgrc[2].right = nc->rgrc[2].right;
2675 nc32->rgrc[2].bottom = nc->rgrc[2].bottom;
2676 WINDOWPOS16to32( pos, nc32->lppos );
2677 HeapFree( GetProcessHeap(), 0, pos );
2678 }
2679 HeapFree( GetProcessHeap(), 0, nc );
2680 }
2681 break;
2682 case WM_NCCREATE:
2683 case WM_CREATE:
2684 {
2685 CREATESTRUCT16 *cs = MapSL(p16->lParam);
2686 UnMapLS( p16->lParam );
2687 UnMapLS( cs->lpszName );
2688 UnMapLS( cs->lpszClass );
2689 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
2690 {
2691 MDICREATESTRUCT16 *mdi_cs16 = (MDICREATESTRUCT16 *)MapSL(cs->lpCreateParams);
2692 UnMapLS( cs->lpCreateParams );
2693 UnMapLS( mdi_cs16->szTitle );
2694 UnMapLS( mdi_cs16->szClass );
2695 HeapFree(GetProcessHeap(), 0, mdi_cs16);
2696 }
2697 HeapFree( GetProcessHeap(), 0, cs );
2698 }
2699 break;
2700 case WM_WINDOWPOSCHANGING:
2701 case WM_WINDOWPOSCHANGED:
2702 {
2703 WINDOWPOS16 *wp = MapSL(p16->lParam);
2704 UnMapLS( p16->lParam );
2705 p16->lParam = *(LPARAM *)(wp + 1);
2706 WINDOWPOS16to32( wp, (WINDOWPOS *)p16->lParam );
2707 HeapFree( GetProcessHeap(), 0, wp );
2708 }
2709 break;
2710 case WM_NOTIFY:
2711 UnMapLS(p16->lParam);
2712 break;
2713 case WM_GETDLGCODE:
2714 if (p16->lParam)
2715 {
2716 LPMSG16 msg16 = MapSL(p16->lParam);
2717 MSGPARAM16 msgp16;
2718 UnMapLS( p16->lParam );
2719 msgp16.wParam=msg16->wParam;
2720 msgp16.lParam=msg16->lParam;
2721 WINPROC_UnmapMsg32ATo16(((LPMSG)lParam)->hwnd, ((LPMSG)lParam)->message,
2722 ((LPMSG)lParam)->wParam, ((LPMSG)lParam)->lParam,
2723 &msgp16 );
2724 HeapFree( GetProcessHeap(), 0, msg16 );
2725 }
2726 break;
2727 case WM_NEXTMENU:
2728 {
2729 MDINEXTMENU *next = (MDINEXTMENU *)lParam;
2730 next->hmenuNext = HMENU_32( LOWORD(p16->lResult) );
2731 next->hwndNext = WIN_Handle32( HIWORD(p16->lResult) );
2732 p16->lResult = 0;
2733 }
2734 break;
2735 }
2736 }
2737
2738
2739 /**********************************************************************
2740 * WINPROC_MapMsg32WTo16
2741 *
2742 * Map a message from 32-bit Unicode to 16-bit.
2743 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
2744 */
2745 INT WINPROC_MapMsg32WTo16( HWND hwnd, UINT msg32, WPARAM wParam32,
2746 UINT16 *pmsg16, WPARAM16 *pwparam16,
2747 LPARAM *plparam )
2748 {
2749 BYTE ch;
2750 WCHAR wch;
2751
2752 *pmsg16 = LOWORD(msg32);
2753 *pwparam16 = LOWORD(wParam32);
2754 switch(msg32)
2755 {
2756 case LB_ADDSTRING:
2757 case LB_FINDSTRING:
2758 case LB_FINDSTRINGEXACT:
2759 case LB_INSERTSTRING:
2760 case LB_SELECTSTRING:
2761 case LB_DIR:
2762 case LB_ADDFILE:
2763 *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2764 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
2765 return 1;
2766
2767 case CB_ADDSTRING:
2768 case CB_FINDSTRING:
2769 case CB_FINDSTRINGEXACT:
2770 case CB_INSERTSTRING:
2771 case CB_SELECTSTRING:
2772 case CB_DIR:
2773 *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2774 *pmsg16 = (UINT16)msg32 + (CB_ADDSTRING16 - CB_ADDSTRING);
2775 return 1;
2776
2777 case WM_NCCREATE:
2778 case WM_CREATE:
2779 {
2780 CREATESTRUCT16 *cs;
2781 CREATESTRUCTW *cs32 = (CREATESTRUCTW *)*plparam;
2782
2783 if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(CREATESTRUCT16) ))) return -1;
2784 CREATESTRUCT32Ato16( (CREATESTRUCTA *)cs32, cs );
2785 cs->lpszName = map_str_32W_to_16( cs32->lpszName );
2786 cs->lpszClass = map_str_32W_to_16( cs32->lpszClass );
2787
2788 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
2789 {
2790 MDICREATESTRUCT16 *mdi_cs16;
2791 MDICREATESTRUCTW *mdi_cs = (MDICREATESTRUCTW *)cs32->lpCreateParams;
2792 mdi_cs16 = HeapAlloc(GetProcessHeap(), 0, sizeof(*mdi_cs16));
2793 if (!mdi_cs16)
2794 {
2795 HeapFree(GetProcessHeap(), 0, cs);
2796 return -1;
2797 }
2798 MDICREATESTRUCT32Ato16((MDICREATESTRUCTA *)mdi_cs, mdi_cs16);
2799 mdi_cs16->szTitle = map_str_32W_to_16(mdi_cs->szTitle);
2800 mdi_cs16->szClass = map_str_32W_to_16(mdi_cs->szClass);
2801 cs->lpCreateParams = MapLS(mdi_cs16);
2802 }
2803 *plparam = MapLS(cs);
2804 }
2805 return 1;
2806 case WM_MDICREATE:
2807 {
2808 MDICREATESTRUCT16 *cs;
2809 MDICREATESTRUCTW *cs32 = (MDICREATESTRUCTW *)*plparam;
2810
2811 if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(MDICREATESTRUCT16) ))) return -1;
2812 MDICREATESTRUCT32Ato16( (MDICREATESTRUCTA *)cs32, cs );
2813 cs->szTitle = map_str_32W_to_16( cs32->szTitle );
2814 cs->szClass = map_str_32W_to_16( cs32->szClass );
2815 *plparam = MapLS(cs);
2816 }
2817 return 1;
2818 case WM_SETTEXT:
2819 case WM_WININICHANGE:
2820 case WM_DEVMODECHANGE:
2821 *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2822 return 1;
2823 case LB_GETTEXT:
2824 if ( WINPROC_TestLBForStr( hwnd ))
2825 {
2826 LPSTR str = HeapAlloc( GetProcessHeap(), 0, 512 ); /* FIXME: fixed sized buffer */
2827 if (!str) return -1;
2828 *pmsg16 = LB_GETTEXT16;
2829 *plparam = (LPARAM)MapLS(str);
2830 }
2831 return 1;
2832 case CB_GETLBTEXT:
2833 if ( WINPROC_TestCBForStr( hwnd ))
2834 {
2835 LPSTR str = HeapAlloc( GetProcessHeap(), 0, 512 ); /* FIXME: fixed sized buffer */
2836 if (!str) return -1;
2837 *pmsg16 = CB_GETLBTEXT16;
2838 *plparam = (LPARAM)MapLS(str);
2839 }
2840 return 1;
2841
2842 case WM_CHARTOITEM:
2843 wch = LOWORD(wParam32);
2844 WideCharToMultiByte( CP_ACP, 0, &wch, 1, (LPSTR)&ch, 1, NULL, NULL);
2845 *pwparam16 = ch;
2846 *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32) );
2847 return 0;
2848 case WM_MENUCHAR:
2849 wch = LOWORD(wParam32);
2850 WideCharToMultiByte( CP_ACP, 0, &wch, 1, (LPSTR)&ch, 1, NULL, NULL);
2851 *pwparam16 = ch;
2852 *plparam = MAKELPARAM( HIWORD(wParam32), (HMENU16)*plparam );
2853 return 0;
2854 case WM_CHAR:
2855 case WM_DEADCHAR:
2856 case WM_SYSCHAR:
2857 case WM_SYSDEADCHAR:
2858 wch = wParam32;
2859 WideCharToMultiByte( CP_ACP, 0, &wch, 1, (LPSTR)&ch, 1, NULL, NULL);
2860 *pwparam16 = ch;
2861 return 0;
2862 case WM_IME_CHAR:
2863 {
2864 BYTE ch[2];
2865
2866 wch = wParam32;
2867 if (WideCharToMultiByte( CP_ACP, 0, &wch, 1, (LPSTR)ch, 2, NULL, NULL ) == 2)
2868 *pwparam16 = (ch[0] << 8) | ch[1];
2869 else
2870 *pwparam16 = ch[0];
2871 }
2872 return 0;
2873
2874 default: /* No Unicode translation needed (?) */
2875 return WINPROC_MapMsg32ATo16( hwnd, msg32, wParam32, pmsg16,
2876 pwparam16, plparam );
2877 }
2878 }
2879
2880
2881 /**********************************************************************
2882 * WINPROC_UnmapMsg32WTo16
2883 *
2884 * Unmap a message that was mapped from 32-bit Unicode to 16-bit.
2885 */
2886 void WINPROC_UnmapMsg32WTo16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
2887 MSGPARAM16* p16 )
2888 {
2889 switch(msg)
2890 {
2891 case LB_ADDSTRING:
2892 case LB_FINDSTRING:
2893 case LB_FINDSTRINGEXACT:
2894 case LB_INSERTSTRING:
2895 case LB_SELECTSTRING:
2896 case LB_DIR:
2897 case LB_ADDFILE:
2898 case CB_ADDSTRING:
2899 case CB_FINDSTRING:
2900 case CB_FINDSTRINGEXACT:
2901 case CB_INSERTSTRING:
2902 case CB_SELECTSTRING:
2903 case CB_DIR:
2904 case WM_SETTEXT:
2905 case WM_WININICHANGE:
2906 case WM_DEVMODECHANGE:
2907 unmap_str_32W_to_16( p16->lParam );
2908 break;
2909 case WM_NCCREATE:
2910 case WM_CREATE:
2911 {
2912 CREATESTRUCT16 *cs = MapSL(p16->lParam);
2913 UnMapLS( p16->lParam );
2914 unmap_str_32W_to_16( cs->lpszName );
2915 unmap_str_32W_to_16( cs->lpszClass );
2916
2917 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
2918 {
2919 MDICREATESTRUCT16 *mdi_cs16 = (MDICREATESTRUCT16 *)MapSL(cs->lpCreateParams);
2920 UnMapLS( cs->lpCreateParams );
2921 unmap_str_32W_to_16(mdi_cs16->szTitle);
2922 unmap_str_32W_to_16(mdi_cs16->szClass);
2923 HeapFree(GetProcessHeap(), 0, mdi_cs16);
2924 }
2925 HeapFree( GetProcessHeap(), 0, cs );
2926 }
2927 break;
2928 case WM_MDICREATE:
2929 {
2930 MDICREATESTRUCT16 *cs = MapSL(p16->lParam);
2931 UnMapLS( p16->lParam );
2932 unmap_str_32W_to_16( cs->szTitle );
2933 unmap_str_32W_to_16( cs->szClass );
2934 HeapFree( GetProcessHeap(), 0, cs );
2935 }
2936 break;
2937 case WM_GETTEXT:
2938 case WM_ASKCBFORMATNAME:
2939 {
2940 LPSTR str = MapSL(p16->lParam);
2941 UnMapLS( p16->lParam );
2942 p16->lParam = *((LPARAM *)str - 1);
2943 MultiByteToWideChar( CP_ACP, 0, str, -1, (LPWSTR)p16->lParam, 0x7fffffff );
2944 p16->lResult = strlenW( (LPWSTR)p16->lParam );
2945 HeapFree( GetProcessHeap(), 0, (LPARAM *)str - 1 );
2946 }
2947 break;
2948 case LB_GETTEXT:
2949 if ( WINPROC_TestLBForStr( hwnd ))
2950 {
2951 LPSTR str = MapSL(p16->lParam);
2952 UnMapLS( p16->lParam );
2953 p16->lResult = MultiByteToWideChar( CP_ACP, 0, str, -1, (LPWSTR)lParam, 0x7fffffff ) - 1;
2954 HeapFree( GetProcessHeap(), 0, (LPARAM *)str );
2955 }
2956 break;
2957 case CB_GETLBTEXT:
2958 if ( WINPROC_TestCBForStr( hwnd ))
2959 {
2960 LPSTR str = MapSL(p16->lParam);
2961 UnMapLS( p16->lParam );
2962 p16->lResult = MultiByteToWideChar( CP_ACP, 0, str, -1, (LPWSTR)lParam, 0x7fffffff ) - 1;
2963 HeapFree( GetProcessHeap(), 0, (LPARAM *)str );
2964 }
2965 break;
2966 default:
2967 WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, p16 );
2968 break;
2969 }
2970 }
2971
2972
2973 /**********************************************************************
2974 * WINPROC_CallProc32ATo32W
2975 *
2976 * Call a window procedure, translating args from Ansi to Unicode.
2977 */
2978 static LRESULT WINPROC_CallProc32ATo32W( WNDPROC func, HWND hwnd,
2979 UINT msg, WPARAM wParam,
2980 LPARAM lParam )
2981 {
2982 LRESULT result;
2983 int unmap;
2984
2985 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
2986 func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2987
2988 if( (unmap = WINPROC_MapMsg32ATo32W( hwnd, msg, &wParam, &lParam )) == -1) {
2989 ERR_(msg)("Message translation failed. (msg=%s,wp=%08x,lp=%08lx)\n",
2990 SPY_GetMsgName(msg, hwnd), wParam, lParam );
2991 return 0;
2992 }
2993 result = WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2994 if (unmap) result = WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam, result, func );
2995 return result;
2996 }
2997
2998
2999 /**********************************************************************
3000 * WINPROC_CallProc32WTo32A_fast
3001 *
3002 */
3003 static BOOL WINPROC_CallProc32WTo32A_fast( WNDPROC func, HWND hwnd,
3004 UINT msg, WPARAM wParam,
3005 LPARAM lParam, LRESULT *result )
3006 {
3007 switch(msg)
3008 {
3009 case WM_NCCREATE:
3010 case WM_CREATE:
3011 { /* csW->lpszName and csW->lpszClass are NOT supposed to be atoms
3012 * at this point.
3013 */
3014 char buffer[1024];
3015 char *cls = buffer, *name;
3016 CREATESTRUCTW *csW = (CREATESTRUCTW *)lParam;
3017 CREATESTRUCTA csA = *(CREATESTRUCTA *)csW;
3018 DWORD name_lenA, name_lenW, class_lenA, class_lenW;
3019
3020 class_lenW = strlenW(csW->lpszClass) * sizeof(WCHAR);
3021 RtlUnicodeToMultiByteSize(&class_lenA, csW->lpszClass, class_lenW);
3022
3023 if (csW->lpszName)
3024 {
3025 name_lenW = strlenW(csW->lpszName) * sizeof(WCHAR);
3026 RtlUnicodeToMultiByteSize(&name_lenA, csW->lpszName, name_lenW);
3027 }
3028 else
3029 name_lenW = name_lenA = 0;
3030
3031 if (class_lenA + name_lenA + 2 > sizeof(buffer))
3032 {
3033 cls = HeapAlloc(GetProcessHeap(), 0, class_lenA + name_lenA + 2);
3034 if (!cls) return FALSE;
3035 }
3036
3037 RtlUnicodeToMultiByteN(cls, class_lenA, NULL, csW->lpszClass, class_lenW);
3038 cls[class_lenA] = 0;
3039 csA.lpszClass = cls;
3040
3041 if (csW->lpszName)
3042 {
3043 name = cls + class_lenA + 1;
3044 RtlUnicodeToMultiByteN(name, name_lenA, NULL, csW->lpszName, name_lenW);
3045 name[name_lenA] = 0;
3046 csA.lpszName = name;
3047 }
3048
3049 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
3050 {
3051 MDICREATESTRUCTA mdi_cs;
3052
3053 mdi_cs = *(MDICREATESTRUCTA *)csW->lpCreateParams;
3054 mdi_cs.szTitle = csA.lpszName;
3055 mdi_cs.szClass = csA.lpszClass;
3056 csA.lpCreateParams = &mdi_cs;
3057 }
3058
3059 lParam = (LPARAM)&csA;
3060 *result = WINPROC_CallWndProc(func, hwnd, msg, wParam, lParam);
3061
3062 if (cls != buffer) HeapFree(GetProcessHeap(), 0, cls);
3063 }
3064 return TRUE;
3065
3066 default:
3067 return FALSE;
3068 }
3069 }
3070
3071 /**********************************************************************
3072 * WINPROC_CallProc32WTo32A
3073 *
3074 * Call a window procedure, translating args from Unicode to Ansi.
3075 */
3076 static LRESULT WINPROC_CallProc32WTo32A( WNDPROC func, HWND hwnd,
3077 UINT msg, WPARAM wParam,
3078 LPARAM lParam )
3079 {
3080 LRESULT result;
3081 int unmap;
3082
3083 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
3084 func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
3085
3086 if (WINPROC_CallProc32WTo32A_fast( func, hwnd, msg, wParam, lParam, &result ))
3087 return result;
3088
3089 if ((unmap = WINPROC_MapMsg32WTo32A( hwnd, msg, &wParam, &lParam )) == -1) {
3090 ERR_(msg)("Message translation failed. (msg=%s,wp=%08x,lp=%08lx)\n",
3091 SPY_GetMsgName(msg, hwnd), wParam, lParam );
3092 return 0;
3093 }
3094 result = WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
3095 if( unmap ) result = WINPROC_UnmapMsg32WTo32A( hwnd, msg, wParam, lParam, result );
3096 return result;
3097 }
3098
3099
3100 /**********************************************************************
3101 * __wine_call_wndproc_32A (USER.1010)
3102 */
3103 LRESULT WINAPI __wine_call_wndproc_32A( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
3104 WNDPROC func )
3105 {
3106 LRESULT result;
3107 UINT msg32;
3108 WPARAM wParam32;
3109 HWND hwnd32 = WIN_Handle32( hwnd );
3110
3111 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
3112 func, hwnd32, SPY_GetMsgName(msg, hwnd32), wParam, lParam);
3113
3114 if (WINPROC_MapMsg16To32A( hwnd32, msg, wParam, &msg32, &wParam32, &lParam ) == -1)
3115 return 0;
3116 result = WINPROC_CallWndProc( func, hwnd32, msg32, wParam32, lParam );
3117 return WINPROC_UnmapMsg16To32A( hwnd32, msg32, wParam32, lParam, result );
3118 }
3119
3120
3121 /**********************************************************************
3122 * __wine_call_wndproc_32W (USER.1011)
3123 */
3124 LRESULT WINAPI __wine_call_wndproc_32W( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
3125 WNDPROC func )
3126 {
3127 LRESULT result;
3128 UINT msg32;
3129 WPARAM wParam32;
3130 HWND hwnd32 = WIN_Handle32( hwnd );
3131
3132 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
3133 func, hwnd32, SPY_GetMsgName(msg, hwnd32), wParam, lParam);
3134
3135 if (WINPROC_MapMsg16To32W( hwnd32, msg, wParam, &msg32, &wParam32, &lParam ) == -1)
3136 return 0;
3137 result = WINPROC_CallWndProc( func, hwnd32, msg32, wParam32, lParam );
3138 return WINPROC_UnmapMsg16To32W( hwnd32, msg32, wParam32, lParam, result,
3139 func );
3140 }
3141
3142
3143 /**********************************************************************
3144 * WINPROC_CallProc32ATo16
3145 *
3146 * Call a 16-bit window procedure, translating the 32-bit args.
3147 */
3148 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND hwnd,
3149 UINT msg, WPARAM wParam,
3150 LPARAM lParam )
3151 {
3152 UINT16 msg16;
3153 MSGPARAM16 mp16;
3154
3155 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
3156 func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
3157
3158 mp16.lParam = lParam;
3159 if (WINPROC_MapMsg32ATo16( hwnd, msg, wParam, &msg16, &mp16.wParam, &mp16.lParam ) == -1)
3160 return 0;
3161 mp16.lResult = WINPROC_CallWndProc16( func, HWND_16(hwnd), msg16,
3162 mp16.wParam, mp16.lParam );
3163 WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, &mp16 );
3164 return mp16.lResult;
3165 }
3166
3167
3168 /**********************************************************************
3169 * WINPROC_CallProc32WTo16
3170 *
3171 * Call a 16-bit window procedure, translating the 32-bit args.
3172 */
3173 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND hwnd,
3174 UINT msg, WPARAM wParam,
3175 LPARAM lParam )
3176 {
3177 UINT16 msg16;
3178 MSGPARAM16 mp16;
3179
3180 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
3181 func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
3182
3183 mp16.lParam = lParam;
3184 if (WINPROC_MapMsg32WTo16( hwnd, msg, wParam, &msg16, &mp16.wParam,
3185 &mp16.lParam ) == -1)
3186 return 0;
3187 mp16.lResult = WINPROC_CallWndProc16( func, HWND_16(hwnd), msg16,
3188 mp16.wParam, mp16.lParam );
3189 WINPROC_UnmapMsg32WTo16( hwnd, msg, wParam, lParam, &mp16 );
3190 return mp16.lResult;
3191 }
3192
3193
3194 /**********************************************************************
3195 * CallWindowProc (USER.122)
3196 */
3197 LRESULT WINAPI CallWindowProc16( WNDPROC16 func, HWND16 hwnd, UINT16 msg,
3198 WPARAM16 wParam, LPARAM lParam )
3199 {
3200 WINDOWPROC *proc;
3201
3202 if (!func) return 0;
3203
3204 if (!(proc = WINPROC_GetPtr( (WNDPROC)func )))
3205 return WINPROC_CallWndProc16( func, hwnd, msg, wParam, lParam );
3206
3207 #if testing
3208 func = WINPROC_GetProc( (WNDPROC)proc, WIN_PROC_16 );
3209 return WINPROC_CallWndProc16( func, hwnd, msg, wParam, lParam );
3210 #endif
3211
3212 switch(proc->type)
3213 {
3214 case WIN_PROC_16:
3215 if (!proc->thunk.t_from32.proc) return 0;
3216 return WINPROC_CallWndProc16( proc->thunk.t_from32.proc,
3217 hwnd, msg, wParam, lParam );
3218 case WIN_PROC_32A:
3219 if (!proc->thunk.t_from16.proc) return 0;
3220 return __wine_call_wndproc_32A( hwnd, msg, wParam, lParam, proc->thunk.t_from16.proc );
3221 case WIN_PROC_32W:
3222 if (!proc->thunk.t_from16.proc) return 0;
3223 return __wine_call_wndproc_32W( hwnd, msg, wParam, lParam, proc->thunk.t_from16.proc );
3224 default:
3225 WARN_(relay)("Invalid proc %p\n", proc );
3226 return 0;
3227 }
3228 }
3229
3230
3231 /**********************************************************************
3232 * CallWindowProcA (USER32.@)
3233 *
3234 * The CallWindowProc() function invokes the windows procedure _func_,
3235 * with _hwnd_ as the target window, the message specified by _msg_, and
3236 * the message parameters _wParam_ and _lParam_.
3237 *
3238 * Some kinds of argument conversion may be done, I'm not sure what.
3239 *
3240 * CallWindowProc() may be used for windows subclassing. Use
3241 * SetWindowLong() to set a new windows procedure for windows of the
3242 * subclass, and handle subclassed messages in the new windows
3243 * procedure. The new windows procedure may then use CallWindowProc()
3244 * with _func_ set to the parent class's windows procedure to dispatch
3245 * the message to the superclass.
3246 *
3247 * RETURNS
3248 *
3249 * The return value is message dependent.
3250 *
3251 * CONFORMANCE
3252 *
3253 * ECMA-234, Win32
3254 */
3255 LRESULT WINAPI CallWindowProcA(
3256 WNDPROC func, /* [in] window procedure */
3257 HWND hwnd, /* [in] target window */
3258 UINT msg, /* [in] message */
3259 WPARAM wParam, /* [in] message dependent parameter */
3260 LPARAM lParam /* [in] message dependent parameter */
3261 ) {
3262 WINDOWPROC *proc;
3263
3264 if (!func) return 0;
3265
3266 if (!(proc = WINPROC_GetPtr( func )))
3267 return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
3268
3269 #if testing
3270 func = WINPROC_GetProc( (WNDPROC)proc, WIN_PROC_32A );
3271 return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
3272 #endif
3273
3274 switch(proc->type)
3275 {
3276 case WIN_PROC_16:
3277 if (!proc->thunk.t_from32.proc) return 0;
3278 return WINPROC_CallProc32ATo16( proc->thunk.t_from32.proc,
3279 hwnd, msg, wParam, lParam );
3280 case WIN_PROC_32A:
3281 if (!proc->thunk.t_from16.proc) return 0;
3282 return WINPROC_CallWndProc( proc->thunk.t_from16.proc,
3283 hwnd, msg, wParam, lParam );
3284 case WIN_PROC_32W:
3285 if (!proc->thunk.t_from16.proc) return 0;
3286 return WINPROC_CallProc32ATo32W( proc->thunk.t_from16.proc,
3287 hwnd, msg, wParam, lParam );
3288 default:
3289 WARN_(relay)("Invalid proc %p\n", proc );
3290 return 0;
3291 }
3292 }
3293
3294
3295 /**********************************************************************
3296 * CallWindowProcW (USER32.@)
3297 *
3298 * See CallWindowProcA.
3299 */
3300 LRESULT WINAPI CallWindowProcW( WNDPROC func, HWND hwnd, UINT msg,
3301 WPARAM wParam, LPARAM lParam )
3302 {
3303 WINDOWPROC *proc;
3304
3305 if (!func) return 0;
3306
3307 if (!(proc = WINPROC_GetPtr( (WNDPROC)func )))
3308 return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
3309
3310 #if testing
3311 func = WINPROC_GetProc( (WNDPROC)proc, WIN_PROC_32W );
3312 return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
3313 #endif
3314
3315 switch(proc->type)
3316 {
3317 case WIN_PROC_16:
3318 if (!proc->thunk.t_from32.proc) return 0;
3319 return WINPROC_CallProc32WTo16( proc->thunk.t_from32.proc,
3320 hwnd, msg, wParam, lParam );
3321 case WIN_PROC_32A:
3322 if (!proc->thunk.t_from16.proc) return 0;
3323 return WINPROC_CallProc32WTo32A( proc->thunk.t_from16.proc,
3324 hwnd, msg, wParam, lParam );
3325 case WIN_PROC_32W:
3326 if (!proc->thunk.t_from16.proc) return 0;
3327 return WINPROC_CallWndProc( proc->thunk.t_from16.proc,
3328 hwnd, msg, wParam, lParam );
3329 default:
3330 WARN_(relay)("Invalid proc %p\n", proc );
3331 return 0;
3332 }
3333 }
Windows API implementation