896 lines
30 KiB
C
896 lines
30 KiB
C
/*
|
|
* Window classes functions
|
|
*
|
|
* Copyright 1993, 1996, 2003 Alexandre Julliard
|
|
* Copyright 1995 Martin von Loewis
|
|
* Copyright 1998 Juergen Schmied (jsch)
|
|
*
|
|
* 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
|
|
*/
|
|
|
|
#if 0
|
|
#pragma makedep unix
|
|
#endif
|
|
|
|
#include <pthread.h>
|
|
#include <assert.h>
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#include "win32u_private.h"
|
|
#include "ntuser_private.h"
|
|
#include "wine/server.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(class);
|
|
WINE_DECLARE_DEBUG_CHANNEL(win);
|
|
|
|
#define MAX_WINPROCS 4096
|
|
#define WINPROC_PROC16 ((WINDOWPROC *)1) /* placeholder for 16-bit window procs */
|
|
|
|
static WINDOWPROC winproc_array[MAX_WINPROCS];
|
|
static UINT winproc_used = NB_BUILTIN_WINPROCS;
|
|
static pthread_mutex_t winproc_lock = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
static struct list class_list = LIST_INIT( class_list );
|
|
|
|
static HINSTANCE user32_module;
|
|
|
|
/* find an existing winproc for a given function and type */
|
|
/* FIXME: probably should do something more clever than a linear search */
|
|
static WINDOWPROC *find_winproc( WNDPROC func, BOOL ansi )
|
|
{
|
|
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 (ansi && winproc_array[i].procA != func) continue;
|
|
if (!ansi && 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. */
|
|
WINDOWPROC *get_winproc_ptr( 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_ptr( WNDPROC func, BOOL ansi )
|
|
{
|
|
WINDOWPROC *proc;
|
|
|
|
/* check if the function is already a win proc */
|
|
if (!func) return NULL;
|
|
if ((proc = get_winproc_ptr( func ))) return proc;
|
|
|
|
pthread_mutex_lock( &winproc_lock );
|
|
|
|
/* check if we already have a winproc for that function */
|
|
if (!(proc = find_winproc( func, ansi )))
|
|
{
|
|
if (winproc_used < MAX_WINPROCS)
|
|
{
|
|
proc = &winproc_array[winproc_used++];
|
|
if (ansi) proc->procA = func;
|
|
else proc->procW = func;
|
|
TRACE_(win)( "allocated %p for %c %p (%d/%d used)\n",
|
|
proc_to_handle(proc), ansi ? 'A' : 'W', func,
|
|
winproc_used, MAX_WINPROCS );
|
|
}
|
|
else WARN_(win)( "too many winprocs, cannot allocate one for %p\n", func );
|
|
}
|
|
else TRACE_(win)( "reusing %p for %p\n", proc_to_handle(proc), func );
|
|
|
|
pthread_mutex_unlock( &winproc_lock );
|
|
return proc;
|
|
}
|
|
|
|
/**********************************************************************
|
|
* alloc_winproc
|
|
*
|
|
* 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 alloc_winproc( WNDPROC func, BOOL ansi )
|
|
{
|
|
WINDOWPROC *proc;
|
|
|
|
if (!(proc = alloc_winproc_ptr( func, ansi ))) return func;
|
|
if (proc == WINPROC_PROC16) return func;
|
|
return proc_to_handle( proc );
|
|
}
|
|
|
|
/* Get a window procedure pointer that can be passed to the Windows program. */
|
|
WNDPROC get_winproc( WNDPROC proc, BOOL ansi )
|
|
{
|
|
WINDOWPROC *ptr = get_winproc_ptr( proc );
|
|
|
|
if (!ptr || ptr == WINPROC_PROC16) return proc;
|
|
if (ansi)
|
|
{
|
|
if (ptr->procA) return ptr->procA;
|
|
return proc;
|
|
}
|
|
else
|
|
{
|
|
if (ptr->procW) return ptr->procW;
|
|
return proc;
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserInitializeClientPfnArrays (win32u.@)
|
|
*/
|
|
NTSTATUS WINAPI NtUserInitializeClientPfnArrays( const struct user_client_procs *client_procsA,
|
|
const struct user_client_procs *client_procsW,
|
|
const void *client_workers, HINSTANCE user_module )
|
|
{
|
|
winproc_array[WINPROC_BUTTON].procA = client_procsA->pButtonWndProc;
|
|
winproc_array[WINPROC_BUTTON].procW = client_procsW->pButtonWndProc;
|
|
winproc_array[WINPROC_COMBO].procA = client_procsA->pComboWndProc;
|
|
winproc_array[WINPROC_COMBO].procW = client_procsW->pComboWndProc;
|
|
winproc_array[WINPROC_DEFWND].procA = client_procsA->pDefWindowProc;
|
|
winproc_array[WINPROC_DEFWND].procW = client_procsW->pDefWindowProc;
|
|
winproc_array[WINPROC_DIALOG].procA = client_procsA->pDefDlgProc;
|
|
winproc_array[WINPROC_DIALOG].procW = client_procsW->pDefDlgProc;
|
|
winproc_array[WINPROC_EDIT].procA = client_procsA->pEditWndProc;
|
|
winproc_array[WINPROC_EDIT].procW = client_procsW->pEditWndProc;
|
|
winproc_array[WINPROC_LISTBOX].procA = client_procsA->pListBoxWndProc;
|
|
winproc_array[WINPROC_LISTBOX].procW = client_procsW->pListBoxWndProc;
|
|
winproc_array[WINPROC_MDICLIENT].procA = client_procsA->pMDIClientWndProc;
|
|
winproc_array[WINPROC_MDICLIENT].procW = client_procsW->pMDIClientWndProc;
|
|
winproc_array[WINPROC_SCROLLBAR].procA = client_procsA->pScrollBarWndProc;
|
|
winproc_array[WINPROC_SCROLLBAR].procW = client_procsW->pScrollBarWndProc;
|
|
winproc_array[WINPROC_STATIC].procA = client_procsA->pStaticWndProc;
|
|
winproc_array[WINPROC_STATIC].procW = client_procsW->pStaticWndProc;
|
|
winproc_array[WINPROC_IME].procA = client_procsA->pImeWndProc;
|
|
winproc_array[WINPROC_IME].procW = client_procsW->pImeWndProc;
|
|
winproc_array[WINPROC_DESKTOP].procA = client_procsA->pDesktopWndProc;
|
|
winproc_array[WINPROC_DESKTOP].procW = client_procsW->pDesktopWndProc;
|
|
winproc_array[WINPROC_ICONTITLE].procA = client_procsA->pIconTitleWndProc;
|
|
winproc_array[WINPROC_ICONTITLE].procW = client_procsW->pIconTitleWndProc;
|
|
winproc_array[WINPROC_MENU].procA = client_procsA->pPopupMenuWndProc;
|
|
winproc_array[WINPROC_MENU].procW = client_procsW->pPopupMenuWndProc;
|
|
winproc_array[WINPROC_MESSAGE].procA = client_procsA->pMessageWndProc;
|
|
winproc_array[WINPROC_MESSAGE].procW = client_procsW->pMessageWndProc;
|
|
|
|
user32_module = user_module;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* get_int_atom_value
|
|
*/
|
|
static ATOM get_int_atom_value( UNICODE_STRING *name )
|
|
{
|
|
const WCHAR *ptr = name->Buffer;
|
|
const WCHAR *end = ptr + name->Length / sizeof(WCHAR);
|
|
UINT ret = 0;
|
|
|
|
if (IS_INTRESOURCE(ptr)) return LOWORD(ptr);
|
|
|
|
if (*ptr++ != '#') return 0;
|
|
while (ptr < end)
|
|
{
|
|
if (*ptr < '0' || *ptr > '9') return 0;
|
|
ret = ret * 10 + *ptr++ - '0';
|
|
if (ret > 0xffff) return 0;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* get_class_ptr
|
|
*/
|
|
static CLASS *get_class_ptr( HWND hwnd, BOOL write_access )
|
|
{
|
|
WND *ptr = get_win_ptr( hwnd );
|
|
|
|
if (ptr)
|
|
{
|
|
if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP) return ptr->class;
|
|
if (!write_access) return OBJ_OTHER_PROCESS;
|
|
|
|
/* modifying classes in other processes is not allowed */
|
|
if (ptr == WND_DESKTOP || is_window( hwnd ))
|
|
{
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
return NULL;
|
|
}
|
|
}
|
|
SetLastError( ERROR_INVALID_WINDOW_HANDLE );
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* release_class_ptr
|
|
*/
|
|
static void release_class_ptr( CLASS *ptr )
|
|
{
|
|
user_unlock();
|
|
}
|
|
|
|
static CLASS *find_class( HINSTANCE module, UNICODE_STRING *name )
|
|
{
|
|
ATOM atom = get_int_atom_value( name );
|
|
ULONG_PTR instance = (UINT_PTR)module & ~0xffff;
|
|
CLASS *class;
|
|
|
|
user_lock();
|
|
LIST_FOR_EACH_ENTRY( class, &class_list, CLASS, entry )
|
|
{
|
|
if (atom)
|
|
{
|
|
if (class->atomName != atom) continue;
|
|
}
|
|
else
|
|
{
|
|
if (wcsnicmp( class->name, name->Buffer, name->Length / sizeof(WCHAR) )) continue;
|
|
}
|
|
if (!class->local || !module || (class->instance & ~0xffff) == instance)
|
|
{
|
|
TRACE( "%s %lx -> %p\n", debugstr_us(name), instance, class );
|
|
return class;
|
|
}
|
|
}
|
|
user_unlock();
|
|
return NULL;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserRegisterClassExWOW (win32u.@)
|
|
*/
|
|
ATOM WINAPI NtUserRegisterClassExWOW( const WNDCLASSEXW *wc, UNICODE_STRING *name, UNICODE_STRING *version,
|
|
struct client_menu_name *client_menu_name, DWORD fnid,
|
|
DWORD flags, DWORD *wow )
|
|
{
|
|
const BOOL is_builtin = fnid, ansi = flags;
|
|
HINSTANCE instance;
|
|
CLASS *class;
|
|
ATOM atom;
|
|
BOOL ret;
|
|
|
|
/* create the desktop window to trigger builtin class registration */
|
|
if (!is_builtin && user_callbacks) user_callbacks->pGetDesktopWindow();
|
|
|
|
if (wc->cbSize != sizeof(*wc) || wc->cbClsExtra < 0 || wc->cbWndExtra < 0 ||
|
|
(!is_builtin && wc->hInstance == user32_module)) /* we can't register a class for user32 */
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
if (!(instance = wc->hInstance)) instance = NtCurrentTeb()->Peb->ImageBaseAddress;
|
|
|
|
TRACE( "name=%s hinst=%p style=0x%x clExtr=0x%x winExtr=0x%x\n",
|
|
debugstr_us(name), instance, wc->style, wc->cbClsExtra, wc->cbWndExtra );
|
|
|
|
/* Fix the extra bytes value */
|
|
|
|
if (wc->cbClsExtra > 40) /* Extra bytes are limited to 40 in Win32 */
|
|
WARN( "Class extra bytes %d is > 40\n", wc->cbClsExtra);
|
|
if (wc->cbWndExtra > 40) /* Extra bytes are limited to 40 in Win32 */
|
|
WARN("Win extra bytes %d is > 40\n", wc->cbWndExtra );
|
|
|
|
if (!(class = calloc( 1, sizeof(CLASS) + wc->cbClsExtra ))) return 0;
|
|
|
|
class->atomName = get_int_atom_value( name );
|
|
class->basename = class->name;
|
|
if (!class->atomName && name)
|
|
{
|
|
memcpy( class->name, name->Buffer, name->Length );
|
|
class->name[name->Length / sizeof(WCHAR)] = 0;
|
|
class->basename += version->Length / sizeof(WCHAR);
|
|
}
|
|
else
|
|
{
|
|
UNICODE_STRING str = { .MaximumLength = sizeof(class->name), .Buffer = class->name };
|
|
NtUserGetAtomName( class->atomName, &str );
|
|
}
|
|
|
|
class->style = wc->style;
|
|
class->local = !is_builtin && !(wc->style & CS_GLOBALCLASS);
|
|
class->cbWndExtra = wc->cbWndExtra;
|
|
class->cbClsExtra = wc->cbClsExtra;
|
|
class->instance = (UINT_PTR)instance;
|
|
|
|
SERVER_START_REQ( create_class )
|
|
{
|
|
req->local = class->local;
|
|
req->style = class->style;
|
|
req->instance = class->instance;
|
|
req->extra = class->cbClsExtra;
|
|
req->win_extra = class->cbWndExtra;
|
|
req->client_ptr = wine_server_client_ptr( class );
|
|
req->atom = class->atomName;
|
|
req->name_offset = version->Length / sizeof(WCHAR);
|
|
if (!req->atom && name) wine_server_add_data( req, name->Buffer, name->Length );
|
|
ret = !wine_server_call_err( req );
|
|
class->atomName = reply->atom;
|
|
}
|
|
SERVER_END_REQ;
|
|
if (!ret)
|
|
{
|
|
free( class );
|
|
return 0;
|
|
}
|
|
|
|
/* Other non-null values must be set by caller */
|
|
|
|
user_lock();
|
|
if (class->local) list_add_head( &class_list, &class->entry );
|
|
else list_add_tail( &class_list, &class->entry );
|
|
|
|
atom = class->atomName;
|
|
|
|
TRACE( "name=%s->%s atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
|
|
debugstr_w(wc->lpszClassName), debugstr_us(name), atom, wc->lpfnWndProc, instance,
|
|
wc->hbrBackground, wc->style, wc->cbClsExtra, wc->cbWndExtra, class );
|
|
|
|
class->hIcon = wc->hIcon;
|
|
class->hIconSm = wc->hIconSm;
|
|
class->hCursor = wc->hCursor;
|
|
class->hbrBackground = wc->hbrBackground;
|
|
class->winproc = alloc_winproc( wc->lpfnWndProc, ansi );
|
|
class->menu_name = *client_menu_name;
|
|
if (wc->hIcon && !wc->hIconSm && user_callbacks)
|
|
class->hIconSmIntern = user_callbacks->pCopyImage( wc->hIcon, IMAGE_ICON,
|
|
get_system_metrics( SM_CXSMICON ),
|
|
get_system_metrics( SM_CYSMICON ),
|
|
LR_COPYFROMRESOURCE );
|
|
release_class_ptr( class );
|
|
return atom;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserUnregisterClass (win32u.@)
|
|
*/
|
|
BOOL WINAPI NtUserUnregisterClass( UNICODE_STRING *name, HINSTANCE instance,
|
|
struct client_menu_name *client_menu_name )
|
|
{
|
|
CLASS *class = NULL;
|
|
|
|
if (user_callbacks) /* create the desktop window to trigger builtin class registration */
|
|
user_callbacks->pGetDesktopWindow();
|
|
|
|
SERVER_START_REQ( destroy_class )
|
|
{
|
|
req->instance = wine_server_client_ptr( instance );
|
|
if (!(req->atom = get_int_atom_value( name )) && name->Length)
|
|
wine_server_add_data( req, name->Buffer, name->Length );
|
|
if (!wine_server_call_err( req )) class = wine_server_get_ptr( reply->client_ptr );
|
|
}
|
|
SERVER_END_REQ;
|
|
if (!class) return FALSE;
|
|
|
|
TRACE( "%p\n", class );
|
|
|
|
user_lock();
|
|
if (class->dce && user_callbacks) user_callbacks->free_dce( class->dce, 0 );
|
|
list_remove( &class->entry );
|
|
if (class->hbrBackground > (HBRUSH)(COLOR_GRADIENTINACTIVECAPTION + 1))
|
|
NtGdiDeleteObjectApp( class->hbrBackground );
|
|
NtUserDestroyCursor( class->hIconSmIntern, 0 );
|
|
free( class );
|
|
user_unlock();
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserGetClassInfo (win32u.@)
|
|
*/
|
|
ATOM WINAPI NtUserGetClassInfoEx( HINSTANCE instance, UNICODE_STRING *name, WNDCLASSEXW *wc,
|
|
struct client_menu_name *menu_name, BOOL ansi )
|
|
{
|
|
static const WCHAR messageW[] = {'M','e','s','s','a','g','e'};
|
|
CLASS *class;
|
|
ATOM atom;
|
|
|
|
/* create the desktop window to trigger builtin class registration */
|
|
if (name->Buffer != (const WCHAR *)DESKTOP_CLASS_ATOM &&
|
|
(IS_INTRESOURCE(name->Buffer) || name->Length != sizeof(messageW) ||
|
|
wcsnicmp( name->Buffer, messageW, ARRAYSIZE(messageW) )))
|
|
user_callbacks->pGetDesktopWindow();
|
|
|
|
if (!(class = find_class( instance, name ))) return 0;
|
|
|
|
if (wc)
|
|
{
|
|
wc->style = class->style;
|
|
wc->lpfnWndProc = get_winproc( class->winproc, ansi );
|
|
wc->cbClsExtra = class->cbClsExtra;
|
|
wc->cbWndExtra = class->cbWndExtra;
|
|
wc->hInstance = (instance == user32_module) ? 0 : instance;
|
|
wc->hIcon = class->hIcon;
|
|
wc->hIconSm = class->hIconSm ? class->hIconSm : class->hIconSmIntern;
|
|
wc->hCursor = class->hCursor;
|
|
wc->hbrBackground = class->hbrBackground;
|
|
wc->lpszMenuName = ansi ? (const WCHAR *)class->menu_name.nameA : class->menu_name.nameW;
|
|
wc->lpszClassName = name->Buffer;
|
|
}
|
|
|
|
if (menu_name) *menu_name = class->menu_name;
|
|
atom = class->atomName;
|
|
release_class_ptr( class );
|
|
return atom;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserGetAtomName (win32u.@)
|
|
*/
|
|
ULONG WINAPI NtUserGetAtomName( ATOM atom, UNICODE_STRING *name )
|
|
{
|
|
char buf[sizeof(ATOM_BASIC_INFORMATION) + MAX_ATOM_LEN * sizeof(WCHAR)];
|
|
ATOM_BASIC_INFORMATION *abi = (ATOM_BASIC_INFORMATION *)buf;
|
|
UINT size;
|
|
|
|
if (!set_ntstatus( NtQueryInformationAtom( atom, AtomBasicInformation,
|
|
buf, sizeof(buf), NULL )))
|
|
return 0;
|
|
|
|
if (name->MaximumLength < sizeof(WCHAR))
|
|
{
|
|
SetLastError( ERROR_INSUFFICIENT_BUFFER );
|
|
return 0;
|
|
}
|
|
|
|
size = min( abi->NameLength, name->MaximumLength - sizeof(WCHAR) );
|
|
if (size) memcpy( name->Buffer, abi->Name, size );
|
|
name->Buffer[size / sizeof(WCHAR)] = 0;
|
|
return size / sizeof(WCHAR);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserGetClassName (win32u.@)
|
|
*/
|
|
INT WINAPI NtUserGetClassName( HWND hwnd, BOOL real, UNICODE_STRING *name )
|
|
{
|
|
CLASS *class;
|
|
int ret;
|
|
|
|
TRACE( "%p %x %p\n", hwnd, real, name );
|
|
|
|
if (name->MaximumLength <= sizeof(WCHAR))
|
|
{
|
|
SetLastError( ERROR_INSUFFICIENT_BUFFER );
|
|
return 0;
|
|
}
|
|
|
|
if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
|
|
|
|
if (class == OBJ_OTHER_PROCESS)
|
|
{
|
|
ATOM atom = 0;
|
|
|
|
SERVER_START_REQ( set_class_info )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
req->flags = 0;
|
|
req->extra_offset = -1;
|
|
req->extra_size = 0;
|
|
if (!wine_server_call_err( req ))
|
|
atom = reply->base_atom;
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
return NtUserGetAtomName( atom, name );
|
|
}
|
|
|
|
ret = min( name->MaximumLength / sizeof(WCHAR) - 1, lstrlenW(class->basename) );
|
|
if (ret) memcpy( name->Buffer, class->basename, ret * sizeof(WCHAR) );
|
|
name->Buffer[ret] = 0;
|
|
release_class_ptr( class );
|
|
return ret;
|
|
}
|
|
|
|
/* Set class info with the wine server. */
|
|
static BOOL set_server_info( HWND hwnd, INT offset, LONG_PTR newval, UINT size )
|
|
{
|
|
BOOL ret;
|
|
|
|
SERVER_START_REQ( set_class_info )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
req->extra_offset = -1;
|
|
switch(offset)
|
|
{
|
|
case GCW_ATOM:
|
|
req->flags = SET_CLASS_ATOM;
|
|
req->atom = LOWORD(newval);
|
|
break;
|
|
case GCL_STYLE:
|
|
req->flags = SET_CLASS_STYLE;
|
|
req->style = newval;
|
|
break;
|
|
case GCL_CBWNDEXTRA:
|
|
req->flags = SET_CLASS_WINEXTRA;
|
|
req->win_extra = newval;
|
|
break;
|
|
case GCLP_HMODULE:
|
|
req->flags = SET_CLASS_INSTANCE;
|
|
req->instance = wine_server_client_ptr( (void *)newval );
|
|
break;
|
|
default:
|
|
assert( offset >= 0 );
|
|
req->flags = SET_CLASS_EXTRA;
|
|
req->extra_offset = offset;
|
|
req->extra_size = size;
|
|
if ( size == sizeof(LONG) )
|
|
{
|
|
LONG newlong = newval;
|
|
memcpy( &req->extra_value, &newlong, sizeof(LONG) );
|
|
}
|
|
else
|
|
memcpy( &req->extra_value, &newval, sizeof(LONG_PTR) );
|
|
break;
|
|
}
|
|
ret = !wine_server_call_err( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
static ULONG_PTR set_class_long( HWND hwnd, INT offset, LONG_PTR newval, UINT size, BOOL ansi )
|
|
{
|
|
ULONG_PTR retval = 0;
|
|
CLASS *class;
|
|
|
|
if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
|
|
|
|
if (offset >= 0)
|
|
{
|
|
if (set_server_info( hwnd, offset, newval, size ))
|
|
{
|
|
void *ptr = (char *)(class + 1) + offset;
|
|
if ( size == sizeof(LONG) )
|
|
{
|
|
DWORD retdword;
|
|
LONG newlong = newval;
|
|
memcpy( &retdword, ptr, sizeof(DWORD) );
|
|
memcpy( ptr, &newlong, sizeof(LONG) );
|
|
retval = retdword;
|
|
}
|
|
else
|
|
{
|
|
memcpy( &retval, ptr, sizeof(ULONG_PTR) );
|
|
memcpy( ptr, &newval, sizeof(LONG_PTR) );
|
|
}
|
|
}
|
|
}
|
|
else switch(offset)
|
|
{
|
|
case GCLP_MENUNAME:
|
|
{
|
|
struct client_menu_name *menu_name = (void *)newval;
|
|
struct client_menu_name prev = class->menu_name;
|
|
class->menu_name = *menu_name;
|
|
*menu_name = prev;
|
|
retval = 0; /* Old value is now meaningless anyway */
|
|
break;
|
|
}
|
|
case GCLP_WNDPROC:
|
|
retval = (ULONG_PTR)get_winproc( class->winproc, ansi );
|
|
class->winproc = alloc_winproc( (WNDPROC)newval, ansi );
|
|
break;
|
|
case GCLP_HBRBACKGROUND:
|
|
retval = (ULONG_PTR)class->hbrBackground;
|
|
class->hbrBackground = (HBRUSH)newval;
|
|
break;
|
|
case GCLP_HCURSOR:
|
|
retval = (ULONG_PTR)class->hCursor;
|
|
class->hCursor = (HCURSOR)newval;
|
|
break;
|
|
case GCLP_HICON:
|
|
retval = (ULONG_PTR)class->hIcon;
|
|
if (class->hIconSmIntern)
|
|
{
|
|
NtUserDestroyCursor( class->hIconSmIntern, 0 );
|
|
class->hIconSmIntern = NULL;
|
|
}
|
|
if (newval && !class->hIconSm && user_callbacks)
|
|
class->hIconSmIntern = user_callbacks->pCopyImage( (HICON)newval, IMAGE_ICON,
|
|
get_system_metrics( SM_CXSMICON ),
|
|
get_system_metrics( SM_CYSMICON ),
|
|
LR_COPYFROMRESOURCE );
|
|
class->hIcon = (HICON)newval;
|
|
break;
|
|
case GCLP_HICONSM:
|
|
retval = (ULONG_PTR)class->hIconSm;
|
|
if (retval && !newval && class->hIcon && user_callbacks)
|
|
class->hIconSmIntern = user_callbacks->pCopyImage( class->hIcon, IMAGE_ICON,
|
|
get_system_metrics( SM_CXSMICON ),
|
|
get_system_metrics( SM_CYSMICON ),
|
|
LR_COPYFROMRESOURCE );
|
|
else if (newval && class->hIconSmIntern)
|
|
{
|
|
NtUserDestroyCursor( class->hIconSmIntern, 0 );
|
|
class->hIconSmIntern = NULL;
|
|
}
|
|
class->hIconSm = (HICON)newval;
|
|
break;
|
|
case GCL_STYLE:
|
|
if (!set_server_info( hwnd, offset, newval, size )) break;
|
|
retval = class->style;
|
|
class->style = newval;
|
|
break;
|
|
case GCL_CBWNDEXTRA:
|
|
if (!set_server_info( hwnd, offset, newval, size )) break;
|
|
retval = class->cbWndExtra;
|
|
class->cbWndExtra = newval;
|
|
break;
|
|
case GCLP_HMODULE:
|
|
if (!set_server_info( hwnd, offset, newval, size )) break;
|
|
retval = class->instance;
|
|
class->instance = newval;
|
|
break;
|
|
case GCW_ATOM:
|
|
{
|
|
UNICODE_STRING us;
|
|
if (!set_server_info( hwnd, offset, newval, size )) break;
|
|
retval = class->atomName;
|
|
class->atomName = newval;
|
|
us.Buffer = class->name;
|
|
us.MaximumLength = sizeof(class->name);
|
|
NtUserGetAtomName( newval, &us );
|
|
}
|
|
break;
|
|
case GCL_CBCLSEXTRA: /* cannot change this one */
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
break;
|
|
default:
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
break;
|
|
}
|
|
release_class_ptr( class );
|
|
return retval;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserSetClassLong (win32u.@)
|
|
*/
|
|
DWORD WINAPI NtUserSetClassLong( HWND hwnd, INT offset, LONG newval, BOOL ansi )
|
|
{
|
|
return set_class_long( hwnd, offset, newval, sizeof(LONG), ansi );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserSetClassLongPtr (win32u.@)
|
|
*/
|
|
ULONG_PTR WINAPI NtUserSetClassLongPtr( HWND hwnd, INT offset, LONG_PTR newval, BOOL ansi )
|
|
{
|
|
return set_class_long( hwnd, offset, newval, sizeof(LONG_PTR), ansi );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* NtUserSetClassWord (win32u.@)
|
|
*/
|
|
WORD WINAPI NtUserSetClassWord( HWND hwnd, INT offset, WORD newval )
|
|
{
|
|
CLASS *class;
|
|
WORD retval = 0;
|
|
|
|
if (offset < 0) return NtUserSetClassLong( hwnd, offset, (DWORD)newval, TRUE );
|
|
|
|
if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
|
|
|
|
SERVER_START_REQ( set_class_info )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
req->flags = SET_CLASS_EXTRA;
|
|
req->extra_offset = offset;
|
|
req->extra_size = sizeof(newval);
|
|
memcpy( &req->extra_value, &newval, sizeof(newval) );
|
|
if (!wine_server_call_err( req ))
|
|
{
|
|
void *ptr = (char *)(class + 1) + offset;
|
|
memcpy( &retval, ptr, sizeof(retval) );
|
|
memcpy( ptr, &newval, sizeof(newval) );
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
release_class_ptr( class );
|
|
return retval;
|
|
}
|
|
|
|
static ULONG_PTR get_class_long_size( HWND hwnd, INT offset, UINT size, BOOL ansi )
|
|
{
|
|
CLASS *class;
|
|
ULONG_PTR retvalue = 0;
|
|
|
|
if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
|
|
|
|
if (class == OBJ_OTHER_PROCESS)
|
|
{
|
|
SERVER_START_REQ( set_class_info )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
req->flags = 0;
|
|
req->extra_offset = (offset >= 0) ? offset : -1;
|
|
req->extra_size = (offset >= 0) ? size : 0;
|
|
if (!wine_server_call_err( req ))
|
|
{
|
|
switch(offset)
|
|
{
|
|
case GCLP_HBRBACKGROUND:
|
|
case GCLP_HCURSOR:
|
|
case GCLP_HICON:
|
|
case GCLP_HICONSM:
|
|
case GCLP_WNDPROC:
|
|
case GCLP_MENUNAME:
|
|
FIXME( "offset %d not supported on other process window %p\n", offset, hwnd );
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
break;
|
|
case GCL_STYLE:
|
|
retvalue = reply->old_style;
|
|
break;
|
|
case GCL_CBWNDEXTRA:
|
|
retvalue = reply->old_win_extra;
|
|
break;
|
|
case GCL_CBCLSEXTRA:
|
|
retvalue = reply->old_extra;
|
|
break;
|
|
case GCLP_HMODULE:
|
|
retvalue = (ULONG_PTR)wine_server_get_ptr( reply->old_instance );
|
|
break;
|
|
case GCW_ATOM:
|
|
retvalue = reply->old_atom;
|
|
break;
|
|
default:
|
|
if (offset >= 0)
|
|
{
|
|
if (size == sizeof(DWORD))
|
|
{
|
|
DWORD retdword;
|
|
memcpy( &retdword, &reply->old_extra_value, sizeof(DWORD) );
|
|
retvalue = retdword;
|
|
}
|
|
else
|
|
memcpy( &retvalue, &reply->old_extra_value,
|
|
sizeof(ULONG_PTR) );
|
|
}
|
|
else SetLastError( ERROR_INVALID_INDEX );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
SERVER_END_REQ;
|
|
return retvalue;
|
|
}
|
|
|
|
if (offset >= 0)
|
|
{
|
|
if (offset <= class->cbClsExtra - size)
|
|
{
|
|
if (size == sizeof(DWORD))
|
|
{
|
|
DWORD retdword;
|
|
memcpy( &retdword, (char *)(class + 1) + offset, sizeof(DWORD) );
|
|
retvalue = retdword;
|
|
}
|
|
else
|
|
memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(ULONG_PTR) );
|
|
}
|
|
else
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
release_class_ptr( class );
|
|
return retvalue;
|
|
}
|
|
|
|
switch(offset)
|
|
{
|
|
case GCLP_HBRBACKGROUND:
|
|
retvalue = (ULONG_PTR)class->hbrBackground;
|
|
break;
|
|
case GCLP_HCURSOR:
|
|
retvalue = (ULONG_PTR)class->hCursor;
|
|
break;
|
|
case GCLP_HICON:
|
|
retvalue = (ULONG_PTR)class->hIcon;
|
|
break;
|
|
case GCLP_HICONSM:
|
|
retvalue = (ULONG_PTR)(class->hIconSm ? class->hIconSm : class->hIconSmIntern);
|
|
break;
|
|
case GCL_STYLE:
|
|
retvalue = class->style;
|
|
break;
|
|
case GCL_CBWNDEXTRA:
|
|
retvalue = class->cbWndExtra;
|
|
break;
|
|
case GCL_CBCLSEXTRA:
|
|
retvalue = class->cbClsExtra;
|
|
break;
|
|
case GCLP_HMODULE:
|
|
retvalue = class->instance;
|
|
break;
|
|
case GCLP_WNDPROC:
|
|
retvalue = (ULONG_PTR)get_winproc( class->winproc, ansi );
|
|
break;
|
|
case GCLP_MENUNAME:
|
|
retvalue = ansi ? (ULONG_PTR)class->menu_name.nameA : (ULONG_PTR)class->menu_name.nameW;
|
|
break;
|
|
case GCW_ATOM:
|
|
retvalue = class->atomName;
|
|
break;
|
|
default:
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
break;
|
|
}
|
|
release_class_ptr( class );
|
|
return retvalue;
|
|
}
|
|
|
|
DWORD get_class_long( HWND hwnd, INT offset, BOOL ansi )
|
|
{
|
|
return get_class_long_size( hwnd, offset, sizeof(DWORD), ansi );
|
|
}
|
|
|
|
ULONG_PTR get_class_long_ptr( HWND hwnd, INT offset, BOOL ansi )
|
|
{
|
|
return get_class_long_size( hwnd, offset, sizeof(ULONG_PTR), ansi );
|
|
}
|
|
|
|
WORD get_class_word( HWND hwnd, INT offset )
|
|
{
|
|
CLASS *class;
|
|
WORD retvalue = 0;
|
|
|
|
if (offset < 0) return get_class_long( hwnd, offset, TRUE );
|
|
|
|
if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
|
|
|
|
if (class == OBJ_OTHER_PROCESS)
|
|
{
|
|
SERVER_START_REQ( set_class_info )
|
|
{
|
|
req->window = wine_server_user_handle( hwnd );
|
|
req->flags = 0;
|
|
req->extra_offset = offset;
|
|
req->extra_size = sizeof(retvalue);
|
|
if (!wine_server_call_err( req ))
|
|
memcpy( &retvalue, &reply->old_extra_value, sizeof(retvalue) );
|
|
}
|
|
SERVER_END_REQ;
|
|
return retvalue;
|
|
}
|
|
|
|
if (offset <= class->cbClsExtra - sizeof(WORD))
|
|
memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(retvalue) );
|
|
else
|
|
SetLastError( ERROR_INVALID_INDEX );
|
|
release_class_ptr( class );
|
|
return retvalue;
|
|
}
|