ReactOS 0.4.15-dev-7201-g2de6e75
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:540
@ UserGetCPDA2U
Definition: ntuser.h:539
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:552
WNDPROC pfnClientPrevious
Definition: ntuser.h:551
struct _CALLPROCDATA * spcpdNext
Definition: ntuser.h:550
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:565
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:110
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
unsigned int BOOL
Definition: ntddk_ex.h:94
struct _PROCESSINFO * GetW32ProcessInfo(VOID)
Definition: misc.c:803
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:28

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:576
UINT Global
Definition: ntuser.h:592
struct _CLS * pclsClone
Definition: ntuser.h:577
struct _CLS * pclsNext
Definition: ntuser.h:566
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 1440 of file class.c.

1441{
1442 PCLS *ClassLink, Class = NULL;
1443 RTL_ATOM ClassAtom;
1444 PTHREADINFO pti;
1445
1446 if (bDesktopThread)
1447 pti = gptiDesktopThread;
1448 else
1450
1451 if ( !(pti->ppi->W32PF_flags & W32PF_CLASSESREGISTERED ))
1452 {
1454 }
1455
1456 /* Check the class. */
1457
1458 TRACE("Finding Class %wZ for hInstance 0x%p\n", ClassName, hInstance);
1459
1460 ClassAtom = IntGetClassAtom(ClassName,
1461 hInstance,
1462 pti->ppi,
1463 &Class,
1464 &ClassLink);
1465
1466 if (ClassAtom == (RTL_ATOM)0)
1467 {
1468 if (IS_ATOM(ClassName->Buffer))
1469 {
1470 ERR("Class 0x%p not found\n", ClassName->Buffer);
1471 }
1472 else
1473 {
1474 ERR("Class \"%wZ\" not found\n", ClassName);
1475 }
1476
1477 return NULL;
1478 }
1479
1480 TRACE("Referencing Class 0x%p with atom 0x%x\n", Class, ClassAtom);
1482 ClassLink,
1483 pti->rpdesk);
1484 if (Class == NULL)
1485 {
1486 ERR("Failed to reference window class!\n");
1487 return NULL;
1488 }
1489
1490 return Class;
1491}
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:1367
BOOL FASTCALL UserRegisterSystemClasses(VOID)
Definition: class.c:2309
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 @5096 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:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
#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:575

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 1637 of file class.c.

1641{
1643 WCHAR szStaticTemp[32];
1644 PWSTR szTemp = NULL;
1645 ULONG BufLen = sizeof(szStaticTemp);
1646 INT Ret = 0;
1647
1648 /* Note: Accessing the buffer in ClassName may raise an exception! */
1649
1650 _SEH2_TRY
1651 {
1652 if (Ansi)
1653 {
1654 PANSI_STRING AnsiClassName = (PANSI_STRING)ClassName;
1655 UNICODE_STRING UnicodeClassName;
1656
1657 /* Limit the size of the static buffer on the stack to the
1658 size of the buffer provided by the caller */
1659 if (BufLen / sizeof(WCHAR) > AnsiClassName->MaximumLength)
1660 {
1661 BufLen = AnsiClassName->MaximumLength * sizeof(WCHAR);
1662 }
1663
1664 /* Find out how big the buffer needs to be */
1666 Class->atomClassName,
1667 NULL,
1668 NULL,
1669 szStaticTemp,
1670 &BufLen);
1672 {
1673 if (BufLen / sizeof(WCHAR) > AnsiClassName->MaximumLength)
1674 {
1675 /* The buffer required exceeds the ansi buffer provided,
1676 pretend like we're using the ansi buffer and limit the
1677 size to the buffer size provided */
1678 BufLen = AnsiClassName->MaximumLength * sizeof(WCHAR);
1679 }
1680
1681 /* Allocate a temporary buffer that can hold the unicode class name */
1683 BufLen,
1685 if (szTemp == NULL)
1686 {
1689 }
1690
1691 /* Query the class name */
1693 Atom ? Atom : Class->atomNVClassName,
1694 NULL,
1695 NULL,
1696 szTemp,
1697 &BufLen);
1698 }
1699 else
1700 szTemp = szStaticTemp;
1701
1702 if (NT_SUCCESS(Status))
1703 {
1704 /* Convert the atom name to ansi */
1705
1706 RtlInitUnicodeString(&UnicodeClassName,
1707 szTemp);
1708
1709 Status = RtlUnicodeStringToAnsiString(AnsiClassName,
1710 &UnicodeClassName,
1711 FALSE);
1712 if (!NT_SUCCESS(Status))
1713 {
1716 }
1717 }
1718
1719 Ret = BufLen / sizeof(WCHAR);
1720 }
1721 else /* !ANSI */
1722 {
1723 BufLen = ClassName->MaximumLength;
1724
1725 /* Query the atom name */
1727 Atom ? Atom : Class->atomNVClassName,
1728 NULL,
1729 NULL,
1730 ClassName->Buffer,
1731 &BufLen);
1732
1733 if (!NT_SUCCESS(Status))
1734 {
1737 }
1738
1739 Ret = BufLen / sizeof(WCHAR);
1740 }
1741 }
1743 {
1745 }
1746 _SEH2_END;
1747
1748 if (Ansi && szTemp != NULL && szTemp != szStaticTemp)
1749 {
1751 }
1752
1753 return Ret;
1754}
_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(NTSTATUS Status)
Definition: error.c:37
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:544
@ UserGetCPDDialog
Definition: ntuser.h:543
@ UserGetCPDWindow
Definition: ntuser.h:542
struct _DESKTOP * rpdeskParent
Definition: ntuser.h:570
RTL_ATOM atomClassName
Definition: ntuser.h:567
Definition: ntuser.h:693
PCLS pcls
Definition: ntuser.h:719
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2905
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170

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

