ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/user32/winproc.c

1177 lines
40 KiB
C
Raw Blame History

/*
* Window procedure callbacks
*
* Copyright 1995 Martin von Loewis
* Copyright 1996 Alexandre Julliard
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include "wine/port.h"
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "controls.h"
#include "win.h"
#include "user_private.h"
#include "wine/unicode.h"
#include "wine/debug.h"
WINE_DECLARE_DEBUG_CHANNEL(msg);
WINE_DECLARE_DEBUG_CHANNEL(relay);
WINE_DEFAULT_DEBUG_CHANNEL(win);
typedef struct tagWINDOWPROC
{
WNDPROC procA; /* ASCII window proc */
WNDPROC procW; /* Unicode window proc */
} WINDOWPROC;
#define MAX_WINPROCS 4096
#define MAX_WINPROC_RECURSION 64
#define WINPROC_PROC16 ((WINDOWPROC *)1) /* placeholder for 16-bit window procs */
static LRESULT WINAPI ButtonWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI ButtonWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI ComboWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI ComboWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
LRESULT WINAPI EditWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI EditWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI ListBoxWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI ListBoxWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI ScrollBarWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI ScrollBarWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI StaticWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static LRESULT WINAPI StaticWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam );
static WINDOWPROC winproc_array[MAX_WINPROCS] =
{
{ ButtonWndProcA, ButtonWndProcW }, /* WINPROC_BUTTON */
{ ComboWndProcA, ComboWndProcW }, /* WINPROC_COMBO */
{ DefWindowProcA, DefWindowProcW }, /* WINPROC_DEFWND */
{ DefDlgProcA, DefDlgProcW }, /* WINPROC_DIALOG */
{ EditWndProcA, EditWndProcW }, /* WINPROC_EDIT */
{ ListBoxWndProcA, ListBoxWndProcW }, /* WINPROC_LISTBOX */
{ MDIClientWndProcA, MDIClientWndProcW }, /* WINPROC_MDICLIENT */
{ ScrollBarWndProcA, ScrollBarWndProcW }, /* WINPROC_SCROLLBAR */
{ StaticWndProcA, StaticWndProcW }, /* WINPROC_STATIC */
{ NULL, DesktopWndProc }, /* WINPROC_DESKTOP */
{ NULL, IconTitleWndProc }, /* WINPROC_ICONTITLE */
{ NULL, PopupMenuWndProc }, /* WINPROC_MENU */
{ NULL, MessageWndProc }, /* WINPROC_MESSAGE */
};
static UINT winproc_used = NB_BUILTIN_WINPROCS;
static CRITICAL_SECTION winproc_cs;
static CRITICAL_SECTION_DEBUG critsect_debug =
{
0, 0, &winproc_cs,
{ &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
0, 0, { (DWORD_PTR)(__FILE__ ": winproc_cs") }
};
static CRITICAL_SECTION winproc_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
static inline void *get_buffer( void *static_buffer, size_t size, size_t need )
{
if (size >= need) return static_buffer;
return HeapAlloc( GetProcessHeap(), 0, need );
}
static inline void free_buffer( void *static_buffer, void *buffer )
{
if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
}
/* find an existing winproc for a given function and type */
/* FIXME: probably should do something more clever than a linear search */
static inline WINDOWPROC *find_winproc( WNDPROC func, BOOL unicode )
{
unsigned int i;
for (i = 0; i < NB_BUILTIN_AW_WINPROCS; i++)
{
/* match either proc, some apps confuse A and W */
if (winproc_array[i].procA != func && winproc_array[i].procW != func) continue;
return &winproc_array[i];
}
for (i = NB_BUILTIN_AW_WINPROCS; i < winproc_used; i++)
{
if (!unicode && winproc_array[i].procA != func) continue;
if (unicode && winproc_array[i].procW != func) continue;
return &winproc_array[i];
}
return NULL;
}
/* return the window proc for a given handle, or NULL for an invalid handle,
* or WINPROC_PROC16 for a handle to a 16-bit proc. */
static inline WINDOWPROC *handle_to_proc( WNDPROC handle )
{
UINT index = LOWORD(handle);
if ((ULONG_PTR)handle >> 16 != WINPROC_HANDLE) return NULL;
if (index >= MAX_WINPROCS) return WINPROC_PROC16;
if (index >= winproc_used) return NULL;
return &winproc_array[index];
}
/* create a handle for a given window proc */
static inline WNDPROC proc_to_handle( WINDOWPROC *proc )
{
return (WNDPROC)(ULONG_PTR)((proc - winproc_array) | (WINPROC_HANDLE << 16));
}
/* allocate and initialize a new winproc */
static inline WINDOWPROC *alloc_winproc( WNDPROC func, BOOL unicode )
{
WINDOWPROC *proc;
/* check if the function is already a win proc */
if (!func) return NULL;
if ((proc = handle_to_proc( func ))) return proc;
EnterCriticalSection( &winproc_cs );
/* check if we already have a winproc for that function */
if (!(proc = find_winproc( func, unicode )))
{
if (winproc_used < MAX_WINPROCS)
{
proc = &winproc_array[winproc_used++];
if (unicode) proc->procW = func;
else proc->procA = func;
TRACE( "allocated %p for %c %p (%d/%d used)\n",
proc_to_handle(proc), unicode ? 'W' : 'A', func,
winproc_used, MAX_WINPROCS );
}
else FIXME( "too many winprocs, cannot allocate one for %p\n", func );
}
else TRACE( "reusing %p for %p\n", proc_to_handle(proc), func );
LeaveCriticalSection( &winproc_cs );
return proc;
}
#ifdef __i386__
/* Some window procedures modify register they shouldn't, or are not
* properly declared stdcall; so we need a small assembly wrapper to
* call them. */
extern LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam );
__ASM_GLOBAL_FUNC( WINPROC_wrapper,
"pushl %ebp\n\t"
__ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
__ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
"movl %esp,%ebp\n\t"
__ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
"pushl %edi\n\t"
__ASM_CFI(".cfi_rel_offset %edi,-4\n\t")
"pushl %esi\n\t"
__ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
"pushl %ebx\n\t"
__ASM_CFI(".cfi_rel_offset %ebx,-12\n\t")
"subl $12,%esp\n\t"
"pushl 24(%ebp)\n\t"
"pushl 20(%ebp)\n\t"
"pushl 16(%ebp)\n\t"
"pushl 12(%ebp)\n\t"
"movl 8(%ebp),%eax\n\t"
"call *%eax\n\t"
"leal -12(%ebp),%esp\n\t"
"popl %ebx\n\t"
__ASM_CFI(".cfi_same_value %ebx\n\t")
"popl %esi\n\t"
__ASM_CFI(".cfi_same_value %esi\n\t")
"popl %edi\n\t"
__ASM_CFI(".cfi_same_value %edi\n\t")
"leave\n\t"
__ASM_CFI(".cfi_def_cfa %esp,4\n\t")
__ASM_CFI(".cfi_same_value %ebp\n\t")
"ret" )
#else
static inline LRESULT WINPROC_wrapper( WNDPROC proc, HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam )
{
return proc( hwnd, msg, wParam, lParam );
}
#endif /* __i386__ */
static WPARAM map_wparam_char_WtoA( WPARAM wParam, DWORD len )
{
WCHAR wch = wParam;
BYTE ch[2];
RtlUnicodeToMultiByteN( (LPSTR)ch, len, &len, &wch, sizeof(wch) );
if (len == 2)
return MAKEWPARAM( (ch[0] << 8) | ch[1], HIWORD(wParam) );
else
return MAKEWPARAM( ch[0], HIWORD(wParam) );
}
/* call a 32-bit window procedure */
static LRESULT call_window_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result, void *arg )
{
WNDPROC proc = arg;
USER_CheckNotLock();
hwnd = WIN_GetFullHandle( hwnd );
if (TRACE_ON(relay))
DPRINTF( "%04x:Call window proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp );
*result = WINPROC_wrapper( proc, hwnd, msg, wp, lp );
if (TRACE_ON(relay))
DPRINTF( "%04x:Ret window proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx) retval=%08lx\n",
GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp, *result );
return *result;
}
/* call a 32-bit dialog procedure */
static LRESULT call_dialog_proc( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp, LRESULT *result, void *arg )
{
WNDPROC proc = arg;
LRESULT ret;
USER_CheckNotLock();
hwnd = WIN_GetFullHandle( hwnd );
if (TRACE_ON(relay))
DPRINTF( "%04x:Call dialog proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp );
ret = WINPROC_wrapper( proc, hwnd, msg, wp, lp );
*result = GetWindowLongPtrW( hwnd, DWLP_MSGRESULT );
if (TRACE_ON(relay))
DPRINTF( "%04x:Ret dialog proc %p (hwnd=%p,msg=%s,wp=%08lx,lp=%08lx) retval=%08lx result=%08lx\n",
GetCurrentThreadId(), proc, hwnd, SPY_GetMsgName(msg, hwnd), wp, lp, ret, *result );
return ret;
}
/**********************************************************************
* WINPROC_GetProc
*
* Get a window procedure pointer that can be passed to the Windows program.
*/
WNDPROC WINPROC_GetProc( WNDPROC proc, BOOL unicode )
{
WINDOWPROC *ptr = handle_to_proc( proc );
if (!ptr || ptr == WINPROC_PROC16) return proc;
if (unicode)
{
if (ptr->procW) return ptr->procW;
return proc;
}
else
{
if (ptr->procA) return ptr->procA;
return proc;
}
}
/**********************************************************************
* WINPROC_AllocProc
*
* Allocate a window procedure for a window or class.
*
* Note that allocated winprocs are never freed; the idea is that even if an app creates a
* lot of windows, it will usually only have a limited number of window procedures, so the
* array won't grow too large, and this way we avoid the need to track allocations per window.
*/
WNDPROC WINPROC_AllocProc( WNDPROC func, BOOL unicode )
{
WINDOWPROC *proc;
if (!(proc = alloc_winproc( func, unicode ))) return NULL;
if (proc == WINPROC_PROC16) return func;
return proc_to_handle( proc );
}
/**********************************************************************
* WINPROC_IsUnicode
*
* Return the window procedure type, or the default value if not a winproc handle.
*/
BOOL WINPROC_IsUnicode( WNDPROC proc, BOOL def_val )
{
WINDOWPROC *ptr = handle_to_proc( proc );
if (!ptr) return def_val;
if (ptr == WINPROC_PROC16) return FALSE; /* 16-bit is always A */
if (ptr->procA && ptr->procW) return def_val; /* can be both */
return (ptr->procW != NULL);
}
/**********************************************************************
* WINPROC_TestLBForStr
*
* Return TRUE if the lparam is a string
*/
static inline BOOL WINPROC_TestLBForStr( HWND hwnd, UINT msg )
{
DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
if (msg <= CB_MSGMAX)
return (!(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) || (style & CBS_HASSTRINGS));
else
return (!(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) || (style & LBS_HASSTRINGS));
}
/**********************************************************************
* WINPROC_CallProcAtoW
*
* Call a window procedure, translating args from Ansi to Unicode.
*/
LRESULT WINPROC_CallProcAtoW( winproc_callback_t callback, HWND hwnd, UINT msg, WPARAM wParam,
LPARAM lParam, LRESULT *result, void *arg, enum wm_char_mapping mapping )
{
LRESULT ret = 0;
TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
switch(msg)
{
case WM_NCCREATE:
case WM_CREATE:
{
WCHAR *ptr, buffer[512];
CREATESTRUCTA *csA = (CREATESTRUCTA *)lParam;
CREATESTRUCTW csW = *(CREATESTRUCTW *)csA;
MDICREATESTRUCTW mdi_cs;
DWORD name_lenA = 0, name_lenW = 0, class_lenA = 0, class_lenW = 0;
if (!IS_INTRESOURCE(csA->lpszClass))
{
class_lenA = strlen(csA->lpszClass) + 1;
RtlMultiByteToUnicodeSize( &class_lenW, csA->lpszClass, class_lenA );
}
if (!IS_INTRESOURCE(csA->lpszName))
{
name_lenA = strlen(csA->lpszName) + 1;
RtlMultiByteToUnicodeSize( &name_lenW, csA->lpszName, name_lenA );
}
if (!(ptr = get_buffer( buffer, sizeof(buffer), class_lenW + name_lenW ))) break;
if (class_lenW)
{
csW.lpszClass = ptr;
RtlMultiByteToUnicodeN( ptr, class_lenW, NULL, csA->lpszClass, class_lenA );
}
if (name_lenW)
{
csW.lpszName = ptr + class_lenW/sizeof(WCHAR);
RtlMultiByteToUnicodeN( ptr + class_lenW/sizeof(WCHAR), name_lenW, NULL,
csA->lpszName, name_lenA );
}
if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
{
mdi_cs = *(MDICREATESTRUCTW *)csA->lpCreateParams;
mdi_cs.szTitle = csW.lpszName;
mdi_cs.szClass = csW.lpszClass;
csW.lpCreateParams = &mdi_cs;
}
ret = callback( hwnd, msg, wParam, (LPARAM)&csW, result, arg );
free_buffer( buffer, ptr );
}
break;
case WM_MDICREATE:
{
WCHAR *ptr, buffer[512];
DWORD title_lenA = 0, title_lenW = 0, class_lenA = 0, class_lenW = 0;
MDICREATESTRUCTA *csA = (MDICREATESTRUCTA *)lParam;
MDICREATESTRUCTW csW;
memcpy( &csW, csA, sizeof(csW) );
if (!IS_INTRESOURCE(csA->szTitle))
{
title_lenA = strlen(csA->szTitle) + 1;
RtlMultiByteToUnicodeSize( &title_lenW, csA->szTitle, title_lenA );
}
if (!IS_INTRESOURCE(csA->szClass))
{
class_lenA = strlen(csA->szClass) + 1;
RtlMultiByteToUnicodeSize( &class_lenW, csA->szClass, class_lenA );
}
if (!(ptr = get_buffer( buffer, sizeof(buffer), title_lenW + class_lenW ))) break;
if (title_lenW)
{
csW.szTitle = ptr;
RtlMultiByteToUnicodeN( ptr, title_lenW, NULL, csA->szTitle, title_lenA );
}
if (class_lenW)
{
csW.szClass = ptr + title_lenW/sizeof(WCHAR);
RtlMultiByteToUnicodeN( ptr + title_lenW/sizeof(WCHAR), class_lenW, NULL,
csA->szClass, class_lenA );
}
ret = callback( hwnd, msg, wParam, (LPARAM)&csW, result, arg );
free_buffer( buffer, ptr );
}
break;
case WM_GETTEXT:
case WM_ASKCBFORMATNAME:
{
WCHAR *ptr, buffer[512];
LPSTR str = (LPSTR)lParam;
DWORD len = wParam * sizeof(WCHAR);
if (!(ptr = get_buffer( buffer, sizeof(buffer), len ))) break;
ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
if (wParam)
{
len = 0;
if (*result)
RtlUnicodeToMultiByteN( str, wParam - 1, &len, ptr, strlenW(ptr) * sizeof(WCHAR) );
str[len] = 0;
*result = len;
}
free_buffer( buffer, ptr );
}
break;
case LB_ADDSTRING:
case LB_INSERTSTRING:
case LB_FINDSTRING:
case LB_FINDSTRINGEXACT:
case LB_SELECTSTRING:
case CB_ADDSTRING:
case CB_INSERTSTRING:
case CB_FINDSTRING:
case CB_FINDSTRINGEXACT:
case CB_SELECTSTRING:
if (!lParam || !WINPROC_TestLBForStr( hwnd, msg ))
{
ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
}
/* fall through */
case WM_SETTEXT:
case WM_WININICHANGE:
case WM_DEVMODECHANGE:
case CB_DIR:
case LB_DIR:
case LB_ADDFILE:
case EM_REPLACESEL:
if (!lParam) ret = callback( hwnd, msg, wParam, lParam, result, arg );
else
{
WCHAR *ptr, buffer[512];
LPCSTR strA = (LPCSTR)lParam;
DWORD lenW, lenA = strlen(strA) + 1;
RtlMultiByteToUnicodeSize( &lenW, strA, lenA );
if ((ptr = get_buffer( buffer, sizeof(buffer), lenW )))
{
RtlMultiByteToUnicodeN( ptr, lenW, NULL, strA, lenA );
ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
free_buffer( buffer, ptr );
}
}
break;
case LB_GETTEXT:
case CB_GETLBTEXT:
if (lParam && WINPROC_TestLBForStr( hwnd, msg ))
{
WCHAR buffer[512]; /* FIXME: fixed sized buffer */
ret = callback( hwnd, msg, wParam, (LPARAM)buffer, result, arg );
if (*result >= 0)
{
DWORD len;
RtlUnicodeToMultiByteN( (LPSTR)lParam, ~0u, &len,
buffer, (strlenW(buffer) + 1) * sizeof(WCHAR) );
*result = len - 1;
}
}
else ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
case EM_GETLINE:
{
WCHAR *ptr, buffer[512];
WORD len = *(WORD *)lParam;
if (!(ptr = get_buffer( buffer, sizeof(buffer), len * sizeof(WCHAR) ))) break;
*((WORD *)ptr) = len; /* store the length */
ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
if (*result)
{
DWORD reslen;
RtlUnicodeToMultiByteN( (LPSTR)lParam, len, &reslen, ptr, *result * sizeof(WCHAR) );
if (reslen < len) ((LPSTR)lParam)[reslen] = 0;
*result = reslen;
}
free_buffer( buffer, ptr );
}
break;
case WM_GETDLGCODE:
if (lParam)
{
MSG newmsg = *(MSG *)lParam;
if (map_wparam_AtoW( newmsg.message, &newmsg.wParam, WMCHAR_MAP_NOMAPPING ))
ret = callback( hwnd, msg, wParam, (LPARAM)&newmsg, result, arg );
}
else ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
case WM_CHARTOITEM:
case WM_MENUCHAR:
case WM_CHAR:
case WM_DEADCHAR:
case WM_SYSCHAR:
case WM_SYSDEADCHAR:
case EM_SETPASSWORDCHAR:
case WM_IME_CHAR:
if (map_wparam_AtoW( msg, &wParam, mapping ))
ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
case WM_GETTEXTLENGTH:
case CB_GETLBTEXTLEN:
case LB_GETTEXTLEN:
ret = callback( hwnd, msg, wParam, lParam, result, arg );
if (*result >= 0)
{
WCHAR *ptr, buffer[512];
LRESULT tmp;
DWORD len = *result + 1;
/* Determine respective GETTEXT message */
UINT msgGetText = (msg == WM_GETTEXTLENGTH) ? WM_GETTEXT :
((msg == CB_GETLBTEXTLEN) ? CB_GETLBTEXT : LB_GETTEXT);
/* wParam differs between the messages */
WPARAM wp = (msg == WM_GETTEXTLENGTH) ? len : wParam;
if (!(ptr = get_buffer( buffer, sizeof(buffer), len * sizeof(WCHAR) ))) break;
if (callback == call_window_proc) /* FIXME: hack */
callback( hwnd, msgGetText, wp, (LPARAM)ptr, &tmp, arg );
else
tmp = SendMessageW( hwnd, msgGetText, wp, (LPARAM)ptr );
RtlUnicodeToMultiByteSize( &len, ptr, tmp * sizeof(WCHAR) );
*result = len;
free_buffer( buffer, ptr );
}
break;
case WM_PAINTCLIPBOARD:
case WM_SIZECLIPBOARD:
FIXME_(msg)( "message %s (0x%x) needs translation, please report\n",
SPY_GetMsgName(msg, hwnd), msg );
break;
default:
ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
}
return ret;
}
/**********************************************************************
* WINPROC_CallProcWtoA
*
* Call a window procedure, translating args from Unicode to Ansi.
*/
static LRESULT WINPROC_CallProcWtoA( winproc_callback_t callback, HWND hwnd, UINT msg, WPARAM wParam,
LPARAM lParam, LRESULT *result, void *arg )
{
LRESULT ret = 0;
TRACE_(msg)("(hwnd=%p,msg=%s,wp=%08lx,lp=%08lx)\n",
hwnd, SPY_GetMsgName(msg, hwnd), wParam, lParam);
switch(msg)
{
case WM_NCCREATE:
case WM_CREATE:
{
char buffer[1024], *cls;
CREATESTRUCTW *csW = (CREATESTRUCTW *)lParam;
CREATESTRUCTA csA = *(CREATESTRUCTA *)csW;
MDICREATESTRUCTA mdi_cs;
DWORD name_lenA = 0, name_lenW = 0, class_lenA = 0, class_lenW = 0;
if (!IS_INTRESOURCE(csW->lpszClass))
{
class_lenW = (strlenW(csW->lpszClass) + 1) * sizeof(WCHAR);
RtlUnicodeToMultiByteSize(&class_lenA, csW->lpszClass, class_lenW);
}
if (!IS_INTRESOURCE(csW->lpszName))
{
name_lenW = (strlenW(csW->lpszName) + 1) * sizeof(WCHAR);
RtlUnicodeToMultiByteSize(&name_lenA, csW->lpszName, name_lenW);
}
if (!(cls = get_buffer( buffer, sizeof(buffer), class_lenA + name_lenA ))) break;
if (class_lenA)
{
RtlUnicodeToMultiByteN(cls, class_lenA, NULL, csW->lpszClass, class_lenW);
csA.lpszClass = cls;
}
if (name_lenA)
{
char *name = cls + class_lenA;
RtlUnicodeToMultiByteN(name, name_lenA, NULL, csW->lpszName, name_lenW);
csA.lpszName = name;
}
if (GetWindowLongW(hwnd, GWL_EXSTYLE) & WS_EX_MDICHILD)
{
mdi_cs = *(MDICREATESTRUCTA *)csW->lpCreateParams;
mdi_cs.szTitle = csA.lpszName;
mdi_cs.szClass = csA.lpszClass;
csA.lpCreateParams = &mdi_cs;
}
ret = callback( hwnd, msg, wParam, (LPARAM)&csA, result, arg );
free_buffer( buffer, cls );
}
break;
case WM_GETTEXT:
case WM_ASKCBFORMATNAME:
{
char *ptr, buffer[512];
DWORD len = wParam * 2;
if (!(ptr = get_buffer( buffer, sizeof(buffer), len ))) break;
ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
if (len)
{
if (*result)
{
RtlMultiByteToUnicodeN( (LPWSTR)lParam, wParam*sizeof(WCHAR), &len, ptr, strlen(ptr)+1 );
*result = len/sizeof(WCHAR) - 1; /* do not count terminating null */
}
((LPWSTR)lParam)[*result] = 0;
}
free_buffer( buffer, ptr );
}
break;
case LB_ADDSTRING:
case LB_INSERTSTRING:
case LB_FINDSTRING:
case LB_FINDSTRINGEXACT:
case LB_SELECTSTRING:
case CB_ADDSTRING:
case CB_INSERTSTRING:
case CB_FINDSTRING:
case CB_FINDSTRINGEXACT:
case CB_SELECTSTRING:
if (!lParam || !WINPROC_TestLBForStr( hwnd, msg ))
{
ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
}
/* fall through */
case WM_SETTEXT:
case WM_WININICHANGE:
case WM_DEVMODECHANGE:
case CB_DIR:
case LB_DIR:
case LB_ADDFILE:
case EM_REPLACESEL:
if (!lParam) ret = callback( hwnd, msg, wParam, lParam, result, arg );
else
{
char *ptr, buffer[512];
LPCWSTR strW = (LPCWSTR)lParam;
DWORD lenA, lenW = (strlenW(strW) + 1) * sizeof(WCHAR);
RtlUnicodeToMultiByteSize( &lenA, strW, lenW );
if ((ptr = get_buffer( buffer, sizeof(buffer), lenA )))
{
RtlUnicodeToMultiByteN( ptr, lenA, NULL, strW, lenW );
ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
free_buffer( buffer, ptr );
}
}
break;
case WM_MDICREATE:
{
char *ptr, buffer[1024];
DWORD title_lenA = 0, title_lenW = 0, class_lenA = 0, class_lenW = 0;
MDICREATESTRUCTW *csW = (MDICREATESTRUCTW *)lParam;
MDICREATESTRUCTA csA;
memcpy( &csA, csW, sizeof(csA) );
if (!IS_INTRESOURCE(csW->szTitle))
{
title_lenW = (strlenW(csW->szTitle) + 1) * sizeof(WCHAR);
RtlUnicodeToMultiByteSize( &title_lenA, csW->szTitle, title_lenW );
}
if (!IS_INTRESOURCE(csW->szClass))
{
class_lenW = (strlenW(csW->szClass) + 1) * sizeof(WCHAR);
RtlUnicodeToMultiByteSize( &class_lenA, csW->szClass, class_lenW );
}
if (!(ptr = get_buffer( buffer, sizeof(buffer), title_lenA + class_lenA ))) break;
if (title_lenA)
{
RtlUnicodeToMultiByteN( ptr, title_lenA, NULL, csW->szTitle, title_lenW );
csA.szTitle = ptr;
}
if (class_lenA)
{
RtlUnicodeToMultiByteN( ptr + title_lenA, class_lenA, NULL, csW->szClass, class_lenW );
csA.szClass = ptr + title_lenA;
}
ret = callback( hwnd, msg, wParam, (LPARAM)&csA, result, arg );
free_buffer( buffer, ptr );
}
break;
case LB_GETTEXT:
case CB_GETLBTEXT:
if (lParam && WINPROC_TestLBForStr( hwnd, msg ))
{
char buffer[512]; /* FIXME: fixed sized buffer */
ret = callback( hwnd, msg, wParam, (LPARAM)buffer, result, arg );
if (*result >= 0)
{
DWORD len;
RtlMultiByteToUnicodeN( (LPWSTR)lParam, ~0u, &len, buffer, strlen(buffer) + 1 );
*result = len / sizeof(WCHAR) - 1;
}
}
else ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
case EM_GETLINE:
{
char *ptr, buffer[512];
WORD len = *(WORD *)lParam;
if (!(ptr = get_buffer( buffer, sizeof(buffer), len * 2 ))) break;
*((WORD *)ptr) = len * 2; /* store the length */
ret = callback( hwnd, msg, wParam, (LPARAM)ptr, result, arg );
if (*result)
{
DWORD reslen;
RtlMultiByteToUnicodeN( (LPWSTR)lParam, len*sizeof(WCHAR), &reslen, ptr, *result );
*result = reslen / sizeof(WCHAR);
if (*result < len) ((LPWSTR)lParam)[*result] = 0;
}
free_buffer( buffer, ptr );
}
break;
case WM_GETDLGCODE:
if (lParam)
{
MSG newmsg = *(MSG *)lParam;
switch(newmsg.message)
{
case WM_CHAR:
case WM_DEADCHAR:
case WM_SYSCHAR:
case WM_SYSDEADCHAR:
newmsg.wParam = map_wparam_char_WtoA( newmsg.wParam, 1 );
break;
case WM_IME_CHAR:
newmsg.wParam = map_wparam_char_WtoA( newmsg.wParam, 2 );
break;
}
ret = callback( hwnd, msg, wParam, (LPARAM)&newmsg, result, arg );
}
else ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
case WM_CHAR:
{
WCHAR wch = wParam;
char ch[2];
DWORD len;
RtlUnicodeToMultiByteN( ch, 2, &len, &wch, sizeof(wch) );
ret = callback( hwnd, msg, (BYTE)ch[0], lParam, result, arg );
if (len == 2) ret = callback( hwnd, msg, (BYTE)ch[1], lParam, result, arg );
}
break;
case WM_CHARTOITEM:
case WM_MENUCHAR:
case WM_DEADCHAR:
case WM_SYSCHAR:
case WM_SYSDEADCHAR:
case EM_SETPASSWORDCHAR:
ret = callback( hwnd, msg, map_wparam_char_WtoA(wParam,1), lParam, result, arg );
break;
case WM_IME_CHAR:
ret = callback( hwnd, msg, map_wparam_char_WtoA(wParam,2), lParam, result, arg );
break;
case WM_PAINTCLIPBOARD:
case WM_SIZECLIPBOARD:
FIXME_(msg)( "message %s (%04x) needs translation, please report\n",
SPY_GetMsgName(msg, hwnd), msg );
break;
default:
ret = callback( hwnd, msg, wParam, lParam, result, arg );
break;
}
return ret;
}
/**********************************************************************
* WINPROC_call_window
*
* Call the window procedure of the specified window.
*/
BOOL WINPROC_call_window( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
LRESULT *result, BOOL unicode, enum wm_char_mapping mapping )
{
struct user_thread_info *thread_info = get_user_thread_info();
WND *wndPtr;
WNDPROC func;
WINDOWPROC *proc;
if (!(wndPtr = WIN_GetPtr( hwnd ))) return FALSE;
if (wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return FALSE;
if (wndPtr->tid != GetCurrentThreadId())
{
WIN_ReleasePtr( wndPtr );
return FALSE;
}
func = wndPtr->winproc;
proc = handle_to_proc( wndPtr->winproc );
WIN_ReleasePtr( wndPtr );
if (!proc) return TRUE;
if (thread_info->recursion_count > MAX_WINPROC_RECURSION) return FALSE;
thread_info->recursion_count++;
if (unicode)
{
if (proc == WINPROC_PROC16)
WINPROC_CallProcWtoA( wow_handlers.call_window_proc, hwnd, msg, wParam, lParam, result, func );
else if (proc->procW)
call_window_proc( hwnd, msg, wParam, lParam, result, proc->procW );
else
WINPROC_CallProcWtoA( call_window_proc, hwnd, msg, wParam, lParam, result, proc->procA );
}
else
{
if (proc == WINPROC_PROC16)
wow_handlers.call_window_proc( hwnd, msg, wParam, lParam, result, func );
else if (proc->procA)
call_window_proc( hwnd, msg, wParam, lParam, result, proc->procA );
else
WINPROC_CallProcAtoW( call_window_proc, hwnd, msg, wParam, lParam, result, proc->procW, mapping );
}
thread_info->recursion_count--;
return TRUE;
}
/**********************************************************************
* CallWindowProcA (USER32.@)
*
* The CallWindowProc() function invokes the windows procedure _func_,
* with _hwnd_ as the target window, the message specified by _msg_, and
* the message parameters _wParam_ and _lParam_.
*
* Some kinds of argument conversion may be done, I'm not sure what.
*
* CallWindowProc() may be used for windows subclassing. Use
* SetWindowLong() to set a new windows procedure for windows of the
* subclass, and handle subclassed messages in the new windows
* procedure. The new windows procedure may then use CallWindowProc()
* with _func_ set to the parent class's windows procedure to dispatch
* the message to the superclass.
*
* RETURNS
*
* The return value is message dependent.
*
* CONFORMANCE
*
* ECMA-234, Win32
*/
LRESULT WINAPI CallWindowProcA(
WNDPROC func, /* [in] window procedure */
HWND hwnd, /* [in] target window */
UINT msg, /* [in] message */
WPARAM wParam, /* [in] message dependent parameter */
LPARAM lParam /* [in] message dependent parameter */
) {
WINDOWPROC *proc;
LRESULT result;
if (!func) return 0;
if (!(proc = handle_to_proc( func )))
call_window_proc( hwnd, msg, wParam, lParam, &result, func );
else if (proc == WINPROC_PROC16)
wow_handlers.call_window_proc( hwnd, msg, wParam, lParam, &result, func );
else if (proc->procA)
call_window_proc( hwnd, msg, wParam, lParam, &result, proc->procA );
else
WINPROC_CallProcAtoW( call_window_proc, hwnd, msg, wParam, lParam, &result,
proc->procW, WMCHAR_MAP_CALLWINDOWPROC );
return result;
}
/**********************************************************************
* CallWindowProcW (USER32.@)
*
* See CallWindowProcA.
*/
LRESULT WINAPI CallWindowProcW( WNDPROC func, HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam )
{
WINDOWPROC *proc;
LRESULT result;
if (!func) return 0;
if (!(proc = handle_to_proc( func )))
call_window_proc( hwnd, msg, wParam, lParam, &result, func );
else if (proc == WINPROC_PROC16)
WINPROC_CallProcWtoA( wow_handlers.call_window_proc, hwnd, msg, wParam, lParam, &result, func );
else if (proc->procW)
call_window_proc( hwnd, msg, wParam, lParam, &result, proc->procW );
else
WINPROC_CallProcWtoA( call_window_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
return result;
}
/**********************************************************************
* WINPROC_CallDlgProcA
*/
INT_PTR WINPROC_CallDlgProcA( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
WINDOWPROC *proc;
LRESULT result;
INT_PTR ret;
if (!func) return 0;
if (!(proc = handle_to_proc( func )))
ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
else if (proc == WINPROC_PROC16)
{
ret = wow_handlers.call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
}
else if (proc->procW)
{
ret = WINPROC_CallProcAtoW( call_dialog_proc, hwnd, msg, wParam, lParam, &result,
proc->procW, WMCHAR_MAP_CALLWINDOWPROC );
SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
}
else
ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, proc->procA );
return ret;
}
/**********************************************************************
* WINPROC_CallDlgProcW
*/
INT_PTR WINPROC_CallDlgProcW( DLGPROC func, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
WINDOWPROC *proc;
LRESULT result;
INT_PTR ret;
if (!func) return 0;
if (!(proc = handle_to_proc( func )))
ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, func );
else if (proc == WINPROC_PROC16)
{
ret = WINPROC_CallProcWtoA( wow_handlers.call_dialog_proc, hwnd, msg, wParam, lParam, &result, func );
SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
}
else if (proc->procA)
{
ret = WINPROC_CallProcWtoA( call_dialog_proc, hwnd, msg, wParam, lParam, &result, proc->procA );
SetWindowLongPtrW( hwnd, DWLP_MSGRESULT, result );
}
else
ret = call_dialog_proc( hwnd, msg, wParam, lParam, &result, proc->procW );
return ret;
}
/***********************************************************************
* Window procedures for builtin classes
*/
static LRESULT WINAPI ButtonWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.button_proc( hwnd, msg, wParam, lParam, FALSE );
}
static LRESULT WINAPI ButtonWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.button_proc( hwnd, msg, wParam, lParam, TRUE );
}
static LRESULT WINAPI ComboWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.combo_proc( hwnd, message, wParam, lParam, FALSE );
}
static LRESULT WINAPI ComboWndProcW( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.combo_proc( hwnd, message, wParam, lParam, TRUE );
}
LRESULT WINAPI EditWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.edit_proc( hwnd, msg, wParam, lParam, FALSE );
}
static LRESULT WINAPI EditWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.edit_proc( hwnd, msg, wParam, lParam, TRUE );
}
static LRESULT WINAPI ListBoxWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.listbox_proc( hwnd, msg, wParam, lParam, FALSE );
}
static LRESULT WINAPI ListBoxWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.listbox_proc( hwnd, msg, wParam, lParam, TRUE );
}
static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.mdiclient_proc( hwnd, msg, wParam, lParam, FALSE );
}
static LRESULT WINAPI MDIClientWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.mdiclient_proc( hwnd, msg, wParam, lParam, TRUE );
}
static LRESULT WINAPI ScrollBarWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.scrollbar_proc( hwnd, msg, wParam, lParam, FALSE );
}
static LRESULT WINAPI ScrollBarWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.scrollbar_proc( hwnd, msg, wParam, lParam, TRUE );
}
static LRESULT WINAPI StaticWndProcA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.static_proc( hwnd, msg, wParam, lParam, FALSE );
}
static LRESULT WINAPI StaticWndProcW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
return wow_handlers.static_proc( hwnd, msg, wParam, lParam, TRUE );
}
static DWORD wait_message( DWORD count, CONST HANDLE *handles, DWORD timeout, DWORD mask, DWORD flags )
{
DWORD ret;
flush_window_surfaces( TRUE );
ret = USER_Driver->pMsgWaitForMultipleObjectsEx( count, handles, timeout, mask, flags );
if (ret == WAIT_TIMEOUT && !count && !timeout) NtYieldExecution();
return ret;
}
/**********************************************************************
* UserRegisterWowHandlers (USER32.@)
*
* NOTE: no attempt has been made to be compatible here,
* the Windows function is most likely completely different.
*/
void WINAPI UserRegisterWowHandlers( const struct wow_handlers16 *new, struct wow_handlers32 *orig )
{
orig->button_proc = ButtonWndProc_common;
orig->combo_proc = ComboWndProc_common;
orig->edit_proc = EditWndProc_common;
orig->listbox_proc = ListBoxWndProc_common;
orig->mdiclient_proc = MDIClientWndProc_common;
orig->scrollbar_proc = ScrollBarWndProc_common;
orig->static_proc = StaticWndProc_common;
orig->wait_message = wait_message;
orig->create_window = WIN_CreateWindowEx;
orig->get_win_handle = WIN_GetFullHandle;
orig->alloc_winproc = WINPROC_AllocProc;
orig->get_dialog_info = DIALOG_get_info;
orig->dialog_box_loop = DIALOG_DoDialogBox;
orig->get_icon_param = get_icon_param;
orig->set_icon_param = set_icon_param;
wow_handlers = *new;
}
struct wow_handlers16 wow_handlers =
{
ButtonWndProc_common,
ComboWndProc_common,
EditWndProc_common,
ListBoxWndProc_common,
MDIClientWndProc_common,
ScrollBarWndProc_common,
StaticWndProc_common,
wait_message,
WIN_CreateWindowEx,
NULL, /* call_window_proc */
NULL, /* call_dialog_proc */
NULL, /* free_icon_param */
};
Reference in New Issue View Git Blame Copy Permalink