class.c File Reference

#include "precomp.h"

Go to the source code of this file.

Defines
#define	INDEX_OFFSET   GCLP_HICONSM
Functions
ATOM	xxxRegisterClassEx (LPWNDCLASSEX cczpwc, PCLSMENUNAME pcmn, WORD fnid, DWORD dwFlags, LPDWORD pdwWOW)
PVOID	ClassAlloc (PDESKTOP pdesk, DWORD cbAlloc)
VOID	ClassFree (PDESKTOP pdesk, PVOID pvfree)
BOOL	ValidateAndLockCursor (PCURSOR *ppcursor, BOOL fIs40Compat)
PCLS	InternalRegisterClassEx (LPWNDCLASSEX cczlpwndcls, WORD fnid, DWORD CSF_flags)
BOOL	_UnregisterClass (LPCWSTR ccxlpszClassName, HANDLE hModule, PCLSMENUNAME pcmn)
PCLS	_GetWOWClass (HANDLE hModule, LPCWSTR ccxlpszClassName)
ATOM	_GetClassInfoEx (HANDLE hModule, LPCWSTR ccxlpszClassName, LPWNDCLASSEX pwc, LPWSTR *ppszMenuName, BOOL bAnsi)
WORD	_SetClassWord (PWND pwnd, int index, WORD value)
ULONG_PTR	xxxSetClassLongPtr (PWND pwnd, int index, ULONG_PTR value, BOOL bAnsi)
PPCLS	_InnerGetClassPtr (ATOM atom, PPCLS ppcls, HANDLE hModule)
PPCLS	GetClassPtr (ATOM atom, PPROCESSINFO ppi, HANDLE hModule)
VOID	UnlockAndFreeCPDs (PCALLPROCDATA *ppCPD)
void	DestroyClassBrush (PCLS pcls)
void	DestroyClass (PPCLS ppcls)
PCURSOR	GetClassIcoCur (PWND pwnd, int index)
ULONG_PTR	SetClassCursor (PWND pwnd, PCLS pcls, DWORD index, ULONG_PTR dwData)
ULONG_PTR	xxxSetClassData (PWND pwnd, int index, ULONG_PTR dwData, BOOL bAnsi)
BOOL	ReferenceClass (PCLS pcls, PWND pwnd)
VOID	DereferenceClass (PWND pwnd)
VOID	DestroyProcessesClasses (PPROCESSINFO ppi)
Variables
CONST BYTE	afClassDWord []
CONST BYTE	aiClassOffset []

---

Define Documentation

#define INDEX_OFFSET   GCLP_HICONSM

Definition at line 87 of file class.c.

---

Function Documentation

ATOM _GetClassInfoEx (  HANDLE  hModule, LPCWSTR  ccxlpszClassName, LPWNDCLASSEX  pwc, LPWSTR *  ppszMenuName, BOOL  bAnsi )

Definition at line 678 of file class.c. References tagCLS::atomClassName, CheckCritIn, CPD_ANSI_TO_UNICODE, CPD_CLASS, CPD_UNICODE_TO_ANSI, CSF_ANSIPROC, tagCLS::CSF_flags, CSF_SERVERSIDEPROC, CURSORF_SECRET, tagTHREADINFO::dwExpWinVer, DWORD, FindClassAtom, tagCLS::fnid, GetClassPtr(), GetCPD(), hModClient, hModuleWin, tagCLS::lpszClientAnsiMenuName, tagCLS::lpszClientUnicodeMenuName, MapClientNeuterToClientPfn(), MapServerToClientPfn(), NULL, tagTHREADINFO::ppi, PtiCurrent, PtoH, TIF_16BIT, tagTHREADINFO::TIF_flags, and VER40. Referenced by NtUserGetClassInfo(). { PCLS pcls; PPCLS ppcls; ATOM atomT; PTHREADINFO ptiCurrent; DWORD dwCPDType = 0; CheckCritIn(); ptiCurrent = PtiCurrent(); /* * These are done first so if we don't find the class, and therefore * fail, the return thank won't try to copy back these (nonexistant) * strings. */ pwc->lpszMenuName = NULL; pwc->lpszClassName = NULL; /* * Is this class registered as a private class? */ /* * bradg (3/9/95) - Must first check to see if an ATOM has been passed. */ atomT = FindClassAtom(ccxlpszClassName); /* * Windows 3.1 does not perform the class search with * a null hModule. If an application supplies a NULL * hModule, they search on hModuleWin instead. */ if (hModule == NULL) hModule = hModClient; ppcls = GetClassPtr(atomT, ptiCurrent->ppi, hModule); if (ppcls == NULL) { RIPERR0(ERROR_CLASS_DOES_NOT_EXIST, RIP_VERBOSE, "GetClassInfo: Class does not exist"); return 0; } pcls = *ppcls; /* * Copy all the fields common to CLS and WNDCLASS structures except * the lpszMenuName and lpszClassName which will be filled in by the * client-side piece of GetClassInfo. */ /* * Return public bits only */ pwc->style = pcls->style & CS_VALID; /* * Corel Depth 6.0 calls GetClassInfo (COMBOBOX) and registers a class * using the same name and style bits. This works OK on Win95 because * their "system" (combo, edit, etc) classes are not CS_GLOBALCLASS * So we got to mask this bit out for our classes */ /* * Bug 17998. If the app is 32bit and WinVer is less than 4.0 don't mask * out the CS_GLOBALCLASS bit. */ if ( (pcls->fnid != 0) && ((LOWORD(ptiCurrent->dwExpWinVer) >= VER40) || (ptiCurrent->TIF_flags & TIF_16BIT)) ) { pwc->style &= ~CS_GLOBALCLASS; } pwc->cbClsExtra = pcls->cbclsExtra; pwc->cbWndExtra = pcls->cbwndExtra; /* * Stop 32-bit apps from inadvertantly using hModuleWin as their hInstance * when they register a window class. FritzS */ if (LOWORD(ptiCurrent->dwExpWinVer) >= VER40) { /* * This is actually, Win95 behavior -- the USER.EXE hModule gets thunked to NULL on * the way out of the 16->32 bit thunk. Note -- if we ever need to support 16-bit * 4.0 apps (shudder), this may need to change. FritzS */ if (hModule == hModClient) { pwc->hInstance = NULL; } else { pwc->hInstance = hModule; } } else { /* * Win NT 3.1/3.51 returned the hInstance from the class. * Note that this is incompatible with Win 3.1. WoW has hacks for 16-bit apps. */ if ((pcls->hModule == hModuleWin) || (pcls->hModule == hModClient)) { pwc->hInstance = hModClient; } else { pwc->hInstance = pcls->hModule; } } pwc->hIcon = PtoH(pcls->spicn); pwc->hCursor = PtoH(pcls->spcur); pwc->hbrBackground = pcls->hbrBackground; /* * Need to hide the small icon if it's USER created */ if (pcls->spicnSm && (pcls->spicnSm->CURSORF_flags & CURSORF_SECRET)) pwc->hIconSm = NULL; else pwc->hIconSm = PtoH(pcls->spicnSm); /* * If its a server proc then map it to a client proc. If not we may have * to create a CPD. */ if (pcls->CSF_flags & CSF_SERVERSIDEPROC) { pwc->lpfnWndProc = (WNDPROC)MapServerToClientPfn((ULONG_PTR)pcls->lpfnWndProc, bAnsi); } else { pwc->lpfnWndProc = (WNDPROC)MapClientNeuterToClientPfn(pcls, 0, bAnsi); /* * If the client mapping didn't change the window proc then see if * we need a callproc handle. */ if (pwc->lpfnWndProc == (WNDPROC)pcls->lpfnWndProc) { /* * Need to return a CallProc handle if there is an Ansi/Unicode mismatch */ if (bAnsi != !!(pcls->CSF_flags & CSF_ANSIPROC)) { dwCPDType |= bAnsi ? CPD_ANSI_TO_UNICODE : CPD_UNICODE_TO_ANSI; } } } if (dwCPDType) { ULONG_PTR dwCPD; dwCPD = GetCPD(pcls, dwCPDType | CPD_CLASS, (ULONG_PTR)pwc->lpfnWndProc); if (dwCPD) { pwc->lpfnWndProc = (WNDPROC)dwCPD; } else { RIPMSG0(RIP_WARNING, "GetClassInfo unable to alloc CPD returning handle\n"); } } /* * Return the stashed pointer to the client-side menu name string. */ if (bAnsi) { *ppszMenuName = (LPWSTR)pcls->lpszClientAnsiMenuName; } else { *ppszMenuName = pcls->lpszClientUnicodeMenuName; } return pcls->atomClassName; }

