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