Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-06-06 09:50:43 +00:00
Code Issues Projects Releases Packages Wiki Activity

- Magnus: Reformat clip.c source code to better match overall coding style. No code logic change.

Browse source 
svn path=/trunk/; revision=33895
This commit is contained in:
Aleksey Bragin 2008-06-08 07:31:10 +00:00
parent b557c10181
commit 7245944072
1 changed files with 292 additions and 278 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -33,231 +33,239 @@
#include <debug.h> #include <debug.h>
static __inline int static __inline int
CompareRightDown(const PRECT r1, const PRECT r2) CompareRightDown(
const PRECT r1,
const PRECT r2)
{ {
int Cmp; int Cmp;
if (r1->top < r2->top) if (r1->top < r2->top)
{ {
Cmp = -1; Cmp = -1;
} }
else if (r2->top < r1->top) else if (r2->top < r1->top)
{ {
Cmp = +1; Cmp = +1;
} }
else else
{ {
ASSERT(r1->bottom == r2->bottom); ASSERT(r1->bottom == r2->bottom);
if (r1->left < r2->left) if (r1->left < r2->left)
{ {
Cmp = -1; Cmp = -1;
} }
else if (r2->left < r1->left) else if (r2->left < r1->left)
{ {
Cmp = +1; Cmp = +1;
} }
else else
{ {
ASSERT(r1->right == r2->right); ASSERT(r1->right == r2->right);
Cmp = 0; Cmp = 0;
} }
} }
return Cmp; return Cmp;
} }
static __inline int static __inline int
CompareRightUp(const PRECT r1, const PRECT r2) CompareRightUp(
const PRECT r1,
const PRECT r2)
{ {
int Cmp; int Cmp;
if (r1->bottom < r2->bottom) if (r1->bottom < r2->bottom)
{ {
Cmp = +1; Cmp = +1;
} }
else if (r2->bottom < r1->bottom) else if (r2->bottom < r1->bottom)
{ {
Cmp = -1; Cmp = -1;
} }
else else
{ {
ASSERT(r1->top == r2->top); ASSERT(r1->top == r2->top);
if (r1->left < r2->left) if (r1->left < r2->left)
{ {
Cmp = -1; Cmp = -1;
} }
else if (r2->left < r1->left) else if (r2->left < r1->left)
{ {
Cmp = +1; Cmp = +1;
} }
else else
{ {
ASSERT(r1->right == r2->right); ASSERT(r1->right == r2->right);
Cmp = 0; Cmp = 0;
} }
} }
return Cmp; return Cmp;
} }
static __inline int static __inline int
CompareLeftDown(const PRECT r1, const PRECT r2) CompareLeftDown(
const PRECT r1,
const PRECT r2)
{ {
int Cmp; int Cmp;
if (r1->top < r2->top) if (r1->top < r2->top)
{ {
Cmp = -1; Cmp = -1;
} }
else if (r2->top < r1->top) else if (r2->top < r1->top)
{ {
Cmp = +1; Cmp = +1;
} }
else else
{ {
ASSERT(r1->bottom == r2->bottom); ASSERT(r1->bottom == r2->bottom);
if (r1->right < r2->right) if (r1->right < r2->right)
{ {
Cmp = +1; Cmp = +1;
} }
else if (r2->right < r1->right) else if (r2->right < r1->right)
{ {
Cmp = -1; Cmp = -1;
} }
else else
{ {
ASSERT(r1->left == r2->left); ASSERT(r1->left == r2->left);
Cmp = 0; Cmp = 0;
} }
} }
return Cmp; return Cmp;
} }
static __inline int static __inline int
CompareLeftUp(const PRECT r1, const PRECT r2) CompareLeftUp(
const PRECT r1,
const PRECT r2)
{ {
int Cmp; int Cmp;
if (r1->bottom < r2->bottom) if (r1->bottom < r2->bottom)
{ {
Cmp = +1; Cmp = +1;
} }
else if (r2->bottom < r1->bottom) else if (r2->bottom < r1->bottom)
{ {
Cmp = -1; Cmp = -1;
} }
else else
{ {
ASSERT(r1->top == r2->top); ASSERT(r1->top == r2->top);
if (r1->right < r2->right) if (r1->right < r2->right)
{ {
Cmp = +1; Cmp = +1;
} }
else if (r2->right < r1->right) else if (r2->right < r1->right)
{ {
Cmp = -1; Cmp = -1;
} }
else else
{ {
ASSERT(r1->left == r2->left); ASSERT(r1->left == r2->left);
Cmp = 0; Cmp = 0;
} }
} }
return Cmp;
return Cmp;
} }
static __inline int static __inline int
CompareSpans(const PSPAN Span1, const PSPAN Span2) CompareSpans(
const PSPAN Span1,
const PSPAN Span2)
{ {
int Cmp; int Cmp;
if (Span1->Y < Span2->Y) if (Span1->Y < Span2->Y)
{ {
Cmp = -1; Cmp = -1;
} }
else if (Span2->Y < Span1->Y) else if (Span2->Y < Span1->Y)
{ {
Cmp = +1; Cmp = +1;
} }
else else
{ {
if (Span1->X < Span2->X) if (Span1->X < Span2->X)
{ {
Cmp = -1; Cmp = -1;
} }
else if (Span2->X < Span1->X) else if (Span2->X < Span1->X)
{ {
Cmp = +1; Cmp = +1;
} }
else else
{ {
Cmp = 0; Cmp = 0;
} }
} }
return Cmp; return Cmp;
} }
VOID FASTCALL VOID FASTCALL
IntEngDeleteClipRegion(CLIPOBJ *ClipObj) IntEngDeleteClipRegion(CLIPOBJ *ClipObj)
{ {
EngFreeMem(ObjToGDI(ClipObj, CLIP)); EngFreeMem(ObjToGDI(ClipObj, CLIP));
} }
CLIPOBJ* FASTCALL CLIPOBJ* FASTCALL
IntEngCreateClipRegion(ULONG count, PRECTL pRect, PRECTL rcBounds) IntEngCreateClipRegion(ULONG count, PRECTL pRect, PRECTL rcBounds)
{ {
CLIPGDI *Clip; CLIPGDI *Clip;
if(count > 1) if(count > 1)
{
RECTL *dest;
Clip = EngAllocMem(0, sizeof(CLIPGDI) + ((count - 1) * sizeof(RECTL)), TAG_CLIPOBJ);
if(Clip != NULL)
{ {
Clip->EnumRects.c = count; RECTL *dest;
Clip->EnumOrder = CD_ANY;
for(dest = Clip->EnumRects.arcl;
count > 0;
count--, dest++, pRect++)
{
*dest = *pRect;
}
Clip->ClipObj.iDComplexity = DC_COMPLEX; Clip = EngAllocMem(0, sizeof(CLIPGDI) + ((count - 1) * sizeof(RECTL)), TAG_CLIPOBJ);
Clip->ClipObj.iFComplexity = ((Clip->EnumRects.c <= 4) ? FC_RECT4 : FC_COMPLEX);
Clip->ClipObj.iMode = TC_RECTANGLES;
Clip->ClipObj.rclBounds = *rcBounds;
return GDIToObj(Clip, CLIP); if(Clip != NULL)
{
Clip->EnumRects.c = count;
Clip->EnumOrder = CD_ANY;
for(dest = Clip->EnumRects.arcl;count > 0; count--, dest++, pRect++)
{
*dest = *pRect;
}
Clip->ClipObj.iDComplexity = DC_COMPLEX;
Clip->ClipObj.iFComplexity = ((Clip->EnumRects.c <= 4) ? FC_RECT4 : FC_COMPLEX);
Clip->ClipObj.iMode = TC_RECTANGLES;
Clip->ClipObj.rclBounds = *rcBounds;
return GDIToObj(Clip, CLIP);
}
} }
} else
else
{
Clip = EngAllocMem(0, sizeof(CLIPGDI), TAG_CLIPOBJ);
if(Clip != NULL)
{ {
Clip->EnumRects.c = 1; Clip = EngAllocMem(0, sizeof(CLIPGDI), TAG_CLIPOBJ);
Clip->EnumOrder = CD_ANY;
Clip->EnumRects.arcl[0] = *rcBounds;
Clip->ClipObj.iDComplexity = (((rcBounds->top == rcBounds->bottom) && if(Clip != NULL)
(rcBounds->left == rcBounds->right)) {
? DC_TRIVIAL : DC_RECT); Clip->EnumRects.c = 1;
Clip->ClipObj.iFComplexity = FC_RECT; Clip->EnumOrder = CD_ANY;
Clip->ClipObj.iMode = TC_RECTANGLES; Clip->EnumRects.arcl[0] = *rcBounds;
Clip->ClipObj.rclBounds = *rcBounds;
return GDIToObj(Clip, CLIP); Clip->ClipObj.iDComplexity = (((rcBounds->top == rcBounds->bottom) &&
(rcBounds->left == rcBounds->right))
? DC_TRIVIAL : DC_RECT);
Clip->ClipObj.iFComplexity = FC_RECT;
Clip->ClipObj.iMode = TC_RECTANGLES;
Clip->ClipObj.rclBounds = *rcBounds;
return GDIToObj(Clip, CLIP);
}
} }
}
return NULL; return NULL;
} }
/* /*
@ -266,13 +274,13 @@ IntEngCreateClipRegion(ULONG count, PRECTL pRect, PRECTL rcBounds)
CLIPOBJ * STDCALL CLIPOBJ * STDCALL
EngCreateClip(VOID) EngCreateClip(VOID)
{ {
CLIPGDI *Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof(CLIPGDI), TAG_CLIPOBJ); CLIPGDI *Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof(CLIPGDI), TAG_CLIPOBJ);
if(Clip != NULL) if(Clip != NULL)
{ {
return GDIToObj(Clip, CLIP); return GDIToObj(Clip, CLIP);
} }
return NULL; return NULL;
} }
/* /*
@ -281,196 +289,202 @@ EngCreateClip(VOID)
VOID STDCALL VOID STDCALL
EngDeleteClip(CLIPOBJ *ClipRegion) EngDeleteClip(CLIPOBJ *ClipRegion)
{ {
EngFreeMem(ObjToGDI(ClipRegion, CLIP)); EngFreeMem(ObjToGDI(ClipRegion, CLIP));
} }
/* /*
* @implemented * @implemented
*/ */
ULONG STDCALL ULONG STDCALL
CLIPOBJ_cEnumStart(IN CLIPOBJ* ClipObj, CLIPOBJ_cEnumStart(
IN BOOL ShouldDoAll, IN CLIPOBJ* ClipObj,
IN ULONG ClipType, IN BOOL ShouldDoAll,
IN ULONG BuildOrder, IN ULONG ClipType,
IN ULONG MaxRects) IN ULONG BuildOrder,
IN ULONG MaxRects)
{ {
CLIPGDI *ClipGDI = ObjToGDI(ClipObj, CLIP); CLIPGDI *ClipGDI = ObjToGDI(ClipObj, CLIP);
SORTCOMP CompareFunc; SORTCOMP CompareFunc;
ClipGDI->EnumPos = 0; ClipGDI->EnumPos = 0;
ClipGDI->EnumMax = (MaxRects > 0) ? MaxRects : ClipGDI->EnumRects.c; ClipGDI->EnumMax = (MaxRects > 0) ? MaxRects : ClipGDI->EnumRects.c;
if (CD_ANY != BuildOrder && ClipGDI->EnumOrder != BuildOrder) if (CD_ANY != BuildOrder && ClipGDI->EnumOrder != BuildOrder)
{ {
switch (BuildOrder) switch (BuildOrder)
{ {
case CD_RIGHTDOWN: case CD_RIGHTDOWN:
CompareFunc = (SORTCOMP) CompareRightDown; CompareFunc = (SORTCOMP) CompareRightDown;
break; break;
case CD_RIGHTUP:
CompareFunc = (SORTCOMP) CompareRightUp;
break;
case CD_LEFTDOWN:
CompareFunc = (SORTCOMP) CompareLeftDown;
break;
case CD_LEFTUP:
CompareFunc = (SORTCOMP) CompareLeftUp;
break;
default:
DPRINT1("Invalid BuildOrder %d\n", BuildOrder);
BuildOrder = ClipGDI->EnumOrder;
CompareFunc = NULL;
break;
}
if (NULL != CompareFunc) case CD_RIGHTUP:
{ CompareFunc = (SORTCOMP) CompareRightUp;
EngSort((PBYTE) ClipGDI->EnumRects.arcl, sizeof(RECTL), ClipGDI->EnumRects.c, break;
CompareFunc);
}
ClipGDI->EnumOrder = BuildOrder; case CD_LEFTDOWN:
CompareFunc = (SORTCOMP) CompareLeftDown;
break;
case CD_LEFTUP:
CompareFunc = (SORTCOMP) CompareLeftUp;
break;
default:
DPRINT1("Invalid BuildOrder %d\n", BuildOrder);
BuildOrder = ClipGDI->EnumOrder;
CompareFunc = NULL;
break;
}
if (NULL != CompareFunc)
{
EngSort((PBYTE) ClipGDI->EnumRects.arcl, sizeof(RECTL), ClipGDI->EnumRects.c, CompareFunc);
}
ClipGDI->EnumOrder = BuildOrder;
} }
/* Return the number of rectangles enumerated */ /* Return the number of rectangles enumerated */
if ((MaxRects > 0) && (ClipGDI->EnumRects.c > MaxRects)) if ((MaxRects > 0) && (ClipGDI->EnumRects.c > MaxRects))
{ {
return 0xFFFFFFFF; return 0xFFFFFFFF;
} }
return ClipGDI->EnumRects.c; return ClipGDI->EnumRects.c;
} }
/* /*
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
CLIPOBJ_bEnum(IN CLIPOBJ* ClipObj, CLIPOBJ_bEnum(
IN ULONG ObjSize, IN CLIPOBJ* ClipObj,
OUT ULONG *EnumRects) IN ULONG ObjSize,
OUT ULONG *EnumRects)
{ {
RECTL *dest, *src; RECTL *dest, *src;
CLIPGDI *ClipGDI = ObjToGDI(ClipObj, CLIP); CLIPGDI *ClipGDI = ObjToGDI(ClipObj, CLIP);
ULONG nCopy, i; ULONG nCopy, i;
ENUMRECTS* pERects = (ENUMRECTS*)EnumRects; ENUMRECTS* pERects = (ENUMRECTS*)EnumRects;
//calculate how many rectangles we should copy //calculate how many rectangles we should copy
nCopy = min( ClipGDI->EnumMax - ClipGDI->EnumPos, nCopy = min( ClipGDI->EnumMax - ClipGDI->EnumPos,
min( ClipGDI->EnumRects.c - ClipGDI->EnumPos, min( ClipGDI->EnumRects.c - ClipGDI->EnumPos,
(ObjSize - sizeof(ULONG)) / sizeof(RECTL))); (ObjSize - sizeof(ULONG)) / sizeof(RECTL)));
if(nCopy == 0)
{
return FALSE;
}
/* copy rectangles */ if(nCopy == 0)
src = ClipGDI->EnumRects.arcl + ClipGDI->EnumPos; {
for(i = 0, dest = pERects->arcl; return FALSE;
i < nCopy; }
i++, dest++, src++)
{
*dest = *src;
}
pERects->c = nCopy; /* copy rectangles */
src = ClipGDI->EnumRects.arcl + ClipGDI->EnumPos;
for(i = 0, dest = pERects->arcl; i < nCopy; i++, dest++, src++)
{
*dest = *src;
}
ClipGDI->EnumPos+=nCopy; pERects->c = nCopy;
return ClipGDI->EnumPos < ClipGDI->EnumRects.c; ClipGDI->EnumPos+=nCopy;
return ClipGDI->EnumPos < ClipGDI->EnumRects.c;
} }
BOOLEAN FASTCALL BOOLEAN FASTCALL
ClipobjToSpans(PSPAN *Spans, UINT *Count, CLIPOBJ *ClipRegion, PRECTL Boundary) ClipobjToSpans(
PSPAN *Spans,
UINT *Count,
CLIPOBJ *ClipRegion,
PRECTL Boundary)
{ {
BOOL EnumMore; BOOL EnumMore;
UINT i, NewCount; UINT i, NewCount;
RECT_ENUM RectEnum; RECT_ENUM RectEnum;
PSPAN NewSpans; PSPAN NewSpans;
RECTL *Rect; RECTL *Rect;
ASSERT(Boundary->top <= Boundary->bottom && Boundary->left <= Boundary->right); ASSERT(Boundary->top <= Boundary->bottom && Boundary->left <= Boundary->right);
*Spans = NULL; *Spans = NULL;
if (NULL == ClipRegion || DC_TRIVIAL == ClipRegion->iDComplexity) if (NULL == ClipRegion || DC_TRIVIAL == ClipRegion->iDComplexity)
{ {
*Count = Boundary->bottom - Boundary->top; *Count = Boundary->bottom - Boundary->top;
if (0 != *Count) if (0 != *Count)
{ {
*Spans = ExAllocatePoolWithTag(PagedPool, *Count * sizeof(SPAN), TAG_CLIP); *Spans = ExAllocatePoolWithTag(PagedPool, *Count * sizeof(SPAN), TAG_CLIP);
if (NULL == *Spans) if (NULL == *Spans)
{ {
*Count = 0; *Count = 0;
return FALSE; return FALSE;
} }
for (i = 0; i < Boundary->bottom - Boundary->top; i++) for (i = 0; i < Boundary->bottom - Boundary->top; i++)
{ {
(*Spans)[i].X = Boundary->left; (*Spans)[i].X = Boundary->left;
(*Spans)[i].Y = Boundary->top + i; (*Spans)[i].Y = Boundary->top + i;
(*Spans)[i].Width = Boundary->right - Boundary->left; (*Spans)[i].Width = Boundary->right - Boundary->left;
} }
} }
return TRUE; return TRUE;
} }
*Count = 0; *Count = 0;
CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, CD_ANY, 0); CLIPOBJ_cEnumStart(ClipRegion, FALSE, CT_RECTANGLES, CD_ANY, 0);
do do
{ {
EnumMore = CLIPOBJ_bEnum(ClipRegion, (ULONG) sizeof(RECT_ENUM), (PVOID) &RectEnum); EnumMore = CLIPOBJ_bEnum(ClipRegion, (ULONG) sizeof(RECT_ENUM), (PVOID) &RectEnum);
NewCount = *Count; NewCount = *Count;
for (i = 0; i < RectEnum.c; i++) for (i = 0; i < RectEnum.c; i++)
{ {
NewCount += RectEnum.arcl[i].bottom - RectEnum.arcl[i].top; NewCount += RectEnum.arcl[i].bottom - RectEnum.arcl[i].top;
} }
if (NewCount != *Count) if (NewCount != *Count)
{ {
NewSpans = ExAllocatePoolWithTag(PagedPool, NewCount * sizeof(SPAN), TAG_CLIP); NewSpans = ExAllocatePoolWithTag(PagedPool, NewCount * sizeof(SPAN), TAG_CLIP);
if (NULL == NewSpans) if (NULL == NewSpans)
{ {
if (NULL != *Spans) if (NULL != *Spans)
{ {
ExFreePool(*Spans); ExFreePool(*Spans);
*Spans = NULL; *Spans = NULL;
} }
*Count = 0; *Count = 0;
return FALSE; return FALSE;
} }
if (0 != *Count) if (0 != *Count)
{ {
PSPAN dest, src; PSPAN dest, src;
UINT i = *Count; UINT i = *Count;
for(dest = NewSpans, src = *Spans; for(dest = NewSpans, src = *Spans;i > 0; i--)
i > 0; {
i--) *dest++ = *src++;
{ }
*dest++ = *src++; ExFreePool(*Spans);
}
ExFreePool(*Spans);
} }
*Spans = NewSpans; *Spans = NewSpans;
} }
for (Rect = RectEnum.arcl; Rect < RectEnum.arcl + RectEnum.c; Rect++) for (Rect = RectEnum.arcl; Rect < RectEnum.arcl + RectEnum.c; Rect++)
{ {
for (i = 0; i < Rect->bottom - Rect->top; i++) for (i = 0; i < Rect->bottom - Rect->top; i++)
{ {
(*Spans)[*Count].X = Rect->left; (*Spans)[*Count].X = Rect->left;
(*Spans)[*Count].Y = Rect->top + i; (*Spans)[*Count].Y = Rect->top + i;
(*Spans)[*Count].Width = Rect->right - Rect->left; (*Spans)[*Count].Width = Rect->right - Rect->left;
(*Count)++; (*Count)++;
} }
} }
ASSERT(*Count == NewCount); ASSERT(*Count == NewCount);
} }
while (EnumMore); while (EnumMore);
if (0 != *Count) if (0 != *Count)
{ {
EngSort((PBYTE) *Spans, sizeof(SPAN), *Count, (SORTCOMP) CompareSpans); EngSort((PBYTE) *Spans, sizeof(SPAN), *Count, (SORTCOMP) CompareSpans);
} }
return TRUE; return TRUE;
} }
/* EOF */ /* EOF */