ReactOS  0.4.14-dev-337-gf981a68
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 = 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 }
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
NTSYSAPI void WINAPI RtlReleaseActivationContext(HANDLE)
Definition: actctx.c:5272
LPCWSTR is_comctl32_class(const WCHAR *name)
Definition: class.c:46
LONG NTSTATUS
Definition: precomp.h:26
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define MAX_PATH
Definition: compat.h:26
static const WCHAR L[]
Definition: oid.c:1250
NTSYSAPI NTSTATUS WINAPI RtlFindActivationContextSectionString(ULONG, const GUID *, ULONG, const UNICODE_STRING *, PVOID)
Definition: actctx.c:5743
unsigned char BYTE
Definition: mem.h:68
uint32_t DWORD_PTR
Definition: typedefs.h:63
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define IS_ATOM(x)
Definition: class.h:3
#define LOWORD(l)
Definition: pedump.c:82
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)

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 }
UINT style
Definition: winuser.h:3176
LPCSTR lpszMenuName
Definition: winuser.h:3184
HCURSOR hCursor
Definition: winuser.h:3182
WNDPROC lpfnWndProc
Definition: winuser.h:3177
BOOL WINAPI GetClassInfoExA(HINSTANCE hInstance, LPCSTR lpszClass, LPWNDCLASSEXA lpwcx)
Definition: class.c:264
LPCSTR lpszClassName
Definition: winuser.h:3185
int cbClsExtra
Definition: winuser.h:3139
LPCSTR lpszMenuName
Definition: winuser.h:3145
HBRUSH hbrBackground
Definition: winuser.h:3144
int cbWndExtra
Definition: winuser.h:3140
HINSTANCE hInstance
Definition: charmap.c:20
HINSTANCE hInstance
Definition: winuser.h:3180
unsigned int BOOL
Definition: ntddk_ex.h:94
HCURSOR hCursor
Definition: winuser.h:3143
HBRUSH hbrBackground
Definition: winuser.h:3183
int cbWndExtra
Definition: winuser.h:3179
HICON hIcon
Definition: winuser.h:3181
LPCSTR lpszClassName
Definition: winuser.h:3146
UINT style
Definition: winuser.h:3137
int cbClsExtra
Definition: winuser.h:3178
HINSTANCE hInstance
Definition: winuser.h:3141
WNDPROC lpfnWndProc
Definition: winuser.h:3138
HICON hIcon
Definition: winuser.h:3142

Referenced by check_class_(), check_instance_(), check_style(), test_actctx_classes(), test_comctl32_class(), test_GetClassInfo(), test_IME(), and test_instances().

◆ 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 
289  if (hInstance == User32Instance)
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_INVALID_PARAMETER
Definition: compat.h:91
HINSTANCE hLibModule
Definition: sfc.c:23
#define TRUE
Definition: types.h:120
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
uint16_t * PWSTR
Definition: typedefs.h:54
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
HINSTANCE User32Instance
Definition: dllmain.c:27
uint32_t ULONG_PTR
Definition: typedefs.h:63
HINSTANCE hInstance
Definition: charmap.c:20
#define ERROR_NOACCESS
Definition: winerror.h:578
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
Definition: class.c:85
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
const char * LPCSTR
Definition: xmlstorage.h:183
LPCWSTR lpszClassName
Definition: winuser.h:3200
BOOL APIENTRY NtUserGetClassInfo(HINSTANCE hInstance, PUNICODE_STRING ClassName, LPWNDCLASSEXW lpWndClassEx, LPWSTR *ppszMenuName, BOOL bAnsi)
Definition: class.c:2690
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:413
BOOL FASTCALL VersionRegisterClass(PCWSTR pszClass, LPCWSTR lpLibFileName, HANDLE Contex, HMODULE *phLibModule)
Definition: class.c:195
unsigned long DWORD
Definition: ntddk_ex.h:95
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define SetLastError(x)
Definition: compat.h:417
BOOL WINAPI RegisterSystemControls(VOID)
Definition: regcontrol.c:70
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define IS_ATOM(x)
Definition: class.h:3
DWORD RegisterDefaultClasses
Definition: regcontrol.c:13
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define ERROR_CLASS_DOES_NOT_EXIST
Definition: winerror.h:892
#define ERROR_CANNOT_FIND_WND_CLASS
Definition: winerror.h:888

Referenced by GetClassInfoA(), test_extra_values(), test_GetClassInfo(), and test_instances().

◆ 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 
402  if (hInstance == User32Instance)
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
HINSTANCE hLibModule
Definition: sfc.c:23
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
uint16_t * PWSTR
Definition: typedefs.h:54
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
HINSTANCE User32Instance
Definition: dllmain.c:27
uint32_t ULONG_PTR
Definition: typedefs.h:63
HINSTANCE hInstance
Definition: charmap.c:20
#define ERROR_NOACCESS
Definition: winerror.h:578
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
Definition: class.c:85
LPCWSTR lpszClassName
Definition: winuser.h:3200
BOOL APIENTRY NtUserGetClassInfo(HINSTANCE hInstance, PUNICODE_STRING ClassName, LPWNDCLASSEXW lpWndClassEx, LPWSTR *ppszMenuName, BOOL bAnsi)
Definition: class.c:2690
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:413
BOOL FASTCALL VersionRegisterClass(PCWSTR pszClass, LPCWSTR lpLibFileName, HANDLE Contex, HMODULE *phLibModule)
Definition: class.c:195
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:417
BOOL WINAPI RegisterSystemControls(VOID)
Definition: regcontrol.c:70
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define IS_ATOM(x)
Definition: class.h:3
DWORD RegisterDefaultClasses
Definition: regcontrol.c:13
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define ERROR_CLASS_DOES_NOT_EXIST
Definition: winerror.h:892
#define ERROR_CANNOT_FIND_WND_CLASS
Definition: winerror.h:888

Referenced by GetClassInfoW(), test_GetClassInfo(), and test_icons().

