ReactOS 0.4.15-dev-8116-gf69e256
class.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _WNDPROC_INFO
 

Macros

#define IS_ATOM(x)    (((ULONG_PTR)(x) > 0x0) && ((ULONG_PTR)(x) < 0x10000))
 

Typedefs

typedef struct _WNDPROC_INFO WNDPROC_INFO
 
typedef struct _WNDPROC_INFOPWNDPROC_INFO
 

Functions

static __inline BOOL IsCallProcHandle (IN WNDPROC lpWndProc)
 
BOOLEAN DestroyCallProc (_Inout_ PVOID Object)
 
PCALLPROCDATA CreateCallProc (IN PDESKTOP Desktop, IN WNDPROC WndProc, IN BOOL Unicode, IN PPROCESSINFO pi)
 
BOOL UserGetCallProcInfo (IN HANDLE hCallProc, OUT PWNDPROC_INFO wpInfo)
 
void FASTCALL DestroyProcessClasses (PPROCESSINFO Process)
 
VOID IntDereferenceClass (IN OUT PCLS Class, IN PDESKTOPINFO Desktop, IN PPROCESSINFO pi)
 
PCLS IntGetAndReferenceClass (PUNICODE_STRING ClassName, HINSTANCE hInstance, BOOL bDesktopThread)
 
BOOL FASTCALL UserRegisterSystemClasses (VOID)
 
VOID UserAddCallProcToClass (IN OUT PCLS Class, IN PCALLPROCDATA CallProc)
 
 _Success_ (return) BOOL NTAPI IntGetAtomFromStringOrAtom(_In_ PUNICODE_STRING ClassName
 
BOOL IntCheckProcessDesktopClasses (IN PDESKTOP Desktop, IN BOOL FreeOnFailure)
 
ULONG_PTR FASTCALL UserGetCPD (PVOID, GETCPD, ULONG_PTR)
 
_Must_inspect_result_ NTSTATUS NTAPI ProbeAndCaptureUnicodeStringOrAtom (_Out_ _When_(return >=0, _At_(pustrOut->Buffer, _Post_ _Notnull_)) PUNICODE_STRING pustrOut, __in_data_source(USER_MODE) _In_ PUNICODE_STRING pustrUnsafe)
 
BOOL FASTCALL LookupFnIdToiCls (int FnId, int *iCls)
 
INT UserGetClassName (IN PCLS Class, IN OUT PUNICODE_STRING ClassName, IN RTL_ATOM Atom, IN BOOL Ansi)
 

Variables

_Out_ RTL_ATOMAtom
 

Macro Definition Documentation

◆ IS_ATOM

#define IS_ATOM (   x)     (((ULONG_PTR)(x) > 0x0) && ((ULONG_PTR)(x) < 0x10000))

Definition at line 3 of file class.h.

Typedef Documentation

◆ PWNDPROC_INFO

◆ WNDPROC_INFO

Function Documentation

◆ _Success_()

_Success_ ( return  )

◆ CreateCallProc()

PCALLPROCDATA CreateCallProc ( IN PDESKTOP  Desktop,
IN WNDPROC  WndProc,
IN BOOL  Unicode,
IN PPROCESSINFO  pi 
)

Definition at line 29 of file callproc.c.

33{
34 PCALLPROCDATA NewCallProc;
36
37 /* We can send any thread pointer to the object manager here,
38 * What's important is the process info */
40 Desktop,
41 pi->ptiList,
42 &Handle,
44 sizeof(CALLPROCDATA));
45 if (NewCallProc != NULL)
46 {
47 NewCallProc->pfnClientPrevious = WndProc;
48 NewCallProc->wType |= Unicode ? UserGetCPDA2U : UserGetCPDU2A ;
49 NewCallProc->spcpdNext = NULL;
50
51 /* Release the extra reference (UserCreateObject added 2 references) */
52 UserDereferenceObject(NewCallProc);
53 }
54
55 return NewCallProc;
56}
#define NULL
Definition: types.h:112
ULONG Handle
Definition: gdb_input.c:15
@ UserGetCPDU2A
Definition: ntuser.h:541
@ UserGetCPDA2U
Definition: ntuser.h:540
struct _CALLPROCDATA * PCALLPROCDATA
@ TYPE_CALLPROC
Definition: ntuser.h:47
static refpint_t pi[]
Definition: server.c:96
LRESULT CALLBACK WndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
Definition: solitaire.cpp:614
GETCPD wType
Definition: ntuser.h:553
WNDPROC pfnClientPrevious
Definition: ntuser.h:552
struct _CALLPROCDATA * spcpdNext
Definition: ntuser.h:551
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644
PUSER_HANDLE_TABLE gHandleTable
Definition: object.c:13
PVOID FASTCALL UserCreateObject(PUSER_HANDLE_TABLE ht, PDESKTOP pDesktop, PTHREADINFO pti, HANDLE *h, HANDLE_TYPE type, ULONG size)
Definition: object.c:568

