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