ReactOS 0.4.15-dev-5666-gc548b97
class.c File Reference
#include <user32.h>
Include dependency graph for class.c:

Go to the source code of this file.

Classes

struct  strsection_header
 
struct  wndclass_redirect_data
 

Macros

#define USE_VERSIONED_CLASSES
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (user32)
 
LPCWSTR is_comctl32_class (const WCHAR *name)
 
LPCWSTR FASTCALL ClassNameToVersion (const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
 
BOOL FASTCALL VersionRegisterClass (PCWSTR pszClass, LPCWSTR lpLibFileName, HANDLE Contex, HMODULE *phLibModule)
 
BOOL WINAPI GetClassInfoExA (HINSTANCE hInstance, LPCSTR lpszClass, LPWNDCLASSEXA lpwcx)
 
BOOL WINAPI GetClassInfoExW (HINSTANCE hInstance, LPCWSTR lpszClass, LPWNDCLASSEXW lpwcx)
 
BOOL WINAPI GetClassInfoA (HINSTANCE hInstance, LPCSTR lpClassName, LPWNDCLASSA lpWndClass)
 
BOOL WINAPI GetClassInfoW (HINSTANCE hInstance, LPCWSTR lpClassName, LPWNDCLASSW lpWndClass)
 
ULONG_PTR FASTCALL IntGetClsWndProc (PWND pWnd, PCLS Class, BOOL Ansi)
 
WNDPROC FASTCALL IntGetWndProc (PWND pWnd, BOOL Ansi)
 
static ULONG_PTR FASTCALL IntGetClassLongA (PWND Wnd, PCLS Class, int nIndex)
 
static ULONG_PTR FASTCALL IntGetClassLongW (PWND Wnd, PCLS Class, int nIndex)
 
DWORD WINAPI GetClassLongA (HWND hWnd, int nIndex)
 
DWORD WINAPI GetClassLongW (HWND hWnd, int nIndex)
 
int WINAPI GetClassNameA (HWND hWnd, LPSTR lpClassName, int nMaxCount)
 
int WINAPI GetClassNameW (HWND hWnd, LPWSTR lpClassName, int nMaxCount)
 
WORD WINAPI GetClassWord (HWND hwnd, int offset)
 
LONG_PTR IntGetWindowLong (HWND hwnd, INT offset, UINT size, BOOL unicode)
 
LONG WINAPI GetWindowLongA (HWND hWnd, int nIndex)
 
LONG WINAPI GetWindowLongW (HWND hWnd, int nIndex)
 
WORD WINAPI GetWindowWord (HWND hWnd, int nIndex)
 
UINT WINAPI RealGetWindowClassW (HWND hwnd, LPWSTR pszType, UINT cchType)
 
UINT WINAPI RealGetWindowClassA (HWND hwnd, LPSTR pszType, UINT cchType)
 
ATOM WINAPI RegisterClassExWOWW (WNDCLASSEXW *lpwcx, LPDWORD pdwWowData, WORD fnID, DWORD dwFlags, BOOL ChkRegCls)
 
ATOM WINAPI RegisterClassExA (CONST WNDCLASSEXA *lpwcx)
 
ATOM WINAPI RegisterClassExW (CONST WNDCLASSEXW *lpwcx)
 
ATOM WINAPI RegisterClassA (CONST WNDCLASSA *lpWndClass)
 
ATOM WINAPI RegisterClassW (CONST WNDCLASSW *lpWndClass)
 
DWORD WINAPI SetClassLongA (HWND hWnd, int nIndex, LONG dwNewLong)
 
DWORD WINAPI SetClassLongW (HWND hWnd, int nIndex, LONG dwNewLong)
 
WORD WINAPI SetClassWord (HWND hWnd, int nIndex, WORD wNewWord)
 
WORD WINAPI SetWindowWord (HWND hWnd, int nIndex, WORD wNewWord)
 
LONG WINAPI DECLSPEC_HOTPATCH SetWindowLongA (HWND hWnd, int nIndex, LONG dwNewLong)
 
LONG WINAPI SetWindowLongW (HWND hWnd, int nIndex, LONG dwNewLong)
 
BOOL WINAPI UnregisterClassA (LPCSTR lpClassName, HINSTANCE hInstance)
 
BOOL WINAPI UnregisterClassW (LPCWSTR lpClassName, HINSTANCE hInstance)
 

Macro Definition Documentation

◆ USE_VERSIONED_CLASSES

#define USE_VERSIONED_CLASSES

Definition at line 15 of file class.c.

Function Documentation

◆ ClassNameToVersion()

LPCWSTR FASTCALL ClassNameToVersion ( const void lpszClass,
LPCWSTR  lpszMenuName,
LPCWSTR plpLibFileName,
HANDLE pContext,
BOOL  bAnsi 
)

Definition at line 85 of file class.c.

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}
LONG NTSTATUS
Definition: precomp.h:26
#define ERR(fmt,...)
Definition: debug.h:110
#define IS_ATOM(x)
Definition: class.h:3
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define MAX_PATH
Definition: compat.h:34
@ AnsiString
Definition: dnslib.h:19
Status
Definition: gdiplustypes.h:25
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
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
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
#define L(x)
Definition: ntvdm.h:50
#define LOWORD(l)
Definition: pedump.c:82
unsigned short USHORT
Definition: pedump.c:61
#define TRACE(s)
Definition: solgame.cpp:4
uint32_t DWORD_PTR
Definition: typedefs.h:65
LPCWSTR is_comctl32_class(const WCHAR *name)
Definition: class.c:46
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
unsigned char BYTE
Definition: xxhash.c:193

