ReactOS 0.4.16-dev-297-gc569aee
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: precomp.h:57
#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:33
#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:5874
NTSYSAPI void WINAPI RtlReleaseActivationContext(HANDLE)
Definition: actctx.c:5384
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:3173
HICON hIcon
Definition: winuser.h:3171
HINSTANCE hInstance
Definition: winuser.h:3170
HCURSOR hCursor
Definition: winuser.h:3172
int cbWndExtra
Definition: winuser.h:3169
UINT style
Definition: winuser.h:3166
LPCSTR lpszMenuName
Definition: winuser.h:3174
LPCSTR lpszClassName
Definition: winuser.h:3175
WNDPROC lpfnWndProc
Definition: winuser.h:3167
int cbClsExtra
Definition: winuser.h:3168
int cbClsExtra
Definition: winuser.h:3207
HINSTANCE hInstance
Definition: winuser.h:3209
HCURSOR hCursor
Definition: winuser.h:3211
LPCSTR lpszMenuName
Definition: winuser.h:3213
UINT style
Definition: winuser.h:3205
int cbWndExtra
Definition: winuser.h:3208
WNDPROC lpfnWndProc
Definition: winuser.h:3206
LPCSTR lpszClassName
Definition: winuser.h:3214
HICON hIcon
Definition: winuser.h:3210
HBRUSH hbrBackground
Definition: winuser.h:3212
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:2779
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:3229
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:1042
#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:3228
HBRUSH hbrBackground
Definition: winuser.h:3227
WNDPROC lpfnWndProc
Definition: winuser.h:3221
int cbWndExtra
Definition: winuser.h:3223
HCURSOR hCursor
Definition: winuser.h:3226
HINSTANCE hInstance
Definition: winuser.h:3224
UINT style
Definition: winuser.h:3220
int cbClsExtra
Definition: winuser.h:3222
HICON hIcon
Definition: winuser.h:3225
LPCWSTR lpszClassName
Definition: winuser.h:3188
LPCWSTR lpszMenuName
Definition: winuser.h:3187
HBRUSH hbrBackground
Definition: winuser.h:3186
HICON hIcon
Definition: winuser.h:3184
HINSTANCE hInstance
Definition: winuser.h:3183
int cbClsExtra
Definition: winuser.h:3181
UINT style
Definition: winuser.h:3179
WNDPROC lpfnWndProc
Definition: winuser.h:3180
int cbWndExtra
Definition: winuser.h:3182
HCURSOR hCursor
Definition: winuser.h:3185
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: precomp.h:61
#define ValidateHwnd(hwnd)
Definition: precomp.h:85
static PVOID FASTCALL DesktopPtrToUser(PVOID ptr)
Definition: utils.c:324
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define _SEH2_END
Definition: pseh2_64.h:155
#define _SEH2_TRY
Definition: pseh2_64.h:55
Definition: ntuser.h:566
Definition: ntuser.h:694
PCLS pcls
Definition: ntuser.h:720
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:677
#define GCLP_HICONSM
Definition: winuser.h:675
#define GCLP_HMODULE
Definition: winuser.h:676
#define GCLP_HICON
Definition: winuser.h:674
#define GCLP_WNDPROC
Definition: winuser.h:678
#define GCLP_HCURSOR
Definition: winuser.h:673
#define GCLP_HBRBACKGROUND
Definition: winuser.h:672

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
_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:34
uint32_t * PULONG
Definition: typedefs.h:59
_In_ int nMaxCount
Definition: winuser.h:4880
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:409

◆ 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:859
#define GWLP_HWNDPARENT
Definition: winuser.h:861
#define GWLP_ID
Definition: winuser.h:863