◆ 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 }
int cbWndExtra
Definition: winuser.h:3194
UINT style
Definition: winuser.h:3150
LPCWSTR lpszMenuName
Definition: winuser.h:3158
HICON hIcon
Definition: winuser.h:3196
int cbClsExtra
Definition: winuser.h:3152
HINSTANCE hInstance
Definition: charmap.c:20
LPCWSTR lpszMenuName
Definition: winuser.h:3199
unsigned int BOOL
Definition: ntddk_ex.h:94
WNDPROC lpfnWndProc
Definition: winuser.h:3151
LPCWSTR lpszClassName
Definition: winuser.h:3159
int cbClsExtra
Definition: winuser.h:3193
LPCWSTR lpszClassName
Definition: winuser.h:3200
int cbWndExtra
Definition: winuser.h:3153
HBRUSH hbrBackground
Definition: winuser.h:3198
HICON hIcon
Definition: winuser.h:3155
HINSTANCE hInstance
Definition: winuser.h:3195
HCURSOR hCursor
Definition: winuser.h:3197
UINT style
Definition: winuser.h:3191
WNDPROC lpfnWndProc
Definition: winuser.h:3192
HCURSOR hCursor
Definition: winuser.h:3156
HBRUSH hbrBackground
Definition: winuser.h:3157
HINSTANCE hInstance
Definition: winuser.h:3154
BOOL WINAPI GetClassInfoExW(HINSTANCE hInstance, LPCWSTR lpszClass, LPWNDCLASSEXW lpwcx)
Definition: class.c:374

Referenced by ClassTest(), test_comctl32_class(), test_GetClassInfo(), and test_IME().

◆ 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 
817  _SEH2_TRY
818  {
819  Class = DesktopPtrToUser(Wnd->pcls);
820  if (Class != NULL)
821  {
822 #ifdef _WIN64
823  switch (nIndex)
824  {
825  case GCLP_HBRBACKGROUND:
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 }
static const WCHAR Class[]
Definition: cfgmgr.c:39
#define WARN(fmt,...)
Definition: debug.h:111
HWND hWnd
Definition: settings.c:17
#define GCLP_HCURSOR
Definition: winuser.h:668
#define GCLP_WNDPROC
Definition: winuser.h:673
#define GCLP_MENUNAME
Definition: winuser.h:672
_SEH2_TRY
Definition: create.c:4250
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define GCLP_HMODULE
Definition: winuser.h:671
static __inline PVOID DesktopPtrToUser(PVOID Ptr)
Definition: user_x.h:12
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define GCLP_HBRBACKGROUND
Definition: winuser.h:667
smooth NULL
Definition: ftsmooth.c:416
Definition: ntuser.h:533
#define GCLP_HICONSM
Definition: winuser.h:670
#define TRACE(s)
Definition: solgame.cpp:4
static ULONG_PTR FASTCALL IntGetClassLongA(PWND Wnd, PCLS Class, int nIndex)
Definition: class.c:653
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:417
PWND FASTCALL ValidateHwnd(HWND hwnd)
Definition: misc.c:369
#define GCLP_HICON
Definition: winuser.h:669
Definition: ntuser.h:657
_SEH2_END
Definition: create.c:4424
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
PCLS pcls
Definition: ntuser.h:684

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 
873  _SEH2_TRY
874  {
875  Class = DesktopPtrToUser(Wnd->pcls);
876  if (Class != NULL)
877  {
878 #ifdef _WIN64
879  switch (nIndex)
880  {
881  case GCLP_HBRBACKGROUND:
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 const WCHAR Class[]
Definition: cfgmgr.c:39
static ULONG_PTR FASTCALL IntGetClassLongW(PWND Wnd, PCLS Class, int nIndex)
Definition: class.c:728
#define WARN(fmt,...)
Definition: debug.h:111
HWND hWnd
Definition: settings.c:17
#define GCLP_HCURSOR
Definition: winuser.h:668
#define GCLP_WNDPROC
Definition: winuser.h:673
#define GCLP_MENUNAME
Definition: winuser.h:672
_SEH2_TRY
Definition: create.c:4250
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define GCLP_HMODULE
Definition: winuser.h:671
static __inline PVOID DesktopPtrToUser(PVOID Ptr)
Definition: user_x.h:12
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define GCLP_HBRBACKGROUND
Definition: winuser.h:667
smooth NULL
Definition: ftsmooth.c:416
Definition: ntuser.h:533
#define GCLP_HICONSM
Definition: winuser.h:670
#define TRACE(s)
Definition: solgame.cpp:4
unsigned long DWORD
Definition: ntddk_ex.h:95
#define SetLastError(x)
Definition: compat.h:417
PWND FASTCALL ValidateHwnd(HWND hwnd)
Definition: misc.c:369
#define GCLP_HICON
Definition: winuser.h:669
Definition: ntuser.h:657
_SEH2_END
Definition: create.c:4424
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
PCLS pcls
Definition: ntuser.h:684

Referenced by ClassTest().

◆ 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
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
int WINAPI GetClassNameW(HWND hWnd, LPWSTR lpClassName, int nMaxCount)
Definition: class.c:1025
HWND hWnd
Definition: settings.c:17
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
NTSYSAPI NTSTATUS NTAPI RtlUnicodeToMultiByteN(PCHAR MbString, ULONG MbSize, PULONG ResultSize, PCWCH UnicodeString, ULONG UnicodeSize)
GLenum GLsizei len
Definition: glext.h:6722
unsigned int * PULONG
Definition: retypes.h:1
#define IS_ATOM(x)
Definition: class.h:3
_In_ int nMaxCount
Definition: winuser.h:4778

Referenced by test_actctx_classes(), and test_instances().

◆ 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 }
HWND hWnd
Definition: settings.c:17
smooth NULL
Definition: ftsmooth.c:416
_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
#define TRACE(s)
Definition: solgame.cpp:4
__wchar_t WCHAR
Definition: xmlstorage.h:180
INT APIENTRY NtUserGetClassName(IN HWND hWnd, IN BOOL Real, OUT PUNICODE_STRING ClassName)
Definition: class.c:2788
#define IS_ATOM(x)
Definition: class.h:3
_In_ int nMaxCount
Definition: winuser.h:4778

Referenced by ClassTest(), and GetClassNameA().

◆ 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 }
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
GLintptr offset
Definition: glext.h:5920
DWORD WINAPI GetClassLongA(HWND hWnd, int nIndex)
Definition: class.c:805
static __inline PVOID DesktopPtrToUser(PVOID Ptr)
Definition: user_x.h:12
smooth NULL
Definition: ftsmooth.c:416
Definition: ntuser.h:533
unsigned short WORD
Definition: ntddk_ex.h:93
#define SetLastError(x)
Definition: compat.h:417
PWND FASTCALL ValidateHwnd(HWND hwnd)
Definition: misc.c:369
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
Definition: ntuser.h:657
#define ERROR_INVALID_INDEX
Definition: winerror.h:894

◆ GetWindowLongA()

LONG WINAPI GetWindowLongA ( HWND  hWnd,
int  nIndex 
)

Definition at line 1154 of file class.c.

1155 {
1156  return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), FALSE );
1157 }
HWND hWnd
Definition: settings.c:17
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 1164 of file class.c.

1165 {
1166  return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), TRUE );
1167 }
#define TRUE
Definition: types.h:120
HWND hWnd
Definition: settings.c:17
long LONG
Definition: pedump.c:60
LONG_PTR IntGetWindowLong(HWND hwnd, INT offset, UINT size, BOOL unicode)
Definition: class.c:1081