Referenced by GetClassInfoExA(), GetClassInfoExW(), RegisterClassExWOWW(), UnregisterClassA(), UnregisterClassW(), and User32CreateWindowEx().

◆ GetClassInfoA()

BOOL WINAPI GetClassInfoA ( HINSTANCE  hInstance,
LPCSTR  lpClassName,
LPWNDCLASSA  lpWndClass 
)

Definition at line 476 of file class.c.

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}
HINSTANCE hInstance
Definition: charmap.c:19
unsigned int BOOL
Definition: ntddk_ex.h:94
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
BOOL WINAPI GetClassInfoExA(_In_opt_ HINSTANCE, _In_ LPCSTR, _Out_ LPWNDCLASSEXA)

◆ GetClassInfoExA()

BOOL WINAPI GetClassInfoExA ( HINSTANCE  hInstance,
LPCSTR  lpszClass,
LPWNDCLASSEXA  lpwcx 
)

Definition at line 264 of file class.c.

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}
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define TRUE
Definition: types.h:120
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define SetLastError(x)
Definition: compat.h:752
#define FreeLibrary(x)
Definition: compat.h:748
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL NTAPI NtUserGetClassInfo(HINSTANCE hInstance, PUNICODE_STRING ClassName, LPWNDCLASSEXW wcex, LPWSTR *ppszMenuName, BOOL Ansi)
Definition: class.c:2720
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
DWORD RegisterDefaultClasses
Definition: regcontrol.c:13
BOOL WINAPI RegisterSystemControls(VOID)
Definition: regcontrol.c:70
HINSTANCE hLibModule
Definition: sfc.c:23
LPCWSTR lpszClassName
Definition: winuser.h:3216
uint16_t * PWSTR
Definition: typedefs.h:56
uint32_t ULONG_PTR
Definition: typedefs.h:65
HINSTANCE User32Instance
Definition: dllmain.c:27
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
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
#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
const char * LPCSTR
Definition: xmlstorage.h:183
WCHAR * LPWSTR
Definition: xmlstorage.h:184

◆ GetClassInfoExW()

BOOL WINAPI GetClassInfoExW ( HINSTANCE  hInstance,
LPCWSTR  lpszClass,
LPWNDCLASSEXW  lpwcx 
)

Definition at line 374 of file class.c.

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}

◆ GetClassInfoW()

BOOL WINAPI GetClassInfoW ( HINSTANCE  hInstance,
LPCWSTR  lpClassName,
LPWNDCLASSW  lpWndClass 
)

