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