◆ GetWindowWord()

WORD WINAPI GetWindowWord ( HWND  hWnd,
int  nIndex 
)

Definition at line 1199 of file class.c.

1200 {
1201  switch(nIndex)
1202  {
1203  case GWLP_ID:
1204  case GWLP_HINSTANCE:
1205  case GWLP_HWNDPARENT:
1206  break;
1207  default:
1208  if (nIndex < 0)
1209  {
1210  WARN("Invalid offset %d\n", nIndex );
1212  return 0;
1213  }
1214  break;
1215  }
1216  return IntGetWindowLong( hWnd, nIndex, sizeof(WORD), FALSE );
1217 }
#define WARN(fmt,...)
Definition: debug.h:111
HWND hWnd
Definition: settings.c:17
LONG_PTR IntGetWindowLong(HWND hwnd, INT offset, UINT size, BOOL unicode)
Definition: class.c:1081
unsigned short WORD
Definition: ntddk_ex.h:93
#define SetLastError(x)
Definition: compat.h:417
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
#define GWLP_HINSTANCE
Definition: winuser.h:850
#define GWLP_ID
Definition: winuser.h:854
#define GWLP_HWNDPARENT
Definition: winuser.h:852

◆ 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 
679  case GCL_HBRBACKGROUND:
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 ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define TRUE
Definition: types.h:120
#define GCLP_HCURSOR
Definition: winuser.h:668
#define GCLP_WNDPROC
Definition: winuser.h:673
#define GCL_MENUNAME
Definition: winuser.h:664
#define GCW_ATOM
Definition: winuser.h:656
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define GCL_STYLE
Definition: winuser.h:665
#define GCLP_HICONSM
Definition: winuser.h:670
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define GCL_CBWNDEXTRA
Definition: winuser.h:658
#define SetLastError(x)
Definition: compat.h:417
#define GCL_CBCLSEXTRA
Definition: winuser.h:657
#define GCLP_HICON
Definition: winuser.h:669
ULONG_PTR FASTCALL IntGetClsWndProc(PWND pWnd, PCLS Class, BOOL Ansi)
Definition: class.c:536
static __inline PVOID SharedPtrToUser(PVOID Ptr)
Definition: user_x.h:4
#define GCL_HBRBACKGROUND
Definition: winuser.h:659
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
unsigned int ULONG
Definition: retypes.h:1
#define ULONG_PTR
Definition: config.h:101
uint32_t * PULONG_PTR
Definition: typedefs.h:63
#define GCL_HMODULE
Definition: winuser.h:663
HBRUSH WINAPI GetSysColorBrush(_In_ int)

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 
754  case GCLP_HBRBACKGROUND:
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 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define GCLP_HCURSOR
Definition: winuser.h:668
#define GCLP_WNDPROC
Definition: winuser.h:673
#define GCW_ATOM
Definition: winuser.h:656
#define GCLP_MENUNAME
Definition: winuser.h:672
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define GCL_STYLE
Definition: winuser.h:665
#define GCLP_HBRBACKGROUND
Definition: winuser.h:667
#define GCLP_HICONSM
Definition: winuser.h:670
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define GCL_CBWNDEXTRA
Definition: winuser.h:658
#define SetLastError(x)
Definition: compat.h:417
#define GCL_CBCLSEXTRA
Definition: winuser.h:657
#define GCLP_HICON
Definition: winuser.h:669
ULONG_PTR FASTCALL IntGetClsWndProc(PWND pWnd, PCLS Class, BOOL Ansi)
Definition: class.c:536
static __inline PVOID SharedPtrToUser(PVOID Ptr)
Definition: user_x.h:4
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
unsigned int ULONG
Definition: retypes.h:1
#define ULONG_PTR
Definition: config.h:101
uint32_t * PULONG_PTR
Definition: typedefs.h:63
#define GCL_HMODULE
Definition: winuser.h:663
HBRUSH WINAPI GetSysColorBrush(_In_ int)

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 }
#define GETPFNSERVER(fnid)
Definition: ntuser.h:870
#define GETPFNCLIENTW(fnid)
Definition: ntuser.h:867
int32_t INT
Definition: typedefs.h:56
uint32_t ULONG_PTR
Definition: typedefs.h:63
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
ULONG_PTR NTAPI NtUserGetCPD(HWND hWnd, GETCPD Flags, ULONG_PTR Proc)
Definition: callproc.c:176
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define FNID_SWITCH
Definition: ntuser.h:827
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define CSF_SERVERSIDEPROC
Definition: ntuser.h:524
#define GETPFNCLIENTA(fnid)
Definition: ntuser.h:865
#define CSF_ANSIPROC
Definition: ntuser.h:525
#define FNID_GHOST
Definition: ntuser.h:837
#define FNID_BUTTON
Definition: ntuser.h:828
#define ULONG_PTR
Definition: config.h:101
#define FNID_FIRST
Definition: ntuser.h:820

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  }
1138  retvalue = (ULONG_PTR)IntGetWndProc(wndPtr, !unicode);
1139  break;
1140  }
1141  default:
1142  WARN("Unknown offset %d\n", offset );
1144  break;
1145  }
1146  return retvalue;
1147 
1148 }
signed char * PCHAR
Definition: retypes.h:7
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
HWND WINAPI GetAncestor(_In_ HWND, _In_ UINT)
DWORD ExStyle
Definition: ntuser.h:668
HINSTANCE hModule
Definition: ntuser.h:672
#define WARN(fmt,...)
Definition: debug.h:111
GLintptr offset
Definition: glext.h:5920
BOOL FASTCALL TestWindowProcess(PWND)
Definition: misc.c:176
#define GWL_EXSTYLE
Definition: winuser.h:845
uint32_t ULONG_PTR
Definition: typedefs.h:63
ULONG cbwndExtra
Definition: ntuser.h:702
#define ERROR_ACCESS_DENIED
Definition: compat.h:87
DWORD fnid
Definition: ntuser.h:673
#define FNID_DESKTOP
Definition: ntuser.h:824
#define GA_PARENT
Definition: winuser.h:2763
#define GWLP_USERDATA
Definition: treelist.c:63
HWND WINAPI GetDesktopWindow(void)
Definition: window.c:652
UINT_PTR IDMenu
Definition: ntuser.h:695
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
GLsizeiptr size
Definition: glext.h:5919
r parent
Definition: btrfs.c:2869
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define SetLastError(x)
Definition: compat.h:417
HWND WINAPI GetWindow(_In_ HWND, _In_ UINT)
PWND FASTCALL ValidateHwnd(HWND hwnd)
Definition: misc.c:369
#define GWLP_WNDPROC
Definition: treelist.c:66
#define GWL_STYLE
Definition: winuser.h:846
Definition: ntuser.h:657
LONG_PTR dwUserData
Definition: ntuser.h:705
DWORD state
Definition: ntuser.h:665
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
#define GW_OWNER
Definition: winuser.h:761
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
#define GWLP_HINSTANCE
Definition: winuser.h:850
#define ULONG_PTR
Definition: config.h:101
WNDPROC FASTCALL IntGetWndProc(PWND pWnd, BOOL Ansi)
Definition: class.c:589
#define GWLP_ID
Definition: winuser.h:854
#define GWLP_HWNDPARENT
Definition: winuser.h:852
DWORD style
Definition: ntuser.h:670

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;
593  PCLS Class = DesktopPtrToUser(pWnd->pcls);
594 
595  if (!Class) return Ret;
596 
597  if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC)
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 FNID_EDIT
Definition: ntuser.h:832
#define GETPFNSERVER(fnid)
Definition: ntuser.h:870
#define GETPFNCLIENTW(fnid)
Definition: ntuser.h:867
WNDPROC lpfnWndProc
Definition: ntuser.h:682
int32_t INT
Definition: typedefs.h:56
uint32_t ULONG_PTR
Definition: typedefs.h:63
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
static __inline PVOID DesktopPtrToUser(PVOID Ptr)
Definition: user_x.h:12
ULONG_PTR NTAPI NtUserGetCPD(HWND hWnd, GETCPD Flags, ULONG_PTR Proc)
Definition: callproc.c:176
Definition: ntuser.h:533
#define UserHMGetHandle(obj)
Definition: ntuser.h:208
#define FNID_SWITCH
Definition: ntuser.h:827
#define GETPFNCLIENTA(fnid)
Definition: ntuser.h:865
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2880
#define FNID_GHOST
Definition: ntuser.h:837
#define WNDS_ANSIWINDOWPROC
Definition: ntuser.h:592
#define FNID_BUTTON
Definition: ntuser.h:828
DWORD state
Definition: ntuser.h:665
#define WNDS_SERVERSIDEWINDOWPROC
Definition: ntuser.h:591
#define FNID_FIRST
Definition: ntuser.h:820
PCLS pcls
Definition: ntuser.h:684

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

