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