PCLS _GetWOWClass (  HANDLE  hModule, LPCWSTR  ccxlpszClassName )

Definition at line 616 of file class.c. References CheckCritInShared, GetClassPtr(), NULL, tagCLS::pclsClone, tagCLS::pclsNext, tagTHREADINFO::ppi, PtiCurrentShared, tagTHREADINFO::rpdesk, tagCLS::rpdeskParent, and UserFindAtom(). Referenced by NtUserGetWOWClass(). { PCLS pcls; PPCLS ppcls = NULL; ATOM atomT; PTHREADINFO ptiCurrent; CheckCritInShared(); ptiCurrent = PtiCurrentShared(); /* * Is this class registered as a private class? */ atomT = UserFindAtom(ccxlpszClassName); if (atomT != 0) ppcls = GetClassPtr(atomT, ptiCurrent->ppi, hModule); if (ppcls == NULL) { RIPERR0(ERROR_CLASS_DOES_NOT_EXIST, RIP_VERBOSE, ""); return NULL; } pcls = *ppcls; if (ptiCurrent->rpdesk != pcls->rpdeskParent) { pcls = pcls->pclsClone; while (pcls != NULL) { if (ptiCurrent->rpdesk == pcls->rpdeskParent) { goto Done; } pcls = pcls->pclsNext; } RIPERR0(ERROR_CLASS_DOES_NOT_EXIST, RIP_VERBOSE, ""); return NULL; } Done: return pcls; }

PPCLS _InnerGetClassPtr (  ATOM  atom, PPCLS  ppcls, HANDLE  hModule )

Definition at line 997 of file class.c. References CSF_WOWDEFERDESTROY, and NULL. Referenced by _UnregisterClass(), GetClassPtr(), and InternalRegisterClassEx(). { if (atom == 0) return NULL; while (*ppcls != NULL) { if ((*ppcls)->atomClassName == atom && (hModule == NULL || HIWORD((ULONG_PTR)(*ppcls)->hModule) == HIWORD((ULONG_PTR)hModule)) && !((*ppcls)->CSF_flags & CSF_WOWDEFERDESTROY)) { return ppcls; } ppcls = (PPCLS)*ppcls; } return NULL; }

WORD _SetClassWord (  PWND  pwnd, int  index, WORD  value )

Definition at line 863 of file class.c. References BYTE, CheckCritIn, GETPTI, NULL, tagWND::pcls, tagCLS::pclsBase, tagCLS::pclsClone, tagCLS::pclsNext, and PpiCurrent. Referenced by NtUserSetClassWord(). { WORD wOld; WORD UNALIGNED *pw; PCLS pcls; CheckCritIn(); if (GETPTI(pwnd)->ppi != PpiCurrent()) { RIPERR1(ERROR_ACCESS_DENIED, RIP_WARNING, "SetClassWord: different process: index 0x%lx", index); return 0; } pcls = pwnd->pcls->pclsBase; if ((index < 0) || (index + (int)sizeof(WORD) > pcls->cbclsExtra)) { RIPERR0(ERROR_INVALID_INDEX, RIP_WARNING, "SetClassWord: invalid index"); return 0; } else { pw = (WORD UNALIGNED *)((BYTE *)(pcls + 1) + index); wOld = *pw; *pw = value; pcls = pcls->pclsClone; while (pcls != NULL) { pw = (WORD UNALIGNED *)((BYTE *)(pcls + 1) + index); *pw = value; pcls = pcls->pclsNext; } return wOld; } }

BOOL _UnregisterClass (  LPCWSTR  ccxlpszClassName, HANDLE  hModule, PCLSMENUNAME  pcmn )

Definition at line 555 of file class.c. References _InnerGetClassPtr(), BOOL, CheckCritIn, DestroyClass(), DWORD, FALSE, FindClassAtom, NULL, tagPROCESSINFO::pclsPrivateList, tagPROCESSINFO::pclsPublicList, tagTHREADINFO::ppi, tagCLSMENUNAME::pszClientAnsiMenuName, PtiCurrent, tagCLSMENUNAME::pusMenuName, tagCLSMENUNAME::pwszClientUnicodeMenuName, and TRUE. Referenced by NtUserUnregisterClass(). { ATOM atomT; PPCLS ppcls; PTHREADINFO ptiCurrent; CheckCritIn(); ptiCurrent = PtiCurrent(); /* * Check whether the given ClassName is already registered by the * Application with the given handle. * Return error, if either the Class does not exist or it does not * belong to the calling process. */ /* * bradg (3/9/95) - Must first check to see if an ATOM has been passed */ atomT = FindClassAtom(ccxlpszClassName); ppcls = _InnerGetClassPtr(atomT, &ptiCurrent->ppi->pclsPrivateList, hModule); if (ppcls == NULL) { /* * Maybe this is a public class. */ ppcls = _InnerGetClassPtr(atomT, &ptiCurrent->ppi->pclsPublicList, NULL); if (ppcls == NULL) { RIPERR1(ERROR_CLASS_DOES_NOT_EXIST, RIP_WARNING, "UnregisterClass: Class does not exist; atom=%lX", (DWORD)atomT); return FALSE; } } /* * If any windows created with this class still exist return an error. */ if ((*ppcls)->cWndReferenceCount != 0) { RIPERR0(ERROR_CLASS_HAS_WINDOWS, RIP_WARNING, "UnregisterClass: Class still has window"); return FALSE; } /* * Return client side pointers for cleanup */ pcmn->pszClientAnsiMenuName = (*ppcls)->lpszClientAnsiMenuName; pcmn->pwszClientUnicodeMenuName = (*ppcls)->lpszClientUnicodeMenuName; pcmn->pusMenuName = NULL; /* * Release the Window class and related information. */ DestroyClass(ppcls); return TRUE; }