Referenced by IntCreateWindow(), and UserGetCPD().

◆ DestroyCallProc()

BOOLEAN DestroyCallProc ( _Inout_ PVOID  Object)

Definition at line 22 of file callproc.c.

23{
25 return TRUE;
26}
#define TRUE
Definition: types.h:120
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
_Must_inspect_result_ _In_ WDFCOLLECTION _In_ WDFOBJECT Object
BOOL FASTCALL UserDeleteObject(HANDLE h, HANDLE_TYPE type)
Definition: object.c:717

Referenced by IntDestroyClass().

◆ DestroyProcessClasses()

void FASTCALL DestroyProcessClasses ( PPROCESSINFO  Process)

Definition at line 303 of file class.c.

304{
305 PCLS Class;
307
308 if (pi != NULL)
309 {
310 /* Free all local classes */
311 Class = pi->pclsPrivateList;
312 while (Class != NULL)
313 {
314 pi->pclsPrivateList = Class->pclsNext;
315
316 ASSERT(Class->pclsBase == Class);
318
319 Class = pi->pclsPrivateList;
320 }
321
322 /* Free all global classes */
323 Class = pi->pclsPublicList;
324 while (Class != NULL)
325 {
326 pi->pclsPublicList = Class->pclsNext;
327
328 ASSERT(Class->pclsBase == Class);
330
331 Class = pi->pclsPublicList;
332 }
333 }
334}
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
#define ASSERT(a)
Definition: mode.c:44
struct _PROCESSINFO * PPROCESSINFO
Definition: ntwin32.h:5
Definition: ntuser.h:566
static VOID IntDestroyClass(IN OUT PCLS Class)
Definition: class.c:231

Referenced by ExitThreadCallback().

◆ IntCheckProcessDesktopClasses()

BOOL IntCheckProcessDesktopClasses ( IN PDESKTOP  Desktop,
IN BOOL  FreeOnFailure 
)

Definition at line 1015 of file class.c.

1017{
1019 BOOL Ret = TRUE;
1020
1022
1023 /* Check all local classes */
1025 &pi->pclsPrivateList,
1026 FreeOnFailure,
1027 &Ret);
1028
1029 /* Check all global classes */
1031 &pi->pclsPublicList,
1032 FreeOnFailure,
1033 &Ret);
1034 if (!Ret)
1035 {
1036 ERR("Failed to move process classes from desktop 0x%p to the shared heap!\n", Desktop);
1038 }
1039
1040 return Ret;
1041}
#define ERR(fmt,...)
Definition: debug.h:113
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
unsigned int BOOL
Definition: ntddk_ex.h:94
struct _PROCESSINFO * GetW32ProcessInfo(VOID)
Definition: misc.c:799
static VOID IntCheckDesktopClasses(IN PDESKTOP Desktop, IN OUT PCLS *ClassList, IN BOOL FreeOnFailure, OUT BOOL *Ret)
Definition: class.c:946
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22

Referenced by IntSetThreadDesktop().

◆ IntDereferenceClass()

VOID IntDereferenceClass ( IN OUT PCLS  Class,
IN PDESKTOPINFO  Desktop,
IN PPROCESSINFO  pi 
)

Definition at line 818 of file class.c.

