2 * Window classes functions
4 * Copyright 1993, 1996, 2003 Alexandre Julliard
5 * Copyright 1998 Juergen Schmied (jsch)
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 "wine/unicode.h"
36 #include "user_private.h"
38 #include "wine/server.h"
39 #include "wine/list.h"
40 #include "wine/debug.h"
42 WINE_DEFAULT_DEBUG_CHANNEL(class);
44 #define MAX_ATOM_LEN 255 /* from dlls/kernel32/atom.c */
46 typedef struct tagCLASS
48 struct list entry; /* Entry in class list */
49 UINT style; /* Class style */
50 BOOL local; /* Local class? */
51 WNDPROC winproc; /* Window procedure */
52 INT cbClsExtra; /* Class extra bytes */
53 INT cbWndExtra; /* Window extra bytes */
54 LPWSTR menuName; /* Default menu name (Unicode followed by ASCII) */
55 struct dce *dce; /* Opaque pointer to class DCE */
56 HINSTANCE hInstance; /* Module that created the task */
57 HICON hIcon; /* Default icon */
58 HICON hIconSm; /* Default small icon */
59 HCURSOR hCursor; /* Default cursor */
60 HBRUSH hbrBackground; /* Default background */
61 ATOM atomName; /* Name of the class */
62 WCHAR name[MAX_ATOM_LEN + 1];
65 static struct list class_list = LIST_INIT( class_list );
67 #define CLASS_OTHER_PROCESS ((CLASS *)1)
69 /***********************************************************************
72 static CLASS *get_class_ptr( HWND hwnd, BOOL write_access )
74 WND *ptr = WIN_GetPtr( hwnd );
78 if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP) return ptr->class;
79 if (!write_access) return CLASS_OTHER_PROCESS;
81 /* modifying classes in other processes is not allowed */
82 if (ptr == WND_DESKTOP || IsWindow( hwnd ))
84 SetLastError( ERROR_ACCESS_DENIED );
88 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
93 /***********************************************************************
96 static inline void release_class_ptr( CLASS *ptr )
102 /***********************************************************************
105 ATOM get_int_atom_value( LPCWSTR name )
109 if (IS_INTRESOURCE(name)) return LOWORD(name);
110 if (*name++ != '#') return 0;
113 if (*name < '0' || *name > '9') return 0;
114 ret = ret * 10 + *name++ - '0';
115 if (ret > 0xffff) return 0;
121 /***********************************************************************
124 * Set class info with the wine server.
126 static BOOL set_server_info( HWND hwnd, INT offset, LONG_PTR newval, UINT size )
130 SERVER_START_REQ( set_class_info )
132 req->window = wine_server_user_handle( hwnd );
133 req->extra_offset = -1;
137 req->flags = SET_CLASS_ATOM;
138 req->atom = LOWORD(newval);
140 req->flags = SET_CLASS_STYLE;
144 req->flags = SET_CLASS_WINEXTRA;
145 req->win_extra = newval;
148 req->flags = SET_CLASS_INSTANCE;
149 req->instance = wine_server_client_ptr( (void *)newval );
152 assert( offset >= 0 );
153 req->flags = SET_CLASS_EXTRA;
154 req->extra_offset = offset;
155 req->extra_size = size;
156 if ( size == sizeof(LONG) )
158 LONG newlong = newval;
159 memcpy( &req->extra_value, &newlong, sizeof(LONG) );
162 memcpy( &req->extra_value, &newval, sizeof(LONG_PTR) );
165 ret = !wine_server_call_err( req );
172 /***********************************************************************
175 * Get the menu name as a ASCII string.
177 static inline LPSTR CLASS_GetMenuNameA( CLASS *classPtr )
179 if (!HIWORD(classPtr->menuName)) return (LPSTR)classPtr->menuName;
180 return (LPSTR)(classPtr->menuName + strlenW(classPtr->menuName) + 1);
184 /***********************************************************************
187 * Get the menu name as a Unicode string.
189 static inline LPWSTR CLASS_GetMenuNameW( CLASS *classPtr )
191 return classPtr->menuName;
195 /***********************************************************************
198 * Set the menu name in a class structure by copying the string.
200 static void CLASS_SetMenuNameA( CLASS *classPtr, LPCSTR name )
202 if (HIWORD(classPtr->menuName)) HeapFree( GetProcessHeap(), 0, classPtr->menuName );
205 DWORD lenA = strlen(name) + 1;
206 DWORD lenW = MultiByteToWideChar( CP_ACP, 0, name, lenA, NULL, 0 );
207 classPtr->menuName = HeapAlloc( GetProcessHeap(), 0, lenA + lenW*sizeof(WCHAR) );
208 MultiByteToWideChar( CP_ACP, 0, name, lenA, classPtr->menuName, lenW );
209 memcpy( classPtr->menuName + lenW, name, lenA );
211 else classPtr->menuName = (LPWSTR)name;
215 /***********************************************************************
218 * Set the menu name in a class structure by copying the string.
220 static void CLASS_SetMenuNameW( CLASS *classPtr, LPCWSTR name )
222 if (HIWORD(classPtr->menuName)) HeapFree( GetProcessHeap(), 0, classPtr->menuName );
225 DWORD lenW = strlenW(name) + 1;
226 DWORD lenA = WideCharToMultiByte( CP_ACP, 0, name, lenW, NULL, 0, NULL, NULL );
227 classPtr->menuName = HeapAlloc( GetProcessHeap(), 0, lenA + lenW*sizeof(WCHAR) );
228 memcpy( classPtr->menuName, name, lenW*sizeof(WCHAR) );
229 WideCharToMultiByte( CP_ACP, 0, name, lenW,
230 (char *)(classPtr->menuName + lenW), lenA, NULL, NULL );
232 else classPtr->menuName = (LPWSTR)name;
236 /***********************************************************************
239 * Free a class structure.
241 static void CLASS_FreeClass( CLASS *classPtr )
243 TRACE("%p\n", classPtr);
247 if (classPtr->dce) free_dce( classPtr->dce, 0 );
248 list_remove( &classPtr->entry );
249 if (classPtr->hbrBackground > (HBRUSH)(COLOR_GRADIENTINACTIVECAPTION + 1))
250 DeleteObject( classPtr->hbrBackground );
251 HeapFree( GetProcessHeap(), 0, classPtr->menuName );
252 HeapFree( GetProcessHeap(), 0, classPtr );
257 /***********************************************************************
258 * CLASS_FreeModuleClasses
260 void CLASS_FreeModuleClasses( HMODULE16 hModule )
262 struct list *ptr, *next;
264 TRACE("0x%08x\n", hModule);
267 for (ptr = list_head( &class_list ); ptr; ptr = next)
269 CLASS *class = LIST_ENTRY( ptr, CLASS, entry );
270 next = list_next( &class_list, ptr );
271 if (class->hInstance == HINSTANCE_32(hModule))
275 SERVER_START_REQ( destroy_class )
277 req->atom = class->atomName;
278 req->instance = wine_server_client_ptr( class->hInstance );
279 ret = !wine_server_call_err( req );
282 if (ret) CLASS_FreeClass( class );
289 /***********************************************************************
292 * Return a pointer to the class.
293 * hinstance has been normalized by the caller.
295 static CLASS *CLASS_FindClass( LPCWSTR name, HINSTANCE hinstance )
298 ATOM atom = get_int_atom_value( name );
302 LIST_FOR_EACH( ptr, &class_list )
304 CLASS *class = LIST_ENTRY( ptr, CLASS, entry );
307 if (class->atomName != atom) continue;
311 if (!name || strcmpiW( class->name, name )) continue;
313 if (!hinstance || !class->local || class->hInstance == hinstance)
315 TRACE("%s %p -> %p\n", debugstr_w(name), hinstance, class);
320 TRACE("%s %p -> not found\n", debugstr_w(name), hinstance);
325 /***********************************************************************
326 * CLASS_RegisterClass
328 * The real RegisterClass() functionality.
330 static CLASS *CLASS_RegisterClass( LPCWSTR name, HINSTANCE hInstance, BOOL local,
331 DWORD style, INT classExtra, INT winExtra )
336 TRACE("name=%s hinst=%p style=0x%x clExtr=0x%x winExtr=0x%x\n",
337 debugstr_w(name), hInstance, style, classExtra, winExtra );
339 /* Fix the extra bytes value */
341 if (classExtra > 40) /* Extra bytes are limited to 40 in Win32 */
342 WARN("Class extra bytes %d is > 40\n", classExtra);
343 if (winExtra > 40) /* Extra bytes are limited to 40 in Win32 */
344 WARN("Win extra bytes %d is > 40\n", winExtra );
346 classPtr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLASS) + classExtra );
347 if (!classPtr) return NULL;
349 classPtr->atomName = get_int_atom_value( name );
350 if (!classPtr->atomName && name) strcpyW( classPtr->name, name );
351 else GlobalGetAtomNameW( classPtr->atomName, classPtr->name, sizeof(classPtr->name)/sizeof(WCHAR) );
353 SERVER_START_REQ( create_class )
357 req->instance = wine_server_client_ptr( hInstance );
358 req->extra = classExtra;
359 req->win_extra = winExtra;
360 req->client_ptr = wine_server_client_ptr( classPtr );
361 req->atom = classPtr->atomName;
362 if (!req->atom && name) wine_server_add_data( req, name, strlenW(name) * sizeof(WCHAR) );
363 ret = !wine_server_call_err( req );
364 classPtr->atomName = reply->atom;
369 HeapFree( GetProcessHeap(), 0, classPtr );
373 classPtr->style = style;
374 classPtr->local = local;
375 classPtr->cbWndExtra = winExtra;
376 classPtr->cbClsExtra = classExtra;
377 classPtr->hInstance = hInstance;
379 /* Other non-null values must be set by caller */
382 if (local) list_add_head( &class_list, &classPtr->entry );
383 else list_add_tail( &class_list, &classPtr->entry );
388 /***********************************************************************
391 * Register a builtin control class.
392 * This allows having both ASCII and Unicode winprocs for the same class.
394 static void register_builtin( const struct builtin_class_descr *descr )
398 if (!(classPtr = CLASS_RegisterClass( descr->name, user32_module, FALSE,
399 descr->style, 0, descr->extra ))) return;
401 classPtr->hCursor = LoadCursorA( 0, (LPSTR)descr->cursor );
402 classPtr->hbrBackground = descr->brush;
403 classPtr->winproc = WINPROC_AllocProc( descr->procA, descr->procW );
404 release_class_ptr( classPtr );
408 /***********************************************************************
409 * CLASS_RegisterBuiltinClasses
411 void CLASS_RegisterBuiltinClasses(void)
413 register_builtin( &DESKTOP_builtin_class );
414 register_builtin( &BUTTON_builtin_class );
415 register_builtin( &COMBO_builtin_class );
416 register_builtin( &COMBOLBOX_builtin_class );
417 register_builtin( &DIALOG_builtin_class );
418 register_builtin( &EDIT_builtin_class );
419 register_builtin( &ICONTITLE_builtin_class );
420 register_builtin( &LISTBOX_builtin_class );
421 register_builtin( &MDICLIENT_builtin_class );
422 register_builtin( &MENU_builtin_class );
423 register_builtin( &MESSAGE_builtin_class );
424 register_builtin( &SCROLL_builtin_class );
425 register_builtin( &STATIC_builtin_class );
429 /***********************************************************************
432 WNDPROC get_class_winproc( CLASS *class )
434 return class->winproc;
438 /***********************************************************************
441 struct dce *get_class_dce( CLASS *class )
447 /***********************************************************************
450 struct dce *set_class_dce( CLASS *class, struct dce *dce )
452 if (class->dce) return class->dce; /* already set, don't change it */
458 /***********************************************************************
459 * RegisterClassA (USER32.@)
461 * Register a window class.
464 * >0: Unique identifier
467 ATOM WINAPI RegisterClassA( const WNDCLASSA* wc ) /* [in] Address of structure with class data */
471 wcex.cbSize = sizeof(wcex);
472 wcex.style = wc->style;
473 wcex.lpfnWndProc = wc->lpfnWndProc;
474 wcex.cbClsExtra = wc->cbClsExtra;
475 wcex.cbWndExtra = wc->cbWndExtra;
476 wcex.hInstance = wc->hInstance;
477 wcex.hIcon = wc->hIcon;
478 wcex.hCursor = wc->hCursor;
479 wcex.hbrBackground = wc->hbrBackground;
480 wcex.lpszMenuName = wc->lpszMenuName;
481 wcex.lpszClassName = wc->lpszClassName;
483 return RegisterClassExA( &wcex );
487 /***********************************************************************
488 * RegisterClassW (USER32.@)
490 * See RegisterClassA.
492 ATOM WINAPI RegisterClassW( const WNDCLASSW* wc )
496 wcex.cbSize = sizeof(wcex);
497 wcex.style = wc->style;
498 wcex.lpfnWndProc = wc->lpfnWndProc;
499 wcex.cbClsExtra = wc->cbClsExtra;
500 wcex.cbWndExtra = wc->cbWndExtra;
501 wcex.hInstance = wc->hInstance;
502 wcex.hIcon = wc->hIcon;
503 wcex.hCursor = wc->hCursor;
504 wcex.hbrBackground = wc->hbrBackground;
505 wcex.lpszMenuName = wc->lpszMenuName;
506 wcex.lpszClassName = wc->lpszClassName;
508 return RegisterClassExW( &wcex );
512 /***********************************************************************
513 * RegisterClassExA (USER32.@)
515 ATOM WINAPI RegisterClassExA( const WNDCLASSEXA* wc )
521 if (wc->cbClsExtra < 0 || wc->cbWndExtra < 0 ||
522 wc->hInstance == user32_module) /* we can't register a class for user32 */
524 SetLastError( ERROR_INVALID_PARAMETER );
527 if (!(instance = wc->hInstance)) instance = GetModuleHandleW( NULL );
529 if (!IS_INTRESOURCE(wc->lpszClassName))
531 WCHAR name[MAX_ATOM_LEN + 1];
533 if (!MultiByteToWideChar( CP_ACP, 0, wc->lpszClassName, -1, name, MAX_ATOM_LEN + 1 )) return 0;
534 classPtr = CLASS_RegisterClass( name, instance, !(wc->style & CS_GLOBALCLASS),
535 wc->style, wc->cbClsExtra, wc->cbWndExtra );
539 classPtr = CLASS_RegisterClass( (LPCWSTR)wc->lpszClassName, instance,
540 !(wc->style & CS_GLOBALCLASS), wc->style,
541 wc->cbClsExtra, wc->cbWndExtra );
543 if (!classPtr) return 0;
544 atom = classPtr->atomName;
546 TRACE("name=%s atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
547 debugstr_a(wc->lpszClassName), atom, wc->lpfnWndProc, instance, wc->hbrBackground,
548 wc->style, wc->cbClsExtra, wc->cbWndExtra, classPtr );
550 classPtr->hIcon = wc->hIcon;
551 classPtr->hIconSm = wc->hIconSm;
552 classPtr->hCursor = wc->hCursor;
553 classPtr->hbrBackground = wc->hbrBackground;
554 classPtr->winproc = WINPROC_AllocProc( wc->lpfnWndProc, NULL );
555 CLASS_SetMenuNameA( classPtr, wc->lpszMenuName );
556 release_class_ptr( classPtr );
561 /***********************************************************************
562 * RegisterClassExW (USER32.@)
564 ATOM WINAPI RegisterClassExW( const WNDCLASSEXW* wc )
570 if (wc->cbClsExtra < 0 || wc->cbWndExtra < 0 ||
571 wc->hInstance == user32_module) /* we can't register a class for user32 */
573 SetLastError( ERROR_INVALID_PARAMETER );
576 if (!(instance = wc->hInstance)) instance = GetModuleHandleW( NULL );
578 if (!(classPtr = CLASS_RegisterClass( wc->lpszClassName, instance, !(wc->style & CS_GLOBALCLASS),
579 wc->style, wc->cbClsExtra, wc->cbWndExtra )))
582 atom = classPtr->atomName;
584 TRACE("name=%s atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
585 debugstr_w(wc->lpszClassName), atom, wc->lpfnWndProc, instance, wc->hbrBackground,
586 wc->style, wc->cbClsExtra, wc->cbWndExtra, classPtr );
588 classPtr->hIcon = wc->hIcon;
589 classPtr->hIconSm = wc->hIconSm;
590 classPtr->hCursor = wc->hCursor;
591 classPtr->hbrBackground = wc->hbrBackground;
592 classPtr->winproc = WINPROC_AllocProc( NULL, wc->lpfnWndProc );
593 CLASS_SetMenuNameW( classPtr, wc->lpszMenuName );
594 release_class_ptr( classPtr );
599 /***********************************************************************
600 * UnregisterClassA (USER32.@)
602 BOOL WINAPI UnregisterClassA( LPCSTR className, HINSTANCE hInstance )
604 if (!IS_INTRESOURCE(className))
606 WCHAR name[MAX_ATOM_LEN + 1];
608 if (!MultiByteToWideChar( CP_ACP, 0, className, -1, name, MAX_ATOM_LEN + 1 ))
610 return UnregisterClassW( name, hInstance );
612 return UnregisterClassW( (LPCWSTR)className, hInstance );
615 /***********************************************************************
616 * UnregisterClassW (USER32.@)
618 BOOL WINAPI UnregisterClassW( LPCWSTR className, HINSTANCE hInstance )
620 CLASS *classPtr = NULL;
622 SERVER_START_REQ( destroy_class )
624 req->instance = wine_server_client_ptr( hInstance );
625 if (!(req->atom = get_int_atom_value(className)) && className)
626 wine_server_add_data( req, className, strlenW(className) * sizeof(WCHAR) );
627 if (!wine_server_call_err( req )) classPtr = wine_server_get_ptr( reply->client_ptr );
631 if (classPtr) CLASS_FreeClass( classPtr );
632 return (classPtr != NULL);
636 /***********************************************************************
637 * GetClassWord (USER32.@)
639 WORD WINAPI GetClassWord( HWND hwnd, INT offset )
644 if (offset < 0) return GetClassLongA( hwnd, offset );
646 if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
648 if (class == CLASS_OTHER_PROCESS)
650 SERVER_START_REQ( set_class_info )
652 req->window = wine_server_user_handle( hwnd );
654 req->extra_offset = offset;
655 req->extra_size = sizeof(retvalue);
656 if (!wine_server_call_err( req ))
657 memcpy( &retvalue, &reply->old_extra_value, sizeof(retvalue) );
663 if (offset <= class->cbClsExtra - sizeof(WORD))
664 memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(retvalue) );
666 SetLastError( ERROR_INVALID_INDEX );
667 release_class_ptr( class );
672 /***********************************************************************
675 * Implementation of GetClassLong(Ptr)A/W
677 static ULONG_PTR CLASS_GetClassLong( HWND hwnd, INT offset, UINT size,
681 ULONG_PTR retvalue = 0;
683 if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
685 if (class == CLASS_OTHER_PROCESS)
687 SERVER_START_REQ( set_class_info )
689 req->window = wine_server_user_handle( hwnd );
691 req->extra_offset = (offset >= 0) ? offset : -1;
692 req->extra_size = (offset >= 0) ? size : 0;
693 if (!wine_server_call_err( req ))
697 case GCLP_HBRBACKGROUND:
703 FIXME( "offset %d (%s) not supported on other process window %p\n",
704 offset, SPY_GetClassLongOffsetName(offset), hwnd );
705 SetLastError( ERROR_INVALID_HANDLE );
708 retvalue = reply->old_style;
711 retvalue = reply->old_win_extra;
714 retvalue = reply->old_extra;
717 retvalue = (ULONG_PTR)wine_server_get_ptr( reply->old_instance );
720 retvalue = reply->old_atom;
725 if (size == sizeof(DWORD))
728 memcpy( &retdword, &reply->old_extra_value, sizeof(DWORD) );
732 memcpy( &retvalue, &reply->old_extra_value,
735 else SetLastError( ERROR_INVALID_INDEX );
746 if (offset <= class->cbClsExtra - size)
748 if (size == sizeof(DWORD))
751 memcpy( &retdword, (char *)(class + 1) + offset, sizeof(DWORD) );
755 memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(ULONG_PTR) );
758 SetLastError( ERROR_INVALID_INDEX );
759 release_class_ptr( class );
765 case GCLP_HBRBACKGROUND:
766 retvalue = (ULONG_PTR)class->hbrBackground;
769 retvalue = (ULONG_PTR)class->hCursor;
772 retvalue = (ULONG_PTR)class->hIcon;
775 retvalue = (ULONG_PTR)class->hIconSm;
778 retvalue = class->style;
781 retvalue = class->cbWndExtra;
784 retvalue = class->cbClsExtra;
787 retvalue = (ULONG_PTR)class->hInstance;
790 retvalue = (ULONG_PTR)WINPROC_GetProc( class->winproc, unicode );
793 retvalue = (ULONG_PTR)CLASS_GetMenuNameW( class );
795 retvalue = (ULONG_PTR)CLASS_GetMenuNameW( class );
797 retvalue = (ULONG_PTR)CLASS_GetMenuNameA( class );
800 retvalue = class->atomName;
803 SetLastError( ERROR_INVALID_INDEX );
806 release_class_ptr( class );
811 /***********************************************************************
812 * GetClassLongW (USER32.@)
814 DWORD WINAPI GetClassLongW( HWND hwnd, INT offset )
816 return CLASS_GetClassLong( hwnd, offset, sizeof(DWORD), TRUE );
821 /***********************************************************************
822 * GetClassLongA (USER32.@)
824 DWORD WINAPI GetClassLongA( HWND hwnd, INT offset )
826 return CLASS_GetClassLong( hwnd, offset, sizeof(DWORD), FALSE );
830 /***********************************************************************
831 * SetClassWord (USER32.@)
833 WORD WINAPI SetClassWord( HWND hwnd, INT offset, WORD newval )
838 if (offset < 0) return SetClassLongA( hwnd, offset, (DWORD)newval );
840 if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
842 SERVER_START_REQ( set_class_info )
844 req->window = wine_server_user_handle( hwnd );
845 req->flags = SET_CLASS_EXTRA;
846 req->extra_offset = offset;
847 req->extra_size = sizeof(newval);
848 memcpy( &req->extra_value, &newval, sizeof(newval) );
849 if (!wine_server_call_err( req ))
851 void *ptr = (char *)(class + 1) + offset;
852 memcpy( &retval, ptr, sizeof(retval) );
853 memcpy( ptr, &newval, sizeof(newval) );
857 release_class_ptr( class );
862 /***********************************************************************
865 * Implementation of SetClassLong(Ptr)A/W
867 static ULONG_PTR CLASS_SetClassLong( HWND hwnd, INT offset, LONG_PTR newval,
868 UINT size, BOOL unicode )
871 ULONG_PTR retval = 0;
873 if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
877 if (set_server_info( hwnd, offset, newval, size ))
879 void *ptr = (char *)(class + 1) + offset;
880 if ( size == sizeof(LONG) )
883 LONG newlong = newval;
884 memcpy( &retdword, ptr, sizeof(DWORD) );
885 memcpy( ptr, &newlong, sizeof(LONG) );
890 memcpy( &retval, ptr, sizeof(ULONG_PTR) );
891 memcpy( ptr, &newval, sizeof(LONG_PTR) );
899 CLASS_SetMenuNameW( class, (LPCWSTR)newval );
901 CLASS_SetMenuNameA( class, (LPCSTR)newval );
902 retval = 0; /* Old value is now meaningless anyway */
905 retval = (ULONG_PTR)WINPROC_GetProc( class->winproc, unicode );
906 class->winproc = WINPROC_AllocProc( unicode ? NULL : (WNDPROC)newval,
907 unicode ? (WNDPROC)newval : NULL );
909 case GCLP_HBRBACKGROUND:
910 retval = (ULONG_PTR)class->hbrBackground;
911 class->hbrBackground = (HBRUSH)newval;
914 retval = (ULONG_PTR)class->hCursor;
915 class->hCursor = (HCURSOR)newval;
918 retval = (ULONG_PTR)class->hIcon;
919 class->hIcon = (HICON)newval;
922 retval = (ULONG_PTR)class->hIconSm;
923 class->hIconSm = (HICON)newval;
926 if (!set_server_info( hwnd, offset, newval, size )) break;
927 retval = class->style;
928 class->style = newval;
931 if (!set_server_info( hwnd, offset, newval, size )) break;
932 retval = class->cbWndExtra;
933 class->cbWndExtra = newval;
936 if (!set_server_info( hwnd, offset, newval, size )) break;
937 retval = (ULONG_PTR)class->hInstance;
938 class->hInstance = (HINSTANCE)newval;
941 if (!set_server_info( hwnd, offset, newval, size )) break;
942 retval = class->atomName;
943 class->atomName = newval;
944 GlobalGetAtomNameW( newval, class->name, sizeof(class->name)/sizeof(WCHAR) );
946 case GCL_CBCLSEXTRA: /* cannot change this one */
947 SetLastError( ERROR_INVALID_PARAMETER );
950 SetLastError( ERROR_INVALID_INDEX );
953 release_class_ptr( class );
958 /***********************************************************************
959 * SetClassLongW (USER32.@)
961 DWORD WINAPI SetClassLongW( HWND hwnd, INT offset, LONG newval )
963 return CLASS_SetClassLong( hwnd, offset, newval, sizeof(LONG), TRUE );
967 /***********************************************************************
968 * SetClassLongA (USER32.@)
970 DWORD WINAPI SetClassLongA( HWND hwnd, INT offset, LONG newval )
972 return CLASS_SetClassLong( hwnd, offset, newval, sizeof(LONG), FALSE );
976 /***********************************************************************
977 * GetClassNameA (USER32.@)
979 INT WINAPI GetClassNameA( HWND hwnd, LPSTR buffer, INT count )
981 WCHAR tmpbuf[MAX_ATOM_LEN + 1];
984 if (count <= 0) return 0;
985 if (!GetClassNameW( hwnd, tmpbuf, sizeof(tmpbuf)/sizeof(WCHAR) )) return 0;
986 RtlUnicodeToMultiByteN( buffer, count - 1, &len, tmpbuf, strlenW(tmpbuf) * sizeof(WCHAR) );
992 /***********************************************************************
993 * GetClassNameW (USER32.@)
995 INT WINAPI GetClassNameW( HWND hwnd, LPWSTR buffer, INT count )
1000 TRACE("%p %p %d\n", hwnd, buffer, count);
1002 if (count <= 0) return 0;
1004 if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
1006 if (class == CLASS_OTHER_PROCESS)
1008 WCHAR tmpbuf[MAX_ATOM_LEN + 1];
1010 ret = GlobalGetAtomNameW( GetClassLongW( hwnd, GCW_ATOM ), tmpbuf, MAX_ATOM_LEN + 1 );
1013 ret = min(count - 1, ret);
1014 memcpy(buffer, tmpbuf, ret * sizeof(WCHAR));
1020 lstrcpynW( buffer, class->name, count );
1021 release_class_ptr( class );
1022 ret = strlenW( buffer );
1028 /***********************************************************************
1029 * RealGetWindowClassA (USER32.@)
1031 UINT WINAPI RealGetWindowClassA( HWND hwnd, LPSTR buffer, UINT count )
1033 return GetClassNameA( hwnd, buffer, count );
1037 /***********************************************************************
1038 * RealGetWindowClassW (USER32.@)
1040 UINT WINAPI RealGetWindowClassW( HWND hwnd, LPWSTR buffer, UINT count )
1042 return GetClassNameW( hwnd, buffer, count );
1046 /***********************************************************************
1047 * GetClassInfoA (USER32.@)
1049 BOOL WINAPI GetClassInfoA( HINSTANCE hInstance, LPCSTR name, WNDCLASSA *wc )
1052 UINT ret = GetClassInfoExA( hInstance, name, &wcex );
1056 wc->style = wcex.style;
1057 wc->lpfnWndProc = wcex.lpfnWndProc;
1058 wc->cbClsExtra = wcex.cbClsExtra;
1059 wc->cbWndExtra = wcex.cbWndExtra;
1060 wc->hInstance = wcex.hInstance;
1061 wc->hIcon = wcex.hIcon;
1062 wc->hCursor = wcex.hCursor;
1063 wc->hbrBackground = wcex.hbrBackground;
1064 wc->lpszMenuName = wcex.lpszMenuName;
1065 wc->lpszClassName = wcex.lpszClassName;
1071 /***********************************************************************
1072 * GetClassInfoW (USER32.@)
1074 BOOL WINAPI GetClassInfoW( HINSTANCE hInstance, LPCWSTR name, WNDCLASSW *wc )
1077 UINT ret = GetClassInfoExW( hInstance, name, &wcex );
1081 wc->style = wcex.style;
1082 wc->lpfnWndProc = wcex.lpfnWndProc;
1083 wc->cbClsExtra = wcex.cbClsExtra;
1084 wc->cbWndExtra = wcex.cbWndExtra;
1085 wc->hInstance = wcex.hInstance;
1086 wc->hIcon = wcex.hIcon;
1087 wc->hCursor = wcex.hCursor;
1088 wc->hbrBackground = wcex.hbrBackground;
1089 wc->lpszMenuName = wcex.lpszMenuName;
1090 wc->lpszClassName = wcex.lpszClassName;
1096 /***********************************************************************
1097 * GetClassInfoExA (USER32.@)
1099 BOOL WINAPI GetClassInfoExA( HINSTANCE hInstance, LPCSTR name, WNDCLASSEXA *wc )
1104 TRACE("%p %s %p\n", hInstance, debugstr_a(name), wc);
1106 if (!hInstance) hInstance = user32_module;
1108 if (!IS_INTRESOURCE(name))
1110 WCHAR nameW[MAX_ATOM_LEN + 1];
1111 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, nameW, sizeof(nameW)/sizeof(WCHAR) ))
1113 classPtr = CLASS_FindClass( nameW, hInstance );
1115 else classPtr = CLASS_FindClass( (LPCWSTR)name, hInstance );
1119 SetLastError( ERROR_CLASS_DOES_NOT_EXIST );
1122 wc->style = classPtr->style;
1123 wc->lpfnWndProc = WINPROC_GetProc( classPtr->winproc, FALSE );
1124 wc->cbClsExtra = classPtr->cbClsExtra;
1125 wc->cbWndExtra = classPtr->cbWndExtra;
1126 wc->hInstance = (hInstance == user32_module) ? 0 : hInstance;
1127 wc->hIcon = classPtr->hIcon;
1128 wc->hIconSm = classPtr->hIconSm;
1129 wc->hCursor = classPtr->hCursor;
1130 wc->hbrBackground = classPtr->hbrBackground;
1131 wc->lpszMenuName = CLASS_GetMenuNameA( classPtr );
1132 wc->lpszClassName = name;
1133 atom = classPtr->atomName;
1134 release_class_ptr( classPtr );
1136 /* We must return the atom of the class here instead of just TRUE. */
1141 /***********************************************************************
1142 * GetClassInfoExW (USER32.@)
1144 BOOL WINAPI GetClassInfoExW( HINSTANCE hInstance, LPCWSTR name, WNDCLASSEXW *wc )
1149 TRACE("%p %s %p\n", hInstance, debugstr_w(name), wc);
1151 if (!hInstance) hInstance = user32_module;
1153 if (!(classPtr = CLASS_FindClass( name, hInstance )))
1155 SetLastError( ERROR_CLASS_DOES_NOT_EXIST );
1158 wc->style = classPtr->style;
1159 wc->lpfnWndProc = WINPROC_GetProc( classPtr->winproc, TRUE );
1160 wc->cbClsExtra = classPtr->cbClsExtra;
1161 wc->cbWndExtra = classPtr->cbWndExtra;
1162 wc->hInstance = (hInstance == user32_module) ? 0 : hInstance;
1163 wc->hIcon = classPtr->hIcon;
1164 wc->hIconSm = classPtr->hIconSm;
1165 wc->hCursor = classPtr->hCursor;
1166 wc->hbrBackground = classPtr->hbrBackground;
1167 wc->lpszMenuName = CLASS_GetMenuNameW( classPtr );
1168 wc->lpszClassName = name;
1169 atom = classPtr->atomName;
1170 release_class_ptr( classPtr );
1172 /* We must return the atom of the class here instead of just TRUE. */
1177 #if 0 /* toolhelp is in kernel, so this cannot work */
1179 /***********************************************************************
1180 * ClassFirst (TOOLHELP.69)
1182 BOOL16 WINAPI ClassFirst16( CLASSENTRY *pClassEntry )
1184 TRACE("%p\n",pClassEntry);
1185 pClassEntry->wNext = 1;
1186 return ClassNext16( pClassEntry );
1190 /***********************************************************************
1191 * ClassNext (TOOLHELP.70)
1193 BOOL16 WINAPI ClassNext16( CLASSENTRY *pClassEntry )
1196 CLASS *class = firstClass;
1198 TRACE("%p\n",pClassEntry);
1200 if (!pClassEntry->wNext) return FALSE;
1201 for (i = 1; (i < pClassEntry->wNext) && class; i++) class = class->next;
1204 pClassEntry->wNext = 0;
1207 pClassEntry->hInst = class->hInstance;
1208 pClassEntry->wNext++;
1209 GlobalGetAtomNameA( class->atomName, pClassEntry->szClassName,
1210 sizeof(pClassEntry->szClassName) );
1215 /* 64bit versions */
1217 #ifdef GetClassLongPtrA
1218 #undef GetClassLongPtrA
1221 #ifdef GetClassLongPtrW
1222 #undef GetClassLongPtrW
1225 #ifdef SetClassLongPtrA
1226 #undef SetClassLongPtrA
1229 #ifdef SetClassLongPtrW
1230 #undef SetClassLongPtrW
1233 /***********************************************************************
1234 * GetClassLongPtrA (USER32.@)
1236 ULONG_PTR WINAPI GetClassLongPtrA( HWND hwnd, INT offset )
1238 return CLASS_GetClassLong( hwnd, offset, sizeof(ULONG_PTR), FALSE );
1241 /***********************************************************************
1242 * GetClassLongPtrW (USER32.@)
1244 ULONG_PTR WINAPI GetClassLongPtrW( HWND hwnd, INT offset )
1246 return CLASS_GetClassLong( hwnd, offset, sizeof(ULONG_PTR), TRUE );
1249 /***********************************************************************
1250 * SetClassLongPtrW (USER32.@)
1252 ULONG_PTR WINAPI SetClassLongPtrW( HWND hwnd, INT offset, LONG_PTR newval )
1254 return CLASS_SetClassLong( hwnd, offset, newval, sizeof(LONG_PTR), TRUE );
1257 /***********************************************************************
1258 * SetClassLongPtrA (USER32.@)
1260 ULONG_PTR WINAPI SetClassLongPtrA( HWND hwnd, INT offset, LONG_PTR newval )
1262 return CLASS_SetClassLong( hwnd, offset, newval, sizeof(LONG_PTR), FALSE );