Definition at line 507 of file class.c.

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}
LPCWSTR lpszMenuName
Definition: winuser.h:3215
HBRUSH hbrBackground
Definition: winuser.h:3214
WNDPROC lpfnWndProc
Definition: winuser.h:3208
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
BOOL WINAPI GetClassInfoExW(_In_opt_ HINSTANCE, _In_ LPCWSTR, _Out_ LPWNDCLASSEXW)

◆ GetClassLongA()

DWORD WINAPI GetClassLongA ( HWND  hWnd,
int  nIndex 
)

Definition at line 805 of file class.c.

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}
HWND hWnd
Definition: settings.c:17
#define WARN(fmt,...)
Definition: debug.h:112
#define ValidateHwnd(hwnd)
Definition: precomp.h:85
static PVOID FASTCALL DesktopPtrToUser(PVOID ptr)
Definition: utils.c:324
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
Definition: ntuser.h:561
Definition: ntuser.h:689
PCLS pcls
Definition: ntuser.h:715
static ULONG_PTR FASTCALL IntGetClassLongA(PWND Wnd, PCLS Class, int nIndex)
Definition: class.c:653
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
#define GCLP_MENUNAME
Definition: winuser.h:672
#define GCLP_HICONSM
Definition: winuser.h:670
#define GCLP_HMODULE
Definition: winuser.h:671
#define GCLP_HICON
Definition: winuser.h:669
#define GCLP_WNDPROC
Definition: winuser.h:673
#define GCLP_HCURSOR
Definition: winuser.h:668
#define GCLP_HBRBACKGROUND
Definition: winuser.h:667

Referenced by GetClassWord().

◆ GetClassLongW()

DWORD WINAPI GetClassLongW ( HWND  hWnd,
int  nIndex 
)

Definition at line 861 of file class.c.

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}
static ULONG_PTR FASTCALL IntGetClassLongW(PWND Wnd, PCLS Class, int nIndex)
Definition: class.c:728

◆ GetClassNameA()

int WINAPI GetClassNameA ( HWND  hWnd,
LPSTR  lpClassName,
int  nMaxCount 
)

Definition at line 998 of file class.c.

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}
#define MAX_ATOM_LEN
Definition: dde_private.h:30
GLenum GLsizei len
Definition: glext.h:6722
unsigned int * PULONG
Definition: retypes.h:1
_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
#define strlenW(s)
Definition: unicode.h:28
_In_ int nMaxCount
Definition: winuser.h:4867
int WINAPI GetClassNameW(_In_ HWND hWnd, _Out_writes_to_(nMaxCount, return) LPWSTR lpClassName, _In_ int nMaxCount)

◆ GetClassNameW()

int WINAPI GetClassNameW ( HWND  hWnd,
LPWSTR  lpClassName,
int  nMaxCount 
)

Definition at line 1025 of file class.c.

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}
INT NTAPI NtUserGetClassName(HWND hWnd, BOOL Real, PUNICODE_STRING ClassName)
_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

◆ GetClassWord()

WORD WINAPI GetClassWord ( HWND  hwnd,
int  offset 
)

Definition at line 1055 of file class.c.

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}
unsigned short WORD
Definition: ntddk_ex.h:93
GLintptr offset
Definition: glext.h:5920
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
DWORD WINAPI GetClassLongA(HWND hWnd, int nIndex)
Definition: class.c:805
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

◆ GetWindowLongA()

LONG WINAPI GetWindowLongA ( HWND  hWnd,
int  nIndex 
)

Definition at line 1156 of file class.c.

1157{
1158 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), FALSE );
1159}
long LONG
Definition: pedump.c:60
LONG_PTR IntGetWindowLong(HWND hwnd, INT offset, UINT size, BOOL unicode)
Definition: class.c:1081

◆ GetWindowLongW()

LONG WINAPI GetWindowLongW ( HWND  hWnd,
int  nIndex 
)

Definition at line 1166 of file class.c.

1167{
1168 return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), TRUE );
1169}

◆ GetWindowWord()

