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_INFO *	PWNDPROC_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_ATOM *	Atom

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

typedef struct _WNDPROC_INFO * PWNDPROC_INFO

WNDPROC_INFO

typedef struct _WNDPROC_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.

{
    PCALLPROCDATA NewCallProc;
    HANDLE Handle;
 
    /* We can send any thread pointer to the object manager here,
     * What's important is the process info */
    NewCallProc = (PCALLPROCDATA)UserCreateObject(gHandleTable,
                                             Desktop,
                                             pi->ptiList,
                                             &Handle,
                                             TYPE_CALLPROC,
                                             sizeof(CALLPROCDATA));
    if (NewCallProc != NULL)
    {
        NewCallProc->pfnClientPrevious = WndProc;
        NewCallProc->wType |= Unicode ? UserGetCPDA2U : UserGetCPDU2A ;
        NewCallProc->spcpdNext = NULL;
 
        /* Release the extra reference (UserCreateObject added 2 references) */
        UserDereferenceObject(NewCallProc);
    }
 
    return NewCallProc;
}

Referenced by IntCreateWindow(), and UserGetCPD().

DestroyCallProc()

BOOLEAN DestroyCallProc

(

_Inout_ PVOID

Object

)

Definition at line 22 of file callproc.c.

{
    UserDeleteObject(UserHMGetHandle((PCALLPROCDATA)Object), TYPE_CALLPROC);
    return TRUE;
}

Referenced by IntDestroyClass().

DestroyProcessClasses()

void FASTCALL DestroyProcessClasses

(

PPROCESSINFO

Process

)

Definition at line 303 of file class.c.

{
    PCLS Class;
    PPROCESSINFO pi = (PPROCESSINFO)Process;
 
    if (pi != NULL)
    {
        /* Free all local classes */
        Class = pi->pclsPrivateList;
        while (Class != NULL)
        {
            pi->pclsPrivateList = Class->pclsNext;
 
            ASSERT(Class->pclsBase == Class);
            IntDestroyClass(Class);
 
            Class = pi->pclsPrivateList;
        }
 
        /* Free all global classes */
        Class = pi->pclsPublicList;
        while (Class != NULL)
        {
            pi->pclsPublicList = Class->pclsNext;
 
            ASSERT(Class->pclsBase == Class);
            IntDestroyClass(Class);
 
            Class = pi->pclsPublicList;
        }
    }
}

Referenced by ExitThreadCallback().

IntCheckProcessDesktopClasses()

BOOL IntCheckProcessDesktopClasses	(	IN PDESKTOP	Desktop,
		IN BOOL	FreeOnFailure
	)

Definition at line 1015 of file class.c.

{
    PPROCESSINFO pi;
    BOOL Ret = TRUE;
 
    pi = GetW32ProcessInfo();
 
    /* Check all local classes */
    IntCheckDesktopClasses(Desktop,
                           &pi->pclsPrivateList,
                           FreeOnFailure,
                           &Ret);
 
    /* Check all global classes */
    IntCheckDesktopClasses(Desktop,
                           &pi->pclsPublicList,
                           FreeOnFailure,
                           &Ret);
    if (!Ret)
    {
        ERR("Failed to move process classes from desktop 0x%p to the shared heap!\n", Desktop);
        EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
    }
 
    return Ret;
}

Referenced by IntSetThreadDesktop().

IntDereferenceClass()

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

Definition at line 818 of file class.c.