◆ 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
uint32_t * PULONG_PTR
Definition: typedefs.h:65
uint32_t ULONG
Definition: typedefs.h:59
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:668
HBRUSH WINAPI GetSysColorBrush(_In_ int)
#define GCL_MENUNAME
Definition: winuser.h:669
#define GCL_CBWNDEXTRA
Definition: winuser.h:663
#define GCL_HBRBACKGROUND
Definition: winuser.h:664
#define GCW_ATOM
Definition: winuser.h:661
#define GCL_STYLE
Definition: winuser.h:670
#define GCL_CBCLSEXTRA
Definition: winuser.h:662

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:865
#define GETPFNCLIENTW(fnid)
Definition: ntuser.h:906
#define GETPFNCLIENTA(fnid)
Definition: ntuser.h:904
#define CSF_ANSIPROC
Definition: ntuser.h:557
#define FNID_FIRST
Definition: ntuser.h:858
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define FNID_BUTTON
Definition: ntuser.h:866
@ UserGetCPDWndtoCls
Definition: ntuser.h:545
@ UserGetCPDU2A
Definition: ntuser.h:541
@ UserGetCPDA2U
Definition: ntuser.h:540
#define GETPFNSERVER(fnid)
Definition: ntuser.h:909
ULONG_PTR NTAPI NtUserGetCPD(HWND hWnd, GETCPD Flags, ULONG_PTR Proc)
Definition: callproc.c:176
#define CSF_SERVERSIDEPROC
Definition: ntuser.h:556
#define FNID_GHOST
Definition: ntuser.h:875
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:862
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
DWORD ExStyle
Definition: ntuser.h:704
DWORD style
Definition: ntuser.h:706
DWORD fnid
Definition: ntuser.h:709
DWORD state
Definition: ntuser.h:701
UINT_PTR IDMenu
Definition: ntuser.h:731
LONG_PTR dwUserData
Definition: ntuser.h:741
HINSTANCE hModule
Definition: ntuser.h:708
ULONG cbwndExtra
Definition: ntuser.h:738
#define GWLP_WNDPROC
Definition: treelist.c:66
#define GWLP_USERDATA
Definition: treelist.c:63
char * PCHAR
Definition: typedefs.h:51
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:769
#define GA_PARENT
Definition: winuser.h:2791
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:628
HWND WINAPI GetWindow(_In_ HWND, _In_ UINT)
#define GWL_STYLE
Definition: winuser.h:855
HWND WINAPI GetAncestor(_In_ HWND, _In_ UINT)
#define GWL_EXSTYLE
Definition: winuser.h:854

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:623
@ UserGetCPDWindow
Definition: ntuser.h:543
#define FNID_EDIT
Definition: ntuser.h:870
#define WNDS_ANSIWINDOWPROC
Definition: ntuser.h:624
WNDPROC lpfnWndProc
Definition: ntuser.h:718
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2909

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:45
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 1434 of file class.c.

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

◆ RegisterClassExA()

ATOM WINAPI RegisterClassExA ( CONST WNDCLASSEXA lpwcx)

Definition at line 1370 of file class.c.

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}
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
#define C_ASSERT(e)
Definition: intsafe.h:73
#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:1262
#define IS_INTRESOURCE(i)
Definition: winuser.h:580

◆ RegisterClassExW()

ATOM WINAPI RegisterClassExW ( CONST WNDCLASSEXW lpwcx)

Definition at line 1417 of file class.c.

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}

◆ RegisterClassExWOWW()

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

Definition at line 1262 of file class.c.

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}
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:2444
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
PUNICODE_STRING pusMenuName
Definition: ntuser.h:500
LPSTR pszClientAnsiMenuName
Definition: ntuser.h:498
LPWSTR pwszClientUnicodeMenuName
Definition: ntuser.h:499
USHORT MaximumLength
Definition: env_spec_w32.h:370
UINT cbSize
Definition: winuser.h:3219
_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 1464 of file class.c.

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

◆ SetClassLongA()

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

Definition at line 1495 of file class.c.

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}
IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN Allocated
Definition: fatprocs.h:311
ULONG_PTR NTAPI NtUserSetClassLong(_In_ HWND hWnd, _In_ INT Offset, _In_ ULONG dwNewLong, _In_ BOOL Ansi)
Definition: class.c:2706
#define DWORD
Definition: nt_native.h:44
#define LONG_PTR
Definition: treelist.c:79
char * PSTR
Definition: typedefs.h:51
_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 1564 of file class.c.

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}

◆ SetClassWord()

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

Definition at line 1637 of file class.c.

