ReactOS 0.4.15-dev-6662-g1b3eed5
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
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 */
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
1263 LPDWORD pdwWowData,
1264 WORD fnID,
1265 DWORD dwFlags,
1266 BOOL ChkRegCls)
1267{
1268 ATOM Atom;
1270 UNICODE_STRING ClassName;
1271 UNICODE_STRING ClassVersion;
1272 UNICODE_STRING MenuName = {0};
1273 CLSMENUNAME clsMenuName;
1274 ANSI_STRING AnsiMenuName;
1275 LPCWSTR lpszClsVersion;
1276
1277 if (lpwcx == NULL || lpwcx->cbSize != sizeof(*lpwcx) ||
1278 lpwcx->cbClsExtra < 0 || lpwcx->cbWndExtra < 0 ||
1279 lpwcx->lpszClassName == NULL)
1280 {
1281 TRACE("RegisterClassExWOWW Invalid Parameter Error!\n");
1283 return 0;
1284 }
1285
1286 if (ChkRegCls)
1287 {
1289 }
1290 /*
1291 * On real Windows this looks more like:
1292 * if (lpwcx->hInstance == User32Instance &&
1293 * *(PULONG)((ULONG_PTR)NtCurrentTeb() + 0x6D4) & 0x400)
1294 * But since I have no idea what the magic field in the
1295 * TEB structure means, I rather decided to omit that.
1296 * -- Filip Navara
1297
1298 GetWin32ClientInfo()->dwExpWinVer & (WINVER == 0x400)
1299 */
1300 if (lpwcx->hInstance == User32Instance)
1301 {
1302 TRACE("RegisterClassExWOWW User32Instance!\n");
1304 return 0;
1305 }
1306 /* Yes, this is correct. We should modify the passed structure. */
1307 if (lpwcx->hInstance == NULL)
1308 ((WNDCLASSEXW*)lpwcx)->hInstance = GetModuleHandleW(NULL);
1309
1310 RtlCopyMemory(&WndClass, lpwcx, sizeof(*lpwcx));
1311
1312 RtlInitEmptyAnsiString(&AnsiMenuName, NULL, 0);
1313 if (!IS_INTRESOURCE(WndClass.lpszMenuName))
1314 {
1315 if (WndClass.lpszMenuName[0])
1316 {
1317 RtlInitUnicodeString(&MenuName, WndClass.lpszMenuName);
1318 RtlUnicodeStringToAnsiString(&AnsiMenuName, &MenuName, TRUE);
1319 }
1320 }
1321 else
1322 {
1323 MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
1324 AnsiMenuName.Buffer = (PCHAR)WndClass.lpszMenuName;
1325 }
1326
1327 if (WndClass.lpszClassName && !IS_ATOM(WndClass.lpszClassName))
1328 {
1329 RtlInitUnicodeString(&ClassName, WndClass.lpszClassName);
1330 }
1331 else
1332 {
1333 ClassName.Length = ClassName.MaximumLength = 0;
1334 ClassName.Buffer = (LPWSTR)WndClass.lpszClassName;
1335 }
1336
1337 ClassVersion = ClassName;
1338 if (fnID == 0)
1339 {
1340 lpszClsVersion = ClassNameToVersion(lpwcx->lpszClassName, NULL, NULL, NULL, FALSE);
1341 if (lpszClsVersion)
1342 {
1343 RtlInitUnicodeString(&ClassVersion, lpszClsVersion);
1344 }
1345 }
1346
1347 clsMenuName.pszClientAnsiMenuName = AnsiMenuName.Buffer;
1348 clsMenuName.pwszClientUnicodeMenuName = MenuName.Buffer;
1349 clsMenuName.pusMenuName = &MenuName;
1350
1352 &ClassName,
1353 &ClassVersion,
1354 &clsMenuName,
1355 fnID,
1356 dwFlags,
1357 pdwWowData);
1358
1359 TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
1360 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1361 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
1362
1363 return Atom;
1364}
1365
1366/*
1367 * @implemented
1368 */
1371{
1372 ATOM Atom;
1375 WCHAR cname[MAX_BUFFER_LEN];
1376
1377 C_ASSERT(sizeof(WndClass) == sizeof(*lpwcx));
1378
1379 RtlCopyMemory(&WndClass, lpwcx, sizeof(*lpwcx));
1380
1381 if (WndClass.lpszMenuName && !IS_INTRESOURCE(WndClass.lpszMenuName))
1382 {
1383 if (WndClass.lpszMenuName[0])
1384 {
1385 if (!MultiByteToWideChar(CP_ACP, 0, lpwcx->lpszMenuName, -1, mname, MAX_ATOM_LEN + 1 ))
1386 return 0;
1387
1388 WndClass.lpszMenuName = mname;
1389 }
1390 }
1391
1392 if (WndClass.lpszClassName && !IS_ATOM(WndClass.lpszClassName))
1393 {
1394 if (!MultiByteToWideChar(CP_ACP, 0, lpwcx->lpszClassName, -1, cname, MAX_ATOM_LEN + 1 ))
1395 return 0;
1396
1397 WndClass.lpszClassName = cname;
1398 }
1399
1401 NULL,
1402 0,
1404 TRUE);
1405
1406 TRACE("A atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
1407 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1408 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
1409
1410 return Atom;
1411}
1412
1413/*
1414 * @implemented
1415 */
1418{
1419 ATOM Atom;
1420
1421 Atom = RegisterClassExWOWW((WNDCLASSEXW *)lpwcx, NULL, 0, 0, TRUE);
1422
1423 TRACE("W atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d\n",
1424 Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1425 lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra);
1426
1427 return Atom;
1428}
1429
1430/*
1431 * @implemented
1432 */
1435{
1437
1438 if (lpWndClass == NULL)
1439 return 0;
1440
1441 /* These MUST be copied manually, since on 64 bit architectures the
1442 alignment of the members is different between the 2 structs! */
1443 Class.style = lpWndClass->style;
1444 Class.lpfnWndProc = lpWndClass->lpfnWndProc;
1445 Class.cbClsExtra = lpWndClass->cbClsExtra;
1446 Class.cbWndExtra = lpWndClass->cbWndExtra;
1447 Class.hInstance = lpWndClass->hInstance;
1448 Class.hIcon = lpWndClass->hIcon;
1449 Class.hCursor = lpWndClass->hCursor;
1450 Class.hbrBackground = lpWndClass->hbrBackground;
1451 Class.lpszMenuName = lpWndClass->lpszMenuName;
1452 Class.lpszClassName = lpWndClass->lpszClassName;
1453
1454 Class.cbSize = sizeof(Class);
1455 Class.hIconSm = NULL;
1456
1457 return RegisterClassExA(&Class);
1458}
1459
1460/*
1461 * @implemented
1462 */
1465{
1467
1468 if (lpWndClass == NULL)
1469 return 0;
1470
1471 /* These MUST be copied manually, since on 64 bit architectures the
1472 alignment of the members is different between the 2 structs! */
1473 Class.style = lpWndClass->style;
1474 Class.lpfnWndProc = lpWndClass->lpfnWndProc;
1475 Class.cbClsExtra = lpWndClass->cbClsExtra;
1476 Class.cbWndExtra = lpWndClass->cbWndExtra;
1477 Class.hInstance = lpWndClass->hInstance;
1478 Class.hIcon = lpWndClass->hIcon;
1479 Class.hCursor = lpWndClass->hCursor;
1480 Class.hbrBackground = lpWndClass->hbrBackground;
1481 Class.lpszMenuName = lpWndClass->lpszMenuName;
1482 Class.lpszClassName = lpWndClass->lpszClassName;
1483
1484 Class.cbSize = sizeof(Class);
1485 Class.hIconSm = NULL;
1486
1487 return RegisterClassExW(&Class);
1488}
1489
1490/*
1491 * @implemented
1492 */
1493DWORD
1494WINAPI
1496 int nIndex,
1497 LONG dwNewLong)
1498{
1499 PSTR lpStr = (PSTR)(ULONG_PTR)dwNewLong;
1500 UNICODE_STRING Value = {0};
1502 DWORD Ret;
1503
1504 /* FIXME - portability!!!! */
1505
1506 if (nIndex == GCL_MENUNAME && lpStr != NULL)
1507 {
1508 if (!IS_INTRESOURCE(lpStr))
1509 {
1511 {
1513 return 0;
1514 }
1515
1516 Allocated = TRUE;
1517 }
1518 else
1519 {
1520 Value.Buffer = (PWSTR)lpStr;
1521 }
1522
1523 dwNewLong = (LONG_PTR)&Value;
1524 }
1525 else if (nIndex == GCW_ATOM && lpStr != NULL)
1526 {
1527 if (!IS_ATOM(lpStr))
1528 {
1530 {
1532 return 0;
1533 }
1534
1535 Allocated = TRUE;
1536 }
1537 else
1538 {
1539 Value.Buffer = (PWSTR)lpStr;
1540 }
1541
1542 dwNewLong = (LONG_PTR)&Value;
1543 }
1544
1546 nIndex,
1547 dwNewLong,
1548 TRUE);
1549
1550 if (Allocated)
1551 {
1553 }
1554
1555 return Ret;
1556}
1557
1558
1559/*
1560 * @implemented
1561 */
1562DWORD
1563WINAPI
1565 int nIndex,
1566 LONG dwNewLong)
1567{
1568 PWSTR lpStr = (PWSTR)(ULONG_PTR)dwNewLong;
1569 UNICODE_STRING Value = {0};
1570
1571 TRACE("%p %d %lx\n", hWnd, nIndex, dwNewLong);
1572
1573 /* FIXME - portability!!!! */
1574
1575 if (nIndex == GCL_MENUNAME && lpStr != NULL)
1576 {
1577 if (!IS_INTRESOURCE(lpStr))
1578 RtlInitUnicodeString(&Value, lpStr);
1579 else
1580 Value.Buffer = lpStr;
1581
1582 dwNewLong = (LONG_PTR)&Value;
1583 }
1584 else if (nIndex == GCW_ATOM && lpStr != NULL)
1585 {
1586 if (!IS_ATOM(lpStr))
1587 RtlInitUnicodeString(&Value, lpStr);
1588 else
1589 Value.Buffer = lpStr;
1590
1591 dwNewLong = (LONG_PTR)&Value;
1592 }
1593
1595 nIndex,
1596 dwNewLong,
1597 FALSE);
1598}
1599
1600#ifdef _WIN64
1601/*
1602 * @unimplemented
1603 */
1605WINAPI
1607 INT nIndex,
1608 LONG_PTR dwNewLong)
1609{
1611 return 0;
1612}
1613
1614/*
1615 * @unimplemented
1616 */
1618WINAPI
1620 INT nIndex,
1621 LONG_PTR dwNewLong)
1622{
1624 return 0;
1625}
1626#endif // _WIN64
1627
1628/*
1629 * @implemented
1630 */
1631WORD
1632WINAPI
1634 HWND hWnd,
1635 int nIndex,
1636 WORD wNewWord)
1637/*
1638 * NOTE: Obsoleted in 32-bit windows
1639 */
1640{
1641 if ((nIndex < 0) && (nIndex != GCW_ATOM))
1642 return 0;
1643
1644 return (WORD) SetClassLongW ( hWnd, nIndex, wNewWord );
1645}
1646
1647/*
1648 * @implemented
1649 */
1650WORD
1651WINAPI
1652SetWindowWord ( HWND hWnd,int nIndex,WORD wNewWord )
1653{
1654 switch(nIndex)
1655 {
1656 case GWLP_ID:
1657 case GWLP_HINSTANCE:
1658 case GWLP_HWNDPARENT:
1659 break;
1660 default:
1661 if (nIndex < 0)
1662 {
1663 WARN("Invalid offset %d\n", nIndex );
1665 return 0;
1666 }
1667 break;
1668 }
1669 /* DO NOT USE NtUserSetWindowLong(Ptr)! */
1670 return NtUserSetWindowWord(hWnd, nIndex, wNewWord);
1671}
1672
1673/*
1674 * @implemented
1675 */
1676LONG
1677WINAPI
1680 HWND hWnd,
1681 int nIndex,
1682 LONG dwNewLong)
1683{
1684 /* DO NOT USE NtUserSetWindowLongPtr! */
1685 return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, TRUE);
1686}
1687
1688/*
1689 * @implemented
1690 */
1691LONG
1692WINAPI
1694 HWND hWnd,
1695 int nIndex,
1696 LONG dwNewLong)
1697{
1698 /* DO NOT USE NtUserSetWindowLongPtr! */
1699 return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, FALSE);
1700}
1701
1702#ifdef _WIN64
1703/*
1704 * @implemented
1705 */
1707WINAPI
1709 INT nIndex,
1710 LONG_PTR dwNewLong)
1711{
1712 return NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, TRUE);
1713}
1714
1715/*
1716 * @implemented
1717 */
1719WINAPI
1721 INT nIndex,
1722 LONG_PTR dwNewLong)
1723{
1724 return NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, FALSE);
1725}
1726#endif
1727
1728/*
1729 * @implemented
1730 */
1731BOOL
1732WINAPI
1734 LPCSTR lpClassName,
1736{
1737 UNICODE_STRING ClassName = {0};
1738 BOOL Ret;
1739 LPCWSTR lpszClsVersion;
1740 BOOL ConvertedString = FALSE;
1741
1742 TRACE("class/atom: %s/%04x %p\n",
1743 IS_ATOM(lpClassName) ? NULL : lpClassName,
1744 IS_ATOM(lpClassName) ? lpClassName : 0,
1745 hInstance);
1746
1747 lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, TRUE);
1748 if (lpszClsVersion)
1749 {
1750 RtlInitUnicodeString(&ClassName, lpszClsVersion);
1751 }
1752 else if (!IS_ATOM(lpClassName))
1753 {
1754 ConvertedString = TRUE;
1755 if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, lpClassName))
1756 {
1758 return 0;
1759 }
1760 }
1761 else
1762 {
1763 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1764 }
1765
1766 Ret = NtUserUnregisterClass(&ClassName, hInstance, 0);
1767
1768 if (ConvertedString)
1769 RtlFreeUnicodeString(&ClassName);
1770
1771 return Ret;
1772}
1773
1774/*
1775 * @implemented
1776 */
1777BOOL
1778WINAPI
1780 LPCWSTR lpClassName,
1782{
1783 UNICODE_STRING ClassName = {0};
1784 LPCWSTR lpszClsVersion;
1785
1786 TRACE("class/atom: %S/%04x %p\n",
1787 IS_ATOM(lpClassName) ? NULL : lpClassName,
1788 IS_ATOM(lpClassName) ? lpClassName : 0,
1789 hInstance);
1790
1791 lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, FALSE);
1792 if (lpszClsVersion)
1793 {
1794 RtlInitUnicodeString(&ClassName, lpszClsVersion);
1795 }
1796 else if (!IS_ATOM(lpClassName))
1797 {
1798 RtlInitUnicodeString(&ClassName, lpClassName);
1799 }
1800 else
1801 {
1802 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1803 }
1804
1805 return NtUserUnregisterClass(&ClassName, hInstance, 0);
1806}
1807
1808/* 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
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
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:3405
#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
LONG NTAPI NtUserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
Definition: window.c:4055
WORD NTAPI NtUserSetWindowWord(HWND hWnd, INT Index, WORD NewVal)
Definition: window.c:4130
#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
#define C_ASSERT(e)
Definition: intsafe.h:73
if(dx< 0)
Definition: linetemp.h:194
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#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
PUNICODE_STRING pusMenuName
Definition: ntuser.h:495
LPSTR pszClientAnsiMenuName
Definition: ntuser.h:493
LPWSTR pwszClientUnicodeMenuName
Definition: ntuser.h:494
Definition: ntuser.h:561
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:2825
BOOL APIENTRY NtUserUnregisterClass(IN PUNICODE_STRING ClassNameOrAtom, IN HINSTANCE hInstance, OUT PCLSMENUNAME pClassMenuName)
Definition: class.c:2689
RTL_ATOM APIENTRY NtUserRegisterClassExWOW(WNDCLASSEXW *lpwcx, PUNICODE_STRING ClassName, PUNICODE_STRING ClsVersion, PCLSMENUNAME pClassMenuName, DWORD fnID, DWORD Flags, LPDWORD pWow)
Definition: class.c:2416
ULONG_PTR APIENTRY NtUserSetClassLong(HWND hWnd, INT Offset, ULONG_PTR dwNewLong, BOOL Ansi)
Definition: class.c:2578
BOOL APIENTRY NtUserGetClassInfo(HINSTANCE hInstance, PUNICODE_STRING ClassName, LPWNDCLASSEXW lpWndClassEx, LPWSTR *ppszMenuName, BOOL bAnsi)
Definition: class.c:2723
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:1262
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:1633
WORD WINAPI SetWindowWord(HWND hWnd, int nIndex, WORD wNewWord)
Definition: class.c:1652
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:1679
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:1693
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
_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
#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
#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
#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 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
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)
#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
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:409
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