Referenced by ClassNameToVersion().

◆ RealGetWindowClassA()

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

Definition at line 1244 of file class.c.

1248 {
1249  WCHAR tmpbuf[MAX_ATOM_LEN + 1];
1250  UINT len;
1251 
1252  if ((INT)cchType <= 0) return 0;
1253  if (!RealGetWindowClassW( hwnd, tmpbuf, sizeof(tmpbuf)/sizeof(WCHAR) )) return 0;
1254  RtlUnicodeToMultiByteN( pszType, cchType - 1, (PULONG)&len, tmpbuf, strlenW(tmpbuf) * sizeof(WCHAR) );
1255  pszType[len] = 0;
1256  return len;
1257 }
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define MAX_ATOM_LEN
Definition: dde_private.h:30
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
int32_t INT
Definition: typedefs.h:56
UINT WINAPI RealGetWindowClassW(HWND hwnd, LPWSTR pszType, UINT cchType)
Definition: class.c:1224
__wchar_t WCHAR
Definition: xmlstorage.h:180
NTSYSAPI NTSTATUS NTAPI RtlUnicodeToMultiByteN(PCHAR MbString, ULONG MbSize, PULONG ResultSize, PCWCH UnicodeString, ULONG UnicodeSize)
GLenum GLsizei len
Definition: glext.h:6722
unsigned int * PULONG
Definition: retypes.h:1
unsigned int UINT
Definition: ndis.h:50

◆ RealGetWindowClassW()

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

Definition at line 1224 of file class.c.

1228 {
1229  UNICODE_STRING ClassName;
1230 
1231  RtlInitEmptyUnicodeString(&ClassName,
1232  pszType,
1233  cchType * sizeof(WCHAR));
1234 
1235  return NtUserGetClassName(hwnd,TRUE,&ClassName);
1236 }
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define TRUE
Definition: types.h:120
__wchar_t WCHAR
Definition: xmlstorage.h:180
INT APIENTRY NtUserGetClassName(IN HWND hWnd, IN BOOL Real, OUT PUNICODE_STRING ClassName)
Definition: class.c:2788

Referenced by RealGetWindowClassA().

◆ RegisterClassA()

ATOM WINAPI RegisterClassA ( CONST WNDCLASSA lpWndClass)

Definition at line 1591 of file class.c.