1644{
1645 if ((nIndex < 0) && (nIndex != GCW_ATOM))
1646 return 0;
1647
1648 return (WORD) SetClassLongW ( hWnd, nIndex, wNewWord );
1649}
DWORD WINAPI SetClassLongW(_In_ HWND, _In_ int, _In_ LONG)

◆ SetWindowLongA()

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

Definition at line 1683 of file class.c.

1687{
1688 /* DO NOT USE NtUserSetWindowLongPtr! */
1689 return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, TRUE);
1690}
LONG NTAPI NtUserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
Definition: window.c:4048

◆ SetWindowLongW()

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

Definition at line 1697 of file class.c.

1701{
1702 /* DO NOT USE NtUserSetWindowLongPtr! */
1703 return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, FALSE);
1704}

◆ SetWindowWord()

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

Definition at line 1656 of file class.c.

1657{
1658 switch(nIndex)
1659 {
1660 case GWLP_ID:
1661 case GWLP_HINSTANCE:
1662 case GWLP_HWNDPARENT:
1663 break;
1664 default:
1665 if (nIndex < 0)
1666 {
1667 WARN("Invalid offset %d\n", nIndex );
1669 return 0;
1670 }
1671 break;
1672 }
1673 /* DO NOT USE NtUserSetWindowLong(Ptr)! */
1674 return NtUserSetWindowWord(hWnd, nIndex, wNewWord);
1675}
WORD NTAPI NtUserSetWindowWord(HWND hWnd, INT Index, WORD NewVal)
Definition: window.c:4123

◆ UnregisterClassA()

BOOL WINAPI UnregisterClassA ( LPCSTR  lpClassName,
HINSTANCE  hInstance 
)

Definition at line 1737 of file class.c.

1740{
1741 UNICODE_STRING ClassName = {0};
1742 BOOL Ret;
1743 LPCWSTR lpszClsVersion;
1744 BOOL ConvertedString = FALSE;
1745
1746 TRACE("class/atom: %s/%04x %p\n",
1747 IS_ATOM(lpClassName) ? NULL : lpClassName,
1748 IS_ATOM(lpClassName) ? lpClassName : 0,
1749 hInstance);
1750
1751 lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, TRUE);
1752 if (lpszClsVersion)
1753 {
1754 RtlInitUnicodeString(&ClassName, lpszClsVersion);
1755 }
1756 else if (!IS_ATOM(lpClassName))
1757 {
1758 ConvertedString = TRUE;
1759 if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, lpClassName))
1760 {
1762 return 0;
1763 }
1764 }
1765 else
1766 {
1767 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1768 }
1769
1770 Ret = NtUserUnregisterClass(&ClassName, hInstance, 0);
1771
1772 if (ConvertedString)
1773 RtlFreeUnicodeString(&ClassName);
1774
1775 return Ret;
1776}
BOOL NTAPI NtUserUnregisterClass(PUNICODE_STRING ClassNameOrAtom, HINSTANCE hInstance, PCLSMENUNAME pClassMenuName)

◆ UnregisterClassW()

BOOL WINAPI UnregisterClassW ( LPCWSTR  lpClassName,
HINSTANCE  hInstance 
)

Definition at line 1783 of file class.c.

1786{
1787 UNICODE_STRING ClassName = {0};
1788 LPCWSTR lpszClsVersion;
1789
1790 TRACE("class/atom: %S/%04x %p\n",
1791 IS_ATOM(lpClassName) ? NULL : lpClassName,
1792 IS_ATOM(lpClassName) ? lpClassName : 0,
1793 hInstance);
1794
1795 lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, FALSE);
1796 if (lpszClsVersion)
1797 {
1798 RtlInitUnicodeString(&ClassName, lpszClsVersion);
1799 }
1800 else if (!IS_ATOM(lpClassName))
1801 {
1802 RtlInitUnicodeString(&ClassName, lpClassName);
1803 }
1804 else
1805 {
1806 ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1807 }
1808
1809 return NtUserUnregisterClass(&ClassName, hInstance, 0);
1810}

◆ 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
210 RtlActivateActivationContextUnsafeFast(&Frame, Contex);
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
255 RtlDeactivateActivationContextUnsafeFast(&Frame);
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:168

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

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( user32  )