PVOID ClassAlloc (  PDESKTOP  pdesk, DWORD  cbAlloc )

Definition at line 169 of file class.c. References DesktopAllocAlways, and DTAG_CLASS. Referenced by InternalRegisterClassEx(), and ReferenceClass(). { PVOID pvalloc; if (pdesk) /* * Later5.0 GerardoB. Make this allocation directly to avoid * DesktopAlloc from failing it when the desktop is destroyed. * When destroying a locked window, we might need to clone the * zombie class which requires an allocation on the wnd's desktop. * We need to make sure that the client side doesn't get to the * class of a zombie window; then we won't need to make the heap * allocation; or is there any other reason for that allocation? */ pvalloc = (PCLS)DesktopAllocAlways(pdesk, cbAlloc, DTAG_CLASS); else { pvalloc = (PCLS)UserAllocPoolWithQuotaZInit(cbAlloc, TAG_CLASS); } return pvalloc; }

VOID ClassFree (  PDESKTOP  pdesk, PVOID  pvfree )

Definition at line 193 of file class.c. References DesktopFree, NULL, and VOID(). Referenced by DestroyClass(), InternalRegisterClassEx(), and ReferenceClass(). { if (pdesk != NULL) DesktopFree(pdesk, pvfree); else UserFreePool(pvfree); }

VOID DereferenceClass (  PWND  pwnd  )

Definition at line 1735 of file class.c. References tagCLS::cWndReferenceCount, DestroyClass(), tagWND::pcls, tagCLS::pclsBase, tagCLS::pclsClone, tagCLS::pclsNext, and VOID(). Referenced by HMChangeOwnerThread(), and xxxFreeWindow(). { PCLS pcls = pwnd->pcls; PPCLS ppcls; UserAssert(pcls->cWndReferenceCount >= 1); pcls->cWndReferenceCount--; if (pcls != pcls->pclsBase) { UserAssert(pcls->pclsBase->cWndReferenceCount >= 1); pcls->pclsBase->cWndReferenceCount--; if (pcls->cWndReferenceCount == 0) { ppcls = &pcls->pclsBase->pclsClone; while ((*ppcls) != pcls) ppcls = &(*ppcls)->pclsNext; UserAssert(ppcls); DestroyClass(ppcls); } } }

void DestroyClass (  PPCLS  ppcls  )

Definition at line 1207 of file class.c. References tagCLS::atomClassName, ClassFree(), tagCLS::cWndReferenceCount, DestroyCacheDC(), DestroyClassBrush(), DestroyClassSmIcon(), tagDCE::hdc, IS_PTR, LockDesktop, NULL, tagCLS::pclsBase, tagCLS::pclsClone, tagCLS::pclsNext, tagCLS::pdce, PtiCurrent, tagCLS::rpdeskParent, tagCLS::spcpdFirst, Unlock, UnlockAndFreeCPDs(), UnlockDesktop, and UserDeleteAtom(). Referenced by _UnregisterClass(), _WOWCleanup(), _WOWModuleUnload(), CleanupResources(), DereferenceClass(), DestroyProcessesClasses(), and FinalUserInit(). { PPCLS ppclsClone; PCLS pcls; PDESKTOP rpdesk; pcls = *ppcls; UserAssert(pcls->cWndReferenceCount == 0); /* * If this is a base class, destroy all clones before deleting * stuff. */ if (pcls == pcls->pclsBase) { ppclsClone = &pcls->pclsClone; while (*ppclsClone != NULL) { DestroyClass(ppclsClone); } UserDeleteAtom(pcls->atomClassName); /* * No freeing if it's an integer resource. */ if (IS_PTR(pcls->lpszMenuName)) { UserFreePool(pcls->lpszMenuName); } /* * Free up the class dc if there is one. */ if (pcls->pdce != NULL) DestroyCacheDC(NULL, pcls->pdce->hdc); /* * Delete the hBrBackground brush if nobody else is * using it. */ DestroyClassBrush(pcls); } /* * If we created the small icon delete it */ DestroyClassSmIcon(pcls); /* * Unlock cursor and icon */ Unlock(&pcls->spicn); Unlock(&pcls->spicnSm); Unlock(&pcls->spcur); /* * Free any CallProcData objects associated with this class */ if (pcls->spcpdFirst) { UnlockAndFreeCPDs(&pcls->spcpdFirst); } /* * Point the previous guy at the guy we currently point to. */ *ppcls = pcls->pclsNext; /* * Lock the desktop. Do not use a thread lock because * this may be called during process cleanup when thread * locks are no longer usable. */ rpdesk = NULL; LockDesktop(&rpdesk, pcls->rpdeskParent, LDL_FN_DESTROYCLASS, (ULONG_PTR)PtiCurrent()); UnlockDesktop(&pcls->rpdeskParent, LDU_CLS_DESKPARENT2, (ULONG_PTR)pcls); ClassFree(rpdesk, pcls->lpszAnsiClassName); ClassFree(rpdesk, pcls); UnlockDesktop(&rpdesk, LDU_FN_DESTROYCLASS, (ULONG_PTR)PtiCurrent()); }

void DestroyClassBrush (  PCLS  pcls  )

