Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 22:02:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

win32k RECT/RECTL issues:

Browse source 
- Although RECT and RECTL are defined equal, the compiler treats them as incompatible. MS has created a lot of definitions with RECT and a lot with RECTL. So far we had to typecast them. Now with adding some defines into a win32k header file, we can finally treat them as equal inside win32k and get rid of a lot of type casts. Also use RECTL in favour of RECT internally, as this is the type that MS uses for the DDI and seems to be the more appropriate type.
- We had a lot of "const PRECT" stuff inside win32k. Note: there's difference between "const RECT *" (what you currently want) and "CONST PRECT" (which you proabably don't want). Despite the fact that CONST is not an official modifier (please stick to const) the main difference is that the former describes a pointer to a constant structure, while the latter describes a constant pointer to a modifyable structure.
- In an attempt to clean up the overpolluted IntGdi namespace, "objectify" the rect functions, moving them into their own namespace RECTL_Xxx.

svn path=/trunk/; revision=40100
This commit is contained in:
Timo Kreuzer 2009-03-19 01:42:34 +00:00
parent ee6542397d
commit 8d620098f5
33 changed files with 401 additions and 410 deletions
Download patch file Download diff file Expand all files Collapse all files

20
reactos/subsystems/win32/win32k/eng/clip.c
View file