821{
822 PCLS *PrevLink, BaseClass, CurrentClass;
823
824 ASSERT(Class->cWndReferenceCount >= 1);
825
826 BaseClass = Class->pclsBase;
827
828 if (--Class->cWndReferenceCount == 0)
829 {
830 if (BaseClass == Class)
831 {
832 ASSERT(Class->pclsBase == Class);
833
834 TRACE("IntDereferenceClass 0x%p\n", Class);
835 /* Check if there are clones of the class on other desktops,
836 link the first clone in if possible. If there are no clones
837 then leave the class on the desktop heap. It will get moved
838 to the shared heap when the thread detaches. */
839 if (BaseClass->pclsClone != NULL)
840 {
841 if (BaseClass->Global)
842 PrevLink = &pi->pclsPublicList;
843 else
844 PrevLink = &pi->pclsPrivateList;
845
846 CurrentClass = *PrevLink;
847 while (CurrentClass != BaseClass)
848 {
849 ASSERT(CurrentClass != NULL);
850
851 PrevLink = &CurrentClass->pclsNext;
852 CurrentClass = CurrentClass->pclsNext;
853 }
854
855 ASSERT(*PrevLink == BaseClass);
856
857 /* Make the first clone become the new base class */
859 PrevLink,
860 &BaseClass->pclsClone);
861
862 /* Destroy the class, there's still another clone of the class
863 that now serves as a base class. Make sure we don't destruct
864 resources shared by all classes (Base = NULL)! */
865 BaseClass->pclsBase = NULL;
866 BaseClass->pclsClone = NULL;
867 IntDestroyClass(BaseClass);
868 }
869 }
870 else
871 {
872 TRACE("IntDereferenceClass1 0x%p\n", Class);
873
874 /* Locate the cloned class and unlink it */
875 PrevLink = &BaseClass->pclsClone;
876 CurrentClass = BaseClass->pclsClone;
877 while (CurrentClass != Class)
878 {
879 ASSERT(CurrentClass != NULL);
880
881 PrevLink = &CurrentClass->pclsNext;
882 CurrentClass = CurrentClass->pclsNext;
883 }
884
885 ASSERT(CurrentClass == Class);
886
888 Class->pclsNext);
889
890 ASSERT(Class->pclsBase == BaseClass);
891 ASSERT(Class->pclsClone == NULL);
892
893 /* The class was just a clone, we don't need it anymore */
895 }
896 }
897}
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
#define TRACE(s)
Definition: solgame.cpp:4
struct _CLS * pclsBase
Definition: ntuser.h:577
UINT Global
Definition: ntuser.h:593
struct _CLS * pclsClone
Definition: ntuser.h:578
struct _CLS * pclsNext
Definition: ntuser.h:567
static VOID IntMakeCloneBaseClass(IN OUT PCLS Class, IN OUT PCLS *BaseClassLink, IN OUT PCLS *CloneLink)
Definition: class.c:780

Referenced by co_UserCreateWindowEx(), and co_UserFreeWindow().

◆ IntGetAndReferenceClass()

PCLS IntGetAndReferenceClass ( PUNICODE_STRING  ClassName,
HINSTANCE  hInstance,
BOOL  bDesktopThread 
)

Definition at line 1448 of file class.c.