{
    PCLS *PrevLink, BaseClass, CurrentClass;
 
    ASSERT(Class->cWndReferenceCount >= 1);
 
    BaseClass = Class->pclsBase;
 
    if (--Class->cWndReferenceCount == 0)
    {
        if (BaseClass == Class)
        {
            ASSERT(Class->pclsBase == Class);
 
            TRACE("IntDereferenceClass 0x%p\n", Class);
            /* Check if there are clones of the class on other desktops,
               link the first clone in if possible. If there are no clones
               then leave the class on the desktop heap. It will get moved
               to the shared heap when the thread detaches. */
            if (BaseClass->pclsClone != NULL)
            {
                if (BaseClass->Global)
                    PrevLink = &pi->pclsPublicList;
                else
                    PrevLink = &pi->pclsPrivateList;
 
                CurrentClass = *PrevLink;
                while (CurrentClass != BaseClass)
                {
                    ASSERT(CurrentClass != NULL);
 
                    PrevLink = &CurrentClass->pclsNext;
                    CurrentClass = CurrentClass->pclsNext;
                }
 
                ASSERT(*PrevLink == BaseClass);
 
                /* Make the first clone become the new base class */
                IntMakeCloneBaseClass(BaseClass->pclsClone,
                                      PrevLink,
                                      &BaseClass->pclsClone);
 
                /* Destroy the class, there's still another clone of the class
                   that now serves as a base class. Make sure we don't destruct
                   resources shared by all classes (Base = NULL)! */
                BaseClass->pclsBase = NULL;
                BaseClass->pclsClone = NULL;
                IntDestroyClass(BaseClass);
            }
        }
        else
        {
            TRACE("IntDereferenceClass1 0x%p\n", Class);
 
            /* Locate the cloned class and unlink it */
            PrevLink = &BaseClass->pclsClone;
            CurrentClass = BaseClass->pclsClone;
            while (CurrentClass != Class)
            {
                ASSERT(CurrentClass != NULL);
 
                PrevLink = &CurrentClass->pclsNext;
                CurrentClass = CurrentClass->pclsNext;
            }
 
            ASSERT(CurrentClass == Class);
 
            (void)InterlockedExchangePointer((PVOID*)PrevLink,
                                             Class->pclsNext);
 
            ASSERT(Class->pclsBase == BaseClass);
            ASSERT(Class->pclsClone == NULL);
 
            /* The class was just a clone, we don't need it anymore */
            IntDestroyClass(Class);
        }
    }
}

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.

{
   PCLS *ClassLink, Class = NULL;
   RTL_ATOM ClassAtom;
   PTHREADINFO pti;
 
   if (bDesktopThread)
       pti = gptiDesktopThread;
   else
       pti = PsGetCurrentThreadWin32Thread();
 
   if ( !(pti->ppi->W32PF_flags & W32PF_CLASSESREGISTERED ))
   {
      UserRegisterSystemClasses();
   }
 
   /* Check the class. */
 
   TRACE("Finding Class %wZ for hInstance 0x%p\n", ClassName, hInstance);
 
   ClassAtom = IntGetClassAtom(ClassName,
                               hInstance,
                               pti->ppi,
                               &Class,
                               &ClassLink);
 
   if (ClassAtom == (RTL_ATOM)0)
   {
      if (IS_ATOM(ClassName->Buffer))
      {
         ERR("Class 0x%p not found\n", ClassName->Buffer);
      }
      else
      {
         ERR("Class \"%wZ\" not found\n", ClassName);
      }
 
      return NULL;
   }
 
   TRACE("Referencing Class 0x%p with atom 0x%x\n", Class, ClassAtom);
   Class = IntReferenceClass(Class,
                             ClassLink,
                             pti->rpdesk);
   if (Class == NULL)
   {
       ERR("Failed to reference window class!\n");
       return NULL;
   }
 
   return Class;
}

Referenced by co_UserCreateWindowEx(), and IntCreateDesktop().

IsCallProcHandle()

static __inline BOOL IsCallProcHandle ( IN WNDPROC  lpWndProc )

static

Definition at line 13 of file class.h.

{
    /* FIXME: Check for 64-bit architectures... */
    return ((ULONG_PTR)lpWndProc & 0xFFFF0000) == 0xFFFF0000;
}

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.

{
  int i;
 
  for ( i = 0; i < ARRAYSIZE(FnidToiCls); i++)
  {
     if (FnidToiCls[i].FnId == FnId)
     {
        if (iCls) *iCls = FnidToiCls[i].ClsId;
        return TRUE;
     }
  }
  if (iCls) *iCls = 0;
  return FALSE;
}

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.

