5 Apr
2006
5 Apr
'06
8:06 a.m.
Author: peterw
Date: Wed Apr 5 12:05:55 2006
New Revision: 21460
URL: http://svn.reactos.ru/svn/reactos?rev=21460&view=rev
Log:
Applied patch by: Thomas Weidenmueller
- win32k window class rewrite.
- http://www.reactos.org/bugzilla/show_bug.cgi?id=1366
Added:
trunk/reactos/subsystems/win32/win32k/misc/usrheap.c
Modified:
trunk/reactos/dll/win32/user32/controls/regcontrol.c
trunk/reactos/dll/win32/user32/misc/misc.c
trunk/reactos/dll/win32/user32/windows/class.c
trunk/reactos/dll/win32/user32/windows/message.c
trunk/reactos/dll/win32/user32/windows/window.c
trunk/reactos/include/ndk/pstypes.h
trunk/reactos/include/reactos/probe.h
trunk/reactos/include/reactos/win32k/ntuser.h
trunk/reactos/lib/rtl/heap.c
trunk/reactos/subsystems/win32/win32k/include/class.h
trunk/reactos/subsystems/win32/win32k/include/desktop.h
trunk/reactos/subsystems/win32/win32k/include/object.h
trunk/reactos/subsystems/win32/win32k/include/userfuncs.h
trunk/reactos/subsystems/win32/win32k/include/win32.h
trunk/reactos/subsystems/win32/win32k/include/window.h
trunk/reactos/subsystems/win32/win32k/main/dllmain.c
trunk/reactos/subsystems/win32/win32k/misc/err.c
trunk/reactos/subsystems/win32/win32k/ntuser/accelerator.c
trunk/reactos/subsystems/win32/win32k/ntuser/class.c
trunk/reactos/subsystems/win32/win32k/ntuser/cursoricon.c
trunk/reactos/subsystems/win32/win32k/ntuser/desktop.c
trunk/reactos/subsystems/win32/win32k/ntuser/hook.c
trunk/reactos/subsystems/win32/win32k/ntuser/menu.c
trunk/reactos/subsystems/win32/win32k/ntuser/message.c
trunk/reactos/subsystems/win32/win32k/ntuser/misc.c
trunk/reactos/subsystems/win32/win32k/ntuser/monitor.c
trunk/reactos/subsystems/win32/win32k/ntuser/object.c
trunk/reactos/subsystems/win32/win32k/ntuser/windc.c
trunk/reactos/subsystems/win32/win32k/ntuser/window.c
trunk/reactos/subsystems/win32/win32k/w32k.h
trunk/reactos/subsystems/win32/win32k/win32k.rbuild
trunk/reactos/tools/nci/w32ksvc.db
Modified: trunk/reactos/dll/win32/user32/controls/regcontrol.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/dll/win32/user32/controls/r…
==============================================================================
--- trunk/reactos/dll/win32/user32/controls/regcontrol.c (original)
+++ trunk/reactos/dll/win32/user32/controls/regcontrol.c Wed Apr 5 12:05:55 2006
@@ -44,15 +44,13 @@
RtlInitUnicodeString(&ClassName, Descr->name);
}
- NtUserRegisterClassExWOW(
+ NtUserRegisterClassEx(
&wc,
- &ClassName,
&ClassName,
&MenuName,
Descr->procA,
REGISTERCLASS_SYSTEM,
- 0,
- 0);
+ NULL);
}
/***********************************************************************
Modified: trunk/reactos/dll/win32/user32/misc/misc.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/dll/win32/user32/misc/misc.…
==============================================================================
--- trunk/reactos/dll/win32/user32/misc/misc.c (original)
+++ trunk/reactos/dll/win32/user32/misc/misc.c Wed Apr 5 12:05:55 2006
@@ -113,3 +113,34 @@
{
return NtUserUpdatePerUserSystemParameters(dwReserved, bEnable);
}
+
+PW32THREADINFO
+GetW32ThreadInfo(VOID)
+{
+ PW32THREADINFO ti;
+
+ ti = (PW32THREADINFO)NtCurrentTeb()->Win32ThreadInfo;
+ if (ti == NULL)
+ {
+ /* create the W32THREADINFO structure */
+ NtUserGetThreadState(THREADSTATE_GETTHREADINFO);
+ ti = (PW32THREADINFO)NtCurrentTeb()->Win32ThreadInfo;
+ }
+
+ return ti;
+}
+
+PW32PROCESSINFO
+GetW32ProcessInfo(VOID)
+{
+ PW32THREADINFO ti;
+ PW32PROCESSINFO pi = NULL;
+
+ ti = GetW32ThreadInfo();
+ if (ti != NULL)
+ {
+ pi = ti->pi;
+ }
+
+ return pi;
+}
Modified: trunk/reactos/dll/win32/user32/windows/class.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/dll/win32/user32/windows/cl…
==============================================================================
--- trunk/reactos/dll/win32/user32/windows/class.c (original)
+++ trunk/reactos/dll/win32/user32/windows/class.c Wed Apr 5 12:05:55 2006
@@ -11,117 +11,6 @@
#include <user32.h>
-static BOOL GetClassInfoExCommon(
- HINSTANCE hInst,
- LPCWSTR lpszClass,
- LPWNDCLASSEXW lpwcx,
- BOOL unicode)
-{
- LPWSTR str;
- UNICODE_STRING str2, str3;
- WNDCLASSEXW w;
- BOOL retval;
- NTSTATUS Status;
-
- if ( !lpszClass || !lpwcx )
- {
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
- }
-
- if(IS_ATOM(lpszClass))
- str = (LPWSTR)lpszClass;
- else
- {
- extern BOOL ControlsInitialized;
-
- if (unicode)
- {
- str = HEAP_strdupW ( lpszClass, wcslen(lpszClass) );
-
- if ( !str )
- {
- SetLastError (ERROR_OUTOFMEMORY);
- return FALSE;
- }
- }
-
- else
- {
- Status = HEAP_strdupAtoW(&str, (LPCSTR)lpszClass, NULL);
-
- if (! NT_SUCCESS(Status))
- {
- SetLastError(RtlNtStatusToDosError(Status));
- return FALSE;
- }
- }
-
- /* Register built-in controls if not already done */
- if ( !ControlsInitialized )
- {
- ControlsInitialized = ControlsInit(str);
- }
- }
-
- str2.Length = str3.Length = 0;
- str2.MaximumLength = str3.MaximumLength = 255;
- str2.Buffer = (PWSTR)HEAP_alloc ( str2.MaximumLength * sizeof(WCHAR) );
- if ( !str2.Buffer )
- {
- SetLastError (ERROR_OUTOFMEMORY);
- if ( !IS_ATOM(str) )
- HEAP_free ( str );
- return FALSE;
- }
-
- str3.Buffer = (PWSTR)HEAP_alloc ( str3.MaximumLength * sizeof(WCHAR) );
- if ( !str3.Buffer )
- {
- SetLastError (ERROR_OUTOFMEMORY);
- HEAP_free ( str2.Buffer );
- if ( !IS_ATOM(str) )
- HEAP_free ( str );
- return FALSE;
- }
-
- w.lpszMenuName = (LPCWSTR)&str2;
- w.lpszClassName = (LPCWSTR)&str3;
-
- /* get info about system classes? */
- if (!hInst) hInst = User32Instance;
-
- retval = (BOOL)NtUserGetClassInfo(hInst, str, &w, TRUE, 0);
-
- w.hInstance = (hInst == User32Instance) ? 0 : hInst;
-
- if ( !IS_ATOM(str) )
- HEAP_free(str);
-
- RtlCopyMemory ( lpwcx, &w, sizeof(WNDCLASSEXW) );
-
- if ( !IS_INTRESOURCE(w.lpszMenuName) && w.lpszMenuName )
- {
- if (unicode)
- lpwcx->lpszMenuName = heap_string_poolW ( str2.Buffer, str2.Length );
- else
- ((LPWNDCLASSEXA) lpwcx)->lpszMenuName = heap_string_poolA ( str2.Buffer,
str2.Length );
- }
-
- if ( !IS_ATOM(w.lpszClassName) && w.lpszClassName )
- {
- if (unicode)
- lpwcx->lpszClassName = heap_string_poolW ( str3.Buffer, str3.Length );
- else
- ((LPWNDCLASSEXA) lpwcx)->lpszClassName = heap_string_poolA ( str3.Buffer,
str3.Length );
- }
-
- HEAP_free ( str2.Buffer );
- HEAP_free ( str3.Buffer );
-
- return retval;
-}
-
/*
* @implemented
@@ -133,7 +22,40 @@
LPCSTR lpszClass,
LPWNDCLASSEXA lpwcx)
{
- return GetClassInfoExCommon(hinst, (LPWSTR)lpszClass, (LPWNDCLASSEXW)lpwcx, FALSE);
+ UNICODE_STRING ClassName = {0};
+ BOOL Ret;
+
+ if (lpszClass == NULL)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ if (IS_ATOM(lpszClass))
+ {
+ ClassName.Buffer = (PWSTR)((ULONG_PTR)lpszClass);
+ }
+ else
+ {
+ if (!RtlCreateUnicodeStringFromAsciiz(&ClassName,
+ lpszClass))
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return FALSE;
+ }
+ }
+
+ Ret = NtUserGetClassInfo(hinst,
+ &ClassName,
+ (LPWNDCLASSEXW)lpwcx,
+ TRUE);
+
+ if (!IS_ATOM(lpszClass))
+ {
+ RtlFreeUnicodeString(&ClassName);
+ }
+
+ return Ret;
}
@@ -147,7 +69,28 @@
LPCWSTR lpszClass,
LPWNDCLASSEXW lpwcx)
{
- return GetClassInfoExCommon(hinst, lpszClass, lpwcx, TRUE);
+ UNICODE_STRING ClassName = {0};
+
+ if (lpszClass == NULL)
+ {
+ SetLastError(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ if (IS_ATOM(lpszClass))
+ {
+ ClassName.Buffer = (PWSTR)((ULONG_PTR)lpszClass);
+ }
+ else
+ {
+ RtlInitUnicodeString(&ClassName,
+ lpszClass);
+ }
+
+ return NtUserGetClassInfo(hinst,
+ &ClassName,
+ lpwcx,
+ FALSE);
}
@@ -170,6 +113,7 @@
return FALSE;
}
+ w.cbSize = sizeof(w);
retval = GetClassInfoExA(hInstance,lpClassName,&w);
if (retval)
{
@@ -197,8 +141,12 @@
return FALSE;
}
+ w.cbSize = sizeof(w);
retval = GetClassInfoExW(hInstance,lpClassName,&w);
- RtlCopyMemory (lpWndClass,&w.style,sizeof(WNDCLASSW));
+ if (retval)
+ {
+ RtlCopyMemory (lpWndClass,&w.style,sizeof(WNDCLASSW));
+ }
return retval;
}
@@ -275,25 +223,14 @@
LPSTR lpClassName,
int nMaxCount)
{
- int result;
- LPWSTR ClassNameW;
- NTSTATUS Status;
-
- if(!lpClassName)
- return 0;
-
- ClassNameW = HEAP_alloc ( (nMaxCount+1)*sizeof(WCHAR) );
-
- result = NtUserGetClassName ( hWnd, ClassNameW, nMaxCount );
-
- Status = HEAP_strcpyWtoA ( lpClassName, ClassNameW, result );
-
- HEAP_free ( ClassNameW );
-
- if ( !NT_SUCCESS(Status) )
- return 0;
-
- return result;
+ ANSI_STRING ClassName;
+
+ ClassName.MaximumLength = nMaxCount;
+ ClassName.Buffer = lpClassName;
+
+ return NtUserGetClassName(hWnd,
+ (PUNICODE_STRING)&ClassName,
+ TRUE);
}
@@ -307,7 +244,14 @@
LPWSTR lpClassName,
int nMaxCount)
{
- return NtUserGetClassName(hWnd, lpClassName, nMaxCount);
+ UNICODE_STRING ClassName;
+
+ ClassName.MaximumLength = nMaxCount;
+ ClassName.Buffer = lpClassName;
+
+ return NtUserGetClassName(hWnd,
+ &ClassName,
+ FALSE);
}
@@ -573,8 +517,8 @@
RTL_ATOM Atom;
WNDCLASSEXA WndClass;
UNICODE_STRING ClassName;
- UNICODE_STRING MenuName;
- HMENU hMenu;
+ UNICODE_STRING MenuName = {0};
+ HMENU hMenu = NULL;
if (lpwcx == NULL || lpwcx->cbSize != sizeof(WNDCLASSEXA) ||
lpwcx->cbClsExtra < 0 || lpwcx->cbWndExtra < 0 ||
@@ -609,16 +553,17 @@
WndClass.hIconSm = CreateSmallIcon(WndClass.hIcon);
}
- if HIWORD(lpwcx->lpszMenuName)
- {
- hMenu = 0;
- RtlCreateUnicodeStringFromAsciiz(&MenuName, WndClass.lpszMenuName);
- }
- else
- {
- MenuName.Length =
- MenuName.MaximumLength = 0;
- MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
+ if (lpwcx->lpszMenuName != NULL)
+ {
+ if (HIWORD(lpwcx->lpszMenuName))
+ {
+ RtlCreateUnicodeStringFromAsciiz(&MenuName, WndClass.lpszMenuName);
+ }
+ else
+ {
+ MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
+ }
+
hMenu = LoadMenuA(WndClass.hInstance, lpwcx->lpszMenuName);
}
@@ -627,20 +572,18 @@
ClassName.Length =
ClassName.MaximumLength = 0;
ClassName.Buffer = (LPWSTR)WndClass.lpszClassName;
- } else
+ }
+ else
{
RtlCreateUnicodeStringFromAsciiz(&ClassName, WndClass.lpszClassName);
}
- Atom = NtUserRegisterClassExWOW(
- (WNDCLASSEXW*)&WndClass,
- &ClassName,
- &ClassName,
- &MenuName,
- NULL,
- REGISTERCLASS_ANSI,
- 0,
- hMenu);
+ Atom = NtUserRegisterClassEx((WNDCLASSEXW*)&WndClass,
+ &ClassName,
+ &MenuName,
+ NULL,
+ REGISTERCLASS_ANSI,
+ hMenu);
if (!IS_ATOM(WndClass.lpszMenuName))
RtlFreeUnicodeString(&MenuName);
@@ -658,8 +601,8 @@
{
WNDCLASSEXW WndClass;
UNICODE_STRING ClassName;
- UNICODE_STRING MenuName;
- HMENU hMenu;
+ UNICODE_STRING MenuName = {0};
+ HMENU hMenu = NULL;
if (lpwcx == NULL || lpwcx->cbSize != sizeof(WNDCLASSEXW) ||
lpwcx->cbClsExtra < 0 || lpwcx->cbWndExtra < 0 ||
@@ -694,16 +637,16 @@
WndClass.hIconSm = CreateSmallIcon(WndClass.hIcon);
}
- if HIWORD(lpwcx->lpszMenuName)
- {
- hMenu = 0;
- RtlInitUnicodeString(&MenuName, WndClass.lpszMenuName);
- }
- else
- {
- MenuName.Length =
- MenuName.MaximumLength = 0;
- MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
+ if (lpwcx->lpszMenuName != NULL)
+ {
+ if (HIWORD(lpwcx->lpszMenuName))
+ {
+ RtlInitUnicodeString(&MenuName, WndClass.lpszMenuName);
+ }
+ else
+ {
+ MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
+ }
hMenu = LoadMenuW(WndClass.hInstance, lpwcx->lpszMenuName);
}
@@ -712,20 +655,18 @@
ClassName.Length =
ClassName.MaximumLength = 0;
ClassName.Buffer = (LPWSTR)WndClass.lpszClassName;
- } else
+ }
+ else
{
RtlInitUnicodeString(&ClassName, WndClass.lpszClassName);
}
- return (ATOM)NtUserRegisterClassExWOW(
- &WndClass,
- &ClassName,
- &ClassName,
- &MenuName,
- NULL,
- 0,
- 0,
- hMenu);
+ return (ATOM)NtUserRegisterClassEx(&WndClass,
+ &ClassName,
+ &MenuName,
+ NULL,
+ 0,
+ hMenu);
}
/*
@@ -769,42 +710,65 @@
*/
DWORD
STDCALL
-SetClassLongA (
- HWND hWnd,
- int nIndex,
- LONG dwNewLong)
-{
- UNICODE_STRING str2buf;
- PUNICODE_STRING str;
- PUNICODE_STRING str2 = &str2buf;
-
- if ( nIndex != GCL_MENUNAME )
- {
- return NtUserSetClassLong ( hWnd, nIndex, dwNewLong, TRUE );
- }
- if ( IS_INTRESOURCE(dwNewLong) )
- {
- str2 = (PUNICODE_STRING)dwNewLong;
- }
- else
- {
- RtlCreateUnicodeStringFromAsciiz ( &str2buf,(LPSTR)dwNewLong );
- }
-
- str = (PUNICODE_STRING)NtUserSetClassLong(hWnd, nIndex, (DWORD)str2, TRUE);
-
- if ( !IS_INTRESOURCE(dwNewLong) )
- {
- RtlFreeUnicodeString ( str2 );
- }
- if ( IS_INTRESOURCE(str) )
- {
- return (DWORD)str;
- }
- else
- {
- return (DWORD)heap_string_poolA ( str->Buffer, str->Length );
- }
+SetClassLongA (HWND hWnd,
+ int nIndex,
+ LONG dwNewLong)
+{
+ PSTR lpStr = (PSTR)dwNewLong;
+ UNICODE_STRING Value = {0};
+ BOOL Allocated = FALSE;
+ DWORD Ret;
+
+ /* FIXME - portability!!!! */
+
+ if (nIndex == GCL_MENUNAME && lpStr != NULL)
+ {
+ if (!IS_INTRESOURCE(lpStr))
+ {
+ if (!RtlCreateUnicodeStringFromAsciiz(&Value,
+ lpStr))
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return 0;
+ }
+
+ Allocated = TRUE;
+ }
+ else
+ Value.Buffer = (PWSTR)lpStr;
+
+ dwNewLong = (LONG)&Value;
+ }
+ else if (nIndex == GCW_ATOM && lpStr != NULL)
+ {
+ if (!IS_ATOM(lpStr))
+ {
+ if (!RtlCreateUnicodeStringFromAsciiz(&Value,
+ lpStr))
+ {
+ SetLastError(ERROR_NOT_ENOUGH_MEMORY);
+ return 0;
+ }
+
+ Allocated = TRUE;
+ }
+ else
+ Value.Buffer = (PWSTR)lpStr;
+
+ dwNewLong = (LONG)&Value;
+ }
+
+ Ret = (DWORD)NtUserSetClassLong(hWnd,
+ nIndex,
+ dwNewLong,
+ TRUE);
+
+ if (Allocated)
+ {
+ RtlFreeUnicodeString(&Value);
+ }
+
+ return Ret;
}
@@ -813,42 +777,44 @@
*/
DWORD
STDCALL
-SetClassLongW(
- HWND hWnd,
- int nIndex,
- LONG dwNewLong)
-{
- UNICODE_STRING str2buf;
- PUNICODE_STRING str;
- PUNICODE_STRING str2 = &str2buf;
-
- if (nIndex != GCL_MENUNAME )
- {
- return NtUserSetClassLong ( hWnd, nIndex, dwNewLong, FALSE );
- }
- if ( IS_INTRESOURCE(dwNewLong) )
- {
- str2 = (PUNICODE_STRING)dwNewLong;
- }
- else
- {
- RtlCreateUnicodeString ( &str2buf, (LPWSTR)dwNewLong );
- }
-
- str = (PUNICODE_STRING)NtUserSetClassLong(hWnd, nIndex, (DWORD)str2, TRUE);
-
- if ( !IS_INTRESOURCE(dwNewLong) )
- {
- RtlFreeUnicodeString(str2);
- }
- if ( IS_INTRESOURCE(str) )
- {
- return (DWORD)str;
- }
- else
- {
- return (DWORD)heap_string_poolW ( str->Buffer, str->Length );
- }
+SetClassLongW(HWND hWnd,
+ int nIndex,
+ LONG dwNewLong)
+{
+ PWSTR lpStr = (PWSTR)dwNewLong;
+ UNICODE_STRING Value = {0};
+
+ /* FIXME - portability!!!! */
+
+ if (nIndex == GCL_MENUNAME && lpStr != NULL)
+ {
+ if (!IS_INTRESOURCE(lpStr))
+ {
+ RtlInitUnicodeString(&Value,
+ lpStr);
+ }
+ else
+ Value.Buffer = lpStr;
+
+ dwNewLong = (LONG)&Value;
+ }
+ else if (nIndex == GCW_ATOM && lpStr != NULL)
+ {
+ if (!IS_ATOM(lpStr))
+ {
+ RtlInitUnicodeString(&Value,
+ lpStr);
+ }
+ else
+ Value.Buffer = lpStr;
+
+ dwNewLong = (LONG)&Value;
+ }
+
+ return (DWORD)NtUserSetClassLong(hWnd,
+ nIndex,
+ dwNewLong,
+ FALSE);
}
@@ -868,7 +834,7 @@
if ((nIndex < 0) && (nIndex != GCW_ATOM))
return 0;
- return (WORD) NtUserSetClassLong ( hWnd, nIndex, wNewWord, TRUE );
+ return (WORD) SetClassLongW ( hWnd, nIndex, wNewWord );
}
@@ -909,28 +875,32 @@
LPCSTR lpClassName,
HINSTANCE hInstance)
{
- LPWSTR ClassName;
- NTSTATUS Status;
- BOOL Result;
-
- if(!IS_ATOM(lpClassName))
- {
- Status = HEAP_strdupAtoW(&ClassName, lpClassName, NULL);
- if(!NT_SUCCESS(Status))
- {
- SetLastError(RtlNtStatusToDosError(Status));
- return FALSE;
- }
- }
- else
- ClassName = (LPWSTR)lpClassName;
-
- Result = (BOOL)NtUserUnregisterClass((LPCWSTR)ClassName, hInstance, 0);
-
- if(ClassName && !IS_ATOM(lpClassName))
- HEAP_free(ClassName);
-
- return Result;
+ UNICODE_STRING ClassName = {0};
+ NTSTATUS Status;
+ BOOL Ret;
+
+ if (!IS_ATOM(lpClassName))
+ {
+ Status = HEAP_strdupAtoW(&ClassName.Buffer, lpClassName, NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastError(RtlNtStatusToDosError(Status));
+ return FALSE;
+ }
+
+ RtlInitUnicodeString(&ClassName,
+ ClassName.Buffer);
+ }
+ else
+ ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
+
+ Ret = NtUserUnregisterClass(&ClassName,
+ hInstance);
+
+ if(!IS_ATOM(lpClassName) && ClassName.Buffer != NULL)
+ HEAP_free(ClassName.Buffer);
+
+ return Ret;
}
@@ -943,7 +913,18 @@
LPCWSTR lpClassName,
HINSTANCE hInstance)
{
- return (BOOL)NtUserUnregisterClass(lpClassName, hInstance, 0);
+ UNICODE_STRING ClassName = {0};
+
+ if (!IS_ATOM(lpClassName))
+ {
+ RtlInitUnicodeString(&ClassName,
+ lpClassName);
+ }
+ else
+ ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
+
+ return NtUserUnregisterClass(&ClassName,
+ hInstance);
}
/* EOF */
Modified: trunk/reactos/dll/win32/user32/windows/message.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/dll/win32/user32/windows/me…
==============================================================================
--- trunk/reactos/dll/win32/user32/windows/message.c (original)
+++ trunk/reactos/dll/win32/user32/windows/message.c Wed Apr 5 12:05:55 2006
@@ -951,6 +951,7 @@
return FALSE;
}
Result = WndProc(AnsiMsg.hwnd, AnsiMsg.message, AnsiMsg.wParam, AnsiMsg.lParam);
+
if (! MsgiUnicodeToAnsiReply(&AnsiMsg, &UnicodeMsg, &Result))
{
return FALSE;
@@ -991,6 +992,7 @@
}
Result = WndProc(UnicodeMsg.hwnd, UnicodeMsg.message,
UnicodeMsg.wParam, UnicodeMsg.lParam);
+
if (! MsgiAnsiToUnicodeReply(&UnicodeMsg, &AnsiMsg, &Result))
{
return FALSE;
@@ -1010,20 +1012,19 @@
WPARAM wParam,
LPARAM lParam)
{
- BOOL IsHandle;
- WndProcHandle wphData;
+ WNDPROC_INFO wpInfo;
if (lpPrevWndFunc == NULL)
- lpPrevWndFunc = (WNDPROC)NtUserGetWindowLong(hWnd, GWL_WNDPROC, FALSE);
-
- IsHandle = NtUserDereferenceWndProcHandle(lpPrevWndFunc,&wphData);
- if (! IsHandle)
+ lpPrevWndFunc = (WNDPROC)NtUserGetWindowLong(hWnd, GWLP_WNDPROC, FALSE);
+
+ if (!NtUserDereferenceWndProcHandle((HANDLE)lpPrevWndFunc,
+ &wpInfo))
{
return IntCallWindowProcA(TRUE, lpPrevWndFunc, hWnd, Msg, wParam, lParam);
}
else
{
- return IntCallWindowProcA(! wphData.IsUnicode, wphData.WindowProc,
+ return IntCallWindowProcA(!wpInfo.IsUnicode, wpInfo.WindowProc,
hWnd, Msg, wParam, lParam);
}
}
@@ -1039,17 +1040,16 @@
WPARAM wParam,
LPARAM lParam)
{
- BOOL IsHandle;
- WndProcHandle wphData;
-
- IsHandle = NtUserDereferenceWndProcHandle(lpPrevWndFunc,&wphData);
- if (! IsHandle)
+ WNDPROC_INFO wpInfo;
+
+ if (!NtUserDereferenceWndProcHandle((HANDLE)lpPrevWndFunc,
+ &wpInfo))
{
return IntCallWindowProcW(FALSE, lpPrevWndFunc, hWnd, Msg, wParam, lParam);
}
else
{
- return IntCallWindowProcW(! wphData.IsUnicode, wphData.WindowProc,
+ return IntCallWindowProcW(!wpInfo.IsUnicode, wpInfo.WindowProc,
hWnd, Msg, wParam, lParam);
}
}
Modified: trunk/reactos/dll/win32/user32/windows/window.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/dll/win32/user32/windows/wi…
==============================================================================
--- trunk/reactos/dll/win32/user32/windows/window.c (original)
+++ trunk/reactos/dll/win32/user32/windows/window.c Wed Apr 5 12:05:55 2006
@@ -289,8 +289,8 @@
{
wce.cbSize = sizeof(WNDCLASSEXW);
if(GetClassInfoExW(hInstance, lpClassName, &wce) && wce.lpszMenuName)
- {
- hMenu = LoadMenuW(hInstance, wce.lpszMenuName);
+ {DbgPrint("LoadingMenu 0x%p %d\n", wce.lpszMenuName,
IS_INTRESOURCE(wce.lpszMenuName));
+ hMenu = LoadMenuW(hInstance, wce.lpszMenuName);DbgPrint("Loaded menu:
0x%p\n", hMenu);
}
}
@@ -1449,7 +1449,7 @@
STDCALL
GetFocus(VOID)
{
- return (HWND)NtUserGetThreadState(0);
+ return (HWND)NtUserGetThreadState(THREADSTATE_FOCUSWINDOW);
}
/*
Modified: trunk/reactos/include/ndk/pstypes.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/include/ndk/pstypes.h?rev=2…
==============================================================================
--- trunk/reactos/include/ndk/pstypes.h (original)
+++ trunk/reactos/include/ndk/pstypes.h Wed Apr 5 12:05:55 2006
@@ -424,7 +424,7 @@
ULONG LastErrorValue; /* 34h */
ULONG CountOfOwnedCriticalSections; /* 38h */
PVOID CsrClientThread; /* 3Ch */
- struct _W32THREAD* Win32ThreadInfo; /* 40h */
+ PVOID Win32ThreadInfo; /* 40h */
ULONG User32Reserved[0x1A]; /* 44h */
ULONG UserReserved[5]; /* ACh */
PVOID WOW32Reserved; /* C0h */
Modified: trunk/reactos/include/reactos/probe.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/include/reactos/probe.h?rev…
==============================================================================
--- trunk/reactos/include/reactos/probe.h (original)
+++ trunk/reactos/include/reactos/probe.h Wed Apr 5 12:05:55 2006
@@ -8,6 +8,14 @@
static const UNICODE_STRING __emptyUnicodeString = {0};
static const LARGE_INTEGER __emptyLargeInteger = {{0, 0}};
static const ULARGE_INTEGER __emptyULargeInteger = {{0, 0}};
+
+#if defined(_WIN32K_)
+/*
+ * NOTE: NTOSKRNL unfortunately doesn't export RtlRaiseStatus!
+ */
+VOID NTAPI W32kRaiseStatus(NTSTATUS Status);
+#define RtlRaiseStatus W32kRaiseStatus
+#endif
/*
* NOTE: Alignment of the pointers is not verified!
Modified: trunk/reactos/include/reactos/win32k/ntuser.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/include/reactos/win32k/ntus…
==============================================================================
--- trunk/reactos/include/reactos/win32k/ntuser.h (original)
+++ trunk/reactos/include/reactos/win32k/ntuser.h Wed Apr 5 12:05:55 2006
@@ -1,6 +1,75 @@
#ifndef __WIN32K_NTUSER_H
#define __WIN32K_NTUSER_H
+struct _W32PROCESSINFO;
+struct _W32THREADINFO;
+
+typedef struct _DESKTOP
+{
+ HANDLE hKernelHeap;
+ WCHAR szDesktopName[1];
+} DESKTOP, *PDESKTOP;
+
+typedef struct _CALLPROC
+{
+ struct _W32PROCESSINFO *pi;
+ WNDPROC WndProc;
+ BOOL Unicode : 1;
+} CALLPROC, *PCALLPROC;
+
+typedef struct _WINDOWCLASS
+{
+ struct _WINDOWCLASS *Next;
+ struct _WINDOWCLASS *Clone;
+ struct _WINDOWCLASS *Base;
+ PDESKTOP Desktop;
+ RTL_ATOM Atom;
+ ULONG Windows;
+
+ UINT Style;
+ WNDPROC WndProc;
+ union
+ {
+ WNDPROC WndProcExtra;
+ PCALLPROC CallProc;
+ };
+ INT ClsExtra;
+ INT WndExtra;
+ HINSTANCE hInstance;
+ HANDLE hIcon; /* FIXME - Use pointer! */
+ HANDLE hIconSm; /* FIXME - Use pointer! */
+ HANDLE hCursor; /* FIXME - Use pointer! */
+ HBRUSH hbrBackground;
+ HANDLE hMenu; /* FIXME - Use pointer! */
+ PWSTR MenuName;
+ PSTR AnsiMenuName;
+
+ ULONG_PTR ClassExtraDataOffset;
+
+ BOOL Destroying : 1;
+ BOOL Unicode : 1;
+ BOOL System : 1;
+ BOOL Global : 1;
+} WINDOWCLASS, *PWINDOWCLASS;
+
+typedef struct _W32PROCESSINFO
+{
+ PVOID UserHandleTable;
+ PWINDOWCLASS LocalClassList;
+ PWINDOWCLASS GlobalClassList;
+ PWINDOWCLASS SystemClassList;
+} W32PROCESSINFO, *PW32PROCESSINFO;
+
+typedef struct _W32THREADINFO
+{
+ PW32PROCESSINFO pi; /* [USER] */
+ PW32PROCESSINFO kpi; /* [KERNEL] */
+ PDESKTOP Desktop;
+ ULONG_PTR DesktopHeapDelta;
+} W32THREADINFO, *PW32THREADINFO;
+
+PW32THREADINFO GetW32ThreadInfo(VOID);
+PW32PROCESSINFO GetW32ProcessInfo(VOID);
DWORD
NTAPI
@@ -196,8 +265,8 @@
ULONG NTAPI
NtUserGetSystemMetrics(ULONG Index);
-DWORD NTAPI
-NtUserGetClassLong(HWND hWnd, DWORD Offset, BOOL Ansi);
+ULONG_PTR NTAPI
+NtUserGetClassLong(HWND hWnd, INT Offset, BOOL Ansi);
LONG NTAPI
NtUserGetWindowLong(HWND hWnd, DWORD Index, BOOL Ansi);
@@ -785,18 +854,17 @@
NtUserGetCaretPos(
LPPOINT lpPoint);
-DWORD NTAPI
-NtUserGetClassInfo(HINSTANCE hInst,
- LPCWSTR str,
+BOOL NTAPI
+NtUserGetClassInfo(HINSTANCE hInstance,
+ PUNICODE_STRING ClassName,
LPWNDCLASSEXW wcex,
- BOOL Ansi,
- DWORD unknown3);
-
-DWORD
+ BOOL Ansi);
+
+INT
NTAPI
NtUserGetClassName(HWND hWnd,
- LPWSTR lpClassName,
- ULONG nMaxCount);
+ PUNICODE_STRING ClassName,
+ BOOL Ansi);
HANDLE
NTAPI
@@ -1041,6 +1109,7 @@
DWORD dwThreadId,
DWORD Unknown1);
+#define THREADSTATE_GETTHREADINFO (0)
#define THREADSTATE_FOCUSWINDOW (1)
#define THREADSTATE_INSENDMESSAGE (2)
DWORD
@@ -1355,14 +1424,12 @@
#define REGISTERCLASS_ALL (REGISTERCLASS_ANSI | REGISTERCLASS_SYSTEM)
RTL_ATOM NTAPI
-NtUserRegisterClassExWOW(
+NtUserRegisterClassEx(
CONST WNDCLASSEXW* lpwcx,
PUNICODE_STRING ClassName,
- PUNICODE_STRING ClassNameCopy,
PUNICODE_STRING MenuName,
WNDPROC wpExtra,
DWORD Flags,
- DWORD Unknown7,
HMENU hMenu);
BOOL
@@ -1470,11 +1537,11 @@
HWND NTAPI
NtUserGetCapture(VOID);
-DWORD NTAPI
+ULONG_PTR NTAPI
NtUserSetClassLong(
HWND hWnd,
- DWORD Offset,
- LONG dwNewLong,
+ INT Offset,
+ ULONG_PTR dwNewLong,
BOOL Ansi );
@@ -1840,9 +1907,8 @@
BOOL
NTAPI
NtUserUnregisterClass(
- LPCWSTR ClassNameOrAtom,
- HINSTANCE hInstance,
- DWORD Unknown);
+ PUNICODE_STRING ClassNameOrAtom,
+ HINSTANCE hInstance);
BOOL
NTAPI
@@ -1951,15 +2017,15 @@
HWND NTAPI
NtUserGetLastActivePopup(HWND hWnd);
-typedef struct _WndProcHandle
+
+typedef struct _WNDPROC_INFO
{
- WNDPROC WindowProc;
- BOOL IsUnicode;
- HANDLE ProcessID;
-} WndProcHandle;
+ WNDPROC WindowProc;
+ BOOL IsUnicode;
+} WNDPROC_INFO, *PWNDPROC_INFO;
-DWORD NTAPI
-NtUserDereferenceWndProcHandle(WNDPROC wpHandle, WndProcHandle *Data);
+BOOL NTAPI
+NtUserDereferenceWndProcHandle(IN HANDLE wpHandle, OUT PWNDPROC_INFO wpInfo);
VOID NTAPI
NtUserManualGuiCheck(LONG Check);
Modified: trunk/reactos/lib/rtl/heap.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/lib/rtl/heap.c?rev=21460&am…
==============================================================================
--- trunk/reactos/lib/rtl/heap.c (original)
+++ trunk/reactos/lib/rtl/heap.c Wed Apr 5 12:05:55 2006
@@ -311,7 +311,7 @@
}
else
{
- Status = NtAllocateVirtualMemory(NtCurrentProcess(),
+ Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
&address,
0,
&commitsize,
@@ -570,13 +570,24 @@
/* Initialize critical section */
- RtlInitializeHeapLock( &heap->critSection );
+ if (RtlpGetMode() == UserMode)
+ {
+ RtlInitializeHeapLock( &heap->critSection );
+ }
}
/* Commit memory */
if (heap->commitRoutine)
{
- Status = heap->commitRoutine(heap, &address, &commitSize);
+ if (subheap != (SUBHEAP *)heap)
+ {
+ Status = heap->commitRoutine(heap, &address, &commitSize);
+ }
+ else
+ {
+ /* the caller is responsible for committing the first page! */
+ Status = STATUS_SUCCESS;
+ }
}
else
{
Modified: trunk/reactos/subsystems/win32/win32k/include/class.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/inc…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/include/class.h (original)
+++ trunk/reactos/subsystems/win32/win32k/include/class.h Wed Apr 5 12:05:55 2006
@@ -4,28 +4,19 @@
#define IS_ATOM(x) \
(((ULONG_PTR)(x) > 0x0) && ((ULONG_PTR)(x) < 0x10000))
-typedef struct _WNDCLASS_OBJECT
-{
- UINT cbSize;
- LONG refs; /* windows using this class (is 0 after class creation)
*/
- UINT style;
- WNDPROC lpfnWndProcA;
- WNDPROC lpfnWndProcW;
- int cbClsExtra;
- int cbWndExtra;
- HANDLE hInstance;
- HICON hIcon;
- HCURSOR hCursor;
- HBRUSH hbrBackground;
- HMENU hMenu;
- UNICODE_STRING lpszMenuName;
- RTL_ATOM Atom;
- HICON hIconSm;
- BOOL Unicode;
- BOOL Global;
- LIST_ENTRY ListEntry; /* linked into owning process */
- PCHAR ExtraData;
-} WNDCLASS_OBJECT, *PWNDCLASS_OBJECT;
+VOID
+DestroyCallProc(IN PDESKTOP Desktop,
+ IN OUT PCALLPROC CallProc);
+
+PCALLPROC
+CloneCallProc(IN PDESKTOP Desktop,
+ IN PCALLPROC CallProc);
+
+PCALLPROC
+CreateCallProc(IN PDESKTOP Desktop,
+ IN WNDPROC WndProc,
+ IN BOOL Unicode,
+ IN PW32PROCESSINFO pi);
NTSTATUS FASTCALL
InitClassImpl(VOID);
@@ -33,32 +24,45 @@
NTSTATUS FASTCALL
CleanupClassImpl(VOID);
-void FASTCALL DestroyProcessClasses(PW32PROCESS Process );
+BOOL
+UserGetCallProcInfo(IN HANDLE hCallProc,
+ OUT PWNDPROC_INFO wpInfo);
-__inline VOID FASTCALL
-ClassDerefObject(PWNDCLASS_OBJECT Class);
+void FASTCALL
+DestroyProcessClasses(PW32PROCESS Process );
-__inline VOID FASTCALL
-ClassRefObject(PWNDCLASS_OBJECT Class);
+PWINDOWCLASS
+IntReferenceClass(IN PWINDOWCLASS BaseClass,
+ IN PDESKTOP Desktop);
-PWNDCLASS_OBJECT FASTCALL
-ClassGetClassByAtom(
- RTL_ATOM Atom,
- HINSTANCE hInstance);
+VOID
+IntDereferenceClass(IN OUT PWINDOWCLASS Class,
+ IN PDESKTOP Desktop,
+ IN PW32PROCESSINFO pi);
-PWNDCLASS_OBJECT FASTCALL
-ClassGetClassByName(
- LPCWSTR ClassName,
- HINSTANCE hInstance);
+RTL_ATOM
+UserRegisterClass(IN CONST WNDCLASSEXW* lpwcx,
+ IN PUNICODE_STRING ClassName,
+ IN PUNICODE_STRING MenuName,
+ IN HANDLE hMenu,
+ IN WNDPROC wpExtra,
+ IN DWORD dwFlags);
-PWNDCLASS_OBJECT FASTCALL
-ClassGetClassByNameOrAtom(
- LPCWSTR ClassNameOrAtom,
- HINSTANCE hInstance);
+BOOL
+UserUnregisterClass(IN PUNICODE_STRING ClassName,
+ IN HINSTANCE hInstance);
-struct _WINDOW_OBJECT;
-ULONG FASTCALL
-IntGetClassLong(struct _WINDOW_OBJECT *WindowObject, ULONG Offset, BOOL Ansi);
+ULONG_PTR
+UserGetClassLongPtr(IN PWINDOWCLASS Class,
+ IN INT Index,
+ IN BOOL Ansi);
+
+RTL_ATOM
+IntGetClassAtom(IN PUNICODE_STRING ClassName,
+ IN HINSTANCE hInstance OPTIONAL,
+ IN PW32PROCESSINFO pi OPTIONAL,
+ OUT PWINDOWCLASS *BaseClass OPTIONAL,
+ OUT PWINDOWCLASS **Link OPTIONAL);
#endif /* _WIN32K_CLASS_H */
Modified: trunk/reactos/subsystems/win32/win32k/include/desktop.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/inc…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/include/desktop.h (original)
+++ trunk/reactos/subsystems/win32/win32k/include/desktop.h Wed Apr 5 12:05:55 2006
@@ -6,8 +6,6 @@
typedef struct _DESKTOP_OBJECT
{
- PVOID DesktopHeap; /* points to kmode memory! */
-
CSHORT Type;
CSHORT Size;
LIST_ENTRY ListEntry;
@@ -26,11 +24,15 @@
PVOID BlockInputThread;
LIST_ENTRY ShellHookWindows;
+
+ HANDLE hDesktopHeap;
+ PSECTION_OBJECT DesktopHeapSection;
+ PDESKTOP DesktopInfo;
} DESKTOP_OBJECT, *PDESKTOP_OBJECT;
extern PDESKTOP_OBJECT InputDesktop;
extern HDESK InputDesktopHandle;
-extern PWNDCLASS_OBJECT DesktopWindowClass;
+extern PWINDOWCLASS DesktopWindowClass;
extern HDC ScreenDeviceContext;
extern BOOL g_PaintDesktopVersion;
@@ -91,6 +93,8 @@
HDESK FASTCALL
IntGetDesktopObjectHandle(PDESKTOP_OBJECT DesktopObject);
+BOOL IntSetThreadDesktop(IN PDESKTOP_OBJECT DesktopObject);
+
NTSTATUS FASTCALL
IntValidateDesktopHandle(
HDESK Desktop,
@@ -115,6 +119,113 @@
#define IntIsActiveDesktop(Desktop) \
((Desktop)->WindowStation->ActiveDesktop == (Desktop))
+static __inline PVOID
+DesktopHeapAlloc(IN PDESKTOP Desktop,
+ IN SIZE_T Bytes)
+{
+ return RtlAllocateHeap(Desktop->hKernelHeap,
+ HEAP_NO_SERIALIZE,
+ Bytes);
+}
+
+static __inline BOOL
+DesktopHeapFree(IN PDESKTOP Desktop,
+ IN PVOID lpMem)
+{
+ return RtlFreeHeap(Desktop->hKernelHeap,
+ HEAP_NO_SERIALIZE,
+ lpMem);
+}
+
+static __inline PVOID
+DesktopHeapReAlloc(IN PDESKTOP Desktop,
+ IN PVOID lpMem,
+ IN SIZE_T Bytes)
+{
+#if 0
+ /* NOTE: ntoskrnl doesn't export RtlReAllocateHeap... */
+ return RtlReAllocateHeap(Desktop->hKernelHeap,
+ HEAP_NO_SERIALIZE,
+ lpMem,
+ Bytes);
+#else
+ SIZE_T PrevSize;
+ PVOID pNew;
+
+ PrevSize = RtlSizeHeap(Desktop->hKernelHeap,
+ HEAP_NO_SERIALIZE,
+ lpMem);
+
+ if (PrevSize == Bytes)
+ return lpMem;
+
+ pNew = RtlAllocateHeap(Desktop->hKernelHeap,
+ HEAP_NO_SERIALIZE,
+ Bytes);
+ if (pNew != NULL)
+ {
+ if (PrevSize < Bytes)
+ Bytes = PrevSize;
+
+ RtlCopyMemory(pNew,
+ lpMem,
+ Bytes);
+
+ RtlFreeHeap(Desktop->hKernelHeap,
+ HEAP_NO_SERIALIZE,
+ lpMem);
+ }
+
+ return pNew;
+#endif
+}
+
+static __inline ULONG_PTR
+DesktopHeapGetUserDelta(VOID)
+{
+ PW32HEAP_USER_MAPPING Mapping;
+ HANDLE hDesktopHeap;
+ ULONG_PTR Delta = 0;
+
+ ASSERT(PsGetWin32Thread()->Desktop != NULL);
+ hDesktopHeap = PsGetWin32Thread()->Desktop->hDesktopHeap;
+
+ Mapping = PsGetWin32Process()->HeapMappings.Next;
+ while (Mapping != NULL)
+ {
+ if (Mapping->UserMapping == (PVOID)hDesktopHeap)
+ {
+ Delta = (ULONG_PTR)Mapping->KernelMapping -
(ULONG_PTR)Mapping->UserMapping;
+ break;
+ }
+
+ Mapping = Mapping->Next;
+ }
+
+ return Delta;
+}
+
+static __inline PVOID
+DesktopHeapAddressToUser(IN PDESKTOP Desktop,
+ PVOID lpMem)
+{
+ PW32HEAP_USER_MAPPING Mapping;
+
+ Mapping = PsGetWin32Process()->HeapMappings.Next;
+ while (Mapping != NULL)
+ {
+ if (Mapping->KernelMapping == (PVOID)Desktop->hKernelHeap)
+ {
+ return (PVOID)(((ULONG_PTR)lpMem - (ULONG_PTR)Desktop->hKernelHeap) +
+ (ULONG_PTR)Mapping->UserMapping);
+ }
+
+ Mapping = Mapping->Next;
+ }
+
+ return NULL;
+}
+
#endif /* _WIN32K_DESKTOP_H */
/* EOF */
Modified: trunk/reactos/subsystems/win32/win32k/include/object.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/inc…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/include/object.h (original)
+++ trunk/reactos/subsystems/win32/win32k/include/object.h Wed Apr 5 12:05:55 2006
@@ -45,7 +45,7 @@
otCursorIcon,
otHook,
otMonitor,
- otClass //fixme: remove
+ otCallProc
} USER_OBJECT_TYPE;
@@ -125,6 +125,8 @@
\
}
+HANDLE FASTCALL ObmObjectToHandle(PVOID obj);
+
VOID FASTCALL CreateStockObjects (VOID);
VOID FASTCALL CreateSysColorObjects (VOID);
Modified: trunk/reactos/subsystems/win32/win32k/include/userfuncs.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/inc…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/include/userfuncs.h (original)
+++ trunk/reactos/subsystems/win32/win32k/include/userfuncs.h Wed Apr 5 12:05:55 2006
@@ -75,7 +75,7 @@
/******************** HANDLE.C ***************/
-extern USER_HANDLE_TABLE gHandleTable;
+extern PUSER_HANDLE_TABLE gHandleTable;
PUSER_HANDLE_ENTRY handle_to_entry(PUSER_HANDLE_TABLE ht, HANDLE handle );
VOID UserInitHandleTable(PUSER_HANDLE_TABLE ht, PVOID mem, ULONG bytes);
Modified: trunk/reactos/subsystems/win32/win32k/include/win32.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/inc…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/include/win32.h (original)
+++ trunk/reactos/subsystems/win32/win32k/include/win32.h Wed Apr 5 12:05:55 2006
@@ -15,10 +15,18 @@
BOOLEAN IsExiting;
SINGLE_LIST_ENTRY ReferencesList;
+ PW32THREADINFO ThreadInfo;
} W32THREAD, *PW32THREAD;
#include <poppack.h>
+typedef struct _W32HEAP_USER_MAPPING
+{
+ struct _W32HEAP_USER_MAPPING *Next;
+ PVOID KernelMapping;
+ PVOID UserMapping;
+ ULONG Count;
+} W32HEAP_USER_MAPPING, *PW32HEAP_USER_MAPPING;
typedef struct _W32PROCESS
{
@@ -32,6 +40,9 @@
ULONG Flags;
LONG GDIObjects;
LONG UserObjects;
+
+ W32HEAP_USER_MAPPING HeapMappings;
+ PW32PROCESSINFO ProcessInfo;
} W32PROCESS, *PW32PROCESS;
Modified: trunk/reactos/subsystems/win32/win32k/include/window.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/inc…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/include/window.h (original)
+++ trunk/reactos/subsystems/win32/win32k/include/window.h Wed Apr 5 12:05:55 2006
@@ -26,8 +26,21 @@
typedef struct _WINDOW_OBJECT
{
+ /* Pointer to the thread information */
+ PW32THREADINFO ti;
+ /* Pointer to the desktop */
+ PDESKTOP Desktop;
+ union
+ {
+ /* Pointer to a call procedure handle */
+ PCALLPROC CallProc;
+ /* Extra Wnd proc (windows of system classes) */
+ WNDPROC WndProcExtra;
+ };
+ /* Indicates whether the window is derived from a system class */
+ BOOL IsSystem;
/* Pointer to the window class. */
- PWNDCLASS_OBJECT Class;
+ PWINDOWCLASS Class;
/* Extended style. */
DWORD ExStyle;
/* Window name. */
@@ -81,8 +94,7 @@
PWINDOW_SCROLLINFO Scroll;
LONG UserData;
BOOL Unicode;
- WNDPROC WndProcA;
- WNDPROC WndProcW;
+ WNDPROC WndProc;
PETHREAD OwnerThread;
HWND hWndLastPopup; /* handle to last active popup window (wine doesn't use
pointer, for unk. reason)*/
PINTERNALPOS InternalPos;
@@ -190,10 +202,6 @@
BOOL FASTCALL
IntIsWindowInDestroy(PWINDOW_OBJECT Window);
-DWORD IntRemoveWndProcHandle(WNDPROC Handle);
-DWORD IntRemoveProcessWndProcHandles(HANDLE ProcessID);
-DWORD IntAddWndProcHandle(WNDPROC WindowProc, BOOL IsUnicode);
-
BOOL FASTCALL
IntShowOwnedPopups( PWINDOW_OBJECT owner, BOOL fShow );
Modified: trunk/reactos/subsystems/win32/win32k/main/dllmain.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/mai…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/main/dllmain.c (original)
+++ trunk/reactos/subsystems/win32/win32k/main/dllmain.c Wed Apr 5 12:05:55 2006
@@ -33,6 +33,9 @@
PGDI_HANDLE_TABLE GdiHandleTable = NULL;
PSECTION_OBJECT GdiTableSection = NULL;
+HANDLE GlobalUserHeap = NULL;
+PSECTION_OBJECT GlobalUserHeapSection = NULL;
+
extern ULONG_PTR Win32kSSDT[];
extern UCHAR Win32kSSPT[];
extern ULONG Win32kNumberOfSysCalls;
@@ -69,7 +72,34 @@
if (Create)
{
+ ULONG ViewSize = 0;
+ LARGE_INTEGER Offset;
+ PVOID UserBase = NULL;
+ NTSTATUS Status;
+ extern PSECTION_OBJECT GlobalUserHeapSection;
DPRINT("Creating W32 process PID:%d at IRQ level: %lu\n",
Process->UniqueProcessId, KeGetCurrentIrql());
+
+ /* map the global heap into the process */
+ Offset.QuadPart = 0;
+ Status = MmMapViewOfSection(GlobalUserHeapSection,
+ PsGetCurrentProcess(),
+ &UserBase,
+ 0,
+ 0,
+ &Offset,
+ &ViewSize,
+ ViewUnmap,
+ SEC_NO_CHANGE,
+ PAGE_EXECUTE_READ); /* would prefer PAGE_READONLY, but
thanks to RTL heaps... */
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed to map the global heap! 0x%x\n", Status);
+ RETURN(Status);
+ }
+ Win32Process->HeapMappings.Next = NULL;
+ Win32Process->HeapMappings.KernelMapping = (PVOID)GlobalUserHeap;
+ Win32Process->HeapMappings.UserMapping = UserBase;
+ Win32Process->HeapMappings.Count = 1;
InitializeListHead(&Win32Process->ClassList);
@@ -95,7 +125,6 @@
else
{
DPRINT("Destroying W32 process PID:%d at IRQ level: %lu\n",
Process->UniqueProcessId, KeGetCurrentIrql());
- IntRemoveProcessWndProcHandles((HANDLE)Process->UniqueProcessId);
IntCleanupMenus(Process, Win32Process);
IntCleanupCurIcons(Process, Win32Process);
IntEngCleanupDriverObjs(Process, Win32Process);
@@ -114,6 +143,12 @@
if(LogonProcess == Win32Process)
{
LogonProcess = NULL;
+ }
+
+ if (Win32Process->ProcessInfo != NULL)
+ {
+ UserHeapFree(Win32Process->ProcessInfo);
+ Win32Process->ProcessInfo = NULL;
}
}
@@ -198,17 +233,25 @@
if (hDesk != NULL)
{
+ PDESKTOP_OBJECT DesktopObject;
+ Win32Thread->Desktop = NULL;
Status = ObReferenceObjectByHandle(hDesk,
0,
ExDesktopObjectType,
KernelMode,
- (PVOID*)&Win32Thread->Desktop,
+ (PVOID*)&DesktopObject,
NULL);
NtClose(hDesk);
- if(!NT_SUCCESS(Status))
+ if(NT_SUCCESS(Status))
+ {
+ if (!IntSetThreadDesktop(DesktopObject))
+ {
+ DPRINT1("Unable to set thread desktop\n");
+ }
+ }
+ else
{
DPRINT1("Unable to reference thread desktop handle 0x%x\n",
hDesk);
- Win32Thread->Desktop = NULL;
}
}
}
@@ -234,11 +277,15 @@
IntBlockInput(Win32Thread, FALSE);
MsqDestroyMessageQueue(Win32Thread->MessageQueue);
IntCleanupThreadCallbacks(Win32Thread);
- if(Win32Thread->Desktop != NULL)
- {
- ObDereferenceObject(Win32Thread->Desktop);
- }
-
+
+ IntSetThreadDesktop(NULL);
+
+ if (Win32Thread->ThreadInfo != NULL)
+ {
+ UserHeapFree(Win32Thread->ThreadInfo);
+ Win32Thread->ThreadInfo = NULL;
+ }
+
/* cleanup user object references stack */
e = PopEntryList(&Win32Thread->ReferencesList);
while (e)
@@ -309,6 +356,7 @@
NTSTATUS Status;
BOOLEAN Result;
W32_CALLOUT_DATA CalloutData;
+ PVOID GlobalUserHeapBase = NULL;
/*
* Register user mode call interface
@@ -342,6 +390,16 @@
*/
PsEstablishWin32Callouts(&CalloutData);
+ GlobalUserHeap = UserCreateHeap(&GlobalUserHeapSection,
+ &GlobalUserHeapBase,
+ 1 * 1024 * 1024); /* FIXME - 1 MB for now... */
+ if (GlobalUserHeap == NULL)
+ {
+ DPRINT1("Failed to initialize the global heap!\n");
+ return STATUS_UNSUCCESSFUL;
+ }
+
+
Status = InitUserImpl();
if (!NT_SUCCESS(Status))
{
Modified: trunk/reactos/subsystems/win32/win32k/misc/err.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/mis…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/misc/err.c (original)
+++ trunk/reactos/subsystems/win32/win32k/misc/err.c Wed Apr 5 12:05:55 2006
@@ -61,4 +61,22 @@
return 0;
}
+VOID
+NTAPI
+W32kRaiseStatus(NTSTATUS Status)
+{
+ EXCEPTION_RECORD ExceptionRecord;
+
+ /* Create an exception record */
+ ExceptionRecord.ExceptionCode = Status;
+ ExceptionRecord.ExceptionRecord = NULL;
+ ExceptionRecord.NumberParameters = 0;
+ ExceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
+
+ RtlRaiseException(&ExceptionRecord);
+
+ /* If we returned, raise a status */
+ W32kRaiseStatus(Status);
+}
+
/* EOF */
Added: trunk/reactos/subsystems/win32/win32k/misc/usrheap.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/mis…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/misc/usrheap.c (added)
+++ trunk/reactos/subsystems/win32/win32k/misc/usrheap.c Wed Apr 5 12:05:55 2006
@@ -1,0 +1,216 @@
+/*
+ * ReactOS W32 Subsystem
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <w32k.h>
+
+#define NDEBUG
+#include <debug.h>
+
+
+static NTSTATUS NTAPI
+IntUserHeapCommitRoutine(IN PVOID Base,
+ IN OUT PVOID *CommitAddress,
+ IN OUT PSIZE_T CommitSize)
+{
+ PW32PROCESS W32Process;
+ PW32HEAP_USER_MAPPING Mapping;
+ PVOID UserBase = NULL;
+ NTSTATUS Status;
+ SIZE_T Delta = (SIZE_T)((ULONG_PTR)(*CommitAddress) - (ULONG_PTR)Base);
+
+ W32Process = PsGetWin32Process();
+
+ if (W32Process != NULL)
+ {
+ /* search for the mapping */
+ Mapping = &W32Process->HeapMappings;
+ while (Mapping != NULL)
+ {
+ if (Mapping->KernelMapping == Base)
+ {
+ UserBase = Mapping->UserMapping;
+ break;
+ }
+
+ Mapping = Mapping->Next;
+ }
+
+ ASSERT(UserBase != NULL);
+ }
+ else
+ {
+ ULONG ViewSize = 0;
+ LARGE_INTEGER Offset;
+ extern PSECTION_OBJECT GlobalUserHeapSection;
+
+ /* HACK: This needs to be handled during startup only... */
+ ASSERT(Base == (PVOID)GlobalUserHeap);
+
+ /* temporarily map it into user space */
+ Offset.QuadPart = 0;
+ Status = MmMapViewOfSection(GlobalUserHeapSection,
+ PsGetCurrentProcess(),
+ &UserBase,
+ 0,
+ 0,
+ &Offset,
+ &ViewSize,
+ ViewUnmap,
+ SEC_NO_CHANGE,
+ PAGE_EXECUTE_READ); /* would prefer PAGE_READONLY,
but thanks to RTL heaps... */
+
+ if (!NT_SUCCESS(Status))
+ return Status;
+ }
+
+ /* commit! */
+ UserBase = (PVOID)((ULONG_PTR)UserBase + Delta);
+
+ Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
+ &UserBase,
+ 0,
+ CommitSize,
+ MEM_COMMIT,
+ PAGE_EXECUTE_READ);
+ if (NT_SUCCESS(Status))
+ {
+ *CommitAddress = (PVOID)((ULONG_PTR)UserBase + Delta);
+ }
+
+ if (W32Process == NULL)
+ {
+ MmUnmapViewOfSection(PsGetCurrentProcess(),
+ UserBase);
+ }
+
+ return Status;
+}
+
+static HANDLE
+IntUserHeapCreate(IN PSECTION_OBJECT SectionObject,
+ IN PVOID *SystemMappedBase,
+ IN ULONG HeapSize)
+{
+ PVOID MappedView = NULL;
+ LARGE_INTEGER Offset;
+ ULONG ViewSize = PAGE_SIZE;
+ RTL_HEAP_PARAMETERS Parameters = {0};
+ HANDLE hHeap;
+ NTSTATUS Status;
+
+ Offset.QuadPart = 0;
+
+ /* Commit the first page before creating the heap! */
+ Status = MmMapViewOfSection(SectionObject,
+ PsGetCurrentProcess(),
+ &MappedView,
+ 0,
+ 0,
+ &Offset,
+ &ViewSize,
+ ViewUnmap,
+ SEC_NO_CHANGE,
+ PAGE_EXECUTE_READ); /* would prefer PAGE_READONLY, but
thanks to RTL heaps... */
+ if (!NT_SUCCESS(Status))
+ return NULL;
+
+ Status = ZwAllocateVirtualMemory(NtCurrentProcess(),
+ &MappedView,
+ 0,
+ &ViewSize,
+ MEM_COMMIT,
+ PAGE_EXECUTE_READ); /* would prefer PAGE_READONLY,
but thanks to RTL heaps... */
+
+ MmUnmapViewOfSection(PsGetCurrentProcess(),
+ MappedView);
+
+ if (!NT_SUCCESS(Status))
+ return NULL;
+
+ /* Create the heap, don't serialize in kmode! The caller is responsible
+ to synchronize the heap! */
+ Parameters.Length = sizeof(Parameters);
+ Parameters.InitialCommit = PAGE_SIZE;
+ Parameters.InitialReserve = (SIZE_T)HeapSize;
+ Parameters.CommitRoutine = IntUserHeapCommitRoutine;
+
+ hHeap = RtlCreateHeap(HEAP_ZERO_MEMORY | HEAP_NO_SERIALIZE,
+ *SystemMappedBase,
+ (SIZE_T)HeapSize,
+ PAGE_SIZE,
+ NULL,
+ &Parameters);
+
+ return hHeap;
+}
+
+HANDLE
+UserCreateHeap(OUT PSECTION_OBJECT *SectionObject,
+ IN OUT PVOID *SystemBase,
+ IN ULONG HeapSize)
+{
+ LARGE_INTEGER SizeHeap;
+ HANDLE hHeap = NULL;
+ NTSTATUS Status;
+
+ SizeHeap.QuadPart = HeapSize;
+
+ /* create the section and map it into session space */
+ Status = MmCreateSection((PVOID*)SectionObject,
+ SECTION_ALL_ACCESS,
+ NULL,
+ &SizeHeap,
+ PAGE_EXECUTE_READWRITE, /* would prefer PAGE_READWRITE, but
thanks to RTL heaps... */
+ SEC_RESERVE,
+ NULL,
+ NULL);
+
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ return FALSE;
+ }
+
+ Status = MmMapViewInSystemSpace(*SectionObject,
+ SystemBase,
+ &HeapSize);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(*SectionObject);
+ *SectionObject = NULL;
+
+ SetLastNtError(Status);
+ return FALSE;
+ }
+
+ /* create the heap */
+ hHeap = IntUserHeapCreate(*SectionObject,
+ SystemBase,
+ HeapSize);
+
+ if (hHeap == NULL)
+ {
+ ObDereferenceObject(*SectionObject);
+ *SectionObject = NULL;
+
+ SetLastNtError(STATUS_UNSUCCESSFUL);
+ }
+
+ return hHeap;
+}
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/accelerator.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/accelerator.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/accelerator.c Wed Apr 5 12:05:55 2006
@@ -80,7 +80,7 @@
return NULL;
}
- Accel= UserGetObject(&gHandleTable, hAccel, otAccel);
+ Accel= UserGetObject(gHandleTable, hAccel, otAccel);
if (!Accel)
{
SetLastWin32Error(ERROR_INVALID_ACCEL_HANDLE);
@@ -344,7 +344,7 @@
Entries, EntriesCount);
UserEnterExclusive();
- Accel = ObmCreateObject(&gHandleTable, (PHANDLE)&hAccel, otAccel,
sizeof(ACCELERATOR_TABLE));
+ Accel = ObmCreateObject(gHandleTable, (PHANDLE)&hAccel, otAccel,
sizeof(ACCELERATOR_TABLE));
if (Accel == NULL)
{
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/class.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/class.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/class.c Wed Apr 5 12:05:55 2006
@@ -1,6 +1,6 @@
/*
* ReactOS W32 Subsystem
- * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
+ * Copyright (C) 1998 - 2006 ReactOS Team
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -22,9 +22,12 @@
* PROJECT: ReactOS kernel
* PURPOSE: Window classes
* FILE: subsys/win32k/ntuser/class.c
- * PROGRAMER: Casper S. Hornstrup (chorns(a)users.sourceforge.net)
+ * PROGRAMER: Thomas Weidenmueller <w3seek(a)reactos.com>
* REVISION HISTORY:
* 06-06-2001 CSH Created
+ *
+ * NOTE: Should classes created on a desktop heap be moved to the shared
+ * heap when the desktop is destroyed, or should they be unregistered?
*/
/* INCLUDES ******************************************************************/
@@ -33,7 +36,96 @@
#define NDEBUG
#include <debug.h>
-/* FUNCTIONS *****************************************************************/
+/* CALLPROC ******************************************************************/
+
+VOID
+DestroyCallProc(IN PDESKTOP Desktop,
+ IN OUT PCALLPROC CallProc)
+{
+ /* FIXME - use new object manager! */
+ HANDLE Handle = ObmObjectToHandle(CallProc);
+
+ ObmDeleteObject(Handle,
+ otCallProc);
+}
+
+PCALLPROC
+CloneCallProc(IN PDESKTOP Desktop,
+ IN PCALLPROC CallProc)
+{
+ PCALLPROC NewCallProc;
+ HANDLE Handle;
+
+ /* FIXME - use new object manager! */
+ NewCallProc = (PCALLPROC)ObmCreateObject(gHandleTable,
+ &Handle,
+ otCallProc,
+ sizeof(CALLPROC));
+ if (NewCallProc != NULL)
+ {
+ NewCallProc->pi = CallProc->pi;
+ NewCallProc->WndProc = CallProc->WndProc;
+ NewCallProc->Unicode = CallProc->Unicode;
+ }
+
+ return NewCallProc;
+}
+
+PCALLPROC
+CreateCallProc(IN PDESKTOP Desktop,
+ IN WNDPROC WndProc,
+ IN BOOL Unicode,
+ IN PW32PROCESSINFO pi)
+{
+ PCALLPROC NewCallProc;
+ HANDLE Handle;
+
+ /* FIXME - use new object manager! */
+ NewCallProc = (PCALLPROC)ObmCreateObject(gHandleTable,
+ &Handle,
+ otCallProc,
+ sizeof(CALLPROC));
+ if (NewCallProc != NULL)
+ {
+ NewCallProc->pi = pi;
+ NewCallProc->WndProc = WndProc;
+ NewCallProc->Unicode = Unicode;
+ }
+
+ return NewCallProc;
+}
+
+BOOL
+UserGetCallProcInfo(IN HANDLE hCallProc,
+ OUT PWNDPROC_INFO wpInfo)
+{
+ PCALLPROC CallProc;
+
+ /* NOTE: Accessing the WNDPROC_INFO structure may raise an exception! */
+
+ /* FIXME - use new object manager! */
+ CallProc = UserGetObject(gHandleTable,
+ hCallProc,
+ otCallProc);
+ if (CallProc == NULL)
+ {
+ SetLastWin32Error(ERROR_INVALID_HANDLE);
+ return FALSE;
+ }
+
+ if (CallProc->pi != GetW32ProcessInfo())
+ {
+ SetLastWin32Error(ERROR_ACCESS_DENIED);
+ return FALSE;
+ }
+
+ wpInfo->WindowProc = CallProc->WndProc;
+ wpInfo->IsUnicode = CallProc->Unicode;
+
+ return TRUE;
+}
+
+/* WINDOWCLASS ***************************************************************/
NTSTATUS FASTCALL
InitClassImpl(VOID)
@@ -47,398 +139,1673 @@
return(STATUS_SUCCESS);
}
-
-__inline VOID FASTCALL
-ClassDerefObject(PWNDCLASS_OBJECT Class)
-{
- ASSERT(Class->refs >= 1);
- Class->refs--;
-}
-
-
-__inline VOID FASTCALL
-ClassRefObject(PWNDCLASS_OBJECT Class)
-{
- ASSERT(Class->refs >= 0);
- Class->refs++;
-}
-
-
-VOID FASTCALL DestroyClass(PWNDCLASS_OBJECT Class)
-{
-#if defined(DBG) || defined(KDBG)
- if ( Class->refs != 0 )
- {
- WCHAR AtomName[256];
- ULONG AtomNameLen = sizeof(AtomName);
- RtlQueryAtomInAtomTable ( gAtomTable, Class->Atom,
- NULL, NULL, AtomName, &AtomNameLen );
- DPRINT1("DestroyClass(): can't delete class = '%ws', b/c refs =
%lu\n", AtomName, Class->refs );
- }
-#endif
- ASSERT(Class->refs == 0);
-
- RemoveEntryList(&Class->ListEntry);
- if (Class->hMenu)
- UserDestroyMenu(Class->hMenu);
- RtlDeleteAtomFromAtomTable(gAtomTable, Class->Atom);
- ExFreePool(Class);
+static VOID
+IntFreeClassMenuName(IN OUT PWINDOWCLASS Class)
+{
+ /* free the menu name, if it was changed and allocated */
+ if (Class->MenuName != NULL && !IS_INTRESOURCE(Class->MenuName)
&&
+ Class->MenuName != (PWSTR)(Class + 1))
+ {
+ UserHeapFree(Class->MenuName);
+ Class->MenuName = NULL;
+ Class->AnsiMenuName = NULL;
+ }
+}
+
+static VOID
+IntDestroyClass(IN OUT PWINDOWCLASS Class)
+{
+ /* there shouldn't be any clones anymore */
+
+ ASSERT(Class->Windows == 0);
+
+ if (Class->Desktop != NULL)
+ {
+ ASSERT(Class->Clone == NULL);
+ }
+ else if (Class->Clone != NULL)
+ {
+ /* there must not be more than one clone! This can be the case
+ when the base class is on the shared heap */
+ ASSERT(Class->Clone->Next == NULL);
+
+ /* free the clone */
+ IntDestroyClass(Class->Clone);
+ Class->Clone = NULL;
+ }
+
+ if (Class->Base == Class)
+ {
+ /* destruct resources shared with clones */
+ if (!Class->System && Class->CallProc != NULL)
+ {
+ DestroyCallProc(Class->Desktop,
+ Class->CallProc);
+ }
+
+ IntFreeClassMenuName(Class);
+ }
+
+ /* free the structure */
+ if (Class->Desktop != NULL)
+ {
+ DesktopHeapFree(Class->Desktop,
+ Class);
+ }
+ else
+ {
+ UserHeapFree(Class);
+ }
}
/* clean all process classes. all process windows must cleaned first!! */
void FASTCALL DestroyProcessClasses(PW32PROCESS Process )
{
- PWNDCLASS_OBJECT Class;
-
- while (!IsListEmpty(&Process->ClassList))
- {
- Class = CONTAINING_RECORD(RemoveHeadList(&Process->ClassList),
WNDCLASS_OBJECT, ListEntry);
- DestroyClass(Class);
- }
-}
-
-
-
-
-PWNDCLASS_OBJECT FASTCALL
-ClassGetClassByAtom(RTL_ATOM Atom, HINSTANCE hInstance)
-{
- PWNDCLASS_OBJECT Class;
- PW32PROCESS Process = PsGetWin32Process();
-
- LIST_FOR_EACH(Class, &Process->ClassList, WNDCLASS_OBJECT, ListEntry)
- {
- if (Class->Atom != Atom) continue;
-
- if (!hInstance || Class->Global || Class->hInstance == hInstance) return
Class;
- }
-
- return NULL;
-}
-
-
-PWNDCLASS_OBJECT FASTCALL
-ClassGetClassByName(LPCWSTR ClassName, HINSTANCE hInstance)
-{
- NTSTATUS Status;
- RTL_ATOM Atom;
-
- if (!ClassName || !PsGetWin32Thread()->Desktop)
- return FALSE;
-
- Status = RtlLookupAtomInAtomTable(
- gAtomTable,
- (LPWSTR)ClassName,
- &Atom);
-
- if (!NT_SUCCESS(Status))
- {
- DPRINT1("Failed to lookup class atom (ClassName '%S')!\n",
ClassName);
- return FALSE;
- }
-
- return ClassGetClassByAtom(Atom, hInstance);
-}
-
-
-PWNDCLASS_OBJECT FASTCALL
-ClassGetClassByNameOrAtom(LPCWSTR ClassNameOrAtom, HINSTANCE hInstance)
-{
- if (!ClassNameOrAtom) return NULL;
-
- if (IS_ATOM(ClassNameOrAtom))
- return ClassGetClassByAtom((RTL_ATOM)((ULONG_PTR)ClassNameOrAtom), hInstance);
- else
- return ClassGetClassByName(ClassNameOrAtom, hInstance);
-}
-
-
-static
-BOOL FASTCALL
-IntRegisterClass(
- CONST WNDCLASSEXW *lpwcx,
- DWORD Flags,
- WNDPROC wpExtra,
- PUNICODE_STRING MenuName,
- RTL_ATOM Atom,
- HMENU hMenu)
-{
- PWNDCLASS_OBJECT Class;
- ULONG objectSize;
- BOOL Global;
-
- ASSERT(lpwcx);
- ASSERT(Atom);
- ASSERT(lpwcx->hInstance);
-
- Global = (Flags & REGISTERCLASS_SYSTEM) || (lpwcx->style &
CS_GLOBALCLASS);
-
- /* Check for double registration of the class. */
- Class = ClassGetClassByAtom(Atom, lpwcx->hInstance);
- if (Class && Global == Class->Global)
- {
- /* can max have one class of each type (global/local) */
- SetLastWin32Error(ERROR_CLASS_ALREADY_EXISTS);
- return(FALSE);
- }
-
- objectSize = sizeof(WNDCLASS_OBJECT) + lpwcx->cbClsExtra;
-
- //FIXME: allocate in session heap (or possibly desktop heap)
- Class = ExAllocatePool(PagedPool, objectSize);
- if (!Class)
- {
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
- return(FALSE);
- }
- RtlZeroMemory(Class, objectSize);
-
- Class->cbSize = lpwcx->cbSize;
- Class->style = lpwcx->style;
- Class->cbClsExtra = lpwcx->cbClsExtra;
- Class->cbWndExtra = lpwcx->cbWndExtra;
- Class->hInstance = lpwcx->hInstance;
- Class->hIcon = lpwcx->hIcon;
- Class->hCursor = lpwcx->hCursor;
- Class->hMenu = hMenu;
- Class->hbrBackground = lpwcx->hbrBackground;
- Class->Unicode = !(Flags & REGISTERCLASS_ANSI);
- Class->Global = Global;
- Class->hIconSm = lpwcx->hIconSm;
- Class->Atom = Atom;
-
- if (MenuName->Length == 0)
- {
- Class->lpszMenuName.Length =
- Class->lpszMenuName.MaximumLength = 0;
- Class->lpszMenuName.Buffer = MenuName->Buffer;
- }
- else
- {
- Class->lpszMenuName.Length =
- Class->lpszMenuName.MaximumLength = MenuName->MaximumLength;
- Class->lpszMenuName.Buffer = ExAllocatePoolWithTag(PagedPool,
Class->lpszMenuName.MaximumLength, TAG_STRING);
-
- if (Class->lpszMenuName.Buffer == NULL)
- {
- SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
- return(FALSE);
- }
-
- RtlCopyUnicodeString(&Class->lpszMenuName, MenuName);
- }
-
- if (wpExtra == NULL)
- {
- if (Flags & REGISTERCLASS_ANSI)
- {
- Class->lpfnWndProcA = lpwcx->lpfnWndProc;
- Class->lpfnWndProcW =
(WNDPROC)IntAddWndProcHandle(lpwcx->lpfnWndProc,FALSE);
- }
- else
- {
- Class->lpfnWndProcW = lpwcx->lpfnWndProc;
- Class->lpfnWndProcA =
(WNDPROC)IntAddWndProcHandle(lpwcx->lpfnWndProc,TRUE);
- }
- }
- else
- {
- if (Flags & REGISTERCLASS_ANSI)
- {
- Class->lpfnWndProcA = lpwcx->lpfnWndProc;
- Class->lpfnWndProcW = wpExtra;
- }
- else
- {
- Class->lpfnWndProcW = lpwcx->lpfnWndProc;
- Class->lpfnWndProcA = wpExtra;
- }
- }
-
-
-
- /* Extra class data */
- if (Class->cbClsExtra)
- Class->ExtraData = (PCHAR)(Class + 1);
-
- if (Global)
- {
- /* global classes go last (incl. system classes) */
- InsertTailList(&PsGetWin32Process()->ClassList, &Class->ListEntry);
- }
- else
- {
- /* local classes have priority so we put them first */
- InsertHeadList(&PsGetWin32Process()->ClassList, &Class->ListEntry);
- }
-
- return TRUE;
-}
-
-
-ULONG FASTCALL
-IntGetClassLong(PWINDOW_OBJECT Window, ULONG Offset, BOOL Ansi)
-{
- LONG Ret;
-
- if ((int)Offset >= 0)
- {
- DPRINT("GetClassLong(%x, %d)\n", Window->hSelf, Offset);
- if ((Offset + sizeof(LONG)) > Window->Class->cbClsExtra)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return 0;
- }
- Ret = *((LONG *)(Window->Class->ExtraData + Offset));
- DPRINT("Result: %x\n", Ret);
- return Ret;
- }
-
- switch (Offset)
- {
- case GCL_CBWNDEXTRA:
- Ret = Window->Class->cbWndExtra;
- break;
- case GCL_CBCLSEXTRA:
- Ret = Window->Class->cbClsExtra;
- break;
- case GCL_HBRBACKGROUND:
- Ret = (ULONG)Window->Class->hbrBackground;
- break;
- case GCL_HCURSOR:
- Ret = (ULONG)Window->Class->hCursor;
- break;
- case GCL_HICON:
- Ret = (ULONG)Window->Class->hIcon;
- break;
- case GCL_HICONSM:
- Ret = (ULONG)Window->Class->hIconSm;
- break;
- case GCL_HMODULE:
- Ret = (ULONG)Window->Class->hInstance;
- break;
- case GCL_MENUNAME:
- Ret = (ULONG)Window->Class->lpszMenuName.Buffer;
- break;
- case GCL_STYLE:
- Ret = Window->Class->style;
- break;
- case GCL_WNDPROC:
- if (Ansi)
- {
- Ret = (ULONG)Window->Class->lpfnWndProcA;
- }
- else
- {
- Ret = (ULONG)Window->Class->lpfnWndProcW;
- }
- break;
- case GCW_ATOM:
- Ret = Window->Class->Atom;
- break;
- default:
- Ret = 0;
- break;
- }
- return(Ret);
-}
-
-static
-void FASTCALL
-co_IntSetClassLong(PWINDOW_OBJECT Window, ULONG Offset, LONG dwNewLong, BOOL Ansi)
-{
- ASSERT_REFS_CO(Window);
-
- if ((int)Offset >= 0)
- {
- DPRINT("SetClassLong(%x, %d, %x)\n", Window->hSelf, Offset,
dwNewLong);
- if ((Offset + sizeof(LONG)) > Window->Class->cbClsExtra)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- return;
- }
- *((LONG *)(Window->Class->ExtraData + Offset)) = dwNewLong;
- return;
- }
-
- switch (Offset)
- {
- case GCL_CBWNDEXTRA:
- Window->Class->cbWndExtra = dwNewLong;
- break;
- case GCL_CBCLSEXTRA:
- Window->Class->cbClsExtra = dwNewLong;
- break;
- case GCL_HBRBACKGROUND:
- Window->Class->hbrBackground = (HBRUSH)dwNewLong;
- break;
- case GCL_HCURSOR:
- Window->Class->hCursor = (HCURSOR)dwNewLong;
- break;
- case GCL_HICON:
- Window->Class->hIcon = (HICON)dwNewLong;
-
- if (!IntGetOwner(Window) && !IntGetParent(Window))
- {
- co_IntShellHookNotify(HSHELL_REDRAW, (LPARAM) Window->hSelf);
- }
- break;
- case GCL_HICONSM:
- Window->Class->hIconSm = (HICON)dwNewLong;
- break;
- case GCL_HMODULE:
- Window->Class->hInstance = (HINSTANCE)dwNewLong;
- break;
- case GCL_MENUNAME:
- if (Window->Class->lpszMenuName.MaximumLength)
- RtlFreeUnicodeString(&Window->Class->lpszMenuName);
- if (!IS_INTRESOURCE(dwNewLong))
- {
- Window->Class->lpszMenuName.Length =
- Window->Class->lpszMenuName.MaximumLength =
((PUNICODE_STRING)dwNewLong)->MaximumLength;
- Window->Class->lpszMenuName.Buffer = ExAllocatePoolWithTag(PagedPool,
Window->Class->lpszMenuName.MaximumLength, TAG_STRING);
- RtlCopyUnicodeString(&Window->Class->lpszMenuName,
(PUNICODE_STRING)dwNewLong);
- }
- else
- {
- Window->Class->lpszMenuName.Length =
- Window->Class->lpszMenuName.MaximumLength = 0;
- Window->Class->lpszMenuName.Buffer = (LPWSTR)dwNewLong;
- }
- break;
- case GCL_STYLE:
- Window->Class->style = dwNewLong;
- break;
- case GCL_WNDPROC:
- if (Ansi)
- {
- Window->Class->lpfnWndProcA = (WNDPROC)dwNewLong;
- Window->Class->lpfnWndProcW = (WNDPROC)
IntAddWndProcHandle((WNDPROC)dwNewLong,FALSE);
- Window->Class->Unicode = FALSE;
- }
- else
- {
- Window->Class->lpfnWndProcW = (WNDPROC)dwNewLong;
- Window->Class->lpfnWndProcA = (WNDPROC)
IntAddWndProcHandle((WNDPROC)dwNewLong,TRUE);
- Window->Class->Unicode = TRUE;
- }
- break;
- }
-}
+ PWINDOWCLASS Class;
+ PW32PROCESSINFO pi = Process->ProcessInfo;
+
+ if (pi != NULL)
+ {
+ /* free all local classes */
+ Class = pi->LocalClassList;
+ while (Class != NULL)
+ {
+ pi->LocalClassList = Class->Next;
+
+ ASSERT(Class->Base == Class);
+ IntDestroyClass(Class);
+
+ Class = pi->LocalClassList;
+ }
+
+ /* free all global classes */
+ Class = pi->GlobalClassList;
+ while (Class != NULL)
+ {
+ pi->GlobalClassList = Class->Next;
+
+ ASSERT(Class->Base == Class);
+ IntDestroyClass(Class);
+
+ Class = pi->GlobalClassList;
+ }
+
+ /* free all system classes */
+ Class = pi->SystemClassList;
+ while (Class != NULL)
+ {
+ pi->SystemClassList = Class->Next;
+
+ ASSERT(Class->Base == Class);
+ IntDestroyClass(Class);
+
+ Class = pi->SystemClassList;
+ }
+ }
+}
+
+static BOOL
+IntRegisterClassAtom(IN PUNICODE_STRING ClassName,
+ OUT RTL_ATOM *pAtom)
+{
+ WCHAR szBuf[65];
+ PWSTR AtomName;
+ NTSTATUS Status;
+
+ if (ClassName->Length != 0)
+ {
+ /* 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);
+ return (RTL_ATOM)0;
+ }
+
+ RtlCopyMemory(szBuf,
+ ClassName->Buffer,
+ ClassName->Length);
+ szBuf[ClassName->Length / sizeof(WCHAR)] = UNICODE_NULL;
+ AtomName = szBuf;
+ }
+ else
+ AtomName = ClassName->Buffer;
+
+ Status = RtlAddAtomToAtomTable(gAtomTable,
+ AtomName,
+ pAtom);
+
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static VOID
+IntDeregisterClassAtom(IN RTL_ATOM Atom)
+{
+ RtlDeleteAtomFromAtomTable(gAtomTable,
+ Atom);
+}
+
+static BOOL
+IntSetClassAtom(IN OUT PWINDOWCLASS Class,
+ IN PUNICODE_STRING ClassName)
+{
+ RTL_ATOM Atom = (RTL_ATOM)0;
+
+ /* update the base class first */
+ Class = Class->Base;
+
+ if (!IntRegisterClassAtom(ClassName,
+ &Atom))
+ {
+ return FALSE;
+ }
+
+ IntDeregisterClassAtom(Class->Atom);
+
+ Class->Atom = Atom;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->Atom = Atom;
+
+ Class = Class->Next;
+ }
+
+ return TRUE;
+}
+
+static WNDPROC
+IntSetClassWndProc(IN OUT PWINDOWCLASS Class,
+ IN WNDPROC WndProc,
+ IN BOOL Ansi)
+{
+ WNDPROC Ret = Class->WndProc;
+
+ if (Class->System)
+ {
+ DPRINT1("Attempted to change window procedure of system window class
0x%p!\n", Class->Atom);
+ SetLastWin32Error(ERROR_ACCESS_DENIED);
+ return NULL;
+ }
+
+ /* update the base class first */
+ Class = Class->Base;
+
+ Class->Unicode = !Ansi;
+ Class->WndProc = WndProc;
+ if (Class->CallProc != NULL)
+ {
+ Class->CallProc->WndProc = WndProc;
+ Class->CallProc->Unicode = !Ansi;
+ }
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->Unicode = !Ansi;
+ Class->WndProc = WndProc;
+
+ Class = Class->Next;
+ }
+
+ return Ret;
+}
+
+static PWINDOWCLASS
+IntGetClassForDesktop(IN PWINDOWCLASS BaseClass,
+ IN PDESKTOP Desktop)
+{
+ SIZE_T ClassSize;
+ PWINDOWCLASS Class;
+
+ ASSERT(Desktop != NULL);
+ ASSERT(BaseClass->Base == BaseClass);
+
+ if (BaseClass->Desktop == Desktop)
+ {
+ /* it is most likely that a window is created on the same
+ desktop as the window class. */
+
+ return BaseClass;
+ }
+
+ if (BaseClass->Desktop == NULL)
+ {
+ /* Classes are also located in the shared heap when the class
+ was created before the thread attached to a desktop. As soon
+ as a window is created for such a class located on the shared
+ heap, the class is cloned into the desktop heap on which the
+ window is created. */
+ Class = NULL;
+ }
+ else
+ {
+ /* The user is asking for a class object on a different desktop,
+ try to find one! */
+ Class = BaseClass->Clone;
+ while (Class != NULL)
+ {
+ if (Class->Desktop == Desktop)
+ {
+ ASSERT(Class->Base == BaseClass);
+ ASSERT(Class->Clone == NULL);
+ break;
+ }
+
+ Class = Class->Next;
+ }
+ }
+
+ if (Class == NULL)
+ {
+ /* The window is created on a different desktop, we need to
+ clone the class object to the desktop heap of the window! */
+ ClassSize = (SIZE_T)BaseClass->ClassExtraDataOffset +
+ (SIZE_T)BaseClass->ClsExtra;
+
+ Class = DesktopHeapAlloc(Desktop,
+ ClassSize);
+ if (Class != NULL)
+ {
+ /* simply clone the class */
+ RtlCopyMemory(Class,
+ BaseClass,
+ ClassSize);
+
+ /* update some pointers and link the class */
+ Class->Next = BaseClass->Clone;
+ Class->Clone = NULL;
+ Class->Base = BaseClass;
+ Class->Desktop = Desktop;
+ Class->Windows = 0;
+ (void)InterlockedExchangePointer(&BaseClass->Clone,
+ Class);
+ }
+ else
+ {
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ }
+
+ return Class;
+}
+
+PWINDOWCLASS
+IntReferenceClass(IN PWINDOWCLASS BaseClass,
+ IN PDESKTOP Desktop)
+{
+ PWINDOWCLASS Class;
+
+ Class = IntGetClassForDesktop(BaseClass,
+ Desktop);
+ if (Class != NULL)
+ {
+ Class->Windows++;
+ }
+
+ return Class;
+}
+
+VOID
+IntDereferenceClass(IN OUT PWINDOWCLASS Class,
+ IN PDESKTOP Desktop,
+ IN PW32PROCESSINFO pi)
+{
+ PWINDOWCLASS *PrevLink, BaseClass, CurrentClass;
+
+ BaseClass = Class->Base;
+
+ if (--Class->Windows == 0)
+ {
+ if (BaseClass == Class)
+ {
+ ASSERT(Class->Base == 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... */
+ if (BaseClass->Clone != NULL)
+ {
+ PWINDOWCLASS NewBase = BaseClass->Clone;
+
+ /* locate the base class and unlink it */
+ if (BaseClass->System)
+ PrevLink = &pi->SystemClassList;
+ else if (BaseClass->Global)
+ PrevLink = &pi->GlobalClassList;
+ else
+ PrevLink = &pi->LocalClassList;
+
+ CurrentClass = *PrevLink;
+ while (CurrentClass != BaseClass)
+ {
+ ASSERT(CurrentClass != NULL);
+
+ PrevLink = &CurrentClass->Next;
+ CurrentClass = CurrentClass->Next;
+ }
+
+ ASSERT(CurrentClass == BaseClass);
+
+ NewBase->Clone = NewBase->Next;
+ NewBase->Next = BaseClass->Next;
+ NewBase->Base = NewBase;
+
+ /* update all clones */
+ CurrentClass = NewBase->Clone;
+ while (CurrentClass != NULL)
+ {
+ ASSERT(CurrentClass->Clone == NULL);
+
+ CurrentClass->Base = NewBase;
+
+ CurrentClass = CurrentClass->Next;
+ }
+
+ /* link in the new base class */
+ (void)InterlockedExchangePointer(PrevLink,
+ NewBase);
+
+ /* 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->Base = NULL;
+ BaseClass->Clone = NULL;
+ IntDestroyClass(BaseClass);
+ }
+ }
+ else
+ {
+ /* locate the cloned class and unlink it */
+ PrevLink = &BaseClass->Clone;
+ CurrentClass = BaseClass->Clone;
+ while (CurrentClass != Class)
+ {
+ ASSERT(CurrentClass != NULL);
+
+ PrevLink = &CurrentClass->Next;
+ CurrentClass = CurrentClass->Next;
+ }
+
+ ASSERT(CurrentClass == Class);
+
+ (void)InterlockedExchangePointer(PrevLink,
+ Class->Next);
+
+ ASSERT(Class->Base == BaseClass);
+ ASSERT(Class->Clone == NULL);
+
+ /* the class was just a clone, we don't need it anymore */
+ IntDestroyClass(Class);
+ }
+ }
+}
+
+static PWINDOWCLASS
+IntCreateClass(IN CONST WNDCLASSEXW* lpwcx,
+ IN PUNICODE_STRING ClassName,
+ IN PUNICODE_STRING MenuName,
+ IN WNDPROC wpExtra,
+ IN DWORD dwFlags,
+ IN PDESKTOP Desktop,
+ IN PW32PROCESSINFO pi)
+{
+ SIZE_T ClassSize;
+ PWINDOWCLASS Class = NULL;
+ RTL_ATOM Atom;
+ NTSTATUS Status = STATUS_SUCCESS;
+
+ if (!IntRegisterClassAtom(ClassName,
+ &Atom))
+ {
+ DPRINT1("Failed to register class atom!\n");
+ return NULL;
+ }
+
+ ClassSize = sizeof(WINDOWCLASS) + lpwcx->cbClsExtra;
+ ClassSize += ClassName->Length + sizeof(UNICODE_NULL);
+ ClassSize += MenuName->Length + sizeof(UNICODE_NULL);
+ if (ClassName->Length != 0)
+ ClassSize += RtlUnicodeStringToAnsiSize(ClassName);
+ if (MenuName->Length != 0)
+ ClassSize += RtlUnicodeStringToAnsiSize(MenuName);
+
+ if (Desktop != NULL)
+ {
+ Class = DesktopHeapAlloc(Desktop,
+ ClassSize);
+ }
+ else
+ {
+ /* FIXME - the class was created before being connected
+ to a desktop. It is possible for the desktop window,
+ but should it be allowed for any other case? */
+ Class = UserHeapAlloc(ClassSize);
+ }
+
+ if (Class != NULL)
+ {
+ RtlZeroMemory(Class,
+ sizeof(ClassSize));
+
+ Class->Desktop = Desktop;
+ Class->Base = Class;
+ Class->Atom = Atom;
+
+ if (dwFlags & REGISTERCLASS_SYSTEM)
+ {
+ dwFlags &= ~REGISTERCLASS_ANSI;
+ Class->WndProcExtra = wpExtra;
+ Class->System = TRUE;
+ }
+
+ _SEH_TRY
+ {
+ PWSTR strBuf;
+ PSTR strBufA;
+ ANSI_STRING AnsiString;
+
+ /* need to protect with SEH since accessing the WNDCLASSEX structure
+ and string buffers might raise an exception! We don't want to
+ leak memory... */
+ Class->WndProc = lpwcx->lpfnWndProc;
+ Class->Style = lpwcx->style;
+ Class->ClsExtra = lpwcx->cbClsExtra;
+ Class->WndExtra = lpwcx->cbWndExtra;
+ Class->hInstance = lpwcx->hInstance;
+ Class->hIcon = lpwcx->hIcon; /* FIXME */
+ Class->hIconSm = lpwcx->hIconSm; /* FIXME */
+ Class->hCursor = lpwcx->hCursor; /* FIXME */
+ Class->hbrBackground = lpwcx->hbrBackground;
+
+ /* make a copy of the string */
+ strBuf = (PWSTR)(Class + 1);
+ if (MenuName->Length != 0)
+ {
+ Class->MenuName = strBuf;
+ RtlCopyMemory(Class->MenuName,
+ MenuName->Buffer,
+ MenuName->Length);
+
+ strBuf += (MenuName->Length / sizeof(WCHAR)) + 1;
+ }
+ else
+ Class->MenuName = MenuName->Buffer;
+
+ /* save an ansi copy of the string */
+ strBufA = (PSTR)strBuf;
+ if (MenuName->Length != 0)
+ {
+ Class->AnsiMenuName = strBufA;
+ AnsiString.MaximumLength = RtlUnicodeStringToAnsiSize(MenuName);
+ AnsiString.Buffer = strBufA;
+ Status = RtlUnicodeStringToAnsiString(&AnsiString,
+ MenuName,
+ FALSE);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed to convert unicode menu name to ansi!\n");
+
+ /* life would've been much prettier if ntoskrnl exported
RtlRaiseStatus()... */
+ _SEH_LEAVE;
+ }
+
+ strBufA += AnsiString.Length + 1;
+ }
+ else
+ Class->AnsiMenuName = (PSTR)MenuName->Buffer;
+
+ /* calculate the offset of the extra data */
+ Class->ClassExtraDataOffset = (ULONG_PTR)strBufA - (ULONG_PTR)Class;
+
+ if (!(dwFlags & REGISTERCLASS_ANSI))
+ Class->Unicode = TRUE;
+
+ if (Class->Style & CS_GLOBALCLASS)
+ Class->Global = TRUE;
+ }
+ _SEH_HANDLE
+ {
+ Status = _SEH_GetExceptionCode();
+ }
+ _SEH_END;
+
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed creating the class: 0x%x\n", Status);
+
+ SetLastNtError(Status);
+
+ DesktopHeapFree(Desktop,
+ Class);
+ Class = NULL;
+
+ IntDeregisterClassAtom(Atom);
+ }
+ }
+ else
+ {
+ DPRINT1("Failed to allocate class on Desktop 0x%p\n", Desktop);
+
+ IntDeregisterClassAtom(Atom);
+
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ }
+
+ return Class;
+}
+
+static PWINDOWCLASS
+IntFindClass(IN RTL_ATOM Atom,
+ IN HINSTANCE hInstance,
+ IN PWINDOWCLASS *ClassList,
+ OUT PWINDOWCLASS **Link OPTIONAL)
+{
+ PWINDOWCLASS Class, *PrevLink = ClassList;
+
+ Class = *PrevLink;
+ while (Class != NULL)
+ {
+ if (Class->Atom == Atom &&
+ (hInstance == NULL || Class->hInstance == hInstance) &&
+ !Class->Destroying)
+ {
+ ASSERT(Class->Base == Class);
+
+ if (Link != NULL)
+ *Link = PrevLink;
+ break;
+ }
+
+ PrevLink = &Class->Next;
+ Class = Class->Next;
+ }
+
+ return Class;
+}
+
+static WNDPROC
+IntGetClassWndProc(IN PWINDOWCLASS Class,
+ IN PW32PROCESSINFO pi,
+ IN BOOL Ansi)
+{
+ if (Class->System)
+ {
+ return (Ansi ? Class->WndProcExtra : Class->WndProc);
+ }
+ else
+ {
+ if (!Ansi == Class->Unicode)
+ {
+ return Class->WndProc;
+ }
+ else
+ {
+ if (Class->CallProc != NULL)
+ {
+ return (WNDPROC)ObmObjectToHandle(Class->CallProc);
+ }
+ else
+ {
+ PCALLPROC NewCallProc, CallProc;
+
+ if (pi == NULL)
+ return NULL;
+
+ /* NOTE: use the interlocked functions, as this operation may be done
even
+ when only the shared lock is held! */
+ NewCallProc = CreateCallProc(Class->Desktop,
+ Class->WndProc,
+ Class->Unicode,
+ pi);
+ if (NewCallProc == NULL)
+ {
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ return NULL;
+ }
+
+ CallProc = InterlockedCompareExchangePointer(&Class->CallProc,
+ NewCallProc,
+ NULL);
+ if (CallProc != NULL)
+ {
+ DestroyCallProc(Class->Desktop,
+ NewCallProc);
+ }
+
+ return (WNDPROC)ObmObjectToHandle((CallProc == NULL ? NewCallProc :
CallProc));
+ }
+ }
+ }
+}
+
+RTL_ATOM
+IntGetClassAtom(IN PUNICODE_STRING ClassName,
+ IN HINSTANCE hInstance OPTIONAL,
+ IN PW32PROCESSINFO pi OPTIONAL,
+ OUT PWINDOWCLASS *BaseClass OPTIONAL,
+ OUT PWINDOWCLASS **Link OPTIONAL)
+{
+ RTL_ATOM Atom = (RTL_ATOM)0;
+
+ if (ClassName->Length != 0)
+ {
+ WCHAR szBuf[65];
+ PWSTR AtomName;
+ NTSTATUS Status;
+
+ /* NOTE: Caller has to protect the call with SEH! */
+
+ if (ClassName->Length != 0)
+ {
+ /* 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);
+ return (RTL_ATOM)0;
+ }
+
+ /* We need to make a local copy of the class name! The caller could
+ modify the buffer and we could overflow in RtlLookupAtomInAtomTable.
+ We're protected by SEH, but the ranges that might be accessed were
+ not probed... */
+ RtlCopyMemory(szBuf,
+ ClassName->Buffer,
+ ClassName->Length);
+ szBuf[ClassName->Length / sizeof(WCHAR)] = UNICODE_NULL;
+ AtomName = szBuf;
+ }
+ else
+ AtomName = ClassName->Buffer;
+
+ /* lookup the atom */
+ Status = RtlLookupAtomInAtomTable(gAtomTable,
+ AtomName,
+ &Atom);
+ if (!NT_SUCCESS(Status))
+ {
+ if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
+ {
+ SetLastWin32Error(ERROR_CANNOT_FIND_WND_CLASS);
+ }
+ else
+ {
+ SetLastNtError(Status);
+ }
+ }
+ }
+ else
+ {
+ ASSERT(IS_ATOM(ClassName->Buffer));
+ Atom = (RTL_ATOM)((ULONG_PTR)ClassName->Buffer);
+ }
+
+ if (BaseClass != NULL && Atom != (RTL_ATOM)0)
+ {
+ PWINDOWCLASS Class;
+
+ /* attempt to locate the class object */
+
+ ASSERT(pi != NULL);
+
+ /* Step 1: try to find an exact match of locally registered classes */
+ Class = IntFindClass(Atom,
+ hInstance,
+ &pi->LocalClassList,
+ Link);
+ if (Class != NULL)
+ {
+ goto FoundClass;
+ }
+
+ /* Step 2: try to find any globally registered class. The hInstance
+ is not relevant for global classes */
+ Class = IntFindClass(Atom,
+ NULL,
+ &pi->GlobalClassList,
+ Link);
+ if (Class != NULL)
+ {
+ goto FoundClass;
+ }
+
+ /* Step 3: try to find a system class */
+ Class = IntFindClass(Atom,
+ NULL,
+ &pi->SystemClassList,
+ Link);
+
+ if (Class == NULL)
+ {
+ SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
+ return (RTL_ATOM)0;
+ }
+
+FoundClass:
+ *BaseClass = Class;
+ }
+
+ return Atom;
+}
+
+static PWINDOWCLASS
+IntClassResizeInternal(IN OUT PWINDOWCLASS Class,
+ IN INT ClsExtraNew,
+ IN PWINDOWCLASS *List)
+{
+ PWINDOWCLASS *PrevLink, CurrentClass, NewClass;
+ SIZE_T NewSize;
+
+ /* temporarily unlink the class, as resizing it may change it's location */
+ PrevLink = List;
+ CurrentClass = *PrevLink;
+ while (CurrentClass != Class)
+ {
+ ASSERT(CurrentClass != NULL);
+
+ PrevLink = &CurrentClass->Next;
+ CurrentClass = CurrentClass->Next;
+ }
+
+ ASSERT(CurrentClass == Class);
+
+ (void)InterlockedExchangePointer(PrevLink,
+ Class->Next);
+
+ NewSize = (SIZE_T)ClsExtraNew + Class->ClassExtraDataOffset;
+ if (Class->Desktop != NULL)
+ {
+ NewClass = DesktopHeapReAlloc(Class->Desktop,
+ Class,
+ NewSize);
+ }
+ else
+ {
+ NewClass = UserHeapReAlloc(Class,
+ NewSize);
+ }
+
+ if (NewClass == NULL)
+ {
+ /* link in the class again */
+ (void)InterlockedExchangePointer(PrevLink,
+ Class);
+
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ return NULL;
+ }
+
+ if (Class != NewClass)
+ {
+ /* adjust the menu name pointers, if neccessary */
+ if (NewClass->MenuName != NULL &&
!IS_INTRESOURCE(NewClass->MenuName) &&
+ NewClass->MenuName == (PWSTR)(NewClass + 1))
+ {
+ ULONG_PTR PtrDelta = (ULONG_PTR)NewClass - (ULONG_PTR)Class;
+
+ NewClass->MenuName = (PWSTR)((ULONG_PTR)NewClass->MenuName +
PtrDelta);
+ NewClass->AnsiMenuName = (PSTR)((ULONG_PTR)NewClass->MenuName +
PtrDelta);
+ }
+
+ Class = NewClass;
+ }
+
+ if (Class->ClsExtra < ClsExtraNew)
+ {
+ /* zero the memory allocated */
+ RtlZeroMemory((PVOID)((ULONG_PTR)Class + Class->ClassExtraDataOffset +
Class->ClsExtra),
+ ClsExtraNew - Class->ClsExtra);
+ }
+
+ /* link in the class again */
+ (void)InterlockedExchangePointer(PrevLink,
+ Class);
+
+ return Class;
+}
+
+static BOOL
+IntClassResize(IN OUT PWINDOWCLASS Class,
+ IN PW32PROCESSINFO pi,
+ IN INT ClsExtraNew)
+{
+ PWINDOWCLASS *List, *CloneList, NewClass, Clone, FailedResize = NULL;
+ BOOL FailOnResize;
+
+ if (pi == NULL)
+ return FALSE;
+
+ /* first modify the base class, then the clones */
+ Class = Class->Base;
+
+ if (ClsExtraNew < 0 ||
+ (ULONG_PTR)ClsExtraNew + Class->ClassExtraDataOffset <
Class->ClassExtraDataOffset)
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ return FALSE;
+ }
+
+ if (Class->System)
+ List = &pi->SystemClassList;
+ else if (Class->Global)
+ List = &pi->GlobalClassList;
+ else
+ List = &pi->LocalClassList;
+
+ FailOnResize = Class->ClsExtra < ClsExtraNew;
+
+ /* resize the base class */
+ NewClass = IntClassResizeInternal(Class,
+ ClsExtraNew,
+ List);
+ if (NewClass == NULL)
+ {
+ if (FailOnResize)
+ {
+ DPRINT1("Failed to resize the base class\n");
+ return FALSE;
+ }
+ }
+ else
+ Class = NewClass;
+
+ /* resize the clones */
+ CloneList = &Class->Clone;
+ Clone = Class->Clone;
+ while (Clone != NULL)
+ {
+ NewClass = IntClassResizeInternal(Clone,
+ ClsExtraNew,
+ CloneList);
+
+ if (NewClass == NULL)
+ {
+ if (FailOnResize)
+ {
+ /* roll back all changes */
+ FailedResize = Clone;
+ break;
+ }
+ }
+ else
+ Clone = NewClass;
+
+ /* save the pointer to the base class in case it changed */
+ Clone->Base = Class;
+
+ Clone = Clone->Next;
+ }
+
+ if (FailedResize != NULL)
+ {
+ /* failed to resize one clone, roll back the changes to all
+ other clones and to the base class */
+ DPRINT1("Failed to resize the cloned class 0x%p\n", FailedResize);
+
+ /* roll back the changes made to the base class */
+ NewClass = IntClassResizeInternal(Class,
+ Class->ClsExtra,
+ List);
+ if (NewClass != NULL)
+ Class = NewClass;
+
+ /* roll back all changes made to the class clones */
+ CloneList = &Class->Clone;
+ Clone = Class->Clone;
+ while (Clone != FailedResize)
+ {
+ ASSERT(Clone != NULL);
+
+ NewClass = IntClassResizeInternal(Clone,
+ Class->ClsExtra,
+ CloneList);
+ if (NewClass != NULL)
+ Clone = NewClass;
+
+ /* save the pointer to the base class in case it changed */
+ Clone->Base = Class;
+
+ CloneList = &Clone->Next;
+ Clone = Clone->Next;
+ }
+
+ return FALSE;
+ }
+ else
+ {
+ /* all classes were successfully resized,
+ save the new extra data size */
+ Class->ClsExtra = ClsExtraNew;
+ Clone = Class->Clone;
+ while (Clone != NULL)
+ {
+ Clone->ClsExtra = ClsExtraNew;
+ Clone = Clone->Next;
+ }
+
+ return TRUE;
+ }
+}
+
+RTL_ATOM
+UserRegisterClass(IN CONST WNDCLASSEXW* lpwcx,
+ IN PUNICODE_STRING ClassName,
+ IN PUNICODE_STRING MenuName,
+ IN HANDLE hMenu, /* FIXME */
+ IN WNDPROC wpExtra,
+ IN DWORD dwFlags)
+{
+ PW32THREADINFO ti;
+ PW32PROCESSINFO pi;
+ PWINDOWCLASS Class;
+ RTL_ATOM ClassAtom;
+ RTL_ATOM Ret = (RTL_ATOM)0;
+
+ /* NOTE: Accessing the buffers in ClassName and MenuName may raise exceptions! */
+
+ ti = GetW32ThreadInfo();
+ if (ti == NULL)
+ {
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ return (RTL_ATOM)0;
+ }
+
+ pi = ti->kpi;
+
+ /* try to find a previously registered class */
+ ClassAtom = IntGetClassAtom(ClassName,
+ NULL,
+ NULL,
+ NULL,
+ NULL);
+ if (ClassAtom != (RTL_ATOM)0)
+ {
+ Class = IntFindClass(ClassAtom,
+ lpwcx->hInstance,
+ &pi->LocalClassList,
+ NULL);
+ if (Class != NULL)
+ {
+ goto ClassAlreadyExists;
+ }
+
+ /* if CS_GLOBALCLASS is set, try to find a previously registered global class.
+ Re-registering system classes as global classes seems to be allowed,
+ so we don't fail */
+ if (lpwcx->style & CS_GLOBALCLASS)
+ {
+ Class = IntFindClass(ClassAtom,
+ NULL,
+ ((dwFlags & REGISTERCLASS_SYSTEM) ?
+ &pi->SystemClassList :
&pi->GlobalClassList),
+ NULL);
+ if (Class != NULL)
+ {
+ClassAlreadyExists:
+ DPRINT1("Class 0x%p does already exist!\n", ClassAtom);
+ SetLastWin32Error(ERROR_CLASS_ALREADY_EXISTS);
+ return (RTL_ATOM)0;
+ }
+ }
+ }
+
+ ASSERT(ti->Desktop != NULL);
+
+ Class = IntCreateClass(lpwcx,
+ ClassName,
+ MenuName,
+ wpExtra,
+ dwFlags,
+ ti->Desktop,
+ pi);
+
+ if (Class != NULL)
+ {
+ PWINDOWCLASS *List;
+
+ /* FIXME - pass the PMENU pointer to IntCreateClass instead! */
+ Class->hMenu = hMenu;
+
+ /* Register the class */
+ if (Class->System)
+ List = &pi->SystemClassList;
+ else if (Class->Global)
+ List = &pi->GlobalClassList;
+ else
+ List = &pi->LocalClassList;
+
+ Class->Next = *List;
+ (void)InterlockedExchangePointer(List,
+ Class);
+
+ Ret = Class->Atom;
+ }
+
+ return Ret;
+}
+
+BOOL
+UserUnregisterClass(IN PUNICODE_STRING ClassName,
+ IN HINSTANCE hInstance)
+{
+ PWINDOWCLASS *Link;
+ PW32PROCESSINFO pi;
+ RTL_ATOM ClassAtom;
+ PWINDOWCLASS Class;
+
+ pi = GetW32ProcessInfo();
+ if (pi == NULL)
+ {
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ return FALSE;
+ }
+
+ /* NOTE: Accessing the buffer in ClassName may raise an exception! */
+ ClassAtom = IntGetClassAtom(ClassName,
+ hInstance,
+ pi,
+ &Class,
+ &Link);
+ if (ClassAtom == (RTL_ATOM)0)
+ {
+ return FALSE;
+ }
+
+ ASSERT(Class != NULL);
+
+ if (Class->System)
+ {
+ DPRINT1("Attempted to unregister system class 0x%p!\n", ClassAtom);
+ SetLastWin32Error(ERROR_ACCESS_DENIED);
+ return FALSE;
+ }
+
+ if (Class->Windows != 0 ||
+ Class->Clone != NULL)
+ {
+ SetLastWin32Error(ERROR_CLASS_HAS_WINDOWS);
+ return FALSE;
+ }
+
+ /* must be a base class! */
+ ASSERT(Class->Base == Class);
+
+ /* unlink the class */
+ *Link = Class->Next;
+
+ /* finally free the resources */
+ IntDestroyClass(Class);
+ return TRUE;
+}
+
+INT
+UserGetClassName(IN PWINDOWCLASS Class,
+ IN OUT PUNICODE_STRING ClassName,
+ IN BOOL Ansi)
+{
+ 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! */
+
+ _SEH_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->Atom,
+ 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 = ExAllocatePool(PagedPool,
+ BufLen);
+ if (szTemp == NULL)
+ {
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ _SEH_LEAVE;
+ }
+
+ /* query the class name */
+ Status = RtlQueryAtomInAtomTable(gAtomTable,
+ Class->Atom,
+ 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);
+ _SEH_LEAVE;
+ }
+ }
+
+ Ret = BufLen / sizeof(WCHAR);
+ }
+ else /* !Ansi */
+ {
+ BufLen = ClassName->MaximumLength;
+
+ /* query the atom name */
+ Status = RtlQueryAtomInAtomTable(gAtomTable,
+ Class->Atom,
+ NULL,
+ NULL,
+ ClassName->Buffer,
+ &BufLen);
+
+ if (NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ _SEH_LEAVE;
+ }
+
+ Ret = BufLen / sizeof(WCHAR);
+ }
+ }
+ _SEH_HANDLE
+ {
+ SetLastNtError(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+
+ if (Ansi && szTemp != NULL && szTemp != szStaticTemp)
+ {
+ ExFreePool(szTemp);
+ }
+
+ return Ret;
+}
+
+ULONG_PTR
+UserGetClassLongPtr(IN PWINDOWCLASS Class,
+ IN INT Index,
+ IN BOOL Ansi)
+{
+ ULONG_PTR Ret = 0;
+
+ if (Index > 0)
+ {
+ PULONG_PTR Data;
+
+ if (Index + sizeof(ULONG_PTR) < Index ||
+ Index + sizeof(ULONG_PTR) > Class->ClsExtra)
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+
+ Data = (PULONG_PTR)((ULONG_PTR)Class + Class->ClassExtraDataOffset);
+
+ /* FIXME - Data might be a unaligned pointer! Might be a problem on
+ certain architectures, maybe using RtlCopyMemory is a
+ better choice for those architectures! */
+ return *Data;
+ }
+
+ switch (Index)
+ {
+ case GCL_CBWNDEXTRA:
+ Ret = (ULONG_PTR)Class->WndExtra;
+ break;
+
+ case GCL_CBCLSEXTRA:
+ Ret = (ULONG_PTR)Class->ClsExtra;
+ 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->hInstance;
+ break;
+
+ case GCLP_MENUNAME:
+ /* NOTE: Returns pointer in kernel heap! */
+ if (Ansi)
+ Ret = (ULONG_PTR)Class->AnsiMenuName;
+ else
+ Ret = (ULONG_PTR)Class->MenuName;
+ break;
+
+ case GCL_STYLE:
+ Ret = (ULONG_PTR)Class->Style;
+ break;
+
+ case GCLP_WNDPROC:
+ Ret = (ULONG_PTR)IntGetClassWndProc(Class,
+ GetW32ProcessInfo(),
+ Ansi);
+ break;
+
+ case GCW_ATOM:
+ Ret = (ULONG_PTR)Class->Atom;
+ break;
+
+ default:
+ SetLastWin32Error(ERROR_INVALID_INDEX);
+ break;
+ }
+
+ return Ret;
+}
+
+static BOOL
+IntSetClassMenuName(IN PWINDOWCLASS Class,
+ IN PUNICODE_STRING MenuName)
+{
+ BOOL Ret = FALSE;
+
+ /* change the base class first */
+ Class = Class->Base;
+
+ if (MenuName->Length != 0)
+ {
+ ANSI_STRING AnsiString;
+ PWSTR strBufW;
+
+ AnsiString.MaximumLength = RtlUnicodeStringToAnsiSize(MenuName);
+
+ strBufW = UserHeapAlloc(MenuName->Length + sizeof(UNICODE_NULL) +
+ AnsiString.MaximumLength);
+ if (strBufW != NULL)
+ {
+ _SEH_TRY
+ {
+ NTSTATUS Status;
+
+ /* copy the unicode string */
+ RtlCopyMemory(strBufW,
+ MenuName->Buffer,
+ MenuName->Length);
+ strBufW[MenuName->Length / sizeof(WCHAR)] = UNICODE_NULL;
+
+ /* create an ansi copy of the string */
+ AnsiString.Buffer = (PSTR)(strBufW + (MenuName->Length /
sizeof(WCHAR)) + 1);
+ Status = RtlUnicodeStringToAnsiString(&AnsiString,
+ MenuName,
+ FALSE);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ _SEH_LEAVE;
+ }
+
+ Ret = TRUE;
+ }
+ _SEH_HANDLE
+ {
+ SetLastNtError(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+
+ if (Ret)
+ {
+ /* update the base class */
+ IntFreeClassMenuName(Class);
+ Class->MenuName = strBufW;
+ Class->AnsiMenuName = AnsiString.Buffer;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->MenuName = strBufW;
+ Class->AnsiMenuName = AnsiString.Buffer;
+
+ Class = Class->Next;
+ }
+ }
+ else
+ {
+ DPRINT1("Failed to copy class menu name!\n");
+ UserHeapFree(strBufW);
+ }
+ }
+ else
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ else
+ {
+ ASSERT(IS_INTRESOURCE(MenuName->Buffer));
+
+ /* update the base class */
+ IntFreeClassMenuName(Class);
+ Class->MenuName = MenuName->Buffer;
+ Class->AnsiMenuName = (PSTR)MenuName->Buffer;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->MenuName = MenuName->Buffer;
+ Class->AnsiMenuName = (PSTR)MenuName->Buffer;
+
+ Class = Class->Next;
+ }
+
+ Ret = TRUE;
+ }
+
+ return Ret;
+}
+
+ULONG_PTR
+UserSetClassLongPtr(IN PWINDOWCLASS Class,
+ IN INT Index,
+ IN ULONG_PTR NewLong,
+ IN BOOL Ansi)
+{
+ ULONG_PTR Ret = 0;
+
+ /* NOTE: For GCLP_MENUNAME and GCW_ATOM this function may raise an exception! */
+
+ /* change the information in the base class first, then update the clones */
+ Class = Class->Base;
+
+ if (Index > 0)
+ {
+ PULONG_PTR Data;
+
+ if (Index + sizeof(ULONG_PTR) < Index ||
+ Index + sizeof(ULONG_PTR) > Class->ClsExtra)
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ return 0;
+ }
+
+ Data = (PULONG_PTR)((ULONG_PTR)Class + Class->ClassExtraDataOffset);
+
+ /* FIXME - Data might be a unaligned pointer! Might be a problem on
+ certain architectures, maybe using RtlCopyMemory is a
+ better choice for those architectures! */
+ Ret = *Data;
+ *Data = NewLong;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ *(PULONG_PTR)((ULONG_PTR)Class + Class->ClassExtraDataOffset) = NewLong;
+ Class = Class->Next;
+ }
+
+ return Ret;
+ }
+
+ switch (Index)
+ {
+ case GCL_CBWNDEXTRA:
+ Ret = (ULONG_PTR)Class->WndExtra;
+ Class->WndExtra = (INT)NewLong;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->WndExtra = (INT)NewLong;
+ Class = Class->Next;
+ }
+
+ break;
+
+ case GCL_CBCLSEXTRA:
+ Ret = (ULONG_PTR)Class->ClsExtra;
+ if (Class->ClsExtra != (INT)NewLong)
+ {
+ if (!IntClassResize(Class,
+ GetW32ProcessInfo(),
+ (INT)NewLong))
+ {
+ Ret = 0;
+ }
+ }
+ break;
+
+ case GCLP_HBRBACKGROUND:
+ Ret = (ULONG_PTR)Class->hbrBackground;
+ Class->hbrBackground = (HBRUSH)NewLong;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->hbrBackground = (HBRUSH)NewLong;
+ Class = Class->Next;
+ }
+ break;
+
+ case GCLP_HCURSOR:
+ /* FIXME - get handle from pointer to CURSOR object */
+ Ret = (ULONG_PTR)Class->hCursor;
+ Class->hCursor = (HANDLE)NewLong;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->hCursor = (HANDLE)NewLong;
+ Class = Class->Next;
+ }
+ break;
+
+ case GCLP_HICON:
+ /* FIXME - get handle from pointer to ICON object */
+ Ret = (ULONG_PTR)Class->hIcon;
+ Class->hIcon = (HANDLE)NewLong;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->hIcon = (HANDLE)NewLong;
+ Class = Class->Next;
+ }
+ break;
+
+ case GCLP_HICONSM:
+ /* FIXME - get handle from pointer to ICON object */
+ Ret = (ULONG_PTR)Class->hIconSm;
+ Class->hIconSm = (HANDLE)NewLong;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->hIconSm = (HANDLE)NewLong;
+ Class = Class->Next;
+ }
+ break;
+
+ case GCLP_HMODULE:
+ Ret = (ULONG_PTR)Class->hInstance;
+ Class->hInstance = (HINSTANCE)NewLong;
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->hInstance = (HINSTANCE)NewLong;
+ Class = Class->Next;
+ }
+ break;
+
+ case GCLP_MENUNAME:
+ {
+ PUNICODE_STRING Value = (PUNICODE_STRING)NewLong;
+
+ if (!IntSetClassMenuName(Class,
+ Value))
+ {
+ DPRINT("Setting the class menu name failed!\n");
+ }
+
+ /* FIXME - really return NULL? Wine does so... */
+ break;
+ }
+
+ case GCL_STYLE:
+ Ret = (ULONG_PTR)Class->Style;
+ Class->Style = (UINT)NewLong;
+
+ /* FIXME - what if the CS_GLOBALCLASS style is changed? should we
+ move the class to the appropriate list? For now, we save
+ the original value in Class->Global, so we can always
+ locate the appropriate list */
+
+ /* update the clones */
+ Class = Class->Clone;
+ while (Class != NULL)
+ {
+ Class->Style = (UINT)NewLong;
+ Class = Class->Next;
+ }
+ break;
+
+ case GCLP_WNDPROC:
+ Ret = (ULONG_PTR)IntSetClassWndProc(Class,
+ (WNDPROC)NewLong,
+ Ansi);
+ break;
+
+ case GCW_ATOM:
+ {
+ PUNICODE_STRING Value = (PUNICODE_STRING)NewLong;
+
+ Ret = (ULONG_PTR)Class->Atom;
+ if (!IntSetClassAtom(Class,
+ Value))
+ {
+ Ret = 0;
+ }
+ break;
+ }
+
+ default:
+ SetLastWin32Error(ERROR_INVALID_INDEX);
+ break;
+ }
+
+ return Ret;
+}
+
+static BOOL
+UserGetClassInfo(IN PWINDOWCLASS Class,
+ OUT PWNDCLASSEXW lpwcx,
+ IN BOOL Ansi)
+{
+ lpwcx->style = Class->Style;
+
+ if (Class->System)
+ {
+ lpwcx->lpfnWndProc = (!Ansi ? Class->WndProc : Class->WndProcExtra);
+ }
+ else
+ {
+ if (!Ansi == Class->Unicode)
+ {
+ lpwcx->lpfnWndProc = Class->WndProc;
+ }
+ else
+ {
+ /* FIXME - return callproc handle or function pointer? */
+ lpwcx->lpfnWndProc = Class->CallProc->WndProc;
+ }
+ }
+
+ lpwcx->cbClsExtra = Class->ClsExtra;
+ lpwcx->cbWndExtra = Class->WndExtra;
+ lpwcx->hInstance = Class->hInstance;
+ lpwcx->hIcon = Class->hIcon; /* FIXME - get handle from pointer */
+ lpwcx->hCursor = Class->hCursor; /* FIXME - get handle from pointer */
+ lpwcx->hbrBackground = Class->hbrBackground;
+
+ if (Ansi)
+ ((PWNDCLASSEXA)lpwcx)->lpszMenuName = Class->AnsiMenuName;
+ else
+ lpwcx->lpszMenuName = Class->MenuName;
+
+ lpwcx->lpszClassName = (LPCWSTR)((ULONG_PTR)Class->Atom); /* FIXME - return the
string? */
+
+ lpwcx->hIconSm = Class->hIconSm; /* FIXME - get handle from pointer */
+
+ return TRUE;
+}
+
/* SYSCALLS *****************************************************************/
-RTL_ATOM STDCALL
-NtUserRegisterClassExWOW(
- CONST WNDCLASSEXW* lpwcx,
- PUNICODE_STRING ClassName,
- PUNICODE_STRING ClassNameCopy,//huhuhuhu???
- PUNICODE_STRING MenuName,
- WNDPROC wpExtra,
- DWORD Flags,
- DWORD Unknown7,
- HMENU hMenu)
+RTL_ATOM NTAPI
+NtUserRegisterClassEx(IN CONST WNDCLASSEXW* lpwcx,
+ IN PUNICODE_STRING ClassName,
+ IN PUNICODE_STRING MenuName,
+ IN WNDPROC wpExtra,
+ IN DWORD Flags,
+ IN HMENU hMenu)
/*
* FUNCTION:
@@ -452,149 +1819,204 @@
* Atom identifying the new class
*/
{
- WNDCLASSEXW SafeClass;
- NTSTATUS Status;
- RTL_ATOM Atom;
- DECLARE_RETURN(RTL_ATOM);
-
- DPRINT("Enter NtUserRegisterClassExWOW\n");
- UserEnterExclusive();
-
- if (!lpwcx)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN( (RTL_ATOM)0);
- }
-
- if (Flags & ~REGISTERCLASS_ALL)
- {
- SetLastWin32Error(ERROR_INVALID_FLAGS);
- RETURN( (RTL_ATOM)0);
- }
-
- Status = MmCopyFromCaller(&SafeClass, lpwcx, sizeof(WNDCLASSEXW));
- if (!NT_SUCCESS(Status))
- {
- SetLastNtError(Status);
- RETURN( (RTL_ATOM)0);
- }
-
- /* Deny negative sizes */
- if (lpwcx->cbClsExtra < 0 || lpwcx->cbWndExtra < 0)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN( (RTL_ATOM)0);
- }
-
- if (!lpwcx->hInstance)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN( (RTL_ATOM)0);
- }
-
- //FIXME: make ClassName ptr the atom, not buffer
- if (ClassName->Length > 0)
- {
- DPRINT("NtUserRegisterClassExWOW(%S)\n", ClassName->Buffer);
- /* FIXME - Safely copy/verify the buffer first!!! */
- Status = RtlAddAtomToAtomTable(gAtomTable,
- ClassName->Buffer,
- &Atom);
- if (!NT_SUCCESS(Status))
- {
- DPRINT1("Failed adding class name (%S) to atom table\n",
- ClassName->Buffer);
- SetLastNtError(Status);
- RETURN((RTL_ATOM)0);
- }
- }
- else
- {
- Atom = (RTL_ATOM)(ULONG)ClassName->Buffer;
- }
-
- if (!Atom)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN(0);
- }
-
- if (!IntRegisterClass(&SafeClass, Flags, wpExtra, MenuName, Atom, hMenu))
- {
- if (ClassName->Length)
- {
- RtlDeleteAtomFromAtomTable(gAtomTable, Atom);
- }
- DPRINT("Failed creating window class object\n");
- RETURN((RTL_ATOM)0);
- }
-
- RETURN(Atom);
-
-CLEANUP:
- DPRINT("Leave NtUserRegisterClassExWOW, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
-}
-
-
-
-DWORD STDCALL
-NtUserGetClassLong(HWND hWnd, DWORD Offset, BOOL Ansi)
-{
- PWINDOW_OBJECT Window;
- DECLARE_RETURN(DWORD);
-
- DPRINT("Enter NtUserGetClassLong\n");
- UserEnterExclusive();
-
- if (!(Window = UserGetWindowObject(hWnd)))
- {
- RETURN(0);
- }
-
- RETURN(IntGetClassLong(Window, Offset, Ansi));
-
-CLEANUP:
- DPRINT("Leave NtUserGetClassLong, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
-}
-
-
-
-DWORD STDCALL
+ WNDCLASSEXW CapturedClassInfo = {0};
+ UNICODE_STRING CapturedName = {0}, CapturedMenuName = {0};
+ RTL_ATOM Ret = (RTL_ATOM)0;
+
+ if (Flags & ~REGISTERCLASS_ALL)
+ {
+ SetLastWin32Error(ERROR_INVALID_FLAGS);
+ return Ret;
+ }
+
+ UserEnterExclusive();
+
+ _SEH_TRY
+ {
+ /* Probe the parameters and basic parameter checks */
+ if (ProbeForReadUint(&lpwcx->cbSize) != sizeof(WNDCLASSEXW))
+ {
+ goto InvalidParameter;
+ }
+
+ ProbeForRead(lpwcx,
+ sizeof(WNDCLASSEXW),
+ sizeof(ULONG));
+ RtlCopyMemory(&CapturedClassInfo,
+ lpwcx,
+ sizeof(WNDCLASSEXW));
+
+ CapturedName = ProbeForReadUnicodeString(ClassName);
+ CapturedMenuName = ProbeForReadUnicodeString(MenuName);
+
+ if (CapturedName.Length & 1 || CapturedMenuName.Length & 1 ||
+ CapturedClassInfo.cbClsExtra < 0 ||
+ CapturedClassInfo.cbClsExtra + CapturedName.Length +
+ CapturedMenuName.Length + sizeof(WINDOWCLASS) <
CapturedClassInfo.cbClsExtra ||
+ CapturedClassInfo.cbWndExtra < 0 ||
+ CapturedClassInfo.hInstance == NULL)
+ {
+ goto InvalidParameter;
+ }
+
+ if (CapturedName.Length != 0)
+ {
+ ProbeForRead(CapturedName.Buffer,
+ CapturedName.Length,
+ sizeof(WCHAR));
+ }
+ else
+ {
+ if (!IS_ATOM(CapturedName.Buffer))
+ {
+ goto InvalidParameter;
+ }
+ }
+
+ if (CapturedMenuName.Length != 0)
+ {
+ ProbeForRead(CapturedMenuName.Buffer,
+ CapturedMenuName.Length,
+ sizeof(WCHAR));
+ }
+ else if (CapturedMenuName.Buffer != NULL &&
+ !IS_INTRESOURCE(CapturedMenuName.Buffer))
+ {
+InvalidParameter:
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ _SEH_LEAVE;
+ }
+
+ /* Register the class */
+ Ret = UserRegisterClass(&CapturedClassInfo,
+ &CapturedName,
+ &CapturedMenuName,
+ hMenu, /* FIXME - pass pointer */
+ wpExtra,
+ Flags);
+
+ }
+ _SEH_HANDLE
+ {
+ SetLastNtError(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+
+ UserLeave();
+
+ return Ret;
+}
+
+
+
+ULONG_PTR NTAPI
+NtUserGetClassLong(IN HWND hWnd,
+ IN INT Offset,
+ IN BOOL Ansi)
+{
+ PWINDOW_OBJECT Window;
+ ULONG_PTR Ret = 0;
+
+ UserEnterShared();
+
+ Window = UserGetWindowObject(hWnd);
+ if (Window != NULL)
+ {
+ Ret = UserGetClassLongPtr(Window->Class,
+ Offset,
+ Ansi);
+
+ if (Ret != 0 && Offset == GCLP_MENUNAME && !IS_INTRESOURCE(Ret))
+ {
+ Ret = (ULONG_PTR)DesktopHeapAddressToUser(Window->Class->Desktop,
+ (PVOID)Ret);
+ }
+ }
+
+ UserLeave();
+
+ return Ret;
+}
+
+
+
+ULONG_PTR STDCALL
NtUserSetClassLong(HWND hWnd,
- DWORD Offset,
- LONG dwNewLong,
+ INT Offset,
+ ULONG_PTR dwNewLong,
BOOL Ansi)
{
- PWINDOW_OBJECT Window;
- LONG Ret;
- USER_REFERENCE_ENTRY Ref;
- DECLARE_RETURN(DWORD);
-
- DPRINT("Enter NtUserSetClassLong\n");
- UserEnterExclusive();
-
- if (!(Window = UserGetWindowObject(hWnd)))
- {
- RETURN(0);
- }
-
- UserRefObjectCo(Window, &Ref);
-
- Ret = IntGetClassLong(Window, Offset, Ansi);
- co_IntSetClassLong(Window, Offset, dwNewLong, Ansi);
-
- UserDerefObjectCo(Window);
-
- RETURN(Ret);
-
-CLEANUP:
- DPRINT("Leave NtUserSetClassLong, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
+ PW32PROCESSINFO pi;
+ PWINDOW_OBJECT Window;
+ ULONG_PTR Ret = 0;
+
+ UserEnterExclusive();
+
+ pi = GetW32ProcessInfo();
+ if (pi == NULL)
+ goto Cleanup;
+
+ Window = UserGetWindowObject(hWnd);
+ if (Window != NULL)
+ {
+ if (Window->ti->kpi != pi)
+ {
+ SetLastWin32Error(ERROR_ACCESS_DENIED);
+ goto Cleanup;
+ }
+
+ _SEH_TRY
+ {
+ UNICODE_STRING Value;
+
+ /* probe the parameters */
+ if (Offset == GCW_ATOM || Offset == GCLP_MENUNAME)
+ {
+ Value = ProbeForReadUnicodeString((PUNICODE_STRING)dwNewLong);
+ if (Value.Length & 1)
+ {
+ goto InvalidParameter;
+ }
+
+ if (Value.Length != 0)
+ {
+ ProbeForRead(Value.Buffer,
+ Value.Length,
+ sizeof(WCHAR));
+ }
+ else
+ {
+ if (Offset == GCW_ATOM && !IS_ATOM(Value.Buffer))
+ {
+ goto InvalidParameter;
+ }
+ else if (Offset == GCLP_MENUNAME &&
!IS_INTRESOURCE(Value.Buffer))
+ {
+InvalidParameter:
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ _SEH_LEAVE;
+ }
+ }
+
+ dwNewLong = (ULONG_PTR)&Value;
+ }
+
+ Ret = UserSetClassLongPtr(Window->Class,
+ Offset,
+ dwNewLong,
+ Ansi);
+ }
+ _SEH_HANDLE
+ {
+ SetLastNtError(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+ }
+
+Cleanup:
+ UserLeave();
+
+ return Ret;
}
DWORD STDCALL
@@ -602,164 +2024,232 @@
DWORD Unknown1,
DWORD Unknown2)
{
- UNIMPLEMENTED;
return(0);
}
+BOOL NTAPI
+NtUserUnregisterClass(IN PUNICODE_STRING ClassNameOrAtom,
+ IN HINSTANCE hInstance)
+{
+ UNICODE_STRING CapturedClassName;
+ BOOL Ret = FALSE;
+
+ UserEnterExclusive();
+
+ _SEH_TRY
+ {
+ /* probe the paramters */
+ CapturedClassName = ProbeForReadUnicodeString(ClassNameOrAtom);
+ if (CapturedClassName.Length & 1)
+ {
+ goto InvalidParameter;
+ }
+
+ if (CapturedClassName.Length != 0)
+ {
+ ProbeForRead(CapturedClassName.Buffer,
+ CapturedClassName.Length,
+ sizeof(WCHAR));
+ }
+ else
+ {
+ if (!IS_ATOM(CapturedClassName.Buffer))
+ {
+InvalidParameter:
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ _SEH_LEAVE;
+ }
+ }
+
+ /* unregister the class */
+ Ret = UserUnregisterClass(&CapturedClassName,
+ hInstance);
+ }
+ _SEH_HANDLE
+ {
+ SetLastNtError(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+
+ UserLeave();
+
+ return Ret;
+}
+
+/* NOTE: for system classes hInstance is not NULL here, but User32Instance */
BOOL STDCALL
-NtUserUnregisterClass(
- LPCWSTR ClassNameOrAtom,
- HINSTANCE hInstance, /* can be 0 */
- DWORD Unknown)
-{
- PWNDCLASS_OBJECT Class;
- DECLARE_RETURN(BOOL);
-
- DPRINT("Enter NtUserUnregisterClass(%S)\n", ClassNameOrAtom);
- UserEnterExclusive();
-
- if (!ClassNameOrAtom)
- {
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
- RETURN(FALSE);
- }
-
- if (!(Class = ClassGetClassByNameOrAtom(ClassNameOrAtom, hInstance)))
- {
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
- RETURN(FALSE);
- }
-
- if (Class->refs)
- {
- /* NOTE: the class will not be freed when its refs become 0 ie. no more
- * windows are using it. I dunno why that is but its how Windows does it (and
Wine).
- * The class will hang around until the process exit. -Gunnar
- */
- SetLastWin32Error(ERROR_CLASS_HAS_WINDOWS);
- RETURN(FALSE);
- }
-
- DestroyClass(Class);
-
- RETURN(TRUE);
-
-CLEANUP:
- DPRINT("Leave NtUserUnregisterClass, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
-}
-
-/* NOTE: for system classes hInstance is not NULL here, but User32Instance */
-DWORD STDCALL
NtUserGetClassInfo(
HINSTANCE hInstance,
- LPCWSTR lpClassName,
+ PUNICODE_STRING ClassName,
LPWNDCLASSEXW lpWndClassEx,
- BOOL Ansi,
- DWORD unknown3)
-{
- PWNDCLASS_OBJECT Class;
- RTL_ATOM Atom;
- DECLARE_RETURN(DWORD);
-
- if (IS_ATOM(lpClassName))
- DPRINT("NtUserGetClassInfo - %x (%lx)\n", lpClassName, hInstance);
- else
- DPRINT("NtUserGetClassInfo - %S (%lx)\n", lpClassName, hInstance);
-
- UserEnterExclusive();
-
- if (!hInstance)
- {
- SetLastWin32Error(ERROR_INVALID_PARAMETER);
- RETURN(0);
- }
-
- if (!(Class = ClassGetClassByNameOrAtom(lpClassName, hInstance)))
- {
- SetLastWin32Error(ERROR_CLASS_DOES_NOT_EXIST);
- RETURN(0);
- }
-
- lpWndClassEx->cbSize = sizeof(WNDCLASSEXW);
- lpWndClassEx->style = Class->style;
- if (Ansi)
- lpWndClassEx->lpfnWndProc = Class->lpfnWndProcA;
- else
- lpWndClassEx->lpfnWndProc = Class->lpfnWndProcW;
- lpWndClassEx->cbClsExtra = Class->cbClsExtra;
- lpWndClassEx->cbWndExtra = Class->cbWndExtra;
- /* This is not typo, we're really not going to use Class->hInstance here. */
- /* Well, i think its wrong so i changed it -Gunnar */
- lpWndClassEx->hInstance = Class->hInstance;
- lpWndClassEx->hIcon = Class->hIcon;
- lpWndClassEx->hCursor = Class->hCursor;
- lpWndClassEx->hbrBackground = Class->hbrBackground;
- if (Class->lpszMenuName.MaximumLength)
- RtlCopyUnicodeString((PUNICODE_STRING)lpWndClassEx->lpszMenuName,
&Class->lpszMenuName);
- else
- lpWndClassEx->lpszMenuName = Class->lpszMenuName.Buffer;
- lpWndClassEx->lpszClassName = lpClassName;
- lpWndClassEx->hIconSm = Class->hIconSm;
- Atom = Class->Atom;
-
- RETURN(Atom);
-
-CLEANUP:
- DPRINT("Leave NtUserGetClassInfo, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
-}
-
-
-
-DWORD STDCALL
-NtUserGetClassName (
- HWND hWnd,
- LPWSTR lpClassName,
- ULONG nMaxCount /* in TCHARS */
- )
-{
- PWINDOW_OBJECT Window;
- DECLARE_RETURN(DWORD);
- NTSTATUS Status;
-
- UserEnterShared();
- DPRINT("Enter NtUserGetClassName\n");
-
- if (!(Window = UserGetWindowObject(hWnd)))
- {
- RETURN(0);
- }
-
- nMaxCount *= sizeof(WCHAR);
-
- //FIXME: wrap in SEH to protect lpClassName access
- Status = RtlQueryAtomInAtomTable(gAtomTable,
- Window->Class->Atom, NULL, NULL,
- lpClassName, &nMaxCount);
- if (!NT_SUCCESS(Status))
- {
- SetLastNtError(Status);
- RETURN(0);
- }
-
- RETURN(nMaxCount / sizeof(WCHAR));
-
-CLEANUP:
- DPRINT("Leave NtUserGetClassName, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
+ BOOL Ansi)
+{
+ UNICODE_STRING CapturedClassName;
+ PWINDOWCLASS Class;
+ RTL_ATOM ClassAtom;
+ PW32PROCESSINFO pi;
+ BOOL Ret = FALSE;
+
+ UserEnterShared();
+
+ pi = GetW32ProcessInfo();
+ if (pi == NULL)
+ {
+ goto Cleanup;
+ }
+
+ _SEH_TRY
+ {
+ /* probe the paramters */
+ CapturedClassName = ProbeForReadUnicodeString(ClassName);
+ if (CapturedClassName.Length & 1)
+ {
+ goto InvalidParameter;
+ }
+
+ if (CapturedClassName.Length != 0)
+ {
+ ProbeForRead(CapturedClassName.Buffer,
+ CapturedClassName.Length,
+ sizeof(WCHAR));
+ }
+ else
+ {
+ if (!IS_ATOM(CapturedClassName.Buffer))
+ {
+ goto InvalidParameter;
+ }
+ }
+
+ if (ProbeForReadUint(&lpWndClassEx->cbSize) != sizeof(WNDCLASSEXW))
+ {
+InvalidParameter:
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ _SEH_LEAVE;
+ }
+
+ ProbeForWrite(lpWndClassEx,
+ sizeof(WNDCLASSEXW),
+ sizeof(ULONG));
+
+ ClassAtom = IntGetClassAtom(&CapturedClassName,
+ hInstance,
+ pi,
+ &Class,
+ NULL);
+ if (ClassAtom != (RTL_ATOM)0)
+ {
+ Ret = UserGetClassInfo(Class,
+ lpWndClassEx,
+ Ansi);
+
+ if (Ret)
+ {
+ lpWndClassEx->lpszClassName = CapturedClassName.Buffer;
+
+ /* FIXME - handle Class->Desktop == NULL!!!!! */
+
+ if (Class->MenuName != NULL &&
+ !IS_INTRESOURCE(Class->MenuName))
+ {
+ lpWndClassEx->lpszMenuName =
DesktopHeapAddressToUser(Class->Desktop,
+ (Ansi ?
+
(PVOID)Class->AnsiMenuName :
+
(PVOID)Class->MenuName));
+ }
+ }
+ }
+ }
+ _SEH_HANDLE
+ {
+ SetLastNtError(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+
+Cleanup:
+ UserLeave();
+
+ return Ret;
+}
+
+
+
+INT NTAPI
+NtUserGetClassName (IN HWND hWnd,
+ OUT PUNICODE_STRING ClassName,
+ IN BOOL Ansi)
+{
+ PWINDOW_OBJECT Window;
+ UNICODE_STRING CapturedClassName;
+ INT Ret = 0;
+
+ UserEnterShared();
+
+ Window = UserGetWindowObject(hWnd);
+ if (Window != NULL)
+ {
+ _SEH_TRY
+ {
+ ProbeForWriteUnicodeString(ClassName);
+ CapturedClassName = *ClassName;
+
+ /* get the class name */
+ Ret = UserGetClassName(Window->Class,
+ &CapturedClassName,
+ Ansi);
+
+ if (Ret != 0)
+ {
+ /* update the Length field */
+ ClassName->Length = CapturedClassName.Length;
+ }
+ }
+ _SEH_HANDLE
+ {
+ SetLastNtError(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+ }
+
+ UserLeave();
+
+ return Ret;
}
DWORD STDCALL
NtUserGetWOWClass(DWORD Unknown0,
DWORD Unknown1)
{
- UNIMPLEMENTED;
return(0);
}
+BOOL NTAPI
+NtUserDereferenceWndProcHandle(IN HANDLE wpHandle,
+ OUT PWNDPROC_INFO wpInfo)
+{
+ BOOL Ret = FALSE;
+
+ UserEnterShared();
+
+ _SEH_TRY
+ {
+ ProbeForWrite(wpInfo,
+ sizeof(WNDPROC_INFO),
+ sizeof(ULONG));
+
+ Ret = UserGetCallProcInfo(wpHandle,
+ wpInfo);
+ }
+ _SEH_HANDLE
+ {
+ SetLastWin32Error(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+
+ UserLeave();
+
+ return Ret;
+}
+
/* EOF */
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/cursoricon.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/cursoricon.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/cursoricon.c Wed Apr 5 12:05:55 2006
@@ -83,7 +83,7 @@
return NULL;
}
- CurIcon = (PCURICON_OBJECT)UserGetObject(&gHandleTable, hCurIcon, otCursorIcon);
+ CurIcon = (PCURICON_OBJECT)UserGetObject(gHandleTable, hCurIcon, otCursorIcon);
if (!CurIcon)
{
/* we never set ERROR_INVALID_ICON_HANDLE. lets hope noone ever checks for it */
@@ -397,7 +397,7 @@
PCURICON_OBJECT CurIcon;
HANDLE hCurIcon;
- CurIcon = ObmCreateObject(&gHandleTable, &hCurIcon, otCursorIcon,
sizeof(CURICON_OBJECT));
+ CurIcon = ObmCreateObject(gHandleTable, &hCurIcon, otCursorIcon,
sizeof(CURICON_OBJECT));
if(!CurIcon)
{
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/desktop.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/desktop.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/desktop.c Wed Apr 5 12:05:55 2006
@@ -43,6 +43,8 @@
BOOL g_PaintDesktopVersion = FALSE;
+static VOID IntFreeDesktopHeap(IN OUT PDESKTOP_OBJECT Desktop);
+
/* INITALIZATION FUNCTIONS ****************************************************/
static GENERIC_MAPPING IntDesktopMapping =
@@ -121,6 +123,8 @@
RemoveEntryList(&Desktop->ListEntry);
RtlFreeUnicodeString(&Desktop->Name);
+
+ IntFreeDesktopHeap(Desktop);
}
/* PRIVATE FUNCTIONS **********************************************************/
@@ -723,7 +727,15 @@
return FALSE;
}
-
+static VOID
+IntFreeDesktopHeap(IN OUT PDESKTOP_OBJECT Desktop)
+{
+ if (Desktop->DesktopHeapSection != NULL)
+ {
+ ObDereferenceObject(Desktop->DesktopHeapSection);
+ Desktop->DesktopHeapSection = NULL;
+ }
+}
/* SYSCALLS *******************************************************************/
@@ -776,6 +788,8 @@
NTSTATUS Status;
HDESK Desktop;
CSR_API_MESSAGE Request;
+ PVOID DesktopHeapSystemBase = NULL;
+ SIZE_T DesktopInfoSize;
DECLARE_RETURN(HDESK);
DPRINT("Enter NtUserCreateDesktop: %wZ\n", lpszDesktopName);
@@ -857,6 +871,39 @@
SetLastNtError(STATUS_UNSUCCESSFUL);
RETURN( NULL);
}
+
+ DesktopObject->DesktopHeapSection = NULL;
+ DesktopObject->hDesktopHeap =
UserCreateHeap(&DesktopObject->DesktopHeapSection,
+ &DesktopHeapSystemBase,
+ 4 * 1024 * 1024); /* FIXME */
+ if (DesktopObject->hDesktopHeap == NULL)
+ {
+ ObDereferenceObject(DesktopObject);
+ DPRINT1("Failed to create desktop heap!\n");
+ RETURN(NULL);
+ }
+
+ DesktopInfoSize = FIELD_OFFSET(DESKTOP,
+ szDesktopName[(lpszDesktopName->Length /
sizeof(WCHAR)) + 1]);
+
+ DesktopObject->DesktopInfo = RtlAllocateHeap(DesktopObject->hDesktopHeap,
+ HEAP_NO_SERIALIZE,
+ DesktopInfoSize);
+
+ if (DesktopObject->DesktopInfo == NULL)
+ {
+ ObDereferenceObject(DesktopObject);
+ DPRINT1("Failed to create the DESKTOP structure!\n");
+ RETURN(NULL);
+ }
+
+ RtlZeroMemory(DesktopObject->DesktopInfo,
+ DesktopInfoSize);
+
+ DesktopObject->DesktopInfo->hKernelHeap = DesktopObject->hDesktopHeap;
+ RtlCopyMemory(DesktopObject->DesktopInfo->szDesktopName,
+ lpszDesktopName->Buffer,
+ lpszDesktopName->Length);
// init desktop area
DesktopObject->WorkArea.left = 0;
@@ -1216,7 +1263,7 @@
RETURN(FALSE);
}
- DesktopBrush = (HBRUSH)IntGetClassLong(WndDesktop, GCL_HBRBACKGROUND, FALSE); //fixme:
verify retval
+ DesktopBrush = (HBRUSH)UserGetClassLongPtr(WndDesktop->Class, GCL_HBRBACKGROUND,
FALSE);
/*
@@ -1560,6 +1607,183 @@
END_CLEANUP;
}
+static NTSTATUS
+IntUnmapDesktopView(IN PDESKTOP_OBJECT DesktopObject)
+{
+ PW32THREADINFO ti;
+ PW32HEAP_USER_MAPPING HeapMapping, *PrevLink =
&PsGetWin32Process()->HeapMappings.Next;
+ NTSTATUS Status = STATUS_SUCCESS;
+
+ /* unmap if we're the last thread using the desktop */
+ HeapMapping = *PrevLink;
+ while (HeapMapping != NULL)
+ {
+ if (HeapMapping->KernelMapping == (PVOID)DesktopObject->hDesktopHeap)
+ {
+ if (--HeapMapping->Count == 0)
+ {
+ *PrevLink = HeapMapping->Next;
+
+ Status = MmUnmapViewOfSection(PsGetCurrentProcess(),
+ HeapMapping->UserMapping);
+
+ ObDereferenceObject(DesktopObject);
+
+ UserHeapFree(HeapMapping);
+ break;
+ }
+ }
+
+ PrevLink = &HeapMapping->Next;
+ HeapMapping = HeapMapping->Next;
+ }
+
+ ti = GetW32ThreadInfo();
+ if (ti != NULL)
+ {
+ if (ti->Desktop == DesktopObject->DesktopInfo)
+ {
+ ti->Desktop = NULL;
+ ti->DesktopHeapDelta = 0;
+ }
+ }
+
+ return Status;
+}
+
+static NTSTATUS
+IntMapDesktopView(IN PDESKTOP_OBJECT DesktopObject)
+{
+ PW32THREADINFO ti;
+ PW32HEAP_USER_MAPPING HeapMapping, *PrevLink =
&PsGetWin32Process()->HeapMappings.Next;
+ PVOID UserBase = NULL;
+ ULONG ViewSize = 0;
+ LARGE_INTEGER Offset;
+ NTSTATUS Status;
+
+ /* find out if another thread already mapped the desktop heap */
+ HeapMapping = *PrevLink;
+ while (HeapMapping != NULL)
+ {
+ if (HeapMapping->KernelMapping == (PVOID)DesktopObject->hDesktopHeap)
+ {
+ HeapMapping->Count++;
+ return STATUS_SUCCESS;
+ }
+
+ PrevLink = &HeapMapping->Next;
+ HeapMapping = HeapMapping->Next;
+ }
+
+ /* we're the first, map the heap */
+ Offset.QuadPart = 0;
+ Status = MmMapViewOfSection(DesktopObject->DesktopHeapSection,
+ PsGetCurrentProcess(),
+ &UserBase,
+ 0,
+ 0,
+ &Offset,
+ &ViewSize,
+ ViewUnmap,
+ SEC_NO_CHANGE,
+ PAGE_EXECUTE_READ); /* would prefer PAGE_READONLY, but
thanks to RTL heaps... */
+ if (!NT_SUCCESS(Status))
+ {
+ DbgPrint("Failed to map desktop\n");
+ return Status;
+ }
+
+ /* add the mapping */
+ HeapMapping = UserHeapAlloc(sizeof(W32HEAP_USER_MAPPING));
+ if (HeapMapping == NULL)
+ {
+ MmUnmapViewOfSection(PsGetCurrentProcess(),
+ UserBase);
+ return STATUS_NO_MEMORY;
+ }
+
+ HeapMapping->Next = NULL;
+ HeapMapping->KernelMapping = (PVOID)DesktopObject->hDesktopHeap;
+ HeapMapping->UserMapping = UserBase;
+ HeapMapping->Count = 1;
+
+ ObReferenceObject(DesktopObject);
+
+ /* create a W32THREADINFO structure if not already done, or update it */
+ ti = GetW32ThreadInfo();
+ if (ti != NULL)
+ {
+ if (ti->Desktop == NULL)
+ {
+ ti->Desktop = DesktopObject->DesktopInfo;
+ ti->DesktopHeapDelta = DesktopHeapGetUserDelta();
+ }
+ }
+
+ return STATUS_SUCCESS;
+}
+
+BOOL
+IntSetThreadDesktop(IN PDESKTOP_OBJECT DesktopObject)
+{
+ PDESKTOP_OBJECT OldDesktop;
+ PW32THREAD W32Thread;
+ NTSTATUS Status;
+ BOOL MapHeap;
+
+ MapHeap = (PsGetCurrentProcess() != PsInitialSystemProcess);
+ W32Thread = PsGetWin32Thread();
+
+ if (W32Thread->Desktop != DesktopObject)
+ {
+ OldDesktop = W32Thread->Desktop;
+
+ W32Thread->Desktop = DesktopObject;
+
+ if (MapHeap && DesktopObject != NULL)
+ {
+ Status = IntMapDesktopView(DesktopObject);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastNtError(Status);
+ return FALSE;
+ }
+ }
+
+ if (DesktopObject != NULL)
+ {
+ ObReferenceObject(DesktopObject);
+ }
+
+ if (OldDesktop != NULL)
+ {
+ if (MapHeap)
+ {
+ IntUnmapDesktopView(OldDesktop);
+ }
+
+ ObDereferenceObject(OldDesktop);
+
+ if (W32Thread != NULL && W32Thread->ThreadInfo != NULL &&
+ W32Thread->ThreadInfo->Desktop != (DesktopObject != NULL ?
DesktopObject->DesktopInfo : NULL))
+ {
+ if (DesktopObject != NULL)
+ {
+ W32Thread->ThreadInfo->Desktop =
DesktopObject->DesktopInfo;
+ W32Thread->ThreadInfo->DesktopHeapDelta =
DesktopHeapGetUserDelta();
+ }
+ else
+ {
+ W32Thread->ThreadInfo->Desktop = NULL;
+ W32Thread->ThreadInfo->DesktopHeapDelta = 0;
+ }
+ }
+ }
+ }
+
+ return TRUE;
+}
+
/*
* NtUserSetThreadDesktop
*
@@ -1570,7 +1794,6 @@
BOOL STDCALL
NtUserSetThreadDesktop(HDESK hDesktop)
{
- PW32THREAD W32Thread;
PDESKTOP_OBJECT DesktopObject;
NTSTATUS Status;
DECLARE_RETURN(BOOL);
@@ -1591,17 +1814,12 @@
RETURN(FALSE);
}
- W32Thread = PsGetWin32Thread();
-
/* FIXME: Should check here to see if the thread has any windows. */
- if (W32Thread->Desktop != NULL)
- {
- ObDereferenceObject(W32Thread->Desktop);
- }
-
- W32Thread->Desktop = DesktopObject;
- W32Thread->hDesktop = hDesktop;
+ if (!IntSetThreadDesktop(DesktopObject))
+ {
+ RETURN(FALSE);
+ }
RETURN(TRUE);
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/hook.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/hook.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/hook.c Wed Apr 5 12:05:55 2006
@@ -69,7 +69,7 @@
return NULL;
}
- Hook = (PHOOK)UserGetObject(&gHandleTable, hHook, otHook);
+ Hook = (PHOOK)UserGetObject(gHandleTable, hHook, otHook);
if (!Hook)
{
SetLastWin32Error(ERROR_INVALID_HOOK_HANDLE);
@@ -110,7 +110,7 @@
}
}
- Hook = ObmCreateObject(&gHandleTable, &Handle, otHook, sizeof(HOOK));
+ Hook = ObmCreateObject(gHandleTable, &Handle, otHook, sizeof(HOOK));
if (NULL == Hook)
{
return NULL;
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/menu.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/menu.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/menu.c Wed Apr 5 12:05:55 2006
@@ -127,7 +127,7 @@
return NULL;
}
- Menu = (PMENU_OBJECT)UserGetObject(&gHandleTable, hMenu, otMenu);
+ Menu = (PMENU_OBJECT)UserGetObject(gHandleTable, hMenu, otMenu);
if (!Menu)
{
SetLastWin32Error(ERROR_INVALID_MENU_HANDLE);
@@ -310,7 +310,7 @@
PMENU_OBJECT Menu;
Menu = (PMENU_OBJECT)ObmCreateObject(
- &gHandleTable, Handle,
+ gHandleTable, Handle,
otMenu, sizeof(MENU_OBJECT));
if(!Menu)
@@ -419,7 +419,7 @@
return NULL;
Menu = (PMENU_OBJECT)ObmCreateObject(
- &gHandleTable, &hMenu,
+ gHandleTable, &hMenu,
otMenu, sizeof(MENU_OBJECT));
if(!Menu)
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/message.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/message.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/message.c Wed Apr 5 12:05:55 2006
@@ -378,28 +378,9 @@
MsgInfo.HandledByKernel = FALSE;
Result = 0;
- if (0xFFFF0000 != ((DWORD) Window->WndProcW & 0xFFFF0000))
- {
- if (0xFFFF0000 != ((DWORD) Window->WndProcA & 0xFFFF0000))
- {
- /* Both Unicode and Ansi winprocs are real, use whatever
- usermode prefers */
- MsgInfo.Proc = (MsgInfo.Ansi ? Window->WndProcA
- : Window->WndProcW);
- }
- else
- {
- /* Real Unicode winproc */
- MsgInfo.Ansi = FALSE;
- MsgInfo.Proc = Window->WndProcW;
- }
- }
- else
- {
- /* Must have real Ansi winproc */
- MsgInfo.Ansi = TRUE;
- MsgInfo.Proc = Window->WndProcA;
- }
+
+ MsgInfo.Ansi = !Window->Unicode;
+ MsgInfo.Proc = Window->WndProc;
}
}
}
@@ -615,7 +596,7 @@
{
/* generate double click messages, if necessary */
if ((((*HitTest) != HTCLIENT) ||
- (IntGetClassLong(Window, GCL_STYLE, FALSE) & CS_DBLCLKS)) &&
+ (Window->Class->Style & CS_DBLCLKS)) &&
MsqIsDblClk(Msg, Remove))
{
Msg->message += WM_LBUTTONDBLCLK - WM_LBUTTONDOWN;
@@ -1401,16 +1382,9 @@
DPRINT1("Failed to pack message parameters\n");
RETURN( FALSE);
}
- if (0xFFFF0000 != ((DWORD) Window->WndProcW & 0xFFFF0000))
- {
- Result = (ULONG_PTR)co_IntCallWindowProc(Window->WndProcW, FALSE, hWnd, Msg,
wParam,
- lParamPacked,lParamBufferSize);
- }
- else
- {
- Result = (ULONG_PTR)co_IntCallWindowProc(Window->WndProcA, TRUE, hWnd, Msg,
wParam,
- lParamPacked,lParamBufferSize);
- }
+
+ Result = (ULONG_PTR)co_IntCallWindowProc(Window->WndProc, !Window->Unicode,
hWnd, Msg, wParam,
+ lParamPacked,lParamBufferSize);
if(uResult)
{
@@ -1580,32 +1554,16 @@
{
/* Gather the information usermode needs to call the window proc directly */
Info.HandledByKernel = FALSE;
- if (0xFFFF0000 != ((DWORD) Window->WndProcW & 0xFFFF0000))
- {
- if (0xFFFF0000 != ((DWORD) Window->WndProcA & 0xFFFF0000))
- {
- /* Both Unicode and Ansi winprocs are real, see what usermode prefers */
- Status = MmCopyFromCaller(&(Info.Ansi), &(UnsafeInfo->Ansi),
- sizeof(BOOL));
- if (! NT_SUCCESS(Status))
- {
- Info.Ansi = ! Window->Unicode;
- }
- Info.Proc = (Info.Ansi ? Window->WndProcA : Window->WndProcW);
- }
- else
- {
- /* Real Unicode winproc */
- Info.Ansi = FALSE;
- Info.Proc = Window->WndProcW;
- }
- }
- else
- {
- /* Must have real Ansi winproc */
- Info.Ansi = TRUE;
- Info.Proc = Window->WndProcA;
- }
+
+ Status = MmCopyFromCaller(&(Info.Ansi), &(UnsafeInfo->Ansi),
+ sizeof(BOOL));
+ if (! NT_SUCCESS(Status))
+ {
+ Info.Ansi = ! Window->Unicode;
+ }
+
+ Info.Ansi = !Window->Unicode;
+ Info.Proc = Window->WndProc;
}
else
{
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/misc.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/misc.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/misc.c Wed Apr 5 12:05:55 2006
@@ -886,11 +886,22 @@
DECLARE_RETURN(DWORD);
DPRINT("Enter NtUserGetThreadState\n");
- UserEnterShared();
+ if (Routine != THREADSTATE_GETTHREADINFO)
+ {
+ UserEnterShared();
+ }
+ else
+ {
+ UserEnterExclusive();
+ }
switch (Routine)
{
- case 0:
+ case THREADSTATE_GETTHREADINFO:
+ GetW32ThreadInfo();
+ RETURN(0);
+
+ case THREADSTATE_FOCUSWINDOW:
RETURN( (DWORD)IntGetThreadFocusWindow());
}
RETURN( 0);
@@ -1829,4 +1840,106 @@
END_CLEANUP;
}
+PW32PROCESSINFO
+GetW32ProcessInfo(VOID)
+{
+ PW32PROCESSINFO pi;
+ PW32PROCESS W32Process = PsGetWin32Process();
+
+ if (W32Process == NULL)
+ {
+ /* FIXME - temporary hack for system threads... */
+ return NULL;
+ }
+
+ if (W32Process->ProcessInfo == NULL)
+ {
+ pi = UserHeapAlloc(sizeof(W32PROCESSINFO));
+ if (pi != NULL)
+ {
+ RtlZeroMemory(pi,
+ sizeof(W32PROCESSINFO));
+
+ /* initialize it */
+ pi->UserHandleTable = gHandleTable;
+
+ if (InterlockedCompareExchangePointer(&W32Process->ProcessInfo,
+ pi,
+ NULL) != NULL)
+ {
+ UserHeapFree(pi);
+ }
+ }
+ else
+ {
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ }
+
+ return W32Process->ProcessInfo;
+}
+
+PW32THREADINFO
+GetW32ThreadInfo(VOID)
+{
+ PTEB Teb;
+ PW32THREADINFO ti;
+ PW32THREAD W32Thread = PsGetWin32Thread();
+
+ if (W32Thread == NULL)
+ {
+ /* FIXME - temporary hack for system threads... */
+ return NULL;
+ }
+
+ /* allocate a W32THREAD structure if neccessary */
+ if (W32Thread->ThreadInfo == NULL)
+ {
+ ti = UserHeapAlloc(sizeof(W32THREADINFO));
+ if (ti != NULL)
+ {
+ RtlZeroMemory(ti,
+ sizeof(W32THREADINFO));
+
+ /* initialize it */
+ ti->kpi = GetW32ProcessInfo();
+ ti->pi = UserHeapAddressToUser(ti->kpi);
+ if (W32Thread->Desktop != NULL)
+ {
+ ti->Desktop = W32Thread->Desktop->DesktopInfo;
+ ti->DesktopHeapDelta = DesktopHeapGetUserDelta();
+ }
+ else
+ {
+ ti->Desktop = NULL;
+ ti->DesktopHeapDelta = 0;
+ }
+
+ W32Thread->ThreadInfo = ti;
+ /* update the TEB */
+ Teb = NtCurrentTeb();
+ _SEH_TRY
+ {
+ ProbeForWrite(Teb,
+ sizeof(TEB),
+ sizeof(ULONG));
+
+ Teb->Win32ThreadInfo =
UserHeapAddressToUser(W32Thread->ThreadInfo);
+ }
+ _SEH_HANDLE
+ {
+ SetLastNtError(_SEH_GetExceptionCode());
+ }
+ _SEH_END;
+ }
+ else
+ {
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ }
+ }
+
+ return W32Thread->ThreadInfo;
+}
+
+
/* EOF */
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/monitor.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/monitor.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/monitor.c Wed Apr 5 12:05:55 2006
@@ -89,7 +89,7 @@
HANDLE Handle;
PMONITOR_OBJECT Monitor;
- Monitor = ObmCreateObject(&gHandleTable, &Handle, otMonitor, sizeof
(MONITOR_OBJECT));
+ Monitor = ObmCreateObject(gHandleTable, &Handle, otMonitor, sizeof
(MONITOR_OBJECT));
if (Monitor == NULL)
{
return NULL;
@@ -133,7 +133,7 @@
}
- Monitor = (PMONITOR_OBJECT)UserGetObject(&gHandleTable, hMonitor, otMonitor);
+ Monitor = (PMONITOR_OBJECT)UserGetObject(gHandleTable, hMonitor, otMonitor);
if (!Monitor)
{
SetLastWin32Error(ERROR_INVALID_MONITOR_HANDLE);
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/object.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/object.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/object.c Wed Apr 5 12:05:55 2006
@@ -28,7 +28,7 @@
#include <debug.h>
int usedHandles=0;
-USER_HANDLE_TABLE gHandleTable;
+PUSER_HANDLE_TABLE gHandleTable = NULL;
PUSER_HANDLE_ENTRY handle_to_entry(PUSER_HANDLE_TABLE ht, HANDLE handle )
@@ -71,19 +71,17 @@
DPRINT1("Out of user handles!\n");
return NULL;
#if 0
-
- struct user_handle *new_handles;
+ PUSER_HANDLE_ENTRY new_handles;
/* grow array by 50% (but at minimum 32 entries) */
- int growth = max( 32, allocated_handles / 2 );
- int new_size = min( allocated_handles + growth,
(LAST_USER_HANDLE-FIRST_USER_HANDLE+1) >> 1 );
- if (new_size <= allocated_handles)
+ int growth = max( 32, ht->allocated_handles / 2 );
+ int new_size = min( ht->allocated_handles + growth,
(LAST_USER_HANDLE-FIRST_USER_HANDLE+1) >> 1 );
+ if (new_size <= ht->allocated_handles)
return NULL;
- if (!(new_handles = realloc( handles, new_size * sizeof(*handles) )))
+ if (!(new_handles = UserHeapReAlloc( ht->handles, new_size *
sizeof(*ht->handles) )))
return NULL;
- handles = new_handles;
- allocated_handles = new_size;
+ ht->handles = new_handles;
+ ht->allocated_handles = new_size;
#endif
-
}
entry = &ht->handles[ht->nb_handles++];
@@ -217,7 +215,7 @@
{
HANDLE hi;
- PUSER_OBJECT_HEADER hdr = ExAllocatePool(PagedPool, size +
sizeof(USER_OBJECT_HEADER));
+ PUSER_OBJECT_HEADER hdr = UserHeapAlloc(size +
sizeof(USER_OBJECT_HEADER));//ExAllocatePool(PagedPool, size +
sizeof(USER_OBJECT_HEADER));
if (!hdr)
return NULL;
@@ -225,7 +223,8 @@
hi = UserAllocHandle(ht, USER_HEADER_TO_BODY(hdr), type );
if (!hi)
{
- ExFreePool(hdr);
+ //ExFreePool(hdr);
+ UserHeapFree(hdr);
return NULL;
}
@@ -242,7 +241,7 @@
ObmDeleteObject(HANDLE h, USER_OBJECT_TYPE type )
{
PUSER_OBJECT_HEADER hdr;
- PVOID body = UserGetObject(&gHandleTable, h, type);
+ PVOID body = UserGetObject(gHandleTable, h, type);
if (!body)
return FALSE;
@@ -252,11 +251,12 @@
hdr->destroyed = TRUE;
if (hdr->RefCount == 0)
{
- UserFreeHandle(&gHandleTable, h);
+ UserFreeHandle(gHandleTable, h);
memset(hdr, 0x55, sizeof(USER_OBJECT_HEADER));
- ExFreePool(hdr);
+ UserHeapFree(hdr);
+ //ExFreePool(hdr);
return TRUE;
}
@@ -274,6 +274,12 @@
hdr->RefCount++;
}
+HANDLE FASTCALL ObmObjectToHandle(PVOID obj)
+{
+ PUSER_OBJECT_HEADER hdr = USER_BODY_TO_HEADER(obj);
+ return hdr->hSelf;
+}
+
BOOL FASTCALL ObmDereferenceObject2(PVOID obj)
{
@@ -287,11 +293,12 @@
{
// DPRINT1("info: something destroyed bcaise of deref, in
use=%i\n",usedHandles);
- UserFreeHandle(&gHandleTable, hdr->hSelf);
+ UserFreeHandle(gHandleTable, hdr->hSelf);
memset(hdr, 0x55, sizeof(USER_OBJECT_HEADER));
- ExFreePool(hdr);
+ UserHeapFree(hdr);
+ //ExFreePool(hdr);
return TRUE;
}
@@ -307,15 +314,24 @@
PVOID mem;
//FIXME: dont alloc all at once! must be mapped into umode also...
- mem = ExAllocatePool(PagedPool, sizeof(USER_HANDLE_ENTRY) * 1024*2);
+ //mem = ExAllocatePool(PagedPool, sizeof(USER_HANDLE_ENTRY) * 1024*2);
+ mem = UserHeapAlloc(sizeof(USER_HANDLE_ENTRY) * 1024*2);
if (!mem)
{
DPRINT1("Failed creating handle table\n");
return FALSE;
}
+ gHandleTable = UserHeapAlloc(sizeof(USER_HANDLE_TABLE));
+ if (gHandleTable == NULL)
+ {
+ UserHeapFree(mem);
+ DPRINT1("Failed creating handle table\n");
+ return FALSE;
+ }
+
//FIXME: make auto growable
- UserInitHandleTable(&gHandleTable, mem, sizeof(USER_HANDLE_ENTRY) * 1024*2);
+ UserInitHandleTable(gHandleTable, mem, sizeof(USER_HANDLE_ENTRY) * 1024*2);
return TRUE;
}
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/windc.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/windc.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/windc.c Wed Apr 5 12:05:55 2006
@@ -353,7 +353,7 @@
if (!(Flags & DCX_WINDOW))
{
- if (Window->Class->style & CS_PARENTDC)
+ if (Window->Class->Style & CS_PARENTDC)
{
Flags |= DCX_PARENTCLIP;
}
@@ -676,7 +676,7 @@
{
if (pDCE == Window->Dce) /* owned or Class DCE*/
{
- if (Window->Class->style & CS_OWNDC) /* owned DCE*/
+ if (Window->Class->Style & CS_OWNDC) /* owned DCE*/
{
pDCE = DceFreeDCE(pDCE, FALSE);
Window->Dce = NULL;
Modified: trunk/reactos/subsystems/win32/win32k/ntuser/window.c
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/ntu…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/ntuser/window.c (original)
+++ trunk/reactos/subsystems/win32/win32k/ntuser/window.c Wed Apr 5 12:05:55 2006
@@ -33,10 +33,6 @@
#define NDEBUG
#include <debug.h>
-static WndProcHandle *WndProcHandlesArray = 0;
-static WORD WndProcHandlesArraySize = 0;
-#define WPH_SIZE 0x40 /* the size to add to the WndProcHandle array each time */
-
/* dialog resources appear to pass this in 16 bits, handle them properly */
#define CW_USEDEFAULT16 (0x8000)
@@ -53,8 +49,6 @@
NTSTATUS FASTCALL
InitWindowImpl(VOID)
{
- WndProcHandlesArray = ExAllocatePoolWithTag(PagedPool,WPH_SIZE *
sizeof(WndProcHandle), TAG_WINPROCLST);
- WndProcHandlesArraySize = WPH_SIZE;
return STATUS_SUCCESS;
}
@@ -67,9 +61,6 @@
NTSTATUS FASTCALL
CleanupWindowImpl(VOID)
{
- ExFreePool(WndProcHandlesArray);
- WndProcHandlesArray = 0;
- WndProcHandlesArraySize = 0;
return STATUS_SUCCESS;
}
@@ -95,15 +86,26 @@
/* temp hack */
PWINDOW_OBJECT FASTCALL UserGetWindowObject(HWND hWnd)
{
+ PW32THREADINFO ti;
PWINDOW_OBJECT Window;
-
+
+ if (PsGetCurrentProcess() != PsInitialSystemProcess)
+ {
+ ti = GetW32ThreadInfo();
+ if (ti == NULL)
+ {
+ SetLastWin32Error(ERROR_ACCESS_DENIED);
+ return NULL;
+ }
+ }
+
if (!hWnd)
{
SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
return NULL;
}
- Window = (PWINDOW_OBJECT)UserGetObject(&gHandleTable, hWnd, otWindow);
+ Window = (PWINDOW_OBJECT)UserGetObject(gHandleTable, hWnd, otWindow);
if (!Window || 0 != (Window->Status & WINDOWSTATUS_DESTROYED))
{
SetLastWin32Error(ERROR_INVALID_WINDOW_HANDLE);
@@ -432,8 +434,16 @@
IntDestroyScrollBars(Window);
+ if (!Window->Class->System && Window->CallProc != NULL)
+ {
+ DestroyCallProc(Window->ti->Desktop,
+ Window->CallProc);
+ }
+
/* dereference the class */
- ClassDerefObject(Window->Class);
+ IntDereferenceClass(Window->Class,
+ Window->ti->Desktop,
+ Window->ti->kpi);
Window->Class = NULL;
if(Window->WindowRegion)
@@ -473,6 +483,57 @@
*cx = *cy = 0;
}
}
+}
+
+static WNDPROC
+IntGetWindowProc(IN PWINDOW_OBJECT Window,
+ IN BOOL Ansi)
+{
+ if (Window->IsSystem)
+ {
+ return (Ansi ? Window->WndProcExtra : Window->WndProc);
+ }
+ else
+ {
+ if (!Ansi == Window->Unicode)
+ {
+ return Window->WndProc;
+ }
+ else
+ {
+ if (Window->CallProc != NULL)
+ {
+ return (WNDPROC)ObmObjectToHandle(Window->CallProc);
+ }
+ else
+ {
+ PCALLPROC NewCallProc, CallProc;
+
+ /* NOTE: use the interlocked functions, as this operation may be done
even
+ when only the shared lock is held! */
+ NewCallProc = CreateCallProc(Window->ti->Desktop,
+ Window->WndProc,
+ Window->Unicode,
+ Window->ti->kpi);
+ if (NewCallProc == NULL)
+ {
+ SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
+ return NULL;
+ }
+
+ CallProc = InterlockedCompareExchangePointer(&Window->CallProc,
+ NewCallProc,
+ NULL);
+ if (CallProc != NULL)
+ {
+ DestroyCallProc(Window->ti->Desktop,
+ NewCallProc);
+ }
+
+ return (WNDPROC)ObmObjectToHandle((CallProc == NULL ? NewCallProc :
CallProc));
+ }
+ }
+ }
}
BOOL FASTCALL
@@ -1333,7 +1394,8 @@
BOOL bUnicodeWindow)
{
PWINSTATION_OBJECT WinSta;
- PWNDCLASS_OBJECT Class = NULL;
+ PWINDOWCLASS Class = NULL;
+ RTL_ATOM ClassAtom;
PWINDOW_OBJECT Window = NULL;
PWINDOW_OBJECT ParentWindow = NULL, OwnerWindow;
HWND ParentWindowHandle;
@@ -1342,6 +1404,7 @@
HWND hWnd;
POINT Pos;
SIZE Size;
+ PW32THREADINFO ti = NULL;
#if 0
POINT MaxSize, MaxPos, MinTrack, MaxTrack;
@@ -1349,7 +1412,6 @@
POINT MaxPos;
#endif
-
CREATESTRUCTW Cs;
CBT_CREATEWNDW CbtCreate;
LRESULT Result;
@@ -1399,13 +1461,27 @@
/* FIXME: parent must belong to the current process */
+ /* Check the window station. */
+ ti = GetW32ThreadInfo();
+ if (ti == NULL || PsGetWin32Thread()->Desktop == NULL)
+ {
+ DPRINT1("Thread is not attached to a desktop! Cannot create window!\n");
+ RETURN( (HWND)0);
+ }
+
/* Check the class. */
- Class = ClassGetClassByNameOrAtom(ClassName->Buffer, hInstance);
- if (!Class)
+
+ ClassAtom = IntGetClassAtom(ClassName,
+ hInstance,
+ ti->kpi,
+ &Class,
+ NULL);
+
+ if (ClassAtom == (RTL_ATOM)0)
{
if (IS_ATOM(ClassName->Buffer))
{
- DPRINT1("Class 0x%x not found\n", (DWORD_PTR) ClassName->Buffer);
+ DPRINT1("Class 0x%p not found\n", (DWORD_PTR) ClassName->Buffer);
}
else
{
@@ -1416,14 +1492,14 @@
RETURN((HWND)0);
}
- ClassRefObject(Class);
-
- /* Check the window station. */
- if (PsGetWin32Thread()->Desktop == NULL)
- {
- DPRINT("Thread is not attached to a desktop! Cannot create window!\n");
- RETURN( (HWND)0);
- }
+ Class = IntReferenceClass(Class,
+ ti->Desktop);
+ if (Class == NULL)
+ {
+ DPRINT1("Failed to reference window class!\n");
+ RETURN(NULL);
+ }
+
WinSta = PsGetWin32Thread()->Desktop->WindowStation;
//FIXME: Reference thread/desktop instead
@@ -1431,8 +1507,8 @@
/* Create the window object. */
Window = (PWINDOW_OBJECT)
- ObmCreateObject(&gHandleTable, (PHANDLE)&hWnd,
- otWindow, sizeof(WINDOW_OBJECT) + Class->cbWndExtra
+ ObmCreateObject(gHandleTable, (PHANDLE)&hWnd,
+ otWindow, sizeof(WINDOW_OBJECT) + Class->WndExtra
);
DPRINT("Created object with handle %X\n", hWnd);
@@ -1456,6 +1532,7 @@
/*
* Fill out the structure describing it.
*/
+ Window->ti = ti;
Window->Class = Class;
Window->SystemMenu = (HMENU)0;
Window->ContextHelpId = 0;
@@ -1474,7 +1551,7 @@
{
IntSetMenu(Window, hMenu, &MenuChanged);
}
-
+
Window->MessageQueue = PsGetWin32Thread()->MessageQueue;
IntReferenceMessageQueue(Window->MessageQueue);
Window->Parent = ParentWindow;
@@ -1491,27 +1568,38 @@
}
Window->UserData = 0;
-
- if ((((DWORD)Class->lpfnWndProcA & 0xFFFF0000) != 0xFFFF0000)
- && (((DWORD)Class->lpfnWndProcW & 0xFFFF0000) != 0xFFFF0000))
- {
- Window->Unicode = bUnicodeWindow;
+
+ Window->IsSystem = Class->System;
+ if (Class->System)
+ {
+ Window->Unicode = bUnicodeWindow;
+ if (bUnicodeWindow)
+ {
+ Window->WndProc = Class->WndProc;
+ Window->WndProcExtra = Class->WndProcExtra;
+ }
+ else
+ {
+ Window->WndProc = Class->WndProcExtra;
+ Window->WndProcExtra = Class->WndProc;
+ }
}
else
{
- Window->Unicode = Class->Unicode;
- }
- Window->WndProcA = Class->lpfnWndProcA;
- Window->WndProcW = Class->lpfnWndProcW;
+ Window->Unicode = Class->Unicode;
+ Window->WndProc = Class->WndProc;
+ Window->CallProc = NULL;
+ }
+
Window->OwnerThread = PsGetCurrentThread();
Window->FirstChild = NULL;
Window->LastChild = NULL;
Window->PrevSibling = NULL;
Window->NextSibling = NULL;
- Window->ExtraDataSize = Class->cbWndExtra;
+ Window->ExtraDataSize = Class->WndExtra;
/* extra window data */
- if (Class->cbWndExtra)
+ if (Class->WndExtra)
Window->ExtraData = (PCHAR)(Window + 1);
InitializeListHead(&Window->PropListHead);
@@ -1535,7 +1623,6 @@
{
RtlInitUnicodeString(&Window->WindowName, NULL);
}
-
/*
* This has been tested for WS_CHILD | WS_VISIBLE. It has not been
@@ -1931,7 +2018,15 @@
CLEANUP:
if (Window) UserDerefObjectCo(Window);
if (ParentWindow) UserDerefObjectCo(ParentWindow);
- if (!_ret_ && Class) ClassDerefObject(Class); /* only deref if failure (return
0) */
+ if (!_ret_ && ti != NULL)
+ {
+ if (Class != NULL)
+ {
+ IntDereferenceClass(Class,
+ ti->Desktop,
+ ti->kpi);
+ }
+ }
END_CLEANUP;
}
@@ -1967,7 +2062,7 @@
SetLastNtError(Status);
RETURN( NULL);
}
- if (! IS_ATOM(ClassName.Buffer))
+ if (ClassName.Length != 0)
{
Status = IntSafeCopyUnicodeStringTerminateNULL(&ClassName, UnsafeClassName);
if (! NT_SUCCESS(Status))
@@ -1975,6 +2070,11 @@
SetLastNtError(Status);
RETURN( NULL);
}
+ }
+ else if (! IS_INTRESOURCE(ClassName.Buffer))
+ {
+ SetLastWin32Error(ERROR_INVALID_PARAMETER);
+ return NULL;
}
/* safely copy the window name */
@@ -3254,10 +3354,8 @@
break;
case GWL_WNDPROC:
- if (Ansi)
- Result = (LONG) Window->WndProcA;
- else
- Result = (LONG) Window->WndProcW;
+ Result = (LONG)IntGetWindowProc(Window,
+ Ansi);
break;
case GWL_HINSTANCE:
@@ -3390,22 +3488,28 @@
break;
case GWL_WNDPROC:
+ {
/* FIXME: should check if window belongs to current process */
- if (Ansi)
+ if (Window->IsSystem)
{
- OldValue = (LONG) Window->WndProcA;
- Window->WndProcA = (WNDPROC) NewValue;
- Window->WndProcW = (WNDPROC)
IntAddWndProcHandle((WNDPROC)NewValue,FALSE);
- Window->Unicode = FALSE;
+ /* the user changes the window procedure, the window is no longer
+ directly derived from the system class, because it no longer
+ uses independent window procedures for ansi and unicode */
+ Window->IsSystem = FALSE;
+ Window->CallProc = NULL;
}
- else
+
+ /* update the window procedure */
+ OldValue = (LONG)Window->WndProc;
+ Window->WndProc = (WNDPROC)NewValue;
+ if (Window->CallProc != NULL)
{
- OldValue = (LONG) Window->WndProcW;
- Window->WndProcW = (WNDPROC) NewValue;
- Window->WndProcA = (WNDPROC)
IntAddWndProcHandle((WNDPROC)NewValue,TRUE);
- Window->Unicode = TRUE;
+ Window->CallProc->WndProc = (WNDPROC)NewValue;
+ Window->CallProc->Unicode = !Ansi;
}
+ Window->Unicode = !Ansi;
break;
+ }
case GWL_HINSTANCE:
OldValue = (LONG) Window->Instance;
@@ -4404,99 +4508,6 @@
END_CLEANUP;
}
-DWORD STDCALL
-NtUserDereferenceWndProcHandle(WNDPROC wpHandle, WndProcHandle *Data)
-{
- DECLARE_RETURN(DWORD);
- WndProcHandle Entry;
-
- DPRINT("Enter NtUserDereferenceWndProcHandle\n");
- UserEnterShared();
-
- if (((DWORD)wpHandle & 0xFFFF0000) == 0xFFFF0000)
- {
- Entry = WndProcHandlesArray[(DWORD)wpHandle & 0x0000FFFF];
- Data->WindowProc = Entry.WindowProc;
- Data->IsUnicode = Entry.IsUnicode;
- Data->ProcessID = Entry.ProcessID;
- RETURN( TRUE);
- }
- else
- {
- RETURN( FALSE);
- }
- RETURN( FALSE);
-
-CLEANUP:
- DPRINT("Leave NtUserDereferenceWndProcHandle, ret=%i\n",_ret_);
- UserLeave();
- END_CLEANUP;
-}
-
-DWORD
-IntAddWndProcHandle(WNDPROC WindowProc, BOOL IsUnicode)
-{
- WORD i;
- WORD FreeSpot = 0;
- BOOL found;
- WndProcHandle *OldArray;
- WORD OldArraySize;
- found = FALSE;
- for (i = 0;i < WndProcHandlesArraySize;i++)
- {
- if (WndProcHandlesArray[i].WindowProc == NULL)
- {
- FreeSpot = i;
- found = TRUE;
- }
- }
- if (!found)
- {
- OldArray = WndProcHandlesArray;
- OldArraySize = WndProcHandlesArraySize;
- WndProcHandlesArray = ExAllocatePoolWithTag(PagedPool,(OldArraySize + WPH_SIZE) *
sizeof(WndProcHandle), TAG_WINPROCLST);
- WndProcHandlesArraySize = OldArraySize + WPH_SIZE;
- RtlCopyMemory(WndProcHandlesArray,OldArray,OldArraySize * sizeof(WndProcHandle));
- ExFreePool(OldArray);
- FreeSpot = OldArraySize + 1;
- }
- WndProcHandlesArray[FreeSpot].WindowProc = WindowProc;
- WndProcHandlesArray[FreeSpot].IsUnicode = IsUnicode;
- WndProcHandlesArray[FreeSpot].ProcessID = PsGetCurrentProcessId();
- return FreeSpot + 0xFFFF0000;
-}
-
-DWORD
-IntRemoveWndProcHandle(WNDPROC Handle)
-{
- WORD position;
- position = (DWORD)Handle & 0x0000FFFF;
- if (position > WndProcHandlesArraySize)
- {
- return FALSE;
- }
- WndProcHandlesArray[position].WindowProc = NULL;
- WndProcHandlesArray[position].IsUnicode = FALSE;
- WndProcHandlesArray[position].ProcessID = NULL;
- return TRUE;
-}
-
-DWORD
-IntRemoveProcessWndProcHandles(HANDLE ProcessID)
-{
- WORD i;
- for (i = 0;i < WndProcHandlesArraySize;i++)
- {
- if (WndProcHandlesArray[i].ProcessID == ProcessID)
- {
- WndProcHandlesArray[i].WindowProc = NULL;
- WndProcHandlesArray[i].IsUnicode = FALSE;
- WndProcHandlesArray[i].ProcessID = NULL;
- }
- }
- return TRUE;
-}
-
#define WIN_NEEDS_SHOW_OWNEDPOPUP (0x00000040)
BOOL
Modified: trunk/reactos/subsystems/win32/win32k/w32k.h
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/w32…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/w32k.h (original)
+++ trunk/reactos/subsystems/win32/win32k/w32k.h Wed Apr 5 12:05:55 2006
@@ -1,3 +1,5 @@
+#ifndef __W32K_H
+#define __W32K_H
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Graphics Subsystem
@@ -68,3 +70,77 @@
#define M_PI_2 1.57079632679489661923
#endif
+/* User heap */
+extern HANDLE GlobalUserHeap;
+
+HANDLE
+UserCreateHeap(OUT PSECTION_OBJECT *SectionObject,
+ IN OUT PVOID *SystemBase,
+ IN ULONG HeapSize);
+
+static __inline PVOID
+UserHeapAlloc(SIZE_T Bytes)
+{
+ return RtlAllocateHeap(GlobalUserHeap,
+ HEAP_NO_SERIALIZE,
+ Bytes);
+}
+
+static __inline BOOL
+UserHeapFree(PVOID lpMem)
+{
+ return RtlFreeHeap(GlobalUserHeap,
+ HEAP_NO_SERIALIZE,
+ lpMem);
+}
+
+static __inline PVOID
+UserHeapReAlloc(PVOID lpMem,
+ SIZE_T Bytes)
+{
+#if 0
+ /* NOTE: ntoskrnl doesn't export RtlReAllocateHeap... */
+ return RtlReAllocateHeap(GlobalUserHeap,
+ HEAP_NO_SERIALIZE,
+ lpMem,
+ Bytes);
+#else
+ SIZE_T PrevSize;
+ PVOID pNew;
+
+ PrevSize = RtlSizeHeap(GlobalUserHeap,
+ HEAP_NO_SERIALIZE,
+ lpMem);
+
+ if (PrevSize == Bytes)
+ return lpMem;
+
+ pNew = RtlAllocateHeap(GlobalUserHeap,
+ HEAP_NO_SERIALIZE,
+ Bytes);
+ if (pNew != NULL)
+ {
+ if (PrevSize < Bytes)
+ Bytes = PrevSize;
+
+ RtlCopyMemory(pNew,
+ lpMem,
+ Bytes);
+
+ RtlFreeHeap(GlobalUserHeap,
+ HEAP_NO_SERIALIZE,
+ lpMem);
+ }
+
+ return pNew;
+#endif
+}
+
+static __inline PVOID
+UserHeapAddressToUser(PVOID lpMem)
+{
+ return (PVOID)(((ULONG_PTR)lpMem - (ULONG_PTR)GlobalUserHeap) +
+ (ULONG_PTR)PsGetWin32Process()->HeapMappings.UserMapping);
+}
+
+#endif /* __W32K_H */
Modified: trunk/reactos/subsystems/win32/win32k/win32k.rbuild
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/subsystems/win32/win32k/win…
==============================================================================
--- trunk/reactos/subsystems/win32/win32k/win32k.rbuild (original)
+++ trunk/reactos/subsystems/win32/win32k/win32k.rbuild Wed Apr 5 12:05:55 2006
@@ -64,14 +64,15 @@
<file>err.c</file>
<file>math.c</file>
<file>copy.c</file>
+ <file>usrheap.c</file>
</compilationunit>
<directory name="i386">
- <file>cos_asm.s</file>
- <file>sin_asm.s</file>
- <file>atan2_asm.s</file>
- <file>floor_asm.s</file>
- <file>ceil_asm.s</file>
- </directory>
+ <file>cos_asm.s</file>
+ <file>sin_asm.s</file>
+ <file>atan2_asm.s</file>
+ <file>floor_asm.s</file>
+ <file>ceil_asm.s</file>
+ </directory>
</directory>
<directory name="ntddraw">
<compilationunit name="ntddraw.c">
Modified: trunk/reactos/tools/nci/w32ksvc.db
URL:
http://svn.reactos.ru/svn/reactos/trunk/reactos/tools/nci/w32ksvc.db?rev=21…
==============================================================================
--- trunk/reactos/tools/nci/w32ksvc.db (original)
+++ trunk/reactos/tools/nci/w32ksvc.db Wed Apr 5 12:05:55 2006
@@ -356,7 +356,7 @@
NtUserGetCapture 0
NtUserGetCaretBlinkTime 0
NtUserGetCaretPos 1
-NtUserGetClassInfo 5
+NtUserGetClassInfo 4
NtUserGetClassLong 3
NtUserGetClassName 3
NtUserGetClientOrigin 2
@@ -457,7 +457,7 @@
NtUserReleaseDC 2
NtUserRealChildWindowFromPoint 3
NtUserRedrawWindow 4
-NtUserRegisterClassExWOW 8
+NtUserRegisterClassEx 6
NtUserRegisterHotKey 4
NtUserRegisterTasklist 1
NtUserRegisterWindowMessage 1
@@ -536,7 +536,7 @@
NtUserUnhookWinEvent 1
NtUserUnloadKeyboardLayout 1
NtUserUnlockWindowStation 1
-NtUserUnregisterClass 3
+NtUserUnregisterClass 2
NtUserUnregisterHotKey 2
NtUserUpdateInputContext 3
NtUserUpdateInstance 3