[YAROTOWS] Reintegrate the branch. For a brighter future.
[reactos.git] / reactos / dll / win32 / user32 / windows / class.c
1 /*
2 * PROJECT: ReactOS user32.dll
3 * COPYRIGHT: GPL - See COPYING in the top level directory
4 * FILE: dll/win32/user32/windows/class.c
5 * PURPOSE: Window classes
6 * PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * UPDATE HISTORY:
8 * 09-05-2001 CSH Created
9 */
10
11 #include <user32.h>
12
13 #include <wine/debug.h>
14 WINE_DEFAULT_DEBUG_CHANNEL(user32);
15
16 /*
17 * @implemented
18 */
19 BOOL
20 WINAPI
21 GetClassInfoExA(
22 HINSTANCE hInstance,
23 LPCSTR lpszClass,
24 LPWNDCLASSEXA lpwcx)
25 {
26 UNICODE_STRING ClassName = {0};
27 BOOL Ret;
28 LPCSTR pszMenuName;
29
30 TRACE("%p class/atom: %s/%04x %p\n", hInstance,
31 IS_ATOM(lpszClass) ? NULL : lpszClass,
32 IS_ATOM(lpszClass) ? lpszClass : 0,
33 lpwcx);
34
35 if (!lpwcx)
36 {
37 SetLastError( ERROR_NOACCESS );
38 return FALSE;
39 }
40
41 if (hInstance == User32Instance)
42 {
43 hInstance = NULL;
44 }
45
46 if (lpszClass == NULL)
47 {
48 SetLastError(ERROR_INVALID_PARAMETER);
49 return FALSE;
50 }
51
52 if (!RegisterDefaultClasses)
53 {
54 ERR("GetClassInfoExA RegisterSystemControls\n");
55 RegisterSystemControls();
56 }
57
58 if (IS_ATOM(lpszClass))
59 {
60 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpszClass);
61 }
62 else
63 {
64 if (!RtlCreateUnicodeStringFromAsciiz(&ClassName,
65 lpszClass))
66 {
67 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
68 return FALSE;
69 }
70 }
71
72 Ret = NtUserGetClassInfo(hInstance,
73 &ClassName,
74 (LPWNDCLASSEXW)lpwcx,
75 (LPWSTR *)&pszMenuName,
76 TRUE);
77 if (Ret)
78 {
79 lpwcx->lpszClassName = lpszClass;
80 // lpwcx->lpszMenuName = pszMenuName;
81 }
82
83 if (!IS_ATOM(lpszClass))
84 {
85 RtlFreeUnicodeString(&ClassName);
86 }
87
88 return Ret;
89 }
90
91
92 /*
93 * @implemented
94 */
95 BOOL
96 WINAPI
97 GetClassInfoExW(
98 HINSTANCE hInstance,
99 LPCWSTR lpszClass,
100 LPWNDCLASSEXW lpwcx)
101 {
102 UNICODE_STRING ClassName = {0};
103 BOOL Ret;
104 LPWSTR pszMenuName;
105
106 TRACE("%p class/atom: %S/%04x %p\n", hInstance,
107 IS_ATOM(lpszClass) ? NULL : lpszClass,
108 IS_ATOM(lpszClass) ? lpszClass : 0,
109 lpwcx);
110
111 /* From wine, for speed only, ReactOS supports the correct return in
112 * Win32k. cbSize is ignored.
113 */
114 if (!lpwcx)
115 {
116 SetLastError( ERROR_NOACCESS );
117 return FALSE;
118 }
119
120 if (hInstance == User32Instance)
121 {
122 hInstance = NULL;
123 }
124
125 if (lpszClass == NULL)
126 {
127 SetLastError(ERROR_INVALID_PARAMETER);
128 return FALSE;
129 }
130
131 if (!RegisterDefaultClasses)
132 {
133 ERR("GetClassInfoExW RegisterSystemControls\n");
134 RegisterSystemControls();
135 }
136
137 if (IS_ATOM(lpszClass))
138 {
139 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpszClass);
140 }
141 else
142 {
143 RtlInitUnicodeString(&ClassName,
144 lpszClass);
145 }
146
147 Ret = NtUserGetClassInfo( hInstance,
148 &ClassName,
149 lpwcx,
150 &pszMenuName,
151 FALSE);
152 if (Ret)
153 {
154 lpwcx->lpszClassName = lpszClass;
155 // lpwcx->lpszMenuName = pszMenuName;
156 }
157 return Ret;
158 }
159
160
161 /*
162 * @implemented
163 */
164 BOOL
165 WINAPI
166 GetClassInfoA(
167 HINSTANCE hInstance,
168 LPCSTR lpClassName,
169 LPWNDCLASSA lpWndClass)
170 {
171 WNDCLASSEXA wcex;
172 BOOL retval;
173
174 retval = GetClassInfoExA(hInstance, lpClassName, &wcex);
175 if (retval)
176 {
177 lpWndClass->style = wcex.style;
178 lpWndClass->lpfnWndProc = wcex.lpfnWndProc;
179 lpWndClass->cbClsExtra = wcex.cbClsExtra;
180 lpWndClass->cbWndExtra = wcex.cbWndExtra;
181 lpWndClass->hInstance = wcex.hInstance;
182 lpWndClass->hIcon = wcex.hIcon;
183 lpWndClass->hCursor = wcex.hCursor;
184 lpWndClass->hbrBackground = wcex.hbrBackground;
185 lpWndClass->lpszMenuName = wcex.lpszMenuName;
186 lpWndClass->lpszClassName = wcex.lpszClassName;
187 }
188
189 return retval;
190 }
191
192 /*
193 * @implemented
194 */
195 BOOL
196 WINAPI
197 GetClassInfoW(
198 HINSTANCE hInstance,
199 LPCWSTR lpClassName,
200 LPWNDCLASSW lpWndClass)
201 {
202 WNDCLASSEXW wcex;
203 BOOL retval;
204
205 retval = GetClassInfoExW(hInstance, lpClassName, &wcex);
206 if (retval)
207 {
208 lpWndClass->style = wcex.style;
209 lpWndClass->lpfnWndProc = wcex.lpfnWndProc;
210 lpWndClass->cbClsExtra = wcex.cbClsExtra;
211 lpWndClass->cbWndExtra = wcex.cbWndExtra;
212 lpWndClass->hInstance = wcex.hInstance;
213 lpWndClass->hIcon = wcex.hIcon;
214 lpWndClass->hCursor = wcex.hCursor;
215 lpWndClass->hbrBackground = wcex.hbrBackground;
216 lpWndClass->lpszMenuName = wcex.lpszMenuName;
217 lpWndClass->lpszClassName = wcex.lpszClassName;
218 }
219 return retval;
220 }
221
222 //
223 // Based on find_winproc... Fixes many whine tests......
224 //
225 ULONG_PTR FASTCALL
226 IntGetClsWndProc(PWND pWnd, PCLS Class, BOOL Ansi)
227 {
228 INT i;
229 ULONG_PTR gcpd, Ret = 0;
230 // If server side, sweep through proc list and return the client side proc.
231 if (Class->CSF_flags & CSF_SERVERSIDEPROC)
232 { // Always scan through the list due to wine class "deftest".
233 for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
234 {
235 if (GETPFNSERVER(i) == Class->lpfnWndProc)
236 {
237 if (Ansi)
238 Ret = (ULONG_PTR)GETPFNCLIENTA(i);
239 else
240 Ret = (ULONG_PTR)GETPFNCLIENTW(i);
241 }
242 }
243 return Ret;
244 }
245 // Set return proc.
246 Ret = (ULONG_PTR)Class->lpfnWndProc;
247 // Return the proc if one of the FnId default class type.
248 if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
249 {
250 if (Ansi)
251 { // If match return the right proc by type.
252 if (GETPFNCLIENTW(Class->fnid) == Class->lpfnWndProc)
253 Ret = (ULONG_PTR)GETPFNCLIENTA(Class->fnid);
254 }
255 else
256 {
257 if (GETPFNCLIENTA(Class->fnid) == Class->lpfnWndProc)
258 Ret = (ULONG_PTR)GETPFNCLIENTW(Class->fnid);
259 }
260 }
261 // Return on change or Ansi/Unicode proc equal.
262 if ( Ret != (ULONG_PTR)Class->lpfnWndProc ||
263 Ansi == !!(Class->CSF_flags & CSF_ANSIPROC) )
264 return Ret;
265
266 /* We have an Ansi and Unicode swap! If Ansi create Unicode proc handle.
267 This will force CallWindowProc to deal with it. */
268 gcpd = NtUserGetCPD( UserHMGetHandle(pWnd),
269 (Ansi ? UserGetCPDA2U : UserGetCPDU2A )|UserGetCPDWndtoCls,
270 Ret);
271
272 return (gcpd ? gcpd : Ret);
273 }
274
275 //
276 // Based on IntGetClsWndProc
277 //
278 WNDPROC FASTCALL
279 IntGetWndProc(PWND pWnd, BOOL Ansi)
280 {
281 INT i;
282 WNDPROC gcpd, Ret = 0;
283 PCLS Class = DesktopPtrToUser(pWnd->pcls);
284
285 if (!Class) return Ret;
286
287 if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC)
288 {
289 for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
290 {
291 if (GETPFNSERVER(i) == pWnd->lpfnWndProc)
292 {
293 if (Ansi)
294 Ret = GETPFNCLIENTA(i);
295 else
296 Ret = GETPFNCLIENTW(i);
297 }
298 }
299 return Ret;
300 }
301 // Wine Class tests:
302 /* Edit controls are special - they return a wndproc handle when
303 GetWindowLongPtr is called with a different A/W.
304 On the other hand there is no W->A->W conversion so this control
305 is treated specially.
306 */
307 if (Class->fnid == FNID_EDIT)
308 Ret = pWnd->lpfnWndProc;
309 else
310 {
311 // Set return proc.
312 Ret = pWnd->lpfnWndProc;
313
314 if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
315 {
316 if (Ansi)
317 {
318 if (GETPFNCLIENTW(Class->fnid) == pWnd->lpfnWndProc)
319 Ret = GETPFNCLIENTA(Class->fnid);
320 }
321 else
322 {
323 if (GETPFNCLIENTA(Class->fnid) == pWnd->lpfnWndProc)
324 Ret = GETPFNCLIENTW(Class->fnid);
325 }
326 }
327 // Return on the change.
328 if ( Ret != pWnd->lpfnWndProc)
329 return Ret;
330 }
331
332 if ( Ansi == !!(pWnd->state & WNDS_ANSIWINDOWPROC) )
333 return Ret;
334
335 gcpd = (WNDPROC)NtUserGetCPD( UserHMGetHandle(pWnd),
336 (Ansi ? UserGetCPDA2U : UserGetCPDU2A )|UserGetCPDWindow,
337 (ULONG_PTR)Ret);
338
339 return (gcpd ? gcpd : Ret);
340 }
341
342 /*
343 * @implemented
344 */
345 DWORD WINAPI
346 GetClassLongA(HWND hWnd, int nIndex)
347 {
348 PWND Wnd;
349 PCLS Class;
350 ULONG_PTR Ret = 0;
351
352 TRACE("%p %d\n", hWnd, nIndex);
353
354 Wnd = ValidateHwnd(hWnd);
355 if (!Wnd)
356 return 0;
357
358 _SEH2_TRY
359 {
360 Class = DesktopPtrToUser(Wnd->pcls);
361 if (Class != NULL)
362 {
363 if (nIndex >= 0)
364 {
365 if (nIndex + sizeof(ULONG_PTR) < nIndex ||
366 nIndex + sizeof(ULONG_PTR) > Class->cbclsExtra)
367 {
368 SetLastError(ERROR_INVALID_PARAMETER);
369 }
370 else
371 Ret = *(PULONG_PTR)((ULONG_PTR)(Class + 1) + nIndex);
372 }
373 else
374 {
375 switch (nIndex)
376 {
377 case GCL_CBWNDEXTRA:
378 Ret = (ULONG_PTR)Class->cbwndExtra;
379 break;
380
381 case GCL_CBCLSEXTRA:
382 Ret = (ULONG_PTR)Class->cbclsExtra;
383 break;
384
385 case GCL_HBRBACKGROUND:
386 Ret = (ULONG_PTR)Class->hbrBackground;
387 if (Ret != 0 && Ret < 0x4000)
388 Ret = (ULONG_PTR)GetSysColorBrush((ULONG)Ret - 1);
389 break;
390
391 case GCL_HMODULE:
392 //ERR("Cls 0x%x GCL_HMODULE 0x%x\n", Wnd->pcls, Class->hModule);
393 Ret = (ULONG_PTR)Class->hModule;
394 break;
395
396 case GCL_MENUNAME:
397 Ret = (ULONG_PTR)Class->lpszClientAnsiMenuName;
398 break;
399
400 case GCL_STYLE:
401 Ret = (ULONG_PTR)Class->style;
402 break;
403
404 case GCW_ATOM:
405 Ret = (ULONG_PTR)Class->atomClassName;
406 break;
407
408 case GCLP_HCURSOR:
409 /* FIXME - get handle from pointer to CURSOR object */
410 Ret = (ULONG_PTR)Class->hCursor;
411 break;
412
413 case GCLP_HICON:
414 /* FIXME - get handle from pointer to ICON object */
415 Ret = (ULONG_PTR)Class->hIcon;
416 break;
417
418 case GCLP_HICONSM:
419 /* FIXME - get handle from pointer to ICON object */
420 Ret = (ULONG_PTR)Class->hIconSm;
421 break;
422
423 case GCLP_WNDPROC:
424 Ret = IntGetClsWndProc(Wnd, Class, TRUE);
425 break;
426
427 default:
428 SetLastError(ERROR_INVALID_INDEX);
429 break;
430 }
431 }
432 }
433 else
434 {
435 WARN("Invalid class for hwnd 0x%p!\n", hWnd);
436 }
437 }
438 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
439 {
440 Ret = 0;
441 }
442 _SEH2_END;
443
444 return Ret;
445 }
446
447 /*
448 * @implemented
449 */
450 DWORD WINAPI
451 GetClassLongW ( HWND hWnd, int nIndex )
452 {
453 PWND Wnd;
454 PCLS Class;
455 ULONG_PTR Ret = 0;
456
457 TRACE("%p %d\n", hWnd, nIndex);
458
459 Wnd = ValidateHwnd(hWnd);
460 if (!Wnd)
461 return 0;
462
463 _SEH2_TRY
464 {
465 Class = DesktopPtrToUser(Wnd->pcls);
466 if (Class != NULL)
467 {
468 if (nIndex >= 0)
469 {
470 if (nIndex + sizeof(ULONG_PTR) < nIndex ||
471 nIndex + sizeof(ULONG_PTR) > Class->cbclsExtra)
472 {
473 SetLastError(ERROR_INVALID_PARAMETER);
474 }
475 else
476 Ret = *(PULONG_PTR)((ULONG_PTR)(Class + 1) + nIndex);
477 }
478 else
479 {
480 switch (nIndex)
481 {
482 case GCL_CBWNDEXTRA:
483 Ret = (ULONG_PTR)Class->cbwndExtra;
484 break;
485
486 case GCL_CBCLSEXTRA:
487 Ret = (ULONG_PTR)Class->cbclsExtra;
488 break;
489
490 case GCL_HBRBACKGROUND:
491 Ret = (ULONG_PTR)Class->hbrBackground;
492 if (Ret != 0 && Ret < 0x4000)
493 Ret = (ULONG_PTR)GetSysColorBrush((ULONG)Ret - 1);
494 break;
495
496 case GCL_HMODULE:
497 Ret = (ULONG_PTR)Class->hModule;
498 break;
499
500 case GCL_MENUNAME:
501 Ret = (ULONG_PTR)Class->lpszClientUnicodeMenuName;
502 break;
503
504 case GCL_STYLE:
505 Ret = (ULONG_PTR)Class->style;
506 break;
507
508 case GCW_ATOM:
509 Ret = (ULONG_PTR)Class->atomClassName;
510 break;
511
512 case GCLP_HCURSOR:
513 /* FIXME - get handle from pointer to CURSOR object */
514 Ret = (ULONG_PTR)Class->hCursor;
515 break;
516
517 case GCLP_HICON:
518 /* FIXME - get handle from pointer to ICON object */
519 Ret = (ULONG_PTR)Class->hIcon;
520 break;
521
522 case GCLP_HICONSM:
523 /* FIXME - get handle from pointer to ICON object */
524 Ret = (ULONG_PTR)Class->hIconSm;
525 break;
526
527 case GCLP_WNDPROC:
528 Ret = IntGetClsWndProc(Wnd, Class, FALSE);
529 break;
530
531 default:
532 SetLastError(ERROR_INVALID_INDEX);
533 break;
534 }
535 }
536 }
537 else
538 {
539 WARN("Invalid class for hwnd 0x%p!\n", hWnd);
540 }
541 }
542 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
543 {
544 }
545 _SEH2_END;
546
547 return Ret;
548 }
549
550 #ifdef _WIN64
551 /*
552 * @unimplemented
553 */
554 ULONG_PTR
555 WINAPI
556 GetClassLongPtrA(HWND hWnd,
557 INT nIndex)
558 {
559 UNIMPLEMENTED;
560 return 0;
561 }
562
563 /*
564 * @unimplemented
565 */
566 ULONG_PTR
567 WINAPI
568 GetClassLongPtrW(HWND hWnd,
569 INT nIndex)
570 {
571 UNIMPLEMENTED;
572 return 0;
573 }
574 #endif
575
576
577 /*
578 * @implemented
579 */
580 int WINAPI
581 GetClassNameA(
582 HWND hWnd,
583 LPSTR lpClassName,
584 int nMaxCount)
585 {
586 ANSI_STRING ClassName;
587 int Result;
588
589 ClassName.MaximumLength = nMaxCount;
590 ClassName.Buffer = lpClassName;
591
592 Result = NtUserGetClassName(hWnd,
593 (PUNICODE_STRING)&ClassName,
594 TRUE);
595
596 TRACE("%p class/atom: %s/%04x %x\n", hWnd,
597 IS_ATOM(lpClassName) ? NULL : lpClassName,
598 IS_ATOM(lpClassName) ? lpClassName : 0,
599 nMaxCount);
600
601 return Result;
602 }
603
604
605 /*
606 * @implemented
607 */
608 int
609 WINAPI
610 GetClassNameW(
611 HWND hWnd,
612 LPWSTR lpClassName,
613 int nMaxCount)
614 {
615 UNICODE_STRING ClassName;
616 int Result;
617
618 ClassName.MaximumLength = nMaxCount * sizeof(WCHAR);
619 ClassName.Buffer = lpClassName;
620
621 Result = NtUserGetClassName(hWnd,
622 &ClassName,
623 FALSE);
624
625 TRACE("%p class/atom: %S/%04x %x\n", hWnd,
626 IS_ATOM(lpClassName) ? NULL : lpClassName,
627 IS_ATOM(lpClassName) ? lpClassName : 0,
628 nMaxCount);
629
630 return Result;
631 }
632
633
634 /*
635 * @implemented
636 */
637 WORD
638 WINAPI
639 GetClassWord(
640 HWND hwnd,
641 int offset)
642 {
643 PWND Wnd;
644 PCLS class;
645 WORD retvalue = 0;
646
647 if (offset < 0) return GetClassLongA( hwnd, offset );
648
649 Wnd = ValidateHwnd(hwnd);
650 if (!Wnd)
651 return 0;
652
653 class = DesktopPtrToUser(Wnd->pcls);
654 if (class == NULL) return 0;
655
656 if (offset <= class->cbclsExtra - sizeof(WORD))
657 memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(retvalue) );
658 else
659 SetLastError( ERROR_INVALID_INDEX );
660
661 return retvalue;
662 }
663
664
665 LONG_PTR IntGetWindowLong( HWND hwnd, INT offset, UINT size, BOOL unicode )
666 {
667 LONG_PTR retvalue = 0;
668 WND *wndPtr;
669
670 if (offset == GWLP_HWNDPARENT)
671 {
672 HWND parent = GetAncestor( hwnd, GA_PARENT );
673 if (parent == GetDesktopWindow()) parent = GetWindow( hwnd, GW_OWNER );
674 return (ULONG_PTR)parent;
675 }
676
677 if (!(wndPtr = ValidateHwnd( hwnd )))
678 {
679 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
680 return 0;
681 }
682
683 if (offset >= 0)
684 {
685 if (offset > (int)(wndPtr->cbwndExtra - size))
686 {
687 WARN("Invalid offset %d\n", offset );
688 SetLastError( ERROR_INVALID_INDEX );
689 return 0;
690 }
691 retvalue = *((LONG_PTR *)((PCHAR)(wndPtr + 1) + offset));
692
693 /* WINE: special case for dialog window procedure */
694 //if ((offset == DWLP_DLGPROC) && (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
695 // retvalue = (LONG_PTR)IntGetWndProc( (WNDPROC)retvalue, unicode );
696 return retvalue;
697 }
698
699 switch(offset)
700 {
701 case GWLP_USERDATA: retvalue = wndPtr->dwUserData; break;
702 case GWL_STYLE: retvalue = wndPtr->style; break;
703 case GWL_EXSTYLE: retvalue = wndPtr->ExStyle; break;
704 case GWLP_ID: retvalue = wndPtr->IDMenu; break;
705 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)wndPtr->hModule; break;
706 case GWLP_WNDPROC:
707 {
708 if (!TestWindowProcess(wndPtr))
709 {
710 SetLastError(ERROR_ACCESS_DENIED);
711 retvalue = 0;
712 }
713 retvalue = (ULONG_PTR)IntGetWndProc(wndPtr, !unicode);
714 break;
715 }
716 default:
717 WARN("Unknown offset %d\n", offset );
718 SetLastError( ERROR_INVALID_INDEX );
719 break;
720 }
721 return retvalue;
722
723 }
724 /*
725 * @implemented
726 */
727 LONG
728 WINAPI
729 GetWindowLongA ( HWND hWnd, int nIndex )
730 {
731 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), FALSE );
732 }
733
734 /*
735 * @implemented
736 */
737 LONG
738 WINAPI
739 GetWindowLongW(HWND hWnd, int nIndex)
740 {
741 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), TRUE );
742 }
743
744 #ifdef _WIN64
745 /*
746 * @implemented
747 */
748 LONG_PTR
749 WINAPI
750 GetWindowLongPtrA(HWND hWnd,
751 INT nIndex)
752 {
753 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG_PTR), FALSE );
754 }
755
756 /*
757 * @implemented
758 */
759 LONG_PTR
760 WINAPI
761 GetWindowLongPtrW(HWND hWnd,
762 INT nIndex)
763 {
764 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG_PTR), TRUE );
765
766 }
767 #endif // _WIN64
768
769 /*
770 * @implemented
771 */
772 WORD
773 WINAPI
774 GetWindowWord(HWND hWnd, int nIndex)
775 {
776 switch(nIndex)
777 {
778 case GWLP_ID:
779 case GWLP_HINSTANCE:
780 case GWLP_HWNDPARENT:
781 break;
782 default:
783 if (nIndex < 0)
784 {
785 WARN("Invalid offset %d\n", nIndex );
786 SetLastError( ERROR_INVALID_INDEX );
787 return 0;
788 }
789 break;
790 }
791 return IntGetWindowLong( hWnd, nIndex, sizeof(WORD), FALSE );
792 }
793
794 /*
795 * @implemented
796 */
797 UINT
798 WINAPI
799 RealGetWindowClassW(
800 HWND hwnd,
801 LPWSTR pszType,
802 UINT cchType)
803 {
804 /* FIXME: Implement correct functionality of RealGetWindowClass */
805 return GetClassNameW(hwnd,pszType,cchType);
806 }
807
808
809 /*
810 * @implemented
811 */
812 UINT
813 WINAPI
814 RealGetWindowClassA(
815 HWND hwnd,
816 LPSTR pszType,
817 UINT cchType)
818 {
819 /* FIXME: Implement correct functionality of RealGetWindowClass */
820 return GetClassNameA(hwnd,pszType,cchType);
821 }
822
823 /*
824 * Create a small icon based on a standard icon
825 */
826 static HICON
827 CreateSmallIcon(HICON StdIcon)
828 {
829 HICON SmallIcon = NULL;
830 ICONINFO StdInfo;
831 int SmallIconWidth;
832 int SmallIconHeight;
833 BITMAP StdBitmapInfo;
834 HDC hSourceDc = NULL;
835 HDC hDestDc = NULL;
836 ICONINFO SmallInfo;
837 HBITMAP OldSourceBitmap = NULL;
838 HBITMAP OldDestBitmap = NULL;
839
840 SmallInfo.hbmColor = NULL;
841 SmallInfo.hbmMask = NULL;
842
843 /* We need something to work with... */
844 if (NULL == StdIcon)
845 {
846 goto cleanup;
847 }
848
849 SmallIconWidth = GetSystemMetrics(SM_CXSMICON);
850 SmallIconHeight = GetSystemMetrics(SM_CYSMICON);
851 if (! GetIconInfo(StdIcon, &StdInfo))
852 {
853 ERR("Failed to get icon info for icon 0x%x\n", StdIcon);
854 goto cleanup;
855 }
856 if (! GetObjectW(StdInfo.hbmMask, sizeof(BITMAP), &StdBitmapInfo))
857 {
858 ERR("Failed to get bitmap info for icon 0x%x bitmap 0x%x\n",
859 StdIcon, StdInfo.hbmColor);
860 goto cleanup;
861 }
862 if (StdBitmapInfo.bmWidth == SmallIconWidth &&
863 StdBitmapInfo.bmHeight == SmallIconHeight)
864 {
865 /* Icon already has the correct dimensions */
866 return StdIcon;
867 }
868
869 hSourceDc = CreateCompatibleDC(NULL);
870 if (NULL == hSourceDc)
871 {
872 ERR("Failed to create source DC\n");
873 goto cleanup;
874 }
875 hDestDc = CreateCompatibleDC(NULL);
876 if (NULL == hDestDc)
877 {
878 ERR("Failed to create dest DC\n");
879 goto cleanup;
880 }
881
882 OldSourceBitmap = SelectObject(hSourceDc, StdInfo.hbmColor);
883 if (NULL == OldSourceBitmap)
884 {
885 ERR("Failed to select source color bitmap\n");
886 goto cleanup;
887 }
888 SmallInfo.hbmColor = CreateCompatibleBitmap(hSourceDc, SmallIconWidth,
889 SmallIconHeight);
890 if (NULL == SmallInfo.hbmColor)
891 {
892 ERR("Failed to create color bitmap\n");
893 goto cleanup;
894 }
895 OldDestBitmap = SelectObject(hDestDc, SmallInfo.hbmColor);
896 if (NULL == OldDestBitmap)
897 {
898 ERR("Failed to select dest color bitmap\n");
899 goto cleanup;
900 }
901 if (! StretchBlt(hDestDc, 0, 0, SmallIconWidth, SmallIconHeight,
902 hSourceDc, 0, 0, StdBitmapInfo.bmWidth,
903 StdBitmapInfo.bmHeight, SRCCOPY))
904 {
905 ERR("Failed to stretch color bitmap\n");
906 goto cleanup;
907 }
908
909 if (NULL == SelectObject(hSourceDc, StdInfo.hbmMask))
910 {
911 ERR("Failed to select source mask bitmap\n");
912 goto cleanup;
913 }
914 SmallInfo.hbmMask = CreateCompatibleBitmap(hSourceDc, SmallIconWidth, SmallIconHeight);
915 if (NULL == SmallInfo.hbmMask)
916 {
917 ERR("Failed to create mask bitmap\n");
918 goto cleanup;
919 }
920 if (NULL == SelectObject(hDestDc, SmallInfo.hbmMask))
921 {
922 ERR("Failed to select dest mask bitmap\n");
923 goto cleanup;
924 }
925 if (! StretchBlt(hDestDc, 0, 0, SmallIconWidth, SmallIconHeight,
926 hSourceDc, 0, 0, StdBitmapInfo.bmWidth,
927 StdBitmapInfo.bmHeight, SRCCOPY))
928 {
929 ERR("Failed to stretch mask bitmap\n");
930 goto cleanup;
931 }
932
933 SmallInfo.fIcon = TRUE;
934 SmallInfo.xHotspot = SmallIconWidth / 2;
935 SmallInfo.yHotspot = SmallIconHeight / 2;
936 SmallIcon = CreateIconIndirect(&SmallInfo);
937 if (NULL == SmallIcon)
938 {
939 ERR("Failed to create icon\n");
940 goto cleanup;
941 }
942
943 cleanup:
944 if (NULL != SmallInfo.hbmMask)
945 {
946 DeleteObject(SmallInfo.hbmMask);
947 }
948 if (NULL != OldDestBitmap)
949 {
950 SelectObject(hDestDc, OldDestBitmap);
951 }
952 if (NULL != SmallInfo.hbmColor)
953 {
954 DeleteObject(SmallInfo.hbmColor);
955 }
956 if (NULL != hDestDc)
957 {
958 DeleteDC(hDestDc);
959 }
960 if (NULL != OldSourceBitmap)
961 {
962 SelectObject(hSourceDc, OldSourceBitmap);
963 }
964 if (NULL != hSourceDc)
965 {
966 DeleteDC(hSourceDc);
967 }
968
969 return SmallIcon;
970 }
971
972
973 ATOM WINAPI
974 RegisterClassExWOWW(WNDCLASSEXW *lpwcx,
975 LPDWORD pdwWowData,
976 WORD fnID,
977 DWORD dwFlags,
978 BOOL ChkRegCls)
979 {
980 ATOM Atom;
981 WNDCLASSEXW WndClass;
982 UNICODE_STRING ClassName;
983 UNICODE_STRING MenuName = {0};
984 CLSMENUNAME clsMenuName;
985 ANSI_STRING AnsiMenuName;
986
987 if (lpwcx == NULL || lpwcx->cbSize != sizeof(WNDCLASSEXW) ||
988 lpwcx->cbClsExtra < 0 || lpwcx->cbWndExtra < 0 ||
989 lpwcx->lpszClassName == NULL)
990 {
991 TRACE("RegisterClassExWOWW Invalid Parameter Error!\n");
992 SetLastError(ERROR_INVALID_PARAMETER);
993 return 0;
994 }
995
996 if (ChkRegCls)
997 {
998 if (!RegisterDefaultClasses) RegisterSystemControls();
999 }
1000 /*
1001 * On real Windows this looks more like:
1002 * if (lpwcx->hInstance == User32Instance &&
1003 * *(PULONG)((ULONG_PTR)NtCurrentTeb() + 0x6D4) & 0x400)
1004 * But since I have no idea what the magic field in the
1005 * TEB structure means, I rather decided to omit that.
1006 * -- Filip Navara
1007
1008 GetWin32ClientInfo()->dwExpWinVer & (WINVER == 0x400)
1009 */
1010 if (lpwcx->hInstance == User32Instance)
1011 {
1012 TRACE("RegisterClassExWOWW User32Instance!\n");
1013 SetLastError(ERROR_INVALID_PARAMETER);
1014 return 0;
1015 }
1016 /* Yes, this is correct. We should modify the passed structure. */
1017 if (lpwcx->hInstance == NULL)
1018 ((WNDCLASSEXW*)lpwcx)->hInstance = GetModuleHandleW(NULL);
1019
1020 RtlCopyMemory(&WndClass, lpwcx, sizeof(WNDCLASSEXW));
1021
1022 if (NULL == WndClass.hIconSm)
1023 {
1024 WndClass.hIconSm = CreateSmallIcon(WndClass.hIcon);
1025 }
1026
1027 if (WndClass.lpszMenuName != NULL)
1028 {
1029 if (!IS_INTRESOURCE(WndClass.lpszMenuName))
1030 {
1031 if (WndClass.lpszMenuName[0])
1032 {
1033 RtlInitUnicodeString(&MenuName, WndClass.lpszMenuName);
1034 RtlUnicodeStringToAnsiString( &AnsiMenuName, &MenuName, TRUE);
1035 }
1036 }
1037 else
1038 {
1039 MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
1040 AnsiMenuName.Buffer = (PCHAR)WndClass.lpszMenuName;
1041 }
1042 }
1043
1044 if (IS_ATOM(WndClass.lpszClassName))
1045 {
1046 ClassName.Length =
1047 ClassName.MaximumLength = 0;
1048 ClassName.Buffer = (LPWSTR)WndClass.lpszClassName;
1049 }
1050 else
1051 {
1052 RtlInitUnicodeString(&ClassName, WndClass.lpszClassName);
1053 }
1054
1055 clsMenuName.pszClientAnsiMenuName = AnsiMenuName.Buffer;
1056 clsMenuName.pwszClientUnicodeMenuName = MenuName.Buffer;
1057 clsMenuName.pusMenuName = &MenuName;
1058
1059 Atom = NtUserRegisterClassExWOW( &WndClass,
1060 &ClassName,
1061 NULL, //PUNICODE_STRING ClsNVersion,
1062 &clsMenuName,
1063 fnID,
1064 dwFlags,
1065 pdwWowData);
1066
1067 TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
1068 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1069 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
1070
1071 return Atom;
1072 }
1073
1074 /*
1075 * @implemented
1076 */
1077 ATOM WINAPI
1078 RegisterClassExA(CONST WNDCLASSEXA *lpwcx)
1079 {
1080 RTL_ATOM Atom;
1081 WNDCLASSEXW WndClass;
1082 WCHAR mname[MAX_BUFFER_LEN];
1083 WCHAR cname[MAX_BUFFER_LEN];
1084
1085 RtlCopyMemory(&WndClass, lpwcx, sizeof(WNDCLASSEXA));
1086
1087 if (WndClass.lpszMenuName != NULL)
1088 {
1089 if (!IS_INTRESOURCE(WndClass.lpszMenuName))
1090 {
1091 if (WndClass.lpszMenuName[0])
1092 {
1093 if (!MultiByteToWideChar( CP_ACP, 0, lpwcx->lpszMenuName, -1, mname, MAX_ATOM_LEN + 1 )) return 0;
1094
1095 WndClass.lpszMenuName = mname;
1096 }
1097 }
1098 }
1099
1100 if (!IS_ATOM(WndClass.lpszClassName))
1101 {
1102 if (!MultiByteToWideChar( CP_ACP, 0, lpwcx->lpszClassName, -1, cname, MAX_ATOM_LEN + 1 )) return 0;
1103
1104 WndClass.lpszClassName = cname;
1105 }
1106
1107 Atom = RegisterClassExWOWW( &WndClass,
1108 0,
1109 0,
1110 CSF_ANSIPROC,
1111 TRUE);
1112
1113 TRACE("A atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
1114 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1115 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
1116
1117 return (ATOM)Atom;
1118 }
1119
1120 /*
1121 * @implemented
1122 */
1123 ATOM WINAPI
1124 RegisterClassExW(CONST WNDCLASSEXW *lpwcx)
1125 {
1126 ATOM Atom;
1127
1128 Atom = RegisterClassExWOWW( (WNDCLASSEXW *)lpwcx, 0, 0, 0, TRUE);
1129
1130 TRACE("W atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d\n",
1131 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1132 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra);
1133
1134 return Atom;
1135 }
1136
1137 /*
1138 * @implemented
1139 */
1140 ATOM WINAPI
1141 RegisterClassA(CONST WNDCLASSA *lpWndClass)
1142 {
1143 WNDCLASSEXA Class;
1144
1145 if (lpWndClass == NULL)
1146 return 0;
1147
1148 RtlCopyMemory(&Class.style, lpWndClass, sizeof(WNDCLASSA));
1149 Class.cbSize = sizeof(WNDCLASSEXA);
1150 Class.hIconSm = NULL;
1151
1152 return RegisterClassExA(&Class);
1153 }
1154
1155 /*
1156 * @implemented
1157 */
1158 ATOM WINAPI
1159 RegisterClassW(CONST WNDCLASSW *lpWndClass)
1160 {
1161 WNDCLASSEXW Class;
1162
1163 if (lpWndClass == NULL)
1164 return 0;
1165
1166 RtlCopyMemory(&Class.style, lpWndClass, sizeof(WNDCLASSW));
1167 Class.cbSize = sizeof(WNDCLASSEXW);
1168 Class.hIconSm = NULL;
1169
1170 return RegisterClassExW(&Class);
1171 }
1172
1173 /*
1174 * @implemented
1175 */
1176 DWORD
1177 WINAPI
1178 SetClassLongA (HWND hWnd,
1179 int nIndex,
1180 LONG dwNewLong)
1181 {
1182 PSTR lpStr = (PSTR)(ULONG_PTR)dwNewLong;
1183 UNICODE_STRING Value = {0};
1184 BOOL Allocated = FALSE;
1185 DWORD Ret;
1186
1187 /* FIXME - portability!!!! */
1188
1189 if (nIndex == GCL_MENUNAME && lpStr != NULL)
1190 {
1191 if (!IS_INTRESOURCE(lpStr))
1192 {
1193 if (!RtlCreateUnicodeStringFromAsciiz(&Value,
1194 lpStr))
1195 {
1196 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1197 return 0;
1198 }
1199
1200 Allocated = TRUE;
1201 }
1202 else
1203 Value.Buffer = (PWSTR)lpStr;
1204
1205 dwNewLong = (LONG_PTR)&Value;
1206 }
1207 else if (nIndex == GCW_ATOM && lpStr != NULL)
1208 {
1209 if (!IS_ATOM(lpStr))
1210 {
1211 if (!RtlCreateUnicodeStringFromAsciiz(&Value,
1212 lpStr))
1213 {
1214 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1215 return 0;
1216 }
1217
1218 Allocated = TRUE;
1219 }
1220 else
1221 Value.Buffer = (PWSTR)lpStr;
1222
1223 dwNewLong = (LONG_PTR)&Value;
1224 }
1225
1226 Ret = (DWORD)NtUserSetClassLong(hWnd,
1227 nIndex,
1228 dwNewLong,
1229 TRUE);
1230
1231 if (Allocated)
1232 {
1233 RtlFreeUnicodeString(&Value);
1234 }
1235
1236 return Ret;
1237 }
1238
1239
1240 /*
1241 * @implemented
1242 */
1243 DWORD
1244 WINAPI
1245 SetClassLongW(HWND hWnd,
1246 int nIndex,
1247 LONG dwNewLong)
1248 {
1249 PWSTR lpStr = (PWSTR)(ULONG_PTR)dwNewLong;
1250 UNICODE_STRING Value = {0};
1251
1252 TRACE("%p %d %lx\n", hWnd, nIndex, dwNewLong);
1253
1254 /* FIXME - portability!!!! */
1255
1256 if (nIndex == GCL_MENUNAME && lpStr != NULL)
1257 {
1258 if (!IS_INTRESOURCE(lpStr))
1259 {
1260 RtlInitUnicodeString(&Value,
1261 lpStr);
1262 }
1263 else
1264 Value.Buffer = lpStr;
1265
1266 dwNewLong = (LONG_PTR)&Value;
1267 }
1268 else if (nIndex == GCW_ATOM && lpStr != NULL)
1269 {
1270 if (!IS_ATOM(lpStr))
1271 {
1272 RtlInitUnicodeString(&Value,
1273 lpStr);
1274 }
1275 else
1276 Value.Buffer = lpStr;
1277
1278 dwNewLong = (LONG_PTR)&Value;
1279 }
1280
1281 return (DWORD)NtUserSetClassLong(hWnd,
1282 nIndex,
1283 dwNewLong,
1284 FALSE);
1285 }
1286
1287 #ifdef _WIN64
1288 /*
1289 * @unimplemented
1290 */
1291 ULONG_PTR
1292 WINAPI
1293 SetClassLongPtrA(HWND hWnd,
1294 INT nIndex,
1295 LONG_PTR dwNewLong)
1296 {
1297 UNIMPLEMENTED;
1298 return 0;
1299 }
1300
1301 /*
1302 * @unimplemented
1303 */
1304 ULONG_PTR
1305 WINAPI
1306 SetClassLongPtrW(HWND hWnd,
1307 INT nIndex,
1308 LONG_PTR dwNewLong)
1309 {
1310 UNIMPLEMENTED;
1311 return 0;
1312 }
1313 #endif // _WIN64
1314
1315 /*
1316 * @implemented
1317 */
1318 WORD
1319 WINAPI
1320 SetClassWord(
1321 HWND hWnd,
1322 int nIndex,
1323 WORD wNewWord)
1324 /*
1325 * NOTE: Obsoleted in 32-bit windows
1326 */
1327 {
1328 if ((nIndex < 0) && (nIndex != GCW_ATOM))
1329 return 0;
1330
1331 return (WORD) SetClassLongW ( hWnd, nIndex, wNewWord );
1332 }
1333
1334 /*
1335 * @implemented
1336 */
1337 WORD
1338 WINAPI
1339 SetWindowWord ( HWND hWnd,int nIndex,WORD wNewWord )
1340 {
1341 switch(nIndex)
1342 {
1343 case GWLP_ID:
1344 case GWLP_HINSTANCE:
1345 case GWLP_HWNDPARENT:
1346 break;
1347 default:
1348 if (nIndex < 0)
1349 {
1350 WARN("Invalid offset %d\n", nIndex );
1351 SetLastError( ERROR_INVALID_INDEX );
1352 return 0;
1353 }
1354 break;
1355 }
1356 return NtUserSetWindowLong( hWnd, nIndex, wNewWord, FALSE );
1357 }
1358
1359 /*
1360 * @implemented
1361 */
1362 LONG
1363 WINAPI
1364 SetWindowLongA(
1365 HWND hWnd,
1366 int nIndex,
1367 LONG dwNewLong)
1368 {
1369 return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, TRUE);
1370 }
1371
1372 /*
1373 * @implemented
1374 */
1375 LONG
1376 WINAPI
1377 SetWindowLongW(
1378 HWND hWnd,
1379 int nIndex,
1380 LONG dwNewLong)
1381 {
1382 return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, FALSE);
1383 }
1384
1385 #ifdef _WIN64
1386 /*
1387 * @implemented
1388 */
1389 LONG_PTR
1390 WINAPI
1391 SetWindowLongPtrA(HWND hWnd,
1392 INT nIndex,
1393 LONG_PTR dwNewLong)
1394 {
1395 return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, FALSE);
1396 }
1397
1398 /*
1399 * @implemented
1400 */
1401 LONG_PTR
1402 WINAPI
1403 SetWindowLongPtrW(HWND hWnd,
1404 INT nIndex,
1405 LONG_PTR dwNewLong)
1406 {
1407 return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, FALSE);
1408 }
1409 #endif
1410
1411 /*
1412 * @implemented
1413 */
1414 BOOL
1415 WINAPI
1416 UnregisterClassA(
1417 LPCSTR lpClassName,
1418 HINSTANCE hInstance)
1419 {
1420 UNICODE_STRING ClassName = {0};
1421 BOOL Ret;
1422
1423 TRACE("class/atom: %s/%04x %p\n",
1424 IS_ATOM(lpClassName) ? NULL : lpClassName,
1425 IS_ATOM(lpClassName) ? lpClassName : 0,
1426 hInstance);
1427
1428 if (!IS_ATOM(lpClassName))
1429 {
1430 if (!RtlCreateUnicodeStringFromAsciiz(&ClassName,
1431 lpClassName))
1432 {
1433 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1434 return 0;
1435 }
1436 }
1437 else
1438 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1439
1440 Ret = NtUserUnregisterClass(&ClassName,
1441 hInstance,
1442 0);
1443
1444 if (!IS_ATOM(lpClassName))
1445 RtlFreeUnicodeString(&ClassName);
1446
1447 return Ret;
1448 }
1449
1450
1451 /*
1452 * @implemented
1453 */
1454 BOOL
1455 WINAPI
1456 UnregisterClassW(
1457 LPCWSTR lpClassName,
1458 HINSTANCE hInstance)
1459 {
1460 UNICODE_STRING ClassName = {0};
1461
1462 TRACE("class/atom: %S/%04x %p\n",
1463 IS_ATOM(lpClassName) ? NULL : lpClassName,
1464 IS_ATOM(lpClassName) ? lpClassName : 0,
1465 hInstance);
1466
1467 if (!IS_ATOM(lpClassName))
1468 {
1469 RtlInitUnicodeString(&ClassName,
1470 lpClassName);
1471 }
1472 else
1473 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1474
1475 return NtUserUnregisterClass(&ClassName,
1476 hInstance,
1477 0);
1478 }
1479
1480 /* EOF */