1592 {
1594 
1595  if (lpWndClass == NULL)
1596  return 0;
1597 
1598  /* These MUST be copied manually, since on 64 bit architectures the
1599  alignment of the members is different between the 2 structs! */
1600  Class.style = lpWndClass->style;
1601  Class.lpfnWndProc = lpWndClass->lpfnWndProc;
1602  Class.cbClsExtra = lpWndClass->cbClsExtra;
1603  Class.cbWndExtra = lpWndClass->cbWndExtra;
1604  Class.hInstance = lpWndClass->hInstance;
1605  Class.hIcon = lpWndClass->hIcon;
1606  Class.hCursor = lpWndClass->hCursor;
1607  Class.hbrBackground = lpWndClass->hbrBackground;
1608  Class.lpszMenuName = lpWndClass->lpszMenuName;
1609  Class.lpszClassName = lpWndClass->lpszClassName;
1610 
1611  Class.cbSize = sizeof(WNDCLASSEXA);
1612  Class.hIconSm = NULL;
1613 
1614  return RegisterClassExA(&Class);
1615 }
static const WCHAR Class[]
Definition: cfgmgr.c:39
struct _WNDCLASSEXA WNDCLASSEXA
ATOM WINAPI RegisterClassExA(CONST WNDCLASSEXA *lpwcx)
Definition: class.c:1528
smooth NULL
Definition: ftsmooth.c:416

Referenced by test_actctx_classes(), and test_instances().

◆ RegisterClassExA()

ATOM WINAPI RegisterClassExA ( CONST WNDCLASSEXA lpwcx)

Definition at line 1528 of file class.c.

1529 {
1530  RTL_ATOM Atom;
1533  WCHAR cname[MAX_BUFFER_LEN];
1534 
1535  RtlCopyMemory(&WndClass, lpwcx, sizeof(WNDCLASSEXA));
1536 
1537  if (WndClass.lpszMenuName != NULL)
1538  {
1539  if (!IS_INTRESOURCE(WndClass.lpszMenuName))
1540  {
1541  if (WndClass.lpszMenuName[0])
1542  {
1543  if (!MultiByteToWideChar( CP_ACP, 0, lpwcx->lpszMenuName, -1, mname, MAX_ATOM_LEN + 1 )) return 0;
1544 
1545  WndClass.lpszMenuName = mname;
1546  }
1547  }
1548  }
1549 
1550  if (!IS_ATOM(WndClass.lpszClassName))
1551  {
1552  if (!MultiByteToWideChar( CP_ACP, 0, lpwcx->lpszClassName, -1, cname, MAX_ATOM_LEN + 1 )) return 0;
1553 
1554  WndClass.lpszClassName = cname;
1555  }
1556 
1558  0,
1559  0,
1560  CSF_ANSIPROC,
1561  TRUE);
1562 
1563  TRACE("A atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
1564  Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1565  lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
1566 
1567  return (ATOM)Atom;
1568 }
#define MAX_ATOM_LEN
Definition: dde_private.h:30
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
unsigned short RTL_ATOM
Definition: atom.c:42
WORD ATOM
Definition: dimm.idl:113
#define CP_ACP
Definition: compat.h:99
#define MAX_BUFFER_LEN
Definition: dde_private.h:34
_Out_ RTL_ATOM * Atom
Definition: class.h:54
const char * mname
Definition: cmds.c:37
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define CSF_ANSIPROC
Definition: ntuser.h:525
ATOM WINAPI RegisterClassExWOWW(WNDCLASSEXW *lpwcx, LPDWORD pdwWowData, WORD fnID, DWORD dwFlags, BOOL ChkRegCls)
Definition: class.c:1411
#define MultiByteToWideChar
Definition: compat.h:100
#define IS_ATOM(x)
Definition: class.h:3
WCHAR WndClass[]
Definition: capicon.c:23

Referenced by RegisterClassA(), RegisterTestDialog(), test_builtinproc(), and test_instances().

◆ RegisterClassExW()

ATOM WINAPI RegisterClassExW ( CONST WNDCLASSEXW lpwcx)

Definition at line 1574 of file class.c.

1575 {
1576  ATOM Atom;
1577 
1578  Atom = RegisterClassExWOWW( (WNDCLASSEXW *)lpwcx, 0, 0, 0, TRUE);
1579 
1580  TRACE("W atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d\n",
1581  Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1582  lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra);
1583 
1584  return Atom;
1585 }
#define TRUE
Definition: types.h:120
WORD ATOM
Definition: dimm.idl:113
_Out_ RTL_ATOM * Atom
Definition: class.h:54
#define TRACE(s)
Definition: solgame.cpp:4
ATOM WINAPI RegisterClassExWOWW(WNDCLASSEXW *lpwcx, LPDWORD pdwWowData, WORD fnID, DWORD dwFlags, BOOL ChkRegCls)
Definition: class.c:1411

Referenced by RegisterClassW(), test_builtinproc(), and test_icons().

◆ RegisterClassExWOWW()

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

Definition at line 1411 of file class.c.

