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