*/
/* INCLUDES ******************************************************************/
-#include <w32k.h>
+#include <win32k.h>
#define NDEBUG
#include <debug.h>
REGISTER_SYSCLASS DefaultServerClasses[] =
{
-/* { ((PWSTR)((ULONG_PTR)(WORD)(0x8001))),
+ { ((PWSTR)((ULONG_PTR)(WORD)(0x8001))),
CS_GLOBALCLASS|CS_DBLCLKS,
NULL,
0,
IDC_ARROW,
- (HBRUSH)(COLOR_BACKGROUND+1),
+ (HBRUSH)(COLOR_BACKGROUND + 1),
FNID_DESKTOP,
ICLS_DESKTOP
- },*/
+ },
{ ((PWSTR)((ULONG_PTR)(WORD)(0x8003))),
CS_VREDRAW|CS_HREDRAW|CS_SAVEBITS,
NULL, // Use User32 procs
/* FIXME - Don't limit to 64 characters! use SEH when allocating memory! */
if (ClassName->Length / sizeof(WCHAR) >= sizeof(szBuf) / sizeof(szBuf[0]))
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return (RTL_ATOM)0;
}
Class->Unicode = !Ansi;
}
+ if (!WndProc) WndProc = Class->lpfnWndProc;
+
chWndProc = WndProc;
// Check if CallProc handle and retrieve previous call proc address and set.
if (Class != NULL)
{
/* simply clone the class */
- RtlCopyMemory(Class,
- BaseClass,
- ClassSize);
+ RtlCopyMemory( Class, BaseClass, ClassSize);
+
DPRINT("Clone Class 0x%x hM 0x%x\n %S\n",Class, Class->hModule, Class->lpszClientUnicodeMenuName);
+ /* restore module address if default user class Ref: Bug 4778 */
+ if ( Class->hModule != hModClient &&
+ Class->fnid <= FNID_GHOST &&
+ Class->fnid >= FNID_BUTTON )
+ {
+ Class->hModule = hModClient;
+ DPRINT("Clone Class 0x%x Reset hM 0x%x\n",Class, Class->hModule);
+ }
+
/* update some pointers and link the class */
Class->rpdeskParent = Desktop;
Class->cWndReferenceCount = 0;
Class->pclsClone = NULL;
Class->pclsBase = BaseClass;
Class->pclsNext = BaseClass->pclsClone;
- (void)InterlockedExchangePointer(&BaseClass->pclsClone,
+ (void)InterlockedExchangePointer((PVOID*)&BaseClass->pclsClone,
Class);
}
}
else
{
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
}
}
return Class;
IN OUT PCLS *BaseClassLink,
IN OUT PCLS *CloneLink)
{
- PCLS Clone, BaseClass;
+ PCLS Clone;
ASSERT(Class->pclsBase != Class);
ASSERT(Class->pclsBase->pclsClone != NULL);
*CloneLink = Class->pclsNext;
Class->pclsClone = Class->pclsBase->pclsClone;
- BaseClass = Class->pclsBase;
-
/* update the class information to make it a base class */
Class->pclsBase = Class;
Class->pclsNext = (*BaseClassLink)->pclsNext;
if (!Ret)
{
DPRINT1("Failed to move process classes from desktop 0x%p to the shared heap!\n", Desktop);
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
}
return Ret;
IntDeregisterClassAtom(Atom);
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
}
return Class;
/* FIXME - Don't limit to 64 characters! use SEH when allocating memory! */
if (ClassName->Length / sizeof(WCHAR) >= sizeof(szBuf) / sizeof(szBuf[0]))
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return (RTL_ATOM)0;
}
{
if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
{
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
+ EngSetLastError(ERROR_CLASS_DOES_NOT_EXIST);
}
else
{
&pi->pclsPrivateList,
Link);
if (Class != NULL)
- {
+ { DPRINT("Step 1: 0x%x\n",Class );
goto FoundClass;
}
&pi->pclsPublicList,
Link);
if (Class != NULL)
- {
+ { DPRINT("Step 2: 0x%x 0x%x\n",Class, Class->hModule);
goto FoundClass;
}
&pi->pclsPrivateList,
Link);
if (Class != NULL)
- {
+ { DPRINT("Step 3: 0x%x\n",Class );
goto FoundClass;
}
Link);
if (Class == NULL)
{
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
+ EngSetLastError(ERROR_CLASS_DOES_NOT_EXIST);
return (RTL_ATOM)0;
- }
+ }else{DPRINT("Step 4: 0x%x\n",Class );}
FoundClass:
*BaseClass = Class;
return Atom;
}
+PCLS
+IntGetAndReferenceClass(PUNICODE_STRING ClassName, HINSTANCE hInstance)
+{
+ PCLS *ClassLink, Class = NULL;
+ RTL_ATOM ClassAtom;
+ PTHREADINFO pti;
+
+ pti = PsGetCurrentThreadWin32Thread();
+
+ if ( !(pti->ppi->W32PF_flags & W32PF_CLASSESREGISTERED ))
+ {
+ UserRegisterSystemClasses();
+ }
+
+ /* Check the class. */
+
+ DPRINT("Class %wZ\n", ClassName);
+
+ ClassAtom = IntGetClassAtom(ClassName,
+ hInstance,
+ pti->ppi,
+ &Class,
+ &ClassLink);
+
+ if (ClassAtom == (RTL_ATOM)0)
+ {
+ if (IS_ATOM(ClassName->Buffer))
+ {
+ DPRINT1("Class 0x%p not found\n", (DWORD_PTR) ClassName->Buffer);
+ }
+ else
+ {
+ DPRINT1("Class \"%wZ\" not found\n", ClassName);
+ }
+
+ EngSetLastError(ERROR_CANNOT_FIND_WND_CLASS);
+ return NULL;
+ }
+ DPRINT("ClassAtom %x\n", ClassAtom);
+ Class = IntReferenceClass(Class,
+ ClassLink,
+ pti->rpdesk);
+ if (Class == NULL)
+ {
+ DPRINT1("Failed to reference window class!\n");
+ return NULL;
+ }
+
+ return Class;
+}
+
RTL_ATOM
UserRegisterClass(IN CONST WNDCLASSEXW* lpwcx,
IN PUNICODE_STRING ClassName,
if (Class != NULL && !Class->Global)
{
// local class already exists
- DPRINT1("Local Class 0x%p does already exist!\n", ClassAtom);
- SetLastWin32Error(ERROR_CLASS_ALREADY_EXISTS);
+ DPRINT("Local Class 0x%p does already exist!\n", ClassAtom);
+ EngSetLastError(ERROR_CLASS_ALREADY_EXISTS);
return (RTL_ATOM)0;
}
if (Class != NULL && Class->Global)
{
- DPRINT1("Global Class 0x%p does already exist!\n", ClassAtom);
- SetLastWin32Error(ERROR_CLASS_ALREADY_EXISTS);
+ DPRINT("Global Class 0x%p does already exist!\n", ClassAtom);
+ EngSetLastError(ERROR_CLASS_ALREADY_EXISTS);
return (RTL_ATOM)0;
}
}
MenuName,
fnID,
dwFlags,
- pti->Desktop,
+ pti->rpdesk,
pi);
if (Class != NULL)
&Link);
if (ClassAtom == (RTL_ATOM)0)
{
- DPRINT1("UserUnregisterClass: No Class found.\n");
+ DPRINT("UserUnregisterClass: No Class found.\n");
return FALSE;
}
Class->pclsClone != NULL)
{
DPRINT("UserUnregisterClass: Class has a Window. Ct %d : Clone 0x%x\n", Class->cWndReferenceCount, Class->pclsClone);
- SetLastWin32Error(ERROR_CLASS_HAS_WINDOWS);
+ EngSetLastError(ERROR_CLASS_HAS_WINDOWS);
return FALSE;
}
}
/* allocate a temporary buffer that can hold the unicode class name */
- szTemp = ExAllocatePool(PagedPool,
- BufLen);
+ szTemp = ExAllocatePoolWithTag(PagedPool,
+ BufLen,
+ USERTAG_CLASS);
if (szTemp == NULL)
{
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
_SEH2_LEAVE;
}
return Ret;
}
-ULONG_PTR
-UserGetClassLongPtr(IN PCLS Class,
- IN INT Index,
- IN BOOL Ansi)
-{
- ULONG_PTR Ret = 0;
-
- if (Index >= 0)
- {
- PULONG_PTR Data;
-
- TRACE("GetClassLong(%d)\n", Index);
- if (Index + sizeof(ULONG_PTR) < Index ||
- Index + sizeof(ULONG_PTR) > Class->cbclsExtra)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return 0;
- }
-
- Data = (PULONG_PTR)((ULONG_PTR)(Class + 1) + Index);
-
- /* FIXME - Data might be a unaligned pointer! Might be a problem on
- certain architectures, maybe using RtlCopyMemory is a
- better choice for those architectures! */
-
- TRACE("Result: %x\n", Ret);
- return *Data;
- }
-
- switch (Index)
- {
- case GCL_CBWNDEXTRA:
- Ret = (ULONG_PTR)Class->cbwndExtra;
- break;
-
- case GCL_CBCLSEXTRA:
- Ret = (ULONG_PTR)Class->cbclsExtra;
- break;
-
- case GCLP_HBRBACKGROUND:
- Ret = (ULONG_PTR)Class->hbrBackground;
- break;
-
- case GCLP_HCURSOR:
- /* FIXME - get handle from pointer to CURSOR object */
- Ret = (ULONG_PTR)Class->hCursor;
- break;
-
- case GCLP_HICON:
- /* FIXME - get handle from pointer to ICON object */
- Ret = (ULONG_PTR)Class->hIcon;
- break;
-
- case GCLP_HICONSM:
- /* FIXME - get handle from pointer to ICON object */
- Ret = (ULONG_PTR)Class->hIconSm;
- break;
-
- case GCLP_HMODULE:
- Ret = (ULONG_PTR)Class->hModule;
- break;
-
- case GCLP_MENUNAME:
- /* NOTE: Returns pointer in kernel heap! */
- if (Ansi)
- Ret = (ULONG_PTR)Class->lpszClientAnsiMenuName;
- else
- Ret = (ULONG_PTR)Class->lpszClientUnicodeMenuName;
- break;
-
- case GCL_STYLE:
- Ret = (ULONG_PTR)Class->style;
- break;
-
- case GCLP_WNDPROC:
- Ret = (ULONG_PTR)IntGetClassWndProc(Class, Ansi);
- break;
-
- case GCW_ATOM:
- Ret = (ULONG_PTR)Class->atomClassName;
- break;
-
- default:
- SetLastWin32Error(ERROR_INVALID_INDEX);
- break;
- }
-
- return Ret;
-}
-
static BOOL
IntSetClassMenuName(IN PCLS Class,
IN PUNICODE_STRING MenuName)
}
}
else
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
}
else
{
if (Index + sizeof(ULONG_PTR) < Index ||
Index + sizeof(ULONG_PTR) > Class->cbclsExtra)
{
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
return 0;
}
break;
case GCL_CBCLSEXTRA:
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
break;
case GCLP_HBRBACKGROUND:
}
default:
- SetLastWin32Error(ERROR_INVALID_INDEX);
+ EngSetLastError(ERROR_INVALID_INDEX);
break;
}
IN BOOL Ansi,
HINSTANCE hInstance)
{
- PPROCESSINFO pi;
-
if (!Class) return FALSE;
lpwcx->style = Class->style;
if (Class->fnid)
lpwcx->style &= ~CS_GLOBALCLASS;
- pi = GetW32ProcessInfo();
-
lpwcx->lpfnWndProc = IntGetClassWndProc(Class, Ansi);
lpwcx->cbClsExtra = Class->cbclsExtra;
if (Flags & ~(CSF_ANSIPROC))
{
DPRINT1("NtUserRegisterClassExWOW Bad Flags!\n");
- SetLastWin32Error(ERROR_INVALID_FLAGS);
+ EngSetLastError(ERROR_INVALID_FLAGS);
return Ret;
}
{
DPRINT1("NtUserRegisterClassExWOW MenuName Error!\n");
InvalidParameter:
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
_SEH2_LEAVE;
}
SetLastNtError(_SEH2_GetExceptionCode());
}
_SEH2_END;
-
+/*
if (!Ret)
{
DPRINT1("NtUserRegisterClassExWOW Null Return!\n");
}
-
- UserLeave();
-
- return Ret;
-}
-
-ULONG_PTR APIENTRY
-NtUserGetClassLong(IN HWND hWnd,
- IN INT Offset,
- IN BOOL Ansi)
-{
- PWINDOW_OBJECT Window;
- ULONG_PTR Ret = 0;
-
- if (Offset != GCLP_WNDPROC)
- {
- UserEnterShared();
- }
- else
- {
- UserEnterExclusive();
- }
-
- Window = UserGetWindowObject(hWnd);
- if (Window != NULL)
- {
- Ret = UserGetClassLongPtr(Window->Wnd->pcls,
- Offset,
- Ansi);
-
- if ( Ret != 0 &&
- Offset == GCLP_MENUNAME &&
- Window->Wnd->pcls->MenuNameIsString)
- {
- Ret = (ULONG_PTR)UserHeapAddressToUser((PVOID)Ret);
- }
- }
-
+ */
UserLeave();
return Ret;
}
-
-
ULONG_PTR APIENTRY
NtUserSetClassLong(HWND hWnd,
INT Offset,
BOOL Ansi)
{
PPROCESSINFO pi;
- PWINDOW_OBJECT Window;
+ PWND Window;
ULONG_PTR Ret = 0;
UserEnterExclusive();
Window = UserGetWindowObject(hWnd);
if (Window != NULL)
{
- if (Window->ti->ppi != pi)
+ if (Window->head.pti->ppi != pi)
{
- SetLastWin32Error(ERROR_ACCESS_DENIED);
+ EngSetLastError(ERROR_ACCESS_DENIED);
goto Cleanup;
}
else if (Offset == GCLP_MENUNAME && !IS_INTRESOURCE(Value.Buffer))
{
InvalidParameter:
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
_SEH2_LEAVE;
}
}
dwNewLong = (ULONG_PTR)&Value;
}
- Ret = UserSetClassLongPtr(Window->Wnd->pcls,
+ Ret = UserSetClassLongPtr(Window->pcls,
Offset,
dwNewLong,
Ansi);
if (!IS_ATOM(CapturedClassName.Buffer))
{
InvalidParameter:
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ EngSetLastError(ERROR_INVALID_PARAMETER);
_SEH2_LEAVE;
}
}
if (CapturedClassName.Length & 1)
{
- goto InvalidParameter;
+ EngSetLastError(ERROR_INVALID_PARAMETER);
+ Ret = FALSE;
+ _SEH2_LEAVE;
}
if (CapturedClassName.Length != 0)
if (!IS_ATOM(CapturedClassName.Buffer))
{
ERR("NtUserGetClassInfo() got ClassName instead of Atom!\n");
- goto InvalidParameter;
+ EngSetLastError(ERROR_INVALID_PARAMETER);
+ Ret = FALSE;
+ _SEH2_LEAVE;
}
SafeClassName.Buffer = CapturedClassName.Buffer;
SafeClassName.MaximumLength = 0;
}
- if (ProbeForReadUint(&lpWndClassEx->cbSize) != sizeof(WNDCLASSEXW))
- {
-InvalidParameter:
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- Ret = FALSE;
- _SEH2_LEAVE;
- }
-
ProbeForWrite( lpWndClassEx, sizeof(WNDCLASSEXW), sizeof(ULONG));
RtlCopyMemory( &Safewcexw, lpWndClassEx, sizeof(WNDCLASSEXW));
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
+ SetLastNtError(_SEH2_GetExceptionCode());
Ret = FALSE;
}
_SEH2_END;
if (Ret)
{
+ DPRINT("GetClassInfo(%wZ, 0x%x)\n", ClassName, hInstance);
ClassAtom = IntGetClassAtom( &SafeClassName,
hInstance,
ppi,
}
else
{
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
+ EngSetLastError(ERROR_CLASS_DOES_NOT_EXIST);
Ret = FALSE;
}
}
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
+ EngSetLastError(ERROR_CLASS_DOES_NOT_EXIST);
Ret = FALSE;
}
_SEH2_END;
OUT PUNICODE_STRING ClassName,
IN BOOL Ansi)
{
- PWINDOW_OBJECT Window;
+ PWND Window;
UNICODE_STRING CapturedClassName;
INT Ret = 0;
CapturedClassName = *ClassName;
/* get the class name */
- Ret = UserGetClassName(Window->Wnd->pcls,
+ Ret = UserGetClassName(Window->pcls,
&CapturedClassName,
Ansi);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
+ EngSetLastError(ERROR_CLASS_DOES_NOT_EXIST);
Hit = TRUE;
}
_SEH2_END;
NULL);
if (!ClassAtom)
{
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
+ EngSetLastError(ERROR_CLASS_DOES_NOT_EXIST);
}
}