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