1449{
1450 PCLS *ClassLink, Class = NULL;
1451 RTL_ATOM ClassAtom;
1452 PTHREADINFO pti;
1453
1454 if (bDesktopThread)
1455 pti = gptiDesktopThread;
1456 else
1458
1459 if ( !(pti->ppi->W32PF_flags & W32PF_CLASSESREGISTERED ))
1460 {
1462 }
1463
1464 /* Check the class. */
1465
1466 TRACE("Finding Class %wZ for hInstance 0x%p\n", ClassName, hInstance);
1467
1468 ClassAtom = IntGetClassAtom(ClassName,
1469 hInstance,
1470 pti->ppi,
1471 &Class,
1472 &ClassLink);
1473
1474 if (ClassAtom == (RTL_ATOM)0)
1475 {
1476 if (IS_ATOM(ClassName->Buffer))
1477 {
1478 ERR("Class 0x%p not found\n", ClassName->Buffer);
1479 }
1480 else
1481 {
1482 ERR("Class \"%wZ\" not found\n", ClassName);
1483 }
1484
1485 return NULL;
1486 }
1487
1488 TRACE("Referencing Class 0x%p with atom 0x%x\n", Class, ClassAtom);
1490 ClassLink,
1491 pti->rpdesk);
1492 if (Class == NULL)
1493 {
1494 ERR("Failed to reference window class!\n");
1495 return NULL;
1496 }
1497
1498 return Class;
1499}
HINSTANCE hInstance
Definition: charmap.c:19
#define IS_ATOM(x)
Definition: class.h:3
unsigned short RTL_ATOM
Definition: atom.c:42
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
PPROCESSINFO ppi
Definition: win32.h:88
struct _DESKTOP * rpdesk
Definition: win32.h:92
#define W32PF_CLASSESREGISTERED
Definition: win32.h:17
PCLS IntReferenceClass(IN OUT PCLS BaseClass, IN OUT PCLS *ClassLink, IN PDESKTOP Desktop)
Definition: class.c:752
RTL_ATOM IntGetClassAtom(_In_ PUNICODE_STRING ClassName, IN HINSTANCE hInstance OPTIONAL, IN PPROCESSINFO pi OPTIONAL, OUT PCLS *BaseClass OPTIONAL, OUT PCLS **Link OPTIONAL)
Definition: class.c:1375
BOOL FASTCALL UserRegisterSystemClasses(VOID)
Definition: class.c:2317
PTHREADINFO gptiDesktopThread
Definition: desktop.c:37

Referenced by co_UserCreateWindowEx(), and IntCreateDesktop().

◆ IsCallProcHandle()

static __inline BOOL IsCallProcHandle ( IN WNDPROC  lpWndProc)
static

Definition at line 13 of file class.h.

14{
15 /* FIXME: Check for 64-bit architectures... */
16 return ((ULONG_PTR)lpWndProc & 0xFFFF0000) == 0xFFFF0000;
17}
uint32_t ULONG_PTR
Definition: typedefs.h:65

Referenced by CallWindowProcA(), CallWindowProcW(), IntCreateWindow(), IntSetClassWndProc(), IntSetWindowProc(), and NtUserRegisterClassExWOW().

◆ LookupFnIdToiCls()

BOOL FASTCALL LookupFnIdToiCls ( int  FnId,
int iCls 
)

Definition at line 131 of file class.c.

132{
133 int i;
134
135 for ( i = 0; i < ARRAYSIZE(FnidToiCls); i++)
136 {
137 if (FnidToiCls[i].FnId == FnId)
138 {
139 if (iCls) *iCls = FnidToiCls[i].ClsId;
140 return TRUE;
141 }
142 }
143 if (iCls) *iCls = 0;
144 return FALSE;
145}
#define FALSE
Definition: types.h:117
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
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
int FnId
Definition: class.c:106
static struct @5132 FnidToiCls[]

Referenced by IntCreateClass(), IntIsGhostWindow(), and NtUserGetClassName().

◆ ProbeAndCaptureUnicodeStringOrAtom()

_Must_inspect_result_ NTSTATUS NTAPI ProbeAndCaptureUnicodeStringOrAtom ( _Out_ _When_(return >=0, _At_(pustrOut->Buffer, _Post_ _Notnull_)) PUNICODE_STRING  pustrOut,
__in_data_source(USER_MODE) _In_ PUNICODE_STRING  pustrUnsafe 
)

Definition at line 150 of file class.c.

