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