WORD WINAPI GetWindowWord ( HWND  hWnd,
int  nIndex 
)

Definition at line 1201 of file class.c.

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}
#define GWLP_HINSTANCE
Definition: winuser.h:850
#define GWLP_HWNDPARENT
Definition: winuser.h:852
#define GWLP_ID
Definition: winuser.h:854

◆ IntGetClassLongA()

static ULONG_PTR FASTCALL IntGetClassLongA ( PWND  Wnd,
PCLS  Class,
int  nIndex 
)
static

Definition at line 653 of file class.c.

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}
#define ULONG_PTR
Definition: config.h:101
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
if(dx< 0)
Definition: linetemp.h:194
unsigned int ULONG
Definition: retypes.h:1
uint32_t * PULONG_PTR
Definition: typedefs.h:65
static __inline PVOID SharedPtrToUser(PVOID Ptr)
Definition: user_x.h:4
ULONG_PTR FASTCALL IntGetClsWndProc(PWND pWnd, PCLS Class, BOOL Ansi)
Definition: class.c:536
#define GCL_HMODULE
Definition: winuser.h:663
HBRUSH WINAPI GetSysColorBrush(_In_ int)
#define GCL_MENUNAME
Definition: winuser.h:664
#define GCL_CBWNDEXTRA
Definition: winuser.h:658
#define GCL_HBRBACKGROUND
Definition: winuser.h:659
#define GCW_ATOM
Definition: winuser.h:656
#define GCL_STYLE
Definition: winuser.h:665
#define GCL_CBCLSEXTRA
Definition: winuser.h:657

Referenced by GetClassLongA().

◆ IntGetClassLongW()

static ULONG_PTR FASTCALL IntGetClassLongW ( PWND  Wnd,
PCLS  Class,
int  nIndex 
)
static

Definition at line 728 of file class.c.

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}

Referenced by GetClassLongW().

◆ IntGetClsWndProc()

ULONG_PTR FASTCALL IntGetClsWndProc ( PWND  pWnd,
PCLS  Class,
BOOL  Ansi 
)

Definition at line 536 of file class.c.

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}
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 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_FIRST
Definition: ntuser.h:853
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define FNID_BUTTON
Definition: ntuser.h:861
@ UserGetCPDWndtoCls
Definition: ntuser.h:540
@ UserGetCPDU2A
Definition: ntuser.h:536
@ UserGetCPDA2U
Definition: ntuser.h:535
#define GETPFNSERVER(fnid)
Definition: ntuser.h:904
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
int32_t INT
Definition: typedefs.h:58

Referenced by IntGetClassLongA(), and IntGetClassLongW().

◆ IntGetWindowLong()

LONG_PTR IntGetWindowLong ( HWND  hwnd,
INT  offset,
UINT  size,
BOOL  unicode 
)

Definition at line 1081 of file class.c.

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}
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
r parent
Definition: btrfs.c:3010
GLsizeiptr size
Definition: glext.h:5919
#define FNID_DESKTOP
Definition: ntuser.h:857
signed char * PCHAR
Definition: retypes.h:7
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
DWORD ExStyle
Definition: ntuser.h:699
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
HINSTANCE hModule
Definition: ntuser.h:703
ULONG cbwndExtra
Definition: ntuser.h:733
#define GWLP_WNDPROC
Definition: treelist.c:66
#define GWLP_USERDATA
Definition: treelist.c:63
BOOL FASTCALL TestWindowProcess(PWND)
Definition: misc.c:166
WNDPROC FASTCALL IntGetWndProc(PWND pWnd, BOOL Ansi)
Definition: class.c:589
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
#define GW_OWNER
Definition: winuser.h:761
#define GA_PARENT
Definition: winuser.h:2778
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:656
HWND WINAPI GetWindow(_In_ HWND, _In_ UINT)
#define GWL_STYLE
Definition: winuser.h:846
HWND WINAPI GetAncestor(_In_ HWND, _In_ UINT)
#define GWL_EXSTYLE
Definition: winuser.h:845

Referenced by GetWindowLongA(), GetWindowLongW(), and GetWindowWord().