153{
155 UNICODE_STRING ustrCopy;
156
157 /* Default to NULL */
158 RtlInitEmptyUnicodeString(pustrOut, NULL, 0);
159
161 {
162 ProbeForRead(pustrUnsafe, sizeof(UNICODE_STRING), 1);
163
164 ustrCopy = *pustrUnsafe;
165
166 /* Validate the string */
167 if ((ustrCopy.Length & 1) || (ustrCopy.Buffer == NULL))
168 {
169 /* This is not legal */
171 }
172
173 /* Check if this is an atom */
174 if (IS_ATOM(ustrCopy.Buffer))
175 {
176 /* Copy the atom, length is 0 */
177 pustrOut->MaximumLength = pustrOut->Length = 0;
178 pustrOut->Buffer = ustrCopy.Buffer;
179 }
180 else
181 {
182 /* Get the length, maximum length includes zero termination */
183 pustrOut->Length = ustrCopy.Length;
184 pustrOut->MaximumLength = pustrOut->Length + sizeof(WCHAR);
185
186 /* Allocate a buffer */
187 pustrOut->Buffer = ExAllocatePoolWithTag(PagedPool,
188 pustrOut->MaximumLength,
189 TAG_STRING);
190 if (!pustrOut->Buffer)
191 {
193 }
194
195 /* Copy the string and zero terminate it */
196 ProbeForRead(ustrCopy.Buffer, pustrOut->Length, 1);
197 RtlCopyMemory(pustrOut->Buffer, ustrCopy.Buffer, pustrOut->Length);
198 pustrOut->Buffer[pustrOut->Length / sizeof(WCHAR)] = L'\0';
199 }
200 }
202 {
203 /* Check if we already allocated a buffer */
204 if (pustrOut->Buffer)
205 {
206 /* Free the buffer */
207 ExFreePoolWithTag(pustrOut->Buffer, TAG_STRING);
209 }
210 }
211 _SEH2_END;
212
213 return Status;
214}
LONG NTSTATUS
Definition: precomp.h:26
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PagedPool
Definition: env_spec_w32.h:308
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
Status
Definition: gdiplustypes.h:25
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define L(x)
Definition: ntvdm.h:50
#define TAG_STRING
Definition: oslist.h:22
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:165
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:168
#define STATUS_SUCCESS
Definition: shellext.h:65
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by NtUserFindExistingCursorIcon(), NtUserGetClassInfo(), NtUserGetWOWClass(), NtUserSetCursorIconData(), and NtUserUnregisterClass().

◆ UserAddCallProcToClass()

VOID UserAddCallProcToClass ( IN OUT PCLS  Class,
IN PCALLPROCDATA  CallProc 
)

Definition at line 426 of file class.c.

428{
429 PCLS BaseClass;
430
431 ASSERT(CallProc->spcpdNext == NULL);
432
433 BaseClass = Class->pclsBase;
434 ASSERT(CallProc->spcpdNext == NULL);
435 CallProc->spcpdNext = BaseClass->spcpdFirst;
436 BaseClass->spcpdFirst = CallProc;
437
438 /* Update all clones */
439 Class = Class->pclsClone;
440 while (Class != NULL)
441 {
442 Class->spcpdFirst = BaseClass->spcpdFirst;
443 Class = Class->pclsNext;
444 }
445}
PCALLPROCDATA spcpdFirst
Definition: ntuser.h:576

Referenced by IntCreateWindow().

◆ UserGetCallProcInfo()

BOOL UserGetCallProcInfo ( IN HANDLE  hCallProc,
OUT PWNDPROC_INFO  wpInfo 
)

Definition at line 59 of file callproc.c.

