ReactOS 0.4.15-dev-5874-gc762234
class.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS user32.dll
3 * COPYRIGHT: GPL - See COPYING in the top level directory
4 * FILE: win32ss/user/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
14
15#define USE_VERSIONED_CLASSES
16
17/* From rtl/actctx.c and must match! */
19{
21 ULONG size;
22 DWORD unk1[3];
25 DWORD unk2[2];
28};
29
31{
32 ULONG size;
33 DWORD res;
35 ULONG name_offset; /* versioned name offset */
37 ULONG module_offset;/* container name offset */
38};
39
40//
41// Use wine hack to process extended context classes.
42//
43/***********************************************************************
44 * is_comctl32_class
45 */
47{
48 static const WCHAR classesW[][20] =
49 {
50 {'C','o','m','b','o','B','o','x','E','x','3','2',0},
51 {'m','s','c','t','l','s','_','h','o','t','k','e','y','3','2',0},
52 {'m','s','c','t','l','s','_','p','r','o','g','r','e','s','s','3','2',0},
53 {'m','s','c','t','l','s','_','s','t','a','t','u','s','b','a','r','3','2',0},
54 {'m','s','c','t','l','s','_','t','r','a','c','k','b','a','r','3','2',0},
55 {'m','s','c','t','l','s','_','u','p','d','o','w','n','3','2',0},
56 {'N','a','t','i','v','e','F','o','n','t','C','t','l',0},
57 {'R','e','B','a','r','W','i','n','d','o','w','3','2',0},
58 {'S','y','s','A','n','i','m','a','t','e','3','2',0},
59 {'S','y','s','D','a','t','e','T','i','m','e','P','i','c','k','3','2',0},
60 {'S','y','s','H','e','a','d','e','r','3','2',0},
61 {'S','y','s','I','P','A','d','d','r','e','s','s','3','2',0},
62 {'S','y','s','L','i','s','t','V','i','e','w','3','2',0},
63 {'S','y','s','M','o','n','t','h','C','a','l','3','2',0},
64 {'S','y','s','P','a','g','e','r',0},
65 {'S','y','s','T','a','b','C','o','n','t','r','o','l','3','2',0},
66 {'S','y','s','T','r','e','e','V','i','e','w','3','2',0},
67 {'T','o','o','l','b','a','r','W','i','n','d','o','w','3','2',0},
68 {'t','o','o','l','t','i','p','s','_','c','l','a','s','s','3','2',0},
69 };
70
71 int min = 0, max = (sizeof(classesW) / sizeof(classesW[0])) - 1;
72
73 while (min <= max)
74 {
75 int res, pos = (min + max) / 2;
76 if (!(res = strcmpiW( name, classesW[pos] ))) return classesW[pos];
77 if (res < 0) max = pos - 1;
78 else min = pos + 1;
79 }
80 return NULL;
81}
82
86 const void* lpszClass,
87 LPCWSTR lpszMenuName,
88 LPCWSTR *plpLibFileName,
89 HANDLE *pContext,
90 BOOL bAnsi)
91{
92 LPCWSTR VersionedClass = NULL;
93#ifdef USE_VERSIONED_CLASSES
95#endif
96 UNICODE_STRING SectionName;
97 WCHAR SectionNameBuf[MAX_PATH] = {0};
98 ACTCTX_SECTION_KEYED_DATA KeyedData = { sizeof(KeyedData) };
99
100 if(!lpszClass)
101 {
102 ERR("Null class given !\n");
103 return NULL;
104 }
105
106 if (IS_ATOM(lpszClass))
107 {
108 RtlInitEmptyUnicodeString(&SectionName, SectionNameBuf, sizeof(SectionNameBuf));
109 if(!NtUserGetAtomName(LOWORD((DWORD_PTR)lpszClass), &SectionName))
110 {
111 ERR("Couldn't get atom name for atom %x !\n", LOWORD((DWORD_PTR)lpszClass));
112 return NULL;
113 }
114 SectionName.Length = (USHORT)wcslen(SectionNameBuf) * sizeof(WCHAR);
115 TRACE("ClassNameToVersion got name %wZ from atom\n", &SectionName);
116 }
117 else
118 {
119 if (bAnsi)
120 {
122 RtlInitAnsiString(&AnsiString, lpszClass);
123 RtlInitEmptyUnicodeString(&SectionName, SectionNameBuf, sizeof(SectionNameBuf));
125 }
126 else
127 {
128 RtlInitUnicodeString(&SectionName, lpszClass);
129 }
130 }
131#ifdef USE_VERSIONED_CLASSES
132 Status = RtlFindActivationContextSectionString( FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX,
133 NULL,
134 ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION,
135 &SectionName,
136 &KeyedData );
137
138 if (NT_SUCCESS(Status) && KeyedData.ulDataFormatVersion == 1)
139 {
140 struct strsection_header *SectionHeader = KeyedData.lpSectionBase;
141
142 /* Find activation context */
143 if(SectionHeader && SectionHeader->count > 0)
144 {
145 struct wndclass_redirect_data *WindowRedirectionData = KeyedData.lpData;
146 if(WindowRedirectionData && WindowRedirectionData->module_len)
147 {
148 LPCWSTR lpLibFileName;
149
150 VersionedClass = (WCHAR*)((BYTE*)WindowRedirectionData + WindowRedirectionData->name_offset);
151 lpLibFileName = (WCHAR*)((BYTE*)KeyedData.lpSectionBase + WindowRedirectionData->module_offset);
152 TRACE("Returning VersionedClass=%S, plpLibFileName=%S for class %S\n", VersionedClass, lpLibFileName, SectionName.Buffer);
153
154 if (pContext) *pContext = KeyedData.hActCtx;
155 if (plpLibFileName) *plpLibFileName = lpLibFileName;
156
157 }
158 }
159 }
160
161 if (KeyedData.hActCtx)
162 RtlReleaseActivationContext(KeyedData.hActCtx);
163#endif
164
165#ifndef DEFAULT_ACTIVATION_CONTEXTS_SUPPORTED
166 /* This block is a hack! */
167 if (!VersionedClass)
168 {
169 /*
170 * In windows the default activation context always contains comctl32v5
171 * In reactos we don't have a default activation context so we
172 * mimic wine here.
173 */
174 VersionedClass = is_comctl32_class(SectionName.Buffer);
175 if (VersionedClass)
176 {
177 if (pContext) *pContext = 0;
178 if (plpLibFileName) *plpLibFileName = L"comctl32";
179 }
180 }
181#endif
182
183 /*
184 * The returned strings are pointers in the activation context and
185 * will get freed when the activation context gets freed
186 */
187 return VersionedClass;
188}
189
190//
191// Ref: http://yvs-it.blogspot.com/2010/04/initcommoncontrolsex.html
192//
193BOOL
196 PCWSTR pszClass,
197 LPCWSTR lpLibFileName,
198 HANDLE Contex,
199 HMODULE * phLibModule)
200{
201 BOOL Ret = FALSE;
203 PREGISTERCLASSNAMEW pRegisterClassNameW;
204 UNICODE_STRING ClassName;
205 WCHAR ClassNameBuf[MAX_PATH] = {0};
206 RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame = { sizeof(Frame), 1 };
207
208 ERR("VersionRegisterClass: Attempting to call RegisterClassNameW in %S.\n", lpLibFileName);
209
211
213 {
214 hLibModule = LoadLibraryW(lpLibFileName);
215 if (hLibModule)
216 {
217 if ((pRegisterClassNameW = (void*)GetProcAddress(hLibModule, "RegisterClassNameW")))
218 {
219 if (IS_ATOM(pszClass))
220 {
221 RtlInitEmptyUnicodeString(&ClassName, ClassNameBuf, sizeof(ClassNameBuf));
222 if (!NtUserGetAtomName(LOWORD((DWORD_PTR)pszClass), &ClassName))
223 {
224 ERR("Error while verifying ATOM\n");
225 _SEH2_YIELD(goto Error_Exit);
226 }
227 pszClass = ClassName.Buffer;
228 }
229 Ret = pRegisterClassNameW(pszClass);
230 }
231 else
232 {
233 WARN("No RegisterClassNameW PROC\n");
234 }
235 }
236 }
238 {
239 ERR("Got exception while trying to call RegisterClassNameW!\n");
240 }
242
243Error_Exit:
244 if (Ret || !hLibModule)
245 {
246 if (phLibModule) *phLibModule = hLibModule;
247 }
248 else
249 {
250 DWORD dwLastError = GetLastError();
252 SetLastError(dwLastError);
253 }
254
256 return Ret;
257}
258
259/*
260 * @implemented
261 */
262BOOL
263WINAPI
266 LPCSTR lpszClass,
267 LPWNDCLASSEXA lpwcx)
268{
269 UNICODE_STRING ClassName = {0};
270 LPCSTR pszMenuName;
272 DWORD dwLastError;
273 BOOL Ret, ClassFound = FALSE, ConvertedString = FALSE;
274 LPCWSTR lpszClsVersion;
275 HANDLE pCtx = NULL;
276 LPCWSTR lpLibFileName = NULL;
277
278 TRACE("%p class/atom: %s/%04x %p\n", hInstance,
279 IS_ATOM(lpszClass) ? NULL : lpszClass,
280 IS_ATOM(lpszClass) ? lpszClass : 0,
281 lpwcx);
282
283 if (!lpwcx)
284 {
286 return FALSE;
287 }
288
290 {
291 hInstance = NULL;
292 }
293
294 if (lpszClass == NULL)
295 {
297 return FALSE;
298 }
299
300 lpszClsVersion = ClassNameToVersion(lpszClass, NULL, &lpLibFileName, &pCtx, TRUE);
301 if (lpszClsVersion)
302 {
303 RtlInitUnicodeString(&ClassName, lpszClsVersion);
304 }
305 else if (IS_ATOM(lpszClass))
306 {
307 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpszClass);
308 }
309 else
310 {
311 ConvertedString = TRUE;
312 if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, lpszClass))
313 {
315 return FALSE;
316 }
317 }
318
320 {
321 TRACE("RegisterSystemControls\n");
323 }
324
325 for(;;)
326 {
328 &ClassName,
329 (LPWNDCLASSEXW)lpwcx,
330 (LPWSTR *)&pszMenuName,
331 TRUE);
332 if (Ret) break;
333 if (!lpLibFileName) break;
334 if (!ClassFound)
335 {
336 dwLastError = GetLastError();
337 if ( dwLastError == ERROR_CANNOT_FIND_WND_CLASS ||
338 dwLastError == ERROR_CLASS_DOES_NOT_EXIST )
339 {
340 ClassFound = VersionRegisterClass(ClassName.Buffer, lpLibFileName, pCtx, &hLibModule);
341 if (ClassFound) continue;
342 }
343 }
344 if (hLibModule)
345 {
346 dwLastError = GetLastError();
348 SetLastError(dwLastError);
349 hLibModule = 0;
350 }
351 break;
352 }
353
354 if (Ret)
355 {
356 lpwcx->lpszClassName = lpszClass;
357// lpwcx->lpszMenuName = pszMenuName;
358 }
359
360 if (ConvertedString)
361 {
362 RtlFreeUnicodeString(&ClassName);
363 }
364
365 return Ret;
366}
367
368
369/*
370 * @implemented
371 */
372BOOL
373WINAPI
376 LPCWSTR lpszClass,
377 LPWNDCLASSEXW lpwcx)
378{
379 UNICODE_STRING ClassName = {0};
380 LPWSTR pszMenuName;
382 DWORD dwLastError;
383 BOOL Ret, ClassFound = FALSE;
384 LPCWSTR lpszClsVersion;
385 HANDLE pCtx = NULL;
386 LPCWSTR lpLibFileName = NULL;
387
388 TRACE("%p class/atom: %S/%04x %p\n", hInstance,
389 IS_ATOM(lpszClass) ? NULL : lpszClass,
390 IS_ATOM(lpszClass) ? lpszClass : 0,
391 lpwcx);
392
393 /* From wine, for speed only, ReactOS supports the correct return in
394 * Win32k. cbSize is ignored.
395 */
396 if (!lpwcx)
397 {
399 return FALSE;
400 }
401
403 {
404 hInstance = NULL;
405 }
406
407 if (lpszClass == NULL)
408 {
410 return FALSE;
411 }
412
413 lpszClsVersion = ClassNameToVersion(lpszClass, NULL, &lpLibFileName, &pCtx, FALSE);
414 if (lpszClsVersion)
415 {
416 RtlInitUnicodeString(&ClassName, lpszClsVersion);
417 }
418 else if (IS_ATOM(lpszClass))
419 {
420 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpszClass);
421 }
422 else
423 {
424 RtlInitUnicodeString(&ClassName, lpszClass);
425 }
426
428 {
429 TRACE("RegisterSystemControls\n");
431 }
432
433 for(;;)
434 {
436 &ClassName,
437 lpwcx,
438 &pszMenuName,
439 FALSE);
440 if (Ret) break;
441 if (!lpLibFileName) break;
442 if (!ClassFound)
443 {
444 dwLastError = GetLastError();
445 if ( dwLastError == ERROR_CANNOT_FIND_WND_CLASS ||
446 dwLastError == ERROR_CLASS_DOES_NOT_EXIST )
447 {
448 ClassFound = VersionRegisterClass(ClassName.Buffer, lpLibFileName, pCtx, &hLibModule);
449 if (ClassFound) continue;
450 }
451 }
452 if (hLibModule)
453 {
454 dwLastError = GetLastError();
456 SetLastError(dwLastError);
457 hLibModule = 0;
458 }
459 break;
460 }
461
462 if (Ret)
463 {
464 lpwcx->lpszClassName = lpszClass;
465// lpwcx->lpszMenuName = pszMenuName;
466 }
467 return Ret;
468}
469
470
471/*
472 * @implemented
473 */
474BOOL
475WINAPI
478 LPCSTR lpClassName,
479 LPWNDCLASSA lpWndClass)
480{
481 WNDCLASSEXA wcex;
482 BOOL retval;
483
484 retval = GetClassInfoExA(hInstance, lpClassName, &wcex);
485 if (retval)
486 {
487 lpWndClass->style = wcex.style;
488 lpWndClass->lpfnWndProc = wcex.lpfnWndProc;
489 lpWndClass->cbClsExtra = wcex.cbClsExtra;
490 lpWndClass->cbWndExtra = wcex.cbWndExtra;
491 lpWndClass->hInstance = wcex.hInstance;
492 lpWndClass->hIcon = wcex.hIcon;
493 lpWndClass->hCursor = wcex.hCursor;
494 lpWndClass->hbrBackground = wcex.hbrBackground;
495 lpWndClass->lpszMenuName = wcex.lpszMenuName;
496 lpWndClass->lpszClassName = wcex.lpszClassName;
497 }
498
499 return retval;
500}
501
502/*
503 * @implemented
504 */
505BOOL
506WINAPI
509 LPCWSTR lpClassName,
510 LPWNDCLASSW lpWndClass)
511{
512 WNDCLASSEXW wcex;
513 BOOL retval;
514
515 retval = GetClassInfoExW(hInstance, lpClassName, &wcex);
516 if (retval)
517 {
518 lpWndClass->style = wcex.style;
519 lpWndClass->lpfnWndProc = wcex.lpfnWndProc;
520 lpWndClass->cbClsExtra = wcex.cbClsExtra;
521 lpWndClass->cbWndExtra = wcex.cbWndExtra;
522 lpWndClass->hInstance = wcex.hInstance;
523 lpWndClass->hIcon = wcex.hIcon;
524 lpWndClass->hCursor = wcex.hCursor;
525 lpWndClass->hbrBackground = wcex.hbrBackground;
526 lpWndClass->lpszMenuName = wcex.lpszMenuName;
527 lpWndClass->lpszClassName = wcex.lpszClassName;
528 }
529 return retval;
530}
531
532//
533// Based on find_winproc... Fixes many whine tests......
534//
537{
538 INT i;
539 ULONG_PTR gcpd, Ret = 0;
540 // If server side, sweep through proc list and return the client side proc.
541 if (Class->CSF_flags & CSF_SERVERSIDEPROC)
542 { // Always scan through the list due to wine class "deftest".
543 for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
544 {
545 if (GETPFNSERVER(i) == Class->lpfnWndProc)
546 {
547 if (Ansi)
548 Ret = (ULONG_PTR)GETPFNCLIENTA(i);
549 else
550 Ret = (ULONG_PTR)GETPFNCLIENTW(i);
551 }
552 }
553 return Ret;
554 }
555 // Set return proc.
556 Ret = (ULONG_PTR)Class->lpfnWndProc;
557 // Return the proc if one of the FnId default class type.
558 if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
559 {
560 if (Ansi)
561 { // If match return the right proc by type.
562 if (GETPFNCLIENTW(Class->fnid) == Class->lpfnWndProc)
563 Ret = (ULONG_PTR)GETPFNCLIENTA(Class->fnid);
564 }
565 else
566 {
567 if (GETPFNCLIENTA(Class->fnid) == Class->lpfnWndProc)
568 Ret = (ULONG_PTR)GETPFNCLIENTW(Class->fnid);
569 }
570 }
571 // Return on change or Ansi/Unicode proc equal.
572 if ( Ret != (ULONG_PTR)Class->lpfnWndProc ||
573 Ansi == !!(Class->CSF_flags & CSF_ANSIPROC) )
574 return Ret;
575
576 /* We have an Ansi and Unicode swap! If Ansi create Unicode proc handle.
577 This will force CallWindowProc to deal with it. */
578 gcpd = NtUserGetCPD( UserHMGetHandle(pWnd),
580 Ret);
581
582 return (gcpd ? gcpd : Ret);
583}
584
585//
586// Based on IntGetClsWndProc
587//
590{
591 INT i;
592 WNDPROC gcpd, Ret = 0;
594
595 if (!Class) return Ret;
596
598 {
599 for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
600 {
601 if (GETPFNSERVER(i) == pWnd->lpfnWndProc)
602 {
603 if (Ansi)
604 Ret = GETPFNCLIENTA(i);
605 else
606 Ret = GETPFNCLIENTW(i);
607 }
608 }
609 return Ret;
610 }
611 // Wine Class tests:
612 /* Edit controls are special - they return a wndproc handle when
613 GetWindowLongPtr is called with a different A/W.
614 On the other hand there is no W->A->W conversion so this control
615 is treated specially.
616 */
617 if (Class->fnid == FNID_EDIT)
618 Ret = pWnd->lpfnWndProc;
619 else
620 {
621 // Set return proc.
622 Ret = pWnd->lpfnWndProc;
623
624 if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
625 {
626 if (Ansi)
627 {
628 if (GETPFNCLIENTW(Class->fnid) == pWnd->lpfnWndProc)
629 Ret = GETPFNCLIENTA(Class->fnid);
630 }
631 else
632 {
633 if (GETPFNCLIENTA(Class->fnid) == pWnd->lpfnWndProc)
634 Ret = GETPFNCLIENTW(Class->fnid);
635 }
636 }
637 // Return on the change.
638 if ( Ret != pWnd->lpfnWndProc)
639 return Ret;
640 }
641
642 if ( Ansi == !!(pWnd->state & WNDS_ANSIWINDOWPROC) )
643 return Ret;
644
645 gcpd = (WNDPROC)NtUserGetCPD( UserHMGetHandle(pWnd),
647 (ULONG_PTR)Ret);
648
649 return (gcpd ? gcpd : Ret);
650}
651
652static ULONG_PTR FASTCALL
654{
655 ULONG_PTR Ret = 0;
656
657 if (nIndex >= 0)
658 {
659 if (nIndex + sizeof(ULONG_PTR) < nIndex ||
660 nIndex + sizeof(ULONG_PTR) > Class->cbclsExtra)
661 {
663 }
664 else
665 Ret = *(PULONG_PTR)((ULONG_PTR)(Class + 1) + nIndex);
666 }
667 else
668 {
669 switch (nIndex)
670 {
671 case GCL_CBWNDEXTRA:
672 Ret = (ULONG_PTR)Class->cbwndExtra;
673 break;
674
675 case GCL_CBCLSEXTRA:
676 Ret = (ULONG_PTR)Class->cbclsExtra;
677 break;
678
680 Ret = (ULONG_PTR)Class->hbrBackground;
681 if (Ret != 0 && Ret < 0x4000)
682 Ret = (ULONG_PTR)GetSysColorBrush((ULONG)Ret - 1);
683 break;
684
685 case GCL_HMODULE:
686 //ERR("Cls 0x%x GCL_HMODULE 0x%x\n", Wnd->pcls, Class->hModule);
687 Ret = (ULONG_PTR)Class->hModule;
688 break;
689
690 case GCL_MENUNAME:
691 Ret = (ULONG_PTR)Class->lpszClientAnsiMenuName;
692 break;
693
694 case GCL_STYLE:
695 Ret = (ULONG_PTR)Class->style;
696 break;
697
698 case GCW_ATOM:
699 Ret = (ULONG_PTR)Class->atomNVClassName;
700 break;
701
702 case GCLP_HCURSOR:
703 Ret = Class->spcur ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spcur))->h : 0;
704 break;
705
706 case GCLP_HICON:
707 Ret = Class->spicn ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spicn))->h : 0;
708 break;
709
710 case GCLP_HICONSM:
711 Ret = Class->spicnSm ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spicnSm))->h : 0;
712 break;
713
714 case GCLP_WNDPROC:
715 Ret = IntGetClsWndProc(Wnd, Class, TRUE);
716 break;
717
718 default:
720 break;
721 }
722 }
723
724 return Ret;
725}
726
727static ULONG_PTR FASTCALL
728IntGetClassLongW (PWND Wnd, PCLS Class, int nIndex)
729{
730 ULONG_PTR Ret = 0;
731
732 if (nIndex >= 0)
733 {
734 if (nIndex + sizeof(ULONG_PTR) < nIndex ||
735 nIndex + sizeof(ULONG_PTR) > Class->cbclsExtra)
736 {
738 }
739 else
740 Ret = *(PULONG_PTR)((ULONG_PTR)(Class + 1) + nIndex);
741 }
742 else
743 {
744 switch (nIndex)
745 {
746 case GCL_CBWNDEXTRA:
747 Ret = (ULONG_PTR)Class->cbwndExtra;
748 break;
749
750 case GCL_CBCLSEXTRA:
751 Ret = (ULONG_PTR)Class->cbclsExtra;
752 break;
753
755 Ret = (ULONG_PTR)Class->hbrBackground;
756 if (Ret != 0 && Ret < 0x4000)
757 Ret = (ULONG_PTR)GetSysColorBrush((ULONG)Ret - 1);
758 break;
759
760 case GCL_HMODULE:
761 Ret = (ULONG_PTR)Class->hModule;
762 break;
763
764 case GCLP_MENUNAME:
765 Ret = (ULONG_PTR)Class->lpszClientUnicodeMenuName;
766 break;
767
768 case GCL_STYLE:
769 Ret = (ULONG_PTR)Class->style;
770 break;
771
772 case GCW_ATOM:
773 Ret = (ULONG_PTR)Class->atomNVClassName;
774 break;
775
776 case GCLP_HCURSOR:
777 Ret = Class->spcur ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spcur))->h : 0;
778 break;
779
780 case GCLP_HICON:
781 Ret = Class->spicn ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spicn))->h : 0;
782 break;
783
784 case GCLP_HICONSM:
785 Ret = Class->spicnSm ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spicnSm))->h : 0;
786 break;
787
788 case GCLP_WNDPROC:
789 Ret = IntGetClsWndProc(Wnd, Class, FALSE);
790 break;
791
792 default:
794 break;
795 }
796 }
797
798 return Ret;
799}
800
801/*
802 * @implemented
803 */
806{
807 PWND Wnd;
808 PCLS Class;
809 ULONG_PTR Ret = 0;
810
811 TRACE("%p %d\n", hWnd, nIndex);
812
813 Wnd = ValidateHwnd(hWnd);
814 if (!Wnd)
815 return 0;
816
818 {
820 if (Class != NULL)
821 {
822#ifdef _WIN64
823 switch (nIndex)
824 {
826 case GCLP_HCURSOR:
827 case GCLP_HICON:
828 case GCLP_HICONSM:
829 case GCLP_HMODULE:
830 case GCLP_MENUNAME:
831 case GCLP_WNDPROC:
833 break;
834
835 default:
836 Ret = IntGetClassLongA(Wnd, Class, nIndex);
837 break;
838 }
839#else
840 Ret = IntGetClassLongA(Wnd, Class, nIndex);
841#endif
842 }
843 else
844 {
845 WARN("Invalid class for hwnd 0x%p!\n", hWnd);
846 }
847 }
849 {
850 Ret = 0;
851 }
852 _SEH2_END;
853
854 return (DWORD)Ret;
855}
856
857/*
858 * @implemented
859 */
861GetClassLongW ( HWND hWnd, int nIndex )
862{
863 PWND Wnd;
864 PCLS Class;
865 ULONG_PTR Ret = 0;
866
867 TRACE("%p %d\n", hWnd, nIndex);
868
869 Wnd = ValidateHwnd(hWnd);
870 if (!Wnd)
871 return 0;
872
874 {
876 if (Class != NULL)
877 {
878#ifdef _WIN64
879 switch (nIndex)
880 {
882 case GCLP_HCURSOR:
883 case GCLP_HICON:
884 case GCLP_HICONSM:
885 case GCLP_HMODULE:
886 case GCLP_MENUNAME:
887 case GCLP_WNDPROC:
889 break;
890
891 default:
892 Ret = IntGetClassLongW(Wnd, Class, nIndex);
893 break;
894 }
895#else
896 Ret = IntGetClassLongW(Wnd, Class, nIndex);
897#endif
898 }
899 else
900 {
901 WARN("Invalid class for hwnd 0x%p!\n", hWnd);
902 }
903 }
905 {
906 Ret = 0;
907 }
908 _SEH2_END;
909
910 return (DWORD)Ret;
911}
912
913#ifdef _WIN64
914/*
915 * @implemented
916 */
918WINAPI
920 INT nIndex)
921{
922 PWND Wnd;
923 PCLS Class;
924 ULONG_PTR Ret = 0;
925
926 TRACE("%p %d\n", hWnd, nIndex);
927
928 Wnd = ValidateHwnd(hWnd);
929 if (!Wnd)
930 return 0;
931
933 {
935 if (Class != NULL)
936 {
937 Ret = IntGetClassLongA(Wnd, Class, nIndex);
938 }
939 else
940 {
941 WARN("Invalid class for hwnd 0x%p!\n", hWnd);
942 }
943 }
945 {
946 Ret = 0;
947 }
948 _SEH2_END;
949
950 return Ret;
951}
952
953/*
954 * @implemented
955 */
957WINAPI
959 INT nIndex)
960{
961 PWND Wnd;
962 PCLS Class;
963 ULONG_PTR Ret = 0;
964
965 TRACE("%p %d\n", hWnd, nIndex);
966
967 Wnd = ValidateHwnd(hWnd);
968 if (!Wnd)
969 return 0;
970
972 {
974 if (Class != NULL)
975 {
976 Ret = IntGetClassLongW(Wnd, Class, nIndex);
977 }
978 else
979 {
980 WARN("Invalid class for hwnd 0x%p!\n", hWnd);
981 }
982 }
984 {
985 Ret = 0;
986 }
987 _SEH2_END;
988
989 return Ret;
990}
991#endif
992
993
994/*
995 * @implemented
996 */
997int WINAPI
999 HWND hWnd,
1000 LPSTR lpClassName,
1001 int nMaxCount)
1002{
1003 WCHAR tmpbuf[MAX_ATOM_LEN + 1];
1004 int len;
1005
1006 if (nMaxCount <= 0) return 0;
1007 if (!GetClassNameW( hWnd, tmpbuf, sizeof(tmpbuf)/sizeof(WCHAR) )) return 0;
1008 RtlUnicodeToMultiByteN( lpClassName, nMaxCount - 1, (PULONG)&len, tmpbuf, strlenW(tmpbuf) * sizeof(WCHAR) );
1009 lpClassName[len] = 0;
1010
1011 TRACE("%p class/atom: %s/%04x %x\n", hWnd,
1012 IS_ATOM(lpClassName) ? NULL : lpClassName,
1013 IS_ATOM(lpClassName) ? lpClassName : 0,
1014 nMaxCount);
1015
1016 return len;
1017}
1018
1019
1020/*
1021 * @implemented
1022 */
1023int
1024WINAPI
1026 HWND hWnd,
1027 LPWSTR lpClassName,
1028 int nMaxCount)
1029{
1030 UNICODE_STRING ClassName;
1031 int Result;
1032
1033 RtlInitEmptyUnicodeString(&ClassName,
1034 lpClassName,
1035 nMaxCount * sizeof(WCHAR));
1036
1038 FALSE,
1039 &ClassName);
1040
1041 TRACE("%p class/atom: %S/%04x %x\n", hWnd,
1042 IS_ATOM(lpClassName) ? NULL : lpClassName,
1043 IS_ATOM(lpClassName) ? lpClassName : 0,
1044 nMaxCount);
1045
1046 return Result;
1047}
1048
1049
1050/*
1051 * @implemented
1052 */
1053WORD
1054WINAPI
1056 HWND hwnd,
1057 int offset)
1058{
1059 PWND Wnd;
1060 PCLS class;
1061 WORD retvalue = 0;
1062
1063 if (offset < 0) return GetClassLongA( hwnd, offset );
1064
1065 Wnd = ValidateHwnd(hwnd);
1066 if (!Wnd)
1067 return 0;
1068
1069 class = DesktopPtrToUser(Wnd->pcls);
1070 if (class == NULL) return 0;
1071
1072 if (offset <= class->cbclsExtra - sizeof(WORD))
1073 memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(retvalue) );
1074 else
1076
1077 return retvalue;
1078}
1079
1080
1082{
1083 LONG_PTR retvalue = 0;
1084 WND *wndPtr;
1085
1086 if (offset == GWLP_HWNDPARENT)
1087 {
1090 return (ULONG_PTR)parent;
1091 }
1092
1093 if (!(wndPtr = ValidateHwnd( hwnd )))
1094 {
1096 return 0;
1097 }
1098
1099 if (offset >= 0 && wndPtr->fnid != FNID_DESKTOP)
1100 {
1101 if (offset > (int)(wndPtr->cbwndExtra - size))
1102 {
1103 WARN("Invalid offset %d\n", offset );
1105 return 0;
1106 }
1107 retvalue = *((LONG_PTR *)((PCHAR)(wndPtr + 1) + offset));
1108
1109 /* WINE: special case for dialog window procedure */
1110 //if ((offset == DWLP_DLGPROC) && (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
1111 // retvalue = (LONG_PTR)IntGetWndProc( (WNDPROC)retvalue, unicode );
1112 return retvalue;
1113 }
1114
1115 switch(offset)
1116 {
1117 case GWLP_USERDATA: retvalue = wndPtr->dwUserData; break;
1118 case GWL_STYLE: retvalue = wndPtr->style; break;
1119 case GWL_EXSTYLE: retvalue = wndPtr->ExStyle; break;
1120 case GWLP_ID: retvalue = wndPtr->IDMenu; break;
1121 case GWLP_HINSTANCE: retvalue = (ULONG_PTR)wndPtr->hModule; break;
1122#if 0
1123 /* -1 is an undocumented case which returns WW* */
1124 /* source: http://www.geoffchappell.com/studies/windows/win32/user32/structs/wnd/index.htm*/
1125 case -1: retvalue = (ULONG_PTR)&wndPtr->ww; break;
1126#else
1127 /* We don't have a WW but WND already contains the same fields in the right order, */
1128 /* so we can return a pointer to its first field */
1129 case -1: retvalue = (ULONG_PTR)&wndPtr->state; break;
1130#endif
1131 case GWLP_WNDPROC:
1132 {
1133 if (!TestWindowProcess(wndPtr))
1134 {
1136 retvalue = 0;
1137 ERR("Outside Access and Denied!\n");
1138 break;
1139 }
1140 retvalue = (ULONG_PTR)IntGetWndProc(wndPtr, !unicode);
1141 break;
1142 }
1143 default:
1144 WARN("Unknown offset %d\n", offset );
1146 break;
1147 }
1148 return retvalue;
1149
1150}
1151/*
1152 * @implemented
1153 */
1154LONG
1155WINAPI
1156GetWindowLongA ( HWND hWnd, int nIndex )
1157{
1158 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), FALSE );
1159}
1160
1161/*
1162 * @implemented
1163 */
1164LONG
1165WINAPI
1167{
1168 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), TRUE );
1169}
1170
1171#ifdef _WIN64
1172/*
1173 * @implemented
1174 */
1176WINAPI
1178 INT nIndex)
1179{
1180 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG_PTR), FALSE );
1181}
1182
1183/*
1184 * @implemented
1185 */
1187WINAPI
1189 INT nIndex)
1190{
1191 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG_PTR), TRUE );
1192
1193}
1194#endif // _WIN64
1195
1196/*
1197 * @implemented
1198 */
1199WORD
1200WINAPI
1202{
1203 switch(nIndex)
1204 {
1205 case GWLP_ID:
1206 case GWLP_HINSTANCE:
1207 case GWLP_HWNDPARENT:
1208 break;
1209 default:
1210 if (nIndex < 0)
1211 {
1212 WARN("Invalid offset %d\n", nIndex );
1214 return 0;
1215 }
1216 break;
1217 }
1218 return IntGetWindowLong( hWnd, nIndex, sizeof(WORD), FALSE );
1219}
1220
1221/*
1222 * @implemented
1223 */
1224UINT
1225WINAPI
1227 HWND hwnd,
1228 LPWSTR pszType,
1229 UINT cchType)
1230{
1231 UNICODE_STRING ClassName;
1232
1233 RtlInitEmptyUnicodeString(&ClassName,
1234 pszType,
1235 cchType * sizeof(WCHAR));
1236
1237 return NtUserGetClassName(hwnd,TRUE,&ClassName);
1238}
1239
1240
1241/*
1242 * @implemented
1243 */
1244UINT
1245WINAPI
1247 HWND hwnd,
1248 LPSTR pszType,
1249 UINT cchType)
1250{
1251 WCHAR tmpbuf[MAX_ATOM_LEN + 1];
1252 UINT len;
1253
1254 if ((INT)cchType <= 0) return 0;
1255 if (!RealGetWindowClassW( hwnd, tmpbuf, sizeof(tmpbuf)/sizeof(WCHAR) )) return 0;
1256 RtlUnicodeToMultiByteN( pszType, cchType - 1, (PULONG)&len, tmpbuf, strlenW(tmpbuf) * sizeof(WCHAR) );
1257 pszType[len] = 0;
1258 return len;
1259}
1260
1261/*
1262 * Create a small icon based on a standard icon
1263 */
1264#if 0 // Keep vintage code from revision 18764 by GvG!
1265static HICON
1266CreateSmallIcon(HICON StdIcon)
1267{
1269 ICONINFO StdInfo;
1270 int SmallIconWidth;
1271 int SmallIconHeight;
1272 BITMAP StdBitmapInfo;
1273 HDC hSourceDc = NULL;
1274 HDC hDestDc = NULL;
1275 ICONINFO SmallInfo;
1276 HBITMAP OldSourceBitmap = NULL;
1277 HBITMAP OldDestBitmap = NULL;
1278
1279 SmallInfo.hbmColor = NULL;
1280 SmallInfo.hbmMask = NULL;
1281
1282 /* We need something to work with... */
1283 if (NULL == StdIcon)
1284 {
1285 goto cleanup;
1286 }
1287
1288 SmallIconWidth = GetSystemMetrics(SM_CXSMICON);
1289 SmallIconHeight = GetSystemMetrics(SM_CYSMICON);
1290 if (! GetIconInfo(StdIcon, &StdInfo))
1291 {
1292 ERR("Failed to get icon info for icon 0x%x\n", StdIcon);
1293 goto cleanup;
1294 }
1295 if (! GetObjectW(StdInfo.hbmMask, sizeof(BITMAP), &StdBitmapInfo))
1296 {
1297 ERR("Failed to get bitmap info for icon 0x%x bitmap 0x%x\n",
1298 StdIcon, StdInfo.hbmColor);
1299 goto cleanup;
1300 }
1301 if (StdBitmapInfo.bmWidth == SmallIconWidth &&
1302 StdBitmapInfo.bmHeight == SmallIconHeight)
1303 {
1304 /* Icon already has the correct dimensions */
1305 return StdIcon;
1306 }
1307
1308 hSourceDc = CreateCompatibleDC(NULL);
1309 if (NULL == hSourceDc)
1310 {
1311 ERR("Failed to create source DC\n");
1312 goto cleanup;
1313 }
1314 hDestDc = CreateCompatibleDC(NULL);
1315 if (NULL == hDestDc)
1316 {
1317 ERR("Failed to create dest DC\n");
1318 goto cleanup;
1319 }
1320
1321 OldSourceBitmap = SelectObject(hSourceDc, StdInfo.hbmColor);
1322 if (NULL == OldSourceBitmap)
1323 {
1324 ERR("Failed to select source color bitmap\n");
1325 goto cleanup;
1326 }
1327 SmallInfo.hbmColor = CreateCompatibleBitmap(hSourceDc, SmallIconWidth,
1328 SmallIconHeight);
1329 if (NULL == SmallInfo.hbmColor)
1330 {
1331 ERR("Failed to create color bitmap\n");
1332 goto cleanup;
1333 }
1334 OldDestBitmap = SelectObject(hDestDc, SmallInfo.hbmColor);
1335 if (NULL == OldDestBitmap)
1336 {
1337 ERR("Failed to select dest color bitmap\n");
1338 goto cleanup;
1339 }
1340 if (! StretchBlt(hDestDc, 0, 0, SmallIconWidth, SmallIconHeight,
1341 hSourceDc, 0, 0, StdBitmapInfo.bmWidth,
1342 StdBitmapInfo.bmHeight, SRCCOPY))
1343 {
1344 ERR("Failed to stretch color bitmap\n");
1345 goto cleanup;
1346 }
1347
1348 if (NULL == SelectObject(hSourceDc, StdInfo.hbmMask))
1349 {
1350 ERR("Failed to select source mask bitmap\n");
1351 goto cleanup;
1352 }
1353 SmallInfo.hbmMask = CreateCompatibleBitmap(hSourceDc, SmallIconWidth, SmallIconHeight);
1354 if (NULL == SmallInfo.hbmMask)
1355 {
1356 ERR("Failed to create mask bitmap\n");
1357 goto cleanup;
1358 }
1359 if (NULL == SelectObject(hDestDc, SmallInfo.hbmMask))
1360 {
1361 ERR("Failed to select dest mask bitmap\n");
1362 goto cleanup;
1363 }
1364 if (! StretchBlt(hDestDc, 0, 0, SmallIconWidth, SmallIconHeight,
1365 hSourceDc, 0, 0, StdBitmapInfo.bmWidth,
1366 StdBitmapInfo.bmHeight, SRCCOPY))
1367 {
1368 ERR("Failed to stretch mask bitmap\n");
1369 goto cleanup;
1370 }
1371
1372 SmallInfo.fIcon = TRUE;
1373 SmallInfo.xHotspot = SmallIconWidth / 2;
1374 SmallInfo.yHotspot = SmallIconHeight / 2;
1375 SmallIcon = CreateIconIndirect(&SmallInfo);
1376 if (NULL == SmallIcon)
1377 {
1378 ERR("Failed to create icon\n");
1379 goto cleanup;
1380 }
1381
1382cleanup:
1383 if (NULL != SmallInfo.hbmMask)
1384 {
1385 DeleteObject(SmallInfo.hbmMask);
1386 }
1387 if (NULL != OldDestBitmap)
1388 {
1389 SelectObject(hDestDc, OldDestBitmap);
1390 }
1391 if (NULL != SmallInfo.hbmColor)
1392 {
1393 DeleteObject(SmallInfo.hbmColor);
1394 }
1395 if (NULL != hDestDc)
1396 {
1397 DeleteDC(hDestDc);
1398 }
1399 if (NULL != OldSourceBitmap)
1400 {
1401 SelectObject(hSourceDc, OldSourceBitmap);
1402 }
1403 if (NULL != hSourceDc)
1404 {
1405 DeleteDC(hSourceDc);
1406 }
1407
1408 return SmallIcon;
1409}
1410#endif
1411
1414 LPDWORD pdwWowData,
1415 WORD fnID,
1416 DWORD dwFlags,
1417 BOOL ChkRegCls)
1418{
1419 ATOM Atom;
1421 UNICODE_STRING ClassName;
1422 UNICODE_STRING ClassVersion;
1423 UNICODE_STRING MenuName = {0};
1424 CLSMENUNAME clsMenuName;
1425 ANSI_STRING AnsiMenuName;
1426 LPCWSTR lpszClsVersion;
1427
1428 if (lpwcx == NULL || lpwcx->cbSize != sizeof(WNDCLASSEXW) ||
1429 lpwcx->cbClsExtra < 0 || lpwcx->cbWndExtra < 0 ||
1430 lpwcx->lpszClassName == NULL)
1431 {
1432 TRACE("RegisterClassExWOWW Invalid Parameter Error!\n");
1434 return 0;
1435 }
1436
1437 if (ChkRegCls)
1438 {
1440 }
1441 /*
1442 * On real Windows this looks more like:
1443 * if (lpwcx->hInstance == User32Instance &&
1444 * *(PULONG)((ULONG_PTR)NtCurrentTeb() + 0x6D4) & 0x400)
1445 * But since I have no idea what the magic field in the
1446 * TEB structure means, I rather decided to omit that.
1447 * -- Filip Navara
1448
1449 GetWin32ClientInfo()->dwExpWinVer & (WINVER == 0x400)
1450 */
1451 if (lpwcx->hInstance == User32Instance)
1452 {
1453 TRACE("RegisterClassExWOWW User32Instance!\n");
1455 return 0;
1456 }
1457 /* Yes, this is correct. We should modify the passed structure. */
1458 if (lpwcx->hInstance == NULL)
1459 ((WNDCLASSEXW*)lpwcx)->hInstance = GetModuleHandleW(NULL);
1460
1461 RtlCopyMemory(&WndClass, lpwcx, sizeof(WNDCLASSEXW));
1462/*
1463 if (NULL == WndClass.hIconSm)
1464 {
1465 WndClass.hIconSm = CreateSmallIcon(WndClass.hIcon);
1466 }
1467*/
1468 RtlInitEmptyAnsiString(&AnsiMenuName, NULL, 0);
1469 if (WndClass.lpszMenuName != NULL)
1470 {
1471 if (!IS_INTRESOURCE(WndClass.lpszMenuName))
1472 {
1473 if (WndClass.lpszMenuName[0])
1474 {
1475 RtlInitUnicodeString(&MenuName, WndClass.lpszMenuName);
1476 RtlUnicodeStringToAnsiString( &AnsiMenuName, &MenuName, TRUE);
1477 }
1478 }
1479 else
1480 {
1481 MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
1482 AnsiMenuName.Buffer = (PCHAR)WndClass.lpszMenuName;
1483 }
1484 }
1485
1486 if (IS_ATOM(WndClass.lpszClassName))
1487 {
1488 ClassName.Length =
1489 ClassName.MaximumLength = 0;
1490 ClassName.Buffer = (LPWSTR)WndClass.lpszClassName;
1491 }
1492 else
1493 {
1494 RtlInitUnicodeString(&ClassName, WndClass.lpszClassName);
1495 }
1496
1497 ClassVersion = ClassName;
1498 if (fnID == 0)
1499 {
1500 lpszClsVersion = ClassNameToVersion(lpwcx->lpszClassName, NULL, NULL, NULL, FALSE);
1501 if (lpszClsVersion)
1502 {
1503 RtlInitUnicodeString(&ClassVersion, lpszClsVersion);
1504 }
1505 }
1506
1507 clsMenuName.pszClientAnsiMenuName = AnsiMenuName.Buffer;
1508 clsMenuName.pwszClientUnicodeMenuName = MenuName.Buffer;
1509 clsMenuName.pusMenuName = &MenuName;
1510
1512 &ClassName,
1513 &ClassVersion,
1514 &clsMenuName,
1515 fnID,
1516 dwFlags,
1517 pdwWowData);
1518
1519 TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
1520 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1521 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
1522
1523 return Atom;
1524}
1525
1526/*
1527 * @implemented
1528 */
1531{
1532 RTL_ATOM Atom;
1535 WCHAR cname[MAX_BUFFER_LEN];
1536
1537 RtlCopyMemory(&WndClass, lpwcx, sizeof(WNDCLASSEXA));
1538
1539 if (WndClass.lpszMenuName != NULL)
1540 {
1541 if (!IS_INTRESOURCE(WndClass.lpszMenuName))
1542 {
1543 if (WndClass.lpszMenuName[0])
1544 {
1545 if (!MultiByteToWideChar( CP_ACP, 0, lpwcx->lpszMenuName, -1, mname, MAX_ATOM_LEN + 1 )) return 0;
1546
1547 WndClass.lpszMenuName = mname;
1548 }
1549 }
1550 }
1551
1552 if (!IS_ATOM(WndClass.lpszClassName))
1553 {
1554 if (!MultiByteToWideChar( CP_ACP, 0, lpwcx->lpszClassName, -1, cname, MAX_ATOM_LEN + 1 )) return 0;
1555
1556 WndClass.lpszClassName = cname;
1557 }
1558
1560 0,
1561 0,
1563 TRUE);
1564
1565 TRACE("A atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
1566 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1567 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
1568
1569 return (ATOM)Atom;
1570}
1571
1572/*
1573 * @implemented
1574 */
1577{
1578 ATOM Atom;
1579
1580 Atom = RegisterClassExWOWW( (WNDCLASSEXW *)lpwcx, 0, 0, 0, TRUE);
1581
1582 TRACE("W atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d\n",
1583 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1584 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra);
1585
1586 return Atom;
1587}
1588
1589/*
1590 * @implemented
1591 */
1594{
1596
1597 if (lpWndClass == NULL)
1598 return 0;
1599
1600 /* These MUST be copied manually, since on 64 bit architectures the
1601 alignment of the members is different between the 2 structs! */
1602 Class.style = lpWndClass->style;
1603 Class.lpfnWndProc = lpWndClass->lpfnWndProc;
1604 Class.cbClsExtra = lpWndClass->cbClsExtra;
1605 Class.cbWndExtra = lpWndClass->cbWndExtra;
1606 Class.hInstance = lpWndClass->hInstance;
1607 Class.hIcon = lpWndClass->hIcon;
1608 Class.hCursor = lpWndClass->hCursor;
1609 Class.hbrBackground = lpWndClass->hbrBackground;
1610 Class.lpszMenuName = lpWndClass->lpszMenuName;
1611 Class.lpszClassName = lpWndClass->lpszClassName;
1612
1613 Class.cbSize = sizeof(WNDCLASSEXA);
1614 Class.hIconSm = NULL;
1615
1616 return RegisterClassExA(&Class);
1617}
1618
1619/*
1620 * @implemented
1621 */
1624{
1626
1627 if (lpWndClass == NULL)
1628 return 0;
1629
1630 /* These MUST be copied manually, since on 64 bit architectures the
1631 alignment of the members is different between the 2 structs! */
1632 Class.style = lpWndClass->style;
1633 Class.lpfnWndProc = lpWndClass->lpfnWndProc;
1634 Class.cbClsExtra = lpWndClass->cbClsExtra;
1635 Class.cbWndExtra = lpWndClass->cbWndExtra;
1636 Class.hInstance = lpWndClass->hInstance;
1637 Class.hIcon = lpWndClass->hIcon;
1638 Class.hCursor = lpWndClass->hCursor;
1639 Class.hbrBackground = lpWndClass->hbrBackground;
1640 Class.lpszMenuName = lpWndClass->lpszMenuName;
1641 Class.lpszClassName = lpWndClass->lpszClassName;
1642
1643 Class.cbSize = sizeof(WNDCLASSEXW);
1644 Class.hIconSm = NULL;
1645
1646 return RegisterClassExW(&Class);
1647}
1648
1649/*
1650 * @implemented
1651 */
1652DWORD
1653WINAPI
1655 int nIndex,
1656 LONG dwNewLong)
1657{
1658 PSTR lpStr = (PSTR)(ULONG_PTR)dwNewLong;
1659 UNICODE_STRING Value = {0};
1661 DWORD Ret;
1662
1663 /* FIXME - portability!!!! */
1664
1665 if (nIndex == GCL_MENUNAME && lpStr != NULL)
1666 {
1667 if (!IS_INTRESOURCE(lpStr))
1668 {
1670 lpStr))
1671 {
1673 return 0;
1674 }
1675
1676 Allocated = TRUE;
1677 }
1678 else
1679 Value.Buffer = (PWSTR)lpStr;
1680
1681 dwNewLong = (LONG_PTR)&Value;
1682 }
1683 else if (nIndex == GCW_ATOM && lpStr != NULL)
1684 {
1685 if (!IS_ATOM(lpStr))
1686 {
1688 lpStr))
1689 {
1691 return 0;
1692 }
1693
1694 Allocated = TRUE;
1695 }
1696 else
1697 Value.Buffer = (PWSTR)lpStr;
1698
1699 dwNewLong = (LONG_PTR)&Value;
1700 }
1701
1703 nIndex,
1704 dwNewLong,
1705 TRUE);
1706
1707 if (Allocated)
1708 {
1710 }
1711
1712 return Ret;
1713}
1714
1715
1716/*
1717 * @implemented
1718 */
1719DWORD
1720WINAPI
1722 int nIndex,
1723 LONG dwNewLong)
1724{
1725 PWSTR lpStr = (PWSTR)(ULONG_PTR)dwNewLong;
1726 UNICODE_STRING Value = {0};
1727
1728 TRACE("%p %d %lx\n", hWnd, nIndex, dwNewLong);
1729
1730 /* FIXME - portability!!!! */
1731
1732 if (nIndex == GCL_MENUNAME && lpStr != NULL)
1733 {
1734 if (!IS_INTRESOURCE(lpStr))
1735 {
1737 lpStr);
1738 }
1739 else
1740 Value.Buffer = lpStr;
1741
1742 dwNewLong = (LONG_PTR)&Value;
1743 }
1744 else if (nIndex == GCW_ATOM && lpStr != NULL)
1745 {
1746 if (!IS_ATOM(lpStr))
1747 {
1749 lpStr);
1750 }
1751 else
1752 Value.Buffer = lpStr;
1753
1754 dwNewLong = (LONG_PTR)&Value;
1755 }
1756
1758 nIndex,
1759 dwNewLong,
1760 FALSE);
1761}
1762
1763#ifdef _WIN64
1764/*
1765 * @unimplemented
1766 */
1768WINAPI
1770 INT nIndex,
1771 LONG_PTR dwNewLong)
1772{
1774 return 0;
1775}
1776
1777/*
1778 * @unimplemented
1779 */
1781WINAPI
1783 INT nIndex,
1784 LONG_PTR dwNewLong)
1785{
1787 return 0;
1788}
1789#endif // _WIN64
1790
1791/*
1792 * @implemented
1793 */
1794WORD
1795WINAPI
1797 HWND hWnd,
1798 int nIndex,
1799 WORD wNewWord)
1800/*
1801 * NOTE: Obsoleted in 32-bit windows
1802 */
1803{
1804 if ((nIndex < 0) && (nIndex != GCW_ATOM))
1805 return 0;
1806
1807 return (WORD) SetClassLongW ( hWnd, nIndex, wNewWord );
1808}
1809
1810/*
1811 * @implemented
1812 */
1813WORD
1814WINAPI
1815SetWindowWord ( HWND hWnd,int nIndex,WORD wNewWord )
1816{
1817 switch(nIndex)
1818 {
1819 case GWLP_ID:
1820 case GWLP_HINSTANCE:
1821 case GWLP_HWNDPARENT:
1822 break;
1823 default:
1824 if (nIndex < 0)
1825 {
1826 WARN("Invalid offset %d\n", nIndex );
1828 return 0;
1829 }
1830 break;
1831 }
1832 return (WORD)NtUserSetWindowLongPtr(hWnd, nIndex, wNewWord, FALSE);
1833}
1834
1835/*
1836 * @implemented
1837 */
1838LONG
1839WINAPI
1842 HWND hWnd,
1843 int nIndex,
1844 LONG dwNewLong)
1845{
1846 return (LONG)NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, TRUE);
1847}
1848
1849/*
1850 * @implemented
1851 */
1852LONG
1853WINAPI
1855 HWND hWnd,
1856 int nIndex,
1857 LONG dwNewLong)
1858{
1859 return (LONG)NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, FALSE);
1860}
1861
1862#ifdef _WIN64
1863/*
1864 * @implemented
1865 */
1867WINAPI
1869 INT nIndex,
1870 LONG_PTR dwNewLong)
1871{
1872 return NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, TRUE);
1873}
1874
1875/*
1876 * @implemented
1877 */
1879WINAPI
1881 INT nIndex,
1882 LONG_PTR dwNewLong)
1883{
1884 return NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, FALSE);
1885}
1886#endif
1887
1888/*
1889 * @implemented
1890 */
1891BOOL
1892WINAPI
1894 LPCSTR lpClassName,
1896{
1897 UNICODE_STRING ClassName = {0};
1898 BOOL Ret;
1899 LPCWSTR lpszClsVersion;
1900 BOOL ConvertedString = FALSE;
1901
1902 TRACE("class/atom: %s/%04x %p\n",
1903 IS_ATOM(lpClassName) ? NULL : lpClassName,
1904 IS_ATOM(lpClassName) ? lpClassName : 0,
1905 hInstance);
1906
1907 lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, TRUE);
1908 if (lpszClsVersion)
1909 {
1910 RtlInitUnicodeString(&ClassName, lpszClsVersion);
1911 }
1912 else if (!IS_ATOM(lpClassName))
1913 {
1914 ConvertedString = TRUE;
1915 if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, lpClassName))
1916 {
1918 return 0;
1919 }
1920 }
1921 else
1922 {
1923 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1924 }
1925
1926 Ret = NtUserUnregisterClass(&ClassName, hInstance, 0);
1927
1928 if (ConvertedString)
1929 RtlFreeUnicodeString(&ClassName);
1930
1931 return Ret;
1932}
1933
1934
1935/*
1936 * @implemented
1937 */
1938BOOL
1939WINAPI
1941 LPCWSTR lpClassName,
1943{
1944 UNICODE_STRING ClassName = {0};
1945 LPCWSTR lpszClsVersion;
1946
1947 TRACE("class/atom: %S/%04x %p\n",
1948 IS_ATOM(lpClassName) ? NULL : lpClassName,
1949 IS_ATOM(lpClassName) ? lpClassName : 0,
1950 hInstance);
1951
1952 lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, FALSE);
1953 if (lpszClsVersion)
1954 {
1955 RtlInitUnicodeString(&ClassName, lpszClsVersion);
1956 }
1957 else if (!IS_ATOM(lpClassName))
1958 {
1959 RtlInitUnicodeString(&ClassName, lpClassName);
1960 }
1961 else
1962 {
1963 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1964 }
1965
1966 return NtUserUnregisterClass(&ClassName, hInstance, 0);
1967}
1968
1969/* EOF */
#define DECLSPEC_HOTPATCH
Definition: _mingw.h:243
HWND hWnd
Definition: settings.c:17
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
LONG NTSTATUS
Definition: precomp.h:26
const char * mname
Definition: cmds.c:37
#define UNIMPLEMENTED
Definition: debug.h:115
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
WCHAR WndClass[]
Definition: capicon.c:23
HINSTANCE hInstance
Definition: charmap.c:19
_Out_ RTL_ATOM * Atom
Definition: class.h:54
#define IS_ATOM(x)
Definition: class.h:3
#define MAX_ATOM_LEN
Definition: dde_private.h:30
#define MAX_BUFFER_LEN
Definition: dde_private.h:34
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
WORD ATOM
Definition: dimm.idl:113
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define CP_ACP
Definition: compat.h:109
#define SetLastError(x)
Definition: compat.h:752
#define GetProcAddress(x, y)
Definition: compat.h:753
#define FreeLibrary(x)
Definition: compat.h:748
#define MAX_PATH
Definition: compat.h:34
#define MultiByteToWideChar
Definition: compat.h:110
#define LoadLibraryW(x)
Definition: compat.h:747
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
#define ValidateHwnd(hwnd)
Definition: precomp.h:85
static PVOID FASTCALL DesktopPtrToUser(PVOID ptr)
Definition: utils.c:324
static void cleanup(void)
Definition: main.c:1335
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
@ AnsiString
Definition: dnslib.h:19
r parent
Definition: btrfs.c:3010
#define ULONG_PTR
Definition: config.h:101
IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN Allocated
Definition: fatprocs.h:310
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
pKey DeleteObject()
Status
Definition: gdiplustypes.h:25
GLsizeiptr size
Definition: glext.h:5919
GLuint res
Definition: glext.h:9613
GLenum GLsizei len
Definition: glext.h:6722
GLintptr offset
Definition: glext.h:5920
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define FNID_SWITCH
Definition: ntuser.h:860
#define GETPFNCLIENTW(fnid)
Definition: ntuser.h:901
#define GETPFNCLIENTA(fnid)
Definition: ntuser.h:899
#define CSF_ANSIPROC
Definition: ntuser.h:552
#define FNID_DESKTOP
Definition: ntuser.h:857
#define FNID_FIRST
Definition: ntuser.h:853
#define WNDS_SERVERSIDEWINDOWPROC
Definition: ntuser.h:618
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define FNID_BUTTON
Definition: ntuser.h:861
@ UserGetCPDWndtoCls
Definition: ntuser.h:540
@ UserGetCPDU2A
Definition: ntuser.h:536
@ UserGetCPDWindow
Definition: ntuser.h:538
@ UserGetCPDA2U
Definition: ntuser.h:535
#define NtUserSetWindowLongPtr
Definition: ntuser.h:3400
#define GETPFNSERVER(fnid)
Definition: ntuser.h:904
#define FNID_EDIT
Definition: ntuser.h:865
ULONG_PTR NTAPI NtUserGetCPD(HWND hWnd, GETCPD Flags, ULONG_PTR Proc)
Definition: callproc.c:176
#define CSF_SERVERSIDEPROC
Definition: ntuser.h:551
#define FNID_GHOST
Definition: ntuser.h:870
#define WNDS_ANSIWINDOWPROC
Definition: ntuser.h:619
NTSYSAPI NTSTATUS WINAPI RtlFindActivationContextSectionString(ULONG, const GUID *, ULONG, const UNICODE_STRING *, PVOID)
Definition: actctx.c:5815
NTSYSAPI void WINAPI RtlReleaseActivationContext(HANDLE)
Definition: actctx.c:5344
if(dx< 0)
Definition: linetemp.h:194
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
static HICON
Definition: imagelist.c:84
unsigned short RTL_ATOM
Definition: atom.c:42
#define min(a, b)
Definition: monoChain.cc:55
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
unsigned int UINT
Definition: ndis.h:50
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
_Use_decl_annotations_ NTSTATUS NTAPI RtlUnicodeToMultiByteN(_Out_ PCHAR MbString, _In_ ULONG MbSize, _Out_opt_ PULONG ResultSize, _In_ PCWCH UnicodeString, _In_ ULONG UnicodeSize)
Definition: nlsboot.c:107
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define FASTCALL
Definition: nt_native.h:50
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define DWORD
Definition: nt_native.h:44
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
#define L(x)
Definition: ntvdm.h:50
#define LOWORD(l)
Definition: pedump.c:82
#define CONST
Definition: pedump.c:81
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
#define strcmpiW(s1, s2)
Definition: unicode.h:39
#define strlenW(s)
Definition: unicode.h:28
DWORD RegisterDefaultClasses
Definition: regcontrol.c:13
BOOL WINAPI RegisterSystemControls(VOID)
Definition: regcontrol.c:70
PRTL_ACTIVATION_CONTEXT_STACK_FRAME FASTCALL RtlActivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame, IN PVOID Context)
Definition: actctx.c:5934
PRTL_ACTIVATION_CONTEXT_STACK_FRAME FASTCALL RtlDeactivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame)
Definition: actctx.c:6011
HINSTANCE hLibModule
Definition: sfc.c:23
#define TRACE(s)
Definition: solgame.cpp:4
convenient loading of small (16x16) icon resources
Definition: globals.h:321
Definition: bl.h:1331
PUNICODE_STRING pusMenuName
Definition: ntuser.h:495
LPSTR pszClientAnsiMenuName
Definition: ntuser.h:493
LPWSTR pwszClientUnicodeMenuName
Definition: ntuser.h:494
Definition: ntuser.h:561
DWORD yHotspot
Definition: winuser.h:3115
BOOL fIcon
Definition: winuser.h:3113
DWORD xHotspot
Definition: winuser.h:3114
HBITMAP hbmColor
Definition: winuser.h:3117
HBITMAP hbmMask
Definition: winuser.h:3116
USHORT MaximumLength
Definition: env_spec_w32.h:370
HBRUSH hbrBackground
Definition: winuser.h:3160
HICON hIcon
Definition: winuser.h:3158
HINSTANCE hInstance
Definition: winuser.h:3157
HCURSOR hCursor
Definition: winuser.h:3159
int cbWndExtra
Definition: winuser.h:3156
UINT style
Definition: winuser.h:3153
LPCSTR lpszMenuName
Definition: winuser.h:3161
LPCSTR lpszClassName
Definition: winuser.h:3162
WNDPROC lpfnWndProc
Definition: winuser.h:3154
int cbClsExtra
Definition: winuser.h:3155
int cbClsExtra
Definition: winuser.h:3194
HINSTANCE hInstance
Definition: winuser.h:3196
HCURSOR hCursor
Definition: winuser.h:3198
LPCSTR lpszMenuName
Definition: winuser.h:3200
UINT style
Definition: winuser.h:3192
int cbWndExtra
Definition: winuser.h:3195
WNDPROC lpfnWndProc
Definition: winuser.h:3193
LPCSTR lpszClassName
Definition: winuser.h:3201
HICON hIcon
Definition: winuser.h:3197
HBRUSH hbrBackground
Definition: winuser.h:3199
LPCWSTR lpszClassName
Definition: winuser.h:3216
LPCWSTR lpszMenuName
Definition: winuser.h:3215
HBRUSH hbrBackground
Definition: winuser.h:3214
WNDPROC lpfnWndProc
Definition: winuser.h:3208
UINT cbSize
Definition: winuser.h:3206
int cbWndExtra
Definition: winuser.h:3210
HCURSOR hCursor
Definition: winuser.h:3213
HINSTANCE hInstance
Definition: winuser.h:3211
UINT style
Definition: winuser.h:3207
int cbClsExtra
Definition: winuser.h:3209
HICON hIcon
Definition: winuser.h:3212
LPCWSTR lpszClassName
Definition: winuser.h:3175
LPCWSTR lpszMenuName
Definition: winuser.h:3174
HBRUSH hbrBackground
Definition: winuser.h:3173
HICON hIcon
Definition: winuser.h:3171
HINSTANCE hInstance
Definition: winuser.h:3170
int cbClsExtra
Definition: winuser.h:3168
UINT style
Definition: winuser.h:3166
WNDPROC lpfnWndProc
Definition: winuser.h:3167
int cbWndExtra
Definition: winuser.h:3169
HCURSOR hCursor
Definition: winuser.h:3172
Definition: ntuser.h:689
DWORD ExStyle
Definition: ntuser.h:699
PCLS pcls
Definition: ntuser.h:715
DWORD style
Definition: ntuser.h:701
DWORD fnid
Definition: ntuser.h:704
DWORD state
Definition: ntuser.h:696
UINT_PTR IDMenu
Definition: ntuser.h:726
LONG_PTR dwUserData
Definition: ntuser.h:736
WNDPROC lpfnWndProc
Definition: ntuser.h:713
HINSTANCE hModule
Definition: ntuser.h:703
ULONG cbwndExtra
Definition: ntuser.h:733
Definition: name.c:39
#define max(a, b)
Definition: svc.c:63
#define LONG_PTR
Definition: treelist.c:79
#define GWLP_WNDPROC
Definition: treelist.c:66
#define GWLP_USERDATA
Definition: treelist.c:63
uint16_t * PWSTR
Definition: typedefs.h:56
uint32_t * PULONG_PTR
Definition: typedefs.h:65
uint32_t * PULONG
Definition: typedefs.h:59
char * PSTR
Definition: typedefs.h:51
const uint16_t * PCWSTR
Definition: typedefs.h:57
uint32_t DWORD_PTR
Definition: typedefs.h:65
uint32_t * LPDWORD
Definition: typedefs.h:59
int32_t INT
Definition: typedefs.h:58
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
uint32_t ULONG_PTR
Definition: typedefs.h:65
uint32_t ULONG
Definition: typedefs.h:59
char * PCHAR
Definition: typedefs.h:51
BOOL FASTCALL TestWindowProcess(PWND)
Definition: misc.c:166
HINSTANCE User32Instance
Definition: dllmain.c:27
static __inline PVOID SharedPtrToUser(PVOID Ptr)
Definition: user_x.h:4
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
INT APIENTRY NtUserGetClassName(IN HWND hWnd, IN BOOL Real, OUT PUNICODE_STRING ClassName)
Definition: class.c:2822
BOOL APIENTRY NtUserUnregisterClass(IN PUNICODE_STRING ClassNameOrAtom, IN HINSTANCE hInstance, OUT PCLSMENUNAME pClassMenuName)
Definition: class.c:2686
RTL_ATOM APIENTRY NtUserRegisterClassExWOW(WNDCLASSEXW *lpwcx, PUNICODE_STRING ClassName, PUNICODE_STRING ClsVersion, PCLSMENUNAME pClassMenuName, DWORD fnID, DWORD Flags, LPDWORD pWow)
Definition: class.c:2413
ULONG_PTR APIENTRY NtUserSetClassLong(HWND hWnd, INT Offset, ULONG_PTR dwNewLong, BOOL Ansi)
Definition: class.c:2575
BOOL APIENTRY NtUserGetClassInfo(HINSTANCE hInstance, PUNICODE_STRING ClassName, LPWNDCLASSEXW lpWndClassEx, LPWSTR *ppszMenuName, BOOL bAnsi)
Definition: class.c:2720
ULONG_PTR FASTCALL IntGetClsWndProc(PWND pWnd, PCLS Class, BOOL Ansi)
Definition: class.c:536
WNDPROC FASTCALL IntGetWndProc(PWND pWnd, BOOL Ansi)
Definition: class.c:589
UINT WINAPI RealGetWindowClassW(HWND hwnd, LPWSTR pszType, UINT cchType)
Definition: class.c:1226
UINT WINAPI RealGetWindowClassA(HWND hwnd, LPSTR pszType, UINT cchType)
Definition: class.c:1246
ATOM WINAPI RegisterClassExWOWW(WNDCLASSEXW *lpwcx, LPDWORD pdwWowData, WORD fnID, DWORD dwFlags, BOOL ChkRegCls)
Definition: class.c:1413
static ULONG_PTR FASTCALL IntGetClassLongA(PWND Wnd, PCLS Class, int nIndex)
Definition: class.c:653
LONG WINAPI GetWindowLongA(HWND hWnd, int nIndex)
Definition: class.c:1156
LONG WINAPI GetWindowLongW(HWND hWnd, int nIndex)
Definition: class.c:1166
WORD WINAPI SetClassWord(HWND hWnd, int nIndex, WORD wNewWord)
Definition: class.c:1796
WORD WINAPI SetWindowWord(HWND hWnd, int nIndex, WORD wNewWord)
Definition: class.c:1815
LONG_PTR IntGetWindowLong(HWND hwnd, INT offset, UINT size, BOOL unicode)
Definition: class.c:1081
LONG WINAPI DECLSPEC_HOTPATCH SetWindowLongA(HWND hWnd, int nIndex, LONG dwNewLong)
Definition: class.c:1841
WORD WINAPI GetWindowWord(HWND hWnd, int nIndex)
Definition: class.c:1201
LPCWSTR is_comctl32_class(const WCHAR *name)
Definition: class.c:46
static ULONG_PTR FASTCALL IntGetClassLongW(PWND Wnd, PCLS Class, int nIndex)
Definition: class.c:728
DWORD WINAPI GetClassLongA(HWND hWnd, int nIndex)
Definition: class.c:805
WORD WINAPI GetClassWord(HWND hwnd, int offset)
Definition: class.c:1055
BOOL FASTCALL VersionRegisterClass(PCWSTR pszClass, LPCWSTR lpLibFileName, HANDLE Contex, HMODULE *phLibModule)
Definition: class.c:195
LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
Definition: class.c:85
LONG WINAPI SetWindowLongW(HWND hWnd, int nIndex, LONG dwNewLong)
Definition: class.c:1854
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
#define WINAPI
Definition: msvc.h:6
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
#define ERROR_CLASS_DOES_NOT_EXIST
Definition: winerror.h:892
#define ERROR_CANNOT_FIND_WND_CLASS
Definition: winerror.h:888
#define ERROR_NOACCESS
Definition: winerror.h:578
int WINAPI GetObjectW(_In_ HANDLE h, _In_ int c, _Out_writes_bytes_opt_(c) LPVOID pv)
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1539
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
BOOL WINAPI StretchBlt(_In_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_opt_ HDC, _In_ int, _In_ int, _In_ int, _In_ int, _In_ DWORD)
#define SRCCOPY
Definition: wingdi.h:333
HBITMAP WINAPI CreateCompatibleBitmap(_In_ HDC hdc, _In_ INT cx, _In_ INT cy)
BOOL WINAPI DeleteDC(_In_ HDC)
#define GW_OWNER
Definition: winuser.h:761
#define SetWindowLongPtrA
Definition: winuser.h:5335
#define SetClassLongPtrW
Definition: winuser.h:5255
#define GCLP_MENUNAME
Definition: winuser.h:672
#define GetWindowLongPtrW
Definition: winuser.h:4819
HICON WINAPI CreateIconIndirect(_In_ PICONINFO)
Definition: cursoricon.c:2550
#define SetClassLongPtrA
Definition: winuser.h:5254
#define GCLP_HICONSM
Definition: winuser.h:670
BOOL WINAPI UnregisterClassA(_In_ LPCSTR, HINSTANCE)
#define GCLP_HMODULE
Definition: winuser.h:671
BOOL WINAPI GetIconInfo(_In_ HICON, _Out_ PICONINFO)
Definition: cursoricon.c:2014
#define GCLP_HICON
Definition: winuser.h:669
#define GCL_HMODULE
Definition: winuser.h:663
HBRUSH WINAPI GetSysColorBrush(_In_ int)
int WINAPI GetClassNameA(_In_ HWND hWnd, _Out_writes_to_(nMaxCount, return) LPSTR lpClassName, _In_ int nMaxCount)
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
ATOM WINAPI RegisterClassW(_In_ CONST WNDCLASSW *)
#define GCLP_WNDPROC
Definition: winuser.h:673
#define SM_CYSMICON
Definition: winuser.h:1007
#define GA_PARENT
Definition: winuser.h:2778
BOOL WINAPI GetClassInfoExA(_In_opt_ HINSTANCE, _In_ LPCSTR, _Out_ LPWNDCLASSEXA)
#define GetWindowLongPtrA
Definition: winuser.h:4818
#define GCL_MENUNAME
Definition: winuser.h:664
BOOL WINAPI GetClassInfoExW(_In_opt_ HINSTANCE, _In_ LPCWSTR, _Out_ LPWNDCLASSEXW)
#define GCLP_HCURSOR
Definition: winuser.h:668
#define GCL_CBWNDEXTRA
Definition: winuser.h:658
#define GWLP_HINSTANCE
Definition: winuser.h:850
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:656
#define SM_CXSMICON
Definition: winuser.h:1006
ATOM WINAPI RegisterClassA(_In_ CONST WNDCLASSA *)
ATOM WINAPI RegisterClassExA(_In_ CONST WNDCLASSEXA *)
_In_ int nMaxCount
Definition: winuser.h:4867
#define GWLP_HWNDPARENT
Definition: winuser.h:852
DWORD WINAPI SetClassLongW(_In_ HWND, _In_ int, _In_ LONG)
ATOM WINAPI RegisterClassExW(_In_ CONST WNDCLASSEXW *)
#define GCL_HBRBACKGROUND
Definition: winuser.h:659
BOOL WINAPI GetClassInfoA(_In_opt_ HINSTANCE, _In_ LPCSTR, _Out_ LPWNDCLASSA)
#define GetClassLongPtrW
Definition: winuser.h:4554
HWND WINAPI GetWindow(_In_ HWND, _In_ UINT)
int WINAPI GetClassNameW(_In_ HWND hWnd, _Out_writes_to_(nMaxCount, return) LPWSTR lpClassName, _In_ int nMaxCount)
#define GWLP_ID
Definition: winuser.h:854
DWORD WINAPI SetClassLongA(_In_ HWND, _In_ int, _In_ LONG)
struct _WNDCLASSEXW WNDCLASSEXW
struct _WNDCLASSEXA WNDCLASSEXA
#define GetClassLongPtrA
Definition: winuser.h:4553
BOOL WINAPI UnregisterClassW(_In_ LPCWSTR, HINSTANCE)
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2896
DWORD WINAPI GetClassLongW(_In_ HWND, _In_ int)
BOOL WINAPI GetClassInfoW(_In_opt_ HINSTANCE, _In_ LPCWSTR, _Out_ LPWNDCLASSW)
#define SetWindowLongPtrW
Definition: winuser.h:5336
#define GWL_STYLE
Definition: winuser.h:846
#define GCLP_HBRBACKGROUND
Definition: winuser.h:667
int WINAPI GetSystemMetrics(_In_ int)
HWND WINAPI GetAncestor(_In_ HWND, _In_ UINT)
#define GCW_ATOM
Definition: winuser.h:656
#define GCL_STYLE
Definition: winuser.h:665
#define GCL_CBCLSEXTRA
Definition: winuser.h:657
#define GWL_EXSTYLE
Definition: winuser.h:845
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193