1416 {
1417  ATOM Atom;
1419  UNICODE_STRING ClassName;
1420  UNICODE_STRING ClassVersion;
1421  UNICODE_STRING MenuName = {0};
1422  CLSMENUNAME clsMenuName;
1423  ANSI_STRING AnsiMenuName;
1424  LPCWSTR lpszClsVersion;
1425 
1426  if (lpwcx == NULL || lpwcx->cbSize != sizeof(WNDCLASSEXW) ||
1427  lpwcx->cbClsExtra < 0 || lpwcx->cbWndExtra < 0 ||
1428  lpwcx->lpszClassName == NULL)
1429  {
1430  TRACE("RegisterClassExWOWW Invalid Parameter Error!\n");
1432  return 0;
1433  }
1434 
1435  if (ChkRegCls)
1436  {
1438  }
1439  /*
1440  * On real Windows this looks more like:
1441  * if (lpwcx->hInstance == User32Instance &&
1442  * *(PULONG)((ULONG_PTR)NtCurrentTeb() + 0x6D4) & 0x400)
1443  * But since I have no idea what the magic field in the
1444  * TEB structure means, I rather decided to omit that.
1445  * -- Filip Navara
1446 
1447  GetWin32ClientInfo()->dwExpWinVer & (WINVER == 0x400)
1448  */
1449  if (lpwcx->hInstance == User32Instance)
1450  {
1451  TRACE("RegisterClassExWOWW User32Instance!\n");
1453  return 0;
1454  }
1455  /* Yes, this is correct. We should modify the passed structure. */
1456  if (lpwcx->hInstance == NULL)
1457  ((WNDCLASSEXW*)lpwcx)->hInstance = GetModuleHandleW(NULL);
1458 
1459  RtlCopyMemory(&WndClass, lpwcx, sizeof(WNDCLASSEXW));
1460 /*
1461  if (NULL == WndClass.hIconSm)
1462  {
1463  WndClass.hIconSm = CreateSmallIcon(WndClass.hIcon);
1464  }
1465 */
1466  RtlInitEmptyAnsiString(&AnsiMenuName, NULL, 0);
1467  if (WndClass.lpszMenuName != NULL)
1468  {
1469  if (!IS_INTRESOURCE(WndClass.lpszMenuName))
1470  {
1471  if (WndClass.lpszMenuName[0])
1472  {
1473  RtlInitUnicodeString(&MenuName, WndClass.lpszMenuName);
1474  RtlUnicodeStringToAnsiString( &AnsiMenuName, &MenuName, TRUE);
1475  }
1476  }
1477  else
1478  {
1479  MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
1480  AnsiMenuName.Buffer = (PCHAR)WndClass.lpszMenuName;
1481  }
1482  }
1483 
1484  if (IS_ATOM(WndClass.lpszClassName))
1485  {
1486  ClassName.Length =
1487  ClassName.MaximumLength = 0;
1488  ClassName.Buffer = (LPWSTR)WndClass.lpszClassName;
1489  }
1490  else
1491  {
1492  RtlInitUnicodeString(&ClassName, WndClass.lpszClassName);
1493  }
1494 
1495  ClassVersion = ClassName;
1496  if (fnID == 0)
1497  {
1498  lpszClsVersion = ClassNameToVersion(lpwcx->lpszClassName, NULL, NULL, NULL, FALSE);
1499  if (lpszClsVersion)
1500  {
1501  RtlInitUnicodeString(&ClassVersion, lpszClsVersion);
1502  }
1503  }
1504 
1505  clsMenuName.pszClientAnsiMenuName = AnsiMenuName.Buffer;
1506  clsMenuName.pwszClientUnicodeMenuName = MenuName.Buffer;
1507  clsMenuName.pusMenuName = &MenuName;
1508 
1510  &ClassName,
1511  &ClassVersion,
1512  &clsMenuName,
1513  fnID,
1514  dwFlags,
1515  pdwWowData);
1516 
1517  TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
1518  Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
1519  lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
1520 
1521  return Atom;
1522 }
signed char * PCHAR
Definition: retypes.h:7
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
int cbWndExtra
Definition: winuser.h:3194
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
USHORT MaximumLength
Definition: env_spec_w32.h:370
LPSTR pszClientAnsiMenuName
Definition: ntuser.h:466
WORD ATOM
Definition: dimm.idl:113
LPWSTR pwszClientUnicodeMenuName
Definition: ntuser.h:467
_Out_ RTL_ATOM * Atom
Definition: class.h:54
HINSTANCE User32Instance
Definition: dllmain.c:27
smooth NULL
Definition: ftsmooth.c:416
LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
Definition: class.c:85
int cbClsExtra
Definition: winuser.h:3193
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
LPCWSTR lpszClassName
Definition: winuser.h:3200
#define TRACE(s)
Definition: solgame.cpp:4
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
HBRUSH hbrBackground
Definition: winuser.h:3198
UINT cbSize
Definition: winuser.h:3190
#define SetLastError(x)
Definition: compat.h:417
HINSTANCE hInstance
Definition: winuser.h:3195
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
UINT style
Definition: winuser.h:3191
WNDPROC lpfnWndProc
Definition: winuser.h:3192
PUNICODE_STRING pusMenuName
Definition: ntuser.h:468
RTL_ATOM APIENTRY NtUserRegisterClassExWOW(WNDCLASSEXW *lpwcx, PUNICODE_STRING ClassName, PUNICODE_STRING ClsVersion, PCLSMENUNAME pClassMenuName, DWORD fnID, DWORD Flags, LPDWORD pWow)
Definition: class.c:2383
BOOL WINAPI RegisterSystemControls(VOID)
Definition: regcontrol.c:70
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:847
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define IS_ATOM(x)
Definition: class.h:3
DWORD RegisterDefaultClasses
Definition: regcontrol.c:13
WCHAR * LPWSTR
Definition: xmlstorage.h:184
WCHAR WndClass[]
Definition: capicon.c:23

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

◆ RegisterClassW()

ATOM WINAPI RegisterClassW ( CONST WNDCLASSW lpWndClass)

Definition at line 1621 of file class.c.

1622 {
1624 
1625  if (lpWndClass == NULL)
1626  return 0;
1627 
1628  /* These MUST be copied manually, since on 64 bit architectures the
1629  alignment of the members is different between the 2 structs! */
1630  Class.style = lpWndClass->style;
1631  Class.lpfnWndProc = lpWndClass->lpfnWndProc;
1632  Class.cbClsExtra = lpWndClass->cbClsExtra;
1633  Class.cbWndExtra = lpWndClass->cbWndExtra;
1634  Class.hInstance = lpWndClass->hInstance;
1635  Class.hIcon = lpWndClass->hIcon;
1636  Class.hCursor = lpWndClass->hCursor;
1637  Class.hbrBackground = lpWndClass->hbrBackground;
1638  Class.lpszMenuName = lpWndClass->lpszMenuName;
1639  Class.lpszClassName = lpWndClass->lpszClassName;
1640 
1641  Class.cbSize = sizeof(WNDCLASSEXW);
1642  Class.hIconSm = NULL;
1643 
1644  return RegisterClassExW(&Class);
1645 }
static const WCHAR Class[]
Definition: cfgmgr.c:39
struct _WNDCLASSEXW WNDCLASSEXW
smooth NULL
Definition: ftsmooth.c:416
ATOM WINAPI RegisterClassExW(CONST WNDCLASSEXW *lpwcx)
Definition: class.c:1574

Referenced by ClassTest().

◆ SetClassLongA()

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

Definition at line 1652 of file class.c.

