?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
user32: Added missing break.
[wine.git] / dlls / user32 / class.c
blob8b5060a628b6111b33b11f3e64e8e6c38697a2e8
1 /*
2 * Window classes functions
3 *
4 * Copyright 1993, 1996, 2003 Alexandre Julliard
5 * Copyright 1998 Juergen Schmied (jsch)
6 *
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.
11 *
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.
16 *
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
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdarg.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "winerror.h"
31 #include "windef.h"
32 #include "winbase.h"
33 #include "wingdi.h"
34 #include "wine/unicode.h"
35 #include "win.h"
36 #include "user_private.h"
37 #include "controls.h"
38 #include "wine/server.h"
39 #include "wine/list.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(class);
43
44 #define MAX_ATOM_LEN 255 /* from dlls/kernel32/atom.c */
45
46 typedef struct tagCLASS
47 {
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];
63 } CLASS;
64
65 static struct list class_list = LIST_INIT( class_list );
66
67 #define CLASS_OTHER_PROCESS ((CLASS *)1)
68
69 /***********************************************************************
70 * get_class_ptr
71 */
72 static CLASS *get_class_ptr( HWND hwnd, BOOL write_access )
73 {
74 WND *ptr = WIN_GetPtr( hwnd );
75
76 if (ptr)
77 {
78 if (ptr != WND_OTHER_PROCESS && ptr != WND_DESKTOP) return ptr->class;
79 if (!write_access) return CLASS_OTHER_PROCESS;
80
81 /* modifying classes in other processes is not allowed */
82 if (ptr == WND_DESKTOP || IsWindow( hwnd ))
83 {
84 SetLastError( ERROR_ACCESS_DENIED );
85 return NULL;
86 }
87 }
88 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
89 return NULL;
90 }
91
92
93 /***********************************************************************
94 * release_class_ptr
95 */
96 static inline void release_class_ptr( CLASS *ptr )
97 {
98 USER_Unlock();
99 }
100
101
102 /***********************************************************************
103 * get_int_atom_value
104 */
105 ATOM get_int_atom_value( LPCWSTR name )
106 {
107 UINT ret = 0;
108
109 if (IS_INTRESOURCE(name)) return LOWORD(name);
110 if (*name++ != '#') return 0;
111 while (*name)
112 {
113 if (*name < '0' || *name > '9') return 0;
114 ret = ret * 10 + *name++ - '0';
115 if (ret > 0xffff) return 0;
116 }
117 return ret;
118 }
119
120
121 /***********************************************************************
122 * set_server_info
123 *
124 * Set class info with the wine server.
125 */
126 static BOOL set_server_info( HWND hwnd, INT offset, LONG_PTR newval, UINT size )
127 {
128 BOOL ret;
129
130 SERVER_START_REQ( set_class_info )
131 {
132 req->window = wine_server_user_handle( hwnd );
133 req->extra_offset = -1;
134 switch(offset)
135 {
136 case GCW_ATOM:
137 req->flags = SET_CLASS_ATOM;
138 req->atom = LOWORD(newval);
139 break;
140 case GCL_STYLE:
141 req->flags = SET_CLASS_STYLE;
142 req->style = newval;
143 break;
144 case GCL_CBWNDEXTRA:
145 req->flags = SET_CLASS_WINEXTRA;
146 req->win_extra = newval;
147 break;
148 case GCLP_HMODULE:
149 req->flags = SET_CLASS_INSTANCE;
150 req->instance = wine_server_client_ptr( (void *)newval );
151 break;
152 default:
153 assert( offset >= 0 );
154 req->flags = SET_CLASS_EXTRA;
155 req->extra_offset = offset;
156 req->extra_size = size;
157 if ( size == sizeof(LONG) )
158 {
159 LONG newlong = newval;
160 memcpy( &req->extra_value, &newlong, sizeof(LONG) );
161 }
162 else
163 memcpy( &req->extra_value, &newval, sizeof(LONG_PTR) );
164 break;
165 }
166 ret = !wine_server_call_err( req );
167 }
168 SERVER_END_REQ;
169 return ret;
170 }
171
172
173 /***********************************************************************
174 * CLASS_GetMenuNameA
175 *
176 * Get the menu name as a ASCII string.
177 */
178 static inline LPSTR CLASS_GetMenuNameA( CLASS *classPtr )
179 {
180 if (IS_INTRESOURCE(classPtr->menuName)) return (LPSTR)classPtr->menuName;
181 return (LPSTR)(classPtr->menuName + strlenW(classPtr->menuName) + 1);
182 }
183
184
185 /***********************************************************************
186 * CLASS_GetMenuNameW
187 *
188 * Get the menu name as a Unicode string.
189 */
190 static inline LPWSTR CLASS_GetMenuNameW( CLASS *classPtr )
191 {
192 return classPtr->menuName;
193 }
194
195
196 /***********************************************************************
197 * CLASS_SetMenuNameA
198 *
199 * Set the menu name in a class structure by copying the string.
200 */
201 static void CLASS_SetMenuNameA( CLASS *classPtr, LPCSTR name )
202 {
203 if (!IS_INTRESOURCE(classPtr->menuName)) HeapFree( GetProcessHeap(), 0, classPtr->menuName );
204 if (!IS_INTRESOURCE(name))
205 {
206 DWORD lenA = strlen(name) + 1;
207 DWORD lenW = MultiByteToWideChar( CP_ACP, 0, name, lenA, NULL, 0 );
208 classPtr->menuName = HeapAlloc( GetProcessHeap(), 0, lenA + lenW*sizeof(WCHAR) );
209 MultiByteToWideChar( CP_ACP, 0, name, lenA, classPtr->menuName, lenW );
210 memcpy( classPtr->menuName + lenW, name, lenA );
211 }
212 else classPtr->menuName = (LPWSTR)name;
213 }
214
215
216 /***********************************************************************
217 * CLASS_SetMenuNameW
218 *
219 * Set the menu name in a class structure by copying the string.
220 */
221 static void CLASS_SetMenuNameW( CLASS *classPtr, LPCWSTR name )
222 {
223 if (!IS_INTRESOURCE(classPtr->menuName)) HeapFree( GetProcessHeap(), 0, classPtr->menuName );
224 if (!IS_INTRESOURCE(name))
225 {
226 DWORD lenW = strlenW(name) + 1;
227 DWORD lenA = WideCharToMultiByte( CP_ACP, 0, name, lenW, NULL, 0, NULL, NULL );
228 classPtr->menuName = HeapAlloc( GetProcessHeap(), 0, lenA + lenW*sizeof(WCHAR) );
229 memcpy( classPtr->menuName, name, lenW*sizeof(WCHAR) );
230 WideCharToMultiByte( CP_ACP, 0, name, lenW,
231 (char *)(classPtr->menuName + lenW), lenA, NULL, NULL );
232 }
233 else classPtr->menuName = (LPWSTR)name;
234 }
235
236
237 /***********************************************************************
238 * CLASS_FreeClass
239 *
240 * Free a class structure.
241 */
242 static void CLASS_FreeClass( CLASS *classPtr )
243 {
244 TRACE("%p\n", classPtr);
245
246 USER_Lock();
247
248 if (classPtr->dce) free_dce( classPtr->dce, 0 );
249 list_remove( &classPtr->entry );
250 if (classPtr->hbrBackground > (HBRUSH)(COLOR_GRADIENTINACTIVECAPTION + 1))
251 DeleteObject( classPtr->hbrBackground );
252 HeapFree( GetProcessHeap(), 0, classPtr->menuName );
253 HeapFree( GetProcessHeap(), 0, classPtr );
254 USER_Unlock();
255 }
256
257
258 /***********************************************************************
259 * CLASS_FindClass
260 *
261 * Return a pointer to the class.
262 * hinstance has been normalized by the caller.
263 */
264 static CLASS *CLASS_FindClass( LPCWSTR name, HINSTANCE hinstance )
265 {
266 struct list *ptr;
267 ATOM atom = get_int_atom_value( name );
268
269 USER_Lock();
270
271 LIST_FOR_EACH( ptr, &class_list )
272 {
273 CLASS *class = LIST_ENTRY( ptr, CLASS, entry );
274 if (atom)
275 {
276 if (class->atomName != atom) continue;
277 }
278 else
279 {
280 if (!name || strcmpiW( class->name, name )) continue;
281 }
282 if (!hinstance || !class->local || class->hInstance == hinstance)
283 {
284 TRACE("%s %p -> %p\n", debugstr_w(name), hinstance, class);
285 return class;
286 }
287 }
288 USER_Unlock();
289 TRACE("%s %p -> not found\n", debugstr_w(name), hinstance);
290 return NULL;
291 }
292
293
294 /***********************************************************************
295 * CLASS_RegisterClass
296 *
297 * The real RegisterClass() functionality.
298 */
299 static CLASS *CLASS_RegisterClass( LPCWSTR name, HINSTANCE hInstance, BOOL local,
300 DWORD style, INT classExtra, INT winExtra )
301 {
302 CLASS *classPtr;
303 BOOL ret;
304
305 TRACE("name=%s hinst=%p style=0x%x clExtr=0x%x winExtr=0x%x\n",
306 debugstr_w(name), hInstance, style, classExtra, winExtra );
307
308 /* Fix the extra bytes value */
309
310 if (classExtra > 40) /* Extra bytes are limited to 40 in Win32 */
311 WARN("Class extra bytes %d is > 40\n", classExtra);
312 if (winExtra > 40) /* Extra bytes are limited to 40 in Win32 */
313 WARN("Win extra bytes %d is > 40\n", winExtra );
314
315 classPtr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLASS) + classExtra );
316 if (!classPtr) return NULL;
317
318 classPtr->atomName = get_int_atom_value( name );
319 if (!classPtr->atomName && name) strcpyW( classPtr->name, name );
320 else GlobalGetAtomNameW( classPtr->atomName, classPtr->name, sizeof(classPtr->name)/sizeof(WCHAR) );
321
322 SERVER_START_REQ( create_class )
323 {
324 req->local = local;
325 req->style = style;
326 req->instance = wine_server_client_ptr( hInstance );
327 req->extra = classExtra;
328 req->win_extra = winExtra;
329 req->client_ptr = wine_server_client_ptr( classPtr );
330 req->atom = classPtr->atomName;
331 if (!req->atom && name) wine_server_add_data( req, name, strlenW(name) * sizeof(WCHAR) );
332 ret = !wine_server_call_err( req );
333 classPtr->atomName = reply->atom;
334 }
335 SERVER_END_REQ;
336 if (!ret)
337 {
338 HeapFree( GetProcessHeap(), 0, classPtr );
339 return NULL;
340 }
341
342 classPtr->style = style;
343 classPtr->local = local;
344 classPtr->cbWndExtra = winExtra;
345 classPtr->cbClsExtra = classExtra;
346 classPtr->hInstance = hInstance;
347
348 /* Other non-null values must be set by caller */
349
350 USER_Lock();
351 if (local) list_add_head( &class_list, &classPtr->entry );
352 else list_add_tail( &class_list, &classPtr->entry );
353 return classPtr;
354 }
355
356
357 /***********************************************************************
358 * register_builtin
359 *
360 * Register a builtin control class.
361 * This allows having both ASCII and Unicode winprocs for the same class.
362 */
363 static void register_builtin( const struct builtin_class_descr *descr )
364 {
365 CLASS *classPtr;
366
367 if (!(classPtr = CLASS_RegisterClass( descr->name, user32_module, FALSE,
368 descr->style, 0, descr->extra ))) return;
369
370 classPtr->hCursor = LoadCursorA( 0, (LPSTR)descr->cursor );
371 classPtr->hbrBackground = descr->brush;
372 classPtr->winproc = BUILTIN_WINPROC( descr->proc );
373 release_class_ptr( classPtr );
374 }
375
376
377 /***********************************************************************
378 * CLASS_RegisterBuiltinClasses
379 */
380 void CLASS_RegisterBuiltinClasses(void)
381 {
382 register_builtin( &DESKTOP_builtin_class );
383 register_builtin( &BUTTON_builtin_class );
384 register_builtin( &COMBO_builtin_class );
385 register_builtin( &COMBOLBOX_builtin_class );
386 register_builtin( &DIALOG_builtin_class );
387 register_builtin( &EDIT_builtin_class );
388 register_builtin( &ICONTITLE_builtin_class );
389 register_builtin( &LISTBOX_builtin_class );
390 register_builtin( &MDICLIENT_builtin_class );
391 register_builtin( &MENU_builtin_class );
392 register_builtin( &MESSAGE_builtin_class );
393 register_builtin( &SCROLL_builtin_class );
394 register_builtin( &STATIC_builtin_class );
395 }
396
397
398 /***********************************************************************
399 * get_class_winproc
400 */
401 WNDPROC get_class_winproc( CLASS *class )
402 {
403 return class->winproc;
404 }
405
406
407 /***********************************************************************
408 * get_class_dce
409 */
410 struct dce *get_class_dce( CLASS *class )
411 {
412 return class->dce;
413 }
414
415
416 /***********************************************************************
417 * set_class_dce
418 */
419 struct dce *set_class_dce( CLASS *class, struct dce *dce )
420 {
421 if (class->dce) return class->dce; /* already set, don't change it */
422 class->dce = dce;
423 return dce;
424 }
425
426
427 /***********************************************************************
428 * RegisterClassA (USER32.@)
429 *
430 * Register a window class.
431 *
432 * RETURNS
433 * >0: Unique identifier
434 * 0: Failure
435 */
436 ATOM WINAPI RegisterClassA( const WNDCLASSA* wc ) /* [in] Address of structure with class data */
437 {
438 WNDCLASSEXA wcex;
439
440 wcex.cbSize = sizeof(wcex);
441 wcex.style = wc->style;
442 wcex.lpfnWndProc = wc->lpfnWndProc;
443 wcex.cbClsExtra = wc->cbClsExtra;
444 wcex.cbWndExtra = wc->cbWndExtra;
445 wcex.hInstance = wc->hInstance;
446 wcex.hIcon = wc->hIcon;
447 wcex.hCursor = wc->hCursor;
448 wcex.hbrBackground = wc->hbrBackground;
449 wcex.lpszMenuName = wc->lpszMenuName;
450 wcex.lpszClassName = wc->lpszClassName;
451 wcex.hIconSm = 0;
452 return RegisterClassExA( &wcex );
453 }
454
455
456 /***********************************************************************
457 * RegisterClassW (USER32.@)
458 *
459 * See RegisterClassA.
460 */
461 ATOM WINAPI RegisterClassW( const WNDCLASSW* wc )
462 {
463 WNDCLASSEXW wcex;
464
465 wcex.cbSize = sizeof(wcex);
466 wcex.style = wc->style;
467 wcex.lpfnWndProc = wc->lpfnWndProc;
468 wcex.cbClsExtra = wc->cbClsExtra;
469 wcex.cbWndExtra = wc->cbWndExtra;
470 wcex.hInstance = wc->hInstance;
471 wcex.hIcon = wc->hIcon;
472 wcex.hCursor = wc->hCursor;
473 wcex.hbrBackground = wc->hbrBackground;
474 wcex.lpszMenuName = wc->lpszMenuName;
475 wcex.lpszClassName = wc->lpszClassName;
476 wcex.hIconSm = 0;
477 return RegisterClassExW( &wcex );
478 }
479
480
481 /***********************************************************************
482 * RegisterClassExA (USER32.@)
483 */
484 ATOM WINAPI RegisterClassExA( const WNDCLASSEXA* wc )
485 {
486 ATOM atom;
487 CLASS *classPtr;
488 HINSTANCE instance;
489
490 if (wc->cbSize != sizeof(*wc) || wc->cbClsExtra < 0 || wc->cbWndExtra < 0 ||
491 wc->hInstance == user32_module) /* we can't register a class for user32 */
492 {
493 SetLastError( ERROR_INVALID_PARAMETER );
494 return 0;
495 }
496 if (!(instance = wc->hInstance)) instance = GetModuleHandleW( NULL );
497
498 if (!IS_INTRESOURCE(wc->lpszClassName))
499 {
500 WCHAR name[MAX_ATOM_LEN + 1];
501
502 if (!MultiByteToWideChar( CP_ACP, 0, wc->lpszClassName, -1, name, MAX_ATOM_LEN + 1 )) return 0;
503 classPtr = CLASS_RegisterClass( name, instance, !(wc->style & CS_GLOBALCLASS),
504 wc->style, wc->cbClsExtra, wc->cbWndExtra );
505 }
506 else
507 {
508 classPtr = CLASS_RegisterClass( (LPCWSTR)wc->lpszClassName, instance,
509 !(wc->style & CS_GLOBALCLASS), wc->style,
510 wc->cbClsExtra, wc->cbWndExtra );
511 }
512 if (!classPtr) return 0;
513 atom = classPtr->atomName;
514
515 TRACE("name=%s atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
516 debugstr_a(wc->lpszClassName), atom, wc->lpfnWndProc, instance, wc->hbrBackground,
517 wc->style, wc->cbClsExtra, wc->cbWndExtra, classPtr );
518
519 classPtr->hIcon = wc->hIcon;
520 classPtr->hIconSm = wc->hIconSm;
521 classPtr->hCursor = wc->hCursor;
522 classPtr->hbrBackground = wc->hbrBackground;
523 classPtr->winproc = WINPROC_AllocProc( wc->lpfnWndProc, FALSE );
524 CLASS_SetMenuNameA( classPtr, wc->lpszMenuName );
525 release_class_ptr( classPtr );
526 return atom;
527 }
528
529
530 /***********************************************************************
531 * RegisterClassExW (USER32.@)
532 */
533 ATOM WINAPI RegisterClassExW( const WNDCLASSEXW* wc )
534 {
535 ATOM atom;
536 CLASS *classPtr;
537 HINSTANCE instance;
538
539 if (wc->cbSize != sizeof(*wc) || wc->cbClsExtra < 0 || wc->cbWndExtra < 0 ||
540 wc->hInstance == user32_module) /* we can't register a class for user32 */
541 {
542 SetLastError( ERROR_INVALID_PARAMETER );
543 return 0;
544 }
545 if (!(instance = wc->hInstance)) instance = GetModuleHandleW( NULL );
546
547 if (!(classPtr = CLASS_RegisterClass( wc->lpszClassName, instance, !(wc->style & CS_GLOBALCLASS),
548 wc->style, wc->cbClsExtra, wc->cbWndExtra )))
549 return 0;
550
551 atom = classPtr->atomName;
552
553 TRACE("name=%s atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
554 debugstr_w(wc->lpszClassName), atom, wc->lpfnWndProc, instance, wc->hbrBackground,
555 wc->style, wc->cbClsExtra, wc->cbWndExtra, classPtr );
556
557 classPtr->hIcon = wc->hIcon;
558 classPtr->hIconSm = wc->hIconSm;
559 classPtr->hCursor = wc->hCursor;
560 classPtr->hbrBackground = wc->hbrBackground;
561 classPtr->winproc = WINPROC_AllocProc( wc->lpfnWndProc, TRUE );
562 CLASS_SetMenuNameW( classPtr, wc->lpszMenuName );
563 release_class_ptr( classPtr );
564 return atom;
565 }
566
567
568 /***********************************************************************
569 * UnregisterClassA (USER32.@)
570 */
571 BOOL WINAPI UnregisterClassA( LPCSTR className, HINSTANCE hInstance )
572 {
573 if (!IS_INTRESOURCE(className))
574 {
575 WCHAR name[MAX_ATOM_LEN + 1];
576
577 if (!MultiByteToWideChar( CP_ACP, 0, className, -1, name, MAX_ATOM_LEN + 1 ))
578 return FALSE;
579 return UnregisterClassW( name, hInstance );
580 }
581 return UnregisterClassW( (LPCWSTR)className, hInstance );
582 }
583
584 /***********************************************************************
585 * UnregisterClassW (USER32.@)
586 */
587 BOOL WINAPI UnregisterClassW( LPCWSTR className, HINSTANCE hInstance )
588 {
589 CLASS *classPtr = NULL;
590
591 SERVER_START_REQ( destroy_class )
592 {
593 req->instance = wine_server_client_ptr( hInstance );
594 if (!(req->atom = get_int_atom_value(className)) && className)
595 wine_server_add_data( req, className, strlenW(className) * sizeof(WCHAR) );
596 if (!wine_server_call_err( req )) classPtr = wine_server_get_ptr( reply->client_ptr );
597 }
598 SERVER_END_REQ;
599
600 if (classPtr) CLASS_FreeClass( classPtr );
601 return (classPtr != NULL);
602 }
603
604
605 /***********************************************************************
606 * GetClassWord (USER32.@)
607 */
608 WORD WINAPI GetClassWord( HWND hwnd, INT offset )
609 {
610 CLASS *class;
611 WORD retvalue = 0;
612
613 if (offset < 0) return GetClassLongA( hwnd, offset );
614
615 if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
616
617 if (class == CLASS_OTHER_PROCESS)
618 {
619 SERVER_START_REQ( set_class_info )
620 {
621 req->window = wine_server_user_handle( hwnd );
622 req->flags = 0;
623 req->extra_offset = offset;
624 req->extra_size = sizeof(retvalue);
625 if (!wine_server_call_err( req ))
626 memcpy( &retvalue, &reply->old_extra_value, sizeof(retvalue) );
627 }
628 SERVER_END_REQ;
629 return retvalue;
630 }
631
632 if (offset <= class->cbClsExtra - sizeof(WORD))
633 memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(retvalue) );
634 else
635 SetLastError( ERROR_INVALID_INDEX );
636 release_class_ptr( class );
637 return retvalue;
638 }
639
640
641 /***********************************************************************
642 * CLASS_GetClassLong
643 *
644 * Implementation of GetClassLong(Ptr)A/W
645 */
646 static ULONG_PTR CLASS_GetClassLong( HWND hwnd, INT offset, UINT size,
647 BOOL unicode )
648 {
649 CLASS *class;
650 ULONG_PTR retvalue = 0;
651
652 if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
653
654 if (class == CLASS_OTHER_PROCESS)
655 {
656 SERVER_START_REQ( set_class_info )
657 {
658 req->window = wine_server_user_handle( hwnd );
659 req->flags = 0;
660 req->extra_offset = (offset >= 0) ? offset : -1;
661 req->extra_size = (offset >= 0) ? size : 0;
662 if (!wine_server_call_err( req ))
663 {
664 switch(offset)
665 {
666 case GCLP_HBRBACKGROUND:
667 case GCLP_HCURSOR:
668 case GCLP_HICON:
669 case GCLP_HICONSM:
670 case GCLP_WNDPROC:
671 case GCLP_MENUNAME:
672 FIXME( "offset %d (%s) not supported on other process window %p\n",
673 offset, SPY_GetClassLongOffsetName(offset), hwnd );
674 SetLastError( ERROR_INVALID_HANDLE );
675 break;
676 case GCL_STYLE:
677 retvalue = reply->old_style;
678 break;
679 case GCL_CBWNDEXTRA:
680 retvalue = reply->old_win_extra;
681 break;
682 case GCL_CBCLSEXTRA:
683 retvalue = reply->old_extra;
684 break;
685 case GCLP_HMODULE:
686 retvalue = (ULONG_PTR)wine_server_get_ptr( reply->old_instance );
687 break;
688 case GCW_ATOM:
689 retvalue = reply->old_atom;
690 break;
691 default:
692 if (offset >= 0)
693 {
694 if (size == sizeof(DWORD))
695 {
696 DWORD retdword;
697 memcpy( &retdword, &reply->old_extra_value, sizeof(DWORD) );
698 retvalue = retdword;
699 }
700 else
701 memcpy( &retvalue, &reply->old_extra_value,
702 sizeof(ULONG_PTR) );
703 }
704 else SetLastError( ERROR_INVALID_INDEX );
705 break;
706 }
707 }
708 }
709 SERVER_END_REQ;
710 return retvalue;
711 }
712
713 if (offset >= 0)
714 {
715 if (offset <= class->cbClsExtra - size)
716 {
717 if (size == sizeof(DWORD))
718 {
719 DWORD retdword;
720 memcpy( &retdword, (char *)(class + 1) + offset, sizeof(DWORD) );
721 retvalue = retdword;
722 }
723 else
724 memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(ULONG_PTR) );
725 }
726 else
727 SetLastError( ERROR_INVALID_INDEX );
728 release_class_ptr( class );
729 return retvalue;
730 }
731
732 switch(offset)
733 {
734 case GCLP_HBRBACKGROUND:
735 retvalue = (ULONG_PTR)class->hbrBackground;
736 break;
737 case GCLP_HCURSOR:
738 retvalue = (ULONG_PTR)class->hCursor;
739 break;
740 case GCLP_HICON:
741 retvalue = (ULONG_PTR)class->hIcon;
742 break;
743 case GCLP_HICONSM:
744 retvalue = (ULONG_PTR)class->hIconSm;
745 break;
746 case GCL_STYLE:
747 retvalue = class->style;
748 break;
749 case GCL_CBWNDEXTRA:
750 retvalue = class->cbWndExtra;
751 break;
752 case GCL_CBCLSEXTRA:
753 retvalue = class->cbClsExtra;
754 break;
755 case GCLP_HMODULE:
756 retvalue = (ULONG_PTR)class->hInstance;
757 break;
758 case GCLP_WNDPROC:
759 retvalue = (ULONG_PTR)WINPROC_GetProc( class->winproc, unicode );
760 break;
761 case GCLP_MENUNAME:
762 retvalue = (ULONG_PTR)CLASS_GetMenuNameW( class );
763 if (unicode)
764 retvalue = (ULONG_PTR)CLASS_GetMenuNameW( class );
765 else
766 retvalue = (ULONG_PTR)CLASS_GetMenuNameA( class );
767 break;
768 case GCW_ATOM:
769 retvalue = class->atomName;
770 break;
771 default:
772 SetLastError( ERROR_INVALID_INDEX );
773 break;
774 }
775 release_class_ptr( class );
776 return retvalue;
777 }
778
779
780 /***********************************************************************
781 * GetClassLongW (USER32.@)
782 */
783 DWORD WINAPI GetClassLongW( HWND hwnd, INT offset )
784 {
785 return CLASS_GetClassLong( hwnd, offset, sizeof(DWORD), TRUE );
786 }
787
788
789
790 /***********************************************************************
791 * GetClassLongA (USER32.@)
792 */
793 DWORD WINAPI GetClassLongA( HWND hwnd, INT offset )
794 {
795 return CLASS_GetClassLong( hwnd, offset, sizeof(DWORD), FALSE );
796 }
797
798
799 /***********************************************************************
800 * SetClassWord (USER32.@)
801 */
802 WORD WINAPI SetClassWord( HWND hwnd, INT offset, WORD newval )
803 {
804 CLASS *class;
805 WORD retval = 0;
806
807 if (offset < 0) return SetClassLongA( hwnd, offset, (DWORD)newval );
808
809 if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
810
811 SERVER_START_REQ( set_class_info )
812 {
813 req->window = wine_server_user_handle( hwnd );
814 req->flags = SET_CLASS_EXTRA;
815 req->extra_offset = offset;
816 req->extra_size = sizeof(newval);
817 memcpy( &req->extra_value, &newval, sizeof(newval) );
818 if (!wine_server_call_err( req ))
819 {
820 void *ptr = (char *)(class + 1) + offset;
821 memcpy( &retval, ptr, sizeof(retval) );
822 memcpy( ptr, &newval, sizeof(newval) );
823 }
824 }
825 SERVER_END_REQ;
826 release_class_ptr( class );
827 return retval;
828 }
829
830
831 /***********************************************************************
832 * CLASS_SetClassLong
833 *
834 * Implementation of SetClassLong(Ptr)A/W
835 */
836 static ULONG_PTR CLASS_SetClassLong( HWND hwnd, INT offset, LONG_PTR newval,
837 UINT size, BOOL unicode )
838 {
839 CLASS *class;
840 ULONG_PTR retval = 0;
841
842 if (!(class = get_class_ptr( hwnd, TRUE ))) return 0;
843
844 if (offset >= 0)
845 {
846 if (set_server_info( hwnd, offset, newval, size ))
847 {
848 void *ptr = (char *)(class + 1) + offset;
849 if ( size == sizeof(LONG) )
850 {
851 DWORD retdword;
852 LONG newlong = newval;
853 memcpy( &retdword, ptr, sizeof(DWORD) );
854 memcpy( ptr, &newlong, sizeof(LONG) );
855 retval = retdword;
856 }
857 else
858 {
859 memcpy( &retval, ptr, sizeof(ULONG_PTR) );
860 memcpy( ptr, &newval, sizeof(LONG_PTR) );
861 }
862 }
863 }
864 else switch(offset)
865 {
866 case GCLP_MENUNAME:
867 if ( unicode )
868 CLASS_SetMenuNameW( class, (LPCWSTR)newval );
869 else
870 CLASS_SetMenuNameA( class, (LPCSTR)newval );
871 retval = 0; /* Old value is now meaningless anyway */
872 break;
873 case GCLP_WNDPROC:
874 retval = (ULONG_PTR)WINPROC_GetProc( class->winproc, unicode );
875 class->winproc = WINPROC_AllocProc( (WNDPROC)newval, unicode );
876 break;
877 case GCLP_HBRBACKGROUND:
878 retval = (ULONG_PTR)class->hbrBackground;
879 class->hbrBackground = (HBRUSH)newval;
880 break;
881 case GCLP_HCURSOR:
882 retval = (ULONG_PTR)class->hCursor;
883 class->hCursor = (HCURSOR)newval;
884 break;
885 case GCLP_HICON:
886 retval = (ULONG_PTR)class->hIcon;
887 class->hIcon = (HICON)newval;
888 break;
889 case GCLP_HICONSM:
890 retval = (ULONG_PTR)class->hIconSm;
891 class->hIconSm = (HICON)newval;
892 break;
893 case GCL_STYLE:
894 if (!set_server_info( hwnd, offset, newval, size )) break;
895 retval = class->style;
896 class->style = newval;
897 break;
898 case GCL_CBWNDEXTRA:
899 if (!set_server_info( hwnd, offset, newval, size )) break;
900 retval = class->cbWndExtra;
901 class->cbWndExtra = newval;
902 break;
903 case GCLP_HMODULE:
904 if (!set_server_info( hwnd, offset, newval, size )) break;
905 retval = (ULONG_PTR)class->hInstance;
906 class->hInstance = (HINSTANCE)newval;
907 break;
908 case GCW_ATOM:
909 if (!set_server_info( hwnd, offset, newval, size )) break;
910 retval = class->atomName;
911 class->atomName = newval;
912 GlobalGetAtomNameW( newval, class->name, sizeof(class->name)/sizeof(WCHAR) );
913 break;
914 case GCL_CBCLSEXTRA: /* cannot change this one */
915 SetLastError( ERROR_INVALID_PARAMETER );
916 break;
917 default:
918 SetLastError( ERROR_INVALID_INDEX );
919 break;
920 }
921 release_class_ptr( class );
922 return retval;
923 }
924
925
926 /***********************************************************************
927 * SetClassLongW (USER32.@)
928 */
929 DWORD WINAPI SetClassLongW( HWND hwnd, INT offset, LONG newval )
930 {
931 return CLASS_SetClassLong( hwnd, offset, newval, sizeof(LONG), TRUE );
932 }
933
934
935 /***********************************************************************
936 * SetClassLongA (USER32.@)
937 */
938 DWORD WINAPI SetClassLongA( HWND hwnd, INT offset, LONG newval )
939 {
940 return CLASS_SetClassLong( hwnd, offset, newval, sizeof(LONG), FALSE );
941 }
942
943
944 /***********************************************************************
945 * GetClassNameA (USER32.@)
946 */
947 INT WINAPI GetClassNameA( HWND hwnd, LPSTR buffer, INT count )
948 {
949 WCHAR tmpbuf[MAX_ATOM_LEN + 1];
950 DWORD len;
951
952 if (count <= 0) return 0;
953 if (!GetClassNameW( hwnd, tmpbuf, sizeof(tmpbuf)/sizeof(WCHAR) )) return 0;
954 RtlUnicodeToMultiByteN( buffer, count - 1, &len, tmpbuf, strlenW(tmpbuf) * sizeof(WCHAR) );
955 buffer[len] = 0;
956 return len;
957 }
958
959
960 /***********************************************************************
961 * GetClassNameW (USER32.@)
962 */
963 INT WINAPI GetClassNameW( HWND hwnd, LPWSTR buffer, INT count )
964 {
965 CLASS *class;
966 INT ret;
967
968 TRACE("%p %p %d\n", hwnd, buffer, count);
969
970 if (count <= 0) return 0;
971
972 if (!(class = get_class_ptr( hwnd, FALSE ))) return 0;
973
974 if (class == CLASS_OTHER_PROCESS)
975 {
976 WCHAR tmpbuf[MAX_ATOM_LEN + 1];
977
978 ret = GlobalGetAtomNameW( GetClassLongW( hwnd, GCW_ATOM ), tmpbuf, MAX_ATOM_LEN + 1 );
979 if (ret)
980 {
981 ret = min(count - 1, ret);
982 memcpy(buffer, tmpbuf, ret * sizeof(WCHAR));
983 buffer[ret] = 0;
984 }
985 }
986 else
987 {
988 lstrcpynW( buffer, class->name, count );
989 release_class_ptr( class );
990 ret = strlenW( buffer );
991 }
992 return ret;
993 }
994
995
996 /***********************************************************************
997 * RealGetWindowClassA (USER32.@)
998 */
999 UINT WINAPI RealGetWindowClassA( HWND hwnd, LPSTR buffer, UINT count )
1000 {
1001 return GetClassNameA( hwnd, buffer, count );
1002 }
1003
1004
1005 /***********************************************************************
1006 * RealGetWindowClassW (USER32.@)
1007 */
1008 UINT WINAPI RealGetWindowClassW( HWND hwnd, LPWSTR buffer, UINT count )
1009 {
1010 return GetClassNameW( hwnd, buffer, count );
1011 }
1012
1013
1014 /***********************************************************************
1015 * GetClassInfoA (USER32.@)
1016 */
1017 BOOL WINAPI GetClassInfoA( HINSTANCE hInstance, LPCSTR name, WNDCLASSA *wc )
1018 {
1019 WNDCLASSEXA wcex;
1020 UINT ret = GetClassInfoExA( hInstance, name, &wcex );
1021
1022 if (ret)
1023 {
1024 wc->style = wcex.style;
1025 wc->lpfnWndProc = wcex.lpfnWndProc;
1026 wc->cbClsExtra = wcex.cbClsExtra;
1027 wc->cbWndExtra = wcex.cbWndExtra;
1028 wc->hInstance = wcex.hInstance;
1029 wc->hIcon = wcex.hIcon;
1030 wc->hCursor = wcex.hCursor;
1031 wc->hbrBackground = wcex.hbrBackground;
1032 wc->lpszMenuName = wcex.lpszMenuName;
1033 wc->lpszClassName = wcex.lpszClassName;
1034 }
1035 return ret;
1036 }
1037
1038
1039 /***********************************************************************
1040 * GetClassInfoW (USER32.@)
1041 */
1042 BOOL WINAPI GetClassInfoW( HINSTANCE hInstance, LPCWSTR name, WNDCLASSW *wc )
1043 {
1044 WNDCLASSEXW wcex;
1045 UINT ret = GetClassInfoExW( hInstance, name, &wcex );
1046
1047 if (ret)
1048 {
1049 wc->style = wcex.style;
1050 wc->lpfnWndProc = wcex.lpfnWndProc;
1051 wc->cbClsExtra = wcex.cbClsExtra;
1052 wc->cbWndExtra = wcex.cbWndExtra;
1053 wc->hInstance = wcex.hInstance;
1054 wc->hIcon = wcex.hIcon;
1055 wc->hCursor = wcex.hCursor;
1056 wc->hbrBackground = wcex.hbrBackground;
1057 wc->lpszMenuName = wcex.lpszMenuName;
1058 wc->lpszClassName = wcex.lpszClassName;
1059 }
1060 return ret;
1061 }
1062
1063
1064 /***********************************************************************
1065 * GetClassInfoExA (USER32.@)
1066 */
1067 BOOL WINAPI GetClassInfoExA( HINSTANCE hInstance, LPCSTR name, WNDCLASSEXA *wc )
1068 {
1069 ATOM atom;
1070 CLASS *classPtr;
1071
1072 TRACE("%p %s %p\n", hInstance, debugstr_a(name), wc);
1073
1074 if (!wc)
1075 {
1076 SetLastError( ERROR_NOACCESS );
1077 return FALSE;
1078 }
1079
1080 if (!hInstance) hInstance = user32_module;
1081
1082 if (!IS_INTRESOURCE(name))
1083 {
1084 WCHAR nameW[MAX_ATOM_LEN + 1];
1085 if (!MultiByteToWideChar( CP_ACP, 0, name, -1, nameW, sizeof(nameW)/sizeof(WCHAR) ))
1086 return FALSE;
1087 classPtr = CLASS_FindClass( nameW, hInstance );
1088 }
1089 else classPtr = CLASS_FindClass( (LPCWSTR)name, hInstance );
1090
1091 if (!classPtr)
1092 {
1093 SetLastError( ERROR_CLASS_DOES_NOT_EXIST );
1094 return FALSE;
1095 }
1096 wc->style = classPtr->style;
1097 wc->lpfnWndProc = WINPROC_GetProc( classPtr->winproc, FALSE );
1098 wc->cbClsExtra = classPtr->cbClsExtra;
1099 wc->cbWndExtra = classPtr->cbWndExtra;
1100 wc->hInstance = (hInstance == user32_module) ? 0 : hInstance;
1101 wc->hIcon = classPtr->hIcon;
1102 wc->hIconSm = classPtr->hIconSm;
1103 wc->hCursor = classPtr->hCursor;
1104 wc->hbrBackground = classPtr->hbrBackground;
1105 wc->lpszMenuName = CLASS_GetMenuNameA( classPtr );
1106 wc->lpszClassName = name;
1107 atom = classPtr->atomName;
1108 release_class_ptr( classPtr );
1109
1110 /* We must return the atom of the class here instead of just TRUE. */
1111 return atom;
1112 }
1113
1114
1115 /***********************************************************************
1116 * GetClassInfoExW (USER32.@)
1117 */
1118 BOOL WINAPI GetClassInfoExW( HINSTANCE hInstance, LPCWSTR name, WNDCLASSEXW *wc )
1119 {
1120 ATOM atom;
1121 CLASS *classPtr;
1122
1123 TRACE("%p %s %p\n", hInstance, debugstr_w(name), wc);
1124
1125 if (!wc)
1126 {
1127 SetLastError( ERROR_NOACCESS );
1128 return FALSE;
1129 }
1130
1131 if (!hInstance) hInstance = user32_module;
1132
1133 if (!(classPtr = CLASS_FindClass( name, hInstance )))
1134 {
1135 SetLastError( ERROR_CLASS_DOES_NOT_EXIST );
1136 return FALSE;
1137 }
1138 wc->style = classPtr->style;
1139 wc->lpfnWndProc = WINPROC_GetProc( classPtr->winproc, TRUE );
1140 wc->cbClsExtra = classPtr->cbClsExtra;
1141 wc->cbWndExtra = classPtr->cbWndExtra;
1142 wc->hInstance = (hInstance == user32_module) ? 0 : hInstance;
1143 wc->hIcon = classPtr->hIcon;
1144 wc->hIconSm = classPtr->hIconSm;
1145 wc->hCursor = classPtr->hCursor;
1146 wc->hbrBackground = classPtr->hbrBackground;
1147 wc->lpszMenuName = CLASS_GetMenuNameW( classPtr );
1148 wc->lpszClassName = name;
1149 atom = classPtr->atomName;
1150 release_class_ptr( classPtr );
1151
1152 /* We must return the atom of the class here instead of just TRUE. */
1153 return atom;
1154 }
1155
1156
1157 #if 0 /* toolhelp is in kernel, so this cannot work */
1158
1159 /***********************************************************************
1160 * ClassFirst (TOOLHELP.69)
1161 */
1162 BOOL16 WINAPI ClassFirst16( CLASSENTRY *pClassEntry )
1163 {
1164 TRACE("%p\n",pClassEntry);
1165 pClassEntry->wNext = 1;
1166 return ClassNext16( pClassEntry );
1167 }
1168
1169
1170 /***********************************************************************
1171 * ClassNext (TOOLHELP.70)
1172 */
1173 BOOL16 WINAPI ClassNext16( CLASSENTRY *pClassEntry )
1174 {
1175 int i;
1176 CLASS *class = firstClass;
1177
1178 TRACE("%p\n",pClassEntry);
1179
1180 if (!pClassEntry->wNext) return FALSE;
1181 for (i = 1; (i < pClassEntry->wNext) && class; i++) class = class->next;
1182 if (!class)
1183 {
1184 pClassEntry->wNext = 0;
1185 return FALSE;
1186 }
1187 pClassEntry->hInst = class->hInstance;
1188 pClassEntry->wNext++;
1189 GlobalGetAtomNameA( class->atomName, pClassEntry->szClassName,
1190 sizeof(pClassEntry->szClassName) );
1191 return TRUE;
1192 }
1193 #endif
1194
1195 /* 64bit versions */
1196
1197 #ifdef GetClassLongPtrA
1198 #undef GetClassLongPtrA
1199 #endif
1200
1201 #ifdef GetClassLongPtrW
1202 #undef GetClassLongPtrW
1203 #endif
1204
1205 #ifdef SetClassLongPtrA
1206 #undef SetClassLongPtrA
1207 #endif
1208
1209 #ifdef SetClassLongPtrW
1210 #undef SetClassLongPtrW
1211 #endif
1212
1213 /***********************************************************************
1214 * GetClassLongPtrA (USER32.@)
1215 */
1216 ULONG_PTR WINAPI GetClassLongPtrA( HWND hwnd, INT offset )
1217 {
1218 return CLASS_GetClassLong( hwnd, offset, sizeof(ULONG_PTR), FALSE );
1219 }
1220
1221 /***********************************************************************
1222 * GetClassLongPtrW (USER32.@)
1223 */
1224 ULONG_PTR WINAPI GetClassLongPtrW( HWND hwnd, INT offset )
1225 {
1226 return CLASS_GetClassLong( hwnd, offset, sizeof(ULONG_PTR), TRUE );
1227 }
1228
1229 /***********************************************************************
1230 * SetClassLongPtrW (USER32.@)
1231 */
1232 ULONG_PTR WINAPI SetClassLongPtrW( HWND hwnd, INT offset, LONG_PTR newval )
1233 {
1234 return CLASS_SetClassLong( hwnd, offset, newval, sizeof(LONG_PTR), TRUE );
1235 }
1236
1237 /***********************************************************************
1238 * SetClassLongPtrA (USER32.@)
1239 */
1240 ULONG_PTR WINAPI SetClassLongPtrA( HWND hwnd, INT offset, LONG_PTR newval )
1241 {
1242 return CLASS_SetClassLong( hwnd, offset, newval, sizeof(LONG_PTR), FALSE );
1243 }
Windows API implementation