61{
62 PCALLPROCDATA CallProc;
63
64 CallProc = UserGetObject(gHandleTable,
65 hCallProc,
67 if (CallProc == NULL)
68 {
69 return FALSE;
70 }
71
72/* Use Handle pEntry->ppi!
73 if (CallProc->pi != GetW32ProcessInfo())
74 {
75 return FALSE;
76 }*/
77
78 wpInfo->WindowProc = CallProc->pfnClientPrevious;
79 wpInfo->IsUnicode = !!(CallProc->wType & UserGetCPDA2U);
80
81 return TRUE;
82}
PVOID UserGetObject(PUSER_HANDLE_TABLE ht, HANDLE handle, HANDLE_TYPE type)
Definition: object.c:495

◆ UserGetClassName()

INT UserGetClassName ( IN PCLS  Class,
IN OUT PUNICODE_STRING  ClassName,
IN RTL_ATOM  Atom,
IN BOOL  Ansi 
)

Definition at line 1645 of file class.c.

1649{
1651 WCHAR szStaticTemp[32];
1652 PWSTR szTemp = NULL;
1653 ULONG BufLen = sizeof(szStaticTemp);
1654 INT Ret = 0;
1655
1656 /* Note: Accessing the buffer in ClassName may raise an exception! */
1657
1658 _SEH2_TRY
1659 {
1660 if (Ansi)
1661 {
1662 PANSI_STRING AnsiClassName = (PANSI_STRING)ClassName;
1663 UNICODE_STRING UnicodeClassName;
1664
1665 /* Limit the size of the static buffer on the stack to the
1666 size of the buffer provided by the caller */
1667 if (BufLen / sizeof(WCHAR) > AnsiClassName->MaximumLength)
1668 {
1669 BufLen = AnsiClassName->MaximumLength * sizeof(WCHAR);
1670 }
1671
1672 /* Find out how big the buffer needs to be */
1674 Class->atomClassName,
1675 NULL,
1676 NULL,
1677 szStaticTemp,
1678 &BufLen);
1680 {
1681 if (BufLen / sizeof(WCHAR) > AnsiClassName->MaximumLength)
1682 {
1683 /* The buffer required exceeds the ansi buffer provided,
1684 pretend like we're using the ansi buffer and limit the
1685 size to the buffer size provided */
1686 BufLen = AnsiClassName->MaximumLength * sizeof(WCHAR);
1687 }
1688
1689 /* Allocate a temporary buffer that can hold the unicode class name */
1691 BufLen,
1693 if (szTemp == NULL)
1694 {
1697 }
1698
1699 /* Query the class name */
1701 Atom ? Atom : Class->atomNVClassName,
1702 NULL,
1703 NULL,
1704 szTemp,
1705 &BufLen);
1706 }
1707 else
1708 szTemp = szStaticTemp;
1709
1710 if (NT_SUCCESS(Status))
1711 {
1712 /* Convert the atom name to ansi */
1713
1714 RtlInitUnicodeString(&UnicodeClassName,
1715 szTemp);
1716
1717 Status = RtlUnicodeStringToAnsiString(AnsiClassName,
1718 &UnicodeClassName,
1719 FALSE);
1720 if (!NT_SUCCESS(Status))
1721 {
1724 }
1725 }
1726
1727 Ret = BufLen / sizeof(WCHAR);
1728 }
1729 else /* !ANSI */
1730 {
1731 BufLen = ClassName->MaximumLength;
1732
1733 /* Query the atom name */
1735 Atom ? Atom : Class->atomNVClassName,
1736 NULL,
1737 NULL,
1738 ClassName->Buffer,
1739 &BufLen);
1740
1741 if (!NT_SUCCESS(Status))
1742 {
1745 }
1746
1747 Ret = BufLen / sizeof(WCHAR);
1748 }
1749 }
1751 {
1753 }
1754 _SEH2_END;
1755
1756 if (Ansi && szTemp != NULL && szTemp != szStaticTemp)
1757 {
1759 }
1760
1761 return Ret;
1762}
_Out_ RTL_ATOM * Atom
Definition: class.h:54
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ANSI_STRING * PANSI_STRING
Definition: env_spec_w32.h:380
#define BufLen
Definition: fatfs.h:167
#define _SEH2_LEAVE
Definition: filesup.c:20
NTSYSAPI NTSTATUS NTAPI RtlQueryAtomInAtomTable(_In_ PRTL_ATOM_TABLE AtomTable, _In_ RTL_ATOM Atom, _Out_opt_ PULONG RefCount, _Out_opt_ PULONG PinCount, _Out_opt_z_bytecap_(*NameLength) PWSTR AtomName, _Inout_opt_ PULONG NameLength)
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
USHORT MaximumLength
Definition: env_spec_w32.h:377
uint16_t * PWSTR
Definition: typedefs.h:56
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG
Definition: typedefs.h:59
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
PRTL_ATOM_TABLE gAtomTable
Definition: session.c:13
#define USERTAG_CLASS
Definition: tags.h:204

Referenced by IntIsGhostWindow(), and NtUserGetClassName().

◆ UserGetCPD()