Definition at line 1128 of file class.c. References BOOL, gpclsList, tagCLS::pclsNext, tagPROCESSINFO::pclsPrivateList, tagPROCESSINFO::pclsPublicList, PpiCurrent, and SYSHBRUSH. Referenced by DestroyClass(). { PPROCESSINFO ppi = PpiCurrent(); PCLS pclsWalk; int nInd; BOOL bRet; /* * Return if it's not a real brush */ if (pcls->hbrBackground <= (HBRUSH)(COLOR_MAX)) return; /* * Don't delete the system brushes */ for (nInd = 0; nInd < COLOR_MAX; nInd++) { if (pcls->hbrBackground == SYSHBRUSH(nInd)) return; } /* * Walk the process public public list */ pclsWalk = ppi->pclsPublicList; while (pclsWalk) { if (pclsWalk != pcls && pclsWalk->hbrBackground == pcls->hbrBackground) return; pclsWalk = pclsWalk->pclsNext; } /* * Walk the process private class list */ pclsWalk = ppi->pclsPrivateList; while (pclsWalk) { if (pclsWalk != pcls && pclsWalk->hbrBackground == pcls->hbrBackground) return; pclsWalk = pclsWalk->pclsNext; } /* * Finaly walk the system class list */ pclsWalk = gpclsList; while (pclsWalk) { if (pclsWalk != pcls && pclsWalk->hbrBackground == pcls->hbrBackground) return; pclsWalk = pclsWalk->pclsNext; } bRet = GreDeleteObject(pcls->hbrBackground); #if DBG if (!bRet) RIPERR1(ERROR_INVALID_HANDLE, RIP_WARNING, "DestroyClassBrush: failed to destroy brush %#p", pcls->hbrBackground); #endif }

VOID DestroyProcessesClasses (  PPROCESSINFO  ppi  )

Definition at line 1768 of file class.c. References DestroyClass(), NULL, tagPROCESSINFO::pclsPrivateList, tagPROCESSINFO::pclsPublicList, and VOID(). Referenced by xxxDestroyThreadInfo(). { PPCLS ppcls; /* * Destroy the private classes first */ ppcls = &(ppi->pclsPrivateList); while (*ppcls != NULL) { DestroyClass(ppcls); } /* * Then the cloned public classes */ ppcls = &(ppi->pclsPublicList); while (*ppcls != NULL) { DestroyClass(ppcls); } }

PCURSOR GetClassIcoCur (  PWND  pwnd, int  index )

Definition at line 1297 of file class.c. References NULL, and tagWND::pcls. { PCLS pcls = pwnd->pcls; PCURSOR pcur; switch (index) { case GCLP_HICON: pcur = pcls->spicn; break; case GCLP_HCURSOR: pcur = pcls->spcur; break; case GCLP_HICONSM: pcur = pcls->spicnSm; break; default: RIPMSG2(RIP_WARNING, "GetWndIcoCur: Invalid index:%#lx. pwnd:%#p", index, pwnd); pcur = NULL; } return pcur; }

PPCLS GetClassPtr (  ATOM  atom, PPROCESSINFO  ppi, HANDLE  hModule )

Definition at line 1036 of file class.c. References _InnerGetClassPtr(), gpclsList, hModClient, NULL, tagPROCESSINFO::pclsPrivateList, and tagPROCESSINFO::pclsPublicList. Referenced by _GetClassInfoEx(), _GetWOWClass(), HMChangeOwnerThread(), xxxCreateWindowEx(), and xxxFreeWindow(). { PPCLS ppcls; /* * First search public then private then usersrv registered classes */ ppcls = _InnerGetClassPtr(atom, &ppi->pclsPrivateList, hModule); if (ppcls) return ppcls; ppcls = _InnerGetClassPtr(atom, &ppi->pclsPublicList, NULL); if (ppcls) return ppcls; /* * Next seach public and private classes and override hmodule; * some apps (bunny) do a GetClassInfo(dialog) and RegisterClass * and only change the wndproc which set the hmodule to be just * like usersrv created it even though it is in the app's public * or private class list */ /* * Later -- since we are no longer returning hModuleWin to any app, * we may only need to check for hModClient. Check this out. * FritzS */ ppcls = _InnerGetClassPtr(atom, &ppi->pclsPrivateList, hModClient); if (ppcls) return ppcls; ppcls = _InnerGetClassPtr(atom, &ppi->pclsPublicList, hModClient); if (ppcls) return ppcls; /* * Search the system class list */ ppcls = _InnerGetClassPtr(atom, &gpclsList, NULL); return ppcls; }

PCLS InternalRegisterClassEx (  LPWNDCLASSEX  cczlpwndcls, WORD  fnid, DWORD  CSF_flags )

Definition at line 244 of file class.c. References _InnerGetClassPtr(), AllocateUnicodeString(), BOOL, CBFNID, CheckCritIn, _CLIENTINFO::CI_flags, CI_REGISTERCLASSES, ClassAlloc(), ClassFree(), COMMON_WNDCLASS, CSF_ANSIPROC, CSF_SERVERSIDEPROC, CSF_SYSTEMCLASS, CSF_WIN40COMPAT, CSF_WOWCLASS, tagTHREADINFO::dwExpWinVer, DWORD, FALSE, FindClassAtom, gpclsList, hModuleWin, IS_PTR, L, LockDesktop, MapClientToServerPfn(), NULL, tagTHREADINFO::pClientInfo, tagCLS::pclsNext, tagPROCESSINFO::pclsPrivateList, tagPROCESSINFO::pclsPublicList, tagTHREADINFO::ppi, PtiCurrent, PTR_TO_ID, tagTHREADINFO::rpdesk, tagCLS::rpdeskParent, RtlInitUnicodeString(), RtlIntegerToChar(), RtlUnicodeStringToAnsiString(), tagTHREADINFO::TIF_flags, TIF_SYSTEMTHREAD, Unlock, UnlockDesktop, UserAddAtom(), UserDeleteAtom(), USHORT, ValidateAndLockCursor(), VER40, WND, and WNDPROC_PWND. Referenced by LW_RegisterWindows(), and xxxRegisterClassEx(). { BOOL fIs40Compat; ULONG_PTR dwT; PCLS pcls; LPWSTR pszT1; ATOM atomT; PTHREADINFO ptiCurrent; HANDLE hModule; PDESKTOP pdesk; ULONG cch; UNICODE_STRING UString; ANSI_STRING AString; /* * NOTE -- lpszClassName and lpszMenuName in the wndclass may be client-side * pointers. Use of those fields must be protected in try blocks. */ CheckCritIn(); ptiCurrent = PtiCurrent(); /* * Don't allow 4.0 apps to register a class using hModuleWin * LATER GerardoB: Our client side classes use hmodUser (USER32) while * our server side classes use hWinInstance (WIN32K). We should change * CreateThreadInfo and LW_RegisterWindows so all classes use hModUser. */ hModule = cczlpwndcls->hInstance; if (!(CSF_flags & (CSF_SYSTEMCLASS | CSF_SERVERSIDEPROC)) && (hModule == hModuleWin) && (LOWORD(ptiCurrent->dwExpWinVer) >= VER40)) { RIPERR0(ERROR_INVALID_PARAMETER, RIP_WARNING, "InternalRegisterClassEx: Invalid hInstance (Cannot use system's hInstance)"); return NULL; } /* * As of NT 4.0 we no longer honor CS_BYTEALIGNCLIENT or CS_BYTEALIGNWINDOW */ if (cczlpwndcls->style & (CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW)) { RIPMSG0(RIP_VERBOSE, "CS_BYTEALIGNCLIENT and CS_BYTEALIGNWINDOW styles no longer honored."); } /* * Does this class exist as a private class? If so, fail. */ atomT = FindClassAtom(cczlpwndcls->lpszClassName); if (atomT != 0 && !(CSF_flags & CSF_SERVERSIDEPROC)) { /* * First check private classes. If already exists, return error. */ if (_InnerGetClassPtr(atomT, &ptiCurrent->ppi->pclsPrivateList, hModule) != NULL) { RIPERR1(ERROR_CLASS_ALREADY_EXISTS, RIP_VERBOSE, "RegisterClass: Class already exists %lx", (DWORD)atomT); return NULL; } /* * Now only check public classes if CS_GLOBALCLASS is set. If it * isn't set, then this will allow an application to re-register * a private class to take precedence over a public class. */ if (cczlpwndcls->style & CS_GLOBALCLASS) { if (_InnerGetClassPtr(atomT, &ptiCurrent->ppi->pclsPublicList, NULL) != NULL) { RIPERR0(ERROR_CLASS_ALREADY_EXISTS, RIP_VERBOSE, "RegisterClass: Global Class already exists"); return NULL; } } } /* * Alloc space for the class. */ if (ptiCurrent->TIF_flags & TIF_SYSTEMTHREAD) { pdesk = NULL; } else { pdesk = ptiCurrent->rpdesk; } pcls = (PCLS)ClassAlloc(pdesk, sizeof(CLS) + cczlpwndcls->cbClsExtra + (CSF_flags & CSF_WOWCLASS ? sizeof(WC):0)); if (pcls == NULL) { return NULL; } LockDesktop(&pcls->rpdeskParent, pdesk, LDL_CLS_DESKPARENT1, (ULONG_PTR)pcls); pcls->pclsBase = pcls; /* * Copy over the shared part of the class structure. */ UserAssert(FIELD_OFFSET(WNDCLASSEX, style) == FIELD_OFFSET(COMMON_WNDCLASS, style)); RtlCopyMemory(&pcls->style, &(cczlpwndcls->style), sizeof(COMMON_WNDCLASS) - FIELD_OFFSET(COMMON_WNDCLASS, style)); /* * Copy CSF_SERVERSIDEPROC, CSF_ANSIPROC (etc.) flags */ pcls->CSF_flags = LOWORD(CSF_flags); pcls->fnid = fnid; if (fnid) { CBFNID(fnid) = (WORD)(pcls->cbwndExtra + sizeof(WND)); if (!(pcls->CSF_flags & CSF_SERVERSIDEPROC) && ptiCurrent->pClientInfo != NULL) { /* * Clear the bit so new threads in this process * won't bother to reregister the client-side USER classes. */ ptiCurrent->pClientInfo->CI_flags &= ~CI_REGISTERCLASSES; } } /* * If this wndproc happens to be a client wndproc stub for a server * wndproc, then remember the server wndproc! This should be rare: why * would an application re-register a class that isn't "subclassed"? */ if (!(pcls->CSF_flags & CSF_SERVERSIDEPROC)) { dwT = MapClientToServerPfn((ULONG_PTR)pcls->lpfnWndProc); if (dwT != 0) { pcls->CSF_flags |= CSF_SERVERSIDEPROC; pcls->CSF_flags &= ~CSF_ANSIPROC; pcls->lpfnWndProc = (WNDPROC_PWND)dwT; } } /* * Win95 compatible validation. * * hbrBackground was validated by GDI in the client side * NULL hInstances are mapped to GetModuleHandle(NULL) in the client * side */ fIs40Compat = (CSF_flags & CSF_WIN40COMPAT) != 0; if (!ValidateAndLockCursor(&pcls->spcur, fIs40Compat)) { goto ValidateError1; } if (!ValidateAndLockCursor(&pcls->spicn, fIs40Compat)) { goto ValidateError2; } if (!ValidateAndLockCursor(&pcls->spicnSm, fIs40Compat)) { goto ValidateError3; } /* * Add the class name to the atom table. */ if (IS_PTR(cczlpwndcls->lpszClassName)) atomT = UserAddAtom(cczlpwndcls->lpszClassName, FALSE); else atomT = PTR_TO_ID(cczlpwndcls->lpszClassName); if (atomT == 0) { goto AtomError; } pcls->atomClassName = atomT; /* * Make an ANSI version of the class name to optimize * GetClassNameA for WOW. */ if (IS_PTR(cczlpwndcls->lpszClassName)) { try { RtlInitUnicodeString(&UString, cczlpwndcls->lpszClassName); } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { goto MemError2; } #ifdef FE_SB // InternalRegisterClassEx() cch = UString.Length + 1; #else cch = UString.Length / sizeof(WCHAR) + 1; #endif // FE_SB } else { cch = 7; // 1 char for '#', 5 for '65536'. } /* * Allocate the ANSI name buffer and convert the unicode name * to ANSI. */ pcls->lpszAnsiClassName = (LPSTR)ClassAlloc(pdesk, cch); if (pcls->lpszAnsiClassName == NULL) { goto MemError2; } /* * Form the ANSI class name. */ if (IS_PTR(cczlpwndcls->lpszClassName)) { /* * Class name is a string. */ AString.Length = 0; AString.MaximumLength = (USHORT)cch; AString.Buffer = pcls->lpszAnsiClassName; try { RtlUnicodeStringToAnsiString(&AString, &UString, FALSE); } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { goto MemError3; } } else { /* * Class name is an integer atom. */ pcls->lpszAnsiClassName[0] = L'#'; RtlIntegerToChar(PTR_TO_ID(cczlpwndcls->lpszClassName), 10, cch - 1, &pcls->lpszAnsiClassName[1]); } /* * Make local copy of menu name. */ pszT1 = pcls->lpszMenuName; if (pszT1 != NULL) { if (IS_PTR(pszT1)) { try { RtlInitUnicodeString(&UString, pszT1); } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { goto MemError3; } if (UString.Length == 0) { /* * app passed an empty string for the name */ pcls->lpszMenuName = NULL; } else { UNICODE_STRING strMenuName; /* * Alloc space for the Menu Name. */ if (!AllocateUnicodeString(&strMenuName, &UString)) { MemError3: ClassFree(pdesk, pcls->lpszAnsiClassName); MemError2: UserDeleteAtom(pcls->atomClassName); AtomError: Unlock(&pcls->spicnSm); ValidateError3: Unlock(&pcls->spicn); ValidateError2: Unlock(&pcls->spcur); ValidateError1: UnlockDesktop(&pcls->rpdeskParent, LDU_CLS_DESKPARENT1, (ULONG_PTR)pcls); ClassFree(pdesk, pcls); return NULL; } pcls->lpszMenuName = strMenuName.Buffer; } } } if ((CSF_flags & CSF_SERVERSIDEPROC) || (pcls->style & CS_GLOBALCLASS)) { if (pcls->CSF_flags & CSF_SYSTEMCLASS) { pcls->pclsNext = gpclsList; gpclsList = pcls; } else { pcls->pclsNext = ptiCurrent->ppi->pclsPublicList; ptiCurrent->ppi->pclsPublicList = pcls; } } else { pcls->pclsNext = ptiCurrent->ppi->pclsPrivateList; ptiCurrent->ppi->pclsPrivateList = pcls; } /* * Because Memory is allocated with ZEROINIT, the pcls->cWndReferenceCount * field is automatically initialised to zero. */ return pcls; }

BOOL ReferenceClass (  PCLS  pcls, PWND  pwnd )

Definition at line 1645 of file class.c. References BOOL, ClassAlloc(), ClassFree(), CLS, tagCLS::CSF_flags, CSF_WOWCLASS, tagCLS::cWndReferenceCount, DWORD, FALSE, tagWND::head, Lock, LockDesktop, NULL, tagWND::pcls, tagCLS::pclsClone, tagCLS::pclsNext, tagCLS::rpdeskParent, strlen(), and TRUE. Referenced by xxxCreateWindowEx(). { DWORD cbName; PCLS pclsClone; PDESKTOP pdesk; /* * If the window is on the same desktop as the base class, just * increment the window count. */ if (pcls->rpdeskParent == pwnd->head.rpdesk) { pcls->cWndReferenceCount++; return TRUE; } /* * The window is not on the base desktop. Try to find a cloned * class. */ for (pclsClone = pcls->pclsClone; pclsClone != NULL; pclsClone = pclsClone->pclsNext) { if (pclsClone->rpdeskParent == pwnd->head.rpdesk) break; } /* * If we can't find one, clone the base class. */ if (pclsClone == NULL) { pdesk = pwnd->head.rpdesk; pclsClone = ClassAlloc(pdesk, sizeof(CLS) + pcls->cbclsExtra + (pcls->CSF_flags & CSF_WOWCLASS ?sizeof(WC):0)); if (pclsClone == NULL) { RIPMSG0(RIP_WARNING, "ReferenceClass: Failed Clone-Class Allocation\n"); return FALSE; } RtlCopyMemory(pclsClone, pcls, sizeof(CLS) + pcls->cbclsExtra + (pcls->CSF_flags & CSF_WOWCLASS?sizeof(WC):0)); cbName = strlen(pcls->lpszAnsiClassName) + 1; pclsClone->lpszAnsiClassName = ClassAlloc(pdesk, cbName); if (pclsClone->lpszAnsiClassName == NULL) { ClassFree(pdesk, pclsClone); RIPMSG0(RIP_WARNING, "ReferenceClass: No Clone Class Name\n"); return FALSE; } /* * Everything has been allocated, now lock everything down. * NULL pointers in clone to prevent Lock() from incorrectly * decrementing object reference count */ pclsClone->rpdeskParent = NULL; LockDesktop(&pclsClone->rpdeskParent, pdesk, LDL_CLS_DESKPARENT2, (ULONG_PTR)pclsClone); pclsClone->pclsNext = pcls->pclsClone; pclsClone->pclsClone = NULL; pcls->pclsClone = pclsClone; RtlCopyMemory(pclsClone->lpszAnsiClassName, pcls->lpszAnsiClassName, cbName); pclsClone->spicn = pclsClone->spicnSm = pclsClone->spcur = NULL; Lock(&pclsClone->spicn, pcls->spicn); Lock(&pclsClone->spicnSm, pcls->spicnSm); Lock(&pclsClone->spcur, pcls->spcur); pclsClone->spcpdFirst = NULL; pclsClone->cWndReferenceCount = 0; } /* * Increment reference counts. */ pcls->cWndReferenceCount++; pclsClone->cWndReferenceCount++; pwnd->pcls = pclsClone; return TRUE; }

ULONG_PTR SetClassCursor (  PWND  pwnd, PCLS  pcls, DWORD  index, ULONG_PTR  dwData )

Definition at line 1329 of file class.c. References CheckLock, HMValidateHandle(), Lock, NULL, tagCLS::pclsBase, tagCLS::pclsClone, tagCLS::pclsNext, PtoH, TYPE_CURSOR, and xxxSetClassIcon(). Referenced by xxxSetClassData(). { ULONG_PTR dwOld; CheckLock(pwnd); if ((HANDLE)dwData != NULL) { dwData = (ULONG_PTR)HMValidateHandle((HANDLE)dwData, TYPE_CURSOR); if ((PVOID)dwData == NULL) { if (index == GCLP_HICON || index == GCLP_HICONSM) { RIPERR0(ERROR_INVALID_ICON_HANDLE, RIP_WARNING, "SetClassData: invalid icon"); } else { RIPERR0(ERROR_INVALID_CURSOR_HANDLE, RIP_WARNING, "SetClassData: invalid cursor"); } } } /* * Handle the locking issue. */ pcls = pcls->pclsBase; switch (index) { case GCLP_HICON: case GCLP_HICONSM: dwOld = (ULONG_PTR)xxxSetClassIcon(pwnd, pcls, (PCURSOR)dwData, index); break; case GCLP_HCURSOR: dwOld = (ULONG_PTR)Lock(&pcls->spcur, dwData); break; } /* * Now set it for each clone class. */ pcls = pcls->pclsClone; while (pcls != NULL) { switch(index) { case GCLP_HICON: case GCLP_HICONSM: xxxSetClassIcon(pwnd, pcls, (PCURSOR)dwData, index); break; case GCLP_HCURSOR: Lock(&pcls->spcur, dwData); break; } pcls = pcls->pclsNext; } return (ULONG_PTR)PtoH((PVOID)dwOld); }

VOID UnlockAndFreeCPDs (  PCALLPROCDATA *  ppCPD  )

Definition at line 1092 of file class.c. References HMIsMarkDestroy, HMMarkObjectDestroy(), NULL, _CALLPROCDATA::spcpdNext, Unlock, and VOID(). Referenced by DestroyClass(). { PCALLPROCDATA pCPD; while ((pCPD = *ppCPD) != NULL) { /* * Unlink the CPD from the list. */ *ppCPD = pCPD->spcpdNext; pCPD->spcpdNext = NULL; /* * Mark it for destruction. */ if (!HMIsMarkDestroy(pCPD)) { HMMarkObjectDestroy(pCPD); } /* * Unlock it and it will be destroyed. */ Unlock(&pCPD); } }

BOOL ValidateAndLockCursor (  PCURSOR *  ppcursor, BOOL  fIs40Compat )

Definition at line 211 of file class.c. References BOOL, FALSE, HMValidateHandleNoSecure(), Lock, NULL, TRUE, and TYPE_CURSOR. Referenced by InternalRegisterClassEx(). { PCURSOR pcur; if (*ppcursor == NULL) { return TRUE; } pcur = HMValidateHandleNoSecure(*ppcursor, TYPE_CURSOR); if (pcur == NULL) { RIPMSG1(RIP_WARNING, "ValidateAndLockCursor: Invalid Cursor or Icon:%#p", *ppcursor); if (fIs40Compat) { RIPERR0(ERROR_INVALID_PARAMETER, RIP_VERBOSE, "RegisterClass: Invalid Parameter"); return FALSE; } } *ppcursor = NULL; Lock(ppcursor, pcur); return TRUE; }

ATOM xxxRegisterClassEx (  LPWNDCLASSEX  cczpwc, PCLSMENUNAME  pcmn, WORD  fnid, DWORD  dwFlags, LPDWORD  pdwWOW )

Definition at line 101 of file class.c. References tagCLS::atomClassName, CSF_WOWCLASS, dwFlags, HMValidateHandleNoRip(), tagCLS::hTaskWow, tagTDB::hTaskWow, InternalRegisterClassEx(), ISCPDTAG, tagCLS::lpszClientAnsiMenuName, tagCLS::lpszClientUnicodeMenuName, NULL, PCALLPROCDATA, PCLSMENUNAME, _CALLPROCDATA::pfnClientPrevious, tagCLSMENUNAME::pszClientAnsiMenuName, tagTHREADINFO::ptdb, PtiCurrent, PWCFromPCLS, tagCLSMENUNAME::pwszClientUnicodeMenuName, TIF_16BIT, tagTHREADINFO::TIF_flags, and TYPE_CALLPROC. Referenced by NtUserRegisterClassExWOW(). { PCLS pcls; PTHREADINFO ptiCurrent = PtiCurrent(); /* * NOTE -- lpszClassName and lpszMenuName in the wndclass may be client-side * pointers. Use of those fields must be protected in try blocks. */ /* * Convert a possible CallProc Handle into a real address. They may * have kept the CallProc Handle from some previous mixed GetClassinfo * or SetWindowLong. */ if (ISCPDTAG(cczpwc->lpfnWndProc)) { PCALLPROCDATA pCPD; if (pCPD = HMValidateHandleNoRip((HANDLE)cczpwc->lpfnWndProc, TYPE_CALLPROC)) { cczpwc->lpfnWndProc = (WNDPROC)pCPD->pfnClientPrevious; } } pcls = InternalRegisterClassEx(cczpwc, fnid, dwFlags | ((ptiCurrent->TIF_flags & TIF_16BIT)? CSF_WOWCLASS : 0) ); if (pcls != NULL) { pcls->lpszClientUnicodeMenuName = pcmn->pwszClientUnicodeMenuName; pcls->lpszClientAnsiMenuName = pcmn->pszClientAnsiMenuName; /* * copy 5 WOW dwords. */ if (pdwWOW) { RtlCopyMemory (PWCFromPCLS(pcls), pdwWOW, sizeof(WC)); } if ((ptiCurrent->TIF_flags & TIF_16BIT) && ptiCurrent->ptdb) { pcls->hTaskWow = ptiCurrent->ptdb->hTaskWow; } else { pcls->hTaskWow = 0; } /* * For some (presumably good) reason Win 3.1 changed RegisterClass * to return the classes classname atom. */ return pcls->atomClassName; } else { return 0; } }

ULONG_PTR xxxSetClassData (  PWND  pwnd, int  index, ULONG_PTR  dwData, BOOL  bAnsi )

Definition at line 1399 of file class.c. References afClassDWord, aiClassOffset, AllocateUnicodeString(), BYTE, CheckLock, CPD_ANSI_TO_UNICODE, CPD_CLASS, CPD_UNICODE_TO_ANSI, CSF_ANSIPROC, tagCLS::CSF_flags, CSF_SERVERSIDEPROC, CSF_WOWCLASS, CSF_WOWEXTRA, DWORD, FALSE, GetCPD(), HMValidateHandleNoRip(), INDEX_OFFSET, IS_PTR, ISCPDTAG, tagCLS::lpszClientAnsiMenuName, tagCLS::lpszClientUnicodeMenuName, MapClientNeuterToClientPfn(), MapClientToServerPfn(), MapServerToClientPfn(), NULL, tagWND::pcls, tagCLS::pclsBase, tagCLS::pclsClone, tagCLS::pclsNext, _CALLPROCDATA::pfnClientPrevious, tagCLSMENUNAME::pszClientAnsiMenuName, tagCLSMENUNAME::pusMenuName, PWCFromPCLS, tagCLSMENUNAME::pwszClientUnicodeMenuName, RtlInitUnicodeString(), SetClassCursor(), TRUE, TYPE_CALLPROC, WNDPROC_PWND, and xxxClientWOWGetProcModule(). Referenced by xxxSetClassLongPtr(). { PCLS pcls = pwnd->pcls; BYTE *pb; ULONG_PTR dwT; ULONG_PTR dwOld; DWORD dwCPDType = 0; PCLSMENUNAME pcmn; UNICODE_STRING strMenuName, UString; CheckLock(pwnd); switch(index) { case GCLP_WNDPROC: /* * If the application (client) subclasses a class that has a server - * side window proc we must return a client side proc stub that it * can call. */ if (pcls->CSF_flags & CSF_SERVERSIDEPROC) { dwOld = MapServerToClientPfn((ULONG_PTR)pcls->lpfnWndProc, bAnsi); pcls->CSF_flags &= ~CSF_SERVERSIDEPROC; UserAssert(!(pcls->CSF_flags & CSF_ANSIPROC)); if (bAnsi) { pcls->CSF_flags |= CSF_ANSIPROC; } } else { dwOld = MapClientNeuterToClientPfn(pcls, 0, bAnsi); /* * If the client mapping didn't change the window proc then see if * we need a callproc handle. */ if (dwOld == (ULONG_PTR)pcls->lpfnWndProc) { /* * Need to return a CallProc handle if there is an Ansi/Unicode mismatch */ if (bAnsi != !!(pcls->CSF_flags & CSF_ANSIPROC)) { dwCPDType |= bAnsi ? CPD_ANSI_TO_UNICODE : CPD_UNICODE_TO_ANSI; } } } if (dwCPDType) { ULONG_PTR dwCPD; dwCPD = GetCPD(pcls, dwCPDType | CPD_CLASS, dwOld); if (dwCPD) { dwOld = dwCPD; } else { RIPMSG0(RIP_WARNING, "GetClassLong unable to alloc CPD returning handle\n"); } } /* * Convert a possible CallProc Handle into a real address. They may * have kept the CallProc Handle from some previous mixed GetClassinfo * or SetWindowLong. */ if (ISCPDTAG(dwData)) { PCALLPROCDATA pCPD; if (pCPD = HMValidateHandleNoRip((HANDLE)dwData, TYPE_CALLPROC)) { dwData = pCPD->pfnClientPrevious; } } /* * If an app 'unsubclasses' a server-side window proc we need to * restore everything so SendMessage and friends know that it's * a server-side proc again. Need to check against client side * stub addresses. */ pcls->lpfnWndProc = (WNDPROC_PWND)dwData; if ((dwT = MapClientToServerPfn(dwData)) != 0) { pcls->lpfnWndProc = (WNDPROC_PWND)dwT; pcls->CSF_flags |= CSF_SERVERSIDEPROC; pcls->CSF_flags &= ~CSF_ANSIPROC; } else { if (bAnsi) { pcls->CSF_flags |= CSF_ANSIPROC; } else { pcls->CSF_flags &= ~CSF_ANSIPROC; } } if (pcls->CSF_flags & CSF_WOWCLASS) { PWC pwc = PWCFromPCLS(pcls); pwc->hMod16 = (pcls->CSF_flags & CSF_SERVERSIDEPROC) ? 0:xxxClientWOWGetProcModule(pcls->lpfnWndProc); } return dwOld; break; case GCLP_HICON: case GCLP_HICONSM: case GCLP_HCURSOR: return SetClassCursor(pwnd, pcls, index, dwData); break; case GCL_WOWMENUNAME: if (pcls->CSF_flags & CSF_WOWCLASS) { PWCFromPCLS(pcls)->vpszMenu = (DWORD)dwData; } else { UserAssert(FALSE); } break; case GCL_CBCLSEXTRA: if (pcls->CSF_flags & CSF_WOWCLASS) { /* * yes -- we can do this for WOW classes only. */ if (pcls->CSF_flags & CSF_WOWEXTRA) { dwOld = PWCFromPCLS(pcls)->iClsExtra; PWCFromPCLS(pcls)->iClsExtra = LOWORD(dwData); return dwOld; } else { PWCFromPCLS(pcls)->iClsExtra = LOWORD(dwData); pcls->CSF_flags |= CSF_WOWEXTRA; return pcls->cbclsExtra; } } RIPERR0(ERROR_INVALID_PARAMETER, RIP_WARNING, "Attempt to change cbClsExtra\n"); break; case GCLP_MENUNAME: pcmn = (PCLSMENUNAME) dwData; /* * pcmn->pusMenuName->Buffer is a client-side address. */ dwOld = (ULONG_PTR) pcls->lpszMenuName; /* Is it a string? */ if (IS_PTR(pcmn->pusMenuName->Buffer)) { try { RtlInitUnicodeString(&UString, pcmn->pusMenuName->Buffer); } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { break; } /* Empty String? */ if (UString.Length == 0) { pcls->lpszMenuName = NULL; } else { /* Make a copy of the string */ if (!AllocateUnicodeString(&strMenuName, &UString)) { RIPMSG0(RIP_WARNING, "xxxSetClassData: GCL_MENUNAME AllocateUnicodeString failed\n"); break; } pcls->lpszMenuName = strMenuName.Buffer; } } else { /* Just copy the id */ pcls->lpszMenuName = pcmn->pusMenuName->Buffer; } /* Don't return the kernel side pointer */ pcmn->pusMenuName = NULL; /* Free old string, if any */ if (IS_PTR(dwOld)) { UserFreePool((PVOID)dwOld); } /* Return client side pointers */ dwOld = (ULONG_PTR) pcls->lpszClientAnsiMenuName; pcls->lpszClientAnsiMenuName = pcmn->pszClientAnsiMenuName; pcmn->pszClientAnsiMenuName = (LPSTR)dwOld; dwOld = (ULONG_PTR) pcls->lpszClientUnicodeMenuName; pcls->lpszClientUnicodeMenuName = pcmn->pwszClientUnicodeMenuName; pcmn->pwszClientUnicodeMenuName = (LPWSTR)dwOld; return (bAnsi ? (ULONG_PTR) pcmn->pszClientAnsiMenuName : (ULONG_PTR) pcmn->pwszClientUnicodeMenuName); default: /* * All other indexes go here... */ index -= INDEX_OFFSET; /* * Only let valid indices go through; if aiClassOffset is zero * then we have no mapping for this negative index so it must * be a bogus index */ if ((index < 0) || (aiClassOffset[index] == 0)) { RIPERR0(ERROR_INVALID_INDEX, RIP_WARNING, "GetClassLong: invalid index"); return 0; } pcls = pcls->pclsBase; pb = ((BYTE *)pcls) + aiClassOffset[index]; if (afClassDWord[index] == sizeof(DWORD)) { dwOld = *(DWORD *)pb; *(DWORD *)pb = (DWORD)dwData; } else if (afClassDWord[index] == sizeof(ULONG_PTR)) { dwOld = *(ULONG_PTR *)pb; *(ULONG_PTR *)pb = dwData; } else { dwOld = (DWORD)*(WORD *)pb; *(WORD *)pb = (WORD)dwData; } pcls = pcls->pclsClone; while (pcls != NULL) { pb = ((BYTE *)pcls) + aiClassOffset[index]; if (afClassDWord[index] == sizeof(DWORD)) { dwOld = *(DWORD *)pb; *(DWORD *)pb = (DWORD)dwData; } else if (afClassDWord[index] == sizeof(ULONG_PTR)) { dwOld = *(ULONG_PTR *)pb; *(ULONG_PTR *)pb = dwData; } else { dwOld = (DWORD)*(WORD *)pb; *(WORD *)pb = (WORD)dwData; } pcls = pcls->pclsNext; } return dwOld; } return 0; }

ULONG_PTR xxxSetClassLongPtr (  PWND  pwnd, int  index, ULONG_PTR  value, BOOL  bAnsi )

Definition at line 909 of file class.c. References BYTE, CheckCritIn, CheckLock, GETPTI, NULL, tagWND::pcls, tagCLS::pclsBase, tagCLS::pclsClone, tagCLS::pclsNext, PpiCurrent, and xxxSetClassData(). { ULONG_PTR dwOld; PCLS pcls; CheckLock(pwnd); CheckCritIn(); if (GETPTI(pwnd)->ppi != PpiCurrent()) { RIPERR1(ERROR_ACCESS_DENIED, RIP_WARNING, "SetClassLongPtr: different process: index 0x%lx", index); return 0; } if (index < 0) { return xxxSetClassData(pwnd, index, value, bAnsi); } else { pcls = pwnd->pcls->pclsBase; if (index + (int)sizeof(ULONG_PTR) > pcls->cbclsExtra) { RIPERR0(ERROR_INVALID_INDEX, RIP_WARNING, "SetClassLongPtr: invalid index"); return 0; } else { ULONG_PTR UNALIGNED *pudw; pudw = (ULONG_PTR UNALIGNED *)((BYTE *)(pcls + 1) + index); dwOld = *pudw; *pudw = value; pcls = pcls->pclsClone; while (pcls != NULL) { pudw = (ULONG_PTR UNALIGNED *)((BYTE *)(pcls + 1) + index); *pudw = value; pcls = pcls->pclsNext; } return dwOld; } } }

---

Variable Documentation

CONST BYTE afClassDWord[]

Initial value: { FIELD_SIZE(CLS, spicnSm), 0, FIELD_SIZE(CLS, atomClassName), 0, 0, 0, 0, 0, FIELD_SIZE(CLS, style), 0, FIELD_SIZE(CLS, lpfnWndProc), 0, 0, 0, FIELD_SIZE(CLS, cbclsExtra), 0, FIELD_SIZE(CLS, cbwndExtra), 0, FIELD_SIZE(CLS, hModule), 0, FIELD_SIZE(CLS, spicn), 0, FIELD_SIZE(CLS, spcur), 0, FIELD_SIZE(CLS, hbrBackground), 0, FIELD_SIZE(CLS, lpszMenuName) } Definition at line 24 of file class.c.

CONST BYTE aiClassOffset[]

Initial value: { FIELD_OFFSET(CLS, spicnSm), 0, FIELD_OFFSET(CLS, atomClassName), 0, 0, 0, 0, 0, FIELD_OFFSET(CLS, style), 0, FIELD_OFFSET(CLS, lpfnWndProc), 0, 0, 0, FIELD_OFFSET(CLS, cbclsExtra), 0, FIELD_OFFSET(CLS, cbwndExtra), 0, FIELD_OFFSET(CLS, hModule), 0, FIELD_OFFSET(CLS, spicn), 0, FIELD_OFFSET(CLS, spcur), 0, FIELD_OFFSET(CLS, hbrBackground), 0, FIELD_OFFSET(CLS, lpszMenuName) } Definition at line 54 of file class.c.

---