?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Converted to the new COM declaration 'standard' for better
[wine/wine-kai.git] / windows / winproc.c
blobc00c182b91a97725d9c87c9015441275f0f5be0f
1 /*
2 * Window procedure callbacks
3 *
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1996 Alexandre Julliard
6 */
7
8 #include "windows.h"
9 #include "callback.h"
10 #include "heap.h"
11 #include "selectors.h"
12 #include "struct32.h"
13 #include "win.h"
14 #include "winproc.h"
15 #include "debug.h"
16 #include "spy.h"
17 #include "commctrl.h"
18 #include "task.h"
19 #include "thread.h"
20
21 /* Window procedure 16-to-32-bit thunk,
22 * see BuildSpec16Files() in tools/build.c */
23
24 typedef struct
25 {
26 BYTE popl_eax; /* popl %eax (return address) */
27 BYTE pushl_func; /* pushl $proc */
28 WNDPROC32 proc WINE_PACKED;
29 BYTE pushl_eax; /* pushl %eax */
30 WORD pushw_bp WINE_PACKED; /* pushw %bp */
31 BYTE pushl_thunk; /* pushl $thunkfrom16 */
32 void (*thunk32)() WINE_PACKED;
33 BYTE lcall; /* lcall cs:relay */
34 void (*relay)() WINE_PACKED; /* WINPROC_CallProc16To32A/W() */
35 WORD cs WINE_PACKED;
36 } WINPROC_THUNK_FROM16;
37
38 /* Window procedure 32-to-16-bit thunk,
39 * see BuildSpec32Files() in tools/build.c */
40
41 typedef struct
42 {
43 BYTE popl_eax; /* popl %eax (return address) */
44 BYTE pushl_func; /* pushl $proc */
45 WNDPROC16 proc WINE_PACKED;
46 BYTE pushl_eax; /* pushl %eax */
47 BYTE jmp; /* jmp relay (relative jump)*/
48 void (*relay)() WINE_PACKED; /* WINPROC_CallProc32ATo16() */
49 } WINPROC_THUNK_FROM32;
50
51 /* Simple jmp to call 32-bit procedure directly */
52 typedef struct
53 {
54 BYTE jmp; /* jmp proc (relative jump) */
55 WNDPROC32 proc WINE_PACKED;
56 } WINPROC_JUMP;
57
58 typedef union
59 {
60 WINPROC_THUNK_FROM16 t_from16;
61 WINPROC_THUNK_FROM32 t_from32;
62 } WINPROC_THUNK;
63
64 typedef struct tagWINDOWPROC
65 {
66 WINPROC_THUNK thunk; /* Thunk */
67 WINPROC_JUMP jmp; /* Jump */
68 struct tagWINDOWPROC *next; /* Next window proc */
69 UINT32 magic; /* Magic number */
70 WINDOWPROCTYPE type; /* Function type */
71 WINDOWPROCUSER user; /* Function user */
72 } WINDOWPROC;
73
74 #define WINPROC_MAGIC ('W' | ('P' << 8) | ('R' << 16) | ('C' << 24))
75
76 #define WINPROC_THUNKPROC(pproc) \
77 (((pproc)->type == WIN_PROC_16) ? \
78 (WNDPROC16)((pproc)->thunk.t_from32.proc) : \
79 (WNDPROC16)((pproc)->thunk.t_from16.proc))
80
81 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND32 hwnd,
82 UINT32 msg, WPARAM32 wParam,
83 LPARAM lParam );
84 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND32 hwnd,
85 UINT32 msg, WPARAM32 wParam,
86 LPARAM lParam );
87 static LRESULT WINPROC_CallProc16To32A( HWND16 hwnd, UINT16 msg,
88 WPARAM16 wParam, LPARAM lParam,
89 WNDPROC32 func );
90 static LRESULT WINPROC_CallProc16To32W( HWND16 hwnd, UINT16 msg,
91 WPARAM16 wParam, LPARAM lParam,
92 WNDPROC32 func );
93
94 static HANDLE32 WinProcHeap;
95
96
97 /**********************************************************************
98 * WINPROC_Init
99 */
100 BOOL32 WINPROC_Init(void)
101 {
102 WinProcHeap = HeapCreate( HEAP_WINE_SEGPTR | HEAP_WINE_CODESEG, 0, 0 );
103 if (!WinProcHeap)
104 {
105 WARN(relay, "Unable to create winproc heap\n" );
106 return FALSE;
107 }
108 return TRUE;
109 }
110
111
112 /**********************************************************************
113 * WINPROC_CallWndProc32
114 *
115 * Call a 32-bit WndProc.
116 */
117 static LRESULT WINPROC_CallWndProc32( WNDPROC32 proc, HWND32 hwnd, UINT32 msg,
118 WPARAM32 wParam, LPARAM lParam )
119 {
120 TRACE(relay, "(wndproc=%p,hwnd=%08x,msg=%s,wp=%08x,lp=%08lx)\n",
121 proc, hwnd, SPY_GetMsgName(msg), wParam, lParam );
122 return proc( hwnd, msg, wParam, lParam );
123 }
124
125
126 /**********************************************************************
127 * WINPROC_GetPtr
128 *
129 * Return a pointer to the win proc.
130 */
131 static WINDOWPROC *WINPROC_GetPtr( WNDPROC16 handle )
132 {
133 BYTE *ptr;
134 WINDOWPROC *proc;
135
136 /* Check for a linear pointer */
137
138 if (HEAP_IsInsideHeap( WinProcHeap, 0, (LPVOID)handle ))
139 {
140 ptr = (BYTE *)handle;
141 /* First check if it is the jmp address */
142 if (*ptr == 0xe9 /* jmp */) ptr -= (int)&((WINDOWPROC *)0)->jmp -
143 (int)&((WINDOWPROC *)0)->thunk;
144 /* Now it must be the thunk address */
145 if (*ptr == 0x58 /* popl eax */) ptr -= (int)&((WINDOWPROC *)0)->thunk;
146 /* Now we have a pointer to the WINDOWPROC struct */
147 if (((WINDOWPROC *)ptr)->magic == WINPROC_MAGIC)
148 return (WINDOWPROC *)ptr;
149 }
150
151 /* Check for a segmented pointer */
152
153 if (!IsBadReadPtr16((SEGPTR)handle,sizeof(WINDOWPROC)-sizeof(proc->thunk)))
154 {
155 ptr = (BYTE *)PTR_SEG_TO_LIN(handle);
156 if (!HEAP_IsInsideHeap( WinProcHeap, 0, ptr )) return NULL;
157 /* It must be the thunk address */
158 if (*ptr == 0x58 /* popl eax */) ptr -= (int)&((WINDOWPROC *)0)->thunk;
159 /* Now we have a pointer to the WINDOWPROC struct */
160 if (((WINDOWPROC *)ptr)->magic == WINPROC_MAGIC)
161 return (WINDOWPROC *)ptr;
162 }
163
164 return NULL;
165 }
166
167
168 /**********************************************************************
169 * WINPROC_AllocWinProc
170 *
171 * Allocate a new window procedure.
172 */
173 static WINDOWPROC *WINPROC_AllocWinProc( WNDPROC16 func, WINDOWPROCTYPE type,
174 WINDOWPROCUSER user )
175 {
176 WINDOWPROC *proc, *oldproc;
177
178 /* Allocate a window procedure */
179
180 if (!(proc = HeapAlloc( WinProcHeap, 0, sizeof(WINDOWPROC) ))) return 0;
181
182 /* Check if the function is already a win proc */
183
184 if ((oldproc = WINPROC_GetPtr( func )))
185 {
186 *proc = *oldproc;
187 }
188 else
189 {
190 switch(type)
191 {
192 case WIN_PROC_16:
193 proc->thunk.t_from32.popl_eax = 0x58; /* popl %eax */
194 proc->thunk.t_from32.pushl_func = 0x68; /* pushl $proc */
195 proc->thunk.t_from32.proc = func;
196 proc->thunk.t_from32.pushl_eax = 0x50; /* pushl %eax */
197 proc->thunk.t_from32.jmp = 0xe9; /* jmp relay*/
198 proc->thunk.t_from32.relay = /* relative jump */
199 (void(*)())((DWORD)WINPROC_CallProc32ATo16 -
200 (DWORD)(&proc->thunk.t_from32.relay + 1));
201 break;
202 case WIN_PROC_32A:
203 case WIN_PROC_32W:
204 proc->thunk.t_from16.popl_eax = 0x58; /* popl %eax */
205 proc->thunk.t_from16.pushl_func = 0x68; /* pushl $proc */
206 proc->thunk.t_from16.proc = (FARPROC32)func;
207 proc->thunk.t_from16.pushl_eax = 0x50; /* pushl %eax */
208 proc->thunk.t_from16.pushw_bp = 0x5566; /* pushw %bp */
209 proc->thunk.t_from16.pushl_thunk = 0x68; /* pushl $thunkfrom16 */
210 proc->thunk.t_from16.thunk32 = (type == WIN_PROC_32A) ?
211 (void(*)())WINPROC_CallProc16To32A :
212 (void(*)())WINPROC_CallProc16To32W;
213 proc->thunk.t_from16.lcall = 0x9a; /* lcall cs:relay */
214 proc->thunk.t_from16.relay = (void*)Callbacks->CallFrom16WndProc;
215 GET_CS(proc->thunk.t_from16.cs);
216 proc->jmp.jmp = 0xe9;
217 /* Fixup relative jump */
218 proc->jmp.proc = (WNDPROC32)((DWORD)func -
219 (DWORD)(&proc->jmp.proc + 1));
220 break;
221 default:
222 /* Should not happen */
223 break;
224 }
225 proc->magic = WINPROC_MAGIC;
226 proc->type = type;
227 proc->user = user;
228 }
229 proc->next = NULL;
230 TRACE(win, "(%08x,%d): returning %08x\n",
231 (UINT32)func, type, (UINT32)proc );
232 return proc;
233 }
234
235
236 /**********************************************************************
237 * WINPROC_GetProc
238 *
239 * Get a window procedure pointer that can be passed to the Windows program.
240 */
241 WNDPROC16 WINPROC_GetProc( HWINDOWPROC proc, WINDOWPROCTYPE type )
242 {
243 if (!proc) return NULL;
244 if (type == WIN_PROC_16) /* We want a 16:16 address */
245 {
246 if (((WINDOWPROC *)proc)->type == WIN_PROC_16)
247 return ((WINDOWPROC *)proc)->thunk.t_from32.proc;
248 else
249 return (WNDPROC16)HEAP_GetSegptr( WinProcHeap, 0,
250 &((WINDOWPROC *)proc)->thunk );
251 }
252 else /* We want a 32-bit address */
253 {
254 if (((WINDOWPROC *)proc)->type == WIN_PROC_16)
255 return (WNDPROC16)&((WINDOWPROC *)proc)->thunk;
256 else if (type != ((WINDOWPROC *)proc)->type)
257 /* Have to return the jmp address if types don't match */
258 return (WNDPROC16)&((WINDOWPROC *)proc)->jmp;
259 else
260 /* Some Win16 programs want to get back the proc they set */
261 return (WNDPROC16)((WINDOWPROC *)proc)->thunk.t_from16.proc;
262 }
263 }
264
265
266 /**********************************************************************
267 * WINPROC_SetProc
268 *
269 * Set the window procedure for a window or class. There are
270 * three tree classes of winproc callbacks:
271 *
272 * 1) class -> wp - not subclassed
273 * class -> wp -> wp -> wp -> wp - SetClassLong()
274 * / /
275 * 2) window -' / - not subclassed
276 * window -> wp -> wp ' - SetWindowLong()
277 *
278 * 3) timer -> wp - SetTimer()
279 *
280 * Initially, winproc of the window points to the current winproc
281 * thunk of its class. Subclassing prepends a new thunk to the
282 * window winproc chain at the head of the list. Thus, window thunk
283 * list includes class thunks and the latter are preserved when the
284 * window is destroyed.
285 *
286 */
287 BOOL32 WINPROC_SetProc( HWINDOWPROC *pFirst, WNDPROC16 func,
288 WINDOWPROCTYPE type, WINDOWPROCUSER user )
289 {
290 BOOL32 bRecycle = FALSE;
291 WINDOWPROC *proc, **ppPrev;
292
293 /* Check if function is already in the list */
294
295 ppPrev = (WINDOWPROC **)pFirst;
296 proc = WINPROC_GetPtr( func );
297 while (*ppPrev)
298 {
299 if (proc)
300 {
301 if (*ppPrev == proc)
302 {
303 if ((*ppPrev)->user != user)
304 {
305 /* terminal thunk is being restored */
306
307 WINPROC_FreeProc( *pFirst, (*ppPrev)->user );
308 *(WINDOWPROC **)pFirst = *ppPrev;
309 return TRUE;
310 }
311 bRecycle = TRUE;
312 break;
313 }
314 }
315 else
316 {
317 if (((*ppPrev)->type == type) &&
318 (func == WINPROC_THUNKPROC(*ppPrev)))
319 {
320 bRecycle = TRUE;
321 break;
322 }
323 }
324
325 /* WPF_CLASS thunk terminates window thunk list */
326 if ((*ppPrev)->user != user) break;
327 ppPrev = &(*ppPrev)->next;
328 }
329
330 if (bRecycle)
331 {
332 /* Extract this thunk from the list */
333 proc = *ppPrev;
334 *ppPrev = proc->next;
335 }
336 else /* Allocate a new one */
337 {
338 if (proc) /* Was already a win proc */
339 {
340 type = proc->type;
341 func = WINPROC_THUNKPROC(proc);
342 }
343 proc = WINPROC_AllocWinProc( func, type, user );
344 if (!proc) return FALSE;
345 }
346
347 /* Add the win proc at the head of the list */
348
349 TRACE(win, "(%08x,%08x,%d): res=%08x\n",
350 (UINT32)*pFirst, (UINT32)func, type, (UINT32)proc );
351 proc->next = *(WINDOWPROC **)pFirst;
352 *(WINDOWPROC **)pFirst = proc;
353 return TRUE;
354 }
355
356
357 /**********************************************************************
358 * WINPROC_FreeProc
359 *
360 * Free a list of win procs.
361 */
362 void WINPROC_FreeProc( HWINDOWPROC proc, WINDOWPROCUSER user )
363 {
364 while (proc)
365 {
366 WINDOWPROC *next = ((WINDOWPROC *)proc)->next;
367 if (((WINDOWPROC *)proc)->user != user) break;
368 TRACE(win, "freeing %08x\n", (UINT32)proc);
369 HeapFree( WinProcHeap, 0, proc );
370 proc = next;
371 }
372 }
373
374
375 /**********************************************************************
376 * WINPROC_GetProcType
377 *
378 * Return the window procedure type.
379 */
380 WINDOWPROCTYPE WINPROC_GetProcType( HWINDOWPROC proc )
381 {
382 if (!proc ||
383 (((WINDOWPROC *)proc)->magic != WINPROC_MAGIC))
384 return WIN_PROC_INVALID;
385 return ((WINDOWPROC *)proc)->type;
386 }
387 /**********************************************************************
388 * WINPROC_TestCBForStr
389 *
390 * Return TRUE if the lparam is a string
391 */
392 BOOL32 WINPROC_TestCBForStr ( HWND32 hwnd )
393 { WND * wnd = WIN_FindWndPtr(hwnd);
394 return ( !(LOWORD(wnd->dwStyle) & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) ||
395 (LOWORD(wnd->dwStyle) & CBS_HASSTRINGS) );
396 }
397 /**********************************************************************
398 * WINPROC_TestLBForStr
399 *
400 * Return TRUE if the lparam is a string
401 */
402 BOOL32 WINPROC_TestLBForStr ( HWND32 hwnd )
403 { WND * wnd = WIN_FindWndPtr(hwnd);
404 return ( !(LOWORD(wnd->dwStyle) & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) ||
405 (LOWORD(wnd->dwStyle) & LBS_HASSTRINGS) );
406 }
407 /**********************************************************************
408 * WINPROC_MapMsg32ATo32W
409 *
410 * Map a message from Ansi to Unicode.
411 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
412 *
413 * FIXME:
414 * WM_CHAR, WM_CHARTOITEM, WM_DEADCHAR, WM_MENUCHAR, WM_SYSCHAR, WM_SYSDEADCHAR
415 *
416 * FIXME:
417 * WM_GETTEXT/WM_SETTEXT and static control with SS_ICON style:
418 * the first four bytes are the handle of the icon
419 * when the WM_SETTEXT message has been used to set the icon
420 */
421 INT32 WINPROC_MapMsg32ATo32W( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM *plparam )
422 {
423 switch(msg)
424 {
425 case WM_GETTEXT:
426 {
427 LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0,
428 wParam * sizeof(WCHAR) + sizeof(LPARAM) );
429 if (!ptr) return -1;
430 *ptr++ = *plparam; /* Store previous lParam */
431 *plparam = (LPARAM)ptr;
432 }
433 return 1;
434
435 case WM_SETTEXT:
436 case CB_DIR32:
437 case CB_FINDSTRING32:
438 case CB_FINDSTRINGEXACT32:
439 case CB_SELECTSTRING32:
440 case LB_DIR32:
441 case LB_ADDFILE32:
442 case LB_FINDSTRING32:
443 case LB_SELECTSTRING32:
444 case EM_REPLACESEL32:
445 *plparam = (LPARAM)HEAP_strdupAtoW( SystemHeap, 0, (LPCSTR)*plparam );
446 return (*plparam ? 1 : -1);
447
448 case WM_NCCREATE:
449 case WM_CREATE:
450 {
451 CREATESTRUCT32W *cs = (CREATESTRUCT32W *)HeapAlloc( SystemHeap, 0,
452 sizeof(*cs) );
453 if (!cs) return -1;
454 *cs = *(CREATESTRUCT32W *)*plparam;
455 if (HIWORD(cs->lpszName))
456 cs->lpszName = HEAP_strdupAtoW( SystemHeap, 0,
457 (LPCSTR)cs->lpszName );
458 if (HIWORD(cs->lpszClass))
459 cs->lpszClass = HEAP_strdupAtoW( SystemHeap, 0,
460 (LPCSTR)cs->lpszClass );
461 *plparam = (LPARAM)cs;
462 }
463 return 1;
464 case WM_MDICREATE:
465 {
466 MDICREATESTRUCT32W *cs =
467 (MDICREATESTRUCT32W *)HeapAlloc( SystemHeap, 0, sizeof(*cs) );
468 if (!cs) return -1;
469 *cs = *(MDICREATESTRUCT32W *)*plparam;
470 if (HIWORD(cs->szClass))
471 cs->szClass = HEAP_strdupAtoW( SystemHeap, 0,
472 (LPCSTR)cs->szClass );
473 if (HIWORD(cs->szTitle))
474 cs->szTitle = HEAP_strdupAtoW( SystemHeap, 0,
475 (LPCSTR)cs->szTitle );
476 *plparam = (LPARAM)cs;
477 }
478 return 1;
479
480 /* Listbox */
481 case LB_ADDSTRING32:
482 case LB_INSERTSTRING32:
483 if ( WINPROC_TestLBForStr( hwnd ))
484 *plparam = (LPARAM)HEAP_strdupAtoW( SystemHeap, 0, (LPCSTR)*plparam );
485 return (*plparam ? 1 : -1);
486
487 case LB_GETTEXT32: /* fixme: fixed sized buffer */
488 { if ( WINPROC_TestLBForStr( hwnd ))
489 { LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
490 if (!ptr) return -1;
491 *ptr++ = *plparam; /* Store previous lParam */
492 *plparam = (LPARAM)ptr;
493 }
494 }
495 return 1;
496
497 /* Combobox */
498 case CB_ADDSTRING32:
499 case CB_INSERTSTRING32:
500 if ( WINPROC_TestCBForStr( hwnd ))
501 *plparam = (LPARAM)HEAP_strdupAtoW( SystemHeap, 0, (LPCSTR)*plparam );
502 return (*plparam ? 1 : -1);
503
504 case CB_GETLBTEXT32: /* fixme: fixed sized buffer */
505 { if ( WINPROC_TestCBForStr( hwnd ))
506 { LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
507 if (!ptr) return -1;
508 *ptr++ = *plparam; /* Store previous lParam */
509 *plparam = (LPARAM)ptr;
510 }
511 }
512 return 1;
513
514 /* Multiline edit */
515 case EM_GETLINE32:
516 { WORD len = (WORD)*plparam;
517 LPARAM *ptr = (LPARAM *) HEAP_xalloc( SystemHeap, 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(WCHAR) );
518 if (!ptr) return -1;
519 *ptr++ = *plparam; /* Store previous lParam */
520 (WORD)*ptr = len; /* Store the lenght */
521 *plparam = (LPARAM)ptr;
522 }
523 return 1;
524
525 case WM_ASKCBFORMATNAME:
526 case WM_DEVMODECHANGE:
527 case WM_PAINTCLIPBOARD:
528 case WM_SIZECLIPBOARD:
529 case WM_WININICHANGE:
530 case EM_SETPASSWORDCHAR32:
531 FIXME(msg, "message %s (0x%x) needs translation, please report\n", SPY_GetMsgName(msg), msg );
532 return -1;
533 default: /* No translation needed */
534 return 0;
535 }
536 }
537
538
539 /**********************************************************************
540 * WINPROC_UnmapMsg32ATo32W
541 *
542 * Unmap a message that was mapped from Ansi to Unicode.
543 */
544 void WINPROC_UnmapMsg32ATo32W( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam )
545 {
546 switch(msg)
547 {
548 case WM_GETTEXT:
549 {
550 LPARAM *ptr = (LPARAM *)lParam - 1;
551 lstrcpynWtoA( (LPSTR)*ptr, (LPWSTR)lParam, wParam );
552 HeapFree( SystemHeap, 0, ptr );
553 }
554 break;
555
556 case WM_NCCREATE:
557 case WM_CREATE:
558 {
559 CREATESTRUCT32W *cs = (CREATESTRUCT32W *)lParam;
560 if (HIWORD(cs->lpszName))
561 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
562 if (HIWORD(cs->lpszClass))
563 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
564 HeapFree( SystemHeap, 0, cs );
565 }
566 break;
567
568 case WM_MDICREATE:
569 {
570 MDICREATESTRUCT32W *cs = (MDICREATESTRUCT32W *)lParam;
571 if (HIWORD(cs->szTitle))
572 HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
573 if (HIWORD(cs->szClass))
574 HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
575 HeapFree( SystemHeap, 0, cs );
576 }
577 break;
578
579 case WM_SETTEXT:
580 case CB_DIR32:
581 case CB_FINDSTRING32:
582 case CB_FINDSTRINGEXACT32:
583 case CB_SELECTSTRING32:
584 case LB_DIR32:
585 case LB_ADDFILE32:
586 case LB_FINDSTRING32:
587 case LB_SELECTSTRING32:
588 case EM_REPLACESEL32:
589 HeapFree( SystemHeap, 0, (void *)lParam );
590 break;
591
592 /* Listbox */
593 case LB_ADDSTRING32:
594 case LB_INSERTSTRING32:
595 if ( WINPROC_TestLBForStr( hwnd ))
596 HeapFree( SystemHeap, 0, (void *)lParam );
597 break;
598
599 case LB_GETTEXT32:
600 { if ( WINPROC_TestLBForStr( hwnd ))
601 { LPARAM *ptr = (LPARAM *)lParam - 1;
602 lstrcpyWtoA( (LPSTR)*ptr, (LPWSTR)(lParam) );
603 HeapFree( SystemHeap, 0, ptr );
604 }
605 }
606 break;
607
608 /* Combobox */
609 case CB_ADDSTRING32:
610 case CB_INSERTSTRING32:
611 if ( WINPROC_TestCBForStr( hwnd ))
612 HeapFree( SystemHeap, 0, (void *)lParam );
613 break;
614
615 case CB_GETLBTEXT32:
616 { if ( WINPROC_TestCBForStr( hwnd ))
617 { LPARAM *ptr = (LPARAM *)lParam - 1;
618 lstrcpyWtoA( (LPSTR)*ptr, (LPWSTR)(lParam) );
619 HeapFree( SystemHeap, 0, ptr );
620 }
621 }
622 break;
623
624 /* Multiline edit */
625 case EM_GETLINE32:
626 { LPARAM * ptr = (LPARAM *)lParam - 1; /* get the old lParam */
627 WORD len = *(WORD *) lParam;
628 lstrcpynWtoA( (LPSTR)*ptr , (LPWSTR)lParam, len );
629 HeapFree( SystemHeap, 0, ptr );
630 }
631 break;
632 }
633 }
634
635
636 /**********************************************************************
637 * WINPROC_MapMsg32WTo32A
638 *
639 * Map a message from Unicode to Ansi.
640 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
641 */
642 INT32 WINPROC_MapMsg32WTo32A( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM *plparam )
643 { switch(msg)
644 {
645 case WM_GETTEXT:
646 {
647 LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0,
648 wParam + sizeof(LPARAM) );
649 if (!ptr) return -1;
650 *ptr++ = *plparam; /* Store previous lParam */
651 *plparam = (LPARAM)ptr;
652 }
653 return 1;
654
655 case WM_SETTEXT:
656 case CB_DIR32:
657 case CB_FINDSTRING32:
658 case CB_FINDSTRINGEXACT32:
659 case CB_SELECTSTRING32:
660 case LB_DIR32:
661 case LB_ADDFILE32:
662 case LB_FINDSTRING32:
663 case LB_SELECTSTRING32:
664 case EM_REPLACESEL32:
665 *plparam = (LPARAM)HEAP_strdupWtoA( SystemHeap, 0, (LPCWSTR)*plparam );
666 return (*plparam ? 1 : -1);
667
668 case WM_NCCREATE:
669 case WM_CREATE:
670 {
671 CREATESTRUCT32A *cs = (CREATESTRUCT32A *)HeapAlloc( SystemHeap, 0,
672 sizeof(*cs) );
673 if (!cs) return -1;
674 *cs = *(CREATESTRUCT32A *)*plparam;
675 if (HIWORD(cs->lpszName))
676 cs->lpszName = HEAP_strdupWtoA( SystemHeap, 0,
677 (LPCWSTR)cs->lpszName );
678 if (HIWORD(cs->lpszClass))
679 cs->lpszClass = HEAP_strdupWtoA( SystemHeap, 0,
680 (LPCWSTR)cs->lpszClass);
681 *plparam = (LPARAM)cs;
682 }
683 return 1;
684 case WM_MDICREATE:
685 {
686 MDICREATESTRUCT32A *cs =
687 (MDICREATESTRUCT32A *)HeapAlloc( SystemHeap, 0, sizeof(*cs) );
688 if (!cs) return -1;
689 *cs = *(MDICREATESTRUCT32A *)*plparam;
690 if (HIWORD(cs->szTitle))
691 cs->szTitle = HEAP_strdupWtoA( SystemHeap, 0,
692 (LPCWSTR)cs->szTitle );
693 if (HIWORD(cs->szClass))
694 cs->szClass = HEAP_strdupWtoA( SystemHeap, 0,
695 (LPCWSTR)cs->szClass );
696 *plparam = (LPARAM)cs;
697 }
698 return 1;
699
700 /* Listbox */
701 case LB_ADDSTRING32:
702 case LB_INSERTSTRING32:
703 if ( WINPROC_TestLBForStr( hwnd ))
704 *plparam = (LPARAM)HEAP_strdupWtoA( SystemHeap, 0, (LPCWSTR)*plparam );
705 return (*plparam ? 1 : -1);
706
707 case LB_GETTEXT32: /* fixme: fixed sized buffer */
708 { if ( WINPROC_TestLBForStr( hwnd ))
709 { LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0, 256 + sizeof(LPARAM) );
710 if (!ptr) return -1;
711 *ptr++ = *plparam; /* Store previous lParam */
712 *plparam = (LPARAM)ptr;
713 }
714 }
715 return 1;
716
717 /* Combobox */
718 case CB_ADDSTRING32:
719 case CB_INSERTSTRING32:
720 if ( WINPROC_TestCBForStr( hwnd ))
721 *plparam = (LPARAM)HEAP_strdupWtoA( SystemHeap, 0, (LPCWSTR)*plparam );
722 return (*plparam ? 1 : -1);
723
724 case CB_GETLBTEXT32: /* fixme: fixed sized buffer */
725 { if ( WINPROC_TestCBForStr( hwnd ))
726 { LPARAM *ptr = (LPARAM *)HeapAlloc( SystemHeap, 0, 256 + sizeof(LPARAM) );
727 if (!ptr) return -1;
728 *ptr++ = *plparam; /* Store previous lParam */
729 *plparam = (LPARAM)ptr;
730 }
731 }
732 return 1;
733
734 /* Multiline edit */
735 case EM_GETLINE32:
736 { WORD len = (WORD)*plparam;
737 LPARAM *ptr = (LPARAM *) HEAP_xalloc( SystemHeap, 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(CHAR) );
738 if (!ptr) return -1;
739 *ptr++ = *plparam; /* Store previous lParam */
740 (WORD)*ptr = len; /* Store the lenght */
741 *plparam = (LPARAM)ptr;
742 }
743 return 1;
744
745 case WM_ASKCBFORMATNAME:
746 case WM_DEVMODECHANGE:
747 case WM_PAINTCLIPBOARD:
748 case WM_SIZECLIPBOARD:
749 case WM_WININICHANGE:
750 case EM_SETPASSWORDCHAR32:
751 FIXME(msg, "message %s (%04x) needs translation, please report\n",SPY_GetMsgName(msg),msg );
752 return -1;
753 default: /* No translation needed */
754 return 0;
755 }
756 }
757
758
759 /**********************************************************************
760 * WINPROC_UnmapMsg32WTo32A
761 *
762 * Unmap a message that was mapped from Unicode to Ansi.
763 */
764 void WINPROC_UnmapMsg32WTo32A( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam )
765 {
766 switch(msg)
767 {
768 case WM_GETTEXT:
769 {
770 LPARAM *ptr = (LPARAM *)lParam - 1;
771 lstrcpynAtoW( (LPWSTR)*ptr, (LPSTR)lParam, wParam );
772 HeapFree( SystemHeap, 0, ptr );
773 }
774 break;
775
776 case WM_SETTEXT:
777 case CB_DIR32:
778 case CB_FINDSTRING32:
779 case CB_FINDSTRINGEXACT32:
780 case CB_SELECTSTRING32:
781 case LB_DIR32:
782 case LB_ADDFILE32:
783 case LB_FINDSTRING32:
784 case LB_SELECTSTRING32:
785 case EM_REPLACESEL32:
786 HeapFree( SystemHeap, 0, (void *)lParam );
787 break;
788
789 case WM_NCCREATE:
790 case WM_CREATE:
791 {
792 CREATESTRUCT32A *cs = (CREATESTRUCT32A *)lParam;
793 if (HIWORD(cs->lpszName))
794 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
795 if (HIWORD(cs->lpszClass))
796 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
797 HeapFree( SystemHeap, 0, cs );
798 }
799 break;
800
801 case WM_MDICREATE:
802 {
803 MDICREATESTRUCT32A *cs = (MDICREATESTRUCT32A *)lParam;
804 if (HIWORD(cs->szTitle))
805 HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
806 if (HIWORD(cs->szClass))
807 HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
808 HeapFree( SystemHeap, 0, cs );
809 }
810 break;
811
812 /* Listbox */
813 case LB_ADDSTRING32:
814 case LB_INSERTSTRING32:
815 if ( WINPROC_TestLBForStr( hwnd ))
816 HeapFree( SystemHeap, 0, (void *)lParam );
817 break;
818
819 case LB_GETTEXT32:
820 { if ( WINPROC_TestLBForStr( hwnd ))
821 { LPARAM *ptr = (LPARAM *)lParam - 1;
822 lstrcpyAtoW( (LPWSTR)*ptr, (LPSTR)(lParam) );
823 HeapFree( SystemHeap, 0, ptr );
824 }
825 }
826 break;
827
828 /* Combobox */
829 case CB_ADDSTRING32:
830 case CB_INSERTSTRING32:
831 if ( WINPROC_TestCBForStr( hwnd ))
832 HeapFree( SystemHeap, 0, (void *)lParam );
833 break;
834
835 case CB_GETLBTEXT32:
836 { if ( WINPROC_TestCBForStr( hwnd ))
837 { LPARAM *ptr = (LPARAM *)lParam - 1;
838 lstrcpyAtoW( (LPWSTR)*ptr, (LPSTR)(lParam) );
839 HeapFree( SystemHeap, 0, ptr );
840 }
841 }
842 break;
843
844 /* Multiline edit */
845 case EM_GETLINE32:
846 { LPARAM * ptr = (LPARAM *)lParam - 1; /* get the old lparam */
847 WORD len = *(WORD *)ptr;
848 lstrcpynAtoW( (LPWSTR) *ptr, (LPSTR)lParam, len );
849 HeapFree( SystemHeap, 0, ptr );
850 }
851 break;
852 }
853 }
854
855
856 /**********************************************************************
857 * WINPROC_MapMsg16To32A
858 *
859 * Map a message from 16- to 32-bit Ansi.
860 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
861 */
862 INT32 WINPROC_MapMsg16To32A( UINT16 msg16, WPARAM16 wParam16, UINT32 *pmsg32,
863 WPARAM32 *pwparam32, LPARAM *plparam )
864 {
865 *pmsg32 = (UINT32)msg16;
866 *pwparam32 = (WPARAM32)wParam16;
867 switch(msg16)
868 {
869 case WM_ACTIVATE:
870 case WM_CHARTOITEM:
871 case WM_COMMAND:
872 case WM_VKEYTOITEM:
873 *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
874 *plparam = (LPARAM)(HWND32)LOWORD(*plparam);
875 return 0;
876 case WM_HSCROLL:
877 case WM_VSCROLL:
878 *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
879 *plparam = (LPARAM)(HWND32)HIWORD(*plparam);
880 return 0;
881 case WM_CTLCOLOR:
882 if ( HIWORD(*plparam) > CTLCOLOR_STATIC ) return -1;
883 *pmsg32 = WM_CTLCOLORMSGBOX + HIWORD(*plparam);
884 *pwparam32 = (WPARAM32)(HDC32)wParam16;
885 *plparam = (LPARAM)(HWND32)LOWORD(*plparam);
886 return 0;
887 case WM_COMPAREITEM:
888 {
889 COMPAREITEMSTRUCT16* cis16 = (COMPAREITEMSTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
890 COMPAREITEMSTRUCT32 *cis = (COMPAREITEMSTRUCT32 *)
891 HeapAlloc(SystemHeap, 0, sizeof(*cis));
892 if (!cis) return -1;
893 cis->CtlType = cis16->CtlType;
894 cis->CtlID = cis16->CtlID;
895 cis->hwndItem = cis16->hwndItem;
896 cis->itemID1 = cis16->itemID1;
897 cis->itemData1 = cis16->itemData1;
898 cis->itemID2 = cis16->itemID2;
899 cis->itemData2 = cis16->itemData2;
900 cis->dwLocaleId = 0; /* FIXME */
901 *plparam = (LPARAM)cis;
902 }
903 return 1;
904 case WM_DELETEITEM:
905 {
906 DELETEITEMSTRUCT16* dis16 = (DELETEITEMSTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
907 DELETEITEMSTRUCT32 *dis = (DELETEITEMSTRUCT32 *)
908 HeapAlloc(SystemHeap, 0, sizeof(*dis));
909 if (!dis) return -1;
910 dis->CtlType = dis16->CtlType;
911 dis->CtlID = dis16->CtlID;
912 dis->hwndItem = dis16->hwndItem;
913 dis->itemData = dis16->itemData;
914 *plparam = (LPARAM)dis;
915 }
916 return 1;
917 case WM_MEASUREITEM:
918 {
919 MEASUREITEMSTRUCT16* mis16 = (MEASUREITEMSTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
920 MEASUREITEMSTRUCT32 *mis = (MEASUREITEMSTRUCT32 *)
921 HeapAlloc(SystemHeap, 0,
922 sizeof(*mis) + sizeof(LPARAM));
923 if (!mis) return -1;
924 mis->CtlType = mis16->CtlType;
925 mis->CtlID = mis16->CtlID;
926 mis->itemID = mis16->itemID;
927 mis->itemWidth = mis16->itemWidth;
928 mis->itemHeight = mis16->itemHeight;
929 mis->itemData = mis16->itemData;
930 *(LPARAM *)(mis + 1) = *plparam; /* Store the previous lParam */
931 *plparam = (LPARAM)mis;
932 }
933 return 1;
934 case WM_DRAWITEM:
935 {
936 DRAWITEMSTRUCT16* dis16 = (DRAWITEMSTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
937 DRAWITEMSTRUCT32 *dis = (DRAWITEMSTRUCT32*)HeapAlloc(SystemHeap, 0,
938 sizeof(*dis));
939 if (!dis) return -1;
940 dis->CtlType = dis16->CtlType;
941 dis->CtlID = dis16->CtlID;
942 dis->itemID = dis16->itemID;
943 dis->itemAction = dis16->itemAction;
944 dis->itemState = dis16->itemState;
945 dis->hwndItem = dis16->hwndItem;
946 dis->hDC = dis16->hDC;
947 dis->itemData = dis16->itemData;
948 CONV_RECT16TO32( &dis16->rcItem, &dis->rcItem );
949 *plparam = (LPARAM)dis;
950 }
951 return 1;
952 case WM_GETMINMAXINFO:
953 {
954 MINMAXINFO32 *mmi = (MINMAXINFO32 *)HeapAlloc( SystemHeap, 0,
955 sizeof(*mmi) + sizeof(LPARAM));
956 if (!mmi) return -1;
957 STRUCT32_MINMAXINFO16to32( (MINMAXINFO16*)PTR_SEG_TO_LIN(*plparam),
958 mmi );
959 *(LPARAM *)(mmi + 1) = *plparam; /* Store the previous lParam */
960 *plparam = (LPARAM)mmi;
961 }
962 return 1;
963 case WM_GETTEXT:
964 case WM_SETTEXT:
965 *plparam = (LPARAM)PTR_SEG_TO_LIN(*plparam);
966 return 0;
967 case WM_MDICREATE:
968 {
969 MDICREATESTRUCT16 *cs16 =
970 (MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
971 MDICREATESTRUCT32A *cs =
972 (MDICREATESTRUCT32A *)HeapAlloc( SystemHeap, 0,
973 sizeof(*cs) + sizeof(LPARAM) );
974 if (!cs) return -1;
975 STRUCT32_MDICREATESTRUCT16to32A( cs16, cs );
976 cs->szTitle = (LPCSTR)PTR_SEG_TO_LIN(cs16->szTitle);
977 cs->szClass = (LPCSTR)PTR_SEG_TO_LIN(cs16->szClass);
978 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
979 *plparam = (LPARAM)cs;
980 }
981 return 1;
982 case WM_MDIGETACTIVE:
983 *plparam = (LPARAM)HeapAlloc( SystemHeap, 0, sizeof(BOOL32) );
984 return 1;
985 case WM_MDISETMENU:
986 if(wParam16==TRUE)
987 *pmsg32=WM_MDIREFRESHMENU;
988 *pwparam32 = (WPARAM32)(HMENU32)LOWORD(*plparam);
989 *plparam = (LPARAM)(HMENU32)HIWORD(*plparam);
990 return 0;
991 case WM_MENUCHAR:
992 case WM_MENUSELECT:
993 *pwparam32 = MAKEWPARAM( wParam16, LOWORD(*plparam) );
994 *plparam = (LPARAM)(HMENU32)HIWORD(*plparam);
995 return 0;
996 case WM_MDIACTIVATE:
997 if( *plparam )
998 {
999 *pwparam32 = (WPARAM32)(HWND32)HIWORD(*plparam);
1000 *plparam = (LPARAM)(HWND32)LOWORD(*plparam);
1001 }
1002 else /* message sent to MDI client */
1003 *pwparam32 = wParam16;
1004 return 0;
1005 case WM_NCCALCSIZE:
1006 {
1007 NCCALCSIZE_PARAMS16 *nc16;
1008 NCCALCSIZE_PARAMS32 *nc;
1009
1010 nc = (NCCALCSIZE_PARAMS32 *)HeapAlloc( SystemHeap, 0,
1011 sizeof(*nc) + sizeof(LPARAM) );
1012 if (!nc) return -1;
1013 nc16 = (NCCALCSIZE_PARAMS16 *)PTR_SEG_TO_LIN(*plparam);
1014 CONV_RECT16TO32( &nc16->rgrc[0], &nc->rgrc[0] );
1015 if (wParam16)
1016 {
1017 nc->lppos = (WINDOWPOS32 *)HeapAlloc( SystemHeap, 0,
1018 sizeof(*nc->lppos) );
1019 CONV_RECT16TO32( &nc16->rgrc[1], &nc->rgrc[1] );
1020 CONV_RECT16TO32( &nc16->rgrc[2], &nc->rgrc[2] );
1021 if (nc->lppos) STRUCT32_WINDOWPOS16to32( (WINDOWPOS16 *)PTR_SEG_TO_LIN(nc16->lppos), nc->lppos );
1022 }
1023 *(LPARAM *)(nc + 1) = *plparam; /* Store the previous lParam */
1024 *plparam = (LPARAM)nc;
1025 }
1026 return 1;
1027 case WM_NCCREATE:
1028 case WM_CREATE:
1029 {
1030 CREATESTRUCT16 *cs16 = (CREATESTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
1031 CREATESTRUCT32A *cs = (CREATESTRUCT32A *)HeapAlloc( SystemHeap, 0,
1032 sizeof(*cs) + sizeof(LPARAM) );
1033 if (!cs) return -1;
1034 STRUCT32_CREATESTRUCT16to32A( cs16, cs );
1035 cs->lpszName = (LPCSTR)PTR_SEG_TO_LIN(cs16->lpszName);
1036 cs->lpszClass = (LPCSTR)PTR_SEG_TO_LIN(cs16->lpszClass);
1037 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1038 *plparam = (LPARAM)cs;
1039 }
1040 return 1;
1041 case WM_PARENTNOTIFY:
1042 if ((wParam16 == WM_CREATE) || (wParam16 == WM_DESTROY))
1043 {
1044 *pwparam32 = MAKEWPARAM( wParam16, HIWORD(*plparam) );
1045 *plparam = (LPARAM)(HWND32)LOWORD(*plparam);
1046 }
1047 return 0;
1048 case WM_WINDOWPOSCHANGING:
1049 case WM_WINDOWPOSCHANGED:
1050 {
1051 WINDOWPOS32 *wp = (WINDOWPOS32 *)HeapAlloc( SystemHeap, 0,
1052 sizeof(*wp) + sizeof(LPARAM) );
1053 if (!wp) return -1;
1054 STRUCT32_WINDOWPOS16to32( (WINDOWPOS16 *)PTR_SEG_TO_LIN(*plparam),
1055 wp );
1056 *(LPARAM *)(wp + 1) = *plparam; /* Store the previous lParam */
1057 *plparam = (LPARAM)wp;
1058 }
1059 return 1;
1060 case WM_GETDLGCODE:
1061 if (*plparam)
1062 {
1063 LPMSG16 msg16 = (LPMSG16)PTR_SEG_TO_LIN(*plparam);
1064 LPMSG32 msg32 = (LPMSG32)HeapAlloc( SystemHeap, 0, sizeof(MSG32) );
1065
1066 if (!msg32) return -1;
1067 msg32->hwnd = msg16->hwnd;
1068 msg32->lParam = msg16->lParam;
1069 msg32->time = msg16->time;
1070 CONV_POINT16TO32(&msg16->pt,&msg32->pt);
1071 /* this is right, right? */
1072 if (WINPROC_MapMsg16To32A(msg16->message,msg16->wParam,
1073 &msg32->message,&msg32->wParam,
1074 &msg32->lParam)<0) {
1075 HeapFree( SystemHeap, 0, msg32 );
1076 return -1;
1077 }
1078 *plparam = (LPARAM)msg32;
1079 return 1;
1080 }
1081 else return 0;
1082 case WM_NOTIFY:
1083 *plparam = (LPARAM)PTR_SEG_TO_LIN(*plparam);
1084 return 1;
1085 case WM_ACTIVATEAPP:
1086 if (*plparam)
1087 { /* We need this when SetActiveWindow sends a Sendmessage16() to
1088 a 32bit window. Might be superflous with 32bit interprocess
1089 message queues.
1090 */
1091 HTASK16 htask = (HTASK16) *plparam;
1092 DWORD idThread = THDB_TO_THREAD_ID(((TDB*)GlobalLock16(htask))->thdb);
1093 *plparam = (LPARAM) idThread;
1094 }
1095 return 1;
1096 case WM_ASKCBFORMATNAME:
1097 case WM_DEVMODECHANGE:
1098 case WM_PAINTCLIPBOARD:
1099 case WM_SIZECLIPBOARD:
1100 case WM_WININICHANGE:
1101 FIXME( msg, "message %04x needs translation\n",msg16 );
1102 return -1;
1103
1104 default: /* No translation needed */
1105 return 0;
1106 }
1107 }
1108
1109
1110 /**********************************************************************
1111 * WINPROC_UnmapMsg16To32A
1112 *
1113 * Unmap a message that was mapped from 16- to 32-bit Ansi.
1114 */
1115 LRESULT WINPROC_UnmapMsg16To32A( HWND16 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam,
1116 LRESULT result )
1117 {
1118 switch(msg)
1119 {
1120 case WM_COMPAREITEM:
1121 case WM_DELETEITEM:
1122 case WM_DRAWITEM:
1123 HeapFree( SystemHeap, 0, (LPVOID)lParam );
1124 break;
1125 case WM_MEASUREITEM:
1126 {
1127 MEASUREITEMSTRUCT16 *mis16;
1128 MEASUREITEMSTRUCT32 *mis = (MEASUREITEMSTRUCT32 *)lParam;
1129 lParam = *(LPARAM *)(mis + 1);
1130 mis16 = (MEASUREITEMSTRUCT16 *)PTR_SEG_TO_LIN(lParam);
1131 mis16->itemWidth = (UINT16)mis->itemWidth;
1132 mis16->itemHeight = (UINT16)mis->itemHeight;
1133 HeapFree( SystemHeap, 0, mis );
1134 }
1135 break;
1136 case WM_GETMINMAXINFO:
1137 {
1138 MINMAXINFO32 *mmi = (MINMAXINFO32 *)lParam;
1139 lParam = *(LPARAM *)(mmi + 1);
1140 STRUCT32_MINMAXINFO32to16( mmi,
1141 (MINMAXINFO16 *)PTR_SEG_TO_LIN(lParam));
1142 HeapFree( SystemHeap, 0, mmi );
1143 }
1144 break;
1145 case WM_MDICREATE:
1146 {
1147 MDICREATESTRUCT32A *cs = (MDICREATESTRUCT32A *)lParam;
1148 lParam = *(LPARAM *)(cs + 1);
1149 STRUCT32_MDICREATESTRUCT32Ato16( cs,
1150 (MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
1151 HeapFree( SystemHeap, 0, cs );
1152 }
1153 break;
1154 case WM_MDIGETACTIVE:
1155 result = MAKELONG( LOWORD(result), (BOOL16)(*(BOOL32 *)lParam) );
1156 HeapFree( SystemHeap, 0, (BOOL32 *)lParam );
1157 break;
1158 case WM_NCCALCSIZE:
1159 {
1160 NCCALCSIZE_PARAMS16 *nc16;
1161 NCCALCSIZE_PARAMS32 *nc = (NCCALCSIZE_PARAMS32 *)lParam;
1162 lParam = *(LPARAM *)(nc + 1);
1163 nc16 = (NCCALCSIZE_PARAMS16 *)PTR_SEG_TO_LIN(lParam);
1164 CONV_RECT32TO16( &nc->rgrc[0], &nc16->rgrc[0] );
1165 if (wParam)
1166 {
1167 CONV_RECT32TO16( &nc->rgrc[1], &nc16->rgrc[1] );
1168 CONV_RECT32TO16( &nc->rgrc[2], &nc16->rgrc[2] );
1169 if (nc->lppos)
1170 {
1171 STRUCT32_WINDOWPOS32to16( nc->lppos,
1172 (WINDOWPOS16 *)PTR_SEG_TO_LIN(nc16->lppos));
1173 HeapFree( SystemHeap, 0, nc->lppos );
1174 }
1175 }
1176 HeapFree( SystemHeap, 0, nc );
1177 }
1178 break;
1179 case WM_NCCREATE:
1180 case WM_CREATE:
1181 {
1182 CREATESTRUCT32A *cs = (CREATESTRUCT32A *)lParam;
1183 lParam = *(LPARAM *)(cs + 1);
1184 STRUCT32_CREATESTRUCT32Ato16( cs,
1185 (CREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
1186 HeapFree( SystemHeap, 0, cs );
1187 }
1188 break;
1189 case WM_WINDOWPOSCHANGING:
1190 case WM_WINDOWPOSCHANGED:
1191 {
1192 WINDOWPOS32 *wp = (WINDOWPOS32 *)lParam;
1193 lParam = *(LPARAM *)(wp + 1);
1194 STRUCT32_WINDOWPOS32to16(wp,(WINDOWPOS16 *)PTR_SEG_TO_LIN(lParam));
1195 HeapFree( SystemHeap, 0, wp );
1196 }
1197 break;
1198 case WM_GETDLGCODE:
1199 if (lParam)
1200 {
1201 LPMSG32 msg32 = (LPMSG32)lParam;
1202
1203 WINPROC_UnmapMsg16To32A( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1204 result);
1205 HeapFree( SystemHeap, 0, msg32 );
1206 }
1207 break;
1208 }
1209 return result;
1210 }
1211
1212
1213 /**********************************************************************
1214 * WINPROC_MapMsg16To32W
1215 *
1216 * Map a message from 16- to 32-bit Unicode.
1217 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1218 */
1219 INT32 WINPROC_MapMsg16To32W( HWND16 hwnd, UINT16 msg16, WPARAM16 wParam16, UINT32 *pmsg32,
1220 WPARAM32 *pwparam32, LPARAM *plparam )
1221 {
1222 switch(msg16)
1223 {
1224 case WM_GETTEXT:
1225 case WM_SETTEXT:
1226 *plparam = (LPARAM)PTR_SEG_TO_LIN(*plparam);
1227 return WINPROC_MapMsg32ATo32W( hwnd, *pmsg32, *pwparam32, plparam );
1228 case WM_NCCREATE:
1229 case WM_CREATE:
1230 {
1231 CREATESTRUCT16 *cs16 = (CREATESTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
1232 CREATESTRUCT32W *cs = (CREATESTRUCT32W *)HeapAlloc( SystemHeap, 0,
1233 sizeof(*cs) + sizeof(LPARAM) );
1234 if (!cs) return -1;
1235 STRUCT32_CREATESTRUCT16to32A( cs16, (CREATESTRUCT32A *)cs );
1236 cs->lpszName = (LPCWSTR)PTR_SEG_TO_LIN(cs16->lpszName);
1237 cs->lpszClass = (LPCWSTR)PTR_SEG_TO_LIN(cs16->lpszClass);
1238 if (HIWORD(cs->lpszName))
1239 cs->lpszName = HEAP_strdupAtoW( SystemHeap, 0,
1240 (LPCSTR)cs->lpszName );
1241 if (HIWORD(cs->lpszClass))
1242 cs->lpszClass = HEAP_strdupAtoW( SystemHeap, 0,
1243 (LPCSTR)cs->lpszClass );
1244 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1245 *plparam = (LPARAM)cs;
1246 }
1247 return 1;
1248 case WM_MDICREATE:
1249 {
1250 MDICREATESTRUCT16 *cs16 =
1251 (MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(*plparam);
1252 MDICREATESTRUCT32W *cs =
1253 (MDICREATESTRUCT32W *)HeapAlloc( SystemHeap, 0,
1254 sizeof(*cs) + sizeof(LPARAM) );
1255 if (!cs) return -1;
1256 STRUCT32_MDICREATESTRUCT16to32A( cs16, (MDICREATESTRUCT32A *)cs );
1257 cs->szTitle = (LPCWSTR)PTR_SEG_TO_LIN(cs16->szTitle);
1258 cs->szClass = (LPCWSTR)PTR_SEG_TO_LIN(cs16->szClass);
1259 if (HIWORD(cs->szTitle))
1260 cs->szTitle = HEAP_strdupAtoW( SystemHeap, 0,
1261 (LPCSTR)cs->szTitle );
1262 if (HIWORD(cs->szClass))
1263 cs->szClass = HEAP_strdupAtoW( SystemHeap, 0,
1264 (LPCSTR)cs->szClass );
1265 *(LPARAM *)(cs + 1) = *plparam; /* Store the previous lParam */
1266 *plparam = (LPARAM)cs;
1267 }
1268 return 1;
1269 case WM_GETDLGCODE:
1270 if (*plparam)
1271 {
1272 LPMSG16 msg16 = (LPMSG16)PTR_SEG_TO_LIN(*plparam);
1273 LPMSG32 msg32 = (LPMSG32)HeapAlloc( SystemHeap, 0, sizeof(MSG32) );
1274
1275 if (!msg32) return -1;
1276 msg32->hwnd = msg16->hwnd;
1277 msg32->lParam = msg16->lParam;
1278 msg32->time = msg16->time;
1279 CONV_POINT16TO32(&msg16->pt,&msg32->pt);
1280 /* this is right, right? */
1281 if (WINPROC_MapMsg16To32W(hwnd, msg16->message,msg16->wParam,
1282 &msg32->message,&msg32->wParam,
1283 &msg32->lParam)<0) {
1284 HeapFree( SystemHeap, 0, msg32 );
1285 return -1;
1286 }
1287 *plparam = (LPARAM)msg32;
1288 return 1;
1289 }
1290 else return 0;
1291 default: /* No Unicode translation needed */
1292 return WINPROC_MapMsg16To32A( msg16, wParam16, pmsg32,
1293 pwparam32, plparam );
1294 }
1295 }
1296
1297
1298 /**********************************************************************
1299 * WINPROC_UnmapMsg16To32W
1300 *
1301 * Unmap a message that was mapped from 16- to 32-bit Unicode.
1302 */
1303 LRESULT WINPROC_UnmapMsg16To32W( HWND16 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam,
1304 LRESULT result )
1305 {
1306 switch(msg)
1307 {
1308 case WM_GETTEXT:
1309 case WM_SETTEXT:
1310 WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam );
1311 break;
1312 case WM_NCCREATE:
1313 case WM_CREATE:
1314 {
1315 CREATESTRUCT32W *cs = (CREATESTRUCT32W *)lParam;
1316 lParam = *(LPARAM *)(cs + 1);
1317 STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCT32A *)cs,
1318 (CREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
1319 if (HIWORD(cs->lpszName))
1320 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszName );
1321 if (HIWORD(cs->lpszClass))
1322 HeapFree( SystemHeap, 0, (LPVOID)cs->lpszClass );
1323 HeapFree( SystemHeap, 0, cs );
1324 }
1325 break;
1326 case WM_MDICREATE:
1327 {
1328 MDICREATESTRUCT32W *cs = (MDICREATESTRUCT32W *)lParam;
1329 lParam = *(LPARAM *)(cs + 1);
1330 STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCT32A *)cs,
1331 (MDICREATESTRUCT16 *)PTR_SEG_TO_LIN(lParam) );
1332 if (HIWORD(cs->szTitle))
1333 HeapFree( SystemHeap, 0, (LPVOID)cs->szTitle );
1334 if (HIWORD(cs->szClass))
1335 HeapFree( SystemHeap, 0, (LPVOID)cs->szClass );
1336 HeapFree( SystemHeap, 0, cs );
1337 }
1338 break;
1339 case WM_GETDLGCODE:
1340 if (lParam)
1341 {
1342 LPMSG32 msg32 = (LPMSG32)lParam;
1343
1344 WINPROC_UnmapMsg16To32W( hwnd, msg32->message, msg32->wParam, msg32->lParam,
1345 result);
1346 HeapFree( SystemHeap, 0, msg32 );
1347 }
1348 break;
1349 default:
1350 return WINPROC_UnmapMsg16To32A( hwnd, msg, wParam, lParam, result );
1351 }
1352 return result;
1353 }
1354
1355
1356 /**********************************************************************
1357 * WINPROC_MapMsg32ATo16
1358 *
1359 * Map a message from 32-bit Ansi to 16-bit.
1360 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1361 */
1362 INT32 WINPROC_MapMsg32ATo16( HWND32 hwnd, UINT32 msg32, WPARAM32 wParam32,
1363 UINT16 *pmsg16, WPARAM16 *pwparam16,
1364 LPARAM *plparam )
1365 {
1366 *pmsg16 = (UINT16)msg32;
1367 *pwparam16 = (WPARAM16)LOWORD(wParam32);
1368 switch(msg32)
1369 {
1370 case BM_GETCHECK32:
1371 case BM_SETCHECK32:
1372 case BM_GETSTATE32:
1373 case BM_SETSTATE32:
1374 case BM_SETSTYLE32:
1375 *pmsg16 = (UINT16)msg32 + (BM_GETCHECK16 - BM_GETCHECK32);
1376 return 0;
1377
1378 case EM_GETSEL32:
1379 case EM_GETRECT32:
1380 case EM_SETRECT32:
1381 case EM_SETRECTNP32:
1382 case EM_SCROLL32:
1383 case EM_LINESCROLL32:
1384 case EM_SCROLLCARET32:
1385 case EM_GETMODIFY32:
1386 case EM_SETMODIFY32:
1387 case EM_GETLINECOUNT32:
1388 case EM_LINEINDEX32:
1389 case EM_SETHANDLE32:
1390 case EM_GETHANDLE32:
1391 case EM_GETTHUMB32:
1392 case EM_LINELENGTH32:
1393 case EM_REPLACESEL32:
1394 case EM_GETLINE32:
1395 case EM_LIMITTEXT32:
1396 case EM_CANUNDO32:
1397 case EM_UNDO32:
1398 case EM_FMTLINES32:
1399 case EM_LINEFROMCHAR32:
1400 case EM_SETTABSTOPS32:
1401 case EM_SETPASSWORDCHAR32:
1402 case EM_EMPTYUNDOBUFFER32:
1403 case EM_GETFIRSTVISIBLELINE32:
1404 case EM_SETREADONLY32:
1405 case EM_SETWORDBREAKPROC32:
1406 case EM_GETWORDBREAKPROC32:
1407 case EM_GETPASSWORDCHAR32:
1408 *pmsg16 = (UINT16)msg32 + (EM_GETSEL16 - EM_GETSEL32);
1409 return 0;
1410
1411 case LB_CARETOFF32:
1412 case LB_CARETON32:
1413 case LB_DELETESTRING32:
1414 case LB_GETANCHORINDEX32:
1415 case LB_GETCARETINDEX32:
1416 case LB_GETCOUNT32:
1417 case LB_GETCURSEL32:
1418 case LB_GETHORIZONTALEXTENT32:
1419 case LB_GETITEMDATA32:
1420 case LB_GETITEMHEIGHT32:
1421 case LB_GETSEL32:
1422 case LB_GETSELCOUNT32:
1423 case LB_GETTEXTLEN32:
1424 case LB_GETTOPINDEX32:
1425 case LB_RESETCONTENT32:
1426 case LB_SELITEMRANGE32:
1427 case LB_SELITEMRANGEEX32:
1428 case LB_SETANCHORINDEX32:
1429 case LB_SETCARETINDEX32:
1430 case LB_SETCOLUMNWIDTH32:
1431 case LB_SETCURSEL32:
1432 case LB_SETHORIZONTALEXTENT32:
1433 case LB_SETITEMDATA32:
1434 case LB_SETITEMHEIGHT32:
1435 case LB_SETSEL32:
1436 case LB_SETTOPINDEX32:
1437 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING32);
1438 return 0;
1439 case CB_DELETESTRING32:
1440 case CB_GETCOUNT32:
1441 case CB_GETLBTEXTLEN32:
1442 case CB_LIMITTEXT32:
1443 case CB_RESETCONTENT32:
1444 case CB_SETEDITSEL32:
1445 case CB_GETCURSEL32:
1446 case CB_SETCURSEL32:
1447 case CB_SHOWDROPDOWN32:
1448 case CB_SETITEMDATA32:
1449 case CB_SETITEMHEIGHT32:
1450 case CB_GETITEMHEIGHT32:
1451 case CB_SETEXTENDEDUI32:
1452 case CB_GETEXTENDEDUI32:
1453 case CB_GETDROPPEDSTATE32:
1454 *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL32);
1455 return 0;
1456 case CB_GETEDITSEL32:
1457 *pmsg16 = CB_GETEDITSEL16;
1458 return 1;
1459
1460 case LB_ADDSTRING32:
1461 case LB_FINDSTRING32:
1462 case LB_FINDSTRINGEXACT32:
1463 case LB_INSERTSTRING32:
1464 case LB_SELECTSTRING32:
1465 case LB_DIR32:
1466 case LB_ADDFILE32:
1467 {
1468 LPSTR str = SEGPTR_STRDUP( (LPSTR)*plparam );
1469 if (!str) return -1;
1470 *plparam = (LPARAM)SEGPTR_GET(str);
1471 }
1472 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING32);
1473 return 1;
1474
1475 case CB_ADDSTRING32:
1476 case CB_FINDSTRING32:
1477 case CB_FINDSTRINGEXACT32:
1478 case CB_INSERTSTRING32:
1479 case CB_SELECTSTRING32:
1480 case CB_DIR32:
1481 {
1482 LPSTR str = SEGPTR_STRDUP( (LPSTR)*plparam );
1483 if (!str) return -1;
1484 *plparam = (LPARAM)SEGPTR_GET(str);
1485 }
1486 *pmsg16 = (UINT16)msg32 + (CB_GETEDITSEL16 - CB_GETEDITSEL32);
1487 return 1;
1488
1489 case LB_GETITEMRECT32:
1490 {
1491 RECT16 *rect;
1492 rect = (RECT16 *)SEGPTR_ALLOC( sizeof(RECT16) + sizeof(LPARAM) );
1493 if (!rect) return -1;
1494 *(LPARAM *)(rect + 1) = *plparam; /* Store the previous lParam */
1495 *plparam = (LPARAM)SEGPTR_GET(rect);
1496 }
1497 *pmsg16 = LB_GETITEMRECT16;
1498 return 1;
1499 case LB_GETSELITEMS32:
1500 {
1501 LPINT16 items;
1502 *pwparam16 = (WPARAM16)MIN( wParam32, 0x7f80 ); /* Must be < 64K */
1503 if (!(items = SEGPTR_ALLOC( *pwparam16 * sizeof(INT16)
1504 + sizeof(LPARAM)))) return -1;
1505 *((LPARAM *)items)++ = *plparam; /* Store the previous lParam */
1506 *plparam = (LPARAM)SEGPTR_GET(items);
1507 }
1508 *pmsg16 = LB_GETSELITEMS16;
1509 return 1;
1510 case LB_SETTABSTOPS32:
1511 if (wParam32)
1512 {
1513 INT32 i;
1514 LPINT16 stops;
1515 *pwparam16 = (WPARAM16)MIN( wParam32, 0x7f80 ); /* Must be < 64K */
1516 if (!(stops = SEGPTR_ALLOC( *pwparam16 * sizeof(INT16)
1517 + sizeof(LPARAM)))) return -1;
1518 for (i = 0; i < *pwparam16; i++) stops[i] = *((LPINT32)*plparam+i);
1519 *plparam = (LPARAM)SEGPTR_GET(stops);
1520 return 1;
1521 }
1522 *pmsg16 = LB_SETTABSTOPS16;
1523 return 0;
1524
1525 case CB_GETDROPPEDCONTROLRECT32:
1526 {
1527 RECT16 *rect;
1528 rect = (RECT16 *)SEGPTR_ALLOC( sizeof(RECT16) + sizeof(LPARAM) );
1529 if (!rect) return -1;
1530 *(LPARAM *)(rect + 1) = *plparam; /* Store the previous lParam */
1531 *plparam = (LPARAM)SEGPTR_GET(rect);
1532 }
1533 *pmsg16 = CB_GETDROPPEDCONTROLRECT16;
1534 return 1;
1535
1536 case LB_GETTEXT32:
1537 *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
1538 *pmsg16 = LB_GETTEXT16;
1539 return 1;
1540
1541 case CB_GETLBTEXT32:
1542 *plparam = (LPARAM)MapLS( (LPVOID)(*plparam) );
1543 *pmsg16 = CB_GETLBTEXT16;
1544 return 1;
1545
1546 case EM_SETSEL32:
1547 *pwparam16 = 0;
1548 *plparam = MAKELONG( (INT16)(INT32)wParam32, (INT16)*plparam );
1549 *pmsg16 = EM_SETSEL16;
1550 return 0;
1551
1552 case WM_ACTIVATE:
1553 case WM_CHARTOITEM:
1554 case WM_COMMAND:
1555 case WM_VKEYTOITEM:
1556 *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32) );
1557 return 0;
1558 case WM_HSCROLL:
1559 case WM_VSCROLL:
1560 *plparam = MAKELPARAM( HIWORD(wParam32), (HWND16)*plparam );
1561 return 0;
1562 case WM_CTLCOLORMSGBOX:
1563 case WM_CTLCOLOREDIT:
1564 case WM_CTLCOLORLISTBOX:
1565 case WM_CTLCOLORBTN:
1566 case WM_CTLCOLORDLG:
1567 case WM_CTLCOLORSCROLLBAR:
1568 case WM_CTLCOLORSTATIC:
1569 *pmsg16 = WM_CTLCOLOR;
1570 *plparam = MAKELPARAM( (HWND16)*plparam,
1571 (WORD)msg32 - WM_CTLCOLORMSGBOX );
1572 return 0;
1573 case WM_COMPAREITEM:
1574 {
1575 COMPAREITEMSTRUCT32 *cis32 = (COMPAREITEMSTRUCT32 *)*plparam;
1576 COMPAREITEMSTRUCT16 *cis = SEGPTR_NEW(COMPAREITEMSTRUCT16);
1577 if (!cis) return -1;
1578 cis->CtlType = (UINT16)cis32->CtlType;
1579 cis->CtlID = (UINT16)cis32->CtlID;
1580 cis->hwndItem = (HWND16)cis32->hwndItem;
1581 cis->itemID1 = (UINT16)cis32->itemID1;
1582 cis->itemData1 = cis32->itemData1;
1583 cis->itemID2 = (UINT16)cis32->itemID2;
1584 cis->itemData2 = cis32->itemData2;
1585 *plparam = (LPARAM)SEGPTR_GET(cis);
1586 }
1587 return 1;
1588 case WM_DELETEITEM:
1589 {
1590 DELETEITEMSTRUCT32 *dis32 = (DELETEITEMSTRUCT32 *)*plparam;
1591 DELETEITEMSTRUCT16 *dis = SEGPTR_NEW(DELETEITEMSTRUCT16);
1592 if (!dis) return -1;
1593 dis->CtlType = (UINT16)dis32->CtlType;
1594 dis->CtlID = (UINT16)dis32->CtlID;
1595 dis->itemID = (UINT16)dis32->itemID;
1596 dis->hwndItem = (HWND16)dis32->hwndItem;
1597 dis->itemData = dis32->itemData;
1598 *plparam = (LPARAM)SEGPTR_GET(dis);
1599 }
1600 return 1;
1601 case WM_DRAWITEM:
1602 {
1603 DRAWITEMSTRUCT32 *dis32 = (DRAWITEMSTRUCT32 *)*plparam;
1604 DRAWITEMSTRUCT16 *dis = SEGPTR_NEW(DRAWITEMSTRUCT16);
1605 if (!dis) return -1;
1606 dis->CtlType = (UINT16)dis32->CtlType;
1607 dis->CtlID = (UINT16)dis32->CtlID;
1608 dis->itemID = (UINT16)dis32->itemID;
1609 dis->itemAction = (UINT16)dis32->itemAction;
1610 dis->itemState = (UINT16)dis32->itemState;
1611 dis->hwndItem = (HWND16)dis32->hwndItem;
1612 dis->hDC = (HDC16)dis32->hDC;
1613 dis->itemData = dis32->itemData;
1614 CONV_RECT32TO16( &dis32->rcItem, &dis->rcItem );
1615 *plparam = (LPARAM)SEGPTR_GET(dis);
1616 }
1617 return 1;
1618 case WM_MEASUREITEM:
1619 {
1620 MEASUREITEMSTRUCT32 *mis32 = (MEASUREITEMSTRUCT32 *)*plparam;
1621 MEASUREITEMSTRUCT16 *mis = (MEASUREITEMSTRUCT16 *)
1622 SEGPTR_ALLOC(sizeof(*mis)+sizeof(LPARAM));
1623 if (!mis) return -1;
1624 mis->CtlType = (UINT16)mis32->CtlType;
1625 mis->CtlID = (UINT16)mis32->CtlID;
1626 mis->itemID = (UINT16)mis32->itemID;
1627 mis->itemWidth = (UINT16)mis32->itemWidth;
1628 mis->itemHeight = (UINT16)mis32->itemHeight;
1629 mis->itemData = mis32->itemData;
1630 *(LPARAM *)(mis + 1) = *plparam; /* Store the previous lParam */
1631 *plparam = (LPARAM)SEGPTR_GET(mis);
1632 }
1633 return 1;
1634 case WM_GETMINMAXINFO:
1635 {
1636 MINMAXINFO16 *mmi = (MINMAXINFO16 *)SEGPTR_ALLOC( sizeof(*mmi) +
1637 sizeof(LPARAM) );
1638 if (!mmi) return -1;
1639 STRUCT32_MINMAXINFO32to16( (MINMAXINFO32 *)*plparam, mmi );
1640 *(LPARAM *)(mmi + 1) = *plparam; /* Store the previous lParam */
1641 *plparam = (LPARAM)SEGPTR_GET(mmi);
1642 }
1643 return 1;
1644 case WM_GETTEXT:
1645 {
1646 LPSTR str;
1647 *pwparam16 = (WPARAM16)MIN( wParam32, 0xff80 ); /* Must be < 64K */
1648 if (!(str = SEGPTR_ALLOC(*pwparam16 + sizeof(LPARAM)))) return -1;
1649 *((LPARAM *)str)++ = *plparam; /* Store the previous lParam */
1650 *plparam = (LPARAM)SEGPTR_GET(str);
1651 }
1652 return 1;
1653 case WM_MDICREATE:
1654 {
1655 MDICREATESTRUCT16 *cs;
1656 MDICREATESTRUCT32A *cs32 = (MDICREATESTRUCT32A *)*plparam;
1657 LPSTR name, cls;
1658
1659 if (!(cs = SEGPTR_NEW(MDICREATESTRUCT16))) return -1;
1660 STRUCT32_MDICREATESTRUCT32Ato16( cs32, cs );
1661 name = SEGPTR_STRDUP( cs32->szTitle );
1662 cls = SEGPTR_STRDUP( cs32->szClass );
1663 cs->szTitle = SEGPTR_GET(name);
1664 cs->szClass = SEGPTR_GET(cls);
1665 *plparam = (LPARAM)SEGPTR_GET(cs);
1666 }
1667 return 1;
1668 case WM_MDIGETACTIVE:
1669 return 1;
1670 case WM_MDISETMENU:
1671 *plparam = MAKELPARAM( (HMENU16)LOWORD(wParam32),
1672 (HMENU16)LOWORD(*plparam) );
1673 *pwparam16 = (*plparam == 0);
1674 return 0;
1675 case WM_MENUCHAR:
1676 case WM_MENUSELECT:
1677 *plparam = MAKELPARAM( HIWORD(wParam32), (HMENU16)*plparam );
1678 return 0;
1679 case WM_MDIACTIVATE:
1680 if( WIDGETS_IsControl32(WIN_FindWndPtr(hwnd), BIC32_MDICLIENT) )
1681 {
1682 *pwparam16 = (HWND32)wParam32;
1683 *plparam = 0;
1684 }
1685 else
1686 {
1687 *pwparam16 = ((HWND32)*plparam == hwnd);
1688 *plparam = MAKELPARAM( (HWND16)LOWORD(*plparam),
1689 (HWND16)LOWORD(wParam32) );
1690 }
1691 return 0;
1692 case WM_NCCALCSIZE:
1693 {
1694 NCCALCSIZE_PARAMS32 *nc32 = (NCCALCSIZE_PARAMS32 *)*plparam;
1695 NCCALCSIZE_PARAMS16 *nc = (NCCALCSIZE_PARAMS16 *)SEGPTR_ALLOC( sizeof(*nc) + sizeof(LPARAM) );
1696 if (!nc) return -1;
1697
1698 CONV_RECT32TO16( &nc32->rgrc[0], &nc->rgrc[0] );
1699 if (wParam32)
1700 {
1701 WINDOWPOS16 *wp;
1702 CONV_RECT32TO16( &nc32->rgrc[1], &nc->rgrc[1] );
1703 CONV_RECT32TO16( &nc32->rgrc[2], &nc->rgrc[2] );
1704 if (!(wp = SEGPTR_NEW(WINDOWPOS16)))
1705 {
1706 SEGPTR_FREE(nc);
1707 return -1;
1708 }
1709 STRUCT32_WINDOWPOS32to16( nc32->lppos, wp );
1710 nc->lppos = SEGPTR_GET(wp);
1711 }
1712 *(LPARAM *)(nc + 1) = *plparam; /* Store the previous lParam */
1713 *plparam = (LPARAM)SEGPTR_GET(nc);
1714 }
1715 return 1;
1716 case WM_NCCREATE:
1717 case WM_CREATE:
1718 {
1719 CREATESTRUCT16 *cs;
1720 CREATESTRUCT32A *cs32 = (CREATESTRUCT32A *)*plparam;
1721 LPSTR name, cls;
1722
1723 if (!(cs = SEGPTR_NEW(CREATESTRUCT16))) return -1;
1724 STRUCT32_CREATESTRUCT32Ato16( cs32, cs );
1725 name = SEGPTR_STRDUP( cs32->lpszName );
1726 cls = SEGPTR_STRDUP( cs32->lpszClass );
1727 cs->lpszName = SEGPTR_GET(name);
1728 cs->lpszClass = SEGPTR_GET(cls);
1729 *plparam = (LPARAM)SEGPTR_GET(cs);
1730 }
1731 return 1;
1732 case WM_PARENTNOTIFY:
1733 if ((LOWORD(wParam32)==WM_CREATE) || (LOWORD(wParam32)==WM_DESTROY))
1734 *plparam = MAKELPARAM( (HWND16)*plparam, HIWORD(wParam32));
1735 /* else nothing to do */
1736 return 0;
1737 case WM_NOTIFY:
1738 *plparam = MapLS( (NMHDR *)*plparam ); /* NMHDR is already 32-bit */
1739 return 1;
1740 case WM_SETTEXT:
1741 {
1742 LPSTR str = SEGPTR_STRDUP( (LPSTR)*plparam );
1743 if (!str) return -1;
1744 *plparam = (LPARAM)SEGPTR_GET(str);
1745 }
1746 return 1;
1747 case WM_WINDOWPOSCHANGING:
1748 case WM_WINDOWPOSCHANGED:
1749 {
1750 WINDOWPOS16 *wp = (WINDOWPOS16 *)SEGPTR_ALLOC( sizeof(*wp) +
1751 sizeof(LPARAM) );
1752 if (!wp) return -1;
1753 STRUCT32_WINDOWPOS32to16( (WINDOWPOS32 *)*plparam, wp );
1754 *(LPARAM *)(wp + 1) = *plparam; /* Store the previous lParam */
1755 *plparam = (LPARAM)SEGPTR_GET(wp);
1756 }
1757 return 1;
1758 case WM_GETDLGCODE:
1759 if (*plparam) {
1760 LPMSG32 msg32 = (LPMSG32) *plparam;
1761 LPMSG16 msg16 = (LPMSG16) SEGPTR_NEW( MSG16 );
1762
1763 if (!msg16) return -1;
1764 msg16->hwnd = msg32->hwnd;
1765 msg16->lParam = msg32->lParam;
1766 msg16->time = msg32->time;
1767 CONV_POINT32TO16(&msg32->pt,&msg16->pt);
1768 /* this is right, right? */
1769 if (WINPROC_MapMsg32ATo16(msg32->hwnd,msg32->message,msg32->wParam,
1770 &msg16->message,&msg16->wParam, &msg16->lParam)<0) {
1771 SEGPTR_FREE( msg16 );
1772 return -1;
1773 }
1774 *plparam = (LPARAM)SEGPTR_GET(msg16);
1775 return 1;
1776 }
1777 return 0;
1778
1779 case WM_ACTIVATEAPP:
1780 if (*plparam) {
1781 *plparam = (LPARAM) THREAD_ID_TO_THDB((DWORD) *plparam)->teb.htask16;
1782 }
1783 return 1;
1784 case WM_ASKCBFORMATNAME:
1785 case WM_DEVMODECHANGE:
1786 case WM_PAINTCLIPBOARD:
1787 case WM_SIZECLIPBOARD:
1788 case WM_WININICHANGE:
1789 FIXME( msg, "message %04x needs translation\n", msg32 );
1790 return -1;
1791 default: /* No translation needed */
1792 return 0;
1793 }
1794 }
1795
1796
1797 /**********************************************************************
1798 * WINPROC_UnmapMsg32ATo16
1799 *
1800 * Unmap a message that was mapped from 32-bit Ansi to 16-bit.
1801 */
1802 void WINPROC_UnmapMsg32ATo16( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam,
1803 MSGPARAM16* p16 )
1804 {
1805 switch(msg)
1806 {
1807 case LB_ADDFILE32:
1808 case LB_ADDSTRING32:
1809 case LB_DIR32:
1810 case LB_FINDSTRING32:
1811 case LB_FINDSTRINGEXACT32:
1812 case LB_INSERTSTRING32:
1813 case LB_SELECTSTRING32:
1814 case LB_SETTABSTOPS32:
1815 case CB_ADDSTRING32:
1816 case CB_FINDSTRING32:
1817 case CB_FINDSTRINGEXACT32:
1818 case CB_INSERTSTRING32:
1819 case CB_SELECTSTRING32:
1820 case CB_DIR32:
1821 case WM_COMPAREITEM:
1822 case WM_DELETEITEM:
1823 case WM_DRAWITEM:
1824 case WM_SETTEXT:
1825 SEGPTR_FREE( PTR_SEG_TO_LIN(p16->lParam) );
1826 break;
1827
1828 case CB_GETDROPPEDCONTROLRECT32:
1829 case LB_GETITEMRECT32:
1830 {
1831 RECT16 *rect = (RECT16 *)PTR_SEG_TO_LIN(p16->lParam);
1832 p16->lParam = *(LPARAM *)(rect + 1);
1833 CONV_RECT16TO32( rect, (RECT32 *)(p16->lParam));
1834 SEGPTR_FREE( rect );
1835 }
1836 break;
1837 case LB_GETSELITEMS32:
1838 {
1839 INT32 i;
1840 LPINT16 items = (LPINT16)PTR_SEG_TO_LIN(lParam);
1841 p16->lParam = *((LPARAM *)items - 1);
1842 for (i = 0; i < p16->wParam; i++) *((LPINT32)(p16->lParam) + i) = items[i];
1843 SEGPTR_FREE( (LPARAM *)items - 1 );
1844 }
1845 break;
1846
1847 case CB_GETEDITSEL32:
1848 if( wParam )
1849 *((LPUINT32)(wParam)) = LOWORD(p16->lResult);
1850 if( lParam )
1851 *((LPUINT32)(lParam)) = HIWORD(p16->lResult); /* FIXME: substract 1? */
1852 break;
1853
1854 case LB_GETTEXT32:
1855 case CB_GETLBTEXT32:
1856 UnMapLS( (SEGPTR)(p16->lParam) );
1857 break;
1858
1859 case WM_MEASUREITEM:
1860 {
1861 MEASUREITEMSTRUCT16 *mis = (MEASUREITEMSTRUCT16 *)PTR_SEG_TO_LIN(p16->lParam);
1862 MEASUREITEMSTRUCT32 *mis32 = *(MEASUREITEMSTRUCT32 **)(mis + 1);
1863 mis32->itemWidth = mis->itemWidth;
1864 mis32->itemHeight = mis->itemHeight;
1865 SEGPTR_FREE(mis);
1866 }
1867 break;
1868 case WM_GETMINMAXINFO:
1869 {
1870 MINMAXINFO16 *mmi = (MINMAXINFO16 *)PTR_SEG_TO_LIN(p16->lParam);
1871 p16->lParam = *(LPARAM *)(mmi + 1);
1872 STRUCT32_MINMAXINFO16to32( mmi, (MINMAXINFO32 *)(p16->lParam) );
1873 SEGPTR_FREE(mmi);
1874 }
1875 break;
1876 case WM_GETTEXT:
1877 {
1878 LPSTR str = (LPSTR)PTR_SEG_TO_LIN(p16->lParam);
1879 p16->lParam = *((LPARAM *)str - 1);
1880 lstrcpyn32A( (LPSTR)(p16->lParam), str, p16->wParam );
1881 SEGPTR_FREE( (LPARAM *)str - 1 );
1882 }
1883 break;
1884 case WM_MDICREATE:
1885 {
1886 MDICREATESTRUCT16 *cs = (MDICREATESTRUCT16*)PTR_SEG_TO_LIN(p16->lParam);
1887 SEGPTR_FREE( PTR_SEG_TO_LIN(cs->szTitle) );
1888 SEGPTR_FREE( PTR_SEG_TO_LIN(cs->szClass) );
1889 SEGPTR_FREE( cs );
1890 }
1891 break;
1892 case WM_MDIGETACTIVE:
1893 if (lParam) *(BOOL32 *)lParam = (BOOL16)HIWORD(p16->lResult);
1894 p16->lResult = (HWND32)LOWORD(p16->lResult);
1895 break;
1896 case WM_NCCALCSIZE:
1897 {
1898 NCCALCSIZE_PARAMS32 *nc32;
1899 NCCALCSIZE_PARAMS16 *nc = (NCCALCSIZE_PARAMS16 *)PTR_SEG_TO_LIN(p16->lParam);
1900 p16->lParam = *(LPARAM *)(nc + 1);
1901 nc32 = (NCCALCSIZE_PARAMS32 *)(p16->lParam);
1902 CONV_RECT16TO32( &nc->rgrc[0], &nc32->rgrc[0] );
1903 if (p16->wParam)
1904 {
1905 CONV_RECT16TO32( &nc->rgrc[1], &nc32->rgrc[1] );
1906 CONV_RECT16TO32( &nc->rgrc[2], &nc32->rgrc[2] );
1907 STRUCT32_WINDOWPOS16to32( (WINDOWPOS16 *)PTR_SEG_TO_LIN(nc->lppos),
1908 nc32->lppos );
1909 SEGPTR_FREE( PTR_SEG_TO_LIN(nc->lppos) );
1910 }
1911 SEGPTR_FREE(nc);
1912 }
1913 break;
1914 case WM_NCCREATE:
1915 case WM_CREATE:
1916 {
1917 CREATESTRUCT16 *cs = (CREATESTRUCT16 *)PTR_SEG_TO_LIN(p16->lParam);
1918 SEGPTR_FREE( PTR_SEG_TO_LIN(cs->lpszName) );
1919 SEGPTR_FREE( PTR_SEG_TO_LIN(cs->lpszClass) );
1920 SEGPTR_FREE( cs );
1921 }
1922 break;
1923 case WM_WINDOWPOSCHANGING:
1924 case WM_WINDOWPOSCHANGED:
1925 {
1926 WINDOWPOS16 *wp = (WINDOWPOS16 *)PTR_SEG_TO_LIN(p16->lParam);
1927 p16->lParam = *(LPARAM *)(wp + 1);
1928 STRUCT32_WINDOWPOS16to32( wp, (WINDOWPOS32 *)p16->lParam );
1929 SEGPTR_FREE(wp);
1930 }
1931 break;
1932 case WM_NOTIFY:
1933 UnMapLS(p16->lParam);
1934 break;
1935 case WM_GETDLGCODE:
1936 if (p16->lParam)
1937 {
1938 LPMSG16 msg16 = (LPMSG16)PTR_SEG_TO_LIN(p16->lParam);
1939 MSGPARAM16 msgp16;
1940 msgp16.wParam=msg16->wParam;
1941 msgp16.lParam=msg16->lParam;
1942 WINPROC_UnmapMsg32ATo16(((LPMSG32)lParam)->hwnd, ((LPMSG32)lParam)->message,
1943 ((LPMSG32)lParam)->wParam, ((LPMSG32)lParam)->lParam,
1944 &msgp16 );
1945 SEGPTR_FREE(msg16);
1946 }
1947 break;
1948 }
1949 }
1950
1951
1952 /**********************************************************************
1953 * WINPROC_MapMsg32WTo16
1954 *
1955 * Map a message from 32-bit Unicode to 16-bit.
1956 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
1957 */
1958 INT32 WINPROC_MapMsg32WTo16( HWND32 hwnd, UINT32 msg32, WPARAM32 wParam32,
1959 UINT16 *pmsg16, WPARAM16 *pwparam16,
1960 LPARAM *plparam )
1961 {
1962 switch(msg32)
1963 {
1964 case LB_ADDSTRING32:
1965 case LB_FINDSTRING32:
1966 case LB_FINDSTRINGEXACT32:
1967 case LB_INSERTSTRING32:
1968 case LB_SELECTSTRING32:
1969 case LB_DIR32:
1970 case LB_ADDFILE32:
1971 {
1972 LPSTR str = SEGPTR_STRDUP_WtoA( (LPWSTR)*plparam );
1973 if (!str) return -1;
1974 *pwparam16 = (WPARAM16)LOWORD(wParam32);
1975 *plparam = (LPARAM)SEGPTR_GET(str);
1976 }
1977 *pmsg16 = (UINT16)msg32 + (LB_ADDSTRING16 - LB_ADDSTRING32);
1978 return 1;
1979
1980 case CB_ADDSTRING32:
1981 case CB_FINDSTRING32:
1982 case CB_FINDSTRINGEXACT32:
1983 case CB_INSERTSTRING32:
1984 case CB_SELECTSTRING32:
1985 case CB_DIR32:
1986 {
1987 LPSTR str = SEGPTR_STRDUP_WtoA( (LPWSTR)*plparam );
1988 if (!str) return -1;
1989 *pwparam16 = (WPARAM16)LOWORD(wParam32);
1990 *plparam = (LPARAM)SEGPTR_GET(str);
1991 }
1992 *pmsg16 = (UINT16)msg32 + (CB_ADDSTRING16 - CB_ADDSTRING32);
1993 return 1;
1994
1995 case WM_NCCREATE:
1996 case WM_CREATE:
1997 {
1998 CREATESTRUCT16 *cs;
1999 CREATESTRUCT32W *cs32 = (CREATESTRUCT32W *)*plparam;
2000 LPSTR name, cls;
2001
2002 if (!(cs = SEGPTR_NEW(CREATESTRUCT16))) return -1;
2003 STRUCT32_CREATESTRUCT32Ato16( (CREATESTRUCT32A *)cs32, cs );
2004 name = SEGPTR_STRDUP_WtoA( cs32->lpszName );
2005 cls = SEGPTR_STRDUP_WtoA( cs32->lpszClass );
2006 cs->lpszName = SEGPTR_GET(name);
2007 cs->lpszClass = SEGPTR_GET(cls);
2008 *pmsg16 = (UINT16)msg32;
2009 *pwparam16 = (WPARAM16)LOWORD(wParam32);
2010 *plparam = (LPARAM)SEGPTR_GET(cs);
2011 }
2012 return 1;
2013 case WM_MDICREATE:
2014 {
2015 MDICREATESTRUCT16 *cs;
2016 MDICREATESTRUCT32W *cs32 = (MDICREATESTRUCT32W *)*plparam;
2017 LPSTR name, cls;
2018
2019 if (!(cs = SEGPTR_NEW(MDICREATESTRUCT16))) return -1;
2020 STRUCT32_MDICREATESTRUCT32Ato16( (MDICREATESTRUCT32A *)cs32, cs );
2021 name = SEGPTR_STRDUP_WtoA( cs32->szTitle );
2022 cls = SEGPTR_STRDUP_WtoA( cs32->szClass );
2023 cs->szTitle = SEGPTR_GET(name);
2024 cs->szClass = SEGPTR_GET(cls);
2025 *pmsg16 = (UINT16)msg32;
2026 *pwparam16 = (WPARAM16)LOWORD(wParam32);
2027 *plparam = (LPARAM)SEGPTR_GET(cs);
2028 }
2029 return 1;
2030 case WM_SETTEXT:
2031 {
2032 LPSTR str = SEGPTR_STRDUP_WtoA( (LPWSTR)*plparam );
2033 if (!str) return -1;
2034 *pmsg16 = (UINT16)msg32;
2035 *pwparam16 = (WPARAM16)LOWORD(wParam32);
2036 *plparam = (LPARAM)SEGPTR_GET(str);
2037 }
2038 return 1;
2039 default: /* No Unicode translation needed */
2040 return WINPROC_MapMsg32ATo16( hwnd, msg32, wParam32, pmsg16,
2041 pwparam16, plparam );
2042 }
2043 }
2044
2045
2046 /**********************************************************************
2047 * WINPROC_UnmapMsg32WTo16
2048 *
2049 * Unmap a message that was mapped from 32-bit Unicode to 16-bit.
2050 */
2051 void WINPROC_UnmapMsg32WTo16( HWND32 hwnd, UINT32 msg, WPARAM32 wParam, LPARAM lParam,
2052 MSGPARAM16* p16 )
2053 {
2054 switch(msg)
2055 {
2056 case WM_GETTEXT:
2057 {
2058 LPSTR str = (LPSTR)PTR_SEG_TO_LIN(p16->lParam);
2059 p16->lParam = *((LPARAM *)str - 1);
2060 lstrcpyAtoW( (LPWSTR)(p16->lParam), str );
2061 SEGPTR_FREE( (LPARAM *)str - 1 );
2062 }
2063 break;
2064 default:
2065 WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, p16 );
2066 break;
2067 }
2068 }
2069
2070
2071 /**********************************************************************
2072 * WINPROC_CallProc32ATo32W
2073 *
2074 * Call a window procedure, translating args from Ansi to Unicode.
2075 */
2076 static LRESULT WINPROC_CallProc32ATo32W( WNDPROC32 func, HWND32 hwnd,
2077 UINT32 msg, WPARAM32 wParam,
2078 LPARAM lParam )
2079 {
2080 LRESULT result;
2081
2082 if (WINPROC_MapMsg32ATo32W( hwnd, msg, wParam, &lParam ) == -1) return 0;
2083 result = WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2084 WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam );
2085 return result;
2086 }
2087
2088
2089 /**********************************************************************
2090 * WINPROC_CallProc32WTo32A
2091 *
2092 * Call a window procedure, translating args from Unicode to Ansi.
2093 */
2094 static LRESULT WINPROC_CallProc32WTo32A( WNDPROC32 func, HWND32 hwnd,
2095 UINT32 msg, WPARAM32 wParam,
2096 LPARAM lParam )
2097 {
2098 LRESULT result;
2099
2100 if (WINPROC_MapMsg32WTo32A( hwnd, msg, wParam, &lParam ) == -1) return 0;
2101 result = WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2102 WINPROC_UnmapMsg32WTo32A( hwnd, msg, wParam, lParam );
2103 return result;
2104 }
2105
2106
2107 /**********************************************************************
2108 * WINPROC_CallProc16To32A
2109 *
2110 * Call a 32-bit window procedure, translating the 16-bit args.
2111 */
2112 LRESULT WINPROC_CallProc16To32A( HWND16 hwnd, UINT16 msg,
2113 WPARAM16 wParam, LPARAM lParam,
2114 WNDPROC32 func )
2115 {
2116 LRESULT result;
2117 UINT32 msg32;
2118 WPARAM32 wParam32;
2119
2120 if (WINPROC_MapMsg16To32A( msg, wParam, &msg32, &wParam32, &lParam ) == -1)
2121 return 0;
2122 result = WINPROC_CallWndProc32( func, hwnd, msg32, wParam32, lParam );
2123 return WINPROC_UnmapMsg16To32A( hwnd, msg32, wParam32, lParam, result );
2124 }
2125
2126
2127 /**********************************************************************
2128 * WINPROC_CallProc16To32W
2129 *
2130 * Call a 32-bit window procedure, translating the 16-bit args.
2131 */
2132 LRESULT WINPROC_CallProc16To32W( HWND16 hwnd, UINT16 msg,
2133 WPARAM16 wParam, LPARAM lParam,
2134 WNDPROC32 func )
2135 {
2136 LRESULT result;
2137 UINT32 msg32;
2138 WPARAM32 wParam32;
2139
2140 if (WINPROC_MapMsg16To32W( hwnd, msg, wParam, &msg32, &wParam32, &lParam ) == -1)
2141 return 0;
2142 result = WINPROC_CallWndProc32( func, hwnd, msg32, wParam32, lParam );
2143 return WINPROC_UnmapMsg16To32W( hwnd, msg32, wParam32, lParam, result );
2144 }
2145
2146
2147 /**********************************************************************
2148 * WINPROC_CallProc32ATo16
2149 *
2150 * Call a 16-bit window procedure, translating the 32-bit args.
2151 */
2152 static LRESULT WINAPI WINPROC_CallProc32ATo16( WNDPROC16 func, HWND32 hwnd,
2153 UINT32 msg, WPARAM32 wParam,
2154 LPARAM lParam )
2155 {
2156 UINT16 msg16;
2157 MSGPARAM16 mp16;
2158
2159 mp16.lParam = lParam;
2160 if (WINPROC_MapMsg32ATo16( hwnd, msg, wParam,
2161 &msg16, &mp16.wParam, &mp16.lParam ) == -1)
2162 return 0;
2163 mp16.lResult = Callbacks->CallWndProc( func, hwnd, msg16,
2164 mp16.wParam, mp16.lParam );
2165 WINPROC_UnmapMsg32ATo16( hwnd, msg, wParam, lParam, &mp16 );
2166 return mp16.lResult;
2167 }
2168
2169
2170 /**********************************************************************
2171 * WINPROC_CallProc32WTo16
2172 *
2173 * Call a 16-bit window procedure, translating the 32-bit args.
2174 */
2175 static LRESULT WINAPI WINPROC_CallProc32WTo16( WNDPROC16 func, HWND32 hwnd,
2176 UINT32 msg, WPARAM32 wParam,
2177 LPARAM lParam )
2178 {
2179 UINT16 msg16;
2180 MSGPARAM16 mp16;
2181
2182 mp16.lParam = lParam;
2183 if (WINPROC_MapMsg32WTo16( hwnd, msg, wParam, &msg16, &mp16.wParam,
2184 &mp16.lParam ) == -1)
2185 return 0;
2186 mp16.lResult = Callbacks->CallWndProc( func, hwnd, msg16,
2187 mp16.wParam, mp16.lParam );
2188 WINPROC_UnmapMsg32WTo16( hwnd, msg, wParam, lParam, &mp16 );
2189 return mp16.lResult;
2190 }
2191
2192
2193 /**********************************************************************
2194 * CallWindowProc16 (USER.122)
2195 */
2196 LRESULT WINAPI CallWindowProc16( WNDPROC16 func, HWND16 hwnd, UINT16 msg,
2197 WPARAM16 wParam, LPARAM lParam )
2198 {
2199 WINDOWPROC *proc = WINPROC_GetPtr( func );
2200
2201 if (!proc)
2202 return Callbacks->CallWndProc( func, hwnd, msg, wParam, lParam );
2203
2204 #if testing
2205 func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_16 );
2206 return Callbacks->CallWndProc( func, hwnd, msg, wParam, lParam );
2207 #endif
2208
2209 switch(proc->type)
2210 {
2211 case WIN_PROC_16:
2212 if (!proc->thunk.t_from32.proc) return 0;
2213 return Callbacks->CallWndProc( proc->thunk.t_from32.proc,
2214 hwnd, msg, wParam, lParam );
2215 case WIN_PROC_32A:
2216 if (!proc->thunk.t_from16.proc) return 0;
2217 return WINPROC_CallProc16To32A( hwnd, msg, wParam, lParam,
2218 proc->thunk.t_from16.proc );
2219 case WIN_PROC_32W:
2220 if (!proc->thunk.t_from16.proc) return 0;
2221 return WINPROC_CallProc16To32W( hwnd, msg, wParam, lParam,
2222 proc->thunk.t_from16.proc );
2223 default:
2224 WARN( relay, "Invalid proc %p\n", proc );
2225 return 0;
2226 }
2227 }
2228
2229
2230 /**********************************************************************
2231 * CallWindowProc32A (USER32.18)
2232 *
2233 * The CallWindowProc() function invokes the windows procedure _func_,
2234 * with _hwnd_ as the target window, the message specified by _msg_, and
2235 * the message parameters _wParam_ and _lParam_.
2236 *
2237 * Some kinds of argument conversion may be done, I'm not sure what.
2238 *
2239 * CallWindowProc() may be used for windows subclassing. Use
2240 * SetWindowLong() to set a new windows procedure for windows of the
2241 * subclass, and handle subclassed messages in the new windows
2242 * procedure. The new windows procedure may then use CallWindowProc()
2243 * with _func_ set to the parent class's windows procedure to dispatch
2244 * the message to the superclass.
2245 *
2246 * RETURNS
2247 *
2248 * The return value is message dependent.
2249 *
2250 * CONFORMANCE
2251 *
2252 * ECMA-234, Win32
2253 */
2254 LRESULT WINAPI CallWindowProc32A(
2255 WNDPROC32 func, /* window procedure */
2256 HWND32 hwnd, /* target window */
2257 UINT32 msg, /* message */
2258 WPARAM32 wParam, /* message dependent parameter */
2259 LPARAM lParam /* message dependent parameter */
2260 ) {
2261 WINDOWPROC *proc = WINPROC_GetPtr( (WNDPROC16)func );
2262
2263 if (!proc) return WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2264
2265 #if testing
2266 func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_32A );
2267 return WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2268 #endif
2269
2270 switch(proc->type)
2271 {
2272 case WIN_PROC_16:
2273 if (!proc->thunk.t_from32.proc) return 0;
2274 return WINPROC_CallProc32ATo16( proc->thunk.t_from32.proc,
2275 hwnd, msg, wParam, lParam );
2276 case WIN_PROC_32A:
2277 if (!proc->thunk.t_from16.proc) return 0;
2278 return WINPROC_CallWndProc32( proc->thunk.t_from16.proc,
2279 hwnd, msg, wParam, lParam );
2280 case WIN_PROC_32W:
2281 if (!proc->thunk.t_from16.proc) return 0;
2282 return WINPROC_CallProc32ATo32W( proc->thunk.t_from16.proc,
2283 hwnd, msg, wParam, lParam );
2284 default:
2285 WARN( relay, "Invalid proc %p\n", proc );
2286 return 0;
2287 }
2288 }
2289
2290
2291 /**********************************************************************
2292 * CallWindowProc32W (USER32.19)
2293 */
2294 LRESULT WINAPI CallWindowProc32W( WNDPROC32 func, HWND32 hwnd, UINT32 msg,
2295 WPARAM32 wParam, LPARAM lParam )
2296 {
2297 WINDOWPROC *proc = WINPROC_GetPtr( (WNDPROC16)func );
2298
2299 if (!proc) return WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2300
2301 #if testing
2302 func = WINPROC_GetProc( (HWINDOWPROC)proc, WIN_PROC_32W );
2303 return WINPROC_CallWndProc32( func, hwnd, msg, wParam, lParam );
2304 #endif
2305
2306 switch(proc->type)
2307 {
2308 case WIN_PROC_16:
2309 if (!proc->thunk.t_from32.proc) return 0;
2310 return WINPROC_CallProc32WTo16( proc->thunk.t_from32.proc,
2311 hwnd, msg, wParam, lParam );
2312 case WIN_PROC_32A:
2313 if (!proc->thunk.t_from16.proc) return 0;
2314 return WINPROC_CallProc32WTo32A( proc->thunk.t_from16.proc,
2315 hwnd, msg, wParam, lParam );
2316 case WIN_PROC_32W:
2317 if (!proc->thunk.t_from16.proc) return 0;
2318 return WINPROC_CallWndProc32( proc->thunk.t_from16.proc,
2319 hwnd, msg, wParam, lParam );
2320 default:
2321 WARN( relay, "Invalid proc %p\n", proc );
2322 return 0;
2323 }
2324 }
Work in progress by Kai Blin