ULONG_PTR FASTCALL UserGetCPD ( PVOID  pvClsWnd,
GETCPD  Flags,
ULONG_PTR  ProcIn 
)

Definition at line 107 of file callproc.c.

111{
112 PCLS pCls;
113 PWND pWnd;
114 PDESKTOP pDesk;
115 PCALLPROCDATA CallProc = NULL;
116 PTHREADINFO pti;
117
119
122 {
123 pWnd = pvClsWnd;
124 pCls = pWnd->pcls;
125 }
126 else
127 pCls = pvClsWnd;
128
129 // Search Class call proc data list.
130 if (pCls->spcpdFirst)
131 CallProc = UserSearchForCallProc( pCls->spcpdFirst, (WNDPROC)ProcIn, Flags);
132
133 // No luck, create a new one for the requested proc.
134 if (!CallProc)
135 {
136 if (!pCls->rpdeskParent)
137 {
138 TRACE("Null DESKTOP Atom %u\n",pCls->atomClassName);
139 pDesk = pti->rpdesk;
140 }
141 else
142 pDesk = pCls->rpdeskParent;
143 CallProc = CreateCallProc( pDesk,
144 (WNDPROC)ProcIn,
145 !!(Flags & UserGetCPDA2U),
146 pti->ppi);
147 if (CallProc)
148 {
149 CallProc->spcpdNext = pCls->spcpdFirst;
151 CallProc);
152 CallProc->wType = Flags;
153 }
154 }
155 return (ULONG_PTR)(CallProc ? GetCallProcHandle(CallProc) : NULL);
156}
PCALLPROCDATA CreateCallProc(IN PDESKTOP Desktop, IN WNDPROC WndProc, IN BOOL Unicode, IN PPROCESSINFO pi)
Definition: callproc.c:29
WNDPROC GetCallProcHandle(IN PCALLPROCDATA CallProc)
Definition: callproc.c:15
PCALLPROCDATA FASTCALL UserSearchForCallProc(PCALLPROCDATA pcpd, WNDPROC WndProc, GETCPD Type)
Definition: callproc.c:89
@ UserGetCPDWndtoCls
Definition: ntuser.h:545
@ UserGetCPDDialog
Definition: ntuser.h:544
@ UserGetCPDWindow
Definition: ntuser.h:543
struct _DESKTOP * rpdeskParent
Definition: ntuser.h:571
RTL_ATOM atomClassName
Definition: ntuser.h:568
Definition: ntuser.h:694
PCLS pcls
Definition: ntuser.h:720
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2906
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

Referenced by IntGetClassWndProc(), IntGetWindowProc(), and NtUserGetCPD().

◆ UserRegisterSystemClasses()

BOOL FASTCALL UserRegisterSystemClasses ( VOID  )

Definition at line 2317 of file class.c.

