}
PCALLPROC FASTCALL ValidateCallProc(HANDLE hCallProc);
-PWINDOW FASTCALL ValidateHwnd(HWND hwnd);
-PWINDOW FASTCALL ValidateHwndOrDesk(HWND hwnd);
-PWINDOW FASTCALL GetThreadDesktopWnd(VOID);
+PWND FASTCALL ValidateHwnd(HWND hwnd);
+PWND FASTCALL ValidateHwndOrDesk(HWND hwnd);
+PWND FASTCALL GetThreadDesktopWnd(VOID);
PVOID FASTCALL ValidateHandleNoErr(HANDLE handle, UINT uType);
-PWINDOW FASTCALL ValidateHwndNoErr(HWND hwnd);
+PWND FASTCALL ValidateHwndNoErr(HWND hwnd);
VOID FASTCALL GetConnected(VOID);
BOOL FASTCALL DefSetText(HWND hWnd, PCWSTR String, BOOL Ansi);
-BOOL FASTCALL TestWindowProcess(PWINDOW);
+BOOL FASTCALL TestWindowProcess(PWND);
void
UserGetFrameSize(ULONG Style, ULONG ExStyle, SIZE *Size);
void
-UserGetInsideRectNC(PWINDOW Wnd, RECT *rect);
+UserGetInsideRectNC(PWND Wnd, RECT *rect);
DWORD
SCROLL_HitTest( HWND hwnd, INT nBar, POINT pt, BOOL bDragging );
BOOL
FASTCALL
-TestWindowProcess(PWINDOW Wnd)
+TestWindowProcess(PWND Wnd)
{
if (Wnd->ti == (PW32THREADINFO)NtCurrentTeb()->Win32ThreadInfo)
return TRUE;
//
// Validate a window handle and return the pointer to the object.
//
-PWINDOW
+PWND
FASTCALL
ValidateHwnd(HWND hwnd)
{
- PWINDOW Wnd;
+ PWND Wnd;
PCLIENTINFO ClientInfo = GetWin32ClientInfo();
ASSERT(ClientInfo != NULL);
//
// Validate a window handle and return the pointer to the object.
//
-PWINDOW
+PWND
FASTCALL
ValidateHwndNoErr(HWND hwnd)
{
- PWINDOW Wnd;
+ PWND Wnd;
PCLIENTINFO ClientInfo = GetWin32ClientInfo();
ASSERT(ClientInfo != NULL);
return NULL;
}
-PWINDOW
+PWND
FASTCALL
GetThreadDesktopWnd(VOID)
{
- PWINDOW Wnd = GetThreadDesktopInfo()->Wnd;
+ PWND Wnd = GetThreadDesktopInfo()->Wnd;
if (Wnd != NULL)
Wnd = DesktopPtrToUser(Wnd);
return Wnd;
//
// Validate a window handle and return the pointer to the object.
//
-PWINDOW
+PWND
FASTCALL
ValidateHwndOrDesk(HWND hwnd)
{
DWORD WINAPI
GetClassLongA(HWND hWnd, int nIndex)
{
- PWINDOW Wnd;
- PWINDOWCLASS Class;
+ PWND Wnd;
+ PCLS Class;
ULONG_PTR Ret = 0;
TRACE("%p %d\n", hWnd, nIndex);
DWORD WINAPI
GetClassLongW ( HWND hWnd, int nIndex )
{
- PWINDOW Wnd;
- PWINDOWCLASS Class;
+ PWND Wnd;
+ PCLS Class;
ULONG_PTR Ret = 0;
TRACE("%p %d\n", hWnd, nIndex);
WINAPI
GetWindowLongA ( HWND hWnd, int nIndex )
{
- PWINDOW Wnd;
+ PWND Wnd;
Wnd = ValidateHwnd(hWnd);
if (Wnd == NULL)
WINAPI
GetWindowLongW(HWND hWnd, int nIndex)
{
- PWINDOW Wnd;
+ PWND Wnd;
Wnd = ValidateHwnd(hWnd);
if (Wnd == NULL)
}
void
-UserGetInsideRectNC(PWINDOW Wnd, RECT *rect)
+UserGetInsideRectNC(PWND Wnd, RECT *rect)
{
ULONG Style;
ULONG ExStyle;
}
static LONG
-DefWndStartSizeMove(HWND hWnd, PWINDOW Wnd, WPARAM wParam, POINT *capturePoint)
+DefWndStartSizeMove(HWND hWnd, PWND Wnd, WPARAM wParam, POINT *capturePoint)
{
LONG hittest = 0;
POINT pt;
DWORD dwPoint = GetMessagePos();
BOOL DragFullWindows = FALSE;
HWND hWndParent = NULL;
- PWINDOW Wnd;
+ PWND Wnd;
Wnd = ValidateHwnd(hwnd);
if (!Wnd)
case WM_QUERYUISTATE:
{
LRESULT Ret = 0;
- PWINDOW Wnd = ValidateHwnd(hWnd);
+ PWND Wnd = ValidateHwnd(hWnd);
if (Wnd != NULL)
{
if (Wnd->HideFocus)
BOOL AlwaysShowCues = FALSE;
WORD Action = LOWORD(wParam);
WORD Flags = HIWORD(wParam);
- PWINDOW Wnd;
+ PWND Wnd;
SystemParametersInfoW(SPI_GETKEYBOARDCUES, 0, &AlwaysShowCues, 0);
if (AlwaysShowCues)
{
/* We're a child window and we need to pass this message down until
we reach the root */
- hWnd = UserHMGetHandle((PWINDOW)DesktopPtrToUser(Wnd->spwndParent));
+ hWnd = UserHMGetHandle((PWND)DesktopPtrToUser(Wnd->spwndParent));
}
else
{
BOOL AlwaysShowCues = FALSE;
WORD Action = LOWORD(wParam);
WORD Flags = HIWORD(wParam);
- PWINDOW Wnd;
+ PWND Wnd;
SystemParametersInfoW(SPI_GETKEYBOARDCUES, 0, &AlwaysShowCues, 0);
if (AlwaysShowCues)
LPARAM lParam)
{
LRESULT Result = 0;
- PWINDOW Wnd;
+ PWND Wnd;
SPY_EnterMessage(SPY_DEFWNDPROC, hWnd, Msg, wParam, lParam);
switch (Msg)
LPARAM lParam)
{
LRESULT Result = 0;
- PWINDOW Wnd;
+ PWND Wnd;
SPY_EnterMessage(SPY_DEFWNDPROC, hWnd, Msg, wParam, lParam);
switch (Msg)
*/
DIALOGINFO * DIALOG_get_info( HWND hWnd, BOOL create )
{
- PWINDOW pWindow;
+ PWND pWindow;
DIALOGINFO* dlgInfo = (DIALOGINFO *)GetWindowLongPtrW( hWnd, DWLP_ROS_DIALOGINFO );
if(!dlgInfo && create)
PWCHAR Text;
BOOL flat_menu = FALSE;
int bkgnd;
- PWINDOW Wnd = ValidateHwnd(hWnd);
+ PWND Wnd = ValidateHwnd(hWnd);
if (!Wnd)
return;
static LRESULT WINAPI
-IntCallMessageProc(IN PWINDOW Wnd, IN HWND hWnd, IN UINT Msg, IN WPARAM wParam, IN LPARAM lParam, IN BOOL Ansi)
+IntCallMessageProc(IN PWND Wnd, IN HWND hWnd, IN UINT Msg, IN WPARAM wParam, IN LPARAM lParam, IN BOOL Ansi)
{
WNDPROC WndProc;
BOOL IsAnsi;
{
LRESULT Ret = 0;
MSG UnicodeMsg;
- PWINDOW Wnd;
+ PWND Wnd;
if (lpmsg->hwnd != NULL)
{
DispatchMessageW(CONST MSG *lpmsg)
{
LRESULT Ret = 0;
- PWINDOW Wnd;
+ PWND Wnd;
if (lpmsg->hwnd != NULL)
{
if (Wnd != HWND_BROADCAST && (Msg < WM_DDE_FIRST || Msg > WM_DDE_LAST))
{
- PWINDOW Window;
+ PWND Window;
PW32THREADINFO ti = GetW32ThreadInfo();
Window = ValidateHwnd(Wnd);
if (Wnd != HWND_BROADCAST && (Msg < WM_DDE_FIRST || Msg > WM_DDE_LAST))
{
- PWINDOW Window;
+ PWND Window;
PW32THREADINFO ti = GetW32ThreadInfo();
Window = ValidateHwnd(Wnd);
{
PLIST_ENTRY ListEntry, temp;
PPROPERTY Property;
- PWINDOW pWnd;
+ PWND pWnd;
int i;
pWnd = ValidateHwnd(hWnd);
HWND WINAPI
GetDesktopWindow(VOID)
{
- PWINDOW Wnd;
+ PWND Wnd;
HWND Ret = NULL;
_SEH2_TRY
GetAncestor(HWND hwnd, UINT gaFlags)
{
HWND Ret = NULL;
- PWINDOW Ancestor, Wnd;
+ PWND Ancestor, Wnd;
Wnd = ValidateHwnd(hwnd);
if (!Wnd)
BOOL WINAPI
GetClientRect(HWND hWnd, LPRECT lpRect)
{
- PWINDOW Wnd = ValidateHwnd(hWnd);
+ PWND Wnd = ValidateHwnd(hWnd);
if (Wnd != NULL)
{
HWND WINAPI
GetLastActivePopup(HWND hWnd)
{
- PWINDOW Wnd;
+ PWND Wnd;
HWND Ret = hWnd;
Wnd = ValidateHwnd(hWnd);
HWND WINAPI
GetParent(HWND hWnd)
{
- PWINDOW Wnd, WndParent;
+ PWND Wnd, WndParent;
HWND Ret = NULL;
Wnd = ValidateHwnd(hWnd);
GetWindow(HWND hWnd,
UINT uCmd)
{
- PWINDOW Wnd, FoundWnd;
+ PWND Wnd, FoundWnd;
HWND Ret = NULL;
Wnd = ValidateHwnd(hWnd);
GetWindowRect(HWND hWnd,
LPRECT lpRect)
{
- PWINDOW Wnd = ValidateHwnd(hWnd);
+ PWND Wnd = ValidateHwnd(hWnd);
if (Wnd != NULL)
{
int WINAPI
GetWindowTextA(HWND hWnd, LPSTR lpString, int nMaxCount)
{
- PWINDOW Wnd;
+ PWND Wnd;
PCWSTR Buffer;
INT Length = 0;
int WINAPI
GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount)
{
- PWINDOW Wnd;
+ PWND Wnd;
PCWSTR Buffer;
INT Length = 0;
{
DWORD Ret = 0;
PW32THREADINFO ti;
- PWINDOW pWnd = ValidateHwnd(hWnd);
+ PWND pWnd = ValidateHwnd(hWnd);
if (!pWnd) return Ret;
IsChild(HWND hWndParent,
HWND hWnd)
{
- PWINDOW WndParent, Wnd;
+ PWND WndParent, Wnd;
BOOL Ret = FALSE;
WndParent = ValidateHwnd(hWndParent);
BOOL WINAPI
IsIconic(HWND hWnd)
{
- PWINDOW Wnd = ValidateHwnd(hWnd);
+ PWND Wnd = ValidateHwnd(hWnd);
if (Wnd != NULL)
return (Wnd->style & WS_MINIMIZE) != 0;
BOOL WINAPI
IsWindow(HWND hWnd)
{
- PWINDOW Wnd = ValidateHwndNoErr(hWnd);
+ PWND Wnd = ValidateHwndNoErr(hWnd);
if (Wnd != NULL)
{
/* FIXME: If window is being destroyed return FALSE! */
BOOL WINAPI
IsWindowUnicode(HWND hWnd)
{
- PWINDOW Wnd = ValidateHwnd(hWnd);
+ PWND Wnd = ValidateHwnd(hWnd);
if (Wnd != NULL)
return Wnd->Unicode;
IsWindowVisible(HWND hWnd)
{
BOOL Ret = FALSE;
- PWINDOW Wnd = ValidateHwnd(hWnd);
+ PWND Wnd = ValidateHwnd(hWnd);
if (Wnd != NULL)
{
int WINAPI
MapWindowPoints(HWND hWndFrom, HWND hWndTo, LPPOINT lpPoints, UINT cPoints)
{
- PWINDOW FromWnd, ToWnd;
+ PWND FromWnd, ToWnd;
POINT Delta;
UINT i;
BOOL WINAPI
ScreenToClient(HWND hWnd, LPPOINT lpPoint)
{
- PWINDOW Wnd, DesktopWnd;
+ PWND Wnd, DesktopWnd;
Wnd = ValidateHwnd(hWnd);
if (!Wnd)
BOOL WINAPI
ClientToScreen(HWND hWnd, LPPOINT lpPoint)
{
- PWINDOW Wnd, DesktopWnd;
+ PWND Wnd, DesktopWnd;
Wnd = ValidateHwnd(hWnd);
if (!Wnd)
typedef struct _PROCESSINFO *PPROCESSINFO;
struct _W32THREADINFO;
-struct _WINDOW;
+struct _WND;
typedef struct _LARGE_UNICODE_STRING
{
HWND hTaskManWindow;
HWND hProgmanWindow;
HWND hShellWindow;
- struct _WINDOW *Wnd;
+ struct _WND *Wnd;
union
{
#define CSF_CACHEDSMICON 0x0040
#define CSF_WIN40COMPAT 0x0080
-typedef struct _WINDOWCLASS
+typedef struct _CLS
{
- struct _WINDOWCLASS *pclsNext;
+ struct _CLS *pclsNext;
RTL_ATOM atomClassName;
ATOM atomNVClassName;
DWORD fnid; // New ClassId
PSTR lpszClientAnsiMenuName;
PWSTR lpszClientUnicodeMenuName;
PCALLPROC spcpdFirst;
- struct _WINDOWCLASS *pclsBase;
- struct _WINDOWCLASS *pclsClone;
+ struct _CLS *pclsBase;
+ struct _CLS *pclsClone;
ULONG cWndReferenceCount;
UINT style;
WNDPROC lpfnWndProc;
UINT Global : 1; // CS_GLOBALCLASS
UINT MenuNameIsString : 1;
UINT NotUsed : 27;
-} WINDOWCLASS, *PWINDOWCLASS;
+} CLS, *PCLS;
// State Flags !Not Implemented!
#define WS_EX2_CONSOLEWINDOW 0X00000400
#define WS_EX2_CHILDNOACTIVATE 0X00000800
-typedef struct _WINDOW
+typedef struct _WND
{
USER_OBJHDR hdr; /* FIXME: Move out of the structure once new handle manager is implemented */
/* NOTE: This structure is located in the desktop heap and will
/* Handle of the module that created the window. */
HINSTANCE hModule;
DWORD fnid;
- struct _WINDOW *spwndNext;
- struct _WINDOW *spwndPrev;
- struct _WINDOW *spwndParent;
- struct _WINDOW *spwndChild;
- struct _WINDOW *spwndOwner;
+ struct _WND *spwndNext;
+ struct _WND *spwndPrev;
+ struct _WND *spwndParent;
+ struct _WND *spwndChild;
+ struct _WND *spwndOwner;
RECT rcWindow;
RECT rcClient;
WNDPROC lpfnWndProc;
};
/* Pointer to the window class. */
- PWINDOWCLASS pcls;
+ PCLS pcls;
HRGN hrgnUpdate;
/* Property list head.*/
LIST_ENTRY PropListHead;
/* Size of the extra data associated with the window. */
ULONG cbwndExtra;
HWND hWndLastActive;
- struct _WINDOW *spwndLastActive;
+ struct _WND *spwndLastActive;
//HIMC hImc; // Input context associated with this window.
LONG dwUserData;
//PACTIVATION_CONTEXT pActCtx;
//PD3DMATRIX pTransForm;
- struct _WINDOW *spwndClipboardListener;
+ struct _WND *spwndClipboardListener;
DWORD ExStyle2;
struct
UINT InternalPosInitialized : 1;
UINT HideFocus : 1; // WS_EX_UISTATEFOCUSRECTHIDDEN ?
UINT HideAccel : 1; // WS_EX_UISTATEKBACCELHIDDEN ?
-} WINDOW, *PWINDOW;
+} WND, *PWND;
typedef struct _PFNCLIENT
{
void FASTCALL
DestroyProcessClasses(PW32PROCESS Process );
-PWINDOWCLASS
-IntReferenceClass(IN OUT PWINDOWCLASS BaseClass,
- IN OUT PWINDOWCLASS *ClassLink,
+PCLS
+IntReferenceClass(IN OUT PCLS BaseClass,
+ IN OUT PCLS *ClassLink,
IN PDESKTOP Desktop);
VOID
-IntDereferenceClass(IN OUT PWINDOWCLASS Class,
+IntDereferenceClass(IN OUT PCLS Class,
IN PDESKTOPINFO Desktop,
IN PPROCESSINFO pi);
IN HINSTANCE hInstance);
ULONG_PTR
-UserGetClassLongPtr(IN PWINDOWCLASS Class,
+UserGetClassLongPtr(IN PCLS Class,
IN INT Index,
IN BOOL Ansi);
IntGetClassAtom(IN PUNICODE_STRING ClassName,
IN HINSTANCE hInstance OPTIONAL,
IN PPROCESSINFO pi OPTIONAL,
- OUT PWINDOWCLASS *BaseClass OPTIONAL,
- OUT PWINDOWCLASS **Link OPTIONAL);
+ OUT PCLS *BaseClass OPTIONAL,
+ OUT PCLS **Link OPTIONAL);
-PWINDOWCLASS
+PCLS
FASTCALL
IntCreateClass(IN CONST WNDCLASSEXW* lpwcx,
IN PUNICODE_STRING ClassName,
IN PPROCESSINFO pi);
PCALLPROC
-UserFindCallProc(IN PWINDOWCLASS Class,
+UserFindCallProc(IN PCLS Class,
IN WNDPROC WndProc,
IN BOOL bUnicode);
IN PREGISTER_SYSCLASS SystemClasses);
VOID
-UserAddCallProcToClass(IN OUT PWINDOWCLASS Class,
+UserAddCallProcToClass(IN OUT PCLS Class,
IN PCALLPROC CallProc);
BOOL
PWIN32HEAP pheapDesktop;
PSECTION_OBJECT DesktopHeapSection;
PDESKTOPINFO DesktopInfo;
- PWINDOW spwndMessage;
+ PWND spwndMessage;
} DESKTOP, *PDESKTOP;
extern PDESKTOP InputDesktop;
extern HDESK InputDesktopHandle;
-extern PWINDOWCLASS DesktopWindowClass;
+extern PCLS DesktopWindowClass;
extern HDC ScreenDeviceContext;
extern BOOL g_PaintDesktopVersion;
W32PROCESS XzyxW32Process; /* Place holder. */
/* ReactOS */
HINSTANCE hModUser;
- PWINDOWCLASS LocalClassList;
- PWINDOWCLASS GlobalClassList;
- PWINDOWCLASS SystemClassList;
+ PCLS LocalClassList;
+ PCLS GlobalClassList;
+ PCLS SystemClassList;
UINT RegisteredSysClasses : 1;
extern ATOM AtomMessage;
-BOOL FASTCALL UserUpdateUiState(PWINDOW Wnd, WPARAM wParam);
+BOOL FASTCALL UserUpdateUiState(PWND Wnd, WPARAM wParam);
typedef struct _WINDOW_OBJECT
{
is a pointer to the WINDOW structure that eventually replaces
the WINDOW_OBJECT structure! USER32 expects this pointer to
be here until WINDOW_OBJECT has completely been superseded! */
- PWINDOW Wnd;
+ PWND Wnd;
/* Pointer to the thread information */
PW32THREADINFO ti;
VOID FASTCALL IntNotifyWinEvent(DWORD, HWND, LONG, LONG);
-PWINDOW APIENTRY co_IntCreateWindowEx(DWORD,PUNICODE_STRING,PUNICODE_STRING,DWORD,LONG,LONG,LONG,LONG,HWND,HMENU,HINSTANCE,LPVOID,DWORD,BOOL);
+PWND APIENTRY co_IntCreateWindowEx(DWORD,PUNICODE_STRING,PUNICODE_STRING,DWORD,LONG,LONG,LONG,LONG,HWND,HMENU,HINSTANCE,LPVOID,DWORD,BOOL);
#endif /* _WIN32K_WINDOW_H */
/* EOF */
/* WINDOWCLASS ***************************************************************/
static VOID
-IntFreeClassMenuName(IN OUT PWINDOWCLASS Class)
+IntFreeClassMenuName(IN OUT PCLS Class)
{
/* free the menu name, if it was changed and allocated */
if (Class->MenuName != NULL && Class->MenuNameIsString)
}
static VOID
-IntDestroyClass(IN OUT PWINDOWCLASS Class)
+IntDestroyClass(IN OUT PCLS Class)
{
/* there shouldn't be any clones anymore */
ASSERT(Class->cWndReferenceCount == 0);
/* clean all process classes. all process windows must cleaned first!! */
void FASTCALL DestroyProcessClasses(PW32PROCESS Process )
{
- PWINDOWCLASS Class;
+ PCLS Class;
PPROCESSINFO pi = (PPROCESSINFO)Process;
if (pi != NULL)
}
PCALLPROC
-UserFindCallProc(IN PWINDOWCLASS Class,
+UserFindCallProc(IN PCLS Class,
IN WNDPROC WndProc,
IN BOOL bUnicode)
{
}
VOID
-UserAddCallProcToClass(IN OUT PWINDOWCLASS Class,
+UserAddCallProcToClass(IN OUT PCLS Class,
IN PCALLPROC CallProc)
{
- PWINDOWCLASS BaseClass;
+ PCLS BaseClass;
ASSERT(CallProc->Next == NULL);
}
static BOOL
-IntSetClassAtom(IN OUT PWINDOWCLASS Class,
+IntSetClassAtom(IN OUT PCLS Class,
IN PUNICODE_STRING ClassName)
{
RTL_ATOM Atom = (RTL_ATOM)0;
}
static WNDPROC
-IntGetClassWndProc(IN PWINDOWCLASS Class,
+IntGetClassWndProc(IN PCLS Class,
IN PPROCESSINFO pi,
IN BOOL Ansi)
{
}
else
{
- PWINDOWCLASS BaseClass;
+ PCLS BaseClass;
/* make sure the call procedures are located on the desktop
of the base class! */
}
static WNDPROC
-IntSetClassWndProc(IN OUT PWINDOWCLASS Class,
+IntSetClassWndProc(IN OUT PCLS Class,
IN WNDPROC WndProc,
IN BOOL Ansi)
{
return Ret;
}
-static PWINDOWCLASS
-IntGetClassForDesktop(IN OUT PWINDOWCLASS BaseClass,
- IN OUT PWINDOWCLASS *ClassLink,
+static PCLS
+IntGetClassForDesktop(IN OUT PCLS BaseClass,
+ IN OUT PCLS *ClassLink,
IN PDESKTOP Desktop)
{
SIZE_T ClassSize;
- PWINDOWCLASS Class;
+ PCLS Class;
ASSERT(Desktop != NULL);
ASSERT(BaseClass->pclsBase == BaseClass);
return Class;
}
-PWINDOWCLASS
-IntReferenceClass(IN OUT PWINDOWCLASS BaseClass,
- IN OUT PWINDOWCLASS *ClassLink,
+PCLS
+IntReferenceClass(IN OUT PCLS BaseClass,
+ IN OUT PCLS *ClassLink,
IN PDESKTOP Desktop)
{
- PWINDOWCLASS Class;
+ PCLS Class;
ASSERT(BaseClass->pclsBase == BaseClass);
}
static VOID
-IntMakeCloneBaseClass(IN OUT PWINDOWCLASS Class,
- IN OUT PWINDOWCLASS *BaseClassLink,
- IN OUT PWINDOWCLASS *CloneLink)
+IntMakeCloneBaseClass(IN OUT PCLS Class,
+ IN OUT PCLS *BaseClassLink,
+ IN OUT PCLS *CloneLink)
{
- PWINDOWCLASS Clone, BaseClass;
+ PCLS Clone, BaseClass;
ASSERT(Class->pclsBase != Class);
ASSERT(Class->pclsBase->pclsClone != NULL);
}
VOID
-IntDereferenceClass(IN OUT PWINDOWCLASS Class,
+IntDereferenceClass(IN OUT PCLS Class,
IN PDESKTOPINFO Desktop,
IN PPROCESSINFO pi)
{
- PWINDOWCLASS *PrevLink, BaseClass, CurrentClass;
+ PCLS *PrevLink, BaseClass, CurrentClass;
BaseClass = Class->pclsBase;
}
static BOOL
-IntMoveClassToSharedHeap(IN OUT PWINDOWCLASS Class,
- IN OUT PWINDOWCLASS **ClassLinkPtr)
+IntMoveClassToSharedHeap(IN OUT PCLS Class,
+ IN OUT PCLS **ClassLinkPtr)
{
- PWINDOWCLASS NewClass;
+ PCLS NewClass;
SIZE_T ClassSize;
ASSERT(Class->pclsBase == Class);
static VOID
IntCheckDesktopClasses(IN PDESKTOP Desktop,
- IN OUT PWINDOWCLASS *ClassList,
+ IN OUT PCLS *ClassList,
IN BOOL FreeOnFailure,
OUT BOOL *Ret)
{
- PWINDOWCLASS Class, NextClass, *Link;
+ PCLS Class, NextClass, *Link;
/* NOTE: We only need to check base classes! When classes are no longer needed
on a desktop, the clones will be freed automatically as soon as possible.
return Ret;
}
-PWINDOWCLASS
+PCLS
FASTCALL
IntCreateClass(IN CONST WNDCLASSEXW* lpwcx,
IN PUNICODE_STRING ClassName,
IN PPROCESSINFO pi)
{
SIZE_T ClassSize;
- PWINDOWCLASS Class = NULL;
+ PCLS Class = NULL;
RTL_ATOM Atom;
PWSTR pszMenuName = NULL;
NTSTATUS Status = STATUS_SUCCESS;
return Class;
}
-static PWINDOWCLASS
+static PCLS
IntFindClass(IN RTL_ATOM Atom,
IN HINSTANCE hInstance,
- IN PWINDOWCLASS *ClassList,
- OUT PWINDOWCLASS **Link OPTIONAL)
+ IN PCLS *ClassList,
+ OUT PCLS **Link OPTIONAL)
{
- PWINDOWCLASS Class, *PrevLink = ClassList;
+ PCLS Class, *PrevLink = ClassList;
Class = *PrevLink;
while (Class != NULL)
IntGetClassAtom(IN PUNICODE_STRING ClassName,
IN HINSTANCE hInstance OPTIONAL,
IN PPROCESSINFO pi OPTIONAL,
- OUT PWINDOWCLASS *BaseClass OPTIONAL,
- OUT PWINDOWCLASS **Link OPTIONAL)
+ OUT PCLS *BaseClass OPTIONAL,
+ OUT PCLS **Link OPTIONAL)
{
RTL_ATOM Atom = (RTL_ATOM)0;
&Atom) &&
Atom != (RTL_ATOM)0)
{
- PWINDOWCLASS Class;
+ PCLS Class;
/* attempt to locate the class object */
PTHREADINFO pti;
PW32THREADINFO ti;
PPROCESSINFO pi;
- PWINDOWCLASS Class;
+ PCLS Class;
RTL_ATOM ClassAtom;
RTL_ATOM Ret = (RTL_ATOM)0;
if (Class != NULL)
{
- PWINDOWCLASS *List;
+ PCLS *List;
/* Register the class */
if (Class->System)
UserUnregisterClass(IN PUNICODE_STRING ClassName,
IN HINSTANCE hInstance)
{
- PWINDOWCLASS *Link;
+ PCLS *Link;
PPROCESSINFO pi;
RTL_ATOM ClassAtom;
- PWINDOWCLASS Class;
+ PCLS Class;
pi = GetW32ProcessInfo();
if (pi == NULL)
}
INT
-UserGetClassName(IN PWINDOWCLASS Class,
+UserGetClassName(IN PCLS Class,
IN OUT PUNICODE_STRING ClassName,
IN BOOL Ansi)
{
}
ULONG_PTR
-UserGetClassLongPtr(IN PWINDOWCLASS Class,
+UserGetClassLongPtr(IN PCLS Class,
IN INT Index,
IN BOOL Ansi)
{
}
static BOOL
-IntSetClassMenuName(IN PWINDOWCLASS Class,
+IntSetClassMenuName(IN PCLS Class,
IN PUNICODE_STRING MenuName)
{
BOOL Ret = FALSE;
}
ULONG_PTR
-UserSetClassLongPtr(IN PWINDOWCLASS Class,
+UserSetClassLongPtr(IN PCLS Class,
IN INT Index,
IN ULONG_PTR NewLong,
IN BOOL Ansi)
}
static BOOL
-UserGetClassInfo(IN PWINDOWCLASS Class,
+UserGetClassInfo(IN PCLS Class,
OUT PWNDCLASSEXW lpwcx,
IN BOOL Ansi,
HINSTANCE hInstance)
UNICODE_STRING ClassName, MenuName;
PPROCESSINFO pi = GetW32ProcessInfo();
WNDCLASSEXW wc;
- PWINDOWCLASS Class;
+ PCLS Class;
BOOL Ret = TRUE;
if (pi->RegisteredSysClasses || pi->hModUser == NULL)
CapturedClassInfo.cbClsExtra +
CapturedName.Length +
CapturedMenuName.Length +
- sizeof(WINDOWCLASS) < CapturedClassInfo.cbClsExtra ||
+ sizeof(CLS) < CapturedClassInfo.cbClsExtra ||
CapturedClassInfo.cbWndExtra < 0 ||
CapturedClassInfo.hInstance == NULL)
{
BOOL Ansi)
{
UNICODE_STRING CapturedClassName;
- PWINDOWCLASS Class;
+ PCLS Class;
RTL_ATOM ClassAtom;
PPROCESSINFO pi;
BOOL Ret = FALSE;
LPARAM lParam,
BOOL Ansi)
{
- PWINDOW Wnd;
+ PWND Wnd;
LRESULT lResult = 0;
if (Msg > WM_USER) return 0;
#else
PWINDOW_OBJECT DesktopWindow;
- PWINDOW DesktopWnd;
+ PWND DesktopWnd;
DesktopWindow = IntGetWindowObject(Desktop->DesktopWindow);
if (! DesktopWindow)
UNICODE_STRING ClassName, WindowName, MenuName;
PPROCESSINFO pi = GetW32ProcessInfo();
WNDCLASSEXW wc;
- PWINDOWCLASS Class;
- PWINDOW pWnd;
+ PCLS Class;
+ PWND pWnd;
DECLARE_RETURN(HDESK);
DPRINT("Enter NtUserCreateDesktop: %wZ\n", lpszDesktopName);
HWND hWndFocus = FocusWindow->hSelf;
HWND hWndFocusPrev = NULL;
PUSER_MESSAGE_QUEUE PrevForegroundQueue;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
HWND Top;
PWINDOW_OBJECT TopWindow;
USER_REFERENCE_ENTRY Ref;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
PUSER_MESSAGE_QUEUE ThreadQueue;
HWND hWndPrev;
HWND hWnd = 0;
- PWINDOW Wnd;
+ PWND Wnd;
CBTACTIVATESTRUCT cbt;
if (Window)
HWND hWndPrev;
PWINDOW_OBJECT TopWnd;
USER_REFERENCE_ENTRY Ref;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
IntIntersectWithParents(PWINDOW_OBJECT Child, RECTL *WindowRect)
{
PWINDOW_OBJECT ParentWindow;
- PWINDOW ParentWnd;
+ PWND ParentWnd;
ParentWindow = Child->Parent;
while (ParentWindow != NULL)
IntValidateParent(PWINDOW_OBJECT Child, HRGN hValidateRgn, BOOL Recurse)
{
PWINDOW_OBJECT ParentWindow = Child->Parent;
- PWINDOW ParentWnd;
+ PWND ParentWnd;
while (ParentWindow)
{
HRGN FASTCALL
IntCalcWindowRgn(PWINDOW_OBJECT Window, BOOL Client)
{
- PWINDOW Wnd;
+ PWND Wnd;
HRGN hRgnWindow;
UINT RgnType;
HDC hDC;
HWND hWnd = Window->hSelf;
HRGN TempRegion;
- PWINDOW Wnd;
+ PWND Wnd;
Wnd = Window->Wnd;
IntInvalidateWindows(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags)
{
INT RgnType;
- PWINDOW Wnd;
+ PWND Wnd;
BOOL HadPaintMessage, HadNCPaintMessage;
BOOL HasPaintMessage, HasNCPaintMessage;
IntIsWindowDrawable(PWINDOW_OBJECT Window)
{
PWINDOW_OBJECT WndObject;
- PWINDOW Wnd;
+ PWND Wnd;
for (WndObject = Window; WndObject != NULL; WndObject = WndObject->Parent)
{
BOOL FASTCALL
IntIsWindowDirty(PWINDOW_OBJECT Window)
{
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
return (Wnd->style & WS_VISIBLE) &&
((Window->UpdateRegion != NULL) ||
(Window->Flags & WINDOWOBJECT_NEED_INTERNALPAINT) ||
{
HWND hChild;
PWINDOW_OBJECT TempWindow;
- PWINDOW Wnd, TempWnd;
+ PWND Wnd, TempWnd;
for (; Window != NULL; Window = Window->NextSibling)
{
NTSTATUS Status;
DECLARE_RETURN(HDC);
USER_REFERENCE_ENTRY Ref;
- PWINDOW Wnd;
+ PWND Wnd;
DPRINT("Enter NtUserBeginPaint\n");
UserEnterExclusive();
RECTL r = *lpRc;
LONG ButtonWidth, IconWidth;
BOOL HasIcon;
- PWINDOW Wnd = NULL;
+ PWND Wnd = NULL;
//ASSERT(pWnd != NULL);
IntGetScrollBarRect (PWINDOW_OBJECT Window, INT nBar, RECTL *lprect)
{
BOOL vertical;
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
RECTL ClientRect = Window->Wnd->rcClient;
RECTL WindowRect = Window->Wnd->rcWindow;
BOOL FASTCALL
IntCalculateThumb(PWINDOW_OBJECT Window, LONG idObject, PSCROLLBARINFO psbi, LPSCROLLINFO psi)
{
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
INT Thumb, ThumbBox, ThumbPos, cxy, mx;
RECTL ClientRect;
co_UserShowScrollBar(PWINDOW_OBJECT Window, int wBar, DWORD bShow)
{
DWORD Style, OldStyle;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
{
BOOL Ret = 0;
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
USER_REFERENCE_ENTRY Ref;
DECLARE_RETURN(BOOLEAN);
{
HRGN VisRgn, ClipRgn;
PWINDOW_OBJECT PreviousWindow, CurrentWindow, CurrentSibling;
- PWINDOW Wnd, CurrentWnd, PreviousWnd, CurrentSiblingWnd;
+ PWND Wnd, CurrentWnd, PreviousWnd, CurrentSiblingWnd;
Wnd = Window->Wnd;
HRGN Temp;
PWINDOW_OBJECT Parent;
USER_REFERENCE_ENTRY Ref;
- PWINDOW Wnd, ParentWnd;
+ PWND Wnd, ParentWnd;
ASSERT_REFS_CO(Window);
DceAllocDCE(PWINDOW_OBJECT Window OPTIONAL, DCE_TYPE Type)
{
PDCE pDce;
- PWINDOW Wnd = NULL;
+ PWND Wnd = NULL;
if (Window) Wnd = Window->Wnd;
DceSetDrawable(PWINDOW_OBJECT Window OPTIONAL, HDC hDC, ULONG Flags,
BOOL SetClipOrigin)
{
- PWINDOW Wnd;
+ PWND Wnd;
DC *dc = DC_LockDc(hDC);
if(!dc)
return;
if (Flags & DCX_PARENTCLIP)
{
PWINDOW_OBJECT Parent;
- PWINDOW ParentWnd;
+ PWND ParentWnd;
Parent = Window->Parent;
if(!Parent)
DCE* Dce = NULL;
BOOL UpdateVisRgn = TRUE;
BOOL UpdateClipOrigin = FALSE;
- PWINDOW Wnd = NULL;
+ PWND Wnd = NULL;
HDC hDC = NULL;
if (NULL == Window)
/* HELPER FUNCTIONS ***********************************************************/
-BOOL FASTCALL UserUpdateUiState(PWINDOW Wnd, WPARAM wParam)
+BOOL FASTCALL UserUpdateUiState(PWND Wnd, WPARAM wParam)
{
WORD Action = LOWORD(wParam);
WORD Flags = HIWORD(wParam);
UserFreeWindowInfo(PW32THREADINFO ti, PWINDOW_OBJECT WindowObject)
{
PCLIENTINFO ClientInfo = GetWin32ClientInfo();
- PWINDOW Wnd = WindowObject->Wnd;
+ PWND Wnd = WindowObject->Wnd;
if (ClientInfo->CallbackWnd.pvWnd == DesktopHeapAddressToUser(WindowObject->Wnd))
{
PWINDOW_OBJECT Child;
PMENU_OBJECT Menu;
BOOLEAN BelongsToThreadData;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT(Window);
VOID FASTCALL
IntGetWindowBorderMeasures(PWINDOW_OBJECT Window, UINT *cx, UINT *cy)
{
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
if(HAS_DLGFRAME(Wnd->style, Wnd->ExStyle) && !(Wnd->style & WS_MINIMIZE))
{
*cx = UserGetSystemMetrics(SM_CXDLGFRAME);
IntGetWindowProc(IN PWINDOW_OBJECT Window,
IN BOOL Ansi)
{
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
ASSERT(UserIsEnteredExclusive() == TRUE);
BOOL FASTCALL
IntGetWindowInfo(PWINDOW_OBJECT Window, PWINDOWINFO pwi)
{
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
pwi->cbSize = sizeof(WINDOWINFO);
pwi->rcWindow = Window->Wnd->rcWindow;
BOOL *Changed)
{
PMENU_OBJECT OldMenu, NewMenu = NULL;
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
if ((Wnd->style & (WS_CHILD | WS_POPUP)) == WS_CHILD)
{
IntIsChildWindow(PWINDOW_OBJECT Parent, PWINDOW_OBJECT BaseWindow)
{
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
Window = BaseWindow;
while (Window)
IntIsWindowVisible(PWINDOW_OBJECT BaseWindow)
{
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
Window = BaseWindow;
while(Window)
FASTCALL
IntGetWindowPlacement(PWINDOW_OBJECT Window, WINDOWPLACEMENT *lpwndpl)
{
- PWINDOW Wnd;
+ PWND Wnd;
POINT Size;
Wnd = Window->Wnd;
for(phWnd = List; *phWnd; phWnd++)
{
PWINDOW_OBJECT Child;
- PWINDOW ChildWnd;
+ PWND ChildWnd;
if((Child = UserGetWindowObject(*phWnd)))
{
ChildWnd = Child->Wnd;
/*
* @implemented
*/
-PWINDOW APIENTRY
+PWND APIENTRY
co_IntCreateWindowEx(DWORD dwExStyle,
PUNICODE_STRING ClassName,
PUNICODE_STRING WindowName,
BOOL bUnicodeWindow)
{
PWINSTATION_OBJECT WinSta;
- PWINDOW Wnd = NULL;
- PWINDOWCLASS *ClassLink, Class = NULL;
+ PWND Wnd = NULL;
+ PCLS *ClassLink, Class = NULL;
RTL_ATOM ClassAtom;
PWINDOW_OBJECT Window = NULL;
PWINDOW_OBJECT ParentWindow = NULL, OwnerWindow;
CBT_CREATEWNDW CbtCreate;
LRESULT Result;
BOOL MenuChanged;
- DECLARE_RETURN(PWINDOW);
+ DECLARE_RETURN(PWND);
BOOL HasOwner;
USER_REFERENCE_ENTRY ParentRef, Ref;
PTHREADINFO pti;
else if ((dwStyle & (WS_CHILD | WS_POPUP)) == WS_CHILD)
{
SetLastWin32Error(ERROR_TLW_WITH_WSCHILD);
- RETURN( (PWINDOW)0); /* WS_CHILD needs a parent, but WS_POPUP doesn't */
+ RETURN( (PWND)0); /* WS_CHILD needs a parent, but WS_POPUP doesn't */
}
if (ParentWindowHandle)
if (ti == NULL || pti->Desktop == NULL)
{
DPRINT1("Thread is not attached to a desktop! Cannot create window!\n");
- RETURN( (PWINDOW)0);
+ RETURN( (PWND)0);
}
/* Check the class. */
}
SetLastWin32Error(ERROR_CANNOT_FIND_WND_CLASS);
- RETURN((PWINDOW)0);
+ RETURN((PWND)0);
}
Class = IntReferenceClass(Class,
if (Window)
{
Window->Wnd = DesktopHeapAlloc(pti->Desktop,
- sizeof(WINDOW) + Class->cbwndExtra);
+ sizeof(WND) + Class->cbwndExtra);
if (!Window->Wnd)
goto AllocErr;
RtlZeroMemory(Window->Wnd,
- sizeof(WINDOW) + Class->cbwndExtra);
+ sizeof(WND) + Class->cbwndExtra);
Window->Wnd->hdr.Handle = hWnd; /* FIXME: Remove hack , are you sure?*/
Wnd = Window->Wnd;
AllocErr:
ObDereferenceObject(WinSta);
SetLastNtError(STATUS_INSUFFICIENT_RESOURCES);
- RETURN( (PWINDOW)0);
+ RETURN( (PWND)0);
}
UserRefObjectCo(Window, &Ref);
if (Wnd->strName.Buffer == NULL)
{
SetLastNtError(STATUS_INSUFFICIENT_RESOURCES);
- RETURN( (PWINDOW)0);
+ RETURN( (PWND)0);
}
Wnd->strName.Buffer[WindowName->Length / sizeof(WCHAR)] = L'\0';
/* FIXME - Delete window object and remove it from the thread windows list */
/* FIXME - delete allocated DCE */
DPRINT1("CBT-hook returned !0\n");
- RETURN( (PWINDOW) NULL);
+ RETURN( (PWND) NULL);
}
}
x = Cs.x;
{
/* FIXME: Cleanup. */
DPRINT1("IntCreateWindowEx(): NCCREATE message failed. No cleanup performed!\n");
- RETURN((PWINDOW)0);
+ RETURN((PWND)0);
}
/* Calculate the non-client size. */
/* FIXME: Cleanup. */
DPRINT1("IntCreateWindowEx(): send CREATE message failed. No cleanup performed!\n");
IntUnlinkWindow(Window);
- RETURN((PWINDOW)0);
+ RETURN((PWND)0);
}
IntNotifyWinEvent(EVENT_OBJECT_CREATE, Window->hSelf, OBJID_WINDOW, 0);
UNICODE_STRING WindowName;
UNICODE_STRING ClassName;
HWND NewWindow = NULL;
- PWINDOW pNewWindow;
+ PWND pNewWindow;
DECLARE_RETURN(HWND);
DPRINT("Enter NtUserCreateWindowEx(): (%d,%d-%d,%d)\n", x, y, nWidth, nHeight);
BOOLEAN FASTCALL co_UserDestroyWindow(PWINDOW_OBJECT Window)
{
BOOLEAN isChild;
- PWINDOW Wnd;
+ PWND Wnd;
HWND hWnd;
ASSERT_REFS_CO(Window); // FIXME: temp hack?
LPPOINT ptIcon)
{
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
DWORD Ret = 0;
BOOL Hit = FALSE;
WINDOWPLACEMENT wndpl;
UserGetWindowLong(HWND hWnd, DWORD Index, BOOL Ansi)
{
PWINDOW_OBJECT Window, Parent;
- PWINDOW Wnd;
+ PWND Wnd;
LONG Result = 0;
DPRINT("NtUserGetWindowLong(%x,%d,%d)\n", hWnd, (INT)Index, Ansi);
{
WNDPROC Ret;
PCALLPROC CallProc;
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
/* resolve any callproc handle if possible */
if (IsCallProcHandle(NewWndProc))
co_UserSetWindowLong(HWND hWnd, DWORD Index, LONG NewValue, BOOL Ansi)
{
PWINDOW_OBJECT Window, Parent;
- PWINDOW Wnd;
+ PWND Wnd;
PWINSTATION_OBJECT WindowStation;
LONG OldValue;
STYLESTRUCT Style;
WINDOWPLACEMENT *lpwndpl)
{
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
POINT Size;
WINDOWPLACEMENT Safepl;
NTSTATUS Status;
WORD fnID)
{
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
DECLARE_RETURN(BOOL);
DPRINT("Enter NtUserSetWindowFNID\n");
WINDOWPLACEMENT *lpwndpl)
{
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
WINDOWPLACEMENT Safepl;
NTSTATUS Status;
DECLARE_RETURN(BOOL);
INT Ret;
HRGN VisRgn;
ROSRGNDATA *pRgn;
- PWINDOW Wnd;
+ PWND Wnd;
if(!Window)
{
INT Ret;
HRGN VisRgn;
ROSRGNDATA *pRgn;
- PWINDOW Wnd;
+ PWND Wnd;
if(!Window)
{
NtUserDefSetText(HWND hWnd, PLARGE_STRING WindowText)
{
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
LARGE_STRING SafeText;
UNICODE_STRING UnicodeString;
BOOL Ret = TRUE;
NtUserInternalGetWindowText(HWND hWnd, LPWSTR lpString, INT nMaxCount)
{
PWINDOW_OBJECT Window;
- PWINDOW Wnd;
+ PWND Wnd;
NTSTATUS Status;
INT Result;
DECLARE_RETURN(INT);
PWINDOW_OBJECT WndTo = NULL;
HWND Fg;
USER_REFERENCE_ENTRY Ref;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
for( i = 0; List[i]; i++)
{
PWINDOW_OBJECT WndChild;
- PWINDOW ChildWnd;
+ PWND ChildWnd;
if (!(WndChild = UserGetWindowObject(List[i])))
continue;
{
PWINDOW_OBJECT Parent;
UINT XInc, YInc;
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
if (!Wnd->InternalPosInitialized)
{
{
POINT Size;
UINT SwpFlags = 0;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
Wnd = Window->Wnd;
{
PWINDOW_OBJECT Parent;
UINT wvrFlags = 0;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
Wnd = Window->Wnd;
PRECTL ClientRect)
{
INT X, Y;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
Wnd = Window->Wnd;
BOOL FASTCALL
WinPosFixupFlags(WINDOWPOS *WinPos, PWINDOW_OBJECT Window)
{
- PWINDOW Wnd = Window->Wnd;
+ PWND Wnd = Window->Wnd;
if (!Wnd) return FALSE;
RECTL NewPos;
BOOLEAN ShowFlag;
// HRGN VisibleRgn;
- PWINDOW Wnd;
+ PWND Wnd;
ASSERT_REFS_CO(Window);
Wnd = Window->Wnd;
)
{
PWINDOW_OBJECT Current;
- PWINDOW CurrentWnd;
+ PWND CurrentWnd;
HWND *List, *phWnd;
USER_REFERENCE_ENTRY Ref;
{
POINT Size;
PWINDOW_OBJECT Window = NULL;
- PWINDOW Wnd;
+ PWND Wnd;
MINMAXINFO SafeMinMax;
NTSTATUS Status;
BOOL ret;
projects / reactos.git / commitdiff