1655 {
1656  PSTR lpStr = (PSTR)(ULONG_PTR)dwNewLong;
1657  UNICODE_STRING Value = {0};
1658  BOOL Allocated = FALSE;
1659  DWORD Ret;
1660 
1661  /* FIXME - portability!!!! */
1662 
1663  if (nIndex == GCL_MENUNAME && lpStr != NULL)
1664  {
1665  if (!IS_INTRESOURCE(lpStr))
1666  {
1668  lpStr))
1669  {
1671  return 0;
1672  }
1673 
1674  Allocated = TRUE;
1675  }
1676  else
1677  Value.Buffer = (PWSTR)lpStr;
1678 
1679  dwNewLong = (LONG_PTR)&Value;
1680  }
1681  else if (nIndex == GCW_ATOM && lpStr != NULL)
1682  {
1683  if (!IS_ATOM(lpStr))
1684  {
1686  lpStr))
1687  {
1689  return 0;
1690  }
1691 
1692  Allocated = TRUE;
1693  }
1694  else
1695  Value.Buffer = (PWSTR)lpStr;
1696 
1697  dwNewLong = (LONG_PTR)&Value;
1698  }
1699 
1700  Ret = (DWORD)NtUserSetClassLong(hWnd,
1701  nIndex,
1702  dwNewLong,
1703  TRUE);
1704 
1705  if (Allocated)
1706  {
1708  }
1709 
1710  return Ret;
1711 }
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2343
#define LONG_PTR
Definition: treelist.c:79
#define TRUE
Definition: types.h:120
uint16_t * PWSTR
Definition: typedefs.h:54
HWND hWnd
Definition: settings.c:17
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define GCL_MENUNAME
Definition: winuser.h:664
#define DWORD
Definition: nt_native.h:44
#define GCW_ATOM
Definition: winuser.h:656
uint32_t ULONG_PTR
Definition: typedefs.h:63
unsigned int BOOL
Definition: ntddk_ex.h:94
IN PFCB IN VBO OUT PLBO OUT PULONG OUT PBOOLEAN Allocated
Definition: fatprocs.h:297
smooth NULL
Definition: ftsmooth.c:416
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
ULONG_PTR APIENTRY NtUserSetClassLong(HWND hWnd, INT Offset, ULONG_PTR dwNewLong, BOOL Ansi)
Definition: class.c:2545
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
unsigned long DWORD
Definition: ntddk_ex.h:95
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define SetLastError(x)
Definition: compat.h:417
signed char * PSTR
Definition: retypes.h:7
#define IS_ATOM(x)
Definition: class.h:3

Referenced by test_instances().

◆ SetClassLongW()

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

Definition at line 1719 of file class.c.

1722 {
1723  PWSTR lpStr = (PWSTR)(ULONG_PTR)dwNewLong;
1724  UNICODE_STRING Value = {0};
1725 
1726  TRACE("%p %d %lx\n", hWnd, nIndex, dwNewLong);
1727 
1728  /* FIXME - portability!!!! */
1729 
1730  if (nIndex == GCL_MENUNAME && lpStr != NULL)
1731  {
1732  if (!IS_INTRESOURCE(lpStr))
1733  {
1735  lpStr);
1736  }
1737  else
1738  Value.Buffer = lpStr;
1739 
1740  dwNewLong = (LONG_PTR)&Value;
1741  }
1742  else if (nIndex == GCW_ATOM && lpStr != NULL)
1743  {
1744  if (!IS_ATOM(lpStr))
1745  {
1747  lpStr);
1748  }
1749  else
1750  Value.Buffer = lpStr;
1751 
1752  dwNewLong = (LONG_PTR)&Value;
1753  }
1754 
1755  return (DWORD)NtUserSetClassLong(hWnd,
1756  nIndex,
1757  dwNewLong,
1758  FALSE);
1759 }
_In_opt_ ULONG _Out_ PULONG Value
Definition: rtlfuncs.h:2343
#define LONG_PTR
Definition: treelist.c:79
uint16_t * PWSTR
Definition: typedefs.h:54
HWND hWnd
Definition: settings.c:17
#define GCL_MENUNAME
Definition: winuser.h:664
#define GCW_ATOM
Definition: winuser.h:656
uint32_t ULONG_PTR
Definition: typedefs.h:63
smooth NULL
Definition: ftsmooth.c:416
ULONG_PTR APIENTRY NtUserSetClassLong(HWND hWnd, INT Offset, ULONG_PTR dwNewLong, BOOL Ansi)
Definition: class.c:2545
#define TRACE(s)
Definition: solgame.cpp:4
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
unsigned long DWORD
Definition: ntddk_ex.h:95
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define IS_ATOM(x)
Definition: class.h:3

Referenced by ClassTest(), and SetClassWord().

◆ SetClassWord()

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

Definition at line 1794 of file class.c.

1801 {
1802  if ((nIndex < 0) && (nIndex != GCW_ATOM))
1803  return 0;
1804 
1805  return (WORD) SetClassLongW ( hWnd, nIndex, wNewWord );
1806 }
HWND hWnd
Definition: settings.c:17
#define GCW_ATOM
Definition: winuser.h:656
unsigned short WORD
Definition: ntddk_ex.h:93
DWORD WINAPI SetClassLongW(HWND hWnd, int nIndex, LONG dwNewLong)
Definition: class.c:1719

◆ SetWindowLongA()

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

Definition at line 1839 of file class.c.

1843 {
1844  return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, TRUE);
1845 }
#define TRUE
Definition: types.h:120
HWND hWnd
Definition: settings.c:17
LONG NTAPI NtUserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
Definition: window.c:3853

◆ SetWindowLongW()

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

Definition at line 1852 of file class.c.

1856 {
1857  return NtUserSetWindowLong(hWnd, nIndex, dwNewLong, FALSE);
1858 }
HWND hWnd
Definition: settings.c:17
LONG NTAPI NtUserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
Definition: window.c:3853

◆ SetWindowWord()

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

Definition at line 1813 of file class.c.