◆ UserRegisterSystemClasses()

BOOL FASTCALL UserRegisterSystemClasses ( VOID  )

Definition at line 2309 of file class.c.

2310{
2311 UINT i;
2312 UNICODE_STRING ClassName, MenuName;
2314 WNDCLASSEXW wc;
2315 PCLS Class;
2316 BOOL Ret = TRUE;
2317 HBRUSH hBrush;
2318 DWORD Flags = 0;
2319
2320 if (ppi->W32PF_flags & W32PF_CLASSESREGISTERED)
2321 return TRUE;
2322
2323 if ( hModClient == NULL)
2324 return FALSE;
2325
2326 RtlZeroMemory(&ClassName, sizeof(ClassName));
2327 RtlZeroMemory(&MenuName, sizeof(MenuName));
2328
2329 for (i = 0; i != ARRAYSIZE(DefaultServerClasses); i++)
2330 {
2331 if (!IS_ATOM(DefaultServerClasses[i].ClassName))
2332 {
2333 RtlInitUnicodeString(&ClassName, DefaultServerClasses[i].ClassName);
2334 }
2335 else
2336 {
2337 ClassName.Buffer = DefaultServerClasses[i].ClassName;
2338 ClassName.Length = 0;
2339 ClassName.MaximumLength = 0;
2340 }
2341
2342 wc.cbSize = sizeof(wc);
2344
2346
2347 if (DefaultServerClasses[i].ProcW)
2348 {
2350 wc.hInstance = hModuleWin;
2351 }
2352 else
2353 {
2355 wc.hInstance = hModClient;
2356 }
2357
2358 wc.cbClsExtra = 0;
2360 wc.hIcon = NULL;
2361
2363 wc.hCursor = NULL;
2364 if (DefaultServerClasses[i].hCursor == (HICON)OCR_NORMAL)
2365 {
2366 if (SYSTEMCUR(ARROW) == NULL)
2367 {
2368 ERR("SYSTEMCUR(ARROW) == NULL, should not happen!!\n");
2369 }
2370 else
2371 {
2372 wc.hCursor = UserHMGetHandle(SYSTEMCUR(ARROW));
2373 }
2374 }
2375
2376 hBrush = DefaultServerClasses[i].hBrush;
2377 if (hBrush <= (HBRUSH)COLOR_MENUBAR)
2378 {
2379 hBrush = IntGetSysColorBrush(HandleToUlong(hBrush));
2380 }
2381 wc.hbrBackground = hBrush;
2382 wc.lpszMenuName = NULL;
2383 wc.lpszClassName = ClassName.Buffer;
2384 wc.hIconSm = NULL;
2385
2386 Class = IntCreateClass( &wc,
2387 &ClassName,
2388 &ClassName,
2389 &MenuName,
2390 DefaultServerClasses[i].fiId,
2391 Flags,
2392 NULL,
2393 ppi);
2394 if (Class != NULL)
2395 {
2396 Class->pclsNext = ppi->pclsPublicList;
2398 Class);
2399
2401 }
2402 else
2403 {
2404 ERR("!!! Registering system class failed!\n");
2405 Ret = FALSE;
2406 }
2407 }
2408 if (Ret) ppi->W32PF_flags |= W32PF_CLASSESREGISTERED;
2409 return Ret;
2410}
#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:901
#define GETPFNSERVER(fnid)
Definition: ntuser.h:908
#define CSF_SERVERSIDEPROC
Definition: ntuser.h:555
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:487
LPCWSTR lpszClassName
Definition: winuser.h:3225
LPCWSTR lpszMenuName
Definition: winuser.h:3224
HBRUSH hbrBackground
Definition: winuser.h:3223
WNDPROC lpfnWndProc
Definition: winuser.h:3217
UINT cbSize
Definition: winuser.h:3215
int cbWndExtra
Definition: winuser.h:3219
HCURSOR hCursor
Definition: winuser.h:3222
HICON hIconSm
Definition: winuser.h:3226
HINSTANCE hInstance
Definition: winuser.h:3220
UINT style
Definition: winuser.h:3216
int cbClsExtra
Definition: winuser.h:3218
HICON hIcon
Definition: winuser.h:3221
#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