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