?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Solved the transparency problem seen in the ClipMirror SDK sample
[wine/wine64.git] / windows / winproc.c
blobd07720614bb4396055f3311be940d9b142b18ffc
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_IME_CHAR:
733 {
734 BYTE ch[2];
735 WCHAR wch;
736 ch[0] = (*pwparam >> 8);
737 ch[1] = *pwparam & 0xff;
738 MultiByteToWideChar(CP_ACP, 0, ch, 2, &wch, 1);
739 *pwparam = MAKEWPARAM( wch, HIWORD(*pwparam) );
740 }
741 return 0;
742
743 case WM_PAINTCLIPBOARD:
744 case WM_SIZECLIPBOARD:
745 FIXME_(msg)("message %s (0x%x) needs translation, please report\n", SPY_GetMsgName(msg, hwnd), msg );
746 return -1;
747 default: /* No translation needed */
748 return 0;
749 }
750 }
751
752
753 /**********************************************************************
754 * WINPROC_UnmapMsg32ATo32W
755 *
756 * Unmap a message that was mapped from Ansi to Unicode.
757 */
758 LRESULT WINPROC_UnmapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
759 LRESULT result )
760 {
761 switch(msg)
762 {
763 case WM_GETTEXT:
764 case WM_ASKCBFORMATNAME:
765 {
766 LPARAM *ptr = (LPARAM *)lParam - 1;
767 if (wParam > 0 && !WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1,
768 (LPSTR)*ptr, wParam, NULL, NULL ))
769 ((LPSTR)*ptr)[wParam-1] = 0;
770 HeapFree( GetProcessHeap(), 0, ptr );
771 }
772 break;
773 case WM_GETTEXTLENGTH:
774 case CB_GETLBTEXTLEN:
775 case LB_GETTEXTLEN:
776 /* there may be one DBCS char for each Unicode char */
777 return result * 2;
778 case WM_NCCREATE:
779 case WM_CREATE:
780 {
781 struct s
782 { CREATESTRUCTW cs; /* new structure */
783 LPWSTR lpszName; /* allocated Name */
784 LPWSTR lpszClass; /* allocated Class */
785 };
786 struct s *xs = (struct s *)lParam;
787 if (xs->lpszName) HeapFree( GetProcessHeap(), 0, xs->lpszName );
788 if (xs->lpszClass) HeapFree( GetProcessHeap(), 0, xs->lpszClass );
789 HeapFree( GetProcessHeap(), 0, xs );
790 }
791 break;
792
793 case WM_MDICREATE:
794 {
795 MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lParam;
796 if (HIWORD(cs->szTitle))
797 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
798 if (HIWORD(cs->szClass))
799 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
800 HeapFree( GetProcessHeap(), 0, cs );
801 }
802 break;
803
804 case WM_SETTEXT:
805 case WM_WININICHANGE:
806 case WM_DEVMODECHANGE:
807 case CB_DIR:
808 case LB_DIR:
809 case LB_ADDFILE:
810 case EM_REPLACESEL:
811 HeapFree( GetProcessHeap(), 0, (void *)lParam );
812 break;
813
814 /* Listbox */
815 case LB_ADDSTRING:
816 case LB_INSERTSTRING:
817 case LB_FINDSTRING:
818 case LB_FINDSTRINGEXACT:
819 case LB_SELECTSTRING:
820 if ( WINPROC_TestLBForStr( hwnd ))
821 HeapFree( GetProcessHeap(), 0, (void *)lParam );
822 break;
823
824 case LB_GETTEXT:
825 { if ( WINPROC_TestLBForStr( hwnd ))
826 { LPARAM *ptr = (LPARAM *)lParam - 1;
827 WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, (LPSTR)*ptr, 0x7fffffff, NULL, NULL );
828 HeapFree( GetProcessHeap(), 0, ptr );
829 }
830 }
831 break;
832
833 /* Combobox */
834 case CB_ADDSTRING:
835 case CB_INSERTSTRING:
836 case CB_FINDSTRING:
837 case CB_FINDSTRINGEXACT:
838 case CB_SELECTSTRING:
839 if ( WINPROC_TestCBForStr( hwnd ))
840 HeapFree( GetProcessHeap(), 0, (void *)lParam );
841 break;
842
843 case CB_GETLBTEXT:
844 { if ( WINPROC_TestCBForStr( hwnd ))
845 { LPARAM *ptr = (LPARAM *)lParam - 1;
846 WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, (LPSTR)*ptr, 0x7fffffff, NULL, NULL );
847 HeapFree( GetProcessHeap(), 0, ptr );
848 }
849 }
850 break;
851
852 /* Multiline edit */
853 case EM_GETLINE:
854 { LPARAM * ptr = (LPARAM *)lParam - 1; /* get the old lParam */
855 WORD len = *(WORD *) lParam;
856 if (len > 0 && !WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1,
857 (LPSTR)*ptr, len, NULL, NULL ))
858 ((LPSTR)*ptr)[len-1] = 0;
859 HeapFree( GetProcessHeap(), 0, ptr );
860 }
861 break;
862 }
863 return result;
864 }
865
866
867 /**********************************************************************
868 * WINPROC_MapMsg32WTo32A
869 *
870 * Map a message from Unicode to Ansi.
871 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
872 */
873 INT WINPROC_MapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM *pwparam, LPARAM *plparam )
874 {
875 switch(msg)
876 {
877 case WM_GETTEXT:
878 case WM_ASKCBFORMATNAME:
879 {
880 LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0,
881 *pwparam + sizeof(LPARAM) );
882 if (!ptr) return -1;
883 *ptr++ = *plparam; /* Store previous lParam */
884 *plparam = (LPARAM)ptr;
885 }
886 return 1;
887
888 case WM_SETTEXT:
889 case WM_WININICHANGE:
890 case WM_DEVMODECHANGE:
891 case CB_DIR:
892 case LB_DIR:
893 case LB_ADDFILE:
894 case EM_REPLACESEL:
895 if(!*plparam) return 0;
896 *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
897 return (*plparam ? 1 : -1);
898
899 case WM_NCCREATE:
900 case WM_CREATE:
901 {
902 CREATESTRUCTA *cs = (CREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0,
903 sizeof(*cs) );
904 if (!cs) return -1;
905 *cs = *(CREATESTRUCTA *)*plparam;
906 if (HIWORD(cs->lpszName))
907 cs->lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0,
908 (LPCWSTR)cs->lpszName );
909 if (HIWORD(cs->lpszClass))
910 cs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
911 (LPCWSTR)cs->lpszClass);
912 *plparam = (LPARAM)cs;
913 }
914 return 1;
915 case WM_MDICREATE:
916 {
917 MDICREATESTRUCTA *cs =
918 (MDICREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
919 if (!cs) return -1;
920 *cs = *(MDICREATESTRUCTA *)*plparam;
921 if (HIWORD(cs->szTitle))
922 cs->szTitle = HEAP_strdupWtoA( GetProcessHeap(), 0,
923 (LPCWSTR)cs->szTitle );
924 if (HIWORD(cs->szClass))
925 cs->szClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
926 (LPCWSTR)cs->szClass );
927 *plparam = (LPARAM)cs;
928 }
929 return 1;
930
931 /* Listbox */
932 case LB_ADDSTRING:
933 case LB_INSERTSTRING:
934 case LB_FINDSTRING:
935 case LB_FINDSTRINGEXACT:
936 case LB_SELECTSTRING:
937 if(!*plparam) return 0;
938 if ( WINPROC_TestLBForStr( hwnd ))
939 *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
940 return (*plparam ? 1 : -1);
941
942 case LB_GETTEXT: /* FIXME: fixed sized buffer */
943 { if ( WINPROC_TestLBForStr( hwnd ))
944 { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM) );
945 if (!ptr) return -1;
946 *ptr++ = *plparam; /* Store previous lParam */
947 *plparam = (LPARAM)ptr;
948 }
949 }
950 return 1;
951
952 /* Combobox */
953 case CB_ADDSTRING:
954 case CB_INSERTSTRING:
955 case CB_FINDSTRING:
956 case CB_FINDSTRINGEXACT:
957 case CB_SELECTSTRING:
958 if(!*plparam) return 0;
959 if ( WINPROC_TestCBForStr( hwnd ))
960 *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
961 return (*plparam ? 1 : -1);
962
963 case CB_GETLBTEXT: /* FIXME: fixed sized buffer */
964 { if ( WINPROC_TestCBForStr( hwnd ))
965 { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM) );
966 if (!ptr) return -1;
967 *ptr++ = *plparam; /* Store previous lParam */
968 *plparam = (LPARAM)ptr;
969 }
970 }
971 return 1;
972
973 /* Multiline edit */
974 case EM_GETLINE:
975 { WORD len = (WORD)*plparam;
976 LPARAM *ptr = (LPARAM *) HeapAlloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(CHAR) );
977 if (!ptr) return -1;
978 *ptr++ = *plparam; /* Store previous lParam */
979 *((WORD *) ptr) = len; /* Store the length */
980 *plparam = (LPARAM)ptr;
981 }
982 return 1;
983
984 case WM_CHARTOITEM:
985 case WM_MENUCHAR:
986 case WM_CHAR:
987 case WM_DEADCHAR:
988 case WM_SYSCHAR:
989 case WM_SYSDEADCHAR:
990 case EM_SETPASSWORDCHAR:
991 {
992 WCHAR wch = LOWORD(*pwparam);
993 BYTE ch;
994 WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL );
995 *pwparam = MAKEWPARAM( ch, HIWORD(*pwparam) );
996 }
997 return 0;
998
999 case WM_IME_CHAR:
1000 {
1001 WCHAR wch = LOWORD(*pwparam);
1002 BYTE ch[2];
1003
1004 ch[1] = 0;
1005 WideCharToMultiByte( CP_ACP, 0, &wch, 1, ch, 2, NULL, NULL );
1006 *pwparam = MAKEWPARAM( (ch[0] << 8) | ch[1], HIWORD(*pwparam) );
1007 }
1008 return 0;
1009
1010 case WM_PAINTCLIPBOARD:
1011 case WM_SIZECLIPBOARD:
1012 FIXME_(msg)("message %s (%04x) needs translation, please report\n",SPY_GetMsgName(msg, hwnd),msg );
1013 return -1;
1014 default: /* No translation needed */
1015 return 0;
1016 }
1017 }
1018
1019
1020 /**********************************************************************
1021 * WINPROC_UnmapMsg32WTo32A
1022 *
1023 * Unmap a message that was mapped from Unicode to Ansi.
1024 */
1025 void WINPROC_UnmapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1026 {
1027 switch(msg)
1028 {
1029 case WM_GETTEXT:
1030 case WM_ASKCBFORMATNAME:
1031 {
1032 LPARAM *ptr = (LPARAM *)lParam - 1;
1033 if (wParam)
1034 {
1035 if (!MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, wParam ))
1036 ((LPWSTR)*ptr)[wParam-1] = 0;
1037 }
1038 HeapFree( GetProcessHeap(), 0, ptr );
1039 }
1040 break;
1041
1042 case WM_SETTEXT:
1043 case WM_WININICHANGE:
1044 case WM_DEVMODECHANGE:
1045 case CB_DIR:
1046 case LB_DIR:
1047 case LB_ADDFILE:
1048 case EM_REPLACESEL:
1049 HeapFree( GetProcessHeap(), 0, (void *)lParam );
1050 break;
1051
1052 case WM_NCCREATE:
1053 case WM_CREATE:
1054 {
1055 CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
1056 if (HIWORD(cs->lpszName))
1057 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszName );
1058 if (HIWORD(cs->lpszClass))
1059 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszClass );
1060 HeapFree( GetProcessHeap(), 0, cs );
1061 }
1062 break;
1063
1064 case WM_MDICREATE:
1065 {
1066 MDICREATESTRUCTA *cs = (MDICREATESTRUCTA *)lParam;
1067 if (HIWORD(cs->szTitle))
1068 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
1069 if (HIWORD(cs->szClass))
1070 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
1071 HeapFree( GetProcessHeap(), 0, cs );
1072 }
1073 break;
1074
1075 /* Listbox */
1076 case LB_ADDSTRING:
1077 case LB_INSERTSTRING:
1078 case LB_FINDSTRING:
1079 case LB_FINDSTRINGEXACT:
1080 case LB_SELECTSTRING:
1081 if ( WINPROC_TestLBForStr( hwnd ))
1082 HeapFree( GetProcessHeap(), 0, (void *)lParam );
1083 break;
1084
1085 case LB_GETTEXT:
1086 if ( WINPROC_TestLBForStr( hwnd ))
1087 {
1088 LPARAM *ptr = (LPARAM *)lParam - 1;
1089 MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, 0x7fffffff );
1090 HeapFree( GetProcessHeap(), 0, ptr );
1091 }
1092 break;
1093
1094 /* Combobox */
1095 case CB_ADDSTRING:
1096 case CB_INSERTSTRING:
1097 case CB_FINDSTRING:
1098 case CB_FINDSTRINGEXACT:
1099 case CB_SELECTSTRING:
1100 if ( WINPROC_TestCBForStr( hwnd ))
1101 HeapFree( GetProcessHeap(), 0, (void *)lParam );
1102 break;
1103
1104 case CB_GETLBTEXT:
1105 if ( WINPROC_TestCBForStr( hwnd ))
1106 {
1107 LPARAM *ptr = (LPARAM *)lParam - 1;
1108 MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, 0x7fffffff );
1109 HeapFree( GetProcessHeap(), 0, ptr );
1110 }
1111 break;
1112
1113 /* Multiline edit */
1114 case EM_GETLINE:
1115 { LPARAM * ptr = (LPARAM *)lParam - 1; /* get the old lparam */
1116 WORD len = *(WORD *)ptr;
1117 if (len)
1118 {
1119 if (!MultiByteToWideChar( CP_ACP, 0, (LPSTR)lParam, -1, (LPWSTR)*ptr, len ))
1120 ((LPWSTR)*ptr)[len-1] = 0;
1121 }
1122 HeapFree( GetProcessHeap(), 0, ptr );
1123 }
1124 break;
1125 }
1126 }
1127
1128 static UINT convert_handle_16_to_32(HANDLE16 src, unsigned int flags)
1129 {
1130 HANDLE dst;
1131 UINT sz = GlobalSize16(src);
1132 LPSTR ptr16, ptr32;
1133
1134 if (!(dst = GlobalAlloc(flags, sz)))
1135 return 0;
1136 ptr16 = GlobalLock16(src);
1137 ptr32 = GlobalLock(dst);
1138 if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr32, ptr16, sz);
1139 GlobalUnlock16(src);
1140 GlobalUnlock(dst);
1141
1142 return (UINT)dst;
1143 }
1144
1145 /**********************************************************************
1146 * WINPROC_MapMsg16To32A
1147 *
1148 * Map a message from 16- to 32-bit Ansi.
1149 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1150 */
1151 INT WINPROC_MapMsg16To32A( HWND hwnd, UINT16 msg16, WPARAM16 wParam16, UINT *pmsg32,
1152 WPARAM *pwparam32, LPARAM *plparam )
1153 {
1154 *pmsg32 = (UINT)msg16;
1155 *pwparam32 = (WPARAM)wParam16;
1156 switch(msg16)
1157 {
1158 case WM_ACTIVATE:
1159 case WM_CHARTOITEM:
1160 case WM_COMMAND:
1161 case WM_VKEYTOITEM:
1162 *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
1163 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1164 return 0;
1165 case WM_HSCROLL:
1166 case WM_VSCROLL:
1167 *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1168 *plparam = (LPARAM)WIN_Handle32( HIWORD(*plparam) );
1169 return 0;
1170 case WM_CTLCOLOR:
1171 if ( HIWORD(*plparam) > CTLCOLOR_STATIC ) return -1;
1172 *pmsg32 = WM_CTLCOLORMSGBOX + HIWORD(*plparam);
1173 *pwparam32 = (WPARAM)HDC_32(wParam16);
1174 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1175 return 0;
1176 case WM_COMPAREITEM:
1177 {
1178 COMPAREITEMSTRUCT16* cis16 = MapSL(*plparam);
1179 COMPAREITEMSTRUCT *cis = (COMPAREITEMSTRUCT *)
1180 HeapAlloc(GetProcessHeap(), 0, sizeof(*cis));
1181 if (!cis) return -1;
1182 cis->CtlType = cis16->CtlType;
1183 cis->CtlID = cis16->CtlID;
1184 cis->hwndItem = WIN_Handle32( cis16->hwndItem );
1185 cis->itemID1 = cis16->itemID1;
1186 cis->itemData1 = cis16->itemData1;
1187 cis->itemID2 = cis16->itemID2;
1188 cis->itemData2 = cis16->itemData2;
1189 cis->dwLocaleId = 0; /* FIXME */
1190 *plparam = (LPARAM)cis;
1191 }
1192 return 1;
1193 case WM_DELETEITEM:
1194 {
1195 DELETEITEMSTRUCT16* dis16 = MapSL(*plparam);
1196 DELETEITEMSTRUCT *dis = (DELETEITEMSTRUCT *)
1197 HeapAlloc(GetProcessHeap(), 0, sizeof(*dis));
1198 if (!dis) return -1;
1199 dis->CtlType = dis16->CtlType;
1200 dis->CtlID = dis16->CtlID;
1201 dis->hwndItem = WIN_Handle32( dis16->hwndItem );
1202 dis->itemData = dis16->itemData;
1203 *plparam = (LPARAM)dis;
1204 }
1205 return 1;
1206 case WM_MEASUREITEM:
1207 {
1208 MEASUREITEMSTRUCT16* mis16 = MapSL(*plparam);
1209 MEASUREITEMSTRUCT *mis = (MEASUREITEMSTRUCT *)
1210 HeapAlloc(GetProcessHeap(), 0,
1211 sizeof(*mis) + sizeof(LPARAM));
1212 if (!mis) return -1;
1213 mis->CtlType = mis16->CtlType;
1214 mis->CtlID = mis16->CtlID;
1215 mis->itemID = mis16->itemID;
1216 mis->itemWidth = mis16->itemWidth;
1217 mis->itemHeight = mis16->itemHeight;
1218 mis->itemData = mis16->itemData;
1219 *(LPARAM *)(mis + 1) = *plparam; /* Store the previous lParam */
1220 *plparam = (LPARAM)mis;
1221 }
1222 return 1;
1223 case WM_DRAWITEM:
1224 {
1225 DRAWITEMSTRUCT16* dis16 = MapSL(*plparam);
1226 DRAWITEMSTRUCT *dis = (DRAWITEMSTRUCT*)HeapAlloc(GetProcessHeap(), 0,
1227 sizeof(*dis));
1228 if (!dis) return -1;
1229 dis->CtlType = dis16->CtlType;
1230 dis->CtlID = dis16->CtlID;
1231 dis->itemID = dis16->itemID;
1232 dis->itemAction = dis16->itemAction;
1233 dis->itemState = dis16->itemState;
1234 dis->hwndItem = (dis->CtlType == ODT_MENU) ? (HWND)HMENU_32(dis16->hwndItem)
1235 : WIN_Handle32( dis16->hwndItem );
1236 dis->hDC = HDC_32(dis16->hDC);
1237 dis->itemData = dis16->itemData;
1238 CONV_RECT16TO32( &dis16->rcItem, &dis->rcItem );
1239 *plparam = (LPARAM)dis;
1240 }
1241 return 1;
1242 case WM_GETMINMAXINFO:
1243 {
1244 MINMAXINFO *mmi = (MINMAXINFO *)HeapAlloc( GetProcessHeap(), 0,
1245 sizeof(*mmi) + sizeof(LPARAM));
1246 if (!mmi) return -1;
1247 STRUCT32_MINMAXINFO16to32( MapSL(*plparam), mmi );
1248 *(LPARAM *)(mmi + 1) = *plparam; /* Store the previous lParam */
1249 *plparam = (LPARAM)mmi;
1250 }
1251 return 1;
1252 case WM_GETTEXT:
1253 case WM_SETTEXT:
1254 case WM_WININICHANGE:
1255 case WM_DEVMODECHANGE:
1256 case WM_ASKCBFORMATNAME:
1257 *plparam = (LPARAM)MapSL(*plparam);
1258 return 0;
1259 case WM_MDICREATE:
1260 {
1261 MDICREATESTRUCT16 *cs16 = MapSL(*plparam);
1262 MDICREATESTRUCTA *cs = HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) + sizeof(LPARAM) );
1263 if (!cs) return -1;
1264 STRUCT32_MDICREATESTRUCT16to32A( cs16, cs );
1265 cs->szTitle = MapSL(cs16->szTitle);
1266 cs->szClass = MapSL(cs16->szClass);
1267 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1268 *plparam = (LPARAM)cs;
1269 }
1270 return 1;
1271 case WM_MDIGETACTIVE:
1272 *plparam = (LPARAM)HeapAlloc( GetProcessHeap(), 0, sizeof(BOOL) );
1273 *(BOOL*)(*plparam) = 0;
1274 return 1;
1275 case WM_MDISETMENU:
1276 if(wParam16==TRUE)
1277 *pmsg32=WM_MDIREFRESHMENU;
1278 *pwparam32 = (WPARAM)HMENU_32(LOWORD(*plparam));
1279 *plparam = (LPARAM)HMENU_32(HIWORD(*plparam));
1280 return 0;
1281 case WM_MENUCHAR:
1282 *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1283 *plparam = (LPARAM)HMENU_32(HIWORD(*plparam));
1284 return 0;
1285 case WM_MENUSELECT:
1286 if((LOWORD(*plparam) & MF_POPUP) && (LOWORD(*plparam) != 0xFFFF))
1287 {
1288 HMENU hmenu=HMENU_32(HIWORD(*plparam));
1289 UINT Pos=MENU_FindSubMenu( &hmenu, HMENU_32(wParam16));
1290 if(Pos==0xFFFF) Pos=0; /* NO_SELECTED_ITEM */
1291 *pwparam32 = MAKEWPARAM( Pos, LOWORD(*plparam) );
1292 }
1293 else *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
1294 *plparam = (LPARAM)HMENU_32(HIWORD(*plparam));
1295 return 0;
1296 case WM_MDIACTIVATE:
1297 if( *plparam )
1298 {
1299 *pwparam32 = (WPARAM)WIN_Handle32( HIWORD(*plparam) );
1300 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1301 }
1302 else /* message sent to MDI client */
1303 *pwparam32 = wParam16;
1304 return 0;
1305 case WM_NCCALCSIZE:
1306 {
1307 NCCALCSIZE_PARAMS16 *nc16;
1308 NCCALCSIZE_PARAMS *nc;
1309
1310 nc = (NCCALCSIZE_PARAMS *)HeapAlloc( GetProcessHeap(), 0,
1311 sizeof(*nc) + sizeof(LPARAM) );
1312 if (!nc) return -1;
1313 nc16 = MapSL(*plparam);
1314 CONV_RECT16TO32( &nc16->rgrc[0], &nc->rgrc[0] );
1315 if (wParam16)
1316 {
1317 nc->lppos = (WINDOWPOS *)HeapAlloc( GetProcessHeap(), 0,
1318 sizeof(*nc->lppos) );
1319 CONV_RECT16TO32( &nc16->rgrc[1], &nc->rgrc[1] );
1320 CONV_RECT16TO32( &nc16->rgrc[2], &nc->rgrc[2] );
1321 if (nc->lppos) STRUCT32_WINDOWPOS16to32( MapSL(nc16->lppos), nc->lppos );
1322 }
1323 *(LPARAM *)(nc + 1) = *plparam; /* Store the previous lParam */
1324 *plparam = (LPARAM)nc;
1325 }
1326 return 1;
1327 case WM_NCCREATE:
1328 case WM_CREATE:
1329 {
1330 CREATESTRUCT16 *cs16 = MapSL(*plparam);
1331 CREATESTRUCTA *cs = (CREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0,
1332 sizeof(*cs) + sizeof(LPARAM) );
1333 if (!cs) return -1;
1334 STRUCT32_CREATESTRUCT16to32A( cs16, cs );
1335 cs->lpszName = MapSL(cs16->lpszName);
1336 cs->lpszClass = MapSL(cs16->lpszClass);
1337 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1338 *plparam = (LPARAM)cs;
1339 }
1340 return 1;
1341 case WM_PARENTNOTIFY:
1342 if ((wParam16 == WM_CREATE) || (wParam16 == WM_DESTROY))
1343 {
1344 *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
1345 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1346 }
1347 return 0;
1348 case WM_WINDOWPOSCHANGING:
1349 case WM_WINDOWPOSCHANGED:
1350 {
1351 WINDOWPOS *wp = (WINDOWPOS *)HeapAlloc( GetProcessHeap(), 0,
1352 sizeof(*wp) + sizeof(LPARAM) );
1353 if (!wp) return -1;
1354 STRUCT32_WINDOWPOS16to32( MapSL(*plparam), wp );
1355 *(LPARAM *)(wp + 1) = *plparam; /* Store the previous lParam */
1356 *plparam = (LPARAM)wp;
1357 }
1358 return 1;
1359 case WM_GETDLGCODE:
1360 if (*plparam)
1361 {
1362 LPMSG16 msg16 = MapSL(*plparam);
1363 LPMSG msg32 = (LPMSG)HeapAlloc( GetProcessHeap(), 0, sizeof(MSG) );
1364
1365 if (!msg32) return -1;
1366 msg32->hwnd = WIN_Handle32( msg16->hwnd );
1367 msg32->lParam = msg16->lParam;
1368 msg32->time = msg16->time;
1369 CONV_POINT16TO32(&msg16->pt,&msg32->pt);
1370 /* this is right, right? */
1371 if (WINPROC_MapMsg16To32A( msg32->hwnd, msg16->message,msg16->wParam,
1372 &msg32->message,&msg32->wParam,
1373 &msg32->lParam)<0) {
1374 HeapFree( GetProcessHeap(), 0, msg32 );
1375 return -1;
1376 }
1377 *plparam = (LPARAM)msg32;
1378 return 1;
1379 }
1380 else return 0;
1381 case WM_NOTIFY:
1382 *plparam = (LPARAM)MapSL(*plparam);
1383 return 0;
1384 case WM_ACTIVATEAPP:
1385 /* We need this when SetActiveWindow sends a Sendmessage16() to
1386 * a 32bit window. Might be superflous with 32bit interprocess
1387 * message queues. */
1388 if (*plparam) *plparam = HTASK_32( *plparam );
1389 return 0;
1390 case WM_NEXTMENU:
1391 {
1392 MDINEXTMENU *next = HeapAlloc( GetProcessHeap(), 0, sizeof(*next) );
1393 if (!next) return -1;
1394 next->hmenuIn = (HMENU)*plparam;
1395 next->hmenuNext = 0;
1396 next->hwndNext = 0;
1397 *plparam = (LPARAM)next;
1398 return 1;
1399 }
1400 case WM_PAINTCLIPBOARD:
1401 case WM_SIZECLIPBOARD:
1402 FIXME_(msg)("message %04x needs translation\n",msg16 );
1403 return -1;
1404 case WM_DDE_INITIATE:
1405 case WM_DDE_TERMINATE:
1406 case WM_DDE_UNADVISE:
1407 case WM_DDE_REQUEST:
1408 *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1409 return 0;
1410 case WM_DDE_ADVISE:
1411 case WM_DDE_DATA:
1412 case WM_DDE_POKE:
1413 {
1414 HANDLE16 lo16;
1415 ATOM hi;
1416 UINT lo32 = 0;
1417
1418 *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1419 lo16 = LOWORD(*plparam);
1420 hi = HIWORD(*plparam);
1421 if (lo16 && !(lo32 = convert_handle_16_to_32(lo16, GMEM_DDESHARE)))
1422 return -1;
1423 *plparam = PackDDElParam(msg16, lo32, hi);
1424 }
1425 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
1426 case WM_DDE_ACK:
1427 {
1428 UINT lo, hi;
1429 int flag = 0;
1430 char buf[2];
1431
1432 *pwparam32 = (WPARAM)WIN_Handle32(wParam16);
1433
1434 lo = LOWORD(*plparam);
1435 hi = HIWORD(*plparam);
1436
1437 if (GlobalGetAtomNameA(hi, buf, 2) > 0) flag |= 1;
1438 if (GlobalSize16(hi) != 0) flag |= 2;
1439 switch (flag)
1440 {
1441 case 0:
1442 if (hi)
1443 {
1444 MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
1445 hi = 0;
1446 }
1447 break;
1448 case 1:
1449 break; /* atom, nothing to do */
1450 case 3:
1451 MESSAGE("DDE_ACK: %x both atom and handle... choosing handle\n", hi);
1452 /* fall thru */
1453 case 2:
1454 hi = convert_handle_16_to_32(hi, GMEM_DDESHARE);
1455 break;
1456 }
1457 *plparam = PackDDElParam(WM_DDE_ACK, lo, hi);
1458 }
1459 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
1460 case WM_DDE_EXECUTE:
1461 *plparam = convert_handle_16_to_32(*plparam, GMEM_DDESHARE);
1462 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
1463 default: /* No translation needed */
1464 return 0;
1465 }
1466 }
1467
1468
1469 /**********************************************************************
1470 * WINPROC_UnmapMsg16To32A
1471 *
1472 * Unmap a message that was mapped from 16- to 32-bit Ansi.
1473 */
1474 LRESULT WINPROC_UnmapMsg16To32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
1475 LRESULT result )
1476 {
1477 switch(msg)
1478 {
1479 case WM_COMPAREITEM:
1480 case WM_DELETEITEM:
1481 case WM_DRAWITEM:
1482 HeapFree( GetProcessHeap(), 0, (LPVOID)lParam );
1483 break;
1484 case WM_MEASUREITEM:
1485 {
1486 MEASUREITEMSTRUCT16 *mis16;
1487 MEASUREITEMSTRUCT *mis = (MEASUREITEMSTRUCT *)lParam;
1488 lParam = *(LPARAM *)(mis + 1);
1489 mis16 = MapSL(lParam);
1490 mis16->itemWidth = (UINT16)mis->itemWidth;
1491 mis16->itemHeight = (UINT16)mis->itemHeight;
1492 HeapFree( GetProcessHeap(), 0, mis );
1493 }
1494 break;
1495 case WM_GETMINMAXINFO:
1496 {
1497 MINMAXINFO *mmi = (MINMAXINFO *)lParam;
1498 lParam = *(LPARAM *)(mmi + 1);
1499 STRUCT32_MINMAXINFO32to16( mmi, MapSL(lParam));
1500 HeapFree( GetProcessHeap(), 0, mmi );
1501 }
1502 break;
1503 case WM_MDICREATE:
1504 {
1505 MDICREATESTRUCTA *cs = (MDICREATESTRUCTA *)lParam;
1506 lParam = *(LPARAM *)(cs + 1);
1507 STRUCT32_MDICREATESTRUCT32Ato16( cs, MapSL(lParam) );
1508 HeapFree( GetProcessHeap(), 0, cs );
1509 }
1510 break;
1511 case WM_MDIGETACTIVE:
1512 result = MAKELONG( LOWORD(result), (BOOL16)(*(BOOL *)lParam) );
1513 HeapFree( GetProcessHeap(), 0, (BOOL *)lParam );
1514 break;
1515 case WM_NCCALCSIZE:
1516 {
1517 NCCALCSIZE_PARAMS16 *nc16;
1518 NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lParam;
1519 lParam = *(LPARAM *)(nc + 1);
1520 nc16 = MapSL(lParam);
1521 CONV_RECT32TO16( &nc->rgrc[0], &nc16->rgrc[0] );
1522 if (wParam)
1523 {
1524 CONV_RECT32TO16( &nc->rgrc[1], &nc16->rgrc[1] );
1525 CONV_RECT32TO16( &nc->rgrc[2], &nc16->rgrc[2] );
1526 if (nc->lppos)
1527 {
1528 STRUCT32_WINDOWPOS32to16( nc->lppos, MapSL(nc16->lppos));
1529 HeapFree( GetProcessHeap(), 0, nc->lppos );
1530 }
1531 }
1532 HeapFree( GetProcessHeap(), 0, nc );
1533 }
1534 break;
1535 case WM_NCCREATE:
1536 case WM_CREATE:
1537 {
1538 CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
1539 lParam = *(LPARAM *)(cs + 1);
1540 STRUCT32_CREATESTRUCT32Ato16( cs, MapSL(lParam) );
1541 HeapFree( GetProcessHeap(), 0, cs );
1542 }
1543 break;
1544 case WM_WINDOWPOSCHANGING:
1545 case WM_WINDOWPOSCHANGED:
1546 {
1547 WINDOWPOS *wp = (WINDOWPOS *)lParam;
1548 lParam = *(LPARAM *)(wp + 1);
1549 STRUCT32_WINDOWPOS32to16(wp, MapSL(lParam));
1550 HeapFree( GetProcessHeap(), 0, wp );
1551 }
1552 break;
1553 case WM_GETDLGCODE:
1554 if (lParam)
1555 {
1556 LPMSG msg32 = (LPMSG)lParam;
1557
1558 WINPROC_UnmapMsg16To32A( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1559 result);
1560 HeapFree( GetProcessHeap(), 0, msg32 );
1561 }
1562 break;
1563 case WM_NEXTMENU:
1564 {
1565 MDINEXTMENU *next = (MDINEXTMENU *)lParam;
1566 result = MAKELONG( HMENU_16(next->hmenuNext), HWND_16(next->hwndNext) );
1567 HeapFree( GetProcessHeap(), 0, next );
1568 }
1569 break;
1570 }
1571 return result;
1572 }
1573
1574
1575 /**********************************************************************
1576 * WINPROC_MapMsg16To32W
1577 *
1578 * Map a message from 16- to 32-bit Unicode.
1579 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1580 */
1581 INT WINPROC_MapMsg16To32W( HWND hwnd, UINT16 msg16, WPARAM16 wParam16, UINT *pmsg32,
1582 WPARAM *pwparam32, LPARAM *plparam )
1583 {
1584 BYTE ch;
1585 WCHAR wch;
1586
1587 *pmsg32=(UINT)msg16;
1588 *pwparam32 = (WPARAM)wParam16;
1589 switch(msg16)
1590 {
1591 case WM_GETTEXT:
1592 case WM_SETTEXT:
1593 case WM_WININICHANGE:
1594 case WM_DEVMODECHANGE:
1595 case WM_ASKCBFORMATNAME:
1596 *plparam = (LPARAM)MapSL(*plparam);
1597 return WINPROC_MapMsg32ATo32W( hwnd, *pmsg32, pwparam32, plparam );
1598 case WM_GETTEXTLENGTH:
1599 case CB_GETLBTEXTLEN:
1600 case LB_GETTEXTLEN:
1601 return 1; /* need to map result */
1602 case WM_NCCREATE:
1603 case WM_CREATE:
1604 {
1605 CREATESTRUCT16 *cs16 = MapSL(*plparam);
1606 CREATESTRUCTW *cs = (CREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0,
1607 sizeof(*cs) + sizeof(LPARAM) );
1608 if (!cs) return -1;
1609 STRUCT32_CREATESTRUCT16to32A( cs16, (CREATESTRUCTA *)cs );
1610 cs->lpszName = map_str_16_to_32W(cs16->lpszName);
1611 cs->lpszClass = map_str_16_to_32W(cs16->lpszClass);
1612 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1613 *plparam = (LPARAM)cs;
1614 }
1615 return 1;
1616 case WM_MDICREATE:
1617 {
1618 MDICREATESTRUCT16 *cs16 = MapSL(*plparam);
1619 MDICREATESTRUCTW *cs =
1620 (MDICREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0,
1621 sizeof(*cs) + sizeof(LPARAM) );
1622 if (!cs) return -1;
1623 STRUCT32_MDICREATESTRUCT16to32A( cs16, (MDICREATESTRUCTA *)cs );
1624 cs->szTitle = map_str_16_to_32W(cs16->szTitle);
1625 cs->szClass = map_str_16_to_32W(cs16->szClass);
1626 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1627 *plparam = (LPARAM)cs;
1628 }
1629 return 1;
1630 case WM_GETDLGCODE:
1631 if (*plparam)
1632 {
1633 LPMSG16 msg16 = MapSL(*plparam);
1634 LPMSG msg32 = (LPMSG)HeapAlloc( GetProcessHeap(), 0, sizeof(MSG) );
1635
1636 if (!msg32) return -1;
1637 msg32->hwnd = WIN_Handle32( msg16->hwnd );
1638 msg32->lParam = msg16->lParam;
1639 msg32->time = msg16->time;
1640 CONV_POINT16TO32(&msg16->pt,&msg32->pt);
1641 /* this is right, right? */
1642 if (WINPROC_MapMsg16To32W(hwnd, msg16->message,msg16->wParam,
1643 &msg32->message,&msg32->wParam,
1644 &msg32->lParam)<0) {
1645 HeapFree( GetProcessHeap(), 0, msg32 );
1646 return -1;
1647 }
1648 *plparam = (LPARAM)msg32;
1649 return 1;
1650 }
1651 else return 0;
1652
1653 case WM_CHARTOITEM:
1654 ch = wParam16;
1655 MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1656 *pwparam32 = MAKEWPARAM( wch, HIWORD(*plparam) );
1657 *plparam = (LPARAM)WIN_Handle32( LOWORD(*plparam) );
1658 return 0;
1659 case WM_MENUCHAR:
1660 ch = wParam16;
1661 MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1662 *pwparam32 = MAKEWPARAM( wch, LOWORD(*plparam) );
1663 *plparam = (LPARAM)HMENU_32(HIWORD(*plparam));
1664 return 0;
1665 case WM_CHAR:
1666 case WM_DEADCHAR:
1667 case WM_SYSCHAR:
1668 case WM_SYSDEADCHAR:
1669 ch = wParam16;
1670 MultiByteToWideChar( CP_ACP, 0, &ch, 1, &wch, 1);
1671 *pwparam32 = wch;
1672 return 0;
1673 case WM_IME_CHAR:
1674 {
1675 char ch[2];
1676 ch[0] = (wParam16 >> 8);
1677 ch[1] = wParam16 & 0xff;
1678 MultiByteToWideChar(CP_ACP, 0, ch, 2, &wch, 1);
1679 *pwparam32 = wch;
1680 }
1681 return 0;
1682
1683 default: /* No Unicode translation needed */
1684 return WINPROC_MapMsg16To32A( hwnd, msg16, wParam16, pmsg32,
1685 pwparam32, plparam );
1686 }
1687 }
1688
1689
1690 /**********************************************************************
1691 * WINPROC_UnmapMsg16To32W
1692 *
1693 * Unmap a message that was mapped from 16- to 32-bit Unicode.
1694 */
1695 LRESULT WINPROC_UnmapMsg16To32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
1696 LRESULT result )
1697 {
1698 switch(msg)
1699 {
1700 case WM_GETTEXT:
1701 case WM_SETTEXT:
1702 case WM_GETTEXTLENGTH:
1703 case CB_GETLBTEXTLEN:
1704 case LB_GETTEXTLEN:
1705 case WM_ASKCBFORMATNAME:
1706 return WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam, result );
1707 case WM_NCCREATE:
1708 case WM_CREATE:
1709 {
1710 CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
1711 lParam = *(LPARAM *)(cs + 1);
1712 STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCTA *)cs, MapSL(lParam) );
1713 unmap_str_16_to_32W( cs->lpszName );
1714 unmap_str_16_to_32W( cs->lpszClass );
1715 HeapFree( GetProcessHeap(), 0, cs );
1716 }
1717 break;
1718 case WM_MDICREATE:
1719 {
1720 MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lParam;
1721 lParam = *(LPARAM *)(cs + 1);
1722 STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCTA *)cs, MapSL(lParam) );
1723 unmap_str_16_to_32W( cs->szTitle );
1724 unmap_str_16_to_32W( cs->szClass );
1725 HeapFree( GetProcessHeap(), 0, cs );
1726 }
1727 break;
1728 case WM_GETDLGCODE:
1729 if (lParam)
1730 {
1731 LPMSG msg32 = (LPMSG)lParam;
1732
1733 WINPROC_UnmapMsg16To32W( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1734 result);
1735 HeapFree( GetProcessHeap(), 0, msg32 );
1736 }
1737 break;
1738 default:
1739 return WINPROC_UnmapMsg16To32A( hwnd, msg, wParam, lParam, result );
1740 }
1741 return result;
1742 }
1743
1744 static HANDLE16 convert_handle_32_to_16(UINT src, unsigned int flags)
1745 {
1746 HANDLE16 dst;
1747 UINT sz = GlobalSize((HANDLE)src);
1748 LPSTR ptr16, ptr32;
1749
1750 if (!(dst = GlobalAlloc16(flags, sz)))
1751 return 0;
1752 ptr32 = GlobalLock((HANDLE)src);
1753 ptr16 = GlobalLock16(dst);
1754 if (ptr16 != NULL && ptr32 != NULL) memcpy(ptr16, ptr32, sz);
1755 GlobalUnlock((HANDLE)src);
1756 GlobalUnlock16(dst);
1757
1758 return dst;
1759 }
1760
1761
1762 /**********************************************************************
1763 * WINPROC_MapMsg32ATo16
1764 *
1765 * Map a message from 32-bit Ansi to 16-bit.
1766 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1767 */
1768 INT WINPROC_MapMsg32ATo16( HWND hwnd, UINT msg32, WPARAM wParam32,
1769 UINT16 *pmsg16, WPARAM16 *pwparam16,
1770 LPARAM *plparam )
1771 {
1772 *pmsg16 = (UINT16)msg32;
1773 *pwparam16 = (WPARAM16)LOWORD(wParam32);
1774 switch(msg32)
1775 {
1776 case BM_GETCHECK:
1777 case BM_SETCHECK:
1778 case BM_GETSTATE:
1779 case BM_SETSTATE:
1780 case BM_SETSTYLE:
1781 *pmsg16 = (UINT16)msg32 + (BM_GETCHECK16 - BM_GETCHECK);
1782 return 0;
1783
1784 case EM_GETSEL:
1785 case EM_GETRECT:
1786 case EM_SETRECT:
1787 case EM_SETRECTNP:
1788 case EM_SCROLL:
1789 case EM_LINESCROLL:
1790 case EM_SCROLLCARET:
1791 case EM_GETMODIFY:
1792 case EM_SETMODIFY:
1793 case EM_GETLINECOUNT:
1794 case EM_LINEINDEX:
1795 case EM_SETHANDLE:
1796 case EM_GETHANDLE:
1797 case EM_GETTHUMB:
1798 case EM_LINELENGTH:
1799 case EM_REPLACESEL:
1800 case EM_GETLINE:
1801 case EM_LIMITTEXT:
1802 case EM_CANUNDO:
1803 case EM_UNDO:
1804 case EM_FMTLINES:
1805 case EM_LINEFROMCHAR:
1806 case EM_SETTABSTOPS:
1807 case EM_SETPASSWORDCHAR:
1808 case EM_EMPTYUNDOBUFFER:
1809 case EM_GETFIRSTVISIBLELINE:
1810 case EM_SETREADONLY:
1811 case EM_SETWORDBREAKPROC:
1812 case EM_GETWORDBREAKPROC:
1813 case EM_GETPASSWORDCHAR:
1814 *pmsg16 = (UINT16)msg32 + (EM_GETSEL16 - EM_GETSEL);
1815 return 0;
1816
1817 case LB_CARETOFF:
1818 case LB_CARETON:
1819 case LB_DELETESTRING:
1820 case LB_GETANCHORINDEX:
1821 case LB_GETCARETINDEX:
1822 case LB_GETCOUNT:
1823 case LB_GETCURSEL:
1824 case LB_GETHORIZONTALEXTENT:
1825 case LB_GETITEMDATA:
1826 case LB_GETITEMHEIGHT:
1827 case LB_GETSEL:
1828 case LB_GETSELCOUNT:
1829 case LB_GETTEXTLEN:
1830 case LB_GETTOPINDEX:
1831 case LB_RESETCONTENT:
1832 case LB_SELITEMRANGE:
1833 case LB_SELITEMRANGEEX:
1834 case LB_SETANCHORINDEX:
1835 case LB_SETCARETINDEX:
1836 case LB_SETCOLUMNWIDTH:
1837 case LB_SETCURSEL:
1838 case LB_SETHORIZONTALEXTENT:
1839 case LB_SETITEMDATA:
1840 case LB_SETITEMHEIGHT:
1841 case LB_SETSEL:
1842 case LB_SETTOPINDEX:
1843 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
1844 return 0;
1845 case CB_DELETESTRING:
1846 case CB_GETCOUNT:
1847 case CB_GETLBTEXTLEN:
1848 case CB_LIMITTEXT:
1849 case CB_RESETCONTENT:
1850 case CB_SETEDITSEL:
1851 case CB_GETCURSEL:
1852 case CB_SETCURSEL:
1853 case CB_SHOWDROPDOWN:
1854 case CB_SETITEMDATA:
1855 case CB_SETITEMHEIGHT:
1856 case CB_GETITEMHEIGHT:
1857 case CB_SETEXTENDEDUI:
1858 case CB_GETEXTENDEDUI:
1859 case CB_GETDROPPEDSTATE:
1860 *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL);
1861 return 0;
1862 case CB_GETEDITSEL:
1863 *pmsg16 = CB_GETEDITSEL16;
1864 return 1;
1865
1866 case LB_ADDSTRING:
1867 case LB_FINDSTRING:
1868 case LB_FINDSTRINGEXACT:
1869 case LB_INSERTSTRING:
1870 case LB_SELECTSTRING:
1871 case LB_DIR:
1872 case LB_ADDFILE:
1873 *plparam = (LPARAM)MapLS( (LPSTR)*plparam );
1874 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
1875 return 1;
1876
1877 case CB_ADDSTRING:
1878 case CB_FINDSTRING:
1879 case CB_FINDSTRINGEXACT:
1880 case CB_INSERTSTRING:
1881 case CB_SELECTSTRING:
1882 case CB_DIR:
1883 *plparam = (LPARAM)MapLS( (LPSTR)*plparam );
1884 *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL);
1885 return 1;
1886
1887 case LB_GETITEMRECT:
1888 {
1889 RECT16 *rect = HeapAlloc( GetProcessHeap(), 0, sizeof(RECT16) + sizeof(LPARAM) );
1890 if (!rect) return -1;
1891 *(LPARAM *)(rect + 1) = *plparam; /* Store the previous lParam */
1892 *plparam = MapLS( rect );
1893 }
1894 *pmsg16 = LB_GETITEMRECT16;
1895 return 1;
1896 case LB_GETSELITEMS:
1897 {
1898 LPINT16 items;
1899 *pwparam16 = (WPARAM16)min( wParam32, 0x7f80 ); /* Must be < 64K */
1900 if (!(items = HeapAlloc( GetProcessHeap(), 0,
1901 *pwparam16 * sizeof(INT16) + sizeof(LPARAM)))) return -1;
1902 *((LPARAM *)items)++ = *plparam; /* Store the previous lParam */
1903 *plparam = MapLS( items );
1904 }
1905 *pmsg16 = LB_GETSELITEMS16;
1906 return 1;
1907 case LB_SETTABSTOPS:
1908 if (wParam32)
1909 {
1910 INT i;
1911 LPINT16 stops;
1912 *pwparam16 = (WPARAM16)min( wParam32, 0x7f80 ); /* Must be < 64K */
1913 if (!(stops = HeapAlloc( GetProcessHeap(), 0,
1914 *pwparam16 * sizeof(INT16) + sizeof(LPARAM)))) return -1;
1915 for (i = 0; i < *pwparam16; i++) stops[i] = *((LPINT)*plparam+i);
1916 *plparam = MapLS( stops );
1917 return 1;
1918 }
1919 *pmsg16 = LB_SETTABSTOPS16;
1920 return 0;
1921
1922 case CB_GETDROPPEDCONTROLRECT:
1923 {
1924 RECT16 *rect = HeapAlloc( GetProcessHeap(), 0, sizeof(RECT16) + sizeof(LPARAM) );
1925 if (!rect) return -1;
1926 *(LPARAM *)(rect + 1) = *plparam; /* Store the previous lParam */
1927 *plparam = (LPARAM)MapLS(rect);
1928 }
1929 *pmsg16 = CB_GETDROPPEDCONTROLRECT16;
1930 return 1;
1931
1932 case LB_GETTEXT:
1933 *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
1934 *pmsg16 = LB_GETTEXT16;
1935 return 1;
1936
1937 case CB_GETLBTEXT:
1938 *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
1939 *pmsg16 = CB_GETLBTEXT16;
1940 return 1;
1941
1942 case EM_SETSEL:
1943 *pwparam16 = 0;
1944 *plparam = MAKELONG( (INT16)(INT)wParam32, (INT16)*plparam );
1945 *pmsg16 = EM_SETSEL16;
1946 return 0;
1947
1948 case WM_ACTIVATE:
1949 case WM_CHARTOITEM:
1950 case WM_COMMAND:
1951 case WM_VKEYTOITEM:
1952 *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32) );
1953 return 0;
1954 case WM_HSCROLL:
1955 case WM_VSCROLL:
1956 *plparam = MAKELPARAM( HIWORD(wParam32), (HWND16)*plparam );
1957 return 0;
1958 case WM_CTLCOLORMSGBOX:
1959 case WM_CTLCOLOREDIT:
1960 case WM_CTLCOLORLISTBOX:
1961 case WM_CTLCOLORBTN:
1962 case WM_CTLCOLORDLG:
1963 case WM_CTLCOLORSCROLLBAR:
1964 case WM_CTLCOLORSTATIC:
1965 *pmsg16 = WM_CTLCOLOR;
1966 *plparam = MAKELPARAM( (HWND16)*plparam,
1967 (WORD)msg32 - WM_CTLCOLORMSGBOX );
1968 return 0;
1969 case WM_COMPAREITEM:
1970 {
1971 COMPAREITEMSTRUCT *cis32 = (COMPAREITEMSTRUCT *)*plparam;
1972 COMPAREITEMSTRUCT16 *cis = HeapAlloc( GetProcessHeap(), 0, sizeof(COMPAREITEMSTRUCT16));
1973 if (!cis) return -1;
1974 cis->CtlType = (UINT16)cis32->CtlType;
1975 cis->CtlID = (UINT16)cis32->CtlID;
1976 cis->hwndItem = HWND_16( cis32->hwndItem );
1977 cis->itemID1 = (UINT16)cis32->itemID1;
1978 cis->itemData1 = cis32->itemData1;
1979 cis->itemID2 = (UINT16)cis32->itemID2;
1980 cis->itemData2 = cis32->itemData2;
1981 *plparam = MapLS( cis );
1982 }
1983 return 1;
1984 case WM_DELETEITEM:
1985 {
1986 DELETEITEMSTRUCT *dis32 = (DELETEITEMSTRUCT *)*plparam;
1987 DELETEITEMSTRUCT16 *dis = HeapAlloc( GetProcessHeap(), 0, sizeof(DELETEITEMSTRUCT16) );
1988 if (!dis) return -1;
1989 dis->CtlType = (UINT16)dis32->CtlType;
1990 dis->CtlID = (UINT16)dis32->CtlID;
1991 dis->itemID = (UINT16)dis32->itemID;
1992 dis->hwndItem = (dis->CtlType == ODT_MENU) ? (HWND16)LOWORD(dis32->hwndItem)
1993 : HWND_16( dis32->hwndItem );
1994 dis->itemData = dis32->itemData;
1995 *plparam = MapLS( dis );
1996 }
1997 return 1;
1998 case WM_DRAWITEM:
1999 {
2000 DRAWITEMSTRUCT *dis32 = (DRAWITEMSTRUCT *)*plparam;
2001 DRAWITEMSTRUCT16 *dis = HeapAlloc( GetProcessHeap(), 0, sizeof(DRAWITEMSTRUCT16) );
2002 if (!dis) return -1;
2003 dis->CtlType = (UINT16)dis32->CtlType;
2004 dis->CtlID = (UINT16)dis32->CtlID;
2005 dis->itemID = (UINT16)dis32->itemID;
2006 dis->itemAction = (UINT16)dis32->itemAction;
2007 dis->itemState = (UINT16)dis32->itemState;
2008 dis->hwndItem = HWND_16( dis32->hwndItem );
2009 dis->hDC = HDC_16(dis32->hDC);
2010 dis->itemData = dis32->itemData;
2011 CONV_RECT32TO16( &dis32->rcItem, &dis->rcItem );
2012 *plparam = MapLS( dis );
2013 }
2014 return 1;
2015 case WM_MEASUREITEM:
2016 {
2017 MEASUREITEMSTRUCT *mis32 = (MEASUREITEMSTRUCT *)*plparam;
2018 MEASUREITEMSTRUCT16 *mis = HeapAlloc( GetProcessHeap(), 0, sizeof(*mis)+sizeof(LPARAM));
2019 if (!mis) return -1;
2020 mis->CtlType = (UINT16)mis32->CtlType;
2021 mis->CtlID = (UINT16)mis32->CtlID;
2022 mis->itemID = (UINT16)mis32->itemID;
2023 mis->itemWidth = (UINT16)mis32->itemWidth;
2024 mis->itemHeight = (UINT16)mis32->itemHeight;
2025 mis->itemData = mis32->itemData;
2026 *(LPARAM *)(mis + 1) = *plparam; /* Store the previous lParam */
2027 *plparam = MapLS( mis );
2028 }
2029 return 1;
2030 case WM_GETMINMAXINFO:
2031 {
2032 MINMAXINFO16 *mmi = HeapAlloc( GetProcessHeap(), 0, sizeof(*mmi) + sizeof(LPARAM) );
2033 if (!mmi) return -1;
2034 STRUCT32_MINMAXINFO32to16( (MINMAXINFO *)*plparam, mmi );
2035 *(LPARAM *)(mmi + 1) = *plparam; /* Store the previous lParam */
2036 *plparam = MapLS( mmi );
2037 }
2038 return 1;
2039 case WM_GETTEXT:
2040 case WM_ASKCBFORMATNAME:
2041 {
2042 LPSTR str;
2043 *pwparam16 = (WPARAM16)min( wParam32, 0xff80 ); /* Must be < 64K */
2044 if (!(str = HeapAlloc( GetProcessHeap(), 0, *pwparam16 + sizeof(LPARAM)))) return -1;
2045 *((LPARAM *)str)++ = *plparam; /* Store the previous lParam */
2046 *plparam = MapLS( str );
2047 }
2048 return 1;
2049 case WM_MDICREATE:
2050 {
2051 MDICREATESTRUCT16 *cs;
2052 MDICREATESTRUCTA *cs32 = (MDICREATESTRUCTA *)*plparam;
2053
2054 if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(MDICREATESTRUCT16) ))) return -1;
2055 STRUCT32_MDICREATESTRUCT32Ato16( cs32, cs );
2056 cs->szTitle = MapLS( cs32->szTitle );
2057 cs->szClass = MapLS( cs32->szClass );
2058 *plparam = MapLS( cs );
2059 }
2060 return 1;
2061 case WM_MDIGETACTIVE:
2062 return 1;
2063 case WM_MDISETMENU:
2064 *plparam = MAKELPARAM( (HMENU16)LOWORD(wParam32),
2065 (HMENU16)LOWORD(*plparam) );
2066 *pwparam16 = (*plparam == 0);
2067 return 0;
2068 case WM_MENUSELECT:
2069 if(HIWORD(wParam32) & MF_POPUP)
2070 {
2071 HMENU hmenu;
2072 if (((UINT)HIWORD(wParam32) != 0xFFFF) || (*plparam))
2073 {
2074 if((hmenu = GetSubMenu((HMENU)*plparam, *pwparam16)))
2075 *pwparam16=HMENU_16(hmenu);
2076 }
2077 }
2078 /* fall through */
2079 case WM_MENUCHAR:
2080 *plparam = MAKELPARAM( HIWORD(wParam32), (HMENU16)*plparam );
2081 return 0;
2082 case WM_MDIACTIVATE:
2083 if (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_MDICHILD)
2084 {
2085 *pwparam16 = ((HWND)*plparam == hwnd);
2086 *plparam = MAKELPARAM( (HWND16)LOWORD(*plparam),
2087 (HWND16)LOWORD(wParam32) );
2088 }
2089 else
2090 {
2091 *pwparam16 = HWND_16( (HWND)wParam32 );
2092 *plparam = 0;
2093 }
2094 return 0;
2095 case WM_NCCALCSIZE:
2096 {
2097 NCCALCSIZE_PARAMS *nc32 = (NCCALCSIZE_PARAMS *)*plparam;
2098 NCCALCSIZE_PARAMS16 *nc = HeapAlloc( GetProcessHeap(), 0, sizeof(*nc) + sizeof(LPARAM));
2099 if (!nc) return -1;
2100
2101 CONV_RECT32TO16( &nc32->rgrc[0], &nc->rgrc[0] );
2102 if (wParam32)
2103 {
2104 WINDOWPOS16 *wp;
2105 CONV_RECT32TO16( &nc32->rgrc[1], &nc->rgrc[1] );
2106 CONV_RECT32TO16( &nc32->rgrc[2], &nc->rgrc[2] );
2107 if (!(wp = HeapAlloc( GetProcessHeap(), 0, sizeof(WINDOWPOS16) )))
2108 {
2109 HeapFree( GetProcessHeap(), 0, nc );
2110 return -1;
2111 }
2112 STRUCT32_WINDOWPOS32to16( nc32->lppos, wp );
2113 nc->lppos = MapLS( wp );
2114 }
2115 *(LPARAM *)(nc + 1) = *plparam; /* Store the previous lParam */
2116 *plparam = MapLS( nc );
2117 }
2118 return 1;
2119 case WM_NCCREATE:
2120 case WM_CREATE:
2121 {
2122 CREATESTRUCT16 *cs;
2123 CREATESTRUCTA *cs32 = (CREATESTRUCTA *)*plparam;
2124
2125 if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(CREATESTRUCT16) ))) return -1;
2126 STRUCT32_CREATESTRUCT32Ato16( cs32, cs );
2127 cs->lpszName = MapLS( cs32->lpszName );
2128 cs->lpszClass = MapLS( cs32->lpszClass );
2129 *plparam = MapLS( cs );
2130 }
2131 return 1;
2132 case WM_PARENTNOTIFY:
2133 if ((LOWORD(wParam32)==WM_CREATE) || (LOWORD(wParam32)==WM_DESTROY))
2134 *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32));
2135 /* else nothing to do */
2136 return 0;
2137 case WM_NOTIFY:
2138 *plparam = MapLS( (NMHDR *)*plparam ); /* NMHDR is already 32-bit */
2139 return 1;
2140 case WM_SETTEXT:
2141 case WM_WININICHANGE:
2142 case WM_DEVMODECHANGE:
2143 *plparam = MapLS( (LPSTR)*plparam );
2144 return 1;
2145 case WM_WINDOWPOSCHANGING:
2146 case WM_WINDOWPOSCHANGED:
2147 {
2148 WINDOWPOS16 *wp = HeapAlloc( GetProcessHeap(), 0, sizeof(*wp) + sizeof(LPARAM) );
2149 if (!wp) return -1;
2150 STRUCT32_WINDOWPOS32to16( (WINDOWPOS *)*plparam, wp );
2151 *(LPARAM *)(wp + 1) = *plparam; /* Store the previous lParam */
2152 *plparam = MapLS( wp );
2153 }
2154 return 1;
2155 case WM_GETDLGCODE:
2156 if (*plparam) {
2157 LPMSG msg32 = (LPMSG) *plparam;
2158 LPMSG16 msg16 = HeapAlloc( GetProcessHeap(), 0, sizeof(MSG16) );
2159
2160 if (!msg16) return -1;
2161 msg16->hwnd = HWND_16( msg32->hwnd );
2162 msg16->lParam = msg32->lParam;
2163 msg16->time = msg32->time;
2164 CONV_POINT32TO16(&msg32->pt,&msg16->pt);
2165 /* this is right, right? */
2166 if (WINPROC_MapMsg32ATo16(msg32->hwnd,msg32->message,msg32->wParam,
2167 &msg16->message,&msg16->wParam, &msg16->lParam)<0)
2168 {
2169 HeapFree( GetProcessHeap(), 0, msg16 );
2170 return -1;
2171 }
2172 *plparam = MapLS( msg16 );
2173 return 1;
2174 }
2175 return 0;
2176
2177 case WM_ACTIVATEAPP:
2178 if (*plparam) *plparam = HTASK_16( (HANDLE)*plparam );
2179 return 0;
2180 case WM_NEXTMENU:
2181 {
2182 MDINEXTMENU *next = (MDINEXTMENU *)*plparam;
2183 *plparam = (LPARAM)next->hmenuIn;
2184 return 1;
2185 }
2186 case WM_PAINTCLIPBOARD:
2187 case WM_SIZECLIPBOARD:
2188 FIXME_(msg)("message %04x needs translation\n", msg32 );
2189 return -1;
2190 /* following messages should not be sent to 16-bit apps */
2191 case WM_SIZING:
2192 case WM_MOVING:
2193 case WM_CAPTURECHANGED:
2194 case WM_STYLECHANGING:
2195 case WM_STYLECHANGED:
2196 return -1;
2197 case WM_DDE_INITIATE:
2198 case WM_DDE_TERMINATE:
2199 case WM_DDE_UNADVISE:
2200 case WM_DDE_REQUEST:
2201 *pwparam16 = HWND_16((HWND)wParam32);
2202 return 0;
2203 case WM_DDE_ADVISE:
2204 case WM_DDE_DATA:
2205 case WM_DDE_POKE:
2206 {
2207 UINT lo32, hi;
2208 HANDLE16 lo16 = 0;
2209
2210 *pwparam16 = HWND_16((HWND)wParam32);
2211 UnpackDDElParam(msg32, *plparam, &lo32, &hi);
2212 if (lo32 && !(lo16 = convert_handle_32_to_16(lo32, GMEM_DDESHARE)))
2213 return -1;
2214 *plparam = MAKELPARAM(lo16, hi);
2215 }
2216 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
2217 case WM_DDE_ACK:
2218 {
2219 UINT lo, hi;
2220 int flag = 0;
2221 char buf[2];
2222
2223 *pwparam16 = HWND_16((HWND)wParam32);
2224
2225 UnpackDDElParam(msg32, *plparam, &lo, &hi);
2226
2227 if (GlobalGetAtomNameA((ATOM)hi, buf, sizeof(buf)) > 0) flag |= 1;
2228 if (GlobalSize((HANDLE)hi) != 0) flag |= 2;
2229 switch (flag)
2230 {
2231 case 0:
2232 if (hi)
2233 {
2234 MESSAGE("DDE_ACK: neither atom nor handle!!!\n");
2235 hi = 0;
2236 }
2237 break;
2238 case 1:
2239 break; /* atom, nothing to do */
2240 case 3:
2241 MESSAGE("DDE_ACK: %x both atom and handle... choosing handle\n", hi);
2242 /* fall thru */
2243 case 2:
2244 hi = convert_handle_32_to_16(hi, GMEM_DDESHARE);
2245 break;
2246 }
2247 *plparam = MAKELPARAM(lo, hi);
2248 }
2249 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
2250 case WM_DDE_EXECUTE:
2251 *plparam = convert_handle_32_to_16(*plparam, GMEM_DDESHARE);
2252 return 0; /* FIXME don't know how to free allocated memory (handle) !! */
2253 default: /* No translation needed */
2254 return 0;
2255 }
2256 }
2257
2258
2259 /**********************************************************************
2260 * WINPROC_UnmapMsg32ATo16
2261 *
2262 * Unmap a message that was mapped from 32-bit Ansi to 16-bit.
2263 */
2264 void WINPROC_UnmapMsg32ATo16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
2265 MSGPARAM16* p16 )
2266 {
2267 switch(msg)
2268 {
2269 case LB_ADDFILE:
2270 case LB_ADDSTRING:
2271 case LB_DIR:
2272 case LB_FINDSTRING:
2273 case LB_FINDSTRINGEXACT:
2274 case LB_INSERTSTRING:
2275 case LB_SELECTSTRING:
2276 case LB_GETTEXT:
2277 case CB_ADDSTRING:
2278 case CB_FINDSTRING:
2279 case CB_FINDSTRINGEXACT:
2280 case CB_INSERTSTRING:
2281 case CB_SELECTSTRING:
2282 case CB_DIR:
2283 case CB_GETLBTEXT:
2284 case WM_SETTEXT:
2285 case WM_WININICHANGE:
2286 case WM_DEVMODECHANGE:
2287 UnMapLS( (SEGPTR)p16->lParam );
2288 break;
2289 case LB_SETTABSTOPS:
2290 case WM_COMPAREITEM:
2291 case WM_DELETEITEM:
2292 case WM_DRAWITEM:
2293 {
2294 void *ptr = MapSL( p16->lParam );
2295 UnMapLS( p16->lParam );
2296 HeapFree( GetProcessHeap(), 0, ptr );
2297 }
2298 break;
2299 case CB_GETDROPPEDCONTROLRECT:
2300 case LB_GETITEMRECT:
2301 {
2302 RECT16 *rect = MapSL(p16->lParam);
2303 UnMapLS( p16->lParam );
2304 p16->lParam = *(LPARAM *)(rect + 1);
2305 CONV_RECT16TO32( rect, (RECT *)(p16->lParam));
2306 HeapFree( GetProcessHeap(), 0, rect );
2307 }
2308 break;
2309 case LB_GETSELITEMS:
2310 {
2311 INT i;
2312 LPINT16 items = MapSL(p16->lParam);
2313 UnMapLS( p16->lParam );
2314 p16->lParam = *((LPARAM *)items - 1);
2315 for (i = 0; i < p16->wParam; i++) *((LPINT)(p16->lParam) + i) = items[i];
2316 HeapFree( GetProcessHeap(), 0, (LPARAM *)items - 1 );
2317 }
2318 break;
2319
2320 case CB_GETEDITSEL:
2321 if( wParam )
2322 *((PUINT)(wParam)) = LOWORD(p16->lResult);
2323 if( lParam )
2324 *((PUINT)(lParam)) = HIWORD(p16->lResult); /* FIXME: substract 1? */
2325 break;
2326
2327 case WM_MEASUREITEM:
2328 {
2329 MEASUREITEMSTRUCT16 *mis = MapSL(p16->lParam);
2330 MEASUREITEMSTRUCT *mis32 = *(MEASUREITEMSTRUCT **)(mis + 1);
2331 mis32->itemWidth = mis->itemWidth;
2332 mis32->itemHeight = mis->itemHeight;
2333 UnMapLS( p16->lParam );
2334 HeapFree( GetProcessHeap(), 0, mis );
2335 }
2336 break;
2337 case WM_GETMINMAXINFO:
2338 {
2339 MINMAXINFO16 *mmi = MapSL(p16->lParam);
2340 UnMapLS( p16->lParam );
2341 p16->lParam = *(LPARAM *)(mmi + 1);
2342 STRUCT32_MINMAXINFO16to32( mmi, (MINMAXINFO *)(p16->lParam) );
2343 HeapFree( GetProcessHeap(), 0, mmi );
2344 }
2345 break;
2346 case WM_GETTEXT:
2347 case WM_ASKCBFORMATNAME:
2348 {
2349 LPSTR str = MapSL(p16->lParam);
2350 UnMapLS( p16->lParam );
2351 p16->lParam = *((LPARAM *)str - 1);
2352 lstrcpynA( (LPSTR)(p16->lParam), str, p16->wParam );
2353 HeapFree( GetProcessHeap(), 0, (LPARAM *)str - 1 );
2354 }
2355 break;
2356 case WM_MDICREATE:
2357 {
2358 MDICREATESTRUCT16 *cs = MapSL(p16->lParam);
2359 UnMapLS( cs->szTitle );
2360 UnMapLS( cs->szClass );
2361 UnMapLS( p16->lParam );
2362 HeapFree( GetProcessHeap(), 0, cs );
2363 }
2364 break;
2365 case WM_MDIGETACTIVE:
2366 if (lParam) *(BOOL *)lParam = (BOOL16)HIWORD(p16->lResult);
2367 p16->lResult = (LRESULT)WIN_Handle32( LOWORD(p16->lResult) );
2368 break;
2369 case WM_NCCALCSIZE:
2370 {
2371 NCCALCSIZE_PARAMS *nc32;
2372 NCCALCSIZE_PARAMS16 *nc = MapSL(p16->lParam);
2373 UnMapLS( p16->lParam );
2374 p16->lParam = *(LPARAM *)(nc + 1);
2375 nc32 = (NCCALCSIZE_PARAMS *)(p16->lParam);
2376 CONV_RECT16TO32( &nc->rgrc[0], &nc32->rgrc[0] );
2377 if (p16->wParam)
2378 {
2379 WINDOWPOS16 *pos = MapSL(nc->lppos);
2380 UnMapLS( nc->lppos );
2381 CONV_RECT16TO32( &nc->rgrc[1], &nc32->rgrc[1] );
2382 CONV_RECT16TO32( &nc->rgrc[2], &nc32->rgrc[2] );
2383 STRUCT32_WINDOWPOS16to32( pos, nc32->lppos );
2384 HeapFree( GetProcessHeap(), 0, pos );
2385 }
2386 HeapFree( GetProcessHeap(), 0, nc );
2387 }
2388 break;
2389 case WM_NCCREATE:
2390 case WM_CREATE:
2391 {
2392 CREATESTRUCT16 *cs = MapSL(p16->lParam);
2393 UnMapLS( p16->lParam );
2394 UnMapLS( cs->lpszName );
2395 UnMapLS( cs->lpszClass );
2396 HeapFree( GetProcessHeap(), 0, cs );
2397 }
2398 break;
2399 case WM_WINDOWPOSCHANGING:
2400 case WM_WINDOWPOSCHANGED:
2401 {
2402 WINDOWPOS16 *wp = MapSL(p16->lParam);
2403 UnMapLS( p16->lParam );
2404 p16->lParam = *(LPARAM *)(wp + 1);
2405 STRUCT32_WINDOWPOS16to32( wp, (WINDOWPOS *)p16->lParam );
2406 HeapFree( GetProcessHeap(), 0, wp );
2407 }
2408 break;
2409 case WM_NOTIFY:
2410 UnMapLS(p16->lParam);
2411 break;
2412 case WM_GETDLGCODE:
2413 if (p16->lParam)
2414 {
2415 LPMSG16 msg16 = MapSL(p16->lParam);
2416 MSGPARAM16 msgp16;
2417 UnMapLS( p16->lParam );
2418 msgp16.wParam=msg16->wParam;
2419 msgp16.lParam=msg16->lParam;
2420 WINPROC_UnmapMsg32ATo16(((LPMSG)lParam)->hwnd, ((LPMSG)lParam)->message,
2421 ((LPMSG)lParam)->wParam, ((LPMSG)lParam)->lParam,
2422 &msgp16 );
2423 HeapFree( GetProcessHeap(), 0, msg16 );
2424 }
2425 break;
2426 case WM_NEXTMENU:
2427 {
2428 MDINEXTMENU *next = (MDINEXTMENU *)lParam;
2429 next->hmenuNext = HMENU_32( LOWORD(p16->lResult) );
2430 next->hwndNext = WIN_Handle32( HIWORD(p16->lResult) );
2431 p16->lResult = 0;
2432 }
2433 break;
2434 }
2435 }
2436
2437
2438 /**********************************************************************
2439 * WINPROC_MapMsg32WTo16
2440 *
2441 * Map a message from 32-bit Unicode to 16-bit.
2442 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
2443 */
2444 INT WINPROC_MapMsg32WTo16( HWND hwnd, UINT msg32, WPARAM wParam32,
2445 UINT16 *pmsg16, WPARAM16 *pwparam16,
2446 LPARAM *plparam )
2447 {
2448 BYTE ch;
2449 WCHAR wch;
2450
2451 *pmsg16 = LOWORD(msg32);
2452 *pwparam16 = LOWORD(wParam32);
2453 switch(msg32)
2454 {
2455 case LB_ADDSTRING:
2456 case LB_FINDSTRING:
2457 case LB_FINDSTRINGEXACT:
2458 case LB_INSERTSTRING:
2459 case LB_SELECTSTRING:
2460 case LB_DIR:
2461 case LB_ADDFILE:
2462 *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2463 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING);
2464 return 1;
2465
2466 case CB_ADDSTRING:
2467 case CB_FINDSTRING:
2468 case CB_FINDSTRINGEXACT:
2469 case CB_INSERTSTRING:
2470 case CB_SELECTSTRING:
2471 case CB_DIR:
2472 *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2473 *pmsg16 = (UINT16)msg32 + (CB_ADDSTRING16 - CB_ADDSTRING);
2474 return 1;
2475
2476 case WM_NCCREATE:
2477 case WM_CREATE:
2478 {
2479 CREATESTRUCT16 *cs;
2480 CREATESTRUCTW *cs32 = (CREATESTRUCTW *)*plparam;
2481
2482 if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(CREATESTRUCT16) ))) return -1;
2483 STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCTA *)cs32, cs );
2484 cs->lpszName = map_str_32W_to_16( cs32->lpszName );
2485 cs->lpszClass = map_str_32W_to_16( cs32->lpszClass );
2486 *plparam = MapLS(cs);
2487 }
2488 return 1;
2489 case WM_MDICREATE:
2490 {
2491 MDICREATESTRUCT16 *cs;
2492 MDICREATESTRUCTW *cs32 = (MDICREATESTRUCTW *)*plparam;
2493
2494 if (!(cs = HeapAlloc( GetProcessHeap(), 0, sizeof(MDICREATESTRUCT16) ))) return -1;
2495 STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCTA *)cs32, cs );
2496 cs->szTitle = map_str_32W_to_16( cs32->szTitle );
2497 cs->szClass = map_str_32W_to_16( cs32->szClass );
2498 *plparam = MapLS(cs);
2499 }
2500 return 1;
2501 case WM_SETTEXT:
2502 case WM_WININICHANGE:
2503 case WM_DEVMODECHANGE:
2504 *plparam = map_str_32W_to_16( (LPWSTR)*plparam );
2505 return 1;
2506 case LB_GETTEXT:
2507 case CB_GETLBTEXT:
2508 if ( WINPROC_TestLBForStr( hwnd ))
2509 {
2510 LPSTR str = HeapAlloc( GetProcessHeap(), 0, 256 ); /* FIXME: fixed sized buffer */
2511 if (!str) return -1;
2512 *pmsg16 = (msg32 == LB_GETTEXT)? LB_GETTEXT16 : CB_GETLBTEXT16;
2513 *plparam = (LPARAM)MapLS(str);
2514 }
2515 return 1;
2516
2517 case WM_CHARTOITEM:
2518 wch = LOWORD(wParam32);
2519 WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL);
2520 *pwparam16 = ch;
2521 *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32) );
2522 return 0;
2523 case WM_MENUCHAR:
2524 wch = LOWORD(wParam32);
2525 WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL);
2526 *pwparam16 = ch;
2527 *plparam = MAKELPARAM( HIWORD(wParam32), (HMENU16)*plparam );
2528 return 0;
2529 case WM_CHAR:
2530 case WM_DEADCHAR:
2531 case WM_SYSCHAR:
2532 case WM_SYSDEADCHAR:
2533 wch = wParam32;
2534 WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL);
2535 *pwparam16 = ch;
2536 return 0;
2537
2538 case WM_IME_CHAR:
2539 {
2540 BYTE ch[2];
2541
2542 wch = wParam32;
2543 ch[1] = 0;
2544 WideCharToMultiByte( CP_ACP, 0, &wch, 1, ch, 2, NULL, NULL );
2545 *pwparam16 = (ch[0] << 8) | ch[1];
2546 }
2547 return 0;
2548
2549 default: /* No Unicode translation needed (?) */
2550 return WINPROC_MapMsg32ATo16( hwnd, msg32, wParam32, pmsg16,
2551 pwparam16, plparam );
2552 }
2553 }
2554
2555
2556 /**********************************************************************
2557 * WINPROC_UnmapMsg32WTo16
2558 *
2559 * Unmap a message that was mapped from 32-bit Unicode to 16-bit.
2560 */
2561 void WINPROC_UnmapMsg32WTo16( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
2562 MSGPARAM16* p16 )
2563 {
2564 switch(msg)
2565 {
2566 case LB_ADDSTRING:
2567 case LB_FINDSTRING:
2568 case LB_FINDSTRINGEXACT:
2569 case LB_INSERTSTRING:
2570 case LB_SELECTSTRING:
2571 case LB_DIR:
2572 case LB_ADDFILE:
2573 case CB_ADDSTRING:
2574 case CB_FINDSTRING:
2575 case CB_FINDSTRINGEXACT:
2576 case CB_INSERTSTRING:
2577 case CB_SELECTSTRING:
2578 case CB_DIR:
2579 case WM_SETTEXT:
2580 case WM_WININICHANGE:
2581 case WM_DEVMODECHANGE:
2582 unmap_str_32W_to_16( p16->lParam );
2583 break;
2584 case WM_NCCREATE:
2585 case WM_CREATE:
2586 {
2587 CREATESTRUCT16 *cs = MapSL(p16->lParam);
2588 UnMapLS( p16->lParam );
2589 unmap_str_32W_to_16( cs->lpszName );
2590 unmap_str_32W_to_16( cs->lpszClass );
2591 HeapFree( GetProcessHeap(), 0, cs );
2592 }
2593 break;
2594 case WM_MDICREATE:
2595 {
2596 MDICREATESTRUCT16 *cs = MapSL(p16->lParam);
2597 UnMapLS( p16->lParam );
2598 unmap_str_32W_to_16( cs->szTitle );
2599 unmap_str_32W_to_16( cs->szClass );
2600 HeapFree( GetProcessHeap(), 0, cs );
2601 }
2602 break;
2603 case WM_GETTEXT:
2604 case WM_ASKCBFORMATNAME:
2605 {
2606 LPSTR str = MapSL(p16->lParam);
2607 UnMapLS( p16->lParam );
2608 p16->lParam = *((LPARAM *)str - 1);
2609 MultiByteToWideChar( CP_ACP, 0, str, -1, (LPWSTR)p16->lParam, 0x7fffffff );
2610 HeapFree( GetProcessHeap(), 0, (LPARAM *)str - 1 );
2611 }
2612 break;
2613 case LB_GETTEXT:
2614 case CB_GETLBTEXT:
2615 if ( WINPROC_TestLBForStr( hwnd ))
2616 {
2617 LPSTR str = MapSL(p16->lParam);
2618 UnMapLS( p16->lParam );
2619 MultiByteToWideChar( CP_ACP, 0, str, -1, (LPWSTR)lParam, 0x7fffffff );
2620 HeapFree( GetProcessHeap(), 0, (LPARAM *)str );
2621 }
2622 break;
2623 default:
2624 WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, p16 );
2625 break;
2626 }
2627 }
2628
2629
2630 /**********************************************************************
2631 * WINPROC_CallProc32ATo32W
2632 *
2633 * Call a window procedure, translating args from Ansi to Unicode.
2634 */
2635 static LRESULT WINPROC_CallProc32ATo32W( WNDPROC func, HWND hwnd,
2636 UINT msg, WPARAM wParam,
2637 LPARAM lParam )
2638 {
2639 LRESULT result;
2640 int unmap;
2641
2642 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
2643 func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2644
2645 if( (unmap = WINPROC_MapMsg32ATo32W( hwnd, msg, &wParam, &lParam )) == -1) {
2646 ERR_(msg)("Message translation failed. (msg=%s,wp=%08x,lp=%08lx)\n",
2647 SPY_GetMsgName(msg, hwnd), wParam, lParam );
2648 return 0;
2649 }
2650 result = WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2651 if (unmap) result = WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam, result );
2652 return result;
2653 }
2654
2655
2656 /**********************************************************************
2657 * WINPROC_CallProc32WTo32A
2658 *
2659 * Call a window procedure, translating args from Unicode to Ansi.
2660 */
2661 static LRESULT WINPROC_CallProc32WTo32A( WNDPROC func, HWND hwnd,
2662 UINT msg, WPARAM wParam,
2663 LPARAM lParam )
2664 {
2665 LRESULT result;
2666 int unmap;
2667
2668 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
2669 func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2670
2671 if ((unmap = WINPROC_MapMsg32WTo32A( hwnd, msg, &wParam, &lParam )) == -1) {
2672 ERR_(msg)("Message translation failed. (msg=%s,wp=%08x,lp=%08lx)\n",
2673 SPY_GetMsgName(msg, hwnd), wParam, lParam );
2674 return 0;
2675 }
2676 result = WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2677 if( unmap ) WINPROC_UnmapMsg32WTo32A( hwnd, msg, wParam, lParam );
2678 return result;
2679 }
2680
2681
2682 /**********************************************************************
2683 * __wine_call_wndproc_32A (USER.1010)
2684 */
2685 LRESULT WINAPI __wine_call_wndproc_32A( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
2686 WNDPROC func )
2687 {
2688 LRESULT result;
2689 UINT msg32;
2690 WPARAM wParam32;
2691 HWND hwnd32 = WIN_Handle32( hwnd );
2692
2693 if (WINPROC_MapMsg16To32A( hwnd32, msg, wParam, &msg32, &wParam32, &lParam ) == -1)
2694 return 0;
2695 result = WINPROC_CallWndProc( func, hwnd32, msg32, wParam32, lParam );
2696 return WINPROC_UnmapMsg16To32A( hwnd32, msg32, wParam32, lParam, result );
2697 }
2698
2699
2700 /**********************************************************************
2701 * __wine_call_wndproc_32W (USER.1011)
2702 */
2703 LRESULT WINAPI __wine_call_wndproc_32W( HWND16 hwnd, UINT16 msg, WPARAM16 wParam, LPARAM lParam,
2704 WNDPROC func )
2705 {
2706 LRESULT result;
2707 UINT msg32;
2708 WPARAM wParam32;
2709 HWND hwnd32 = WIN_Handle32( hwnd );
2710
2711 if (WINPROC_MapMsg16To32W( hwnd32, msg, wParam, &msg32, &wParam32, &lParam ) == -1)
2712 return 0;
2713 result = WINPROC_CallWndProc( func, hwnd32, msg32, wParam32, lParam );
2714 return WINPROC_UnmapMsg16To32W( hwnd32, msg32, wParam32, lParam, result );
2715 }
2716
2717
2718 /**********************************************************************
2719 * WINPROC_CallProc32ATo16
2720 *
2721 * Call a 16-bit window procedure, translating the 32-bit args.
2722 */
2723 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND hwnd,
2724 UINT msg, WPARAM wParam,
2725 LPARAM lParam )
2726 {
2727 UINT16 msg16;
2728 MSGPARAM16 mp16;
2729
2730 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
2731 func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2732
2733 mp16.lParam = lParam;
2734 if (WINPROC_MapMsg32ATo16( hwnd, msg, wParam, &msg16, &mp16.wParam, &mp16.lParam ) == -1)
2735 return 0;
2736 mp16.lResult = WINPROC_CallWndProc16( func, HWND_16(hwnd), msg16,
2737 mp16.wParam, mp16.lParam );
2738 WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, &mp16 );
2739 return mp16.lResult;
2740 }
2741
2742
2743 /**********************************************************************
2744 * WINPROC_CallProc32WTo16
2745 *
2746 * Call a 16-bit window procedure, translating the 32-bit args.
2747 */
2748 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND hwnd,
2749 UINT msg, WPARAM wParam,
2750 LPARAM lParam )
2751 {
2752 UINT16 msg16;
2753 MSGPARAM16 mp16;
2754
2755 TRACE_(msg)("func %p (hwnd=%p,msg=%s,wp=%08x,lp=%08lx)\n",
2756 func, hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
2757
2758 mp16.lParam = lParam;
2759 if (WINPROC_MapMsg32WTo16( hwnd, msg, wParam, &msg16, &mp16.wParam,
2760 &mp16.lParam ) == -1)
2761 return 0;
2762 mp16.lResult = WINPROC_CallWndProc16( func, HWND_16(hwnd), msg16,
2763 mp16.wParam, mp16.lParam );
2764 WINPROC_UnmapMsg32WTo16( hwnd, msg, wParam, lParam, &mp16 );
2765 return mp16.lResult;
2766 }
2767
2768
2769 /**********************************************************************
2770 * CallWindowProc (USER.122)
2771 */
2772 LRESULT WINAPI CallWindowProc16( WNDPROC16 func, HWND16 hwnd, UINT16 msg,
2773 WPARAM16 wParam, LPARAM lParam )
2774 {
2775 WINDOWPROC *proc;
2776
2777 if (!func) return 0;
2778
2779 if (!(proc = WINPROC_GetPtr( (WNDPROC)func )))
2780 return WINPROC_CallWndProc16( func, hwnd, msg, wParam, lParam );
2781
2782 #if testing
2783 func = WINPROC_GetProc( (WNDPROC)proc, WIN_PROC_16 );
2784 return WINPROC_CallWndProc16( func, hwnd, msg, wParam, lParam );
2785 #endif
2786
2787 switch(proc->type)
2788 {
2789 case WIN_PROC_16:
2790 if (!proc->thunk.t_from32.proc) return 0;
2791 return WINPROC_CallWndProc16( proc->thunk.t_from32.proc,
2792 hwnd, msg, wParam, lParam );
2793 case WIN_PROC_32A:
2794 if (!proc->thunk.t_from16.proc) return 0;
2795 return __wine_call_wndproc_32A( hwnd, msg, wParam, lParam, proc->thunk.t_from16.proc );
2796 case WIN_PROC_32W:
2797 if (!proc->thunk.t_from16.proc) return 0;
2798 return __wine_call_wndproc_32W( hwnd, msg, wParam, lParam, proc->thunk.t_from16.proc );
2799 default:
2800 WARN_(relay)("Invalid proc %p\n", proc );
2801 return 0;
2802 }
2803 }
2804
2805
2806 /**********************************************************************
2807 * CallWindowProcA (USER32.@)
2808 *
2809 * The CallWindowProc() function invokes the windows procedure _func_,
2810 * with _hwnd_ as the target window, the message specified by _msg_, and
2811 * the message parameters _wParam_ and _lParam_.
2812 *
2813 * Some kinds of argument conversion may be done, I'm not sure what.
2814 *
2815 * CallWindowProc() may be used for windows subclassing. Use
2816 * SetWindowLong() to set a new windows procedure for windows of the
2817 * subclass, and handle subclassed messages in the new windows
2818 * procedure. The new windows procedure may then use CallWindowProc()
2819 * with _func_ set to the parent class's windows procedure to dispatch
2820 * the message to the superclass.
2821 *
2822 * RETURNS
2823 *
2824 * The return value is message dependent.
2825 *
2826 * CONFORMANCE
2827 *
2828 * ECMA-234, Win32
2829 */
2830 LRESULT WINAPI CallWindowProcA(
2831 WNDPROC func, /* [in] window procedure */
2832 HWND hwnd, /* [in] target window */
2833 UINT msg, /* [in] message */
2834 WPARAM wParam, /* [in] message dependent parameter */
2835 LPARAM lParam /* [in] message dependent parameter */
2836 ) {
2837 WINDOWPROC *proc = WINPROC_GetPtr( func );
2838
2839 if (!proc) return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2840
2841 #if testing
2842 func = WINPROC_GetProc( (WNDPROC)proc, WIN_PROC_32A );
2843 return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2844 #endif
2845
2846 switch(proc->type)
2847 {
2848 case WIN_PROC_16:
2849 if (!proc->thunk.t_from32.proc) return 0;
2850 return WINPROC_CallProc32ATo16( proc->thunk.t_from32.proc,
2851 hwnd, msg, wParam, lParam );
2852 case WIN_PROC_32A:
2853 if (!proc->thunk.t_from16.proc) return 0;
2854 return WINPROC_CallWndProc( proc->thunk.t_from16.proc,
2855 hwnd, msg, wParam, lParam );
2856 case WIN_PROC_32W:
2857 if (!proc->thunk.t_from16.proc) return 0;
2858 return WINPROC_CallProc32ATo32W( proc->thunk.t_from16.proc,
2859 hwnd, msg, wParam, lParam );
2860 default:
2861 WARN_(relay)("Invalid proc %p\n", proc );
2862 return 0;
2863 }
2864 }
2865
2866
2867 /**********************************************************************
2868 * CallWindowProcW (USER32.@)
2869 */
2870 LRESULT WINAPI CallWindowProcW( WNDPROC func, HWND hwnd, UINT msg,
2871 WPARAM wParam, LPARAM lParam )
2872 {
2873 WINDOWPROC *proc = WINPROC_GetPtr( func );
2874
2875 if (!proc) return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2876
2877 #if testing
2878 func = WINPROC_GetProc( (WNDPROC)proc, WIN_PROC_32W );
2879 return WINPROC_CallWndProc( func, hwnd, msg, wParam, lParam );
2880 #endif
2881
2882 switch(proc->type)
2883 {
2884 case WIN_PROC_16:
2885 if (!proc->thunk.t_from32.proc) return 0;
2886 return WINPROC_CallProc32WTo16( proc->thunk.t_from32.proc,
2887 hwnd, msg, wParam, lParam );
2888 case WIN_PROC_32A:
2889 if (!proc->thunk.t_from16.proc) return 0;
2890 return WINPROC_CallProc32WTo32A( proc->thunk.t_from16.proc,
2891 hwnd, msg, wParam, lParam );
2892 case WIN_PROC_32W:
2893 if (!proc->thunk.t_from16.proc) return 0;
2894 return WINPROC_CallWndProc( proc->thunk.t_from16.proc,
2895 hwnd, msg, wParam, lParam );
2896 default:
2897 WARN_(relay)("Invalid proc %p\n", proc );
2898 return 0;
2899 }
2900 }