◆ IntGetWndProc()

WNDPROC FASTCALL IntGetWndProc ( PWND  pWnd,
BOOL  Ansi 
)

Definition at line 589 of file class.c.

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}
#define WNDS_SERVERSIDEWINDOWPROC
Definition: ntuser.h:618
@ UserGetCPDWindow
Definition: ntuser.h:538
#define FNID_EDIT
Definition: ntuser.h:865
#define WNDS_ANSIWINDOWPROC
Definition: ntuser.h:619
WNDPROC lpfnWndProc
Definition: ntuser.h:713
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2896

Referenced by IntGetWindowLong().

◆ is_comctl32_class()

LPCWSTR is_comctl32_class ( const WCHAR name)

Definition at line 46 of file class.c.

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}
GLuint res
Definition: glext.h:9613
#define min(a, b)
Definition: monoChain.cc:55
#define strcmpiW(s1, s2)
Definition: unicode.h:39
Definition: name.c:39
#define max(a, b)
Definition: svc.c:63

Referenced by ClassNameToVersion().

◆ RealGetWindowClassA()

UINT WINAPI RealGetWindowClassA ( HWND  hwnd,
LPSTR  pszType,
UINT  cchType 
)

Definition at line 1246 of file class.c.

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}
unsigned int UINT
Definition: ndis.h:50
UINT WINAPI RealGetWindowClassW(HWND hwnd, LPWSTR pszType, UINT cchType)
Definition: class.c:1226

◆ RealGetWindowClassW()

UINT WINAPI RealGetWindowClassW ( HWND  hwnd,
LPWSTR  pszType,
UINT  cchType 
)

Definition at line 1226 of file class.c.

1230{
1231 UNICODE_STRING ClassName;
1232
1233 RtlInitEmptyUnicodeString(&ClassName,
1234 pszType,
1235 cchType * sizeof(WCHAR));
1236
1237 return NtUserGetClassName(hwnd,TRUE,&ClassName);
1238}

Referenced by RealGetWindowClassA().

◆ RegisterClassA()

ATOM WINAPI RegisterClassA ( CONST WNDCLASSA lpWndClass)

Definition at line 1593 of file class.c.

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}
ATOM WINAPI RegisterClassExA(_In_ CONST WNDCLASSEXA *)
struct _WNDCLASSEXA WNDCLASSEXA

◆ RegisterClassExA()

ATOM WINAPI RegisterClassExA ( CONST WNDCLASSEXA lpwcx)

Definition at line 1530 of file class.c.

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}
const char * mname
Definition: cmds.c:37
WCHAR WndClass[]
Definition: capicon.c:23
_Out_ RTL_ATOM * Atom
Definition: class.h:54
#define MAX_BUFFER_LEN
Definition: dde_private.h:34
WORD ATOM
Definition: dimm.idl:113
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
unsigned short RTL_ATOM
Definition: atom.c:42
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
ATOM WINAPI RegisterClassExWOWW(WNDCLASSEXW *lpwcx, LPDWORD pdwWowData, WORD fnID, DWORD dwFlags, BOOL ChkRegCls)
Definition: class.c:1413
#define IS_INTRESOURCE(i)
Definition: winuser.h:580

◆ RegisterClassExW()

ATOM WINAPI RegisterClassExW ( CONST WNDCLASSEXW lpwcx)

Definition at line 1576 of file class.c.

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}

◆ RegisterClassExWOWW()

ATOM WINAPI RegisterClassExWOWW ( WNDCLASSEXW lpwcx,
LPDWORD  pdwWowData,
WORD  fnID,
DWORD  dwFlags,
BOOL  ChkRegCls 
)

Definition at line 1413 of file class.c.

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}
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
RTL_ATOM NTAPI NtUserRegisterClassExWOW(WNDCLASSEXW *lpwcx, PUNICODE_STRING pustrClassName, PUNICODE_STRING pustrCVersion, PCLSMENUNAME pClassMenuName, DWORD fnID, DWORD Flags, LPDWORD pWow)
Definition: class.c:2413
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
PUNICODE_STRING pusMenuName
Definition: ntuser.h:495
LPSTR pszClientAnsiMenuName
Definition: ntuser.h:493
LPWSTR pwszClientUnicodeMenuName
Definition: ntuser.h:494
USHORT MaximumLength
Definition: env_spec_w32.h:370
UINT cbSize
Definition: winuser.h:3206
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176

