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