@ -34,8 +34,8 @@
static __inline int static __inline int
CompareRightDown( CompareRightDown(
const PRECT r1, const RECTL *r1,
const PRECT r2) const RECTL *r2)
{ {
int Cmp; int Cmp;
@ -70,8 +70,8 @@ CompareRightDown(
static __inline int static __inline int
CompareRightUp( CompareRightUp(
const PRECT r1, const RECTL *r1,
const PRECT r2) const RECTL *r2)
{ {
int Cmp; int Cmp;
@ -106,8 +106,8 @@ CompareRightUp(
static __inline int static __inline int
CompareLeftDown( CompareLeftDown(
const PRECT r1, const RECTL *r1,
const PRECT r2) const RECTL *r2)
{ {
int Cmp; int Cmp;
@ -142,8 +142,8 @@ CompareLeftDown(
static __inline int static __inline int
CompareLeftUp( CompareLeftUp(
const PRECT r1, const RECTL *r1,
const PRECT r2) const RECTL *r2)
{ {
int Cmp; int Cmp;
@ -177,8 +177,8 @@ CompareLeftUp(
static __inline int static __inline int
CompareSpans( CompareSpans(
const PSPAN Span1, const SPAN *Span1,
const PSPAN Span2) const SPAN *Span2)
{ {
int Cmp; int Cmp;

8
reactos/subsystems/win32/win32k/eng/engwindow.c
View file

@ -91,8 +91,8 @@ IntEngWndUpdateClipObj(
{ {
if (visRgn->rdh.nCount > 0) if (visRgn->rdh.nCount > 0)
{ {
ClipObj = IntEngCreateClipRegion(visRgn->rdh.nCount, (PRECTL)visRgn->Buffer, ClipObj = IntEngCreateClipRegion(visRgn->rdh.nCount, visRgn->Buffer,
(PRECTL)&visRgn->rdh.rcBound); &visRgn->rdh.rcBound);
DPRINT("Created visible region with %d rects\n", visRgn->rdh.nCount); DPRINT("Created visible region with %d rects\n", visRgn->rdh.nCount);
DPRINT(" BoundingRect: %d, %d %d, %d\n", DPRINT(" BoundingRect: %d, %d %d, %d\n",
visRgn->rdh.rcBound.left, visRgn->rdh.rcBound.top, visRgn->rdh.rcBound.left, visRgn->rdh.rcBound.top,
@ -122,8 +122,8 @@ IntEngWndUpdateClipObj(
if (ClipObj == NULL) if (ClipObj == NULL)
{ {
/* Fall back to client rect */ /* Fall back to client rect */
ClipObj = IntEngCreateClipRegion(1, (PRECTL)&Window->Wnd->ClientRect, ClipObj = IntEngCreateClipRegion(1, &Window->Wnd->ClientRect,
(PRECTL)&Window->Wnd->ClientRect); &Window->Wnd->ClientRect);
} }
if (ClipObj == NULL) if (ClipObj == NULL)

21
reactos/subsystems/win32/win32k/eng/gradient.c
View file

@ -43,11 +43,6 @@ const LONG LINC[2] = {-1, 1};
#define VCMPCLRS(a,b,c) \ #define VCMPCLRS(a,b,c) \
!(!VCMPCLR(a,b,c,Red) || !VCMPCLR(a,b,c,Green) || !VCMPCLR(a,b,c,Blue)) !(!VCMPCLR(a,b,c,Red) || !VCMPCLR(a,b,c,Green) || !VCMPCLR(a,b,c,Blue))
#define MOVERECT(r,x,y) \
r.left += x; r.right += x; \
r.top += y; r.bottom += y
/* Horizontal/Vertical gradients */ /* Horizontal/Vertical gradients */
#define HVINITCOL(Col, id) \ #define HVINITCOL(Col, id) \
c[id] = v1->Col >> 8; \ c[id] = v1->Col >> 8; \
@ -94,7 +89,7 @@ IntEngGradientFillRect(
rcGradient.top = min(v1->y, v2->y); rcGradient.top = min(v1->y, v2->y);
rcGradient.bottom = max(v1->y, v2->y); rcGradient.bottom = max(v1->y, v2->y);
rcSG = rcGradient; rcSG = rcGradient;
MOVERECT(rcSG, pptlDitherOrg->x, pptlDitherOrg->y); RECTL_vOffsetRect(&rcSG, pptlDitherOrg->x, pptlDitherOrg->y);
if(Horizontal) if(Horizontal)
{ {
@ -115,7 +110,7 @@ IntEngGradientFillRect(
CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0); CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0);
do do
{ {
RECT FillRect; RECTL FillRect;
ULONG Color; ULONG Color;
if(Horizontal) if(Horizontal)
@ -123,7 +118,7 @@ IntEngGradientFillRect(
EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++) for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
{ {
if(IntGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG)) if(RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], &rcSG))
{ {
HVINITCOL(Red, 0); HVINITCOL(Red, 0);
HVINITCOL(Green, 1); HVINITCOL(Green, 1);
@ -151,7 +146,7 @@ IntEngGradientFillRect(
EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++) for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
{ {
if(IntGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG)) if(RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], &rcSG))
{ {
HVINITCOL(Red, 0); HVINITCOL(Red, 0);
HVINITCOL(Green, 1); HVINITCOL(Green, 1);
@ -181,13 +176,13 @@ IntEngGradientFillRect(
CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0); CLIPOBJ_cEnumStart(pco, FALSE, CT_RECTANGLES, CD_RIGHTDOWN, 0);
do do
{ {
RECT FillRect; RECTL FillRect;
ULONG Color = XLATEOBJ_iXlate(pxlo, RGB(v1->Red, v1->Green, v1->Blue)); ULONG Color = XLATEOBJ_iXlate(pxlo, RGB(v1->Red, v1->Green, v1->Blue));
EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++) for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
{ {
if(IntGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG)) if(RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], &rcSG))
{ {
for(; FillRect.top < FillRect.bottom; FillRect.top++) for(; FillRect.top < FillRect.bottom; FillRect.top++)
{ {
@ -369,7 +364,7 @@ IntEngGradientFillTriangle(
// EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); // EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
// for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= prclExtents->bottom; i++) // for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= prclExtents->bottom; i++)
// { // {
// if(IntGdiIntersectRect((PRECT)&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)prclExtents)) // if(RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], prclExtents))
// { // {
// BOOL InY; // BOOL InY;
@ -417,7 +412,7 @@ IntEngGradientFillTriangle(
// EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum); // EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
// for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= prclExtents->bottom; i++) // for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= prclExtents->bottom; i++)
// { // {
// if(IntGdiIntersectRect((PRECT)&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)prclExtents)) // if(RECTL_bIntersectRect(&FillRect, &RectEnum.arcl[i], prclExtents))
// { // {
// S_INITLINE(v1, v3, 0); // S_INITLINE(v1, v3, 0);
// S_INITLINE(v1, v2, 1); // S_INITLINE(v1, v2, 1);

4
reactos/subsystems/win32/win32k/include/cliprgn.h
View file

@ -4,10 +4,10 @@
#include <include/dc.h> #include <include/dc.h>
#include <include/region.h> #include <include/region.h>
INT FASTCALL IntGdiGetClipBox(PDC, LPRECT rc); INT FASTCALL IntGdiGetClipBox(PDC, RECTL* rc);
INT FASTCALL IntGdiExtSelectClipRgn (PDC, PROSRGNDATA, int); INT FASTCALL IntGdiExtSelectClipRgn (PDC, PROSRGNDATA, int);
INT FASTCALL GdiGetClipBox(HDC hDC, LPRECT rc); INT FASTCALL GdiGetClipBox(HDC hDC, RECTL *rc);
INT FASTCALL GdiSelectVisRgn(HDC hdc, HRGN hrgn); INT FASTCALL GdiSelectVisRgn(HDC hdc, HRGN hrgn);
INT FASTCALL GdiExtSelectClipRgn (PDC dc, HRGN hrgn, int fnMode); INT FASTCALL GdiExtSelectClipRgn (PDC dc, HRGN hrgn, int fnMode);

4
reactos/subsystems/win32/win32k/include/desktop.h
View file

@ -17,7 +17,7 @@ typedef struct _DESKTOP
/* Pointer to the active queue. */ /* Pointer to the active queue. */
PVOID ActiveMessageQueue; PVOID ActiveMessageQueue;
/* Rectangle of the work area */ /* Rectangle of the work area */
RECT WorkArea; RECTL WorkArea;
/* Handle of the desktop window. */ /* Handle of the desktop window. */
HANDLE DesktopWindow; HANDLE DesktopWindow;
/* Thread blocking input */ /* Thread blocking input */
@ -65,7 +65,7 @@ VOID APIENTRY
IntDesktopObjectDelete(PWIN32_DELETEMETHOD_PARAMETERS Parameters); IntDesktopObjectDelete(PWIN32_DELETEMETHOD_PARAMETERS Parameters);
VOID FASTCALL VOID FASTCALL
IntGetDesktopWorkArea(PDESKTOP Desktop, PRECT Rect); IntGetDesktopWorkArea(PDESKTOP Desktop, RECTL *Rect);
LRESULT CALLBACK LRESULT CALLBACK
IntDesktopWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); IntDesktopWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

20
reactos/subsystems/win32/win32k/include/intgdi.h
View file

@ -155,26 +155,6 @@ IntGdiCombineTransform(LPXFORM XFormResult,
LPXFORM xform1, LPXFORM xform1,
LPXFORM xform2); LPXFORM xform2);
/* RECT functions */
VOID FASTCALL
IntGdiSetRect(PRECT Rect, INT left, INT top, INT right, INT bottom);
VOID FASTCALL
IntGdiSetEmptyRect(PRECT Rect);
BOOL FASTCALL
IntGdiIsEmptyRect(const RECT* Rect);
VOID FASTCALL
IntGdiOffsetRect(LPRECT Rect, INT x, INT y);
BOOL FASTCALL
IntGdiUnionRect(PRECT Dest, const RECT* Src1, const RECT* Src2);
BOOL FASTCALL
IntGdiIntersectRect(PRECT Dest, const RECT* Src1, const RECT* Src2);
/* Stock objects */ /* Stock objects */
BOOL FASTCALL BOOL FASTCALL

6
reactos/subsystems/win32/win32k/include/menu.h
View file

@ -23,7 +23,7 @@ typedef struct _MENU_ITEM
ULONG_PTR dwItemData; ULONG_PTR dwItemData;
UNICODE_STRING Text; UNICODE_STRING Text;
HBITMAP hbmpItem; HBITMAP hbmpItem;
RECT Rect; RECTL Rect;
UINT XTab; UINT XTab;
} MENU_ITEM, *PMENU_ITEM; } MENU_ITEM, *PMENU_ITEM;
@ -40,7 +40,7 @@ typedef struct _SETMENUITEMRECT
{ {
UINT uItem; UINT uItem;
BOOL fByPosition; BOOL fByPosition;
RECT rcRect; RECTL rcRect;
} SETMENUITEMRECT, *PSETMENUITEMRECT; } SETMENUITEMRECT, *PSETMENUITEMRECT;
PMENU_OBJECT FASTCALL PMENU_OBJECT FASTCALL
@ -95,7 +95,7 @@ DWORD FASTCALL
IntCheckMenuItem(PMENU_OBJECT MenuObject, UINT uIDCheckItem, UINT uCheck); IntCheckMenuItem(PMENU_OBJECT MenuObject, UINT uIDCheckItem, UINT uCheck);
BOOL FASTCALL BOOL FASTCALL
IntSetMenuItemRect(PMENU_OBJECT MenuObject, UINT Item, BOOL fByPos, RECT *rcRect); IntSetMenuItemRect(PMENU_OBJECT MenuObject, UINT Item, BOOL fByPos, RECTL *rcRect);
DWORD APIENTRY UserInsertMenuItem(HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmii); DWORD APIENTRY UserInsertMenuItem(HMENU hMenu, UINT uItem, BOOL fByPosition, LPCMENUITEMINFOW lpmii);

2
reactos/subsystems/win32/win32k/include/painting.h
View file

@ -6,7 +6,7 @@
#include <include/window.h> #include <include/window.h>
BOOL FASTCALL BOOL FASTCALL
co_UserRedrawWindow(PWINDOW_OBJECT Wnd, const RECT* UpdateRect, HRGN UpdateRgn, ULONG Flags); co_UserRedrawWindow(PWINDOW_OBJECT Wnd, const RECTL* UpdateRect, HRGN UpdateRgn, ULONG Flags);
VOID FASTCALL VOID FASTCALL
IntInvalidateWindows(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags); IntInvalidateWindows(PWINDOW_OBJECT Window, HRGN hRgn, ULONG Flags);
BOOL FASTCALL BOOL FASTCALL

2
reactos/subsystems/win32/win32k/include/path.h
View file

@ -67,7 +67,7 @@ BOOL FASTCALL PATH_PolyPolyline( PDC dc, const POINT* pts, const DWORD* counts,
BOOL FASTCALL PATH_Rectangle (PDC dc, INT x1, INT y1, INT x2, INT y2); BOOL FASTCALL PATH_Rectangle (PDC dc, INT x1, INT y1, INT x2, INT y2);
BOOL FASTCALL PATH_RoundRect(DC *dc, INT x1, INT y1, INT x2, INT y2, INT ell_width, INT ell_height); BOOL FASTCALL PATH_RoundRect(DC *dc, INT x1, INT y1, INT x2, INT y2, INT ell_width, INT ell_height);
BOOL FASTCALL PATH_PathToRegion (PPATH pPath, INT nPolyFillMode, HRGN *pHrgn); BOOL FASTCALL PATH_PathToRegion (PPATH pPath, INT nPolyFillMode, HRGN *pHrgn);
BOOL FASTCALL PATH_ExtTextOut(PDC dc,INT x,INT y,UINT flags,const RECT *lprc,LPCWSTR str,UINT count,const INT *dx); BOOL FASTCALL PATH_ExtTextOut(PDC dc,INT x,INT y,UINT flags,const RECTL *lprc,LPCWSTR str,UINT count,const INT *dx);
VOID FASTCALL IntGdiCloseFigure(PPATH pPath); VOID FASTCALL IntGdiCloseFigure(PPATH pPath);
BOOL FASTCALL PATH_Delete(HPATH hPath); BOOL FASTCALL PATH_Delete(HPATH hPath);

67
reactos/subsystems/win32/win32k/include/rect.h
View file

@ -1,17 +1,60 @@
#ifndef _WIN32K_RECT_H #ifndef _WIN32K_RECT_H
#define _WIN32K_RECT_H #define _WIN32K_RECT_H
BOOL APIENTRY VOID
NtGdiUnionRect(PRECT Dest, const RECT* Src1, const RECT* Src2); FORCEINLINE
BOOL APIENTRY RECTL_vSetRect(RECTL *prcl, LONG left, LONG top, LONG right, LONG bottom)
NtGdiSetRect(PRECT Rect, int left, int top, int right, int bottom); {
BOOL APIENTRY prcl->left = left;
NtGdiSetEmptyRect(PRECT Rect); prcl->top = top;
BOOL APIENTRY prcl->right = right;
NtGdiIsEmptyRect(const RECT* Rect); prcl->bottom = bottom;
BOOL APIENTRY }
NtGdiIntersectRect(PRECT Dest, const RECT* Src1, const RECT* Src2);
BOOL APIENTRY VOID
NtGdiOffsetRect(LPRECT Rect, int x, int y); FORCEINLINE
RECTL_vSetEmptyRect(RECTL *prcl)
{
prcl->left = 0;
prcl->top = 0;
prcl->right = 0;
prcl->bottom = 0;
}
VOID
FORCEINLINE
RECTL_vOffsetRect(RECTL *prcl, INT cx, INT cy)
{
prcl->left += cx;
prcl->right += cx;
prcl->top += cy;
prcl->bottom += cy;
}
BOOL
FORCEINLINE
RECTL_bIsEmptyRect(const RECTL *prcl)
{
return (prcl->left >= prcl->right || prcl->top >= prcl->bottom);
}
BOOL
FORCEINLINE
RECTL_bPointInRect(const RECTL *prcl, INT x, INT y)
{
return (x >= prcl->left && x <= prcl->right &&
y >= prcl->top && y <= prcl->bottom);
}
BOOL
FASTCALL
RECTL_bUnionRect(RECTL *prclDst, const RECTL *prcl1, const RECTL *prcl2);
BOOL
FASTCALL
RECTL_bIntersectRect(RECTL *prclDst, const RECTL *prcl1, const RECTL *prcl2);
#endif /* _WIN32K_RECT_H */ #endif /* _WIN32K_RECT_H */

12
reactos/subsystems/win32/win32k/include/region.h
View file

@ -15,7 +15,7 @@ typedef struct _ROSRGNDATA
BASEOBJECT BaseObject; BASEOBJECT BaseObject;
RGNDATAHEADER rdh; RGNDATAHEADER rdh;
PRECT Buffer; RECTL *Buffer;
} ROSRGNDATA, *PROSRGNDATA, *LPROSRGNDATA; } ROSRGNDATA, *PROSRGNDATA, *LPROSRGNDATA;
@ -27,10 +27,10 @@ typedef struct _ROSRGNDATA
#define REGION_UnlockRgn(pRgn) GDIOBJ_UnlockObjByPtr((POBJ)pRgn) #define REGION_UnlockRgn(pRgn) GDIOBJ_UnlockObjByPtr((POBJ)pRgn)
PROSRGNDATA FASTCALL REGION_AllocRgnWithHandle(INT n); PROSRGNDATA FASTCALL REGION_AllocRgnWithHandle(INT n);
VOID FASTCALL REGION_UnionRectWithRgn(ROSRGNDATA *rgn, CONST RECT *rect); VOID FASTCALL REGION_UnionRectWithRgn(ROSRGNDATA *rgn, const RECTL *rect);
INT FASTCALL REGION_GetRgnBox(PROSRGNDATA Rgn, LPRECT pRect); INT FASTCALL REGION_GetRgnBox(PROSRGNDATA Rgn, RECTL *pRect);
BOOL FASTCALL REGION_RectInRegion(PROSRGNDATA Rgn, CONST LPRECT rc); BOOL FASTCALL REGION_RectInRegion(PROSRGNDATA Rgn, const RECTL *rc);
BOOL FASTCALL REGION_CropAndOffsetRegion(PROSRGNDATA rgnDst, PROSRGNDATA rgnSrc, const PRECT rect, const PPOINT off); BOOL FASTCALL REGION_CropAndOffsetRegion(PROSRGNDATA rgnDst, PROSRGNDATA rgnSrc, const RECTL *rect, const POINT *off);
VOID FASTCALL REGION_SetRectRgn(PROSRGNDATA pRgn, INT LeftRect, INT TopRect, INT RightRect, INT BottomRect); VOID FASTCALL REGION_SetRectRgn(PROSRGNDATA pRgn, INT LeftRect, INT TopRect, INT RightRect, INT BottomRect);
BOOL INTERNAL_CALL REGION_Cleanup(PVOID ObjectBody); BOOL INTERNAL_CALL REGION_Cleanup(PVOID ObjectBody);
@ -41,7 +41,7 @@ VOID FASTCALL REGION_Delete(PROSRGNDATA);
VOID FASTCALL IntGdiReleaseRaoRgn(PDC); VOID FASTCALL IntGdiReleaseRaoRgn(PDC);
VOID FASTCALL IntGdiReleaseVisRgn(PDC); VOID FASTCALL IntGdiReleaseVisRgn(PDC);
INT APIENTRY IntGdiGetRgnBox(HRGN, LPRECT); INT APIENTRY IntGdiGetRgnBox(HRGN, RECTL*);
BOOL FASTCALL IntGdiPaintRgn(PDC, HRGN ); BOOL FASTCALL IntGdiPaintRgn(PDC, HRGN );
HRGN FASTCALL IntCreatePolyPolygonRgn(PPOINT, PULONG, INT, INT); HRGN FASTCALL IntCreatePolyPolygonRgn(PPOINT, PULONG, INT, INT);

2
reactos/subsystems/win32/win32k/include/text.h
View file

@ -106,7 +106,7 @@ DWORD FASTCALL ftGdiGetFontData(PFONTGDI,DWORD,DWORD,PVOID,DWORD);
BOOL FASTCALL IntGdiGetFontResourceInfo(PUNICODE_STRING,PVOID,DWORD*,DWORD); BOOL FASTCALL IntGdiGetFontResourceInfo(PUNICODE_STRING,PVOID,DWORD*,DWORD);
BOOL FASTCALL ftGdiRealizationInfo(PFONTGDI,PREALIZATION_INFO); BOOL FASTCALL ftGdiRealizationInfo(PFONTGDI,PREALIZATION_INFO);
DWORD FASTCALL ftGdiGetKerningPairs(PFONTGDI,DWORD,LPKERNINGPAIR); DWORD FASTCALL ftGdiGetKerningPairs(PFONTGDI,DWORD,LPKERNINGPAIR);
BOOL NTAPI GreExtTextOutW(IN HDC,IN INT,IN INT,IN UINT,IN OPTIONAL LPRECT, BOOL NTAPI GreExtTextOutW(IN HDC,IN INT,IN INT,IN UINT,IN OPTIONAL RECTL*,
IN LPWSTR, IN INT, IN OPTIONAL LPINT, IN DWORD); IN LPWSTR, IN INT, IN OPTIONAL LPINT, IN DWORD);
DWORD FASTCALL IntGetCharDimensions(HDC, PTEXTMETRICW, PDWORD); DWORD FASTCALL IntGetCharDimensions(HDC, PTEXTMETRICW, PDWORD);

4
reactos/subsystems/win32/win32k/include/window.h
View file

@ -116,7 +116,7 @@ NTSTATUS FASTCALL
CleanupWindowImpl (VOID); CleanupWindowImpl (VOID);
VOID FASTCALL VOID FASTCALL
IntGetClientRect (PWINDOW_OBJECT WindowObject, PRECT Rect); IntGetClientRect (PWINDOW_OBJECT WindowObject, RECTL *Rect);
HWND FASTCALL HWND FASTCALL
IntGetActiveWindow (VOID); IntGetActiveWindow (VOID);
@ -147,7 +147,7 @@ INT FASTCALL
IntGetWindowRgn(PWINDOW_OBJECT Window, HRGN hRgn); IntGetWindowRgn(PWINDOW_OBJECT Window, HRGN hRgn);
INT FASTCALL INT FASTCALL
IntGetWindowRgnBox(PWINDOW_OBJECT Window, RECT *Rect); IntGetWindowRgnBox(PWINDOW_OBJECT Window, RECTL *Rect);
BOOL FASTCALL BOOL FASTCALL
IntGetWindowInfo(PWINDOW_OBJECT WindowObject, PWINDOWINFO pwi); IntGetWindowInfo(PWINDOW_OBJECT WindowObject, PWINDOWINFO pwi);

6
reactos/subsystems/win32/win32k/include/winpos.h
View file

@ -21,12 +21,12 @@ FASTCALL co_WinPosArrangeIconicWindows(PWINDOW_OBJECT parent);
BOOL FASTCALL BOOL FASTCALL
IntGetClientOrigin(PWINDOW_OBJECT Window, LPPOINT Point); IntGetClientOrigin(PWINDOW_OBJECT Window, LPPOINT Point);
LRESULT FASTCALL LRESULT FASTCALL
co_WinPosGetNonClientSize(PWINDOW_OBJECT Window, RECT* WindowRect, RECT* ClientRect); co_WinPosGetNonClientSize(PWINDOW_OBJECT Window, RECTL* WindowRect, RECTL* ClientRect);
UINT FASTCALL UINT FASTCALL
co_WinPosGetMinMaxInfo(PWINDOW_OBJECT Window, POINT* MaxSize, POINT* MaxPos, co_WinPosGetMinMaxInfo(PWINDOW_OBJECT Window, POINT* MaxSize, POINT* MaxPos,
POINT* MinTrack, POINT* MaxTrack); POINT* MinTrack, POINT* MaxTrack);
UINT FASTCALL UINT FASTCALL
co_WinPosMinMaximize(PWINDOW_OBJECT WindowObject, UINT ShowFlag, RECT* NewPos); co_WinPosMinMaximize(PWINDOW_OBJECT WindowObject, UINT ShowFlag, RECTL* NewPos);
BOOLEAN FASTCALL BOOLEAN FASTCALL
co_WinPosSetWindowPos(PWINDOW_OBJECT Wnd, HWND WndInsertAfter, INT x, INT y, INT cx, co_WinPosSetWindowPos(PWINDOW_OBJECT Wnd, HWND WndInsertAfter, INT x, INT y, INT cx,
INT cy, UINT flags); INT cy, UINT flags);
@ -38,6 +38,6 @@ co_WinPosWindowFromPoint(PWINDOW_OBJECT ScopeWin, PUSER_MESSAGE_QUEUE OnlyHitTes
VOID FASTCALL co_WinPosActivateOtherWindow(PWINDOW_OBJECT Window); VOID FASTCALL co_WinPosActivateOtherWindow(PWINDOW_OBJECT Window);
VOID FASTCALL WinPosInitInternalPos(PWINDOW_OBJECT WindowObject, VOID FASTCALL WinPosInitInternalPos(PWINDOW_OBJECT WindowObject,
POINT *pt, PRECT RestoreRect); POINT *pt, RECTL *RestoreRect);
#endif /* _WIN32K_WINPOS_H */ #endif /* _WIN32K_WINPOS_H */

12
reactos/subsystems/win32/win32k/ntuser/cursoricon.c
View file

@ -840,13 +840,13 @@ CLEANUP:
BOOL BOOL
APIENTRY APIENTRY
NtUserClipCursor( NtUserClipCursor(
RECT *UnsafeRect) RECTL *UnsafeRect)
{ {
/* FIXME - check if process has WINSTA_WRITEATTRIBUTES */ /* FIXME - check if process has WINSTA_WRITEATTRIBUTES */
PWINSTATION_OBJECT WinSta; PWINSTATION_OBJECT WinSta;
PSYSTEM_CURSORINFO CurInfo; PSYSTEM_CURSORINFO CurInfo;
RECT Rect; RECTL Rect;
PWINDOW_OBJECT DesktopWindow = NULL; PWINDOW_OBJECT DesktopWindow = NULL;
POINT MousePos = {0}; POINT MousePos = {0};
DECLARE_RETURN(BOOL); DECLARE_RETURN(BOOL);
@ -1001,12 +1001,12 @@ CLEANUP:
BOOL BOOL
APIENTRY APIENTRY
NtUserGetClipCursor( NtUserGetClipCursor(
RECT *lpRect) RECTL *lpRect)
{ {
/* FIXME - check if process has WINSTA_READATTRIBUTES */ /* FIXME - check if process has WINSTA_READATTRIBUTES */
PSYSTEM_CURSORINFO CurInfo; PSYSTEM_CURSORINFO CurInfo;
PWINSTATION_OBJECT WinSta; PWINSTATION_OBJECT WinSta;
RECT Rect; RECTL Rect;
NTSTATUS Status; NTSTATUS Status;
DECLARE_RETURN(BOOL); DECLARE_RETURN(BOOL);
@ -1038,7 +1038,7 @@ NtUserGetClipCursor(
Rect.bottom = UserGetSystemMetrics(SM_CYSCREEN); Rect.bottom = UserGetSystemMetrics(SM_CYSCREEN);
} }
Status = MmCopyToCaller((PRECT)lpRect, &Rect, sizeof(RECT)); Status = MmCopyToCaller(lpRect, &Rect, sizeof(RECT));
if(!NT_SUCCESS(Status)) if(!NT_SUCCESS(Status))
{ {
ObDereferenceObject(WinSta); ObDereferenceObject(WinSta);
@ -1491,7 +1491,7 @@ UserDrawIconEx(
if (DoFlickerFree || bAlpha) if (DoFlickerFree || bAlpha)
{ {
RECT r; RECTL r;
BITMAP bm; BITMAP bm;
SURFACE *psurfOff = NULL; SURFACE *psurfOff = NULL;

8
reactos/subsystems/win32/win32k/ntuser/desktop.c
View file

@ -439,9 +439,9 @@ IntValidateDesktopHandle(
} }
VOID FASTCALL VOID FASTCALL
IntGetDesktopWorkArea(PDESKTOP Desktop, PRECT Rect) IntGetDesktopWorkArea(PDESKTOP Desktop, RECTL *Rect)
{ {
PRECT Ret; RECTL *Ret;
ASSERT(Desktop); ASSERT(Desktop);
@ -1358,7 +1358,7 @@ CLEANUP:
BOOL APIENTRY BOOL APIENTRY
NtUserPaintDesktop(HDC hDC) NtUserPaintDesktop(HDC hDC)
{ {
RECT Rect; RECTL Rect;
HBRUSH DesktopBrush, PreviousBrush; HBRUSH DesktopBrush, PreviousBrush;
HWND hWndDesktop; HWND hWndDesktop;
BOOL doPatBlt = TRUE; BOOL doPatBlt = TRUE;
@ -1513,7 +1513,7 @@ NtUserPaintDesktop(HDC hDC)
if (g_PaintDesktopVersion) if (g_PaintDesktopVersion)
{ {
static WCHAR s_wszVersion[256] = {0}; static WCHAR s_wszVersion[256] = {0};
RECT rect; RECTL rect;
if (*s_wszVersion) if (*s_wszVersion)
{ {

2
reactos/subsystems/win32/win32k/ntuser/hook.c
View file

@ -734,7 +734,7 @@ UserCallNextHookEx(
case HCBT_MOVESIZE: case HCBT_MOVESIZE:
{ {
RECT rt; RECTL rt;
DPRINT1("HOOK HCBT_MOVESIZE\n"); DPRINT1("HOOK HCBT_MOVESIZE\n");
if (lParam) if (lParam)
{ {

14
reactos/subsystems/win32/win32k/ntuser/menu.c
View file

@ -1265,14 +1265,14 @@ co_IntExitTracking(PWINDOW_OBJECT Window, PMENU_OBJECT Menu, BOOL Popup,
INT FASTCALL INT FASTCALL
IntTrackMenu(PMENU_OBJECT Menu, PWINDOW_OBJECT Window, INT x, INT y, IntTrackMenu(PMENU_OBJECT Menu, PWINDOW_OBJECT Window, INT x, INT y,
RECT lprect) RECTL lprect)
{ {
return 0; return 0;
} }
BOOL FASTCALL BOOL FASTCALL
co_IntTrackPopupMenu(PMENU_OBJECT Menu, PWINDOW_OBJECT Window, co_IntTrackPopupMenu(PMENU_OBJECT Menu, PWINDOW_OBJECT Window,
UINT Flags, POINT *Pos, UINT MenuPos, RECT *ExcludeRect) UINT Flags, POINT *Pos, UINT MenuPos, RECTL *ExcludeRect)
{ {
co_IntInitTracking(Window, Menu, TRUE, Flags); co_IntInitTracking(Window, Menu, TRUE, Flags);
@ -1281,7 +1281,7 @@ co_IntTrackPopupMenu(PMENU_OBJECT Menu, PWINDOW_OBJECT Window,
} }
BOOL FASTCALL BOOL FASTCALL
IntSetMenuItemRect(PMENU_OBJECT Menu, UINT Item, BOOL fByPos, RECT *rcRect) IntSetMenuItemRect(PMENU_OBJECT Menu, UINT Item, BOOL fByPos, RECTL *rcRect)
{ {
PMENU_ITEM mi; PMENU_ITEM mi;
if(IntGetMenuItemByFlag(Menu, Item, (fByPos ? MF_BYPOSITION : MF_BYCOMMAND), if(IntGetMenuItemByFlag(Menu, Item, (fByPos ? MF_BYPOSITION : MF_BYCOMMAND),
@ -1327,7 +1327,7 @@ IntCleanupMenus(struct _EPROCESS *Process, PW32PROCESS Win32Process)
} }
VOID APIENTRY VOID APIENTRY
co_InflateRect(LPRECT rect, int dx, int dy) co_InflateRect(RECTL *rect, int dx, int dy)
{ {
rect->left -= dx; rect->left -= dx;
rect->top -= dy; rect->top -= dy;
@ -1876,7 +1876,7 @@ NtUserGetMenuBarInfo(
PWINDOW_OBJECT WindowObject; PWINDOW_OBJECT WindowObject;
HMENU hMenu; HMENU hMenu;
POINT Offset; POINT Offset;
RECT Rect; RECTL Rect;
MENUBARINFO kmbi; MENUBARINFO kmbi;
DECLARE_RETURN(BOOL); DECLARE_RETURN(BOOL);
@ -2098,12 +2098,12 @@ NtUserGetMenuItemRect(
HWND hWnd, HWND hWnd,
HMENU hMenu, HMENU hMenu,
UINT uItem, UINT uItem,
LPRECT lprcItem) PRECTL lprcItem)
{ {
ROSMENUINFO mi; ROSMENUINFO mi;
PWINDOW_OBJECT ReferenceWnd; PWINDOW_OBJECT ReferenceWnd;
LONG XMove, YMove; LONG XMove, YMove;
RECT Rect; RECTL Rect;
NTSTATUS Status; NTSTATUS Status;
PMENU_OBJECT Menu; PMENU_OBJECT Menu;
PMENU_ITEM MenuItem; PMENU_ITEM MenuItem;

26
reactos/subsystems/win32/win32k/ntuser/monitor.c
View file

@ -316,9 +316,9 @@ IntGetPrimaryMonitor()
*/ */
static static
UINT UINT
IntGetMonitorsFromRect(OPTIONAL IN LPCRECT pRect, IntGetMonitorsFromRect(OPTIONAL IN LPCRECTL pRect,
OPTIONAL OUT HMONITOR *hMonitorList, OPTIONAL OUT HMONITOR *hMonitorList,
OPTIONAL OUT LPRECT monitorRectList, OPTIONAL OUT PRECTL monitorRectList,
OPTIONAL IN DWORD listSize, OPTIONAL IN DWORD listSize,
OPTIONAL IN DWORD flags) OPTIONAL IN DWORD flags)
{ {
@ -329,7 +329,7 @@ IntGetMonitorsFromRect(OPTIONAL IN LPCRECT pRect,
/* find monitors which intersect the rectangle */ /* find monitors which intersect the rectangle */
for (Monitor = gMonitorList; Monitor != NULL; Monitor = Monitor->Next) for (Monitor = gMonitorList; Monitor != NULL; Monitor = Monitor->Next)
{ {
RECT MonitorRect, IntersectionRect; RECTL MonitorRect, IntersectionRect;
ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&Monitor->Lock); ExEnterCriticalRegionAndAcquireFastMutexUnsafe(&Monitor->Lock);
MonitorRect.left = 0; /* FIXME: get origin */ MonitorRect.left = 0; /* FIXME: get origin */
@ -456,16 +456,16 @@ INT
APIENTRY APIENTRY
NtUserEnumDisplayMonitors( NtUserEnumDisplayMonitors(
OPTIONAL IN HDC hDC, OPTIONAL IN HDC hDC,
OPTIONAL IN LPCRECT pRect, OPTIONAL IN LPCRECTL pRect,
OPTIONAL OUT HMONITOR *hMonitorList, OPTIONAL OUT HMONITOR *hMonitorList,
OPTIONAL OUT LPRECT monitorRectList, OPTIONAL OUT PRECTL monitorRectList,
OPTIONAL IN DWORD listSize) OPTIONAL IN DWORD listSize)
{ {
INT numMonitors, i; INT numMonitors, i;
HMONITOR *safeHMonitorList = NULL; HMONITOR *safeHMonitorList = NULL;
LPRECT safeRectList = NULL; PRECTL safeRectList = NULL;
RECT rect, *myRect; RECTL rect, *myRect;
RECT dcRect; RECTL dcRect;
NTSTATUS status; NTSTATUS status;
/* get rect */ /* get rect */
@ -729,7 +729,7 @@ NtUserMonitorFromPoint(
IN DWORD dwFlags) IN DWORD dwFlags)
{ {
INT NumMonitors; INT NumMonitors;
RECT InRect; RECTL InRect;
HMONITOR hMonitor = NULL; HMONITOR hMonitor = NULL;
/* fill inRect */ /* fill inRect */
@ -783,14 +783,14 @@ NtUserMonitorFromPoint(
HMONITOR HMONITOR
APIENTRY APIENTRY
NtUserMonitorFromRect( NtUserMonitorFromRect(
IN LPCRECT pRect, IN LPCRECTL pRect,
IN DWORD dwFlags) IN DWORD dwFlags)
{ {
INT numMonitors, iLargestArea = -1, i; INT numMonitors, iLargestArea = -1, i;
LPRECT rectList; PRECTL rectList;
HMONITOR *hMonitorList; HMONITOR *hMonitorList;
HMONITOR hMonitor = NULL; HMONITOR hMonitor = NULL;
RECT rect; RECTL rect;
NTSTATUS status; NTSTATUS status;
/* get rect */ /* get rect */
@ -883,7 +883,7 @@ NtUserMonitorFromWindow(
{ {
PWINDOW_OBJECT Window; PWINDOW_OBJECT Window;
HMONITOR hMonitor = NULL; HMONITOR hMonitor = NULL;
RECT Rect; RECTL Rect;
DECLARE_RETURN(HMONITOR); DECLARE_RETURN(HMONITOR);
DPRINT("Enter NtUserMonitorFromWindow\n"); DPRINT("Enter NtUserMonitorFromWindow\n");

2
reactos/subsystems/win32/win32k/ntuser/ntstubs.c
View file

@ -1092,7 +1092,7 @@ BOOL
APIENTRY APIENTRY
NtUserValidateRect( NtUserValidateRect(
HWND hWnd, HWND hWnd,
CONST RECT *lpRect) const RECT *lpRect)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return 0; return 0;

86
reactos/subsystems/win32/win32k/ntuser/painting.c
View file

@ -55,7 +55,7 @@
*/ */
BOOL FASTCALL BOOL FASTCALL
IntIntersectWithParents(PWINDOW_OBJECT Child, PRECT WindowRect) IntIntersectWithParents(PWINDOW_OBJECT Child, RECTL *WindowRect)
{ {
PWINDOW_OBJECT ParentWindow; PWINDOW_OBJECT ParentWindow;
PWINDOW ParentWnd; PWINDOW ParentWnd;
@ -70,7 +70,7 @@ IntIntersectWithParents(PWINDOW_OBJECT Child, PRECT WindowRect)
return FALSE; return FALSE;
} }
if (!IntGdiIntersectRect(WindowRect, WindowRect, &ParentWnd->ClientRect)) if (!RECTL_bIntersectRect(WindowRect, WindowRect, &ParentWnd->ClientRect))
{ {
return FALSE; return FALSE;
} }
@ -534,7 +534,7 @@ IntIsWindowDrawable(PWINDOW_OBJECT Window)
*/ */
BOOL FASTCALL BOOL FASTCALL
co_UserRedrawWindow(PWINDOW_OBJECT Window, const RECT* UpdateRect, HRGN UpdateRgn, co_UserRedrawWindow(PWINDOW_OBJECT Window, const RECTL* UpdateRect, HRGN UpdateRgn,
ULONG Flags) ULONG Flags)
{ {
HRGN hRgn = NULL; HRGN hRgn = NULL;
@ -572,21 +572,21 @@ co_UserRedrawWindow(PWINDOW_OBJECT Window, const RECT* UpdateRect, HRGN UpdateRg
} }
else if (UpdateRect != NULL) else if (UpdateRect != NULL)
{ {
if (!IntGdiIsEmptyRect(UpdateRect)) if (!RECTL_bIsEmptyRect(UpdateRect))
{ {
hRgn = UnsafeIntCreateRectRgnIndirect((RECT *)UpdateRect); hRgn = UnsafeIntCreateRectRgnIndirect((RECTL *)UpdateRect);
NtGdiOffsetRgn(hRgn, Window->Wnd->ClientRect.left, Window->Wnd->ClientRect.top); NtGdiOffsetRgn(hRgn, Window->Wnd->ClientRect.left, Window->Wnd->ClientRect.top);
} }
} }
else if ((Flags & (RDW_INVALIDATE | RDW_FRAME)) == (RDW_INVALIDATE | RDW_FRAME) || else if ((Flags & (RDW_INVALIDATE | RDW_FRAME)) == (RDW_INVALIDATE | RDW_FRAME) ||
(Flags & (RDW_VALIDATE | RDW_NOFRAME)) == (RDW_VALIDATE | RDW_NOFRAME)) (Flags & (RDW_VALIDATE | RDW_NOFRAME)) == (RDW_VALIDATE | RDW_NOFRAME))
{ {
if (!IntGdiIsEmptyRect(&Window->Wnd->WindowRect)) if (!RECTL_bIsEmptyRect(&Window->Wnd->WindowRect))
hRgn = UnsafeIntCreateRectRgnIndirect(&Window->Wnd->WindowRect); hRgn = UnsafeIntCreateRectRgnIndirect(&Window->Wnd->WindowRect);
} }
else else
{ {
if (!IntGdiIsEmptyRect(&Window->Wnd->ClientRect)) if (!RECTL_bIsEmptyRect(&Window->Wnd->ClientRect))
hRgn = UnsafeIntCreateRectRgnIndirect(&Window->Wnd->ClientRect); hRgn = UnsafeIntCreateRectRgnIndirect(&Window->Wnd->ClientRect);
} }
} }
@ -712,7 +712,7 @@ IntGetPaintMessage(HWND hWnd, UINT MsgFilterMin, UINT MsgFilterMax,
static static
HWND FASTCALL HWND FASTCALL
co_IntFixCaret(PWINDOW_OBJECT Window, LPRECT lprc, UINT flags) co_IntFixCaret(PWINDOW_OBJECT Window, RECTL *lprc, UINT flags)
{ {
PDESKTOP Desktop; PDESKTOP Desktop;
PTHRDCARETINFO CaretInfo; PTHRDCARETINFO CaretInfo;
@ -732,7 +732,7 @@ co_IntFixCaret(PWINDOW_OBJECT Window, LPRECT lprc, UINT flags)
((flags & SW_SCROLLCHILDREN) && IntIsChildWindow(Window, WndCaret))) ((flags & SW_SCROLLCHILDREN) && IntIsChildWindow(Window, WndCaret)))
{ {
POINT pt, FromOffset, ToOffset, Offset; POINT pt, FromOffset, ToOffset, Offset;
RECT rcCaret; RECTL rcCaret;
pt.x = CaretInfo->Pos.x; pt.x = CaretInfo->Pos.x;
pt.y = CaretInfo->Pos.y; pt.y = CaretInfo->Pos.y;
@ -744,7 +744,7 @@ co_IntFixCaret(PWINDOW_OBJECT Window, LPRECT lprc, UINT flags)
rcCaret.top = pt.y; rcCaret.top = pt.y;
rcCaret.right = pt.x + CaretInfo->Size.cx; rcCaret.right = pt.x + CaretInfo->Size.cx;
rcCaret.bottom = pt.y + CaretInfo->Size.cy; rcCaret.bottom = pt.y + CaretInfo->Size.cy;
if (IntGdiIntersectRect(lprc, lprc, &rcCaret)) if (RECTL_bIntersectRect(lprc, lprc, &rcCaret))
{ {
co_UserHideCaret(0); co_UserHideCaret(0);
lprc->left = pt.x; lprc->left = pt.x;
@ -927,7 +927,7 @@ INT FASTCALL
co_UserGetUpdateRgn(PWINDOW_OBJECT Window, HRGN hRgn, BOOL bErase) co_UserGetUpdateRgn(PWINDOW_OBJECT Window, HRGN hRgn, BOOL bErase)
{ {
int RegionType; int RegionType;
RECT Rect; RECTL Rect;
ASSERT_REFS_CO(Window); ASSERT_REFS_CO(Window);
@ -998,7 +998,7 @@ BOOL APIENTRY
NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase) NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
{ {
PWINDOW_OBJECT Window; PWINDOW_OBJECT Window;
RECT Rect; RECTL Rect;
INT RegionType; INT RegionType;
PROSRGNDATA RgnData; PROSRGNDATA RgnData;
NTSTATUS Status; NTSTATUS Status;
@ -1031,12 +1031,12 @@ NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
REGION_UnlockRgn(RgnData); REGION_UnlockRgn(RgnData);
if (RegionType != ERROR && RegionType != NULLREGION) if (RegionType != ERROR && RegionType != NULLREGION)
IntGdiIntersectRect(&Rect, &Rect, &Window->Wnd->ClientRect); RECTL_bIntersectRect(&Rect, &Rect, &Window->Wnd->ClientRect);
} }
if (IntIntersectWithParents(Window, &Rect)) if (IntIntersectWithParents(Window, &Rect))
{ {
IntGdiOffsetRect(&Rect, RECTL_vOffsetRect(&Rect,
-Window->Wnd->ClientRect.left, -Window->Wnd->ClientRect.left,
-Window->Wnd->ClientRect.top); -Window->Wnd->ClientRect.top);
} else } else
@ -1045,7 +1045,7 @@ NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
} }
} }
if (bErase && !IntGdiIsEmptyRect(&Rect)) if (bErase && !RECTL_bIsEmptyRect(&Rect))
{ {
USER_REFERENCE_ENTRY Ref; USER_REFERENCE_ENTRY Ref;
UserRefObjectCo(Window, &Ref); UserRefObjectCo(Window, &Ref);
@ -1055,7 +1055,7 @@ NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
if (UnsafeRect != NULL) if (UnsafeRect != NULL)
{ {
Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECT)); Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECTL));
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastWin32Error(ERROR_INVALID_PARAMETER); SetLastWin32Error(ERROR_INVALID_PARAMETER);
@ -1063,7 +1063,7 @@ NtUserGetUpdateRect(HWND hWnd, LPRECT UnsafeRect, BOOL bErase)
} }
} }
RETURN(!IntGdiIsEmptyRect(&Rect)); RETURN(!RECTL_bIsEmptyRect(&Rect));
CLEANUP: CLEANUP:
DPRINT("Leave NtUserGetUpdateRect, ret=%i\n",_ret_); DPRINT("Leave NtUserGetUpdateRect, ret=%i\n",_ret_);
@ -1082,7 +1082,7 @@ BOOL APIENTRY
NtUserRedrawWindow(HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate, NtUserRedrawWindow(HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate,
UINT flags) UINT flags)
{ {
RECT SafeUpdateRect; RECTL SafeUpdateRect;
NTSTATUS Status; NTSTATUS Status;
PWINDOW_OBJECT Wnd; PWINDOW_OBJECT Wnd;
DECLARE_RETURN(BOOL); DECLARE_RETURN(BOOL);
@ -1098,8 +1098,8 @@ NtUserRedrawWindow(HWND hWnd, CONST RECT *lprcUpdate, HRGN hrgnUpdate,
if (lprcUpdate != NULL) if (lprcUpdate != NULL)
{ {
Status = MmCopyFromCaller(&SafeUpdateRect, (PRECT)lprcUpdate, Status = MmCopyFromCaller(&SafeUpdateRect, lprcUpdate,
sizeof(RECT)); sizeof(RECTL));
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
@ -1134,24 +1134,24 @@ CLEANUP:
static static
INT FASTCALL INT FASTCALL
UserScrollDC(HDC hDC, INT dx, INT dy, const RECT *prcScroll, UserScrollDC(HDC hDC, INT dx, INT dy, const RECTL *prcScroll,
const RECT *prcClip, HRGN hrgnUpdate, LPRECT prcUpdate) const RECTL *prcClip, HRGN hrgnUpdate, RECTL *prcUpdate)
{ {
PDC pDC; PDC pDC;
RECT rcScroll, rcClip, rcSrc, rcDst; RECTL rcScroll, rcClip, rcSrc, rcDst;
INT Result; INT Result;
GdiGetClipBox(hDC, &rcClip); GdiGetClipBox(hDC, &rcClip);
rcScroll = rcClip; rcScroll = rcClip;
if (prcClip) if (prcClip)
{ {
IntGdiIntersectRect(&rcClip, &rcClip, prcClip); RECTL_bIntersectRect(&rcClip, &rcClip, prcClip);
} }
if (prcScroll) if (prcScroll)
{ {
rcScroll = *prcScroll; rcScroll = *prcScroll;
IntGdiIntersectRect(&rcSrc, &rcClip, prcScroll); RECTL_bIntersectRect(&rcSrc, &rcClip, prcScroll);
} }
else else
{ {
@ -1159,8 +1159,8 @@ UserScrollDC(HDC hDC, INT dx, INT dy, const RECT *prcScroll,
} }
rcDst = rcSrc; rcDst = rcSrc;
IntGdiOffsetRect(&rcDst, dx, dy); RECTL_vOffsetRect(&rcDst, dx, dy);
IntGdiIntersectRect(&rcDst, &rcDst, &rcClip); RECTL_bIntersectRect(&rcDst, &rcDst, &rcClip);
if (!NtGdiBitBlt(hDC, rcDst.left, rcDst.top, if (!NtGdiBitBlt(hDC, rcDst.left, rcDst.top,
rcDst.right - rcDst.left, rcDst.bottom - rcDst.top, rcDst.right - rcDst.left, rcDst.bottom - rcDst.top,
@ -1185,8 +1185,8 @@ UserScrollDC(HDC hDC, INT dx, INT dy, const RECT *prcScroll,
/* Begin with the shifted and then clipped scroll rect */ /* Begin with the shifted and then clipped scroll rect */
rcDst = rcScroll; rcDst = rcScroll;
IntGdiOffsetRect(&rcDst, dx, dy); RECTL_vOffsetRect(&rcDst, dx, dy);
IntGdiIntersectRect(&rcDst, &rcDst, &rcClip); RECTL_bIntersectRect(&rcDst, &rcDst, &rcClip);
if (hrgnUpdate) if (hrgnUpdate)
{ {
hrgnOwn = hrgnUpdate; hrgnOwn = hrgnUpdate;
@ -1242,7 +1242,7 @@ NtUserScrollDC(HDC hDC, INT dx, INT dy, const RECT *prcUnsafeScroll,
const RECT *prcUnsafeClip, HRGN hrgnUpdate, LPRECT prcUnsafeUpdate) const RECT *prcUnsafeClip, HRGN hrgnUpdate, LPRECT prcUnsafeUpdate)
{ {
DECLARE_RETURN(DWORD); DECLARE_RETURN(DWORD);
RECT rcScroll, rcClip, rcUpdate; RECTL rcScroll, rcClip, rcUpdate;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
DWORD Result; DWORD Result;
@ -1325,7 +1325,7 @@ DWORD APIENTRY
NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *prcUnsafeScroll, NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *prcUnsafeScroll,
const RECT *prcUnsafeClip, HRGN hrgnUpdate, LPRECT prcUnsafeUpdate, UINT flags) const RECT *prcUnsafeClip, HRGN hrgnUpdate, LPRECT prcUnsafeUpdate, UINT flags)
{ {
RECT rcScroll, rcClip, rcCaret, rcUpdate; RECTL rcScroll, rcClip, rcCaret, rcUpdate;
INT Result; INT Result;
PWINDOW_OBJECT Window = NULL, CaretWnd; PWINDOW_OBJECT Window = NULL, CaretWnd;
HDC hDC; HDC hDC;
@ -1353,7 +1353,7 @@ NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *prcUnsafeScroll,
if (prcUnsafeScroll) if (prcUnsafeScroll)
{ {
ProbeForRead(prcUnsafeScroll, sizeof(*prcUnsafeScroll), 1); ProbeForRead(prcUnsafeScroll, sizeof(*prcUnsafeScroll), 1);
IntGdiIntersectRect(&rcScroll, &rcClip, prcUnsafeScroll); RECTL_bIntersectRect(&rcScroll, &rcClip, prcUnsafeScroll);
} }
else else
rcScroll = rcClip; rcScroll = rcClip;
@ -1361,7 +1361,7 @@ NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *prcUnsafeScroll,
if (prcUnsafeClip) if (prcUnsafeClip)
{ {
ProbeForRead(prcUnsafeClip, sizeof(*prcUnsafeClip), 1); ProbeForRead(prcUnsafeClip, sizeof(*prcUnsafeClip), 1);
IntGdiIntersectRect(&rcClip, &rcClip, prcUnsafeClip); RECTL_bIntersectRect(&rcClip, &rcClip, prcUnsafeClip);
} }
} }
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
@ -1419,10 +1419,10 @@ NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *prcUnsafeScroll,
if (flags & SW_SCROLLCHILDREN) if (flags & SW_SCROLLCHILDREN)
{ {
PWINDOW_OBJECT Child; PWINDOW_OBJECT Child;
RECT rcChild; RECTL rcChild;
POINT ClientOrigin; POINT ClientOrigin;
USER_REFERENCE_ENTRY WndRef; USER_REFERENCE_ENTRY WndRef;
RECT rcDummy; RECTL rcDummy;
IntGetClientOrigin(Window, &ClientOrigin); IntGetClientOrigin(Window, &ClientOrigin);
for (Child = Window->FirstChild; Child; Child = Child->NextSibling) for (Child = Window->FirstChild; Child; Child = Child->NextSibling)
@ -1433,7 +1433,7 @@ NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *prcUnsafeScroll,
rcChild.right -= ClientOrigin.x; rcChild.right -= ClientOrigin.x;
rcChild.bottom -= ClientOrigin.y; rcChild.bottom -= ClientOrigin.y;
if (! prcUnsafeScroll || IntGdiIntersectRect(&rcDummy, &rcChild, &rcScroll)) if (! prcUnsafeScroll || RECTL_bIntersectRect(&rcDummy, &rcChild, &rcScroll))
{ {
UserRefObjectCo(Child, &WndRef); UserRefObjectCo(Child, &WndRef);
co_WinPosSetWindowPos(Child, 0, rcChild.left + dx, rcChild.top + dy, 0, 0, co_WinPosSetWindowPos(Child, 0, rcChild.left + dx, rcChild.top + dy, 0, 0,
@ -1503,7 +1503,7 @@ BOOL
UserDrawSysMenuButton( UserDrawSysMenuButton(
PWINDOW_OBJECT pWnd, PWINDOW_OBJECT pWnd,
HDC hDc, HDC hDc,
LPRECT lpRc, RECTL *lpRc,
BOOL Down) BOOL Down)
{ {
HICON hIcon; HICON hIcon;
@ -1543,7 +1543,7 @@ UserDrawSysMenuButton(
BOOL BOOL
UserDrawCaptionText(HDC hDc, UserDrawCaptionText(HDC hDc,
const PUNICODE_STRING Text, const PUNICODE_STRING Text,
const LPRECT lpRc, const RECTL *lpRc,
UINT uFlags) UINT uFlags)
{ {
HFONT hOldFont = NULL, hFont = NULL; HFONT hOldFont = NULL, hFont = NULL;
@ -1608,7 +1608,7 @@ UserDrawCaptionText(HDC hDc,
BOOL UserDrawCaption( BOOL UserDrawCaption(
PWINDOW_OBJECT pWnd, PWINDOW_OBJECT pWnd,
HDC hDc, HDC hDc,
LPCRECT lpRc, RECTL *lpRc,
HFONT hFont, HFONT hFont,
HICON hIcon, HICON hIcon,
const PUNICODE_STRING str, const PUNICODE_STRING str,
@ -1620,7 +1620,7 @@ BOOL UserDrawCaption(
HDC hMemDc = NULL; HDC hMemDc = NULL;
ULONG Height; ULONG Height;
UINT VCenter = 0, Padding = 0; UINT VCenter = 0, Padding = 0;
RECT r = *lpRc; RECTL r = *lpRc;
LONG ButtonWidth, IconWidth; LONG ButtonWidth, IconWidth;
BOOL HasIcon; BOOL HasIcon;
PWINDOW Wnd = NULL; PWINDOW Wnd = NULL;
@ -1901,7 +1901,7 @@ NtUserDrawCaptionTemp(
UINT uFlags) UINT uFlags)
{ {
PWINDOW_OBJECT pWnd = NULL; PWINDOW_OBJECT pWnd = NULL;
RECT SafeRect; RECTL SafeRect;
UNICODE_STRING SafeStr = {0}; UNICODE_STRING SafeStr = {0};
BOOL Ret = FALSE; BOOL Ret = FALSE;
@ -1918,8 +1918,8 @@ NtUserDrawCaptionTemp(
_SEH2_TRY _SEH2_TRY
{ {
ProbeForRead(lpRc, sizeof(RECT), sizeof(ULONG)); ProbeForRead(lpRc, sizeof(RECTL), sizeof(ULONG));
RtlCopyMemory(&SafeRect, lpRc, sizeof(RECT)); RtlCopyMemory(&SafeRect, lpRc, sizeof(RECTL));
if (str != NULL) if (str != NULL)
{ {
SafeStr = ProbeForReadUnicodeString(str); SafeStr = ProbeForReadUnicodeString(str);

12
reactos/subsystems/win32/win32k/ntuser/scrollbar.c
View file

@ -57,12 +57,12 @@
* the top. Return TRUE if the scrollbar is vertical, FALSE if horizontal. * the top. Return TRUE if the scrollbar is vertical, FALSE if horizontal.
*/ */
BOOL FASTCALL BOOL FASTCALL
IntGetScrollBarRect (PWINDOW_OBJECT Window, INT nBar, PRECT lprect) IntGetScrollBarRect (PWINDOW_OBJECT Window, INT nBar, RECTL *lprect)
{ {
BOOL vertical; BOOL vertical;
PWINDOW Wnd = Window->Wnd; PWINDOW Wnd = Window->Wnd;
RECT ClientRect = Window->Wnd->ClientRect; RECTL ClientRect = Window->Wnd->ClientRect;
RECT WindowRect = Window->Wnd->WindowRect; RECTL WindowRect = Window->Wnd->WindowRect;
switch (nBar) switch (nBar)
{ {
@ -107,7 +107,7 @@ IntCalculateThumb(PWINDOW_OBJECT Window, LONG idObject, PSCROLLBARINFO psbi, LPS
{ {
PWINDOW Wnd = Window->Wnd; PWINDOW Wnd = Window->Wnd;
INT Thumb, ThumbBox, ThumbPos, cxy, mx; INT Thumb, ThumbBox, ThumbPos, cxy, mx;
RECT ClientRect; RECTL ClientRect;
switch(idObject) switch(idObject)
{ {
@ -120,7 +120,7 @@ IntCalculateThumb(PWINDOW_OBJECT Window, LONG idObject, PSCROLLBARINFO psbi, LPS
cxy = psbi->rcScrollBar.bottom - psbi->rcScrollBar.top; cxy = psbi->rcScrollBar.bottom - psbi->rcScrollBar.top;
break; break;
case SB_CTL: case SB_CTL:
IntGetClientRect (Window, &ClientRect); IntGetClientRect(Window, &ClientRect);
if(Wnd->Style & SBS_VERT) if(Wnd->Style & SBS_VERT)
{ {
Thumb = UserGetSystemMetrics(SM_CYVSCROLL); Thumb = UserGetSystemMetrics(SM_CYVSCROLL);
@ -391,7 +391,7 @@ co_IntSetScrollInfo(PWINDOW_OBJECT Window, INT nBar, LPCSCROLLINFO lpsi, BOOL bR
if (bRedraw) if (bRedraw)
{ {
RECT UpdateRect = psbi->rcScrollBar; RECTL UpdateRect = psbi->rcScrollBar;
UpdateRect.left -= Window->Wnd->ClientRect.left - Window->Wnd->WindowRect.left; UpdateRect.left -= Window->Wnd->ClientRect.left - Window->Wnd->WindowRect.left;
UpdateRect.right -= Window->Wnd->ClientRect.left - Window->Wnd->WindowRect.left; UpdateRect.right -= Window->Wnd->ClientRect.left - Window->Wnd->WindowRect.left;
UpdateRect.top -= Window->Wnd->ClientRect.top - Window->Wnd->WindowRect.top; UpdateRect.top -= Window->Wnd->ClientRect.top - Window->Wnd->WindowRect.top;

2
reactos/subsystems/win32/win32k/ntuser/simplecall.c
View file

@ -453,7 +453,7 @@ NtUserCallTwoParam(
case TWOPARAM_ROUTINE_GETWINDOWRGNBOX: case TWOPARAM_ROUTINE_GETWINDOWRGNBOX:
{ {
DWORD Ret; DWORD Ret;
RECT rcRect; RECTL rcRect;
Window = UserGetWindowObject((HWND)Param1); Window = UserGetWindowObject((HWND)Param1);
if (!Window) RETURN(ERROR); if (!Window) RETURN(ERROR);

6
reactos/subsystems/win32/win32k/ntuser/sysparams.c
View file

@ -506,7 +506,7 @@ IntSystemParametersInfo(
} }
case SPI_SETWORKAREA: case SPI_SETWORKAREA:
{ {
RECT *rc; RECTL *rc;
PTHREADINFO pti = PsGetCurrentThreadWin32Thread(); PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
PDESKTOP Desktop = pti->Desktop; PDESKTOP Desktop = pti->Desktop;
@ -517,7 +517,7 @@ IntSystemParametersInfo(
} }
ASSERT(pvParam); ASSERT(pvParam);
rc = (RECT*)pvParam; rc = pvParam;
Desktop->WorkArea = *rc; Desktop->WorkArea = *rc;
bChanged = TRUE; bChanged = TRUE;
@ -535,7 +535,7 @@ IntSystemParametersInfo(
} }
ASSERT(pvParam); ASSERT(pvParam);
IntGetDesktopWorkArea(Desktop, (PRECT)pvParam); IntGetDesktopWorkArea(Desktop, pvParam);
break; break;
} }

18
reactos/subsystems/win32/win32k/ntuser/window.c
View file

@ -739,7 +739,7 @@ co_DestroyThreadWindows(struct _ETHREAD *Thread)
* \note Does not check the validity of the parameters * \note Does not check the validity of the parameters
*/ */
VOID FASTCALL VOID FASTCALL
IntGetClientRect(PWINDOW_OBJECT Window, PRECT Rect) IntGetClientRect(PWINDOW_OBJECT Window, RECTL *Rect)
{ {
ASSERT( Window ); ASSERT( Window );
ASSERT( Rect ); ASSERT( Rect );
@ -1484,14 +1484,14 @@ NtUserChildWindowFromPointEx(HWND hwndParent,
* calculates the default position of a window * calculates the default position of a window
*/ */
BOOL FASTCALL BOOL FASTCALL
IntCalcDefPosSize(PWINDOW_OBJECT Parent, PWINDOW_OBJECT Window, RECT *rc, BOOL IncPos) IntCalcDefPosSize(PWINDOW_OBJECT Parent, PWINDOW_OBJECT Window, RECTL *rc, BOOL IncPos)
{ {
SIZE Sz; SIZE Sz;
POINT Pos = {0, 0}; POINT Pos = {0, 0};
if(Parent != NULL) if(Parent != NULL)
{ {
IntGdiIntersectRect(rc, rc, &Parent->Wnd->ClientRect); RECTL_bIntersectRect(rc, rc, &Parent->Wnd->ClientRect);
if(IncPos) if(IncPos)
{ {
@ -1899,7 +1899,7 @@ AllocErr:
/* default positioning for overlapped windows */ /* default positioning for overlapped windows */
if(!(Wnd->Style & (WS_POPUP | WS_CHILD))) if(!(Wnd->Style & (WS_POPUP | WS_CHILD)))
{ {
RECT rc, WorkArea; RECTL rc, WorkArea;
PRTL_USER_PROCESS_PARAMETERS ProcessParams; PRTL_USER_PROCESS_PARAMETERS ProcessParams;
BOOL CalculatedDefPosSize = FALSE; BOOL CalculatedDefPosSize = FALSE;
@ -1997,7 +1997,7 @@ AllocErr:
Wnd->WindowRect.bottom = Pos.y + Size.cy; Wnd->WindowRect.bottom = Pos.y + Size.cy;
if (0 != (Wnd->Style & WS_CHILD) && ParentWindow) if (0 != (Wnd->Style & WS_CHILD) && ParentWindow)
{ {
IntGdiOffsetRect(&(Wnd->WindowRect), ParentWindow->Wnd->ClientRect.left, RECTL_vOffsetRect(&(Wnd->WindowRect), ParentWindow->Wnd->ClientRect.left,
ParentWindow->Wnd->ClientRect.top); ParentWindow->Wnd->ClientRect.top);
} }
Wnd->ClientRect = Wnd->WindowRect; Wnd->ClientRect = Wnd->WindowRect;
@ -2032,7 +2032,7 @@ AllocErr:
Wnd->WindowRect.bottom = Pos.y + Size.cy; Wnd->WindowRect.bottom = Pos.y + Size.cy;
if (0 != (Wnd->Style & WS_CHILD) && ParentWindow) if (0 != (Wnd->Style & WS_CHILD) && ParentWindow)
{ {
IntGdiOffsetRect(&(Wnd->WindowRect), ParentWindow->Wnd->ClientRect.left, RECTL_vOffsetRect(&(Wnd->WindowRect), ParentWindow->Wnd->ClientRect.left,
ParentWindow->Wnd->ClientRect.top); ParentWindow->Wnd->ClientRect.top);
} }
Wnd->ClientRect = Wnd->WindowRect; Wnd->ClientRect = Wnd->WindowRect;
@ -2067,7 +2067,7 @@ AllocErr:
&Window->Wnd->WindowRect, &Window->Wnd->WindowRect,
&Window->Wnd->ClientRect); &Window->Wnd->ClientRect);
IntGdiOffsetRect(&Window->Wnd->WindowRect, RECTL_vOffsetRect(&Window->Wnd->WindowRect,
MaxPos.x - Window->Wnd->WindowRect.left, MaxPos.x - Window->Wnd->WindowRect.left,
MaxPos.y - Window->Wnd->WindowRect.top); MaxPos.y - Window->Wnd->WindowRect.top);
@ -2172,7 +2172,7 @@ AllocErr:
/* Show or maybe minimize or maximize the window. */ /* Show or maybe minimize or maximize the window. */
if (Wnd->Style & (WS_MINIMIZE | WS_MAXIMIZE)) if (Wnd->Style & (WS_MINIMIZE | WS_MAXIMIZE))
{ {
RECT NewPos; RECTL NewPos;
UINT16 SwFlag; UINT16 SwFlag;
SwFlag = (Wnd->Style & WS_MINIMIZE) ? SW_MINIMIZE : SwFlag = (Wnd->Style & WS_MINIMIZE) ? SW_MINIMIZE :
@ -4484,7 +4484,7 @@ IntGetWindowRgn(PWINDOW_OBJECT Window, HRGN hRgn)
} }
INT FASTCALL INT FASTCALL
IntGetWindowRgnBox(PWINDOW_OBJECT Window, RECT *Rect) IntGetWindowRgnBox(PWINDOW_OBJECT Window, RECTL *Rect)
{ {
INT Ret; INT Ret;
HRGN VisRgn; HRGN VisRgn;

52
reactos/subsystems/win32/win32k/ntuser/winpos.c
View file

@ -191,7 +191,7 @@ UINT
FASTCALL FASTCALL
co_WinPosArrangeIconicWindows(PWINDOW_OBJECT parent) co_WinPosArrangeIconicWindows(PWINDOW_OBJECT parent)
{ {
RECT rectParent; RECTL rectParent;
INT i, x, y, xspacing, yspacing; INT i, x, y, xspacing, yspacing;
HWND *List = IntWinListChildren(parent); HWND *List = IntWinListChildren(parent);
@ -248,7 +248,7 @@ WinPosFindIconPos(PWINDOW_OBJECT Window, POINT *Pos)
} }
VOID FASTCALL VOID FASTCALL
WinPosInitInternalPos(PWINDOW_OBJECT Window, POINT *pt, PRECT RestoreRect) WinPosInitInternalPos(PWINDOW_OBJECT Window, POINT *pt, RECTL *RestoreRect)
{ {
PWINDOW_OBJECT Parent; PWINDOW_OBJECT Parent;
UINT XInc, YInc; UINT XInc, YInc;
@ -256,7 +256,7 @@ WinPosInitInternalPos(PWINDOW_OBJECT Window, POINT *pt, PRECT RestoreRect)
if (!Wnd->InternalPosInitialized) if (!Wnd->InternalPosInitialized)
{ {
RECT WorkArea; RECTL WorkArea;
PTHREADINFO pti = PsGetCurrentThreadWin32Thread(); PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
PDESKTOP Desktop = pti->Desktop; /* Or rather get it from the window? */ PDESKTOP Desktop = pti->Desktop; /* Or rather get it from the window? */
@ -333,7 +333,7 @@ co_WinPosMinMaximize(PWINDOW_OBJECT Window, UINT ShowFlag, RECT* NewPos)
RDW_NOINTERNALPAINT); RDW_NOINTERNALPAINT);
Wnd->Style |= WS_MINIMIZE; Wnd->Style |= WS_MINIMIZE;
WinPosFindIconPos(Window, &Wnd->InternalPos.IconPos); WinPosFindIconPos(Window, &Wnd->InternalPos.IconPos);
IntGdiSetRect(NewPos, Wnd->InternalPos.IconPos.x, Wnd->InternalPos.IconPos.y, RECTL_vSetRect(NewPos, Wnd->InternalPos.IconPos.x, Wnd->InternalPos.IconPos.y,
UserGetSystemMetrics(SM_CXMINIMIZED), UserGetSystemMetrics(SM_CXMINIMIZED),
UserGetSystemMetrics(SM_CYMINIMIZED)); UserGetSystemMetrics(SM_CYMINIMIZED));
SwpFlags |= SWP_NOCOPYBITS; SwpFlags |= SWP_NOCOPYBITS;
@ -351,7 +351,7 @@ co_WinPosMinMaximize(PWINDOW_OBJECT Window, UINT ShowFlag, RECT* NewPos)
Wnd->Style &= ~WS_MINIMIZE; Wnd->Style &= ~WS_MINIMIZE;
} }
Wnd->Style |= WS_MAXIMIZE; Wnd->Style |= WS_MAXIMIZE;
IntGdiSetRect(NewPos, Wnd->InternalPos.MaxPos.x, Wnd->InternalPos.MaxPos.y, RECTL_vSetRect(NewPos, Wnd->InternalPos.MaxPos.x, Wnd->InternalPos.MaxPos.y,
Size.x, Size.y); Size.x, Size.y);
break; break;
} }
@ -366,7 +366,7 @@ co_WinPosMinMaximize(PWINDOW_OBJECT Window, UINT ShowFlag, RECT* NewPos)
co_WinPosGetMinMaxInfo(Window, &Size, co_WinPosGetMinMaxInfo(Window, &Size,
&Wnd->InternalPos.MaxPos, NULL, NULL); &Wnd->InternalPos.MaxPos, NULL, NULL);
Wnd->Style |= WS_MAXIMIZE; Wnd->Style |= WS_MAXIMIZE;
IntGdiSetRect(NewPos, Wnd->InternalPos.MaxPos.x, RECTL_vSetRect(NewPos, Wnd->InternalPos.MaxPos.x,
Wnd->InternalPos.MaxPos.y, Size.x, Size.y); Wnd->InternalPos.MaxPos.y, Size.x, Size.y);
break; break;
} }
@ -401,7 +401,7 @@ VOID FASTCALL
WinPosFillMinMaxInfoStruct(PWINDOW_OBJECT Window, MINMAXINFO *Info) WinPosFillMinMaxInfoStruct(PWINDOW_OBJECT Window, MINMAXINFO *Info)
{ {
UINT XInc, YInc; UINT XInc, YInc;
RECT WorkArea; RECTL WorkArea;
PTHREADINFO pti = PsGetCurrentThreadWin32Thread(); PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
PDESKTOP Desktop = pti->Desktop; /* Or rather get it from the window? */ PDESKTOP Desktop = pti->Desktop; /* Or rather get it from the window? */
@ -459,7 +459,7 @@ co_WinPosGetMinMaxInfo(PWINDOW_OBJECT Window, POINT* MaxSize, POINT* MaxPos,
static static
VOID FASTCALL VOID FASTCALL
FixClientRect(PRECT ClientRect, PRECT WindowRect) FixClientRect(PRECTL ClientRect, PRECTL WindowRect)
{ {
if (ClientRect->left < WindowRect->left) if (ClientRect->left < WindowRect->left)
{ {
@ -519,11 +519,11 @@ co_WinPosDoNCCALCSize(PWINDOW_OBJECT Window, PWINDOWPOS WinPos,
Parent = Window->Parent; Parent = Window->Parent;
if (0 != (Wnd->Style & WS_CHILD) && Parent) if (0 != (Wnd->Style & WS_CHILD) && Parent)
{ {
IntGdiOffsetRect(&(params.rgrc[0]), - Parent->Wnd->ClientRect.left, RECTL_vOffsetRect(&(params.rgrc[0]), - Parent->Wnd->ClientRect.left,
- Parent->Wnd->ClientRect.top); - Parent->Wnd->ClientRect.top);
IntGdiOffsetRect(&(params.rgrc[1]), - Parent->Wnd->ClientRect.left, RECTL_vOffsetRect(&(params.rgrc[1]), - Parent->Wnd->ClientRect.left,
- Parent->Wnd->ClientRect.top); - Parent->Wnd->ClientRect.top);
IntGdiOffsetRect(&(params.rgrc[2]), - Parent->Wnd->ClientRect.left, RECTL_vOffsetRect(&(params.rgrc[2]), - Parent->Wnd->ClientRect.left,
- Parent->Wnd->ClientRect.top); - Parent->Wnd->ClientRect.top);
} }
params.lppos = &winposCopy; params.lppos = &winposCopy;
@ -538,7 +538,7 @@ co_WinPosDoNCCALCSize(PWINDOW_OBJECT Window, PWINDOWPOS WinPos,
*ClientRect = params.rgrc[0]; *ClientRect = params.rgrc[0];
if ((Wnd->Style & WS_CHILD) && Parent) if ((Wnd->Style & WS_CHILD) && Parent)
{ {
IntGdiOffsetRect(ClientRect, Parent->Wnd->ClientRect.left, RECTL_vOffsetRect(ClientRect, Parent->Wnd->ClientRect.left,
Parent->Wnd->ClientRect.top); Parent->Wnd->ClientRect.top);
} }
FixClientRect(ClientRect, WindowRect); FixClientRect(ClientRect, WindowRect);
@ -577,8 +577,8 @@ static
BOOL FASTCALL BOOL FASTCALL
co_WinPosDoWinPosChanging(PWINDOW_OBJECT Window, co_WinPosDoWinPosChanging(PWINDOW_OBJECT Window,
PWINDOWPOS WinPos, PWINDOWPOS WinPos,
PRECT WindowRect, PRECTL WindowRect,
PRECT ClientRect) PRECTL ClientRect)
{ {
INT X, Y; INT X, Y;
PWINDOW Wnd; PWINDOW Wnd;
@ -616,7 +616,7 @@ co_WinPosDoWinPosChanging(PWINDOW_OBJECT Window,
WindowRect->top = Y; WindowRect->top = Y;
WindowRect->right += X - Wnd->WindowRect.left; WindowRect->right += X - Wnd->WindowRect.left;
WindowRect->bottom += Y - Wnd->WindowRect.top; WindowRect->bottom += Y - Wnd->WindowRect.top;
IntGdiOffsetRect(ClientRect, RECTL_vOffsetRect(ClientRect,
X - Wnd->WindowRect.left, X - Wnd->WindowRect.left,
Y - Wnd->WindowRect.top); Y - Wnd->WindowRect.top);
} }
@ -871,8 +871,8 @@ co_WinPosSetWindowPos(
) )
{ {
WINDOWPOS WinPos; WINDOWPOS WinPos;
RECT NewWindowRect; RECTL NewWindowRect;
RECT NewClientRect; RECTL NewClientRect;
PROSRGNDATA VisRgn; PROSRGNDATA VisRgn;
HRGN VisBefore = NULL; HRGN VisBefore = NULL;
HRGN VisAfter = NULL; HRGN VisAfter = NULL;
@ -880,11 +880,11 @@ co_WinPosSetWindowPos(
HRGN ExposedRgn = NULL; HRGN ExposedRgn = NULL;
HRGN CopyRgn = NULL; HRGN CopyRgn = NULL;
ULONG WvrFlags = 0; ULONG WvrFlags = 0;
RECT OldWindowRect, OldClientRect; RECTL OldWindowRect, OldClientRect;
int RgnType; int RgnType;
HDC Dc; HDC Dc;
RECT CopyRect; RECTL CopyRect;
RECT TempRect; RECTL TempRect;
PWINDOW_OBJECT Ancestor; PWINDOW_OBJECT Ancestor;
ASSERT_REFS_CO(Window); ASSERT_REFS_CO(Window);
@ -1132,11 +1132,11 @@ co_WinPosSetWindowPos(
RgnType != NULLREGION) RgnType != NULLREGION)
{ {
PROSRGNDATA pCopyRgn; PROSRGNDATA pCopyRgn;
RECT ORect = OldClientRect; RECTL ORect = OldClientRect;
RECT NRect = NewClientRect; RECTL NRect = NewClientRect;
IntGdiOffsetRect(&ORect, - OldWindowRect.left, - OldWindowRect.top); RECTL_vOffsetRect(&ORect, - OldWindowRect.left, - OldWindowRect.top);
IntGdiOffsetRect(&NRect, - NewWindowRect.left, - NewWindowRect.top); RECTL_vOffsetRect(&NRect, - NewWindowRect.left, - NewWindowRect.top);
IntGdiIntersectRect(&CopyRect, &ORect, &NRect); RECTL_bIntersectRect(&CopyRect, &ORect, &NRect);
pCopyRgn = REGION_LockRgn(CopyRgn); pCopyRgn = REGION_LockRgn(CopyRgn);
REGION_CropAndOffsetRegion(pCopyRgn, pCopyRgn, &CopyRect, NULL); REGION_CropAndOffsetRegion(pCopyRgn, pCopyRgn, &CopyRect, NULL);
REGION_UnlockRgn(pCopyRgn); REGION_UnlockRgn(pCopyRgn);
@ -1316,7 +1316,7 @@ co_WinPosShowWindow(PWINDOW_OBJECT Window, INT Cmd)
{ {
BOOLEAN WasVisible; BOOLEAN WasVisible;
UINT Swp = 0; UINT Swp = 0;
RECT NewPos; RECTL NewPos;
BOOLEAN ShowFlag; BOOLEAN ShowFlag;
// HRGN VisibleRgn; // HRGN VisibleRgn;
PWINDOW Wnd; PWINDOW Wnd;

10
reactos/subsystems/win32/win32k/objects/bitmaps.c
View file

@ -23,14 +23,6 @@
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
#define IN_RECT(r,x,y) \
( \
(x) >= (r).left && \
(y) >= (r).top && \
(x) < (r).right && \
(y) < (r).bottom \
)
HBITMAP APIENTRY HBITMAP APIENTRY
IntGdiCreateBitmap( IntGdiCreateBitmap(
INT Width, INT Width,
@ -366,7 +358,7 @@ NtGdiGetPixel(HDC hDC, INT XPos, INT YPos)
XPos += dc->ptlDCOrig.x; XPos += dc->ptlDCOrig.x;
YPos += dc->ptlDCOrig.y; YPos += dc->ptlDCOrig.y;
if (IN_RECT(dc->CombinedClip->rclBounds,XPos,YPos)) if (RECTL_bPointInRect(&dc->CombinedClip->rclBounds, XPos, YPos))
{ {
bInRect = TRUE; bInRect = TRUE;
psurf = SURFACE_LockSurface(dc->w.hBitmap); psurf = SURFACE_LockSurface(dc->w.hBitmap);

24
reactos/subsystems/win32/win32k/objects/cliprgn.c
View file

@ -43,8 +43,8 @@ CLIPPING_UpdateGCRegion(DC* Dc)
Dc->CombinedClip = IntEngCreateClipRegion( Dc->CombinedClip = IntEngCreateClipRegion(
CombinedRegion->rdh.nCount, CombinedRegion->rdh.nCount,
(PRECTL)CombinedRegion->Buffer, CombinedRegion->Buffer,
(PRECTL)&CombinedRegion->rdh.rcBound); &CombinedRegion->rdh.rcBound);
REGION_UnlockRgn(CombinedRegion); REGION_UnlockRgn(CombinedRegion);
} }
@ -124,7 +124,7 @@ int FASTCALL GdiExtSelectClipRgn(PDC dc,
if (!dc->w.hClipRgn) if (!dc->w.hClipRgn)
{ {
PROSRGNDATA Rgn; PROSRGNDATA Rgn;
RECT rect; RECTL rect;
if((Rgn = REGION_LockRgn(dc->w.hVisRgn))) if((Rgn = REGION_LockRgn(dc->w.hVisRgn)))
{ {
REGION_GetRgnBox(Rgn, &rect); REGION_GetRgnBox(Rgn, &rect);
@ -169,7 +169,7 @@ int APIENTRY NtGdiExtSelectClipRgn(HDC hDC,
} }
INT FASTCALL INT FASTCALL
GdiGetClipBox(HDC hDC, LPRECT rc) GdiGetClipBox(HDC hDC, PRECTL rc)
{ {
PROSRGNDATA Rgn; PROSRGNDATA Rgn;
INT retval; INT retval;
@ -194,11 +194,11 @@ GdiGetClipBox(HDC hDC, LPRECT rc)
} }
INT APIENTRY INT APIENTRY
NtGdiGetAppClipBox(HDC hDC, LPRECT rc) NtGdiGetAppClipBox(HDC hDC, PRECTL rc)
{ {
INT Ret; INT Ret;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
RECT Saferect; RECTL Saferect;
Ret = GdiGetClipBox(hDC, &Saferect); Ret = GdiGetClipBox(hDC, &Saferect);
@ -231,7 +231,7 @@ int APIENTRY NtGdiExcludeClipRect(HDC hDC,
int BottomRect) int BottomRect)
{ {
INT Result; INT Result;
RECT Rect; RECTL Rect;
HRGN NewRgn; HRGN NewRgn;
PDC dc = DC_LockDc(hDC); PDC dc = DC_LockDc(hDC);
@ -282,7 +282,7 @@ int APIENTRY NtGdiIntersectClipRect(HDC hDC,
int BottomRect) int BottomRect)
{ {
INT Result; INT Result;
RECT Rect; RECTL Rect;
HRGN NewRgn; HRGN NewRgn;
PDC dc = DC_LockDc(hDC); PDC dc = DC_LockDc(hDC);
@ -374,13 +374,13 @@ BOOL APIENTRY NtGdiPtVisible(HDC hDC,
} }
BOOL APIENTRY NtGdiRectVisible(HDC hDC, BOOL APIENTRY NtGdiRectVisible(HDC hDC,
CONST PRECT UnsafeRect) LPRECT UnsafeRect)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
PROSRGNDATA Rgn; PROSRGNDATA Rgn;
PDC dc = DC_LockDc(hDC); PDC dc = DC_LockDc(hDC);
BOOL Result = FALSE; BOOL Result = FALSE;
RECT Rect; RECTL Rect;
if (!dc) if (!dc)
{ {
@ -545,8 +545,8 @@ NEW_CLIPPING_UpdateGCRegion(PDC pDC)
// if (Dc->CombinedClip != NULL) IntEngDeleteClipRegion(Dc->CombinedClip); // if (Dc->CombinedClip != NULL) IntEngDeleteClipRegion(Dc->CombinedClip);
co = IntEngCreateClipRegion( ((PROSRGNDATA)pDC->prgnRao)->rdh.nCount, co = IntEngCreateClipRegion( ((PROSRGNDATA)pDC->prgnRao)->rdh.nCount,
(PRECTL)((PROSRGNDATA)pDC->prgnRao)->Buffer, ((PROSRGNDATA)pDC->prgnRao)->Buffer,
(PRECTL)&pDC->erclClip); &pDC->erclClip);
return REGION_Complexity(pDC->prgnRao); return REGION_Complexity(pDC->prgnRao);
} }

6
reactos/subsystems/win32/win32k/objects/freetype.c
View file

@ -3105,7 +3105,7 @@ GreExtTextOutW(
IN INT XStart, IN INT XStart,
IN INT YStart, IN INT YStart,
IN UINT fuOptions, IN UINT fuOptions,
IN OPTIONAL LPRECT lprc, IN OPTIONAL PRECTL lprc,
IN LPWSTR String, IN LPWSTR String,
IN INT Count, IN INT Count,
IN OPTIONAL LPINT Dx, IN OPTIONAL LPINT Dx,
@ -3188,7 +3188,7 @@ GreExtTextOutW(
XStart, XStart,
YStart, YStart,
fuOptions, fuOptions,
(const RECT *)lprc, (const RECTL *)lprc,
String, String,
Count, Count,
(const INT *)Dx)) goto fail; (const INT *)Dx)) goto fail;
@ -3694,7 +3694,7 @@ NtGdiExtTextOutW(
{ {
BOOL Result = FALSE; BOOL Result = FALSE;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
RECT SafeRect; RECTL SafeRect;
BYTE LocalBuffer[STACK_TEXT_BUFFER_SIZE]; BYTE LocalBuffer[STACK_TEXT_BUFFER_SIZE];
PVOID Buffer = LocalBuffer; PVOID Buffer = LocalBuffer;
LPWSTR SafeString = NULL; LPWSTR SafeString = NULL;

2
reactos/subsystems/win32/win32k/objects/path.c
View file

@ -2025,7 +2025,7 @@ PATH_add_outline(PDC dc, INT x, INT y, TTPOLYGONHEADER *header, DWORD size)
*/ */
BOOL BOOL
FASTCALL FASTCALL
PATH_ExtTextOut(PDC dc, INT x, INT y, UINT flags, const RECT *lprc, PATH_ExtTextOut(PDC dc, INT x, INT y, UINT flags, const RECTL *lprc,
LPCWSTR str, UINT count, const INT *dx) LPCWSTR str, UINT count, const INT *dx)
{ {
unsigned int idx; unsigned int idx;

106
reactos/subsystems/win32/win32k/objects/rect.c
View file

@ -25,87 +25,61 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
VOID FASTCALL BOOL
IntGdiSetEmptyRect(PRECT Rect) FASTCALL
RECTL_bUnionRect(RECTL *prclDst, const RECTL *prcl1, const RECTL *prcl2)
{ {
Rect->left = Rect->right = Rect->top = Rect->bottom = 0; if (RECTL_bIsEmptyRect(prcl1))
}
BOOL FASTCALL
IntGdiIsEmptyRect(const RECT* Rect)
{
return(Rect->left >= Rect->right || Rect->top >= Rect->bottom);
}
VOID FASTCALL
IntGdiOffsetRect(LPRECT Rect, INT x, INT y)
{
Rect->left += x;
Rect->right += x;
Rect->top += y;
Rect->bottom += y;
}
BOOL FASTCALL
IntGdiUnionRect(PRECT Dest, const RECT* Src1, const RECT* Src2)
{
if (IntGdiIsEmptyRect(Src1))
{ {
if (IntGdiIsEmptyRect(Src2)) if (RECTL_bIsEmptyRect(prcl2))
{ {
IntGdiSetEmptyRect(Dest); RECTL_vSetEmptyRect(prclDst);
return FALSE; return FALSE;
} }
else else
{ {
*Dest = *Src2; *prclDst = *prcl2;
} }
} }
else else
{ {
if (IntGdiIsEmptyRect(Src2)) if (RECTL_bIsEmptyRect(prcl2))
{ {
*Dest = *Src1; *prclDst = *prcl1;
} }
else else
{ {
Dest->left = min(Src1->left, Src2->left); prclDst->left = min(prcl1->left, prcl2->left);
Dest->top = min(Src1->top, Src2->top); prclDst->top = min(prcl1->top, prcl2->top);
Dest->right = max(Src1->right, Src2->right); prclDst->right = max(prcl1->right, prcl2->right);
Dest->bottom = max(Src1->bottom, Src2->bottom); prclDst->bottom = max(prcl1->bottom, prcl2->bottom);
} }
} }
return TRUE; return TRUE;
} }
VOID FASTCALL
IntGdiSetRect(PRECT Rect, INT left, INT top, INT right, INT bottom)
{
Rect->left = left;
Rect->top = top;
Rect->right = right;
Rect->bottom = bottom;
}
BOOL FASTCALL BOOL
IntGdiIntersectRect(PRECT Dest, const RECT* Src1, const RECT* Src2) FASTCALL
RECTL_bIntersectRect(RECTL *prclDst, const RECTL *prcl1, const RECTL *prcl2)
{ {
if (IntGdiIsEmptyRect(Src1) || IntGdiIsEmptyRect(Src2) || if (RECTL_bIsEmptyRect(prcl1) || RECTL_bIsEmptyRect(prcl2) ||
Src1->left >= Src2->right || Src2->left >= Src1->right || prcl1->left >= prcl2->right || prcl2->left >= prcl1->right ||
Src1->top >= Src2->bottom || Src2->top >= Src1->bottom) prcl1->top >= prcl2->bottom || prcl2->top >= prcl1->bottom)
{ {
IntGdiSetEmptyRect(Dest); RECTL_vSetEmptyRect(prclDst);
return FALSE; return FALSE;
} }
Dest->left = max(Src1->left, Src2->left); prclDst->left = max(prcl1->left, prcl2->left);
Dest->right = min(Src1->right, Src2->right); prclDst->right = min(prcl1->right, prcl2->right);
Dest->top = max(Src1->top, Src2->top); prclDst->top = max(prcl1->top, prcl2->top);
Dest->bottom = min(Src1->bottom, Src2->bottom); prclDst->bottom = min(prcl1->bottom, prcl2->bottom);
return TRUE; return TRUE;
} }
/* EOF */ /* EOF */

238
reactos/subsystems/win32/win32k/objects/region.c
View file

@ -126,15 +126,15 @@ HRGN hrgnDefault = NULL;
#if 1 #if 1
#define COPY_RECTS(dest, src, nRects) \ #define COPY_RECTS(dest, src, nRects) \
do { \ do { \
PRECT xDest = (dest); \ PRECTL xDest = (dest); \
PRECT xSrc = (src); \ PRECTL xSrc = (src); \
UINT xRects = (nRects); \ UINT xRects = (nRects); \
while(xRects-- > 0) { \ while(xRects-- > 0) { \
*(xDest++) = *(xSrc++); \ *(xDest++) = *(xSrc++); \
} \ } \
} while(0) } while(0)
#else #else
#define COPY_RECTS(dest, src, nRects) RtlCopyMemory(dest, src, (nRects) * sizeof(RECT)) #define COPY_RECTS(dest, src, nRects) RtlCopyMemory(dest, src, (nRects) * sizeof(RECTL))
#endif #endif
#define EMPTY_REGION(pReg) { \ #define EMPTY_REGION(pReg) { \
@ -408,11 +408,11 @@ typedef struct _ScanLineListBlock
/* /*
* Check to see if there is enough memory in the present region. * Check to see if there is enough memory in the present region.
*/ */
static __inline int xmemcheck(ROSRGNDATA *reg, PRECT *rect, PRECT *firstrect) static __inline int xmemcheck(ROSRGNDATA *reg, PRECTL *rect, PRECTL *firstrect)
{ {
if ( (reg->rdh.nCount+1) * sizeof(RECT) >= reg->rdh.nRgnSize ) if ( (reg->rdh.nCount+1) * sizeof(RECT) >= reg->rdh.nRgnSize )
{ {
PRECT temp; PRECTL temp;
DWORD NewSize = 2 * reg->rdh.nRgnSize; DWORD NewSize = 2 * reg->rdh.nRgnSize;
if (NewSize < (reg->rdh.nCount + 1) * sizeof(RECT)) if (NewSize < (reg->rdh.nCount + 1) * sizeof(RECT))
{ {
@ -439,7 +439,7 @@ static __inline int xmemcheck(ROSRGNDATA *reg, PRECT *rect, PRECT *firstrect)
return 1; return 1;
} }
#define MEMCHECK(reg, rect, firstrect) xmemcheck(reg,&(rect),(LPRECT *)&(firstrect)) #define MEMCHECK(reg, rect, firstrect) xmemcheck(reg,&(rect),(PRECTL *)&(firstrect))
typedef void (FASTCALL *overlapProcp)(PROSRGNDATA, PRECT, PRECT, PRECT, PRECT, INT, INT); typedef void (FASTCALL *overlapProcp)(PROSRGNDATA, PRECT, PRECT, PRECT, PRECT, INT, INT);
typedef void (FASTCALL *nonOverlapProcp)(PROSRGNDATA, PRECT, PRECT, INT, INT); typedef void (FASTCALL *nonOverlapProcp)(PROSRGNDATA, PRECT, PRECT, INT, INT);
@ -513,7 +513,7 @@ REGION_CopyRegion(
{ {
if (dst->rdh.nRgnSize < src->rdh.nCount * sizeof(RECT)) if (dst->rdh.nRgnSize < src->rdh.nCount * sizeof(RECT))
{ {
PRECT temp; PRECTL temp;
temp = ExAllocatePoolWithTag(PagedPool, src->rdh.nCount * sizeof(RECT), TAG_REGION ); temp = ExAllocatePoolWithTag(PagedPool, src->rdh.nCount * sizeof(RECT), TAG_REGION );
if (!temp) if (!temp)
@ -538,7 +538,7 @@ REGION_CopyRegion(
static void FASTCALL static void FASTCALL
REGION_SetExtents(ROSRGNDATA *pReg) REGION_SetExtents(ROSRGNDATA *pReg)
{ {
RECT *pRect, *pRectEnd, *pExtents; RECTL *pRect, *pRectEnd, *pExtents;
if (pReg->rdh.nCount == 0) if (pReg->rdh.nCount == 0)
{ {
@ -551,8 +551,8 @@ REGION_SetExtents(ROSRGNDATA *pReg)
} }
pExtents = &pReg->rdh.rcBound; pExtents = &pReg->rdh.rcBound;
pRect = (PRECT)pReg->Buffer; pRect = pReg->Buffer;
pRectEnd = (PRECT)pReg->Buffer + pReg->rdh.nCount - 1; pRectEnd = pReg->Buffer + pReg->rdh.nCount - 1;
/* /*
* Since pRect is the first rectangle in the region, it must have the * Since pRect is the first rectangle in the region, it must have the
@ -585,22 +585,22 @@ BOOL FASTCALL
REGION_CropAndOffsetRegion( REGION_CropAndOffsetRegion(
PROSRGNDATA rgnDst, PROSRGNDATA rgnDst,
PROSRGNDATA rgnSrc, PROSRGNDATA rgnSrc,
const PRECT rect, const RECTL *rect,
const PPOINT offset const POINTL *offset
) )
{ {
POINT pt = {0,0}; POINT pt = {0,0};
PPOINT off = offset; const POINT *off = offset;
if (!off) off = &pt; if (!off) off = &pt;
if (!rect) // just copy and offset if (!rect) // just copy and offset
{ {
PRECT xrect; PRECTL xrect;
if (rgnDst == rgnSrc) if (rgnDst == rgnSrc)
{ {
if (off->x || off->y) if (off->x || off->y)
xrect = (PRECT)rgnDst->Buffer; xrect = rgnDst->Buffer;
else else
return TRUE; return TRUE;
} }
@ -624,10 +624,10 @@ REGION_CropAndOffsetRegion(
{ {
for (i = 0; i < rgnDst->rdh.nCount; i++) for (i = 0; i < rgnDst->rdh.nCount; i++)
{ {
xrect[i].left = ((PRECT)rgnSrc->Buffer + i)->left + off->x; xrect[i].left = (rgnSrc->Buffer + i)->left + off->x;
xrect[i].right = ((PRECT)rgnSrc->Buffer + i)->right + off->x; xrect[i].right = (rgnSrc->Buffer + i)->right + off->x;
xrect[i].top = ((PRECT)rgnSrc->Buffer + i)->top + off->y; xrect[i].top = (rgnSrc->Buffer + i)->top + off->y;
xrect[i].bottom = ((PRECT)rgnSrc->Buffer + i)->bottom + off->y; xrect[i].bottom = (rgnSrc->Buffer + i)->bottom + off->y;
} }
rgnDst->rdh.rcBound.left += off->x; rgnDst->rdh.rcBound.left += off->x;
rgnDst->rdh.rcBound.right += off->x; rgnDst->rdh.rcBound.right += off->x;
@ -652,17 +652,17 @@ REGION_CropAndOffsetRegion(
} }
else // region box and clipping rect appear to intersect else // region box and clipping rect appear to intersect
{ {
PRECT lpr, rpr; PRECTL lpr, rpr;
ULONG i, j, clipa, clipb; ULONG i, j, clipa, clipb;
INT left = rgnSrc->rdh.rcBound.right + off->x; INT left = rgnSrc->rdh.rcBound.right + off->x;
INT right = rgnSrc->rdh.rcBound.left + off->x; INT right = rgnSrc->rdh.rcBound.left + off->x;
for (clipa = 0; ((PRECT)rgnSrc->Buffer + clipa)->bottom <= rect->top; clipa++) for (clipa = 0; (rgnSrc->Buffer + clipa)->bottom <= rect->top; clipa++)
//region and rect intersect so we stop before clipa > rgnSrc->rdh.nCount //region and rect intersect so we stop before clipa > rgnSrc->rdh.nCount
; // skip bands above the clipping rectangle ; // skip bands above the clipping rectangle
for (clipb = clipa; clipb < rgnSrc->rdh.nCount; clipb++) for (clipb = clipa; clipb < rgnSrc->rdh.nCount; clipb++)
if (((PRECT)rgnSrc->Buffer + clipb)->top >= rect->bottom) if ((rgnSrc->Buffer + clipb)->top >= rect->bottom)
break; // and below it break; // and below it
// clipa - index of the first rect in the first intersecting band // clipa - index of the first rect in the first intersecting band
@ -670,7 +670,7 @@ REGION_CropAndOffsetRegion(
if ((rgnDst != rgnSrc) && (rgnDst->rdh.nCount < (i = (clipb - clipa)))) if ((rgnDst != rgnSrc) && (rgnDst->rdh.nCount < (i = (clipb - clipa))))
{ {
PRECT temp; PRECTL temp;
temp = ExAllocatePoolWithTag(PagedPool, i * sizeof(RECT), TAG_REGION); temp = ExAllocatePoolWithTag(PagedPool, i * sizeof(RECT), TAG_REGION);
if (!temp) if (!temp)
return FALSE; return FALSE;
@ -686,11 +686,11 @@ REGION_CropAndOffsetRegion(
{ {
// i - src index, j - dst index, j is always <= i for obvious reasons // i - src index, j - dst index, j is always <= i for obvious reasons
lpr = (PRECT)rgnSrc->Buffer + i; lpr = rgnSrc->Buffer + i;
if (lpr->left < rect->right && lpr->right > rect->left) if (lpr->left < rect->right && lpr->right > rect->left)
{ {
rpr = (PRECT)rgnDst->Buffer + j; rpr = rgnDst->Buffer + j;
rpr->top = lpr->top + off->y; rpr->top = lpr->top + off->y;
rpr->bottom = lpr->bottom + off->y; rpr->bottom = lpr->bottom + off->y;
@ -720,13 +720,13 @@ REGION_CropAndOffsetRegion(
break; break;
for (i = j; i > 0; i--) // fixup bottom band for (i = j; i > 0; i--) // fixup bottom band
if (((PRECT)rgnDst->Buffer + i)->bottom > right) if ((rgnDst->Buffer + i)->bottom > right)
((PRECT)rgnDst->Buffer + i)->bottom = right; (rgnDst->Buffer + i)->bottom = right;
else else
break; break;
rgnDst->rdh.rcBound.top = ((PRECT)rgnDst->Buffer)->top; rgnDst->rdh.rcBound.top = (rgnDst->Buffer)->top;
rgnDst->rdh.rcBound.bottom = ((PRECT)rgnDst->Buffer + j)->bottom; rgnDst->rdh.rcBound.bottom = (rgnDst->Buffer + j)->bottom;
rgnDst->rdh.iType = RDH_RECTANGLES; rgnDst->rdh.iType = RDH_RECTANGLES;
} }
@ -736,7 +736,7 @@ REGION_CropAndOffsetRegion(
empty: empty:
if (!rgnDst->Buffer) if (!rgnDst->Buffer)
{ {
rgnDst->Buffer = (PRECT)ExAllocatePoolWithTag(PagedPool, RGN_DEFAULT_RECTS * sizeof(RECT), TAG_REGION); rgnDst->Buffer = ExAllocatePoolWithTag(PagedPool, RGN_DEFAULT_RECTS * sizeof(RECT), TAG_REGION);
if (rgnDst->Buffer) if (rgnDst->Buffer)
{ {
rgnDst->rdh.nCount = RGN_DEFAULT_RECTS; rgnDst->rdh.nCount = RGN_DEFAULT_RECTS;
@ -771,15 +771,15 @@ REGION_Coalesce(
INT curStart /* Index of start of current band */ INT curStart /* Index of start of current band */
) )
{ {
RECT *pPrevRect; /* Current rect in previous band */ RECTL *pPrevRect; /* Current rect in previous band */
RECT *pCurRect; /* Current rect in current band */ RECTL *pCurRect; /* Current rect in current band */
RECT *pRegEnd; /* End of region */ RECTL *pRegEnd; /* End of region */
INT curNumRects; /* Number of rectangles in current band */ INT curNumRects; /* Number of rectangles in current band */
INT prevNumRects; /* Number of rectangles in previous band */ INT prevNumRects; /* Number of rectangles in previous band */
INT bandtop; /* top coordinate for current band */ INT bandtop; /* top coordinate for current band */
pRegEnd = (PRECT)pReg->Buffer + pReg->rdh.nCount; pRegEnd = pReg->Buffer + pReg->rdh.nCount;
pPrevRect = (PRECT)pReg->Buffer + prevStart; pPrevRect = pReg->Buffer + prevStart;
prevNumRects = curStart - prevStart; prevNumRects = curStart - prevStart;
/* /*
@ -787,7 +787,7 @@ REGION_Coalesce(
* this because multiple bands could have been added in REGION_RegionOp * this because multiple bands could have been added in REGION_RegionOp
* at the end when one region has been exhausted. * at the end when one region has been exhausted.
*/ */
pCurRect = (PRECT)pReg->Buffer + curStart; pCurRect = pReg->Buffer + curStart;
bandtop = pCurRect->top; bandtop = pCurRect->top;
for (curNumRects = 0; for (curNumRects = 0;
(pCurRect != pRegEnd) && (pCurRect->top == bandtop); (pCurRect != pRegEnd) && (pCurRect->top == bandtop);
@ -809,8 +809,8 @@ REGION_Coalesce(
{ {
pRegEnd--; pRegEnd--;
} }
curStart = pRegEnd - (PRECT)pReg->Buffer; curStart = pRegEnd - pReg->Buffer;
pRegEnd = (PRECT)pReg->Buffer + pReg->rdh.nCount; pRegEnd = pReg->Buffer + pReg->rdh.nCount;
} }
if ((curNumRects == prevNumRects) && (curNumRects != 0)) if ((curNumRects == prevNumRects) && (curNumRects != 0))
@ -921,18 +921,18 @@ REGION_RegionOp(
nonOverlapProcp nonOverlap2Func /* Function to call for non-overlapping bands in region 2 */ nonOverlapProcp nonOverlap2Func /* Function to call for non-overlapping bands in region 2 */
) )
{ {
RECT *r1; /* Pointer into first region */ RECTL *r1; /* Pointer into first region */
RECT *r2; /* Pointer into 2d region */ RECTL *r2; /* Pointer into 2d region */
RECT *r1End; /* End of 1st region */ RECTL *r1End; /* End of 1st region */
RECT *r2End; /* End of 2d region */ RECTL *r2End; /* End of 2d region */
INT ybot; /* Bottom of intersection */ INT ybot; /* Bottom of intersection */
INT ytop; /* Top of intersection */ INT ytop; /* Top of intersection */
RECT *oldRects; /* Old rects for newReg */ RECTL *oldRects; /* Old rects for newReg */
ULONG prevBand; /* Index of start of ULONG prevBand; /* Index of start of
* previous band in newReg */ * previous band in newReg */
ULONG curBand; /* Index of start of current band in newReg */ ULONG curBand; /* Index of start of current band in newReg */
RECT *r1BandEnd; /* End of current band in r1 */ RECTL *r1BandEnd; /* End of current band in r1 */
RECT *r2BandEnd; /* End of current band in r2 */ RECTL *r2BandEnd; /* End of current band in r2 */
ULONG top; /* Top of non-overlapping band */ ULONG top; /* Top of non-overlapping band */
ULONG bot; /* Bottom of non-overlapping band */ ULONG bot; /* Bottom of non-overlapping band */
@ -943,8 +943,8 @@ REGION_RegionOp(
* the two source regions, then mark the "new" region empty, allocating * the two source regions, then mark the "new" region empty, allocating
* another array of rectangles for it to use. * another array of rectangles for it to use.
*/ */
r1 = (PRECT)reg1->Buffer; r1 = reg1->Buffer;
r2 = (PRECT)reg2->Buffer; r2 = reg2->Buffer;
r1End = r1 + reg1->rdh.nCount; r1End = r1 + reg1->rdh.nCount;
r2End = r2 + reg2->rdh.nCount; r2End = r2 + reg2->rdh.nCount;
@ -955,7 +955,7 @@ REGION_RegionOp(
* extents and simply set numRects to zero. * extents and simply set numRects to zero.
*/ */
oldRects = (PRECT)newReg->Buffer; oldRects = newReg->Buffer;
newReg->rdh.nCount = 0; newReg->rdh.nCount = 0;
/* /*
@ -1159,7 +1159,7 @@ REGION_RegionOp(
{ {
if (REGION_NOT_EMPTY(newReg)) if (REGION_NOT_EMPTY(newReg))
{ {
RECT *prev_rects = (PRECT)newReg->Buffer; RECTL *prev_rects = newReg->Buffer;
newReg->Buffer = ExAllocatePoolWithTag(PagedPool, newReg->rdh.nCount*sizeof(RECT), TAG_REGION); newReg->Buffer = ExAllocatePoolWithTag(PagedPool, newReg->rdh.nCount*sizeof(RECT), TAG_REGION);
if (! newReg->Buffer) if (! newReg->Buffer)
@ -1210,18 +1210,18 @@ REGION_RegionOp(
static void FASTCALL static void FASTCALL
REGION_IntersectO( REGION_IntersectO(
PROSRGNDATA pReg, PROSRGNDATA pReg,
PRECT r1, PRECTL r1,
PRECT r1End, PRECTL r1End,
PRECT r2, PRECTL r2,
PRECT r2End, PRECTL r2End,
INT top, INT top,
INT bottom INT bottom
) )
{ {
INT left, right; INT left, right;
RECT *pNextRect; RECTL *pNextRect;
pNextRect = (PRECT)pReg->Buffer + pReg->rdh.nCount; pNextRect = pReg->Buffer + pReg->rdh.nCount;
while ((r1 != r1End) && (r2 != r2End)) while ((r1 != r1End) && (r2 != r2End))
{ {
@ -1317,15 +1317,15 @@ REGION_IntersectRegion(
static void FASTCALL static void FASTCALL
REGION_UnionNonO ( REGION_UnionNonO (
PROSRGNDATA pReg, PROSRGNDATA pReg,
PRECT r, PRECTL r,
PRECT rEnd, PRECTL rEnd,
INT top, INT top,
INT bottom INT bottom
) )
{ {
RECT *pNextRect; RECTL *pNextRect;
pNextRect = (PRECT)pReg->Buffer + pReg->rdh.nCount; pNextRect = pReg->Buffer + pReg->rdh.nCount;
while (r != rEnd) while (r != rEnd)
{ {
@ -1356,17 +1356,17 @@ REGION_UnionNonO (
static void FASTCALL static void FASTCALL
REGION_UnionO ( REGION_UnionO (
PROSRGNDATA pReg, PROSRGNDATA pReg,
PRECT r1, PRECTL r1,
PRECT r1End, PRECTL r1End,
PRECT r2, PRECTL r2,
PRECT r2End, PRECTL r2End,
INT top, INT top,
INT bottom INT bottom
) )
{ {
RECT *pNextRect; RECTL *pNextRect;
pNextRect = (PRECT)pReg->Buffer + pReg->rdh.nCount; pNextRect = pReg->Buffer + pReg->rdh.nCount;
#define MERGERECT(r) \ #define MERGERECT(r) \
if ((pReg->rdh.nCount != 0) && \ if ((pReg->rdh.nCount != 0) && \
@ -1516,15 +1516,15 @@ REGION_UnionRegion(
static void FASTCALL static void FASTCALL
REGION_SubtractNonO1( REGION_SubtractNonO1(
PROSRGNDATA pReg, PROSRGNDATA pReg,
PRECT r, PRECTL r,
PRECT rEnd, PRECTL rEnd,
INT top, INT top,
INT bottom INT bottom
) )
{ {
RECT *pNextRect; RECTL *pNextRect;
pNextRect = (PRECT)pReg->Buffer + pReg->rdh.nCount; pNextRect = pReg->Buffer + pReg->rdh.nCount;
while (r != rEnd) while (r != rEnd)
{ {
@ -1555,19 +1555,19 @@ REGION_SubtractNonO1(
static void FASTCALL static void FASTCALL
REGION_SubtractO( REGION_SubtractO(
PROSRGNDATA pReg, PROSRGNDATA pReg,
PRECT r1, PRECTL r1,
PRECT r1End, PRECTL r1End,
PRECT r2, PRECTL r2,
PRECT r2End, PRECTL r2End,
INT top, INT top,
INT bottom INT bottom
) )
{ {
RECT *pNextRect; RECTL *pNextRect;
INT left; INT left;
left = r1->left; left = r1->left;
pNextRect = (PRECT)pReg->Buffer + pReg->rdh.nCount; pNextRect = pReg->Buffer + pReg->rdh.nCount;
while ((r1 != r1End) && (r2 != r2End)) while ((r1 != r1End) && (r2 != r2End))
{ {
@ -1763,7 +1763,7 @@ REGION_XorRegion(
VOID FASTCALL VOID FASTCALL
REGION_UnionRectWithRgn( REGION_UnionRectWithRgn(
ROSRGNDATA *rgn, ROSRGNDATA *rgn,
const RECT *rect const RECTL *rect
) )
{ {
ROSRGNDATA region; ROSRGNDATA region;
@ -1782,8 +1782,8 @@ REGION_CreateSimpleFrameRgn(
INT y INT y
) )
{ {
RECT rc[4]; RECTL rc[4];
PRECT prc; PRECTL prc;
if (x != 0 || y != 0) if (x != 0 || y != 0)
{ {
@ -1860,7 +1860,7 @@ REGION_CreateFrameRgn(
) )
{ {
PROSRGNDATA srcObj, destObj; PROSRGNDATA srcObj, destObj;
PRECT rc; PRECTL rc;
ULONG i; ULONG i;
if (!(srcObj = REGION_LockRgn(hSrc))) if (!(srcObj = REGION_LockRgn(hSrc)))
@ -1899,7 +1899,7 @@ REGION_CreateFrameRgn(
else else
{ {
/* Original region moved to right */ /* Original region moved to right */
rc = (PRECT)srcObj->Buffer; rc = srcObj->Buffer;
for (i = 0; i < srcObj->rdh.nCount; i++) for (i = 0; i < srcObj->rdh.nCount; i++)
{ {
rc->left += x; rc->left += x;
@ -1909,7 +1909,7 @@ REGION_CreateFrameRgn(
REGION_IntersectRegion(destObj, destObj, srcObj); REGION_IntersectRegion(destObj, destObj, srcObj);
/* Original region moved to left */ /* Original region moved to left */
rc = (PRECT)srcObj->Buffer; rc = srcObj->Buffer;
for (i = 0; i < srcObj->rdh.nCount; i++) for (i = 0; i < srcObj->rdh.nCount; i++)
{ {
rc->left -= 2 * x; rc->left -= 2 * x;
@ -1919,7 +1919,7 @@ REGION_CreateFrameRgn(
REGION_IntersectRegion(destObj, destObj, srcObj); REGION_IntersectRegion(destObj, destObj, srcObj);
/* Original region moved down */ /* Original region moved down */
rc = (PRECT)srcObj->Buffer; rc = srcObj->Buffer;
for (i = 0; i < srcObj->rdh.nCount; i++) for (i = 0; i < srcObj->rdh.nCount; i++)
{ {
rc->left += x; rc->left += x;
@ -1931,7 +1931,7 @@ REGION_CreateFrameRgn(
REGION_IntersectRegion(destObj, destObj, srcObj); REGION_IntersectRegion(destObj, destObj, srcObj);
/* Original region moved up */ /* Original region moved up */
rc = (PRECT)srcObj->Buffer; rc = srcObj->Buffer;
for (i = 0; i < srcObj->rdh.nCount; i++) for (i = 0; i < srcObj->rdh.nCount; i++)
{ {
rc->top -= 2 * y; rc->top -= 2 * y;
@ -1941,7 +1941,7 @@ REGION_CreateFrameRgn(
REGION_IntersectRegion(destObj, destObj, srcObj); REGION_IntersectRegion(destObj, destObj, srcObj);
/* Restore the original region */ /* Restore the original region */
rc = (PRECT)srcObj->Buffer; rc = srcObj->Buffer;
for (i = 0; i < srcObj->rdh.nCount; i++) for (i = 0; i < srcObj->rdh.nCount; i++)
{ {
rc->top += y; rc->top += y;
@ -1963,11 +1963,11 @@ REGION_LPTODP(
HRGN hDest, HRGN hDest,
HRGN hSrc) HRGN hSrc)
{ {
RECT *pCurRect, *pEndRect; RECTL *pCurRect, *pEndRect;
PROSRGNDATA srcObj = NULL; PROSRGNDATA srcObj = NULL;
PROSRGNDATA destObj = NULL; PROSRGNDATA destObj = NULL;
RECT tmpRect; RECTL tmpRect;
BOOL ret = FALSE; BOOL ret = FALSE;
PDC_ATTR Dc_Attr; PDC_ATTR Dc_Attr;
@ -1996,8 +1996,8 @@ REGION_LPTODP(
} }
EMPTY_REGION(destObj); EMPTY_REGION(destObj);
pEndRect = (PRECT)srcObj->Buffer + srcObj->rdh.nCount; pEndRect = srcObj->Buffer + srcObj->rdh.nCount;
for (pCurRect = (PRECT)srcObj->Buffer; pCurRect < pEndRect; pCurRect++) for (pCurRect = srcObj->Buffer; pCurRect < pEndRect; pCurRect++)
{ {
tmpRect = *pCurRect; tmpRect = *pCurRect;
tmpRect.left = XLPTODP(Dc_Attr, tmpRect.left); tmpRect.left = XLPTODP(Dc_Attr, tmpRect.left);
@ -2093,7 +2093,7 @@ IntGdiReleaseRaoRgn(PDC pDC)
PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index]; PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index];
pDC->DC_Flags |= DC_FLAG_DIRTY_RAO; pDC->DC_Flags |= DC_FLAG_DIRTY_RAO;
Entry->Flags |= GDI_ENTRY_VALIDATE_VIS; Entry->Flags |= GDI_ENTRY_VALIDATE_VIS;
IntGdiSetEmptyRect((PRECT)&pDC->erclClip); RECTL_vSetEmptyRect(&pDC->erclClip);
} }
@ -2104,7 +2104,7 @@ IntGdiReleaseVisRgn(PDC pDC)
PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index]; PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index];
pDC->DC_Flags |= DC_FLAG_DIRTY_RAO; pDC->DC_Flags |= DC_FLAG_DIRTY_RAO;
Entry->Flags |= GDI_ENTRY_VALIDATE_VIS; Entry->Flags |= GDI_ENTRY_VALIDATE_VIS;
IntGdiSetEmptyRect((PRECT)&pDC->erclClip); RECTL_vSetEmptyRect(&pDC->erclClip);
REGION_Delete(pDC->prgnVis); REGION_Delete(pDC->prgnVis);
pDC->prgnVis = prgnDefault; pDC->prgnVis = prgnDefault;
} }
@ -2137,7 +2137,7 @@ IntUpdateVisRectRgn(PDC pDC, PROSRGNDATA pRgn)
rcl.bottom -= pDC->erclWindow.top; rcl.bottom -= pDC->erclWindow.top;
} }
else else
IntGdiSetEmptyRect((PRECT)&rcl); RECTL_vSetEmptyRect(&rcl);
pDc_Attr->VisRectRegion.Rect = rcl; pDc_Attr->VisRectRegion.Rect = rcl;
@ -2303,7 +2303,7 @@ NtGdiCreateRectRgn(INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
PROSRGNDATA pRgn; PROSRGNDATA pRgn;
HRGN hRgn; HRGN hRgn;
/* Allocate region data structure with space for 1 RECT */ /* Allocate region data structure with space for 1 RECTL */
if (!(pRgn = REGION_AllocRgnWithHandle(1))) if (!(pRgn = REGION_AllocRgnWithHandle(1)))
{ {
SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY); SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
@ -2332,7 +2332,7 @@ NtGdiCreateRoundRectRgn(
PROSRGNDATA obj; PROSRGNDATA obj;
HRGN hrgn; HRGN hrgn;
int asq, bsq, d, xd, yd; int asq, bsq, d, xd, yd;
RECT rect; RECTL rect;
/* Make the dimensions sensible */ /* Make the dimensions sensible */
@ -2444,7 +2444,7 @@ NtGdiEqualRgn(
) )
{ {
PROSRGNDATA rgn1, rgn2; PROSRGNDATA rgn1, rgn2;
PRECT tRect1, tRect2; PRECTL tRect1, tRect2;
ULONG i; ULONG i;
BOOL bRet = FALSE; BOOL bRet = FALSE;
@ -2465,8 +2465,8 @@ NtGdiEqualRgn(
rgn1->rdh.rcBound.bottom != rgn2->rdh.rcBound.bottom) rgn1->rdh.rcBound.bottom != rgn2->rdh.rcBound.bottom)
goto exit; goto exit;
tRect1 = (PRECT)rgn1->Buffer; tRect1 = rgn1->Buffer;
tRect2 = (PRECT)rgn2->Buffer; tRect2 = rgn2->Buffer;
if (!tRect1 || !tRect2) if (!tRect1 || !tRect2)
goto exit; goto exit;
@ -2598,7 +2598,7 @@ NtGdiFillRgn(
{ {
HBRUSH oldhBrush; HBRUSH oldhBrush;
PROSRGNDATA rgn; PROSRGNDATA rgn;
PRECT r; PRECTL r;
if (NULL == (rgn = REGION_LockRgn(hRgn))) if (NULL == (rgn = REGION_LockRgn(hRgn)))
{ {
@ -2654,7 +2654,7 @@ NtGdiFrameRgn(
INT FASTCALL INT FASTCALL
REGION_GetRgnBox( REGION_GetRgnBox(
PROSRGNDATA Rgn, PROSRGNDATA Rgn,
LPRECT pRect PRECTL pRect
) )
{ {
DWORD ret; DWORD ret;
@ -2754,7 +2754,7 @@ NtGdiGetRandomRgn(
INT APIENTRY INT APIENTRY
IntGdiGetRgnBox( IntGdiGetRgnBox(
HRGN hRgn, HRGN hRgn,
LPRECT pRect PRECTL pRect
) )
{ {
PROSRGNDATA Rgn; PROSRGNDATA Rgn;
@ -2775,11 +2775,11 @@ IntGdiGetRgnBox(
INT APIENTRY INT APIENTRY
NtGdiGetRgnBox( NtGdiGetRgnBox(
HRGN hRgn, HRGN hRgn,
LPRECT pRect PRECTL pRect
) )
{ {
PROSRGNDATA Rgn; PROSRGNDATA Rgn;
RECT SafeRect; RECTL SafeRect;
DWORD ret; DWORD ret;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
@ -2822,7 +2822,7 @@ NtGdiInvertRgn(
{ {
PROSRGNDATA RgnData; PROSRGNDATA RgnData;
ULONG i; ULONG i;
PRECT rc; PRECTL rc;
if (!(RgnData = REGION_LockRgn(hRgn))) if (!(RgnData = REGION_LockRgn(hRgn)))
{ {
@ -2830,7 +2830,7 @@ NtGdiInvertRgn(
return FALSE; return FALSE;
} }
rc = (PRECT)RgnData->Buffer; rc = RgnData->Buffer;
for (i = 0; i < RgnData->rdh.nCount; i++) for (i = 0; i < RgnData->rdh.nCount; i++)
{ {
@ -2868,7 +2868,7 @@ NtGdiOffsetRgn(
if (XOffset || YOffset) if (XOffset || YOffset)
{ {
int nbox = rgn->rdh.nCount; int nbox = rgn->rdh.nCount;
PRECT pbox = (PRECT)rgn->Buffer; PRECTL pbox = rgn->Buffer;
if (nbox && pbox) if (nbox && pbox)
{ {
@ -2935,8 +2935,8 @@ IntGdiPaintRgn(
} }
ClipRegion = IntEngCreateClipRegion(visrgn->rdh.nCount, ClipRegion = IntEngCreateClipRegion(visrgn->rdh.nCount,
(PRECTL)visrgn->Buffer, visrgn->Buffer,
(PRECTL)&visrgn->rdh.rcBound ); &visrgn->rdh.rcBound );
ASSERT(ClipRegion); ASSERT(ClipRegion);
pBrush = BRUSHOBJ_LockBrush(Dc_Attr->hbrush); pBrush = BRUSHOBJ_LockBrush(Dc_Attr->hbrush);
ASSERT(pBrush); ASSERT(pBrush);
@ -2972,14 +2972,14 @@ NtGdiPtInRegion(
{ {
PROSRGNDATA rgn; PROSRGNDATA rgn;
ULONG i; ULONG i;
PRECT r; PRECTL r;
if (!(rgn = REGION_LockRgn(hRgn) ) ) if (!(rgn = REGION_LockRgn(hRgn) ) )
return FALSE; return FALSE;
if (rgn->rdh.nCount > 0 && INRECT(rgn->rdh.rcBound, X, Y)) if (rgn->rdh.nCount > 0 && INRECT(rgn->rdh.rcBound, X, Y))
{ {
r = (PRECT) rgn->Buffer; r = rgn->Buffer;
for (i = 0; i < rgn->rdh.nCount; i++) for (i = 0; i < rgn->rdh.nCount; i++)
{ {
if (INRECT(*r, X, Y)) if (INRECT(*r, X, Y))
@ -2998,15 +2998,15 @@ BOOL
FASTCALL FASTCALL
REGION_RectInRegion( REGION_RectInRegion(
PROSRGNDATA Rgn, PROSRGNDATA Rgn,
CONST LPRECT rc const RECTL *rc
) )
{ {
PRECT pCurRect, pRectEnd; PRECTL pCurRect, pRectEnd;
// this is (just) a useful optimization // this is (just) a useful optimization
if ((Rgn->rdh.nCount > 0) && EXTENTCHECK(&Rgn->rdh.rcBound, rc)) if ((Rgn->rdh.nCount > 0) && EXTENTCHECK(&Rgn->rdh.rcBound, rc))
{ {
for (pCurRect = (PRECT)Rgn->Buffer, pRectEnd = pCurRect + Rgn->rdh.nCount; pCurRect < pRectEnd; pCurRect++) for (pCurRect = Rgn->Buffer, pRectEnd = pCurRect + Rgn->rdh.nCount; pCurRect < pRectEnd; pCurRect++)
{ {
if (pCurRect->bottom <= rc->top) continue; // not far enough down yet if (pCurRect->bottom <= rc->top) continue; // not far enough down yet
if (pCurRect->top >= rc->bottom) break; // too far down if (pCurRect->top >= rc->bottom) break; // too far down
@ -3023,11 +3023,11 @@ BOOL
APIENTRY APIENTRY
NtGdiRectInRegion( NtGdiRectInRegion(
HRGN hRgn, HRGN hRgn,
LPRECT unsaferc LPRECTL unsaferc
) )
{ {
PROSRGNDATA Rgn; PROSRGNDATA Rgn;
RECT rc = {0}; RECTL rc = {0};
BOOL Ret; BOOL Ret;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
@ -3070,7 +3070,7 @@ REGION_SetRectRgn(
INT BottomRect INT BottomRect
) )
{ {
PRECT firstRect; PRECTL firstRect;
if (LeftRect > RightRect) if (LeftRect > RightRect)
{ {
@ -3087,7 +3087,7 @@ REGION_SetRectRgn(
if ((LeftRect != RightRect) && (TopRect != BottomRect)) if ((LeftRect != RightRect) && (TopRect != BottomRect))
{ {
firstRect = (PRECT)rgn->Buffer; firstRect = rgn->Buffer;
ASSERT(firstRect); ASSERT(firstRect);
firstRect->left = rgn->rdh.rcBound.left = LeftRect; firstRect->left = rgn->rdh.rcBound.left = LeftRect;
firstRect->top = rgn->rdh.rcBound.top = TopRect; firstRect->top = rgn->rdh.rcBound.top = TopRect;
@ -3126,10 +3126,10 @@ NtGdiSetRectRgn(
HRGN APIENTRY HRGN APIENTRY
NtGdiUnionRectWithRgn( NtGdiUnionRectWithRgn(
HRGN hDest, HRGN hDest,
CONST PRECT UnsafeRect const RECTL *UnsafeRect
) )
{ {
RECT SafeRect = {0}; RECTL SafeRect = {0};
PROSRGNDATA Rgn; PROSRGNDATA Rgn;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
@ -3457,11 +3457,11 @@ REGION_PtsToRegion(
POINTBLOCK *FirstPtBlock, POINTBLOCK *FirstPtBlock,
ROSRGNDATA *reg) ROSRGNDATA *reg)
{ {
RECT *rects; RECTL *rects;
POINT *pts; POINT *pts;
POINTBLOCK *CurPtBlock; POINTBLOCK *CurPtBlock;
int i; int i;
RECT *extents, *temp; RECTL *extents, *temp;
INT numRects; INT numRects;
extents = &reg->rdh.rcBound; extents = &reg->rdh.rcBound;

7
reactos/subsystems/win32/win32k/pch.h
View file

@ -27,6 +27,13 @@ typedef struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
#define STARTF_USEPOSITION 4 #define STARTF_USEPOSITION 4
#include <stdarg.h> #include <stdarg.h>
#include <windef.h> #include <windef.h>
/* Avoid type casting, by defining RECT to RECTL */
#define RECT RECTL
#define PRECT PRECTL
#define LPRECT LPRECTL
#define LPCRECT LPCRECTL
#include <winerror.h> #include <winerror.h>
#include <wingdi.h> #include <wingdi.h>
#include <winddi.h> #include <winddi.h>