Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-06-29 01:12:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Create Int versions of Rect functions

Browse source 
svn path=/trunk/; revision=11674
This commit is contained in:
Gé van Geldorp 2004-11-15 23:10:42 +00:00
parent ccc0695954
commit 22e0d4d8eb
6 changed files with 272 additions and 68 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
reactos/subsys/win32k/eng/gradient.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: gradient.c,v 1.10 2004/07/03 13:55:35 navaraf Exp $
/* $Id: gradient.c,v 1.11 2004/11/15 23:10:41 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -119,7 +119,7 @@ IntEngGradientFillRect(
EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
{
if(NtGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG))
if(IntGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG))
{
HVINITCOL(Red, 0);
HVINITCOL(Green, 1);
@ -147,7 +147,7 @@ IntEngGradientFillRect(
EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
{
if(NtGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG))
if(IntGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG))
{
HVINITCOL(Red, 0);
HVINITCOL(Green, 1);
@ -183,7 +183,7 @@ IntEngGradientFillRect(
EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= rcSG.bottom; i++)
{
if(NtGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG))
if(IntGdiIntersectRect(&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)&rcSG))
{
for(; FillRect.top < FillRect.bottom; FillRect.top++)
{
@ -363,7 +363,7 @@ IntEngGradientFillTriangle(
EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= prclExtents->bottom; i++)
{
if(NtGdiIntersectRect((PRECT)&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)prclExtents))
if(IntGdiIntersectRect((PRECT)&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)prclExtents))
{
BOOL InY;
@ -411,7 +411,7 @@ IntEngGradientFillTriangle(
EnumMore = CLIPOBJ_bEnum(pco, (ULONG) sizeof(RectEnum), (PVOID) &RectEnum);
for (i = 0; i < RectEnum.c && RectEnum.arcl[i].top <= prclExtents->bottom; i++)
{
if(NtGdiIntersectRect((PRECT)&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)prclExtents))
if(IntGdiIntersectRect((PRECT)&FillRect, (PRECT)&RectEnum.arcl[i], (PRECT)prclExtents))
{
S_INITLINE(v1, v3, 0);
S_INITLINE(v1, v2, 1);

20
reactos/subsys/win32k/include/intgdi.h
View file

@ -145,5 +145,25 @@ IntGdiCombineTransform(LPXFORM XFormResult,
LPXFORM xform1,
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);
#endif /* _WIN32K_INTGDI_H */