2318{
2319 UINT i;
2320 UNICODE_STRING ClassName, MenuName;
2322 WNDCLASSEXW wc;
2323 PCLS Class;
2324 BOOL Ret = TRUE;
2325 HBRUSH hBrush;
2326 DWORD Flags = 0;
2327
2328 if (ppi->W32PF_flags & W32PF_CLASSESREGISTERED)
2329 return TRUE;
2330
2331 if ( hModClient == NULL)
2332 return FALSE;
2333
2334 RtlZeroMemory(&ClassName, sizeof(ClassName));
2335 RtlZeroMemory(&MenuName, sizeof(MenuName));
2336
2337 for (i = 0; i != ARRAYSIZE(DefaultServerClasses); i++)
2338 {
2339 if (!IS_ATOM(DefaultServerClasses[i].ClassName))
2340 {
2341 RtlInitUnicodeString(&ClassName, DefaultServerClasses[i].ClassName);
2342 }
2343 else
2344 {
2345 ClassName.Buffer = DefaultServerClasses[i].ClassName;
2346 ClassName.Length = 0;
2347 ClassName.MaximumLength = 0;
2348 }
2349
2350 wc.cbSize = sizeof(wc);
2352
2354
2355 if (DefaultServerClasses[i].ProcW)
2356 {
2358 wc.hInstance = hModuleWin;
2359 }
2360 else
2361 {
2363 wc.hInstance = hModClient;
2364 }
2365
2366 wc.cbClsExtra = 0;
2368 wc.hIcon = NULL;
2369
2371 wc.hCursor = NULL;
2372 if (DefaultServerClasses[i].hCursor == (HICON)OCR_NORMAL)
2373 {
2374 if (SYSTEMCUR(ARROW) == NULL)
2375 {
2376 ERR("SYSTEMCUR(ARROW) == NULL, should not happen!!\n");
2377 }
2378 else
2379 {
2380 wc.hCursor = UserHMGetHandle(SYSTEMCUR(ARROW));
2381 }
2382 }
2383
2384 hBrush = DefaultServerClasses[i].hBrush;
2385 if (hBrush <= (HBRUSH)COLOR_MENUBAR)
2386 {
2387 hBrush = IntGetSysColorBrush(HandleToUlong(hBrush));
2388 }
2389 wc.hbrBackground = hBrush;
2390 wc.lpszMenuName = NULL;
2391 wc.lpszClassName = ClassName.Buffer;
2392 wc.hIconSm = NULL;
2393
2394 Class = IntCreateClass( &wc,
2395 &ClassName,
2396 &ClassName,
2397 &MenuName,
2398 DefaultServerClasses[i].fiId,
2399 Flags,
2400 NULL,
2401 ppi);
2402 if (Class != NULL)
2403 {
2404 Class->pclsNext = ppi->pclsPublicList;
2406 Class);
2407
2409 }
2410 else
2411 {
2412 ERR("!!! Registering system class failed!\n");
2413 Ret = FALSE;
2414 }
2415 }
2416 if (Ret) ppi->W32PF_flags |= W32PF_CLASSESREGISTERED;
2417 return Ret;
2418}
#define HandleToUlong(h)
Definition: basetsd.h:79
#define SYSTEMCUR(func)
Definition: cursoricon.h:129
unsigned long DWORD
Definition: ntddk_ex.h:95
#define ICLASS_TO_MASK(iCls)
Definition: ntuser.h:902
#define GETPFNSERVER(fnid)
Definition: ntuser.h:909
#define CSF_SERVERSIDEPROC
Definition: ntuser.h:556
HGDIOBJ FASTCALL IntGetSysColorBrush(INT Object)
Definition: stockobj.c:317
static HICON
Definition: imagelist.c:84
unsigned int UINT
Definition: ndis.h:50
HINSTANCE hModClient
Definition: ntuser.c:25
DWORD dwRegisteredClasses
Definition: win32.h:280
struct _CLS * pclsPublicList
Definition: win32.h:260
WNDPROC ProcW
Definition: ntuser.h:488
LPCWSTR lpszClassName
Definition: winuser.h:3226
LPCWSTR lpszMenuName
Definition: winuser.h:3225
HBRUSH hbrBackground
Definition: winuser.h:3224
WNDPROC lpfnWndProc
Definition: winuser.h:3218
UINT cbSize
Definition: winuser.h:3216
int cbWndExtra
Definition: winuser.h:3220
HCURSOR hCursor
Definition: winuser.h:3223
HICON hIconSm
Definition: winuser.h:3227
HINSTANCE hInstance
Definition: winuser.h:3221
UINT style
Definition: winuser.h:3217
int cbClsExtra
Definition: winuser.h:3219
HICON hIcon
Definition: winuser.h:3222
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
REGISTER_SYSCLASS DefaultServerClasses[]
Definition: class.c:35
PCLS FASTCALL IntCreateClass(IN CONST WNDCLASSEXW *lpwcx, IN PUNICODE_STRING ClassName, IN PUNICODE_STRING ClassVersion, IN PUNICODE_STRING MenuName, IN DWORD fnID, IN DWORD dwFlags, IN PDESKTOP Desktop, IN PPROCESSINFO pi)
Definition: class.c:1045
HANDLE hModuleWin
Definition: main.c:16

Referenced by DesktopThreadMain(), IntGetAndReferenceClass(), NtUserGetClassInfo(), and NtUserRegisterClassExWOW().

Variable Documentation

◆ Atom