BOOL WINAPI
UnionRect( LPRECT dest, const RECT *src1, const RECT *src2 )
{
if (IsRectEmpty(src1))
{
if (IsRectEmpty(src2))
{
SetRectEmpty( dest );
return FALSE;
}
else *dest = *src2;
}
else
{
if (IsRectEmpty(src2)) *dest = *src1;
else
{
dest->left = MWMIN( src1->left, src2->left );
dest->right = MWMAX( src1->right, src2->right );
dest->top = MWMIN( src1->top, src2->top );
dest->bottom = MWMAX( src1->bottom, src2->bottom );
}
}
return TRUE;
}
HBITMAP WINAPI
CreateCompatibleBitmap(HDC hdc, int nWidth, int nHeight)
{
MWBITMAPOBJ * hbitmap;
int size;
int linelen;
if(!hdc)
return NULL;
nWidth = MWMAX(nWidth, 1);
nHeight = MWMAX(nHeight, 1);
/* calc memory allocation size and linelen from width and height*/
if(!GdCalcMemGCAlloc(hdc->psd, nWidth, nHeight, 0, 0, &size, &linelen))
return NULL;
/* allocate gdi object*/
hbitmap = (MWBITMAPOBJ *)GdItemAlloc(sizeof(MWBITMAPOBJ)-1+size);
if(!hbitmap)
return NULL;
hbitmap->hdr.type = OBJ_BITMAP;
hbitmap->hdr.stockobj = FALSE;
hbitmap->width = nWidth;
hbitmap->height = nHeight;
/* create compatible with hdc*/
hbitmap->planes = hdc->psd->planes;
hbitmap->bpp = hdc->psd->bpp;
hbitmap->linelen = linelen;
hbitmap->size = size;
return (HBRUSH)hbitmap;
}
/*
* Rectangle-related functions
*
* Copyright 1993, 1996 Alexandre Julliard
*
*/
BOOL WINAPI
IntersectRect( LPRECT dest, const RECT *src1, const RECT *src2 )
{
if (IsRectEmpty(src1) || IsRectEmpty(src2) ||
(src1->left >= src2->right) || (src2->left >= src1->right) ||
(src1->top >= src2->bottom) || (src2->top >= src1->bottom))
{
SetRectEmpty( dest );
return FALSE;
}
dest->left = MWMAX( src1->left, src2->left );
dest->right = MWMIN( src1->right, src2->right );
dest->top = MWMAX( src1->top, src2->top );
dest->bottom = MWMIN( src1->bottom, src2->bottom );
return TRUE;
}
/*
* GdAllocPolyPolygonRegion
*/
MWCLIPREGION *
GdAllocPolyPolygonRegion(MWPOINT *points, int *count, int nbpolygons, int mode)
{
MWCLIPREGION *rgn;
EdgeTableEntry *pAET; /* Active Edge Table */
int y; /* current scanline */
int iPts = 0; /* number of pts in buffer */
EdgeTableEntry *pWETE; /* Winding Edge Table Entry*/
ScanLineList *pSLL; /* current scanLineList */
MWPOINT *pts; /* output buffer */
EdgeTableEntry *pPrevAET; /* ptr to previous AET */
EdgeTable ET; /* header node for ET */
EdgeTableEntry AET; /* header node for AET */
EdgeTableEntry *pETEs; /* EdgeTableEntries pool */
ScanLineListBlock SLLBlock; /* header for scanlinelist */
int fixWAET = FALSE;
POINTBLOCK FirstPtBlock, *curPtBlock; /* PtBlock buffers */
POINTBLOCK *tmpPtBlock;
int numFullPtBlocks = 0;
int poly, total;
if(!(rgn = GdAllocRegion()))
return NULL;
/* special case a rectangle */
if (((nbpolygons == 1) && ((*count == 4) ||
((*count == 5) && (points[4].x == points[0].x)
&& (points[4].y == points[0].y)))) &&
(((points[0].y == points[1].y) &&
(points[1].x == points[2].x) &&
(points[2].y == points[3].y) &&
(points[3].x == points[0].x)) ||
((points[0].x == points[1].x) &&
(points[1].y == points[2].y) &&
(points[2].x == points[3].x) &&
(points[3].y == points[0].y))))
{
GdSetRectRegion( rgn,
MWMIN(points[0].x, points[2].x), MWMIN(points[0].y, points[2].y),
MWMAX(points[0].x, points[2].x), MWMAX(points[0].y, points[2].y) );
return rgn;
}
for(poly = total = 0; poly < nbpolygons; poly++)
total += count[poly];
if (! (pETEs = malloc( sizeof(EdgeTableEntry) * total )))
{
GdDestroyRegion( rgn );
return 0;
}
pts = FirstPtBlock.pts;
REGION_CreateETandAET(count, nbpolygons, points, &ET, &AET,
pETEs, &SLLBlock);
pSLL = ET.scanlines.next;
curPtBlock = &FirstPtBlock;
if (mode != MWPOLY_WINDING) {
/*
* for each scanline
*/
for (y = ET.ymin; y < ET.ymax; y++) {
/*
* Add a new edge to the active edge table when we
* get to the next edge.
*/
if (pSLL != NULL && y == pSLL->scanline) {
REGION_loadAET(&AET, pSLL->edgelist);
pSLL = pSLL->next;
}
pPrevAET = &AET;
pAET = AET.next;
/*
* for each active edge
*/
while (pAET) {
pts->x = pAET->bres.minor_axis, pts->y = y;
pts++, iPts++;
/*
* send out the buffer
*/
if (iPts == NUMPTSTOBUFFER) {
tmpPtBlock = malloc( sizeof(POINTBLOCK));
if(!tmpPtBlock) {
return 0;
}
curPtBlock->next = tmpPtBlock;
curPtBlock = tmpPtBlock;
pts = curPtBlock->pts;
numFullPtBlocks++;
iPts = 0;
}
EVALUATEEDGEEVENODD(pAET, pPrevAET, y);
}
REGION_InsertionSort(&AET);
}
}
else {
/*
* for each scanline
*/
for (y = ET.ymin; y < ET.ymax; y++) {
/*
* Add a new edge to the active edge table when we
* get to the next edge.
*/
if (pSLL != NULL && y == pSLL->scanline) {
REGION_loadAET(&AET, pSLL->edgelist);
REGION_computeWAET(&AET);
pSLL = pSLL->next;
}
pPrevAET = &AET;
pAET = AET.next;
pWETE = pAET;
/*
* for each active edge
*/
while (pAET) {
/*
* add to the buffer only those edges that
* are in the Winding active edge table.
*/
if (pWETE == pAET) {
pts->x = pAET->bres.minor_axis, pts->y = y;
pts++, iPts++;
/*
* send out the buffer
*/
if (iPts == NUMPTSTOBUFFER) {
tmpPtBlock = malloc( sizeof(POINTBLOCK) );
if(!tmpPtBlock) {
return 0;
}
curPtBlock->next = tmpPtBlock;
curPtBlock = tmpPtBlock;
pts = curPtBlock->pts;
numFullPtBlocks++; iPts = 0;
}
pWETE = pWETE->nextWETE;
}
EVALUATEEDGEWINDING(pAET, pPrevAET, y, fixWAET);
}
/*
* recompute the winding active edge table if
* we just resorted or have exited an edge.
*/
if (REGION_InsertionSort(&AET) || fixWAET) {
REGION_computeWAET(&AET);
fixWAET = FALSE;
}
}
}
REGION_FreeStorage(SLLBlock.next);
REGION_PtsToRegion(numFullPtBlocks, iPts, &FirstPtBlock, rgn);
for (curPtBlock = FirstPtBlock.next; --numFullPtBlocks >= 0;) {
tmpPtBlock = curPtBlock->next;
free( curPtBlock );
curPtBlock = tmpPtBlock;
}
free( pETEs );
return rgn;
}