1814 {
1815  switch(nIndex)
1816  {
1817  case GWLP_ID:
1818  case GWLP_HINSTANCE:
1819  case GWLP_HWNDPARENT:
1820  break;
1821  default:
1822  if (nIndex < 0)
1823  {
1824  WARN("Invalid offset %d\n", nIndex );
1826  return 0;
1827  }
1828  break;
1829  }
1830  return NtUserSetWindowLong( hWnd, nIndex, wNewWord, FALSE );
1831 }
#define WARN(fmt,...)
Definition: debug.h:111
HWND hWnd
Definition: settings.c:17
#define SetLastError(x)
Definition: compat.h:417
#define ERROR_INVALID_INDEX
Definition: winerror.h:894
#define GWLP_HINSTANCE
Definition: winuser.h:850
LONG NTAPI NtUserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
Definition: window.c:3853
#define GWLP_ID
Definition: winuser.h:854
#define GWLP_HWNDPARENT
Definition: winuser.h:852

◆ UnregisterClassA()

BOOL WINAPI UnregisterClassA ( LPCSTR  lpClassName,
HINSTANCE  hInstance 
)

Definition at line 1891 of file class.c.

1894 {
1895  UNICODE_STRING ClassName = {0};
1896  BOOL Ret;
1897  LPCWSTR lpszClsVersion;
1898  BOOL ConvertedString = FALSE;
1899 
1900  TRACE("class/atom: %s/%04x %p\n",
1901  IS_ATOM(lpClassName) ? NULL : lpClassName,
1902  IS_ATOM(lpClassName) ? lpClassName : 0,
1903  hInstance);
1904 
1905  lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, TRUE);
1906  if (lpszClsVersion)
1907  {
1908  RtlInitUnicodeString(&ClassName, lpszClsVersion);
1909  }
1910  else if (!IS_ATOM(lpClassName))
1911  {
1912  ConvertedString = TRUE;
1913  if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, lpClassName))
1914  {
1916  return 0;
1917  }
1918  }
1919  else
1920  {
1921  ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1922  }
1923 
1924  Ret = NtUserUnregisterClass(&ClassName, hInstance, 0);
1925 
1926  if (ConvertedString)
1927  RtlFreeUnicodeString(&ClassName);
1928 
1929  return Ret;
1930 }
#define TRUE
Definition: types.h:120
BOOL APIENTRY NtUserUnregisterClass(IN PUNICODE_STRING ClassNameOrAtom, IN HINSTANCE hInstance, OUT PCLSMENUNAME pClassMenuName)
Definition: class.c:2656
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
uint16_t * PWSTR
Definition: typedefs.h:54
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
uint32_t ULONG_PTR
Definition: typedefs.h:63
HINSTANCE hInstance
Definition: charmap.c:20
unsigned int BOOL
Definition: ntddk_ex.h:94
smooth NULL
Definition: ftsmooth.c:416
LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
Definition: class.c:85
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
#define TRACE(s)
Definition: solgame.cpp:4
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
#define SetLastError(x)
Definition: compat.h:417
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define IS_ATOM(x)
Definition: class.h:3

Referenced by check_instance_(), test_actctx_classes(), test_builtinproc(), and test_instances().

◆ UnregisterClassW()

BOOL WINAPI UnregisterClassW ( LPCWSTR  lpClassName,
HINSTANCE  hInstance 
)

Definition at line 1938 of file class.c.

1941 {
1942  UNICODE_STRING ClassName = {0};
1943  LPCWSTR lpszClsVersion;
1944 
1945  TRACE("class/atom: %S/%04x %p\n",
1946  IS_ATOM(lpClassName) ? NULL : lpClassName,
1947  IS_ATOM(lpClassName) ? lpClassName : 0,
1948  hInstance);
1949 
1950  lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, FALSE);
1951  if (lpszClsVersion)
1952  {
1953  RtlInitUnicodeString(&ClassName, lpszClsVersion);
1954  }
1955  else if (!IS_ATOM(lpClassName))
1956  {
1957  RtlInitUnicodeString(&ClassName, lpClassName);
1958  }
1959  else
1960  {
1961  ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
1962  }
1963 
1964  return NtUserUnregisterClass(&ClassName, hInstance, 0);
1965 }
BOOL APIENTRY NtUserUnregisterClass(IN PUNICODE_STRING ClassNameOrAtom, IN HINSTANCE hInstance, OUT PCLSMENUNAME pClassMenuName)
Definition: class.c:2656
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
uint16_t * PWSTR
Definition: typedefs.h:54
uint32_t ULONG_PTR
Definition: typedefs.h:63
HINSTANCE hInstance
Definition: charmap.c:20
smooth NULL
Definition: ftsmooth.c:416
LPCWSTR FASTCALL ClassNameToVersion(const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
Definition: class.c:85
#define TRACE(s)
Definition: solgame.cpp:4
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define IS_ATOM(x)
Definition: class.h:3

Referenced by ClassTest(), and test_icons().

◆ 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 
212  _SEH2_TRY
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  }
241  _SEH2_END
242 
243 Error_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 }
HINSTANCE hLibModule
Definition: sfc.c:23
#define WARN(fmt,...)
Definition: debug.h:111
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
_SEH2_TRY
Definition: create.c:4250
unsigned int BOOL
Definition: ntddk_ex.h:94
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define LoadLibraryW(x)
Definition: compat.h:412
smooth NULL
Definition: ftsmooth.c:416
#define FreeLibrary(x)
Definition: compat.h:413
#define _SEH2_YIELD(STMT_)
Definition: pseh2_64.h:8
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MAX_PATH
Definition: compat.h:26
unsigned long DWORD
Definition: ntddk_ex.h:95
PRTL_ACTIVATION_CONTEXT_STACK_FRAME FASTCALL RtlDeactivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame)
Definition: actctx.c:5939
#define SetLastError(x)
Definition: compat.h:417
uint32_t DWORD_PTR
Definition: typedefs.h:63
#define ERR(fmt,...)
Definition: debug.h:109
_SEH2_END
Definition: create.c:4424
PRTL_ACTIVATION_CONTEXT_STACK_FRAME FASTCALL RtlActivateActivationContextUnsafeFast(IN PRTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame, IN PVOID Context)
Definition: actctx.c:5862
#define GetProcAddress(x, y)
Definition: compat.h:418
#define IS_ATOM(x)
Definition: class.h:3
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
#define LOWORD(l)
Definition: pedump.c:82

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

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( user32  )