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