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