shell32: Remove dead initialization (clang).
[wine] / dlls / user32 / winproc.c
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 };