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