?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdi32: The text extents functions fail if passed a negative count.
[wine.git] / dlls / user32 / winproc.c
blobb06e93d6abcd2300e2003110d52d38bfc1541d56
1 /*
2 * Window procedure callbacks
3 *
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1996 Alexandre Julliard
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdarg.h>
27 #include <string.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "controls.h"
32 #include "win.h"
33 #include "user_private.h"
34 #include "wine/unicode.h"
35 #include "wine/debug.h"
36
37 WINE_DECLARE_DEBUG_CHANNEL(msg);
38 WINE_DECLARE_DEBUG_CHANNEL(relay);
39 WINE_DEFAULT_DEBUG_CHANNEL(win);
40
41 typedef struct tagWINDOWPROC
42 {
43 WNDPROC procA; /* ASCII window proc */
44 WNDPROC procW; /* Unicode window proc */
45 } WINDOWPROC;
46
47 #define MAX_WINPROCS 4096
48 #define MAX_WINPROC_RECURSION 64
49 #define WINPROC_PROC16 ((WINDOWPROC *)1) /* placeholder for 16-bit window procs */
50
51 static LRESULT WINAPI ButtonWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
52 static LRESULT WINAPI ButtonWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
53 static LRESULT WINAPI ComboWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
54 static LRESULT WINAPI ComboWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
55 LRESULT WINAPI EditWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
56 static LRESULT WINAPI EditWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
57 static LRESULT WINAPI ListBoxWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
58 static LRESULT WINAPI ListBoxWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
59 static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
60 static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
61 static LRESULT WINAPI ScrollBarWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
62 static LRESULT WINAPI ScrollBarWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
63 static LRESULT WINAPI StaticWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
64 static LRESULT WINAPI StaticWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
65
66 static WINDOWPROC winproc_array[MAX_WINPROCS] =
67 {
68 { ButtonWndProcA, ButtonWndProcW }, /* WINPROC_BUTTON */
69 { ComboWndProcA, ComboWndProcW }, /* WINPROC_COMBO */
70 { DefWindowProcA, DefWindowProcW }, /* WINPROC_DEFWND */
71 { DefDlgProcA, DefDlgProcW }, /* WINPROC_DIALOG */
72 { EditWndProcA, EditWndProcW }, /* WINPROC_EDIT */
73 { ListBoxWndProcA, ListBoxWndProcW }, /* WINPROC_LISTBOX */
74 { MDIClientWndProcA, MDIClientWndProcW }, /* WINPROC_MDICLIENT */
75 { ScrollBarWndProcA, ScrollBarWndProcW }, /* WINPROC_SCROLLBAR */
76 { StaticWndProcA, StaticWndProcW }, /* WINPROC_STATIC */
77 { NULL, DesktopWndProc }, /* WINPROC_DESKTOP */
78 { NULL, IconTitleWndProc }, /* WINPROC_ICONTITLE */
79 { NULL, PopupMenuWndProc }, /* WINPROC_MENU */
80 { NULL, MessageWndProc }, /* WINPROC_MESSAGE */
81 };
82
83 static UINT winproc_used = NB_BUILTIN_WINPROCS;
84
85 static CRITICAL_SECTION winproc_cs;
86 static CRITICAL_SECTION_DEBUG critsect_debug =
87 {
88 0, 0, &winproc_cs,
89 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
90 0, 0, { (DWORD_PTR)(__FILE__ ": winproc_cs") }
91 };
92 static CRITICAL_SECTION winproc_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
93
94 static inline void *get_buffer( void *static_buffer, size_t size, size_t need )
95 {
96 if (size >= need) return static_buffer;
97 return HeapAlloc( GetProcessHeap(), 0, need );
98 }
99
100 static inline void free_buffer( void *static_buffer, void *buffer )
101 {
102 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
103 }
104
105 /* find an existing winproc for a given function and type */
106 /* FIXME: probably should do something more clever than a linear search */
107 static inline WINDOWPROC *find_winproc( WNDPROC func, BOOL unicode )
108 {
109 unsigned int i;
110
111 for (i = 0; i < NB_BUILTIN_AW_WINPROCS; i++)
112 {
113 /* match either proc, some apps confuse A and W */
114 if (winproc_array[i].procA != func && winproc_array[i].procW != func) continue;
115 return &winproc_array[i];
116 }
117 for (i = NB_BUILTIN_AW_WINPROCS; i < winproc_used; i++)
118 {
119 if (!unicode && winproc_array[i].procA != func) continue;
120 if (unicode && winproc_array[i].procW != func) continue;
121 return &winproc_array[i];
122 }
123 return NULL;
124 }
125
126 /* return the window proc for a given handle, or NULL for an invalid handle,
127 * or WINPROC_PROC16 for a handle to a 16-bit proc. */
128 static inline WINDOWPROC *handle_to_proc( WNDPROC handle )
129 {
130 UINT index = LOWORD(handle);
131 if ((ULONG_PTR)handle >> 16 != WINPROC_HANDLE) return NULL;
132 if (index >= MAX_WINPROCS) return WINPROC_PROC16;
133 if (index >= winproc_used) return NULL;
134 return &winproc_array[index];
135 }
136
137 /* create a handle for a given window proc */
138 static inline WNDPROC proc_to_handle( WINDOWPROC *proc )
139 {
140 return (WNDPROC)(ULONG_PTR)((proc - winproc_array) | (WINPROC_HANDLE << 16));
141 }
142
143 /* allocate and initialize a new winproc */
144 static inline WINDOWPROC *alloc_winproc( WNDPROC func, BOOL unicode )
145 {
146 WINDOWPROC *proc;
147
148 /* check if the function is already a win proc */
149 if (!func) return NULL;
150 if ((proc = handle_to_proc( func ))) return proc;
151
152 EnterCriticalSection( &winproc_cs );
153
154 /* check if we already have a winproc for that function */
155 if (!(proc = find_winproc( func, unicode )))
156 {
157 if (winproc_used < MAX_WINPROCS)
158 {
159 proc = &winproc_array[winproc_used++];
160 if (unicode) proc->procW = func;
161 else proc->procA = func;
162 TRACE( "allocated %p for %c %p (%d/%d used)\n",
163 proc_to_handle(proc), unicode ? 'W' : 'A', func,
164 winproc_used, MAX_WINPROCS );
165 }
166 else FIXME( "too many winprocs, cannot allocate one for %p\n", func );
167 }
168 else TRACE( "reusing %p for %p\n", proc_to_handle(proc), func );
169
170 LeaveCriticalSection( &winproc_cs );
171 return proc;
172 }
173
174 #ifdef __i386__
175 /* Some window procedures modify register they shouldn't, or are not
176 * properly declared stdcall; so we need a small assembly wrapper to
177 * call them. */
178 extern LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
179 WPARAM wParam, LPARAM lParam );
180 __ASM_GLOBAL_FUNC( WINPROC_wrapper,
181 "pushl %ebp\n\t"
182 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
183 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
184 "movl %esp,%ebp\n\t"
185 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
186 "pushl %edi\n\t"
187 __ASM_CFI(".cfi_rel_offset %edi,-4\n\t")
188 "pushl %esi\n\t"
189 __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
190 "pushl %ebx\n\t"
191 __ASM_CFI(".cfi_rel_offset %ebx,-12\n\t")
192 "subl $12,%esp\n\t"
193 "pushl 24(%ebp)\n\t"
194 "pushl 20(%ebp)\n\t"
195 "pushl 16(%ebp)\n\t"
196 "pushl 12(%ebp)\n\t"
197 "movl 8(%ebp),%eax\n\t"
198 "call *%eax\n\t"
199 "leal -12(%ebp),%esp\n\t"
200 "popl %ebx\n\t"
201 __ASM_CFI(".cfi_same_value %ebx\n\t")
202 "popl %esi\n\t"
203 __ASM_CFI(".cfi_same_value %esi\n\t")
204 "popl %edi\n\t"
205 __ASM_CFI(".cfi_same_value %edi\n\t")
206 "leave\n\t"
207 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
208 __ASM_CFI(".cfi_same_value %ebp\n\t")
209 "ret" )
210 #else
211 static inline LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
212 WPARAM wParam, LPARAM lParam )
213 {
214 return proc( hwnd, msg, wParam, lParam );
215 }
216 #endif /* __i386__ */
217
218 static WPARAM map_wparam_char_WtoA( WPARAM wParam, DWORD len )
219 {
220 WCHAR wch = wParam;
221 BYTE ch[2];
222
223 RtlUnicodeToMultiByteN( (LPSTR)ch, len, &len, &wch, sizeof(wch) );
224 if (len == 2)
225 return MAKEWPARAM( (ch[0] << 8) | ch[1], HIWORD(wParam) );
226 else
227 return MAKEWPARAM( ch[0], HIWORD(wParam) );
228 }
229
230 /* call a 32-bit window procedure */
231 static LRESULT call_window_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result, void *arg )
232 {
233 WNDPROC proc = arg;
234
235 USER_CheckNotLock();
236
237 hwnd = WIN_GetFullHandle( hwnd );
238 if (TRACE_ON(relay))
239 DPRINTF( "%04x:Call window proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
240 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp );
241
242 *result = WINPROC_wrapper( proc, hwnd, msg, wp, lp );
243
244 if (TRACE_ON(relay))
245 DPRINTF( "%04x:Ret window proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx) retval=%08lx\n",
246 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp, *result );
247 return *result;
248 }
249
250 /* call a 32-bit dialog procedure */
251 static LRESULT call_dialog_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result, void *arg )
252 {
253 WNDPROC proc = arg;
254 LRESULT ret;
255
256 USER_CheckNotLock();
257
258 hwnd = WIN_GetFullHandle( hwnd );
259 if (TRACE_ON(relay))
260 DPRINTF( "%04x:Call dialog proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
261 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp );
262
263 ret = WINPROC_wrapper( proc, hwnd, msg, wp, lp );
264 *result = GetWindowLongPtrW( hwnd, DWLP_MSGRESULT );
265
266 if (TRACE_ON(relay))
267 DPRINTF( "%04x:Ret dialog proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx) retval=%08lx result=%08lx\n",
268 GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp, ret, *result );
269 return ret;
270 }
271
272
273 /**********************************************************************
274 * WINPROC_GetProc
275 *
276 * Get a window procedure pointer that can be passed to the Windows program.
277 */
278 WNDPROC WINPROC_GetProc( WNDPROC proc, BOOL unicode )
279 {
280 WINDOWPROC *ptr = handle_to_proc( proc );
281
282 if (!ptr || ptr == WINPROC_PROC16) return proc;
283 if (unicode)
284 {
285 if (ptr->procW) return ptr->procW;
286 return proc;
287 }
288 else
289 {
290 if (ptr->procA) return ptr->procA;
291 return proc;
292 }
293 }
294
295
296 /**********************************************************************
297 * WINPROC_AllocProc
298 *
299 * Allocate a window procedure for a window or class.
300 *
301 * Note that allocated winprocs are never freed; the idea is that even if an app creates a
302 * lot of windows, it will usually only have a limited number of window procedures, so the
303 * array won't grow too large, and this way we avoid the need to track allocations per window.
304 */
305 WNDPROC WINPROC_AllocProc( WNDPROC func, BOOL unicode )
306 {
307 WINDOWPROC *proc;
308
309 if (!(proc = alloc_winproc( func, unicode ))) return NULL;
310 if (proc == WINPROC_PROC16) return func;
311 return proc_to_handle( proc );
312 }
313
314
315 /**********************************************************************
316 * WINPROC_IsUnicode
317 *
318 * Return the window procedure type, or the default value if not a winproc handle.
319 */
320 BOOL WINPROC_IsUnicode( WNDPROC proc, BOOL def_val )
321 {
322 WINDOWPROC *ptr = handle_to_proc( proc );
323
324 if (!ptr) return def_val;
325 if (ptr == WINPROC_PROC16) return FALSE; /* 16-bit is always A */
326 if (ptr->procA && ptr->procW) return def_val; /* can be both */
327 return (ptr->procW != NULL);
328 }
329
330
331 /**********************************************************************
332 * WINPROC_TestLBForStr
333 *
334 * Return TRUE if the lparam is a string
335 */
336 static inline BOOL WINPROC_TestLBForStr( HWND hwnd, UINT msg )
337 {
338 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
339 if (msg <= CB_MSGMAX)
340 return (!(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) || (style & CBS_HASSTRINGS));
341 else
342 return (!(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) || (style & LBS_HASSTRINGS));
343
344 }
345
346
347 /**********************************************************************
348 * WINPROC_CallProcAtoW
349 *
350 * Call a window procedure, translating args from Ansi to Unicode.
351 */
352 LRESULT WINPROC_CallProcAtoW( winproc_callback_t callback, HWND hwnd, UINT msg, WPARAM wParam,
353 LPARAM lParam, LRESULT *result, void *arg, enum wm_char_mapping mapping )
354 {
355 LRESULT ret = 0;
356
357 TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
358 hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
359
360 switch(msg)
361 {
362 case WM_NCCREATE:
363 case WM_CREATE:
364 {
365 WCHAR *ptr, buffer[512];
366 CREATESTRUCTA *csA = (CREATESTRUCTA *)lParam;
367 CREATESTRUCTW csW = *(CREATESTRUCTW *)csA;
368 MDICREATESTRUCTW mdi_cs;
369 DWORD name_lenA = 0, name_lenW = 0, class_lenA = 0, class_lenW = 0;
370
371 if (!IS_INTRESOURCE(csA->lpszClass))
372 {
373 class_lenA = strlen(csA->lpszClass) + 1;
374 RtlMultiByteToUnicodeSize( &class_lenW, csA->lpszClass, class_lenA );
375 }
376 if (!IS_INTRESOURCE(csA->lpszName))
377 {
378 name_lenA = strlen(csA->lpszName) + 1;
379 RtlMultiByteToUnicodeSize( &name_lenW, csA->lpszName, name_lenA );
380 }
381
382 if (!(ptr = get_buffer( buffer, sizeof(buffer), class_lenW + name_lenW ))) break;
383
384 if (class_lenW)
385 {
386 csW.lpszClass = ptr;
387 RtlMultiByteToUnicodeN( ptr, class_lenW, NULL, csA->lpszClass, class_lenA );
388 }
389 if (name_lenW)
390 {
391 csW.lpszName = ptr + class_lenW/sizeof(WCHAR);
392 RtlMultiByteToUnicodeN( ptr + class_lenW/sizeof(WCHAR), name_lenW, NULL,
393 csA->lpszName, name_lenA );
394 }
395
396 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
397 {
398 mdi_cs = *(MDICREATESTRUCTW *)csA->lpCreateParams;
399 mdi_cs.szTitle = csW.lpszName;
400 mdi_cs.szClass = csW.lpszClass;
401 csW.lpCreateParams = &mdi_cs;
402 }
403
404 ret = callback( hwnd, msg, wParam, (LPARAM)&csW, result, arg );
405 free_buffer( buffer, ptr );
406 }
407 break;
408
409 case WM_MDICREATE:
410 {
411 WCHAR *ptr, buffer[512];
412 DWORD title_lenA = 0, title_lenW = 0, class_lenA = 0, class_lenW = 0;
413 MDICREATESTRUCTA *csA = (MDICREATESTRUCTA *)lParam;
414 MDICREATESTRUCTW csW;
415
416 memcpy( &csW, csA, sizeof(csW) );
417
418 if (!IS_INTRESOURCE(csA->szTitle))
419 {
420 title_lenA = strlen(csA->szTitle) + 1;
421 RtlMultiByteToUnicodeSize( &title_lenW, csA->szTitle, title_lenA );
422 }
423 if (!IS_INTRESOURCE(csA->szClass))
424 {
425 class_lenA = strlen(csA->szClass) + 1;
426 RtlMultiByteToUnicodeSize( &class_lenW, csA->szClass, class_lenA );
427 }
428
429 if (!(ptr = get_buffer( buffer, sizeof(buffer), title_lenW + class_lenW ))) break;
430
431 if (title_lenW)
432 {
433 csW.szTitle = ptr;
434 RtlMultiByteToUnicodeN( ptr, title_lenW, NULL, csA->szTitle, title_lenA );
435 }
436 if (class_lenW)
437 {
438 csW.szClass = ptr + title_lenW/sizeof(WCHAR);
439 RtlMultiByteToUnicodeN( ptr + title_lenW/sizeof(WCHAR), class_lenW, NULL,
440 csA->szClass, class_lenA );
441 }
442 ret = callback( hwnd, msg, wParam, (LPARAM)&csW, result, arg );
443 free_buffer( buffer, ptr );
444 }
445 break;
446
447 case WM_GETTEXT:
448 case WM_ASKCBFORMATNAME:
449 {
450 WCHAR *ptr, buffer[512];
451 LPSTR str = (LPSTR)lParam;
452 DWORD len = wParam * sizeof(WCHAR);
453
454 if (!(ptr = get_buffer( buffer, sizeof(buffer), len ))) break;
455 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
456 if (wParam)
457 {
458 len = 0;
459 if (*result)
460 RtlUnicodeToMultiByteN( str, wParam - 1, &len, ptr, strlenW(ptr) * sizeof(WCHAR) );
461 str[len] = 0;
462 *result = len;
463 }
464 free_buffer( buffer, ptr );
465 }
466 break;
467
468 case LB_ADDSTRING:
469 case LB_INSERTSTRING:
470 case LB_FINDSTRING:
471 case LB_FINDSTRINGEXACT:
472 case LB_SELECTSTRING:
473 case CB_ADDSTRING:
474 case CB_INSERTSTRING:
475 case CB_FINDSTRING:
476 case CB_FINDSTRINGEXACT:
477 case CB_SELECTSTRING:
478 if (!lParam || !WINPROC_TestLBForStr( hwnd, msg ))
479 {
480 ret = callback( hwnd, msg, wParam, lParam, result, arg );
481 break;
482 }
483 /* fall through */
484 case WM_SETTEXT:
485 case WM_WININICHANGE:
486 case WM_DEVMODECHANGE:
487 case CB_DIR:
488 case LB_DIR:
489 case LB_ADDFILE:
490 case EM_REPLACESEL:
491 if (!lParam) ret = callback( hwnd, msg, wParam, lParam, result, arg );
492 else
493 {
494 WCHAR *ptr, buffer[512];
495 LPCSTR strA = (LPCSTR)lParam;
496 DWORD lenW, lenA = strlen(strA) + 1;
497
498 RtlMultiByteToUnicodeSize( &lenW, strA, lenA );
499 if ((ptr = get_buffer( buffer, sizeof(buffer), lenW )))
500 {
501 RtlMultiByteToUnicodeN( ptr, lenW, NULL, strA, lenA );
502 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
503 free_buffer( buffer, ptr );
504 }
505 }
506 break;
507
508 case LB_GETTEXT:
509 case CB_GETLBTEXT:
510 if (lParam && WINPROC_TestLBForStr( hwnd, msg ))
511 {
512 WCHAR buffer[512]; /* FIXME: fixed sized buffer */
513
514 ret = callback( hwnd, msg, wParam, (LPARAM)buffer, result, arg );
515 if (*result >= 0)
516 {
517 DWORD len;
518 RtlUnicodeToMultiByteN( (LPSTR)lParam, ~0u, &len,
519 buffer, (strlenW(buffer) + 1) * sizeof(WCHAR) );
520 *result = len - 1;
521 }
522 }
523 else ret = callback( hwnd, msg, wParam, lParam, result, arg );
524 break;
525
526 case EM_GETLINE:
527 {
528 WCHAR *ptr, buffer[512];
529 WORD len = *(WORD *)lParam;
530
531 if (!(ptr = get_buffer( buffer, sizeof(buffer), len * sizeof(WCHAR) ))) break;
532 *((WORD *)ptr) = len; /* store the length */
533 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
534 if (*result)
535 {
536 DWORD reslen;
537 RtlUnicodeToMultiByteN( (LPSTR)lParam, len, &reslen, ptr, *result * sizeof(WCHAR) );
538 if (reslen < len) ((LPSTR)lParam)[reslen] = 0;
539 *result = reslen;
540 }
541 free_buffer( buffer, ptr );
542 }
543 break;
544
545 case WM_GETDLGCODE:
546 if (lParam)
547 {
548 MSG newmsg = *(MSG *)lParam;
549 if (map_wparam_AtoW( newmsg.message, &newmsg.wParam, WMCHAR_MAP_NOMAPPING ))
550 ret = callback( hwnd, msg, wParam, (LPARAM)&newmsg, result, arg );
551 }
552 else ret = callback( hwnd, msg, wParam, lParam, result, arg );
553 break;
554
555 case WM_CHARTOITEM:
556 case WM_MENUCHAR:
557 case WM_CHAR:
558 case WM_DEADCHAR:
559 case WM_SYSCHAR:
560 case WM_SYSDEADCHAR:
561 case EM_SETPASSWORDCHAR:
562 case WM_IME_CHAR:
563 if (map_wparam_AtoW( msg, &wParam, mapping ))
564 ret = callback( hwnd, msg, wParam, lParam, result, arg );
565 break;
566
567 case WM_GETTEXTLENGTH:
568 case CB_GETLBTEXTLEN:
569 case LB_GETTEXTLEN:
570 ret = callback( hwnd, msg, wParam, lParam, result, arg );
571 if (*result >= 0)
572 {
573 WCHAR *ptr, buffer[512];
574 LRESULT tmp;
575 DWORD len = *result + 1;
576 /* Determine respective GETTEXT message */
577 UINT msgGetText = (msg == WM_GETTEXTLENGTH) ? WM_GETTEXT :
578 ((msg == CB_GETLBTEXTLEN) ? CB_GETLBTEXT : LB_GETTEXT);
579 /* wParam differs between the messages */
580 WPARAM wp = (msg == WM_GETTEXTLENGTH) ? len : wParam;
581
582 if (!(ptr = get_buffer( buffer, sizeof(buffer), len * sizeof(WCHAR) ))) break;
583
584 if (callback == call_window_proc) /* FIXME: hack */
585 callback( hwnd, msgGetText, wp, (LPARAM)ptr, &tmp, arg );
586 else
587 tmp = SendMessageW( hwnd, msgGetText, wp, (LPARAM)ptr );
588 RtlUnicodeToMultiByteSize( &len, ptr, tmp * sizeof(WCHAR) );
589 *result = len;
590 free_buffer( buffer, ptr );
591 }
592 break;
593
594 case WM_PAINTCLIPBOARD:
595 case WM_SIZECLIPBOARD:
596 FIXME_(msg)( "message %s (0x%x) needs translation, please report\n",
597 SPY_GetMsgName(msg, hwnd), msg );
598 break;
599
600 default:
601 ret = callback( hwnd, msg, wParam, lParam, result, arg );
602 break;
603 }
604 return ret;
605 }
606
607
608 /**********************************************************************
609 * WINPROC_CallProcWtoA
610 *
611 * Call a window procedure, translating args from Unicode to Ansi.
612 */
613 static LRESULT WINPROC_CallProcWtoA( winproc_callback_t callback, HWND hwnd, UINT msg, WPARAM wParam,
614 LPARAM lParam, LRESULT *result, void *arg )
615 {
616 LRESULT ret = 0;
617
618 TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
619 hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
620
621 switch(msg)
622 {
623 case WM_NCCREATE:
624 case WM_CREATE:
625 {
626 char buffer[1024], *cls;
627 CREATESTRUCTW *csW = (CREATESTRUCTW *)lParam;
628 CREATESTRUCTA csA = *(CREATESTRUCTA *)csW;
629 MDICREATESTRUCTA mdi_cs;
630 DWORD name_lenA = 0, name_lenW = 0, class_lenA = 0, class_lenW = 0;
631
632 if (!IS_INTRESOURCE(csW->lpszClass))
633 {
634 class_lenW = (strlenW(csW->lpszClass) + 1) * sizeof(WCHAR);
635 RtlUnicodeToMultiByteSize(&class_lenA, csW->lpszClass, class_lenW);
636 }
637 if (!IS_INTRESOURCE(csW->lpszName))
638 {
639 name_lenW = (strlenW(csW->lpszName) + 1) * sizeof(WCHAR);
640 RtlUnicodeToMultiByteSize(&name_lenA, csW->lpszName, name_lenW);
641 }
642
643 if (!(cls = get_buffer( buffer, sizeof(buffer), class_lenA + name_lenA ))) break;
644
645 if (class_lenA)
646 {
647 RtlUnicodeToMultiByteN(cls, class_lenA, NULL, csW->lpszClass, class_lenW);
648 csA.lpszClass = cls;
649 }
650 if (name_lenA)
651 {
652 char *name = cls + class_lenA;
653 RtlUnicodeToMultiByteN(name, name_lenA, NULL, csW->lpszName, name_lenW);
654 csA.lpszName = name;
655 }
656
657 if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
658 {
659 mdi_cs = *(MDICREATESTRUCTA *)csW->lpCreateParams;
660 mdi_cs.szTitle = csA.lpszName;
661 mdi_cs.szClass = csA.lpszClass;
662 csA.lpCreateParams = &mdi_cs;
663 }
664
665 ret = callback( hwnd, msg, wParam, (LPARAM)&csA, result, arg );
666 free_buffer( buffer, cls );
667 }
668 break;
669
670 case WM_GETTEXT:
671 case WM_ASKCBFORMATNAME:
672 {
673 char *ptr, buffer[512];
674 DWORD len = wParam * 2;
675
676 if (!(ptr = get_buffer( buffer, sizeof(buffer), len ))) break;
677 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
678 if (len)
679 {
680 if (*result)
681 {
682 RtlMultiByteToUnicodeN( (LPWSTR)lParam, wParam*sizeof(WCHAR), &len, ptr, strlen(ptr)+1 );
683 *result = len/sizeof(WCHAR) - 1; /* do not count terminating null */
684 }
685 ((LPWSTR)lParam)[*result] = 0;
686 }
687 free_buffer( buffer, ptr );
688 }
689 break;
690
691 case LB_ADDSTRING:
692 case LB_INSERTSTRING:
693 case LB_FINDSTRING:
694 case LB_FINDSTRINGEXACT:
695 case LB_SELECTSTRING:
696 case CB_ADDSTRING:
697 case CB_INSERTSTRING:
698 case CB_FINDSTRING:
699 case CB_FINDSTRINGEXACT:
700 case CB_SELECTSTRING:
701 if (!lParam || !WINPROC_TestLBForStr( hwnd, msg ))
702 {
703 ret = callback( hwnd, msg, wParam, lParam, result, arg );
704 break;
705 }
706 /* fall through */
707 case WM_SETTEXT:
708 case WM_WININICHANGE:
709 case WM_DEVMODECHANGE:
710 case CB_DIR:
711 case LB_DIR:
712 case LB_ADDFILE:
713 case EM_REPLACESEL:
714 if (!lParam) ret = callback( hwnd, msg, wParam, lParam, result, arg );
715 else
716 {
717 char *ptr, buffer[512];
718 LPCWSTR strW = (LPCWSTR)lParam;
719 DWORD lenA, lenW = (strlenW(strW) + 1) * sizeof(WCHAR);
720
721 RtlUnicodeToMultiByteSize( &lenA, strW, lenW );
722 if ((ptr = get_buffer( buffer, sizeof(buffer), lenA )))
723 {
724 RtlUnicodeToMultiByteN( ptr, lenA, NULL, strW, lenW );
725 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
726 free_buffer( buffer, ptr );
727 }
728 }
729 break;
730
731 case WM_MDICREATE:
732 {
733 char *ptr, buffer[1024];
734 DWORD title_lenA = 0, title_lenW = 0, class_lenA = 0, class_lenW = 0;
735 MDICREATESTRUCTW *csW = (MDICREATESTRUCTW *)lParam;
736 MDICREATESTRUCTA csA;
737
738 memcpy( &csA, csW, sizeof(csA) );
739
740 if (!IS_INTRESOURCE(csW->szTitle))
741 {
742 title_lenW = (strlenW(csW->szTitle) + 1) * sizeof(WCHAR);
743 RtlUnicodeToMultiByteSize( &title_lenA, csW->szTitle, title_lenW );
744 }
745 if (!IS_INTRESOURCE(csW->szClass))
746 {
747 class_lenW = (strlenW(csW->szClass) + 1) * sizeof(WCHAR);
748 RtlUnicodeToMultiByteSize( &class_lenA, csW->szClass, class_lenW );
749 }
750
751 if (!(ptr = get_buffer( buffer, sizeof(buffer), title_lenA + class_lenA ))) break;
752
753 if (title_lenA)
754 {
755 RtlUnicodeToMultiByteN( ptr, title_lenA, NULL, csW->szTitle, title_lenW );
756 csA.szTitle = ptr;
757 }
758 if (class_lenA)
759 {
760 RtlUnicodeToMultiByteN( ptr + title_lenA, class_lenA, NULL, csW->szClass, class_lenW );
761 csA.szClass = ptr + title_lenA;
762 }
763 ret = callback( hwnd, msg, wParam, (LPARAM)&csA, result, arg );
764 free_buffer( buffer, ptr );
765 }
766 break;
767
768 case LB_GETTEXT:
769 case CB_GETLBTEXT:
770 if (lParam && WINPROC_TestLBForStr( hwnd, msg ))
771 {
772 char buffer[512]; /* FIXME: fixed sized buffer */
773
774 ret = callback( hwnd, msg, wParam, (LPARAM)buffer, result, arg );
775 if (*result >= 0)
776 {
777 DWORD len;
778 RtlMultiByteToUnicodeN( (LPWSTR)lParam, ~0u, &len, buffer, strlen(buffer) + 1 );
779 *result = len / sizeof(WCHAR) - 1;
780 }
781 }
782 else ret = callback( hwnd, msg, wParam, lParam, result, arg );
783 break;
784
785 case EM_GETLINE:
786 {
787 char *ptr, buffer[512];
788 WORD len = *(WORD *)lParam;
789
790 if (!(ptr = get_buffer( buffer, sizeof(buffer), len * 2 ))) break;
791 *((WORD *)ptr) = len * 2; /* store the length */
792 ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
793 if (*result)
794 {
795 DWORD reslen;
796 RtlMultiByteToUnicodeN( (LPWSTR)lParam, len*sizeof(WCHAR), &reslen, ptr, *result );
797 *result = reslen / sizeof(WCHAR);
798 if (*result < len) ((LPWSTR)lParam)[*result] = 0;
799 }
800 free_buffer( buffer, ptr );
801 }
802 break;
803
804 case WM_GETDLGCODE:
805 if (lParam)
806 {
807 MSG newmsg = *(MSG *)lParam;
808 switch(newmsg.message)
809 {
810 case WM_CHAR:
811 case WM_DEADCHAR:
812 case WM_SYSCHAR:
813 case WM_SYSDEADCHAR:
814 newmsg.wParam = map_wparam_char_WtoA( newmsg.wParam, 1 );
815 break;
816 case WM_IME_CHAR:
817 newmsg.wParam = map_wparam_char_WtoA( newmsg.wParam, 2 );
818 break;
819 }
820 ret = callback( hwnd, msg, wParam, (LPARAM)&newmsg, result, arg );
821 }
822 else ret = callback( hwnd, msg, wParam, lParam, result, arg );
823 break;
824
825 case WM_CHAR:
826 {
827 WCHAR wch = wParam;
828 char ch[2];
829 DWORD len;
830
831 RtlUnicodeToMultiByteN( ch, 2, &len, &wch, sizeof(wch) );
832 ret = callback( hwnd, msg, (BYTE)ch[0], lParam, result, arg );
833 if (len == 2) ret = callback( hwnd, msg, (BYTE)ch[1], lParam, result, arg );
834 }
835 break;
836
837 case WM_CHARTOITEM:
838 case WM_MENUCHAR:
839 case WM_DEADCHAR:
840 case WM_SYSCHAR:
841 case WM_SYSDEADCHAR:
842 case EM_SETPASSWORDCHAR:
843 ret = callback( hwnd, msg, map_wparam_char_WtoA(wParam,1), lParam, result, arg );
844 break;
845
846 case WM_IME_CHAR:
847 ret = callback( hwnd, msg, map_wparam_char_WtoA(wParam,2), lParam, result, arg );
848 break;
849
850 case WM_PAINTCLIPBOARD:
851 case WM_SIZECLIPBOARD:
852 FIXME_(msg)( "message %s (%04x) needs translation, please report\n",
853 SPY_GetMsgName(msg, hwnd), msg );
854 break;
855
856 default:
857 ret = callback( hwnd, msg, wParam, lParam, result, arg );
858 break;
859 }
860
861 return ret;
862 }
863
864
865 /**********************************************************************
866 * WINPROC_call_window
867 *
868 * Call the window procedure of the specified window.
869 */
870 BOOL WINPROC_call_window( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
871 LRESULT *result, BOOL unicode, enum wm_char_mapping mapping )
872 {
873 struct user_thread_info *thread_info = get_user_thread_info();
874 WND *wndPtr;
875 WNDPROC func;
876 WINDOWPROC *proc;
877
878 if (!(wndPtr = WIN_GetPtr( hwnd ))) return FALSE;
879 if (wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
880 if (wndPtr->tid != GetCurrentThreadId())
881 {
882 WIN_ReleasePtr( wndPtr );
883 return FALSE;
884 }
885 func = wndPtr->winproc;
886 proc = handle_to_proc( wndPtr->winproc );
887 WIN_ReleasePtr( wndPtr );
888
889 if (!proc) return TRUE;
890
891 if (thread_info->recursion_count > MAX_WINPROC_RECURSION) return FALSE;
892 thread_info->recursion_count++;
893
894 if (unicode)
895 {
896 if (proc == WINPROC_PROC16)
897 WINPROC_CallProcWtoA( wow_handlers.call_window_proc, hwnd, msg, wParam, lParam, result, func );
898 else if (proc->procW)
899 call_window_proc( hwnd, msg, wParam, lParam, result, proc->procW );
900 else
901 WINPROC_CallProcWtoA( call_window_proc, hwnd, msg, wParam, lParam, result, proc->procA );
902 }
903 else
904 {
905 if (proc == WINPROC_PROC16)
906 wow_handlers.call_window_proc( hwnd, msg, wParam, lParam, result, func );
907 else if (proc->procA)
908 call_window_proc( hwnd, msg, wParam, lParam, result, proc->procA );
909 else
910 WINPROC_CallProcAtoW( call_window_proc, hwnd, msg, wParam, lParam, result, proc->procW, mapping );
911 }
912 thread_info->recursion_count--;
913 return TRUE;
914 }
915
916
917 /**********************************************************************
918 * CallWindowProcA (USER32.@)
919 *
920 * The CallWindowProc() function invokes the windows procedure _func_,
921 * with _hwnd_ as the target window, the message specified by _msg_, and
922 * the message parameters _wParam_ and _lParam_.
923 *
924 * Some kinds of argument conversion may be done, I'm not sure what.
925 *
926 * CallWindowProc() may be used for windows subclassing. Use
927 * SetWindowLong() to set a new windows procedure for windows of the
928 * subclass, and handle subclassed messages in the new windows
929 * procedure. The new windows procedure may then use CallWindowProc()
930 * with _func_ set to the parent class's windows procedure to dispatch
931 * the message to the superclass.
932 *
933 * RETURNS
934 *
935 * The return value is message dependent.
936 *
937 * CONFORMANCE
938 *
939 * ECMA-234, Win32
940 */
941 LRESULT WINAPI CallWindowProcA(
942 WNDPROC func, /* [in] window procedure */
943 HWND hwnd, /* [in] target window */
944 UINT msg, /* [in] message */
945 WPARAM wParam, /* [in] message dependent parameter */
946 LPARAM lParam /* [in] message dependent parameter */
947 ) {
948 WINDOWPROC *proc;
949 LRESULT result;
950
951 if (!func) return 0;
952
953 if (!(proc = handle_to_proc( func )))
954 call_window_proc( hwnd, msg, wParam, lParam, &result, func );
955 else if (proc == WINPROC_PROC16)
956 wow_handlers.call_window_proc( hwnd, msg, wParam, lParam, &result, func );
957 else if (proc->procA)
958 call_window_proc( hwnd, msg, wParam, lParam, &result, proc->procA );
959 else
960 WINPROC_CallProcAtoW( call_window_proc, hwnd, msg, wParam, lParam, &result,
961 proc->procW, WMCHAR_MAP_CALLWINDOWPROC );
962 return result;
963 }
964
965
966 /**********************************************************************
967 * CallWindowProcW (USER32.@)
968 *
969 * See CallWindowProcA.
970 */
971 LRESULT WINAPI CallWindowProcW( WNDPROC func, HWND hwnd, UINT msg,
972 WPARAM wParam, LPARAM lParam )
973 {
974 WINDOWPROC *proc;
975 LRESULT result;
976
977 if (!func) return 0;
978
979 if (!(proc = handle_to_proc( func )))
980 call_window_proc( hwnd, msg, wParam, lParam, &result, func );
981 else if (proc == WINPROC_PROC16)
982 WINPROC_CallProcWtoA( wow_handlers.call_window_proc, hwnd, msg, wParam, lParam, &result, func );
983 else if (proc->procW)
984 call_window_proc( hwnd, msg, wParam, lParam, &result, proc->procW );
985 else
986 WINPROC_CallProcWtoA( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
987 return result;
988 }
989
990
991 /**********************************************************************
992 * WINPROC_CallDlgProcA
993 */
994 INT_PTR WINPROC_CallDlgProcA( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
995 {
996 WINDOWPROC *proc;
997 LRESULT result;
998 INT_PTR ret;
999
1000 if (!func) return 0;
1001
1002 if (!(proc = handle_to_proc( func )))
1003 ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
1004 else if (proc == WINPROC_PROC16)
1005 {
1006 ret = wow_handlers.call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
1007 SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
1008 }
1009 else if (proc->procW)
1010 {
1011 ret = WINPROC_CallProcAtoW( call_dialog_proc, hwnd, msg, wParam, lParam, &result,
1012 proc->procW, WMCHAR_MAP_CALLWINDOWPROC );
1013 SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
1014 }
1015 else
1016 ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, proc->procA );
1017 return ret;
1018 }
1019
1020
1021 /**********************************************************************
1022 * WINPROC_CallDlgProcW
1023 */
1024 INT_PTR WINPROC_CallDlgProcW( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1025 {
1026 WINDOWPROC *proc;
1027 LRESULT result;
1028 INT_PTR ret;
1029
1030 if (!func) return 0;
1031
1032 if (!(proc = handle_to_proc( func )))
1033 ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
1034 else if (proc == WINPROC_PROC16)
1035 {
1036 ret = WINPROC_CallProcWtoA( wow_handlers.call_dialog_proc, hwnd, msg, wParam, lParam, &result, func );
1037 SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
1038 }
1039 else if (proc->procA)
1040 {
1041 ret = WINPROC_CallProcWtoA( call_dialog_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
1042 SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
1043 }
1044 else
1045 ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, proc->procW );
1046 return ret;
1047 }
1048
1049
1050 /***********************************************************************
1051 * Window procedures for builtin classes
1052 */
1053
1054 static LRESULT WINAPI ButtonWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1055 {
1056 return wow_handlers.button_proc( hwnd, msg, wParam, lParam, FALSE );
1057 }
1058
1059 static LRESULT WINAPI ButtonWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1060 {
1061 return wow_handlers.button_proc( hwnd, msg, wParam, lParam, TRUE );
1062 }
1063
1064 static LRESULT WINAPI ComboWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
1065 {
1066 return wow_handlers.combo_proc( hwnd, message, wParam, lParam, FALSE );
1067 }
1068
1069 static LRESULT WINAPI ComboWndProcW( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
1070 {
1071 return wow_handlers.combo_proc( hwnd, message, wParam, lParam, TRUE );
1072 }
1073
1074 LRESULT WINAPI EditWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1075 {
1076 return wow_handlers.edit_proc( hwnd, msg, wParam, lParam, FALSE );
1077 }
1078
1079 static LRESULT WINAPI EditWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1080 {
1081 return wow_handlers.edit_proc( hwnd, msg, wParam, lParam, TRUE );
1082 }
1083
1084 static LRESULT WINAPI ListBoxWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1085 {
1086 return wow_handlers.listbox_proc( hwnd, msg, wParam, lParam, FALSE );
1087 }
1088
1089 static LRESULT WINAPI ListBoxWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1090 {
1091 return wow_handlers.listbox_proc( hwnd, msg, wParam, lParam, TRUE );
1092 }
1093
1094 static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1095 {
1096 return wow_handlers.mdiclient_proc( hwnd, msg, wParam, lParam, FALSE );
1097 }
1098
1099 static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1100 {
1101 return wow_handlers.mdiclient_proc( hwnd, msg, wParam, lParam, TRUE );
1102 }
1103
1104 static LRESULT WINAPI ScrollBarWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1105 {
1106 return wow_handlers.scrollbar_proc( hwnd, msg, wParam, lParam, FALSE );
1107 }
1108
1109 static LRESULT WINAPI ScrollBarWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1110 {
1111 return wow_handlers.scrollbar_proc( hwnd, msg, wParam, lParam, TRUE );
1112 }
1113
1114 static LRESULT WINAPI StaticWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1115 {
1116 return wow_handlers.static_proc( hwnd, msg, wParam, lParam, FALSE );
1117 }
1118
1119 static LRESULT WINAPI StaticWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1120 {
1121 return wow_handlers.static_proc( hwnd, msg, wParam, lParam, TRUE );
1122 }
1123
1124 static DWORD wait_message( DWORD count, CONST HANDLE *handles, DWORD timeout, DWORD mask, DWORD flags )
1125 {
1126 DWORD ret = USER_Driver->pMsgWaitForMultipleObjectsEx( count, handles, timeout, mask, flags );
1127 if (ret == WAIT_TIMEOUT && !count && !timeout) NtYieldExecution();
1128 return ret;
1129 }
1130
1131 /**********************************************************************
1132 * UserRegisterWowHandlers (USER32.@)
1133 *
1134 * NOTE: no attempt has been made to be compatible here,
1135 * the Windows function is most likely completely different.
1136 */
1137 void WINAPI UserRegisterWowHandlers( const struct wow_handlers16 *new, struct wow_handlers32 *orig )
1138 {
1139 orig->button_proc = ButtonWndProc_common;
1140 orig->combo_proc = ComboWndProc_common;
1141 orig->edit_proc = EditWndProc_common;
1142 orig->listbox_proc = ListBoxWndProc_common;
1143 orig->mdiclient_proc = MDIClientWndProc_common;
1144 orig->scrollbar_proc = ScrollBarWndProc_common;
1145 orig->static_proc = StaticWndProc_common;
1146 orig->wait_message = wait_message;
1147 orig->create_window = WIN_CreateWindowEx;
1148 orig->get_win_handle = WIN_GetFullHandle;
1149 orig->alloc_winproc = WINPROC_AllocProc;
1150 orig->get_dialog_info = DIALOG_get_info;
1151 orig->dialog_box_loop = DIALOG_DoDialogBox;
1152 orig->get_icon_param = get_icon_param;
1153 orig->set_icon_param = set_icon_param;
1154
1155 wow_handlers = *new;
1156 }
1157
1158 struct wow_handlers16 wow_handlers =
1159 {
1160 ButtonWndProc_common,
1161 ComboWndProc_common,
1162 EditWndProc_common,
1163 ListBoxWndProc_common,
1164 MDIClientWndProc_common,
1165 ScrollBarWndProc_common,
1166 StaticWndProc_common,
1167 wait_message,
1168 WIN_CreateWindowEx,
1169 NULL, /* call_window_proc */
1170 NULL, /* call_dialog_proc */
1171 NULL, /* free_icon_param */
1172 };
Windows API implementation