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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "wine/port.h"
34 #include "wine/winuser16.h"
35 #include "wine/unicode.h"
37 #include "user_private.h"
40 #include "wine/server.h"
41 #include "wine/list.h"
42 #include "wine/debug.h"
44 WINE_DEFAULT_DEBUG_CHANNEL(class);
46 typedef struct tagCLASS
48 struct list entry
; /* Entry in class list */
49 UINT style
; /* Class style */
50 BOOL local
; /* Local class? */
51 WNDPROC winprocA
; /* Window procedure (ASCII) */
52 WNDPROC winprocW
; /* Window procedure (Unicode) */
53 INT cbClsExtra
; /* Class extra bytes */
54 INT cbWndExtra
; /* Window extra bytes */
55 LPWSTR menuName
; /* Default menu name (Unicode followed by ASCII) */
56 SEGPTR segMenuName
; /* Default menu name as SEGPTR */
57 HINSTANCE hInstance
; /* Module that created the task */
58 HICON hIcon
; /* Default icon */
59 HICON hIconSm
; /* Default small icon */
60 HCURSOR hCursor
; /* Default cursor */
61 HBRUSH hbrBackground
; /* Default background */
62 ATOM atomName
; /* Name of the class */
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;
80 if (write_access
&& (ptr
== WND_DESKTOP
|| IsWindow( hwnd
))) /* check other processes */
82 /* modifying classes in other processes is not allowed */
83 SetLastError( ERROR_ACCESS_DENIED
);
86 return CLASS_OTHER_PROCESS
;
88 SetLastError( ERROR_INVALID_WINDOW_HANDLE
);
93 /***********************************************************************
96 inline static void release_class_ptr( CLASS
*ptr
)
102 /***********************************************************************
105 * Set class info with the wine server.
107 static BOOL
set_server_info( HWND hwnd
, INT offset
, LONG newval
)
111 SERVER_START_REQ( set_class_info
)
114 req
->extra_offset
= -1;
118 req
->flags
= SET_CLASS_ATOM
;
121 req
->flags
= SET_CLASS_STYLE
;
125 req
->flags
= SET_CLASS_WINEXTRA
;
126 req
->win_extra
= newval
;
129 req
->flags
= SET_CLASS_INSTANCE
;
130 req
->instance
= (void *)newval
;
133 assert( offset
>= 0 );
134 req
->flags
= SET_CLASS_EXTRA
;
135 req
->extra_offset
= offset
;
136 req
->extra_size
= sizeof(newval
);
137 memcpy( &req
->extra_value
, &newval
, sizeof(newval
) );
140 ret
= !wine_server_call_err( req
);
147 /***********************************************************************
150 * Get the class winproc for a given proc type
152 static WNDPROC16
CLASS_GetProc( CLASS
*classPtr
, WINDOWPROCTYPE type
)
154 WNDPROC proc
= classPtr
->winprocA
;
156 if (classPtr
->winprocW
)
158 /* if we have a Unicode proc, use it if we have no ASCII proc
159 * or if we have both and Unicode was requested
161 if (!proc
|| type
== WIN_PROC_32W
) proc
= classPtr
->winprocW
;
163 return WINPROC_GetProc( proc
, type
);
167 /***********************************************************************
170 * Set the class winproc for a given proc type.
171 * Returns the previous window proc.
173 static WNDPROC16
CLASS_SetProc( CLASS
*classPtr
, WNDPROC newproc
, WINDOWPROCTYPE type
)
175 WNDPROC
*proc
= &classPtr
->winprocA
;
178 if (classPtr
->winprocW
)
180 /* if we have a Unicode proc, use it if we have no ASCII proc
181 * or if we have both and Unicode was requested
183 if (!*proc
|| type
== WIN_PROC_32W
) proc
= &classPtr
->winprocW
;
185 ret
= WINPROC_GetProc( *proc
, type
);
186 *proc
= WINPROC_AllocProc( newproc
, type
);
187 /* now clear the one that we didn't set */
188 if (classPtr
->winprocA
&& classPtr
->winprocW
)
190 if (proc
== &classPtr
->winprocA
)
191 classPtr
->winprocW
= 0;
193 classPtr
->winprocA
= 0;
199 /***********************************************************************
202 * Get the menu name as a ASCII string.
204 inline static LPSTR
CLASS_GetMenuNameA( CLASS
*classPtr
)
206 if (!HIWORD(classPtr
->menuName
)) return (LPSTR
)classPtr
->menuName
;
207 return (LPSTR
)(classPtr
->menuName
+ strlenW(classPtr
->menuName
) + 1);
211 /***********************************************************************
212 * CLASS_GetMenuName16
214 * Get the menu name as a SEGPTR.
216 inline static SEGPTR
CLASS_GetMenuName16( CLASS
*classPtr
)
218 if (!HIWORD(classPtr
->menuName
)) return (SEGPTR
)classPtr
->menuName
;
219 if (!classPtr
->segMenuName
)
220 classPtr
->segMenuName
= MapLS( CLASS_GetMenuNameA(classPtr
) );
221 return classPtr
->segMenuName
;
225 /***********************************************************************
228 * Get the menu name as a Unicode string.
230 inline static LPWSTR
CLASS_GetMenuNameW( CLASS
*classPtr
)
232 return classPtr
->menuName
;
236 /***********************************************************************
239 * Set the menu name in a class structure by copying the string.
241 static void CLASS_SetMenuNameA( CLASS
*classPtr
, LPCSTR name
)
243 UnMapLS( classPtr
->segMenuName
);
244 classPtr
->segMenuName
= 0;
245 if (HIWORD(classPtr
->menuName
)) HeapFree( GetProcessHeap(), 0, classPtr
->menuName
);
248 DWORD lenA
= strlen(name
) + 1;
249 DWORD lenW
= MultiByteToWideChar( CP_ACP
, 0, name
, lenA
, NULL
, 0 );
250 classPtr
->menuName
= HeapAlloc( GetProcessHeap(), 0, lenA
+ lenW
*sizeof(WCHAR
) );
251 MultiByteToWideChar( CP_ACP
, 0, name
, lenA
, classPtr
->menuName
, lenW
);
252 memcpy( classPtr
->menuName
+ lenW
, name
, lenA
);
254 else classPtr
->menuName
= (LPWSTR
)name
;
258 /***********************************************************************
261 * Set the menu name in a class structure by copying the string.
263 static void CLASS_SetMenuNameW( CLASS
*classPtr
, LPCWSTR name
)
265 UnMapLS( classPtr
->segMenuName
);
266 classPtr
->segMenuName
= 0;
267 if (HIWORD(classPtr
->menuName
)) HeapFree( GetProcessHeap(), 0, classPtr
->menuName
);
270 DWORD lenW
= strlenW(name
) + 1;
271 DWORD lenA
= WideCharToMultiByte( CP_ACP
, 0, name
, lenW
, NULL
, 0, NULL
, NULL
);
272 classPtr
->menuName
= HeapAlloc( GetProcessHeap(), 0, lenA
+ lenW
*sizeof(WCHAR
) );
273 memcpy( classPtr
->menuName
, name
, lenW
*sizeof(WCHAR
) );
274 WideCharToMultiByte( CP_ACP
, 0, name
, lenW
,
275 (char *)(classPtr
->menuName
+ lenW
), lenA
, NULL
, NULL
);
277 else classPtr
->menuName
= (LPWSTR
)name
;
281 /***********************************************************************
284 * Free a class structure.
286 static void CLASS_FreeClass( CLASS
*classPtr
)
288 TRACE("%p\n", classPtr
);
292 list_remove( &classPtr
->entry
);
293 if (classPtr
->hbrBackground
> (HBRUSH
)(COLOR_GRADIENTINACTIVECAPTION
+ 1))
294 DeleteObject( classPtr
->hbrBackground
);
295 UnMapLS( classPtr
->segMenuName
);
296 HeapFree( GetProcessHeap(), 0, classPtr
->menuName
);
297 HeapFree( GetProcessHeap(), 0, classPtr
);
302 /***********************************************************************
303 * CLASS_FreeModuleClasses
305 void CLASS_FreeModuleClasses( HMODULE16 hModule
)
307 struct list
*ptr
, *next
;
309 TRACE("0x%08x\n", hModule
);
312 for (ptr
= list_head( &class_list
); ptr
; ptr
= next
)
314 CLASS
*class = LIST_ENTRY( ptr
, CLASS
, entry
);
315 next
= list_next( &class_list
, ptr
);
316 if (class->hInstance
== HINSTANCE_32(hModule
))
320 SERVER_START_REQ( destroy_class
)
322 req
->atom
= class->atomName
;
323 req
->instance
= class->hInstance
;
324 ret
= !wine_server_call_err( req
);
327 if (ret
) CLASS_FreeClass( class );
334 /***********************************************************************
335 * CLASS_FindClassByAtom
337 * Return a pointer to the class.
338 * hinstance has been normalized by the caller.
340 static CLASS
*CLASS_FindClassByAtom( ATOM atom
, HINSTANCE hinstance
)
346 LIST_FOR_EACH( ptr
, &class_list
)
348 CLASS
*class = LIST_ENTRY( ptr
, CLASS
, entry
);
349 if (class->atomName
!= atom
) continue;
350 if (!hinstance
|| !class->local
|| class->hInstance
== hinstance
)
352 TRACE("0x%04x %p -> %p\n", atom
, hinstance
, class);
357 TRACE("0x%04x %p -> not found\n", atom
, hinstance
);
362 /***********************************************************************
363 * CLASS_RegisterClass
365 * The real RegisterClass() functionality.
366 * The atom is deleted no matter what.
368 static CLASS
*CLASS_RegisterClass( ATOM atom
, HINSTANCE hInstance
, BOOL local
,
369 DWORD style
, INT classExtra
, INT winExtra
)
374 TRACE("atom=0x%x hinst=%p style=0x%lx clExtr=0x%x winExtr=0x%x\n",
375 atom
, hInstance
, style
, classExtra
, winExtra
);
377 /* Fix the extra bytes value */
379 if (classExtra
< 0 || winExtra
< 0)
381 SetLastError( ERROR_INVALID_PARAMETER
);
384 if (classExtra
> 40) /* Extra bytes are limited to 40 in Win32 */
385 WARN("Class extra bytes %d is > 40\n", classExtra
);
386 if (winExtra
> 40) /* Extra bytes are limited to 40 in Win32 */
387 WARN("Win extra bytes %d is > 40\n", winExtra
);
389 classPtr
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(CLASS
) + classExtra
);
392 GlobalDeleteAtom( atom
);
396 SERVER_START_REQ( create_class
)
401 req
->instance
= hInstance
;
402 req
->extra
= classExtra
;
403 req
->win_extra
= winExtra
;
404 req
->client_ptr
= classPtr
;
405 ret
= !wine_server_call_err( req
);
408 GlobalDeleteAtom( atom
); /* the server increased the atom ref count */
411 HeapFree( GetProcessHeap(), 0, classPtr
);
415 classPtr
->style
= style
;
416 classPtr
->local
= local
;
417 classPtr
->cbWndExtra
= winExtra
;
418 classPtr
->cbClsExtra
= classExtra
;
419 classPtr
->hInstance
= hInstance
;
420 classPtr
->atomName
= atom
;
422 /* Other non-null values must be set by caller */
425 if (local
) list_add_head( &class_list
, &classPtr
->entry
);
426 else list_add_tail( &class_list
, &classPtr
->entry
);
431 /***********************************************************************
434 * Register a builtin control class.
435 * This allows having both ASCII and Unicode winprocs for the same class.
437 static CLASS
*register_builtin( const struct builtin_class_descr
*descr
)
442 if (!(atom
= GlobalAddAtomA( descr
->name
))) return 0;
444 if (!(classPtr
= CLASS_RegisterClass( atom
, user32_module
, FALSE
,
445 descr
->style
, 0, descr
->extra
))) return 0;
447 classPtr
->hCursor
= LoadCursorA( 0, (LPSTR
)descr
->cursor
);
448 classPtr
->hbrBackground
= descr
->brush
;
450 if (descr
->procA
) classPtr
->winprocA
= WINPROC_AllocProc( descr
->procA
, WIN_PROC_32A
);
451 if (descr
->procW
) classPtr
->winprocW
= WINPROC_AllocProc( descr
->procW
, WIN_PROC_32W
);
452 release_class_ptr( classPtr
);
457 /***********************************************************************
458 * CLASS_RegisterBuiltinClasses
460 void CLASS_RegisterBuiltinClasses(void)
462 extern const struct builtin_class_descr BUTTON_builtin_class
;
463 extern const struct builtin_class_descr COMBO_builtin_class
;
464 extern const struct builtin_class_descr COMBOLBOX_builtin_class
;
465 extern const struct builtin_class_descr DIALOG_builtin_class
;
466 extern const struct builtin_class_descr DESKTOP_builtin_class
;
467 extern const struct builtin_class_descr EDIT_builtin_class
;
468 extern const struct builtin_class_descr ICONTITLE_builtin_class
;
469 extern const struct builtin_class_descr LISTBOX_builtin_class
;
470 extern const struct builtin_class_descr MDICLIENT_builtin_class
;
471 extern const struct builtin_class_descr MENU_builtin_class
;
472 extern const struct builtin_class_descr SCROLL_builtin_class
;
473 extern const struct builtin_class_descr STATIC_builtin_class
;
475 register_builtin( &DESKTOP_builtin_class
);
476 register_builtin( &BUTTON_builtin_class
);
477 register_builtin( &COMBO_builtin_class
);
478 register_builtin( &COMBOLBOX_builtin_class
);
479 register_builtin( &DIALOG_builtin_class
);
480 register_builtin( &EDIT_builtin_class
);
481 register_builtin( &ICONTITLE_builtin_class
);
482 register_builtin( &LISTBOX_builtin_class
);
483 register_builtin( &MDICLIENT_builtin_class
);
484 register_builtin( &MENU_builtin_class
);
485 register_builtin( &SCROLL_builtin_class
);
486 register_builtin( &STATIC_builtin_class
);
490 /***********************************************************************
493 * Add a new window using this class, and set the necessary
494 * information inside the window structure.
496 void CLASS_AddWindow( CLASS
*class, WND
*win
, WINDOWPROCTYPE type
)
498 if (type
== WIN_PROC_32W
)
500 if (!(win
->winproc
= class->winprocW
)) win
->winproc
= class->winprocA
;
504 if (!(win
->winproc
= class->winprocA
)) win
->winproc
= class->winprocW
;
507 win
->clsStyle
= class->style
;
511 /***********************************************************************
512 * RegisterClassA (USER32.@)
514 * Register a window class.
517 * >0: Unique identifier
520 ATOM WINAPI
RegisterClassA( const WNDCLASSA
* wc
) /* [in] Address of structure with class data */
524 wcex
.cbSize
= sizeof(wcex
);
525 wcex
.style
= wc
->style
;
526 wcex
.lpfnWndProc
= wc
->lpfnWndProc
;
527 wcex
.cbClsExtra
= wc
->cbClsExtra
;
528 wcex
.cbWndExtra
= wc
->cbWndExtra
;
529 wcex
.hInstance
= wc
->hInstance
;
530 wcex
.hIcon
= wc
->hIcon
;
531 wcex
.hCursor
= wc
->hCursor
;
532 wcex
.hbrBackground
= wc
->hbrBackground
;
533 wcex
.lpszMenuName
= wc
->lpszMenuName
;
534 wcex
.lpszClassName
= wc
->lpszClassName
;
536 return RegisterClassExA( &wcex
);
540 /***********************************************************************
541 * RegisterClassW (USER32.@)
543 * See RegisterClassA.
545 ATOM WINAPI
RegisterClassW( const WNDCLASSW
* wc
)
549 wcex
.cbSize
= sizeof(wcex
);
550 wcex
.style
= wc
->style
;
551 wcex
.lpfnWndProc
= wc
->lpfnWndProc
;
552 wcex
.cbClsExtra
= wc
->cbClsExtra
;
553 wcex
.cbWndExtra
= wc
->cbWndExtra
;
554 wcex
.hInstance
= wc
->hInstance
;
555 wcex
.hIcon
= wc
->hIcon
;
556 wcex
.hCursor
= wc
->hCursor
;
557 wcex
.hbrBackground
= wc
->hbrBackground
;
558 wcex
.lpszMenuName
= wc
->lpszMenuName
;
559 wcex
.lpszClassName
= wc
->lpszClassName
;
561 return RegisterClassExW( &wcex
);
565 /***********************************************************************
566 * RegisterClassExA (USER32.@)
568 ATOM WINAPI
RegisterClassExA( const WNDCLASSEXA
* wc
)
574 if (wc
->hInstance
== user32_module
)
576 /* we can't register a class for user32 */
577 SetLastError( ERROR_INVALID_PARAMETER
);
580 if (!(instance
= wc
->hInstance
)) instance
= GetModuleHandleW( NULL
);
582 if (!(atom
= GlobalAddAtomA( wc
->lpszClassName
))) return 0;
584 if (!(classPtr
= CLASS_RegisterClass( atom
, instance
, !(wc
->style
& CS_GLOBALCLASS
),
585 wc
->style
, wc
->cbClsExtra
, wc
->cbWndExtra
)))
588 TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
589 atom
, wc
->lpfnWndProc
, instance
, wc
->hbrBackground
,
590 wc
->style
, wc
->cbClsExtra
, wc
->cbWndExtra
, classPtr
);
592 classPtr
->hIcon
= wc
->hIcon
;
593 classPtr
->hIconSm
= wc
->hIconSm
;
594 classPtr
->hCursor
= wc
->hCursor
;
595 classPtr
->hbrBackground
= wc
->hbrBackground
;
596 classPtr
->winprocA
= WINPROC_AllocProc( wc
->lpfnWndProc
, WIN_PROC_32A
);
597 CLASS_SetMenuNameA( classPtr
, wc
->lpszMenuName
);
598 release_class_ptr( classPtr
);
603 /***********************************************************************
604 * RegisterClassExW (USER32.@)
606 ATOM WINAPI
RegisterClassExW( const WNDCLASSEXW
* wc
)
612 if (wc
->hInstance
== user32_module
)
614 /* we can't register a class for user32 */
615 SetLastError( ERROR_INVALID_PARAMETER
);
618 if (!(instance
= wc
->hInstance
)) instance
= GetModuleHandleW( NULL
);
620 if (!(atom
= GlobalAddAtomW( wc
->lpszClassName
))) return 0;
622 if (!(classPtr
= CLASS_RegisterClass( atom
, instance
, !(wc
->style
& CS_GLOBALCLASS
),
623 wc
->style
, wc
->cbClsExtra
, wc
->cbWndExtra
)))
626 TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
627 atom
, wc
->lpfnWndProc
, instance
, wc
->hbrBackground
,
628 wc
->style
, wc
->cbClsExtra
, wc
->cbWndExtra
, classPtr
);
630 classPtr
->hIcon
= wc
->hIcon
;
631 classPtr
->hIconSm
= wc
->hIconSm
;
632 classPtr
->hCursor
= wc
->hCursor
;
633 classPtr
->hbrBackground
= wc
->hbrBackground
;
634 classPtr
->winprocW
= WINPROC_AllocProc( wc
->lpfnWndProc
, WIN_PROC_32W
);
635 CLASS_SetMenuNameW( classPtr
, wc
->lpszMenuName
);
636 release_class_ptr( classPtr
);
641 /***********************************************************************
642 * UnregisterClassA (USER32.@)
644 BOOL WINAPI
UnregisterClassA( LPCSTR className
, HINSTANCE hInstance
)
646 ATOM atom
= HIWORD(className
) ? GlobalFindAtomA( className
) : LOWORD(className
);
647 return UnregisterClassW( MAKEINTATOMW(atom
), hInstance
);
650 /***********************************************************************
651 * UnregisterClassW (USER32.@)
653 BOOL WINAPI
UnregisterClassW( LPCWSTR className
, HINSTANCE hInstance
)
655 CLASS
*classPtr
= NULL
;
656 ATOM atom
= HIWORD(className
) ? GlobalFindAtomW( className
) : LOWORD(className
);
658 TRACE("%s %p %x\n",debugstr_w(className
), hInstance
, atom
);
662 SetLastError( ERROR_CLASS_DOES_NOT_EXIST
);
666 SERVER_START_REQ( destroy_class
)
669 req
->instance
= hInstance
;
670 if (!wine_server_call_err( req
)) classPtr
= reply
->client_ptr
;
674 if (classPtr
) CLASS_FreeClass( classPtr
);
675 return (classPtr
!= NULL
);
679 /***********************************************************************
680 * GetClassWord (USER32.@)
682 WORD WINAPI
GetClassWord( HWND hwnd
, INT offset
)
687 if (offset
< 0) return GetClassLongA( hwnd
, offset
);
689 TRACE("%p %x\n",hwnd
, offset
);
691 if (!(class = get_class_ptr( hwnd
, FALSE
))) return 0;
693 if (class == CLASS_OTHER_PROCESS
)
695 SERVER_START_REQ( set_class_info
)
699 req
->extra_offset
= offset
;
700 req
->extra_size
= sizeof(retvalue
);
701 if (!wine_server_call_err( req
))
702 memcpy( &retvalue
, &reply
->old_extra_value
, sizeof(retvalue
) );
708 if (offset
<= class->cbClsExtra
- sizeof(WORD
))
709 memcpy( &retvalue
, (char *)(class + 1) + offset
, sizeof(retvalue
) );
711 SetLastError( ERROR_INVALID_INDEX
);
712 release_class_ptr( class );
717 /***********************************************************************
718 * GetClassLong (USER.131)
720 LONG WINAPI
GetClassLong16( HWND16 hwnd16
, INT16 offset
)
724 HWND hwnd
= (HWND
)(ULONG_PTR
)hwnd16
; /* no need for full handle */
726 TRACE("%p %d\n",hwnd
, offset
);
731 if (!(class = get_class_ptr( hwnd
, FALSE
))) return 0;
732 if (class == CLASS_OTHER_PROCESS
) break;
733 ret
= (LONG
)CLASS_GetProc( class, WIN_PROC_16
);
734 release_class_ptr( class );
737 if (!(class = get_class_ptr( hwnd
, FALSE
))) return 0;
738 if (class == CLASS_OTHER_PROCESS
) break;
739 ret
= (LONG
)CLASS_GetMenuName16( class );
740 release_class_ptr( class );
743 return GetClassLongA( hwnd
, offset
);
745 FIXME( "offset %d not supported on other process window %p\n", offset
, hwnd
);
746 SetLastError( ERROR_INVALID_HANDLE
);
751 /***********************************************************************
752 * GetClassLongW (USER32.@)
754 DWORD WINAPI
GetClassLongW( HWND hwnd
, INT offset
)
759 TRACE("%p %d\n", hwnd
, offset
);
761 if (!(class = get_class_ptr( hwnd
, FALSE
))) return 0;
763 if (class == CLASS_OTHER_PROCESS
)
765 SERVER_START_REQ( set_class_info
)
769 req
->extra_offset
= (offset
>= 0) ? offset
: -1;
770 req
->extra_size
= (offset
>= 0) ? sizeof(retvalue
) : 0;
771 if (!wine_server_call_err( req
))
775 case GCLP_HBRBACKGROUND
:
781 FIXME( "offset %d not supported on other process window %p\n", offset
, hwnd
);
782 SetLastError( ERROR_INVALID_HANDLE
);
785 retvalue
= reply
->old_style
;
788 retvalue
= reply
->old_win_extra
;
791 retvalue
= reply
->old_extra
;
794 retvalue
= (DWORD
)reply
->old_instance
;
797 retvalue
= reply
->old_atom
;
800 if (offset
>= 0) memcpy( &retvalue
, &reply
->old_extra_value
, sizeof(retvalue
) );
801 else SetLastError( ERROR_INVALID_INDEX
);
812 if (offset
<= class->cbClsExtra
- sizeof(LONG
))
813 memcpy( &retvalue
, (char *)(class + 1) + offset
, sizeof(retvalue
) );
815 SetLastError( ERROR_INVALID_INDEX
);
816 release_class_ptr( class );
822 case GCLP_HBRBACKGROUND
:
823 retvalue
= (DWORD
)class->hbrBackground
;
826 retvalue
= (DWORD
)class->hCursor
;
829 retvalue
= (DWORD
)class->hIcon
;
832 retvalue
= (DWORD
)class->hIconSm
;
835 retvalue
= (DWORD
)class->style
;
838 retvalue
= (DWORD
)class->cbWndExtra
;
841 retvalue
= (DWORD
)class->cbClsExtra
;
844 retvalue
= (DWORD
)class->hInstance
;
847 retvalue
= (DWORD
)CLASS_GetProc( class, WIN_PROC_32W
);
850 retvalue
= (DWORD
)CLASS_GetMenuNameW( class );
853 retvalue
= (DWORD
)class->atomName
;
856 SetLastError( ERROR_INVALID_INDEX
);
859 release_class_ptr( class );
864 /***********************************************************************
865 * GetClassLongA (USER32.@)
867 DWORD WINAPI
GetClassLongA( HWND hwnd
, INT offset
)
872 if (offset
!= GCLP_WNDPROC
&& offset
!= GCLP_MENUNAME
)
873 return GetClassLongW( hwnd
, offset
);
875 TRACE("%p %d\n", hwnd
, offset
);
877 if (!(class = get_class_ptr( hwnd
, FALSE
))) return 0;
879 if (class == CLASS_OTHER_PROCESS
)
881 FIXME( "offset %d not supported on other process window %p\n", offset
, hwnd
);
882 SetLastError( ERROR_INVALID_HANDLE
);
886 if (offset
== GCLP_WNDPROC
)
887 retvalue
= (DWORD
)CLASS_GetProc( class, WIN_PROC_32A
);
888 else /* GCL_MENUNAME */
889 retvalue
= (DWORD
)CLASS_GetMenuNameA( class );
891 release_class_ptr( class );
896 /***********************************************************************
897 * SetClassWord (USER32.@)
899 WORD WINAPI
SetClassWord( HWND hwnd
, INT offset
, WORD newval
)
904 if (offset
< 0) return SetClassLongA( hwnd
, offset
, (DWORD
)newval
);
906 TRACE("%p %d %x\n", hwnd
, offset
, newval
);
908 if (!(class = get_class_ptr( hwnd
, TRUE
))) return 0;
910 SERVER_START_REQ( set_class_info
)
913 req
->flags
= SET_CLASS_EXTRA
;
914 req
->extra_offset
= offset
;
915 req
->extra_size
= sizeof(newval
);
916 memcpy( &req
->extra_value
, &newval
, sizeof(newval
) );
917 if (!wine_server_call_err( req
))
919 void *ptr
= (char *)(class + 1) + offset
;
920 memcpy( &retval
, ptr
, sizeof(retval
) );
921 memcpy( ptr
, &newval
, sizeof(newval
) );
925 release_class_ptr( class );
930 /***********************************************************************
931 * SetClassLong (USER.132)
933 LONG WINAPI
SetClassLong16( HWND16 hwnd16
, INT16 offset
, LONG newval
)
937 HWND hwnd
= (HWND
)(ULONG_PTR
)hwnd16
; /* no need for full handle */
939 TRACE("%p %d %lx\n", hwnd
, offset
, newval
);
944 if (!(class = get_class_ptr( hwnd
, TRUE
))) return 0;
945 retval
= (LONG
)CLASS_SetProc( class, (WNDPROC
)newval
, WIN_PROC_16
);
946 release_class_ptr( class );
949 newval
= (LONG
)MapSL( newval
);
952 return SetClassLongA( hwnd
, offset
, newval
);
957 /***********************************************************************
958 * SetClassLongW (USER32.@)
960 DWORD WINAPI
SetClassLongW( HWND hwnd
, INT offset
, LONG newval
)
965 TRACE("%p %d %lx\n", hwnd
, offset
, newval
);
967 if (!(class = get_class_ptr( hwnd
, TRUE
))) return 0;
971 if (set_server_info( hwnd
, offset
, newval
))
973 void *ptr
= (char *)(class + 1) + offset
;
974 memcpy( &retval
, ptr
, sizeof(retval
) );
975 memcpy( ptr
, &newval
, sizeof(newval
) );
981 CLASS_SetMenuNameW( class, (LPCWSTR
)newval
);
982 retval
= 0; /* Old value is now meaningless anyway */
985 retval
= (DWORD
)CLASS_SetProc( class, (WNDPROC
)newval
, WIN_PROC_32W
);
987 case GCLP_HBRBACKGROUND
:
988 retval
= (DWORD
)class->hbrBackground
;
989 class->hbrBackground
= (HBRUSH
)newval
;
992 retval
= (DWORD
)class->hCursor
;
993 class->hCursor
= (HCURSOR
)newval
;
996 retval
= (DWORD
)class->hIcon
;
997 class->hIcon
= (HICON
)newval
;
1000 retval
= (DWORD
)class->hIconSm
;
1001 class->hIconSm
= (HICON
)newval
;
1004 if (!set_server_info( hwnd
, offset
, newval
)) break;
1005 retval
= (DWORD
)class->style
;
1006 class->style
= newval
;
1008 case GCL_CBWNDEXTRA
:
1009 if (!set_server_info( hwnd
, offset
, newval
)) break;
1010 retval
= (DWORD
)class->cbWndExtra
;
1011 class->cbWndExtra
= newval
;
1014 if (!set_server_info( hwnd
, offset
, newval
)) break;
1015 retval
= (DWORD
)class->hInstance
;
1016 class->hInstance
= (HINSTANCE
)newval
;
1019 if (!set_server_info( hwnd
, offset
, newval
)) break;
1020 retval
= (DWORD
)class->atomName
;
1021 class->atomName
= newval
;
1023 case GCL_CBCLSEXTRA
: /* cannot change this one */
1024 SetLastError( ERROR_INVALID_PARAMETER
);
1027 SetLastError( ERROR_INVALID_INDEX
);
1030 release_class_ptr( class );
1035 /***********************************************************************
1036 * SetClassLongA (USER32.@)
1038 DWORD WINAPI
SetClassLongA( HWND hwnd
, INT offset
, LONG newval
)
1043 if (offset
!= GCLP_WNDPROC
&& offset
!= GCLP_MENUNAME
)
1044 return SetClassLongW( hwnd
, offset
, newval
);
1046 TRACE("%p %d %lx\n", hwnd
, offset
, newval
);
1048 if (!(class = get_class_ptr( hwnd
, TRUE
))) return 0;
1050 if (offset
== GCLP_WNDPROC
)
1051 retval
= (DWORD
)CLASS_SetProc( class, (WNDPROC
)newval
, WIN_PROC_32A
);
1052 else /* GCL_MENUNAME */
1054 CLASS_SetMenuNameA( class, (LPCSTR
)newval
);
1055 retval
= 0; /* Old value is now meaningless anyway */
1057 release_class_ptr( class );
1062 /***********************************************************************
1063 * GetClassNameA (USER32.@)
1065 INT WINAPI
GetClassNameA( HWND hwnd
, LPSTR buffer
, INT count
)
1067 INT ret
= GlobalGetAtomNameA( GetClassLongA( hwnd
, GCW_ATOM
), buffer
, count
);
1069 TRACE("%p %s %x\n",hwnd
, debugstr_a(buffer
), count
);
1074 /***********************************************************************
1075 * GetClassNameW (USER32.@)
1077 INT WINAPI
GetClassNameW( HWND hwnd
, LPWSTR buffer
, INT count
)
1079 INT ret
= GlobalGetAtomNameW( GetClassLongW( hwnd
, GCW_ATOM
), buffer
, count
);
1081 TRACE("%p %s %x\n",hwnd
, debugstr_w(buffer
), count
);
1086 /***********************************************************************
1087 * RealGetWindowClassA (USER32.@)
1089 UINT WINAPI
RealGetWindowClassA( HWND hwnd
, LPSTR buffer
, UINT count
)
1091 return GetClassNameA( hwnd
, buffer
, count
);
1095 /***********************************************************************
1096 * RealGetWindowClassW (USER32.@)
1098 UINT WINAPI
RealGetWindowClassW( HWND hwnd
, LPWSTR buffer
, UINT count
)
1100 return GetClassNameW( hwnd
, buffer
, count
);
1104 /***********************************************************************
1105 * GetClassInfoA (USER32.@)
1107 BOOL WINAPI
GetClassInfoA( HINSTANCE hInstance
, LPCSTR name
, WNDCLASSA
*wc
)
1110 UINT ret
= GetClassInfoExA( hInstance
, name
, &wcex
);
1114 wc
->style
= wcex
.style
;
1115 wc
->lpfnWndProc
= wcex
.lpfnWndProc
;
1116 wc
->cbClsExtra
= wcex
.cbClsExtra
;
1117 wc
->cbWndExtra
= wcex
.cbWndExtra
;
1118 wc
->hInstance
= wcex
.hInstance
;
1119 wc
->hIcon
= wcex
.hIcon
;
1120 wc
->hCursor
= wcex
.hCursor
;
1121 wc
->hbrBackground
= wcex
.hbrBackground
;
1122 wc
->lpszMenuName
= wcex
.lpszMenuName
;
1123 wc
->lpszClassName
= wcex
.lpszClassName
;
1129 /***********************************************************************
1130 * GetClassInfoW (USER32.@)
1132 BOOL WINAPI
GetClassInfoW( HINSTANCE hInstance
, LPCWSTR name
, WNDCLASSW
*wc
)
1135 UINT ret
= GetClassInfoExW( hInstance
, name
, &wcex
);
1139 wc
->style
= wcex
.style
;
1140 wc
->lpfnWndProc
= wcex
.lpfnWndProc
;
1141 wc
->cbClsExtra
= wcex
.cbClsExtra
;
1142 wc
->cbWndExtra
= wcex
.cbWndExtra
;
1143 wc
->hInstance
= wcex
.hInstance
;
1144 wc
->hIcon
= wcex
.hIcon
;
1145 wc
->hCursor
= wcex
.hCursor
;
1146 wc
->hbrBackground
= wcex
.hbrBackground
;
1147 wc
->lpszMenuName
= wcex
.lpszMenuName
;
1148 wc
->lpszClassName
= wcex
.lpszClassName
;
1154 /***********************************************************************
1155 * GetClassInfoExA (USER32.@)
1157 BOOL WINAPI
GetClassInfoExA( HINSTANCE hInstance
, LPCSTR name
, WNDCLASSEXA
*wc
)
1159 ATOM atom
= HIWORD(name
) ? GlobalFindAtomA( name
) : LOWORD(name
);
1162 TRACE("%p %s %x %p\n", hInstance
, debugstr_a(name
), atom
, wc
);
1164 if (!hInstance
) hInstance
= user32_module
;
1166 if (!atom
|| !(classPtr
= CLASS_FindClassByAtom( atom
, hInstance
)))
1168 SetLastError( ERROR_CLASS_DOES_NOT_EXIST
);
1171 wc
->style
= classPtr
->style
;
1172 wc
->lpfnWndProc
= (WNDPROC
)CLASS_GetProc( classPtr
, WIN_PROC_32A
);
1173 wc
->cbClsExtra
= classPtr
->cbClsExtra
;
1174 wc
->cbWndExtra
= classPtr
->cbWndExtra
;
1175 wc
->hInstance
= (hInstance
== user32_module
) ? 0 : hInstance
;
1176 wc
->hIcon
= (HICON
)classPtr
->hIcon
;
1177 wc
->hIconSm
= (HICON
)classPtr
->hIconSm
;
1178 wc
->hCursor
= (HCURSOR
)classPtr
->hCursor
;
1179 wc
->hbrBackground
= (HBRUSH
)classPtr
->hbrBackground
;
1180 wc
->lpszMenuName
= CLASS_GetMenuNameA( classPtr
);
1181 wc
->lpszClassName
= name
;
1182 release_class_ptr( classPtr
);
1184 /* We must return the atom of the class here instead of just TRUE. */
1189 /***********************************************************************
1190 * GetClassInfoExW (USER32.@)
1192 BOOL WINAPI
GetClassInfoExW( HINSTANCE hInstance
, LPCWSTR name
, WNDCLASSEXW
*wc
)
1194 ATOM atom
= HIWORD(name
) ? GlobalFindAtomW( name
) : LOWORD(name
);
1197 TRACE("%p %s %x %p\n", hInstance
, debugstr_w(name
), atom
, wc
);
1199 if (!hInstance
) hInstance
= user32_module
;
1201 if (!atom
|| !(classPtr
= CLASS_FindClassByAtom( atom
, hInstance
)))
1203 SetLastError( ERROR_CLASS_DOES_NOT_EXIST
);
1206 wc
->style
= classPtr
->style
;
1207 wc
->lpfnWndProc
= (WNDPROC
)CLASS_GetProc( classPtr
, WIN_PROC_32W
);
1208 wc
->cbClsExtra
= classPtr
->cbClsExtra
;
1209 wc
->cbWndExtra
= classPtr
->cbWndExtra
;
1210 wc
->hInstance
= (hInstance
== user32_module
) ? 0 : hInstance
;
1211 wc
->hIcon
= (HICON
)classPtr
->hIcon
;
1212 wc
->hIconSm
= (HICON
)classPtr
->hIconSm
;
1213 wc
->hCursor
= (HCURSOR
)classPtr
->hCursor
;
1214 wc
->hbrBackground
= (HBRUSH
)classPtr
->hbrBackground
;
1215 wc
->lpszMenuName
= CLASS_GetMenuNameW( classPtr
);
1216 wc
->lpszClassName
= name
;
1217 release_class_ptr( classPtr
);
1219 /* We must return the atom of the class here instead of just TRUE. */
1224 #if 0 /* toolhelp is in kernel, so this cannot work */
1226 /***********************************************************************
1227 * ClassFirst (TOOLHELP.69)
1229 BOOL16 WINAPI
ClassFirst16( CLASSENTRY
*pClassEntry
)
1231 TRACE("%p\n",pClassEntry
);
1232 pClassEntry
->wNext
= 1;
1233 return ClassNext16( pClassEntry
);
1237 /***********************************************************************
1238 * ClassNext (TOOLHELP.70)
1240 BOOL16 WINAPI
ClassNext16( CLASSENTRY
*pClassEntry
)
1243 CLASS
*class = firstClass
;
1245 TRACE("%p\n",pClassEntry
);
1247 if (!pClassEntry
->wNext
) return FALSE
;
1248 for (i
= 1; (i
< pClassEntry
->wNext
) && class; i
++) class = class->next
;
1251 pClassEntry
->wNext
= 0;
1254 pClassEntry
->hInst
= class->hInstance
;
1255 pClassEntry
->wNext
++;
1256 GlobalGetAtomNameA( class->atomName
, pClassEntry
->szClassName
,
1257 sizeof(pClassEntry
->szClassName
) );