89
reactos/subsys/win32k/ntuser/painting.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* $Id: painting.c,v 1.86 2004/09/28 15:02:30 weiden Exp $
* $Id: painting.c,v 1.87 2004/11/15 23:10:42 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -695,7 +695,7 @@ IntFixCaret(HWND hWnd, LPRECT lprc, UINT flags)
rcCaret.top = pt.y;
rcCaret.right = pt.x + CaretInfo->Size.cx;
rcCaret.bottom = pt.y + CaretInfo->Size.cy;
if (NtGdiIntersectRect(lprc, lprc, &rcCaret))
if (IntGdiIntersectRect(lprc, lprc, &rcCaret))
{
NtUserHideCaret(0);
lprc->left = pt.x;
@ -717,9 +717,12 @@ IntFixCaret(HWND hWnd, LPRECT lprc, UINT flags)
*/
HDC STDCALL
NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* lPs)
NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* UnsafePs)
{
PWINDOW_OBJECT Window;
PAINTSTRUCT Ps;
PROSRGNDATA Rgn;
NTSTATUS Status;
if (!(Window = IntGetWindowObject(hWnd)))
{
@ -729,10 +732,11 @@ NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* lPs)
NtUserHideCaret(hWnd);
lPs->hdc = NtUserGetDCEx(hWnd, 0, DCX_INTERSECTUPDATE | DCX_WINDOWPAINT |
RtlZeroMemory(&Ps, sizeof(PAINTSTRUCT));
Ps.hdc = NtUserGetDCEx(hWnd, 0, DCX_INTERSECTUPDATE | DCX_WINDOWPAINT |
DCX_USESTYLE);
if (!lPs->hdc)
if (!Ps.hdc)
{
IntReleaseWindowObject(Window);
return NULL;
@ -743,33 +747,49 @@ NtUserBeginPaint(HWND hWnd, PAINTSTRUCT* lPs)
{
MsqDecPaintCountQueue(Window->MessageQueue);
IntValidateParent(Window, Window->UpdateRegion);
NtGdiGetRgnBox(Window->UpdateRegion, &lPs->rcPaint);
NtGdiOffsetRect(&lPs->rcPaint,
Window->WindowRect.left - Window->ClientRect.left,
Window->WindowRect.top - Window->ClientRect.top);
Rgn = RGNDATA_LockRgn(Window->UpdateRegion);
if (NULL != Rgn)
{
UnsafeIntGetRgnBox(Rgn, &Ps.rcPaint);
RGNDATA_UnlockRgn(Window->UpdateRegion);
IntGdiOffsetRect(&Ps.rcPaint,
Window->WindowRect.left - Window->ClientRect.left,
Window->WindowRect.top - Window->ClientRect.top);
}
else
{
IntGetClientRect(Window, &Ps.rcPaint);
}
GDIOBJ_SetOwnership(Window->UpdateRegion, PsGetCurrentProcess());
NtGdiDeleteObject(Window->UpdateRegion);
Window->UpdateRegion = NULL;
}
else
{
NtUserGetClientRect(Window->Self, &lPs->rcPaint);
IntGetClientRect(Window, &Ps.rcPaint);
}
IntUnLockWindowUpdate(Window);
if (Window->Flags & WINDOWOBJECT_NEED_ERASEBKGND)
{
Window->Flags &= ~WINDOWOBJECT_NEED_ERASEBKGND;
lPs->fErase = !IntSendMessage(hWnd, WM_ERASEBKGND, (WPARAM)lPs->hdc, 0);
Ps.fErase = !IntSendMessage(hWnd, WM_ERASEBKGND, (WPARAM)Ps.hdc, 0);
}
else
{
lPs->fErase = FALSE;
Ps.fErase = FALSE;
}
IntReleaseWindowObject(Window);
return lPs->hdc;
Status = MmCopyToCaller(UnsafePs, &Ps, sizeof(PAINTSTRUCT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return NULL;
}
return Ps.hdc;
}
/*
@ -1019,13 +1039,13 @@ NtUserScrollDC(HDC hDC, INT dx, INT dy, const RECT *lprcScroll,
IntGdiGetClipBox(hDC, &rClip);
IntLPtoDP(DC, (LPPOINT)&rClip, 2);
NtGdiIntersectRect(&rClipped_src, &rSrc, &rClip);
IntGdiIntersectRect(&rClipped_src, &rSrc, &rClip);
rDst = rClipped_src;
NtGdiSetRect(&offset, 0, 0, dx, dy);
IntGdiSetRect(&offset, 0, 0, dx, dy);
IntLPtoDP(DC, (LPPOINT)&offset, 2);
NtGdiOffsetRect(&rDst, offset.right - offset.left, offset.bottom - offset.top);
NtGdiIntersectRect(&rDst, &rDst, &rClip);
IntGdiOffsetRect(&rDst, offset.right - offset.left, offset.bottom - offset.top);
IntGdiIntersectRect(&rDst, &rDst, &rClip);
/*
* Copy bits, if possible.
@ -1035,7 +1055,7 @@ NtUserScrollDC(HDC hDC, INT dx, INT dy, const RECT *lprcScroll,
{
RECT rDst_lp = rDst, rSrc_lp = rDst;
NtGdiOffsetRect(&rSrc_lp, offset.left - offset.right, offset.top - offset.bottom);
IntGdiOffsetRect(&rSrc_lp, offset.left - offset.right, offset.top - offset.bottom);
IntDPtoLP(DC, (LPPOINT)&rDst_lp, 2);
IntDPtoLP(DC, (LPPOINT)&rSrc_lp, 2);
DC_UnlockDc(hDC);
@ -1097,10 +1117,10 @@ NtUserScrollDC(HDC hDC, INT dx, INT dy, const RECT *lprcScroll,
*/
DWORD STDCALL
NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *rect,
const RECT *clipRect, HRGN hrgnUpdate, LPRECT rcUpdate, UINT flags)
NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *UnsafeRect,
const RECT *UnsafeClipRect, HRGN hrgnUpdate, LPRECT rcUpdate, UINT flags)
{
RECT rc, cliprc, caretrc;
RECT rc, cliprc, caretrc, rect, clipRect;
INT Result;
PWINDOW_OBJECT Window;
HDC hDC;
@ -1108,6 +1128,7 @@ NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *rect,
HWND hwndCaret;
BOOL bUpdate = (rcUpdate || hrgnUpdate || flags & (SW_INVALIDATE | SW_ERASE));
BOOL bOwnRgn = TRUE;
NTSTATUS Status;
Window = IntGetWindowObject(hWnd);
if (!Window || !IntIsWindowDrawable(Window))
@ -1117,11 +1138,27 @@ NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *rect,
}
IntGetClientRect(Window, &rc);
if (rect)
NtGdiIntersectRect(&rc, &rc, rect);
if (NULL != UnsafeRect)
{
Status = MmCopyFromCaller(&rect, UnsafeRect, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return ERROR;
}
IntGdiIntersectRect(&rc, &rc, &rect);
}
if (clipRect)
NtGdiIntersectRect(&cliprc, &rc, clipRect);
if (NULL != UnsafeClipRect)
{
Status = MmCopyFromCaller(&clipRect, UnsafeClipRect, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return ERROR;
}
IntGdiIntersectRect(&cliprc, &rc, &clipRect);
}
else
cliprc = rc;
@ -1180,7 +1217,7 @@ NtUserScrollWindowEx(HWND hWnd, INT dx, INT dy, const RECT *rect,
r.top -= ClientOrigin.y;
r.right -= ClientOrigin.x;
r.bottom -= ClientOrigin.y;
if (!rect || NtGdiIntersectRect(&dummy, &r, &rc))
if (! UnsafeRect || IntGdiIntersectRect(&dummy, &r, &rc))
WinPosSetWindowPos(List[i], 0, r.left + dx, r.top + dy, 0, 0,
SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE |
SWP_NOREDRAW);

10
reactos/subsys/win32k/ntuser/window.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: window.c,v 1.247 2004/09/28 15:02:30 weiden Exp $
/* $Id: window.c,v 1.248 2004/11/15 23:10:42 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -1338,7 +1338,7 @@ IntCalcDefPosSize(PWINDOW_OBJECT Parent, PWINDOW_OBJECT WindowObject, RECT *rc,
if(Parent != NULL)
{
NtGdiIntersectRect(rc, rc, &Parent->ClientRect);
IntGdiIntersectRect(rc, rc, &Parent->ClientRect);
if(IncPos)
{
@ -1793,7 +1793,7 @@ IntCreateWindowEx(DWORD dwExStyle,
WindowObject->WindowRect.bottom = Pos.y + Size.cy;
if (0 != (WindowObject->Style & WS_CHILD) && ParentWindow)
{
NtGdiOffsetRect(&(WindowObject->WindowRect), ParentWindow->ClientRect.left,
IntGdiOffsetRect(&(WindowObject->WindowRect), ParentWindow->ClientRect.left,
ParentWindow->ClientRect.top);
}
WindowObject->ClientRect = WindowObject->WindowRect;
@ -1822,7 +1822,7 @@ IntCreateWindowEx(DWORD dwExStyle,
WindowObject->WindowRect.bottom = Pos.y + Size.cy;
if (0 != (WindowObject->Style & WS_CHILD) && ParentWindow)
{
NtGdiOffsetRect(&(WindowObject->WindowRect), ParentWindow->ClientRect.left,
IntGdiOffsetRect(&(WindowObject->WindowRect), ParentWindow->ClientRect.left,
ParentWindow->ClientRect.top);
}
WindowObject->ClientRect = WindowObject->WindowRect;
@ -1858,7 +1858,7 @@ IntCreateWindowEx(DWORD dwExStyle,
Result = WinPosGetNonClientSize(WindowObject->Self,
&WindowObject->WindowRect,
&WindowObject->ClientRect);
NtGdiOffsetRect(&WindowObject->WindowRect,
IntGdiOffsetRect(&WindowObject->WindowRect,
MaxPos.x - WindowObject->WindowRect.left,
MaxPos.y - WindowObject->WindowRect.top);

18
reactos/subsys/win32k/ntuser/winpos.c
View file

@ -16,7 +16,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: winpos.c,v 1.121 2004/09/24 15:07:38 navaraf Exp $
/* $Id: winpos.c,v 1.122 2004/11/15 23:10:42 gvg Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
@ -439,11 +439,11 @@ WinPosDoNCCALCSize(PWINDOW_OBJECT Window, PWINDOWPOS WinPos,
Parent = IntGetParentObject(Window);
if (0 != (Window->Style & WS_CHILD) && Parent)
{
NtGdiOffsetRect(&(params.rgrc[0]), - Parent->ClientRect.left,
IntGdiOffsetRect(&(params.rgrc[0]), - Parent->ClientRect.left,
- Parent->ClientRect.top);
NtGdiOffsetRect(&(params.rgrc[1]), - Parent->ClientRect.left,
IntGdiOffsetRect(&(params.rgrc[1]), - Parent->ClientRect.left,
- Parent->ClientRect.top);
NtGdiOffsetRect(&(params.rgrc[2]), - Parent->ClientRect.left,
IntGdiOffsetRect(&(params.rgrc[2]), - Parent->ClientRect.left,
- Parent->ClientRect.top);
}
params.lppos = &winposCopy;
@ -458,7 +458,7 @@ WinPosDoNCCALCSize(PWINDOW_OBJECT Window, PWINDOWPOS WinPos,
*ClientRect = params.rgrc[0];
if ((Window->Style & WS_CHILD) && Parent)
{
NtGdiOffsetRect(ClientRect, Parent->ClientRect.left,
IntGdiOffsetRect(ClientRect, Parent->ClientRect.left,
Parent->ClientRect.top);
}
FixClientRect(ClientRect, WindowRect);
@ -534,7 +534,7 @@ WinPosDoWinPosChanging(PWINDOW_OBJECT WindowObject,
WindowRect->top = Y;
WindowRect->right += X - WindowObject->WindowRect.left;
WindowRect->bottom += Y - WindowObject->WindowRect.top;
NtGdiOffsetRect(ClientRect,
IntGdiOffsetRect(ClientRect,
X - WindowObject->WindowRect.left,
Y - WindowObject->WindowRect.top);
}
@ -1025,9 +1025,9 @@ WinPosSetWindowPos(HWND Wnd, HWND WndInsertAfter, INT x, INT y, INT cx,
{
RECT ORect = OldClientRect;
RECT NRect = NewClientRect;
NtGdiOffsetRect(&ORect, - OldWindowRect.left, - OldWindowRect.top);
NtGdiOffsetRect(&NRect, - NewWindowRect.left, - NewWindowRect.top);
NtGdiIntersectRect(&CopyRect, &ORect, &NRect);
IntGdiOffsetRect(&ORect, - OldWindowRect.left, - OldWindowRect.top);
IntGdiOffsetRect(&NRect, - NewWindowRect.left, - NewWindowRect.top);
IntGdiIntersectRect(&CopyRect, &ORect, &NRect);
REGION_CropRgn(CopyRgn, CopyRgn, &CopyRect, NULL);
}

191
reactos/subsys/win32k/objects/rect.c
View file

@ -16,44 +16,100 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* $Id: rect.c,v 1.7 2004/05/10 17:07:20 weiden Exp $ */
/* $Id: rect.c,v 1.8 2004/11/15 23:10:42 gvg Exp $ */
#include <w32k.h>
/* FUNCTIONS *****************************************************************/
BOOL STDCALL
NtGdiSetEmptyRect(PRECT Rect)
VOID FASTCALL
IntGdiSetEmptyRect(PRECT Rect)
{
Rect->left = Rect->right = Rect->top = Rect->bottom = 0;
return(TRUE);
}
BOOL STDCALL
NtGdiIsEmptyRect(const RECT* Rect)
NtGdiSetEmptyRect(PRECT UnsafeRect)
{
RECT Rect;
NTSTATUS Status;
IntGdiSetEmptyRect(&Rect);
Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
return TRUE;
}
BOOL FASTCALL
IntGdiIsEmptyRect(const RECT* Rect)
{
return(Rect->left >= Rect->right || Rect->top >= Rect->bottom);
}
BOOL STDCALL
NtGdiOffsetRect(LPRECT Rect, INT x, INT y)
NtGdiIsEmptyRect(const RECT* UnsafeRect)
{
RECT Rect;
NTSTATUS Status;
Status = MmCopyFromCaller(&Rect, UnsafeRect, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
return IntGdiIsEmptyRect(&Rect);
}
VOID FASTCALL
IntGdiOffsetRect(LPRECT Rect, INT x, INT y)
{
Rect->left += x;
Rect->right += x;
Rect->top += y;
Rect->bottom += y;
return(TRUE);
}
BOOL STDCALL
NtGdiUnionRect(PRECT Dest, const RECT* Src1, const RECT* Src2)
NtGdiOffsetRect(LPRECT UnsafeRect, INT x, INT y)
{
if (NtGdiIsEmptyRect(Src1))
RECT Rect;
NTSTATUS Status;
Status = MmCopyFromCaller(&Rect, UnsafeRect, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
if (NtGdiIsEmptyRect(Src2))
SetLastNtError(Status);
return FALSE;
}
IntGdiOffsetRect(&Rect, x, y);
Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
return TRUE;
}
BOOL FASTCALL
IntGdiUnionRect(PRECT Dest, const RECT* Src1, const RECT* Src2)
{
if (IntGdiIsEmptyRect(Src1))
{
if (IntGdiIsEmptyRect(Src2))
{
NtGdiSetEmptyRect(Dest);
return(FALSE);
IntGdiSetEmptyRect(Dest);
return FALSE;
}
else
{
@ -62,7 +118,7 @@ NtGdiUnionRect(PRECT Dest, const RECT* Src1, const RECT* Src2)
}
else
{
if (NtGdiIsEmptyRect(Src2))
if (IntGdiIsEmptyRect(Src2))
{
*Dest = *Src1;
}
@ -74,33 +130,124 @@ NtGdiUnionRect(PRECT Dest, const RECT* Src1, const RECT* Src2)
Dest->bottom = max(Src1->bottom, Src2->bottom);
}
}
return(TRUE);
return TRUE;
}
BOOL STDCALL
NtGdiSetRect(PRECT Rect, INT left, INT top, INT right, INT bottom)
NtGdiUnionRect(PRECT UnsafeDest, const RECT* UnsafeSrc1, const RECT* UnsafeSrc2)
{
RECT Dest, Src1, Src2;
NTSTATUS Status;
BOOL Ret;
Status = MmCopyFromCaller(&Src1, UnsafeSrc1, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
Status = MmCopyFromCaller(&Src2, UnsafeSrc2, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
Ret = IntGdiUnionRect(&Dest, &Src1, &Src2);
if (Ret)
{
Status = MmCopyToCaller(UnsafeDest, &Dest, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
}
return Ret;
}
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;
return(TRUE);
}
BOOL STDCALL
NtGdiIntersectRect(PRECT Dest, const RECT* Src1, const RECT* Src2)
NtGdiSetRect(PRECT UnsafeRect, INT left, INT top, INT right, INT bottom)
{
if (NtGdiIsEmptyRect(Src1) || NtGdiIsEmptyRect(Src2) ||
RECT Rect;
NTSTATUS Status;
IntGdiSetRect(&Rect, left, top, right, bottom);
Status = MmCopyToCaller(UnsafeRect, &Rect, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
return TRUE;
}
BOOL FASTCALL
IntGdiIntersectRect(PRECT Dest, const RECT* Src1, const RECT* Src2)
{
if (IntGdiIsEmptyRect(Src1) || IntGdiIsEmptyRect(Src2) ||
Src1->left >= Src2->right || Src2->left >= Src1->right ||
Src1->top >= Src2->bottom || Src2->top >= Src1->bottom)
{
NtGdiSetEmptyRect(Dest);
return(FALSE);
IntGdiSetEmptyRect(Dest);
return FALSE;
}
Dest->left = max(Src1->left, Src2->left);
Dest->right = min(Src1->right, Src2->right);
Dest->top = max(Src1->top, Src2->top);
Dest->bottom = min(Src1->bottom, Src2->bottom);
return(TRUE);
return TRUE;
}
BOOL STDCALL
NtGdiIntersectRect(PRECT UnsafeDest, const RECT* UnsafeSrc1, const RECT* UnsafeSrc2)
{
RECT Dest, Src1, Src2;
NTSTATUS Status;
BOOL Ret;
Status = MmCopyFromCaller(&Src1, UnsafeSrc1, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
Status = MmCopyFromCaller(&Src2, UnsafeSrc2, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
Ret = IntGdiIntersectRect(&Dest, &Src2, &Src2);
if (Ret)
{
Status = MmCopyToCaller(UnsafeDest, &Dest, sizeof(RECT));
if (! NT_SUCCESS(Status))
{
SetLastNtError(Status);
return FALSE;
}
}
return Ret;
}
/* EOF */