Referenced by RegisterClassExA(), RegisterClassExW(), RegisterIMEClass(), and RegisterSystemControls().

◆ RegisterClassW()

ATOM WINAPI RegisterClassW ( CONST WNDCLASSW lpWndClass)

Definition at line 1623 of file class.c.

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}
ATOM WINAPI RegisterClassExW(_In_ CONST WNDCLASSEXW *)
struct _WNDCLASSEXW WNDCLASSEXW

◆ SetClassLongA()

DWORD WINAPI SetClassLongA ( HWND  hWnd,
int  nIndex,
LONG  dwNewLong 
)

Definition at line 1654 of file class.c.

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}
IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN Allocated
Definition: fatprocs.h:310
ULONG_PTR NTAPI NtUserSetClassLong(HWND hWnd, INT Offset, ULONG_PTR dwNewLong, BOOL Ansi)
Definition: class.c:2575
signed char * PSTR
Definition: retypes.h:7
#define DWORD
Definition: nt_native.h:44
#define LONG_PTR
Definition: treelist.c:79
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413

◆ SetClassLongW()

DWORD WINAPI SetClassLongW ( HWND  hWnd,
int  nIndex,
LONG  dwNewLong 
)

Definition at line 1721 of file class.c.

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}

◆ SetClassWord()

WORD WINAPI SetClassWord ( HWND  hWnd,
int  nIndex,
WORD  wNewWord 
)

Definition at line 1796 of file class.c.

1803{
1804 if ((nIndex < 0) && (nIndex != GCW_ATOM))
1805 return 0;
1806
1807 return (WORD) SetClassLongW ( hWnd, nIndex, wNewWord );
1808}
DWORD WINAPI SetClassLongW(_In_ HWND, _In_ int, _In_ LONG)

◆ SetWindowLongA()

LONG WINAPI DECLSPEC_HOTPATCH SetWindowLongA ( HWND  hWnd,
int  nIndex,
LONG  dwNewLong 
)

Definition at line 1841 of file class.c.

1845{
1846 return (LONG)NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, TRUE);
1847}
#define NtUserSetWindowLongPtr
Definition: ntuser.h:3400

◆ SetWindowLongW()

LONG WINAPI SetWindowLongW ( HWND  hWnd,
int  nIndex,
LONG  dwNewLong 
)

Definition at line 1854 of file class.c.

1858{
1859 return (LONG)NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, FALSE);
1860}

◆ SetWindowWord()

WORD WINAPI SetWindowWord ( HWND  hWnd,
int  nIndex,
WORD  wNewWord 
)

Definition at line 1815 of file class.c.

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}

◆ UnregisterClassA()

BOOL WINAPI UnregisterClassA ( LPCSTR  lpClassName,
HINSTANCE  hInstance 
)

Definition at line 1893 of file class.c.

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}
BOOL NTAPI NtUserUnregisterClass(PUNICODE_STRING ClassNameOrAtom, HINSTANCE hInstance, PCLSMENUNAME pClassMenuName)

◆ UnregisterClassW()

BOOL WINAPI UnregisterClassW ( LPCWSTR  lpClassName,
HINSTANCE  hInstance 
)

Definition at line 1940 of file class.c.

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}

◆ VersionRegisterClass()

BOOL FASTCALL VersionRegisterClass ( PCWSTR  pszClass,
LPCWSTR  lpLibFileName,
HANDLE  Contex,
HMODULE phLibModule 
)

Definition at line 195 of file class.c.

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}
#define GetProcAddress(x, y)
Definition: compat.h:753
#define LoadLibraryW(x)
Definition: compat.h:747
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
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

Referenced by GetClassInfoExA(), GetClassInfoExW(), and User32CreateWindowEx().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( user32  )