2 * Window procedure callbacks
4 * Copyright 1995 Martin von Loewis
5 * Copyright 1996 Alexandre Julliard
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.
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.
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
23 #include "wine/port.h"
34 #include "user_private.h"
35 #include "wine/unicode.h"
36 #include "wine/debug.h"
38 WINE_DECLARE_DEBUG_CHANNEL(msg
);
39 WINE_DECLARE_DEBUG_CHANNEL(relay
);
40 WINE_DEFAULT_DEBUG_CHANNEL(win
);
42 typedef struct tagWINDOWPROC
44 WNDPROC procA
; /* ASCII window proc */
45 WNDPROC procW
; /* Unicode window proc */
48 #define MAX_WINPROCS 4096
49 #define MAX_WINPROC_RECURSION 64
50 #define WINPROC_PROC16 ((WINDOWPROC *)1) /* placeholder for 16-bit window procs */
52 static LRESULT WINAPI
ButtonWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
53 static LRESULT WINAPI
ButtonWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
54 static LRESULT WINAPI
ComboWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
55 static LRESULT WINAPI
ComboWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
56 LRESULT WINAPI
EditWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
57 static LRESULT WINAPI
EditWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
58 static LRESULT WINAPI
ListBoxWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
59 static LRESULT WINAPI
ListBoxWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
60 static LRESULT WINAPI
MDIClientWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
61 static LRESULT WINAPI
MDIClientWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
62 static LRESULT WINAPI
ScrollBarWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
63 static LRESULT WINAPI
ScrollBarWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
64 static LRESULT WINAPI
StaticWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
65 static LRESULT WINAPI
StaticWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
);
67 static WINDOWPROC winproc_array
[MAX_WINPROCS
] =
69 { ButtonWndProcA
, ButtonWndProcW
}, /* WINPROC_BUTTON */
70 { ComboWndProcA
, ComboWndProcW
}, /* WINPROC_COMBO */
71 { DefWindowProcA
, DefWindowProcW
}, /* WINPROC_DEFWND */
72 { DefDlgProcA
, DefDlgProcW
}, /* WINPROC_DIALOG */
73 { EditWndProcA
, EditWndProcW
}, /* WINPROC_EDIT */
74 { ListBoxWndProcA
, ListBoxWndProcW
}, /* WINPROC_LISTBOX */
75 { MDIClientWndProcA
, MDIClientWndProcW
}, /* WINPROC_MDICLIENT */
76 { ScrollBarWndProcA
, ScrollBarWndProcW
}, /* WINPROC_SCROLLBAR */
77 { StaticWndProcA
, StaticWndProcW
}, /* WINPROC_STATIC */
78 { ImeWndProcA
, ImeWndProcW
}, /* WINPROC_IME */
79 { NULL
, DesktopWndProc
}, /* WINPROC_DESKTOP */
80 { NULL
, IconTitleWndProc
}, /* WINPROC_ICONTITLE */
81 { NULL
, PopupMenuWndProc
}, /* WINPROC_MENU */
82 { NULL
, MessageWndProc
}, /* WINPROC_MESSAGE */
85 static UINT winproc_used
= NB_BUILTIN_WINPROCS
;
87 static CRITICAL_SECTION winproc_cs
;
88 static CRITICAL_SECTION_DEBUG critsect_debug
=
91 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
92 0, 0, { (DWORD_PTR
)(__FILE__
": winproc_cs") }
94 static CRITICAL_SECTION winproc_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
96 static inline void *get_buffer( void *static_buffer
, size_t size
, size_t need
)
98 if (size
>= need
) return static_buffer
;
99 return HeapAlloc( GetProcessHeap(), 0, need
);
102 static inline void free_buffer( void *static_buffer
, void *buffer
)
104 if (buffer
!= static_buffer
) HeapFree( GetProcessHeap(), 0, buffer
);
107 /* find an existing winproc for a given function and type */
108 /* FIXME: probably should do something more clever than a linear search */
109 static inline WINDOWPROC
*find_winproc( WNDPROC func
, BOOL unicode
)
113 for (i
= 0; i
< NB_BUILTIN_AW_WINPROCS
; i
++)
115 /* match either proc, some apps confuse A and W */
116 if (winproc_array
[i
].procA
!= func
&& winproc_array
[i
].procW
!= func
) continue;
117 return &winproc_array
[i
];
119 for (i
= NB_BUILTIN_AW_WINPROCS
; i
< winproc_used
; i
++)
121 if (!unicode
&& winproc_array
[i
].procA
!= func
) continue;
122 if (unicode
&& winproc_array
[i
].procW
!= func
) continue;
123 return &winproc_array
[i
];
128 /* return the window proc for a given handle, or NULL for an invalid handle,
129 * or WINPROC_PROC16 for a handle to a 16-bit proc. */
130 static inline WINDOWPROC
*handle_to_proc( WNDPROC handle
)
132 UINT index
= LOWORD(handle
);
133 if ((ULONG_PTR
)handle
>> 16 != WINPROC_HANDLE
) return NULL
;
134 if (index
>= MAX_WINPROCS
) return WINPROC_PROC16
;
135 if (index
>= winproc_used
) return NULL
;
136 return &winproc_array
[index
];
139 /* create a handle for a given window proc */
140 static inline WNDPROC
proc_to_handle( WINDOWPROC
*proc
)
142 return (WNDPROC
)(ULONG_PTR
)((proc
- winproc_array
) | (WINPROC_HANDLE
<< 16));
145 /* allocate and initialize a new winproc */
146 static inline WINDOWPROC
*alloc_winproc( WNDPROC func
, BOOL unicode
)
150 /* check if the function is already a win proc */
151 if (!func
) return NULL
;
152 if ((proc
= handle_to_proc( func
))) return proc
;
154 EnterCriticalSection( &winproc_cs
);
156 /* check if we already have a winproc for that function */
157 if (!(proc
= find_winproc( func
, unicode
)))
159 if (winproc_used
< MAX_WINPROCS
)
161 proc
= &winproc_array
[winproc_used
++];
162 if (unicode
) proc
->procW
= func
;
163 else proc
->procA
= func
;
164 TRACE( "allocated %p for %c %p (%d/%d used)\n",
165 proc_to_handle(proc
), unicode
? 'W' : 'A', func
,
166 winproc_used
, MAX_WINPROCS
);
168 else WARN( "too many winprocs, cannot allocate one for %p\n", func
);
170 else TRACE( "reusing %p for %p\n", proc_to_handle(proc
), func
);
172 LeaveCriticalSection( &winproc_cs
);
177 /* Some window procedures modify register they shouldn't, or are not
178 * properly declared stdcall; so we need a small assembly wrapper to
180 extern LRESULT
WINPROC_wrapper( WNDPROC proc
, HWND hwnd
, UINT msg
,
181 WPARAM wParam
, LPARAM lParam
);
182 __ASM_GLOBAL_FUNC( WINPROC_wrapper
,
184 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
185 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
187 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
189 __ASM_CFI(".cfi_rel_offset %edi,-4\n\t")
191 __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
193 __ASM_CFI(".cfi_rel_offset %ebx,-12\n\t")
199 "movl 8(%ebp),%eax\n\t"
201 "leal -12(%ebp),%esp\n\t"
203 __ASM_CFI(".cfi_same_value %ebx\n\t")
205 __ASM_CFI(".cfi_same_value %esi\n\t")
207 __ASM_CFI(".cfi_same_value %edi\n\t")
209 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
210 __ASM_CFI(".cfi_same_value %ebp\n\t")
213 static inline LRESULT
WINPROC_wrapper( WNDPROC proc
, HWND hwnd
, UINT msg
,
214 WPARAM wParam
, LPARAM lParam
)
216 return proc( hwnd
, msg
, wParam
, lParam
);
218 #endif /* __i386__ */
220 static WPARAM
map_wparam_char_WtoA( WPARAM wParam
, DWORD len
)
224 DWORD cp
= get_input_codepage();
226 len
= WideCharToMultiByte( cp
, 0, &wch
, 1, (LPSTR
)ch
, len
, NULL
, NULL
);
228 return MAKEWPARAM( (ch
[0] << 8) | ch
[1], HIWORD(wParam
) );
230 return MAKEWPARAM( ch
[0], HIWORD(wParam
) );
233 /* call a 32-bit window procedure */
234 static LRESULT
call_window_proc( HWND hwnd
, UINT msg
, WPARAM wp
, LPARAM lp
, LRESULT
*result
, void *arg
)
240 hwnd
= WIN_GetFullHandle( hwnd
);
242 DPRINTF( "%04x:Call window proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
243 GetCurrentThreadId(), proc
, hwnd
, SPY_GetMsgName(msg
, hwnd
), wp
, lp
);
245 *result
= WINPROC_wrapper( proc
, hwnd
, msg
, wp
, lp
);
248 DPRINTF( "%04x:Ret window proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx) retval=%08lx\n",
249 GetCurrentThreadId(), proc
, hwnd
, SPY_GetMsgName(msg
, hwnd
), wp
, lp
, *result
);
253 /* call a 32-bit dialog procedure */
254 static LRESULT
call_dialog_proc( HWND hwnd
, UINT msg
, WPARAM wp
, LPARAM lp
, LRESULT
*result
, void *arg
)
261 hwnd
= WIN_GetFullHandle( hwnd
);
263 DPRINTF( "%04x:Call dialog proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
264 GetCurrentThreadId(), proc
, hwnd
, SPY_GetMsgName(msg
, hwnd
), wp
, lp
);
266 ret
= WINPROC_wrapper( proc
, hwnd
, msg
, wp
, lp
);
267 *result
= GetWindowLongPtrW( hwnd
, DWLP_MSGRESULT
);
270 DPRINTF( "%04x:Ret dialog proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx) retval=%08lx result=%08lx\n",
271 GetCurrentThreadId(), proc
, hwnd
, SPY_GetMsgName(msg
, hwnd
), wp
, lp
, ret
, *result
);
276 /**********************************************************************
279 * Get a window procedure pointer that can be passed to the Windows program.
281 WNDPROC
WINPROC_GetProc( WNDPROC proc
, BOOL unicode
)
283 WINDOWPROC
*ptr
= handle_to_proc( proc
);
285 if (!ptr
|| ptr
== WINPROC_PROC16
) return proc
;
288 if (ptr
->procW
) return ptr
->procW
;
293 if (ptr
->procA
) return ptr
->procA
;
299 /**********************************************************************
302 * Allocate a window procedure for a window or class.
304 * Note that allocated winprocs are never freed; the idea is that even if an app creates a
305 * lot of windows, it will usually only have a limited number of window procedures, so the
306 * array won't grow too large, and this way we avoid the need to track allocations per window.
308 WNDPROC
WINPROC_AllocProc( WNDPROC func
, BOOL unicode
)
312 if (!(proc
= alloc_winproc( func
, unicode
))) return func
;
313 if (proc
== WINPROC_PROC16
) return func
;
314 return proc_to_handle( proc
);
318 /**********************************************************************
321 * Return the window procedure type, or the default value if not a winproc handle.
323 BOOL
WINPROC_IsUnicode( WNDPROC proc
, BOOL def_val
)
325 WINDOWPROC
*ptr
= handle_to_proc( proc
);
327 if (!ptr
) return def_val
;
328 if (ptr
== WINPROC_PROC16
) return FALSE
; /* 16-bit is always A */
329 if (ptr
->procA
&& ptr
->procW
) return def_val
; /* can be both */
330 return (ptr
->procW
!= NULL
);
334 /**********************************************************************
335 * WINPROC_TestLBForStr
337 * Return TRUE if the lparam is a string
339 static inline BOOL
WINPROC_TestLBForStr( HWND hwnd
, UINT msg
)
341 DWORD style
= GetWindowLongA( hwnd
, GWL_STYLE
);
342 if (msg
<= CB_MSGMAX
)
343 return (!(style
& (CBS_OWNERDRAWFIXED
| CBS_OWNERDRAWVARIABLE
)) || (style
& CBS_HASSTRINGS
));
345 return (!(style
& (LBS_OWNERDRAWFIXED
| LBS_OWNERDRAWVARIABLE
)) || (style
& LBS_HASSTRINGS
));
350 /**********************************************************************
351 * WINPROC_CallProcAtoW
353 * Call a window procedure, translating args from Ansi to Unicode.
355 LRESULT
WINPROC_CallProcAtoW( winproc_callback_t callback
, HWND hwnd
, UINT msg
, WPARAM wParam
,
356 LPARAM lParam
, LRESULT
*result
, void *arg
, enum wm_char_mapping mapping
)
360 TRACE_(msg
)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
361 hwnd
, SPY_GetMsgName(msg
, hwnd
), wParam
, lParam
);
368 WCHAR
*ptr
, buffer
[512];
369 CREATESTRUCTA
*csA
= (CREATESTRUCTA
*)lParam
;
370 CREATESTRUCTW csW
= *(CREATESTRUCTW
*)csA
;
371 MDICREATESTRUCTW mdi_cs
;
372 DWORD name_lenA
= 0, name_lenW
= 0, class_lenA
= 0, class_lenW
= 0;
374 if (!IS_INTRESOURCE(csA
->lpszClass
))
376 class_lenA
= strlen(csA
->lpszClass
) + 1;
377 RtlMultiByteToUnicodeSize( &class_lenW
, csA
->lpszClass
, class_lenA
);
379 if (!IS_INTRESOURCE(csA
->lpszName
))
381 name_lenA
= strlen(csA
->lpszName
) + 1;
382 RtlMultiByteToUnicodeSize( &name_lenW
, csA
->lpszName
, name_lenA
);
385 if (!(ptr
= get_buffer( buffer
, sizeof(buffer
), class_lenW
+ name_lenW
))) break;
390 RtlMultiByteToUnicodeN( ptr
, class_lenW
, NULL
, csA
->lpszClass
, class_lenA
);
394 csW
.lpszName
= ptr
+ class_lenW
/sizeof(WCHAR
);
395 RtlMultiByteToUnicodeN( ptr
+ class_lenW
/sizeof(WCHAR
), name_lenW
, NULL
,
396 csA
->lpszName
, name_lenA
);
399 if (GetWindowLongW(hwnd
, GWL_EXSTYLE
) & WS_EX_MDICHILD
)
401 mdi_cs
= *(MDICREATESTRUCTW
*)csA
->lpCreateParams
;
402 mdi_cs
.szTitle
= csW
.lpszName
;
403 mdi_cs
.szClass
= csW
.lpszClass
;
404 csW
.lpCreateParams
= &mdi_cs
;
407 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)&csW
, result
, arg
);
408 free_buffer( buffer
, ptr
);
414 WCHAR
*ptr
, buffer
[512];
415 DWORD title_lenA
= 0, title_lenW
= 0, class_lenA
= 0, class_lenW
= 0;
416 MDICREATESTRUCTA
*csA
= (MDICREATESTRUCTA
*)lParam
;
417 MDICREATESTRUCTW csW
;
419 memcpy( &csW
, csA
, sizeof(csW
) );
421 if (!IS_INTRESOURCE(csA
->szTitle
))
423 title_lenA
= strlen(csA
->szTitle
) + 1;
424 RtlMultiByteToUnicodeSize( &title_lenW
, csA
->szTitle
, title_lenA
);
426 if (!IS_INTRESOURCE(csA
->szClass
))
428 class_lenA
= strlen(csA
->szClass
) + 1;
429 RtlMultiByteToUnicodeSize( &class_lenW
, csA
->szClass
, class_lenA
);
432 if (!(ptr
= get_buffer( buffer
, sizeof(buffer
), title_lenW
+ class_lenW
))) break;
437 RtlMultiByteToUnicodeN( ptr
, title_lenW
, NULL
, csA
->szTitle
, title_lenA
);
441 csW
.szClass
= ptr
+ title_lenW
/sizeof(WCHAR
);
442 RtlMultiByteToUnicodeN( ptr
+ title_lenW
/sizeof(WCHAR
), class_lenW
, NULL
,
443 csA
->szClass
, class_lenA
);
445 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)&csW
, result
, arg
);
446 free_buffer( buffer
, ptr
);
451 case WM_ASKCBFORMATNAME
:
453 WCHAR
*ptr
, buffer
[512];
454 LPSTR str
= (LPSTR
)lParam
;
455 DWORD len
= wParam
* sizeof(WCHAR
);
457 if (!(ptr
= get_buffer( buffer
, sizeof(buffer
), len
))) break;
458 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)ptr
, result
, arg
);
463 RtlUnicodeToMultiByteN( str
, wParam
- 1, &len
, ptr
, strlenW(ptr
) * sizeof(WCHAR
) );
467 free_buffer( buffer
, ptr
);
472 case LB_INSERTSTRING
:
474 case LB_FINDSTRINGEXACT
:
475 case LB_SELECTSTRING
:
477 case CB_INSERTSTRING
:
479 case CB_FINDSTRINGEXACT
:
480 case CB_SELECTSTRING
:
481 if (!lParam
|| !WINPROC_TestLBForStr( hwnd
, msg
))
483 ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
488 case WM_WININICHANGE
:
489 case WM_DEVMODECHANGE
:
494 if (!lParam
) ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
497 WCHAR
*ptr
, buffer
[512];
498 LPCSTR strA
= (LPCSTR
)lParam
;
499 DWORD lenW
, lenA
= strlen(strA
) + 1;
501 RtlMultiByteToUnicodeSize( &lenW
, strA
, lenA
);
502 if ((ptr
= get_buffer( buffer
, sizeof(buffer
), lenW
)))
504 RtlMultiByteToUnicodeN( ptr
, lenW
, NULL
, strA
, lenA
);
505 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)ptr
, result
, arg
);
506 free_buffer( buffer
, ptr
);
513 if (lParam
&& WINPROC_TestLBForStr( hwnd
, msg
))
515 WCHAR buffer
[512]; /* FIXME: fixed sized buffer */
517 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)buffer
, result
, arg
);
521 RtlUnicodeToMultiByteN( (LPSTR
)lParam
, ~0u, &len
,
522 buffer
, (strlenW(buffer
) + 1) * sizeof(WCHAR
) );
526 else ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
531 WCHAR
*ptr
, buffer
[512];
532 WORD len
= *(WORD
*)lParam
;
534 if (!(ptr
= get_buffer( buffer
, sizeof(buffer
), len
* sizeof(WCHAR
) ))) break;
535 *((WORD
*)ptr
) = len
; /* store the length */
536 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)ptr
, result
, arg
);
540 RtlUnicodeToMultiByteN( (LPSTR
)lParam
, len
, &reslen
, ptr
, *result
* sizeof(WCHAR
) );
541 if (reslen
< len
) ((LPSTR
)lParam
)[reslen
] = 0;
544 free_buffer( buffer
, ptr
);
551 MSG newmsg
= *(MSG
*)lParam
;
552 if (map_wparam_AtoW( newmsg
.message
, &newmsg
.wParam
, WMCHAR_MAP_NOMAPPING
))
553 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)&newmsg
, result
, arg
);
555 else ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
564 case EM_SETPASSWORDCHAR
:
566 if (map_wparam_AtoW( msg
, &wParam
, mapping
))
567 ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
570 case WM_GETTEXTLENGTH
:
571 case CB_GETLBTEXTLEN
:
573 ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
576 WCHAR
*ptr
, buffer
[512];
578 DWORD len
= *result
+ 1;
579 /* Determine respective GETTEXT message */
580 UINT msgGetText
= (msg
== WM_GETTEXTLENGTH
) ? WM_GETTEXT
:
581 ((msg
== CB_GETLBTEXTLEN
) ? CB_GETLBTEXT
: LB_GETTEXT
);
582 /* wParam differs between the messages */
583 WPARAM wp
= (msg
== WM_GETTEXTLENGTH
) ? len
: wParam
;
585 if (!(ptr
= get_buffer( buffer
, sizeof(buffer
), len
* sizeof(WCHAR
) ))) break;
587 if (callback
== call_window_proc
) /* FIXME: hack */
588 callback( hwnd
, msgGetText
, wp
, (LPARAM
)ptr
, &tmp
, arg
);
590 tmp
= SendMessageW( hwnd
, msgGetText
, wp
, (LPARAM
)ptr
);
591 RtlUnicodeToMultiByteSize( &len
, ptr
, tmp
* sizeof(WCHAR
) );
593 free_buffer( buffer
, ptr
);
597 case WM_PAINTCLIPBOARD
:
598 case WM_SIZECLIPBOARD
:
599 FIXME_(msg
)( "message %s (0x%x) needs translation, please report\n",
600 SPY_GetMsgName(msg
, hwnd
), msg
);
604 ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
611 /**********************************************************************
612 * WINPROC_CallProcWtoA
614 * Call a window procedure, translating args from Unicode to Ansi.
616 static LRESULT
WINPROC_CallProcWtoA( winproc_callback_t callback
, HWND hwnd
, UINT msg
, WPARAM wParam
,
617 LPARAM lParam
, LRESULT
*result
, void *arg
)
621 TRACE_(msg
)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
622 hwnd
, SPY_GetMsgName(msg
, hwnd
), wParam
, lParam
);
629 char buffer
[1024], *cls
;
630 CREATESTRUCTW
*csW
= (CREATESTRUCTW
*)lParam
;
631 CREATESTRUCTA csA
= *(CREATESTRUCTA
*)csW
;
632 MDICREATESTRUCTA mdi_cs
;
633 DWORD name_lenA
= 0, name_lenW
= 0, class_lenA
= 0, class_lenW
= 0;
635 if (!IS_INTRESOURCE(csW
->lpszClass
))
637 class_lenW
= (strlenW(csW
->lpszClass
) + 1) * sizeof(WCHAR
);
638 RtlUnicodeToMultiByteSize(&class_lenA
, csW
->lpszClass
, class_lenW
);
640 if (!IS_INTRESOURCE(csW
->lpszName
))
642 name_lenW
= (strlenW(csW
->lpszName
) + 1) * sizeof(WCHAR
);
643 RtlUnicodeToMultiByteSize(&name_lenA
, csW
->lpszName
, name_lenW
);
646 if (!(cls
= get_buffer( buffer
, sizeof(buffer
), class_lenA
+ name_lenA
))) break;
650 RtlUnicodeToMultiByteN(cls
, class_lenA
, NULL
, csW
->lpszClass
, class_lenW
);
655 char *name
= cls
+ class_lenA
;
656 RtlUnicodeToMultiByteN(name
, name_lenA
, NULL
, csW
->lpszName
, name_lenW
);
660 if (GetWindowLongW(hwnd
, GWL_EXSTYLE
) & WS_EX_MDICHILD
)
662 mdi_cs
= *(MDICREATESTRUCTA
*)csW
->lpCreateParams
;
663 mdi_cs
.szTitle
= csA
.lpszName
;
664 mdi_cs
.szClass
= csA
.lpszClass
;
665 csA
.lpCreateParams
= &mdi_cs
;
668 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)&csA
, result
, arg
);
669 free_buffer( buffer
, cls
);
674 case WM_ASKCBFORMATNAME
:
676 char *ptr
, buffer
[512];
677 DWORD len
= wParam
* 2;
679 if (!(ptr
= get_buffer( buffer
, sizeof(buffer
), len
))) break;
680 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)ptr
, result
, arg
);
685 RtlMultiByteToUnicodeN( (LPWSTR
)lParam
, wParam
*sizeof(WCHAR
), &len
, ptr
, strlen(ptr
)+1 );
686 *result
= len
/sizeof(WCHAR
) - 1; /* do not count terminating null */
688 ((LPWSTR
)lParam
)[*result
] = 0;
690 free_buffer( buffer
, ptr
);
695 case LB_INSERTSTRING
:
697 case LB_FINDSTRINGEXACT
:
698 case LB_SELECTSTRING
:
700 case CB_INSERTSTRING
:
702 case CB_FINDSTRINGEXACT
:
703 case CB_SELECTSTRING
:
704 if (!lParam
|| !WINPROC_TestLBForStr( hwnd
, msg
))
706 ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
711 case WM_WININICHANGE
:
712 case WM_DEVMODECHANGE
:
717 if (!lParam
) ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
720 char *ptr
, buffer
[512];
721 LPCWSTR strW
= (LPCWSTR
)lParam
;
722 DWORD lenA
, lenW
= (strlenW(strW
) + 1) * sizeof(WCHAR
);
724 RtlUnicodeToMultiByteSize( &lenA
, strW
, lenW
);
725 if ((ptr
= get_buffer( buffer
, sizeof(buffer
), lenA
)))
727 RtlUnicodeToMultiByteN( ptr
, lenA
, NULL
, strW
, lenW
);
728 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)ptr
, result
, arg
);
729 free_buffer( buffer
, ptr
);
736 char *ptr
, buffer
[1024];
737 DWORD title_lenA
= 0, title_lenW
= 0, class_lenA
= 0, class_lenW
= 0;
738 MDICREATESTRUCTW
*csW
= (MDICREATESTRUCTW
*)lParam
;
739 MDICREATESTRUCTA csA
;
741 memcpy( &csA
, csW
, sizeof(csA
) );
743 if (!IS_INTRESOURCE(csW
->szTitle
))
745 title_lenW
= (strlenW(csW
->szTitle
) + 1) * sizeof(WCHAR
);
746 RtlUnicodeToMultiByteSize( &title_lenA
, csW
->szTitle
, title_lenW
);
748 if (!IS_INTRESOURCE(csW
->szClass
))
750 class_lenW
= (strlenW(csW
->szClass
) + 1) * sizeof(WCHAR
);
751 RtlUnicodeToMultiByteSize( &class_lenA
, csW
->szClass
, class_lenW
);
754 if (!(ptr
= get_buffer( buffer
, sizeof(buffer
), title_lenA
+ class_lenA
))) break;
758 RtlUnicodeToMultiByteN( ptr
, title_lenA
, NULL
, csW
->szTitle
, title_lenW
);
763 RtlUnicodeToMultiByteN( ptr
+ title_lenA
, class_lenA
, NULL
, csW
->szClass
, class_lenW
);
764 csA
.szClass
= ptr
+ title_lenA
;
766 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)&csA
, result
, arg
);
767 free_buffer( buffer
, ptr
);
773 if (lParam
&& WINPROC_TestLBForStr( hwnd
, msg
))
775 char buffer
[512]; /* FIXME: fixed sized buffer */
777 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)buffer
, result
, arg
);
781 RtlMultiByteToUnicodeN( (LPWSTR
)lParam
, ~0u, &len
, buffer
, strlen(buffer
) + 1 );
782 *result
= len
/ sizeof(WCHAR
) - 1;
785 else ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
790 char *ptr
, buffer
[512];
791 WORD len
= *(WORD
*)lParam
;
793 if (!(ptr
= get_buffer( buffer
, sizeof(buffer
), len
* 2 ))) break;
794 *((WORD
*)ptr
) = len
* 2; /* store the length */
795 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)ptr
, result
, arg
);
799 RtlMultiByteToUnicodeN( (LPWSTR
)lParam
, len
*sizeof(WCHAR
), &reslen
, ptr
, *result
);
800 *result
= reslen
/ sizeof(WCHAR
);
801 if (*result
< len
) ((LPWSTR
)lParam
)[*result
] = 0;
803 free_buffer( buffer
, ptr
);
810 MSG newmsg
= *(MSG
*)lParam
;
811 switch(newmsg
.message
)
817 newmsg
.wParam
= map_wparam_char_WtoA( newmsg
.wParam
, 1 );
820 newmsg
.wParam
= map_wparam_char_WtoA( newmsg
.wParam
, 2 );
823 ret
= callback( hwnd
, msg
, wParam
, (LPARAM
)&newmsg
, result
, arg
);
825 else ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
832 DWORD cp
= get_input_codepage();
833 DWORD len
= WideCharToMultiByte( cp
, 0, &wch
, 1, ch
, 2, NULL
, NULL
);
834 ret
= callback( hwnd
, msg
, (BYTE
)ch
[0], lParam
, result
, arg
);
835 if (len
== 2) ret
= callback( hwnd
, msg
, (BYTE
)ch
[1], lParam
, result
, arg
);
844 case EM_SETPASSWORDCHAR
:
845 ret
= callback( hwnd
, msg
, map_wparam_char_WtoA(wParam
,1), lParam
, result
, arg
);
849 ret
= callback( hwnd
, msg
, map_wparam_char_WtoA(wParam
,2), lParam
, result
, arg
);
852 case WM_PAINTCLIPBOARD
:
853 case WM_SIZECLIPBOARD
:
854 FIXME_(msg
)( "message %s (%04x) needs translation, please report\n",
855 SPY_GetMsgName(msg
, hwnd
), msg
);
859 ret
= callback( hwnd
, msg
, wParam
, lParam
, result
, arg
);
867 /**********************************************************************
868 * WINPROC_call_window
870 * Call the window procedure of the specified window.
872 BOOL
WINPROC_call_window( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
,
873 LRESULT
*result
, BOOL unicode
, enum wm_char_mapping mapping
)
875 struct user_thread_info
*thread_info
= get_user_thread_info();
881 if (!(wndPtr
= WIN_GetPtr( hwnd
))) return FALSE
;
882 if (wndPtr
== WND_OTHER_PROCESS
|| wndPtr
== WND_DESKTOP
) return FALSE
;
883 if (wndPtr
->tid
!= GetCurrentThreadId())
885 WIN_ReleasePtr( wndPtr
);
888 func
= wndPtr
->winproc
;
889 proc
= handle_to_proc( wndPtr
->winproc
);
890 unicode_win
= wndPtr
->flags
& WIN_ISUNICODE
;
891 WIN_ReleasePtr( wndPtr
);
893 if (thread_info
->recursion_count
> MAX_WINPROC_RECURSION
) return FALSE
;
894 thread_info
->recursion_count
++;
898 if (proc
== WINPROC_PROC16
)
899 WINPROC_CallProcWtoA( wow_handlers
.call_window_proc
, hwnd
, msg
, wParam
, lParam
, result
, func
);
900 else if (proc
&& proc
->procW
)
901 call_window_proc( hwnd
, msg
, wParam
, lParam
, result
, proc
->procW
);
903 WINPROC_CallProcWtoA( call_window_proc
, hwnd
, msg
, wParam
, lParam
, result
, proc
->procA
);
904 else if (unicode_win
)
905 call_window_proc( hwnd
, msg
, wParam
, lParam
, result
, func
);
907 WINPROC_CallProcWtoA( call_window_proc
, hwnd
, msg
, wParam
, lParam
, result
, func
);
911 if (proc
== WINPROC_PROC16
)
912 wow_handlers
.call_window_proc( hwnd
, msg
, wParam
, lParam
, result
, func
);
913 else if (proc
&& proc
->procA
)
914 call_window_proc( hwnd
, msg
, wParam
, lParam
, result
, proc
->procA
);
916 WINPROC_CallProcAtoW( call_window_proc
, hwnd
, msg
, wParam
, lParam
, result
, proc
->procW
, mapping
);
917 else if (unicode_win
)
918 WINPROC_CallProcAtoW( call_window_proc
, hwnd
, msg
, wParam
, lParam
, result
, func
, mapping
);
920 call_window_proc( hwnd
, msg
, wParam
, lParam
, result
, func
);
922 thread_info
->recursion_count
--;
927 /**********************************************************************
928 * CallWindowProcA (USER32.@)
930 * The CallWindowProc() function invokes the windows procedure _func_,
931 * with _hwnd_ as the target window, the message specified by _msg_, and
932 * the message parameters _wParam_ and _lParam_.
934 * Some kinds of argument conversion may be done, I'm not sure what.
936 * CallWindowProc() may be used for windows subclassing. Use
937 * SetWindowLong() to set a new windows procedure for windows of the
938 * subclass, and handle subclassed messages in the new windows
939 * procedure. The new windows procedure may then use CallWindowProc()
940 * with _func_ set to the parent class's windows procedure to dispatch
941 * the message to the superclass.
945 * The return value is message dependent.
951 LRESULT WINAPI
CallWindowProcA(
952 WNDPROC func
, /* [in] window procedure */
953 HWND hwnd
, /* [in] target window */
954 UINT msg
, /* [in] message */
955 WPARAM wParam
, /* [in] message dependent parameter */
956 LPARAM lParam
/* [in] message dependent parameter */
963 if (!(proc
= handle_to_proc( func
)))
964 call_window_proc( hwnd
, msg
, wParam
, lParam
, &result
, func
);
965 else if (proc
== WINPROC_PROC16
)
966 wow_handlers
.call_window_proc( hwnd
, msg
, wParam
, lParam
, &result
, func
);
967 else if (proc
->procA
)
968 call_window_proc( hwnd
, msg
, wParam
, lParam
, &result
, proc
->procA
);
970 WINPROC_CallProcAtoW( call_window_proc
, hwnd
, msg
, wParam
, lParam
, &result
,
971 proc
->procW
, WMCHAR_MAP_CALLWINDOWPROC
);
976 /**********************************************************************
977 * CallWindowProcW (USER32.@)
979 * See CallWindowProcA.
981 LRESULT WINAPI
CallWindowProcW( WNDPROC func
, HWND hwnd
, UINT msg
,
982 WPARAM wParam
, LPARAM lParam
)
989 if (!(proc
= handle_to_proc( func
)))
990 call_window_proc( hwnd
, msg
, wParam
, lParam
, &result
, func
);
991 else if (proc
== WINPROC_PROC16
)
992 WINPROC_CallProcWtoA( wow_handlers
.call_window_proc
, hwnd
, msg
, wParam
, lParam
, &result
, func
);
993 else if (proc
->procW
)
994 call_window_proc( hwnd
, msg
, wParam
, lParam
, &result
, proc
->procW
);
996 WINPROC_CallProcWtoA( call_window_proc
, hwnd
, msg
, wParam
, lParam
, &result
, proc
->procA
);
1001 /**********************************************************************
1002 * WINPROC_CallDlgProcA
1004 INT_PTR
WINPROC_CallDlgProcA( DLGPROC func
, HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1010 if (!func
) return 0;
1012 if (!(proc
= handle_to_proc( func
)))
1013 ret
= call_dialog_proc( hwnd
, msg
, wParam
, lParam
, &result
, func
);
1014 else if (proc
== WINPROC_PROC16
)
1016 ret
= wow_handlers
.call_dialog_proc( hwnd
, msg
, wParam
, lParam
, &result
, func
);
1017 SetWindowLongPtrW( hwnd
, DWLP_MSGRESULT
, result
);
1019 else if (proc
->procW
)
1021 ret
= WINPROC_CallProcAtoW( call_dialog_proc
, hwnd
, msg
, wParam
, lParam
, &result
,
1022 proc
->procW
, WMCHAR_MAP_CALLWINDOWPROC
);
1023 SetWindowLongPtrW( hwnd
, DWLP_MSGRESULT
, result
);
1026 ret
= call_dialog_proc( hwnd
, msg
, wParam
, lParam
, &result
, proc
->procA
);
1031 /**********************************************************************
1032 * WINPROC_CallDlgProcW
1034 INT_PTR
WINPROC_CallDlgProcW( DLGPROC func
, HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1040 if (!func
) return 0;
1042 if (!(proc
= handle_to_proc( func
)))
1043 ret
= call_dialog_proc( hwnd
, msg
, wParam
, lParam
, &result
, func
);
1044 else if (proc
== WINPROC_PROC16
)
1046 ret
= WINPROC_CallProcWtoA( wow_handlers
.call_dialog_proc
, hwnd
, msg
, wParam
, lParam
, &result
, func
);
1047 SetWindowLongPtrW( hwnd
, DWLP_MSGRESULT
, result
);
1049 else if (proc
->procA
)
1051 ret
= WINPROC_CallProcWtoA( call_dialog_proc
, hwnd
, msg
, wParam
, lParam
, &result
, proc
->procA
);
1052 SetWindowLongPtrW( hwnd
, DWLP_MSGRESULT
, result
);
1055 ret
= call_dialog_proc( hwnd
, msg
, wParam
, lParam
, &result
, proc
->procW
);
1060 /***********************************************************************
1061 * Window procedures for builtin classes
1064 static LRESULT WINAPI
ButtonWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1066 return wow_handlers
.button_proc( hwnd
, msg
, wParam
, lParam
, FALSE
);
1069 static LRESULT WINAPI
ButtonWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1071 return wow_handlers
.button_proc( hwnd
, msg
, wParam
, lParam
, TRUE
);
1074 static LRESULT WINAPI
ComboWndProcA( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
1076 return wow_handlers
.combo_proc( hwnd
, message
, wParam
, lParam
, FALSE
);
1079 static LRESULT WINAPI
ComboWndProcW( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
1081 return wow_handlers
.combo_proc( hwnd
, message
, wParam
, lParam
, TRUE
);
1084 LRESULT WINAPI
EditWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1086 return wow_handlers
.edit_proc( hwnd
, msg
, wParam
, lParam
, FALSE
);
1089 static LRESULT WINAPI
EditWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1091 return wow_handlers
.edit_proc( hwnd
, msg
, wParam
, lParam
, TRUE
);
1094 static LRESULT WINAPI
ListBoxWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1096 return wow_handlers
.listbox_proc( hwnd
, msg
, wParam
, lParam
, FALSE
);
1099 static LRESULT WINAPI
ListBoxWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1101 return wow_handlers
.listbox_proc( hwnd
, msg
, wParam
, lParam
, TRUE
);
1104 static LRESULT WINAPI
MDIClientWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1106 return wow_handlers
.mdiclient_proc( hwnd
, msg
, wParam
, lParam
, FALSE
);
1109 static LRESULT WINAPI
MDIClientWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1111 return wow_handlers
.mdiclient_proc( hwnd
, msg
, wParam
, lParam
, TRUE
);
1114 static LRESULT WINAPI
ScrollBarWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1116 return wow_handlers
.scrollbar_proc( hwnd
, msg
, wParam
, lParam
, FALSE
);
1119 static LRESULT WINAPI
ScrollBarWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1121 return wow_handlers
.scrollbar_proc( hwnd
, msg
, wParam
, lParam
, TRUE
);
1124 static LRESULT WINAPI
StaticWndProcA( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1126 return wow_handlers
.static_proc( hwnd
, msg
, wParam
, lParam
, FALSE
);
1129 static LRESULT WINAPI
StaticWndProcW( HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1131 return wow_handlers
.static_proc( hwnd
, msg
, wParam
, lParam
, TRUE
);
1134 static DWORD
wait_message( DWORD count
, const HANDLE
*handles
, DWORD timeout
, DWORD mask
, DWORD flags
)
1136 DWORD ret
= USER_Driver
->pMsgWaitForMultipleObjectsEx( count
, handles
, timeout
, mask
, flags
);
1137 if (ret
== WAIT_TIMEOUT
&& !count
&& !timeout
) NtYieldExecution();
1138 if ((mask
& QS_INPUT
) == QS_INPUT
) get_user_thread_info()->message_count
= 0;
1142 /**********************************************************************
1143 * UserRegisterWowHandlers (USER32.@)
1145 * NOTE: no attempt has been made to be compatible here,
1146 * the Windows function is most likely completely different.
1148 void WINAPI
UserRegisterWowHandlers( const struct wow_handlers16
*new, struct wow_handlers32
*orig
)
1150 orig
->button_proc
= ButtonWndProc_common
;
1151 orig
->combo_proc
= ComboWndProc_common
;
1152 orig
->edit_proc
= EditWndProc_common
;
1153 orig
->listbox_proc
= ListBoxWndProc_common
;
1154 orig
->mdiclient_proc
= MDIClientWndProc_common
;
1155 orig
->scrollbar_proc
= ScrollBarWndProc_common
;
1156 orig
->static_proc
= StaticWndProc_common
;
1157 orig
->wait_message
= wait_message
;
1158 orig
->create_window
= WIN_CreateWindowEx
;
1159 orig
->get_win_handle
= WIN_GetFullHandle
;
1160 orig
->alloc_winproc
= WINPROC_AllocProc
;
1161 orig
->get_dialog_info
= DIALOG_get_info
;
1162 orig
->dialog_box_loop
= DIALOG_DoDialogBox
;
1163 orig
->get_icon_param
= get_icon_param
;
1164 orig
->set_icon_param
= set_icon_param
;
1166 wow_handlers
= *new;
1169 struct wow_handlers16 wow_handlers
=
1171 ButtonWndProc_common
,
1172 ComboWndProc_common
,
1174 ListBoxWndProc_common
,
1175 MDIClientWndProc_common
,
1176 ScrollBarWndProc_common
,
1177 StaticWndProc_common
,
1180 NULL
, /* call_window_proc */
1181 NULL
, /* call_dialog_proc */
1182 NULL
, /* free_icon_param */