{
    NTSTATUS Status = STATUS_SUCCESS;
    UNICODE_STRING ustrCopy;
 
    /* Default to NULL */
    RtlInitEmptyUnicodeString(pustrOut, NULL, 0);
 
    _SEH2_TRY
    {
        ProbeForRead(pustrUnsafe, sizeof(UNICODE_STRING), 1);
 
        ustrCopy = *pustrUnsafe;
 
        /* Validate the string */
        if ((ustrCopy.Length & 1) || (ustrCopy.Buffer == NULL))
        {
            /* This is not legal */
            _SEH2_YIELD(return STATUS_INVALID_PARAMETER);
        }
 
        /* Check if this is an atom */
        if (IS_ATOM(ustrCopy.Buffer))
        {
            /* Copy the atom, length is 0 */
            pustrOut->MaximumLength = pustrOut->Length = 0;
            pustrOut->Buffer = ustrCopy.Buffer;
        }
        else
        {
            /* Get the length, maximum length includes zero termination */
            pustrOut->Length = ustrCopy.Length;
            pustrOut->MaximumLength = pustrOut->Length + sizeof(WCHAR);
 
            /* Allocate a buffer */
            pustrOut->Buffer = ExAllocatePoolWithTag(PagedPool,
                                                     pustrOut->MaximumLength,
                                                     TAG_STRING);
            if (!pustrOut->Buffer)
            {
                _SEH2_YIELD(return STATUS_INSUFFICIENT_RESOURCES);
            }
 
            /* Copy the string and zero terminate it */
            ProbeForRead(ustrCopy.Buffer, pustrOut->Length, 1);
            RtlCopyMemory(pustrOut->Buffer, ustrCopy.Buffer, pustrOut->Length);
            pustrOut->Buffer[pustrOut->Length / sizeof(WCHAR)] = L'\0';
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        /* Check if we already allocated a buffer */
        if (pustrOut->Buffer)
        {
            /* Free the buffer */
            ExFreePoolWithTag(pustrOut->Buffer, TAG_STRING);
            Status = _SEH2_GetExceptionCode();
        }
    }
    _SEH2_END;
 
    return Status;
}

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.

{
    PCLS BaseClass;
 
    ASSERT(CallProc->spcpdNext == NULL);
 
    BaseClass = Class->pclsBase;
    ASSERT(CallProc->spcpdNext == NULL);
    CallProc->spcpdNext = BaseClass->spcpdFirst;
    BaseClass->spcpdFirst = CallProc;
 
    /* Update all clones */
    Class = Class->pclsClone;
    while (Class != NULL)
    {
        Class->spcpdFirst = BaseClass->spcpdFirst;
        Class = Class->pclsNext;
    }
}

Referenced by IntCreateWindow().

UserGetCallProcInfo()

BOOL UserGetCallProcInfo	(	IN HANDLE	hCallProc,
		OUT PWNDPROC_INFO	wpInfo
	)

Definition at line 59 of file callproc.c.

{
    PCALLPROCDATA CallProc;
 
    CallProc = UserGetObject(gHandleTable,
                             hCallProc,
                             TYPE_CALLPROC);
    if (CallProc == NULL)
    {
        return FALSE;
    }
 
/* Use Handle pEntry->ppi!
    if (CallProc->pi != GetW32ProcessInfo())
    {
        return FALSE;
    }*/
 
    wpInfo->WindowProc = CallProc->pfnClientPrevious;
    wpInfo->IsUnicode = !!(CallProc->wType & UserGetCPDA2U);
 
    return TRUE;
}

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.

{
    NTSTATUS Status = STATUS_SUCCESS;
    WCHAR szStaticTemp[32];
    PWSTR szTemp = NULL;
    ULONG BufLen = sizeof(szStaticTemp);
    INT Ret = 0;
 
    /* Note: Accessing the buffer in ClassName may raise an exception! */
 
    _SEH2_TRY
    {
        if (Ansi)
        {
            PANSI_STRING AnsiClassName = (PANSI_STRING)ClassName;
            UNICODE_STRING UnicodeClassName;
 
            /* Limit the size of the static buffer on the stack to the
               size of the buffer provided by the caller */
            if (BufLen / sizeof(WCHAR) > AnsiClassName->MaximumLength)
            {
                BufLen = AnsiClassName->MaximumLength * sizeof(WCHAR);
            }
 
            /* Find out how big the buffer needs to be */
            Status = RtlQueryAtomInAtomTable(gAtomTable,
                                             Class->atomClassName,
                                             NULL,
                                             NULL,
                                             szStaticTemp,
                                             &BufLen);
            if (Status == STATUS_BUFFER_TOO_SMALL)
            {
                if (BufLen / sizeof(WCHAR) > AnsiClassName->MaximumLength)
                {
                    /* The buffer required exceeds the ansi buffer provided,
                       pretend like we're using the ansi buffer and limit the
                       size to the buffer size provided */
                    BufLen = AnsiClassName->MaximumLength * sizeof(WCHAR);
                }
 
                /* Allocate a temporary buffer that can hold the unicode class name */
                szTemp = ExAllocatePoolWithTag(PagedPool,
                                               BufLen,
                                               USERTAG_CLASS);
                if (szTemp == NULL)
                {
                    EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
                    _SEH2_LEAVE;
                }
 
                /* Query the class name */
                Status = RtlQueryAtomInAtomTable(gAtomTable,
                                                 Atom ? Atom : Class->atomNVClassName,
                                                 NULL,
                                                 NULL,
                                                 szTemp,
                                                 &BufLen);
            }
            else
                szTemp = szStaticTemp;
 
            if (NT_SUCCESS(Status))
            {
                /* Convert the atom name to ansi */
 
                RtlInitUnicodeString(&UnicodeClassName,
                                     szTemp);
 
                Status = RtlUnicodeStringToAnsiString(AnsiClassName,
                                                      &UnicodeClassName,
                                                      FALSE);
                if (!NT_SUCCESS(Status))
                {
                    SetLastNtError(Status);
                    _SEH2_LEAVE;
                }
            }
 
            Ret = BufLen / sizeof(WCHAR);
        }
        else /* !ANSI */
        {
            BufLen = ClassName->MaximumLength;
 
            /* Query the atom name */
            Status = RtlQueryAtomInAtomTable(gAtomTable,
                                             Atom ? Atom : Class->atomNVClassName,
                                             NULL,
                                             NULL,
                                             ClassName->Buffer,
                                             &BufLen);
 
            if (!NT_SUCCESS(Status))
            {
                SetLastNtError(Status);
                _SEH2_LEAVE;
            }
 
            Ret = BufLen / sizeof(WCHAR);
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        SetLastNtError(_SEH2_GetExceptionCode());
    }
    _SEH2_END;
 
    if (Ansi && szTemp != NULL && szTemp != szStaticTemp)
    {
        ExFreePoolWithTag(szTemp, USERTAG_CLASS);
    }
 
    return Ret;
}

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.

{
   PCLS pCls;
   PWND pWnd;
   PDESKTOP pDesk;
   PCALLPROCDATA CallProc = NULL;
   PTHREADINFO pti;
 
   pti = PsGetCurrentThreadWin32Thread();
 
   if ( Flags & (UserGetCPDWindow|UserGetCPDDialog) ||
        Flags & UserGetCPDWndtoCls)
   {
      pWnd = pvClsWnd;
      pCls = pWnd->pcls;
   }
   else
      pCls = pvClsWnd;
 
   // Search Class call proc data list.
   if (pCls->spcpdFirst)
      CallProc = UserSearchForCallProc( pCls->spcpdFirst, (WNDPROC)ProcIn, Flags);
 
   // No luck, create a new one for the requested proc.
   if (!CallProc)
   {
      if (!pCls->rpdeskParent)
      {
         TRACE("Null DESKTOP Atom %u\n",pCls->atomClassName);
         pDesk = pti->rpdesk;
      }
      else
         pDesk = pCls->rpdeskParent;
      CallProc = CreateCallProc( pDesk,
                                 (WNDPROC)ProcIn,
                                 !!(Flags & UserGetCPDA2U),
                                 pti->ppi);
      if (CallProc)
      {
          CallProc->spcpdNext = pCls->spcpdFirst;
          (void)InterlockedExchangePointer((PVOID*)&pCls->spcpdFirst,
                                                    CallProc);
          CallProc->wType = Flags;
      }
   }
   return (ULONG_PTR)(CallProc ? GetCallProcHandle(CallProc) : NULL);
}

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

UserRegisterSystemClasses()

BOOL FASTCALL UserRegisterSystemClasses

(

VOID

)

Definition at line 2309 of file class.c.

{
    UINT i;
    UNICODE_STRING ClassName, MenuName;
    PPROCESSINFO ppi = GetW32ProcessInfo();
    WNDCLASSEXW wc;
    PCLS Class;
    BOOL Ret = TRUE;
    HBRUSH hBrush;
    DWORD Flags = 0;
 
    if (ppi->W32PF_flags & W32PF_CLASSESREGISTERED)
       return TRUE;
 
    if ( hModClient == NULL)
       return FALSE;
 
    RtlZeroMemory(&ClassName, sizeof(ClassName));
    RtlZeroMemory(&MenuName, sizeof(MenuName));
 
    for (i = 0; i != ARRAYSIZE(DefaultServerClasses); i++)
    {
        if (!IS_ATOM(DefaultServerClasses[i].ClassName))
        {
           RtlInitUnicodeString(&ClassName, DefaultServerClasses[i].ClassName);
        }
        else
        {
           ClassName.Buffer = DefaultServerClasses[i].ClassName;
           ClassName.Length = 0;
           ClassName.MaximumLength = 0;
        }
 
        wc.cbSize = sizeof(wc);
        wc.style = DefaultServerClasses[i].Style;
 
        Flags |= CSF_SERVERSIDEPROC;
 
        if (DefaultServerClasses[i].ProcW)
        {
           wc.lpfnWndProc = DefaultServerClasses[i].ProcW;
           wc.hInstance = hModuleWin;
        }
        else
        {
           wc.lpfnWndProc = GETPFNSERVER(DefaultServerClasses[i].fiId);
           wc.hInstance = hModClient;
        }
 
        wc.cbClsExtra = 0;
        wc.cbWndExtra = DefaultServerClasses[i].ExtraBytes;
        wc.hIcon = NULL;
 
        wc.hCursor = NULL;
        if (DefaultServerClasses[i].hCursor == (HICON)OCR_NORMAL)
        {
            if (SYSTEMCUR(ARROW) == NULL)
            {
                ERR("SYSTEMCUR(ARROW) == NULL, should not happen!!\n");
            }
            else
            {
                wc.hCursor = UserHMGetHandle(SYSTEMCUR(ARROW));
            }
        }
 
        hBrush = DefaultServerClasses[i].hBrush;
        if (hBrush <= (HBRUSH)COLOR_MENUBAR)
        {
            hBrush = IntGetSysColorBrush(HandleToUlong(hBrush));
        }
        wc.hbrBackground = hBrush;
        wc.lpszMenuName = NULL;
        wc.lpszClassName = ClassName.Buffer;
        wc.hIconSm = NULL;
 
        Class = IntCreateClass( &wc,
                                &ClassName,
                                &ClassName,
                                &MenuName,
                                 DefaultServerClasses[i].fiId,
                                 Flags,
                                 NULL,
                                 ppi);
        if (Class != NULL)
        {
            Class->pclsNext = ppi->pclsPublicList;
            (void)InterlockedExchangePointer((PVOID*)&ppi->pclsPublicList,
                                             Class);
 
            ppi->dwRegisteredClasses |= ICLASS_TO_MASK(DefaultServerClasses[i].iCls);
        }
        else
        {
            ERR("!!! Registering system class failed!\n");
            Ret = FALSE;
        }
    }
    if (Ret) ppi->W32PF_flags |= W32PF_CLASSESREGISTERED;
    return Ret;
}

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

Variable Documentation

Atom

_Out_ RTL_ATOM* Atom

Definition at line 54 of file class.h.

Referenced by _Success_(), ewmh_modify_state(), get_property_value(), GetPropW(), IntAddAtom(), IntAddGlobalAtom(), IntCreateClass(), IntDeregisterClassAtom(), InternalAddAtom(), InternalDeleteAtom(), InternalFindAtom(), InternalGetAtomName(), IntFindClass(), IntGetClassAtom(), IntGetProp(), IntGhostWindowFromHungWindow(), IntIsGhostWindow(), IntSetClassAtom(), mwm_hide_decorations(), NtAddAtom(), NtDeleteAtom(), NtFindAtom(), NtQueryInformationAtom(), NtUserGetClassName(), NtUserRemoveProp(), NtUserSetProp(), RegisterClassExA(), RegisterClassExW(), RegisterClassExWOWW(), RegisterControlAtoms(), RegisterWindowMessageA(), RemovePropW(), RtlAddAtomToAtomTable(), RtlAtomTestThread(), RtlDeleteAtomFromAtomTable(), RtlLookupAtomInAtomTable(), RtlPinAtomInAtomTable(), RtlQueryAtomInAtomTable(), SetPropW(), START_TEST(), test_NtRefPinAtom(), UserGetClassName(), UserGetProp(), xclip_handle_PropertyNotify(), xclip_handle_SelectionNotify(), xclip_handle_SelectionRequest(), and xwin_process_events().