799 lines
21 KiB
C
799 lines
21 KiB
C
/*
|
|
* GDI region objects
|
|
*
|
|
* Copyright 1993, 1994, 1995 Alexandre Julliard
|
|
*
|
|
* RGNOBJ is documented in the Dr. Dobbs Journal March 1993.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "region.h"
|
|
#include "stddebug.h"
|
|
#include "debug.h"
|
|
|
|
|
|
/***********************************************************************
|
|
* REGION_DeleteObject
|
|
*/
|
|
BOOL32 REGION_DeleteObject( HRGN32 hrgn, RGNOBJ * obj )
|
|
{
|
|
dprintf_region(stddeb, "DeleteRegion: %04x\n", hrgn );
|
|
if (obj->xrgn) XDestroyRegion( obj->xrgn );
|
|
return GDI_FreeObject( hrgn );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* OffsetRgn16 (GDI.101)
|
|
*/
|
|
INT16 WINAPI OffsetRgn16( HRGN16 hrgn, INT16 x, INT16 y )
|
|
{
|
|
return OffsetRgn32( hrgn, x, y );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* OffsetRgn32 (GDI32.256)
|
|
*/
|
|
INT32 WINAPI OffsetRgn32( HRGN32 hrgn, INT32 x, INT32 y )
|
|
{
|
|
RGNOBJ * obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
|
|
|
|
if (obj)
|
|
{
|
|
INT32 ret;
|
|
dprintf_region(stddeb, "OffsetRgn: %04x %d,%d\n", hrgn, x, y );
|
|
if (obj->xrgn)
|
|
{
|
|
XOffsetRegion( obj->xrgn, x, y );
|
|
ret = COMPLEXREGION;
|
|
}
|
|
else
|
|
ret = NULLREGION;
|
|
GDI_HEAP_UNLOCK( hrgn );
|
|
return ret;
|
|
}
|
|
return ERROR;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetRgnBox16 (GDI.134)
|
|
*/
|
|
INT16 WINAPI GetRgnBox16( HRGN16 hrgn, LPRECT16 rect )
|
|
{
|
|
RGNOBJ * obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC );
|
|
if (obj)
|
|
{
|
|
INT16 ret;
|
|
dprintf_region(stddeb, "GetRgnBox: %04x\n", hrgn );
|
|
if (obj->xrgn)
|
|
{
|
|
XRectangle xrect;
|
|
XClipBox( obj->xrgn, &xrect );
|
|
SetRect16( rect, xrect.x, xrect.y,
|
|
xrect.x + xrect.width, xrect.y + xrect.height);
|
|
ret = COMPLEXREGION;
|
|
}
|
|
else
|
|
{
|
|
SetRectEmpty16( rect );
|
|
ret = NULLREGION;
|
|
}
|
|
GDI_HEAP_UNLOCK(hrgn);
|
|
return ret;
|
|
}
|
|
return ERROR;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetRgnBox32 (GDI32.219)
|
|
*/
|
|
INT32 WINAPI GetRgnBox32( HRGN32 hrgn, LPRECT32 rect )
|
|
{
|
|
RECT16 r;
|
|
INT16 ret = GetRgnBox16( hrgn, &r );
|
|
CONV_RECT16TO32( &r, rect );
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateRectRgn16 (GDI.64)
|
|
*/
|
|
HRGN16 WINAPI CreateRectRgn16(INT16 left, INT16 top, INT16 right, INT16 bottom)
|
|
{
|
|
return (HRGN16)CreateRectRgn32( left, top, right, bottom );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateRectRgn32 (GDI32.59)
|
|
*/
|
|
HRGN32 WINAPI CreateRectRgn32(INT32 left, INT32 top, INT32 right, INT32 bottom)
|
|
{
|
|
HRGN32 hrgn;
|
|
RGNOBJ *obj;
|
|
|
|
if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
|
|
obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
|
|
if ((right > left) && (bottom > top))
|
|
{
|
|
XRectangle rect = { left, top, right - left, bottom - top };
|
|
if (!(obj->xrgn = XCreateRegion()))
|
|
{
|
|
GDI_FreeObject( hrgn );
|
|
return 0;
|
|
}
|
|
XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
|
|
}
|
|
else obj->xrgn = 0;
|
|
dprintf_region( stddeb, "CreateRectRgn(%d,%d-%d,%d): returning %04x\n",
|
|
left, top, right, bottom, hrgn );
|
|
GDI_HEAP_UNLOCK( hrgn );
|
|
return hrgn;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateRectRgnIndirect16 (GDI.65)
|
|
*/
|
|
HRGN16 WINAPI CreateRectRgnIndirect16( const RECT16* rect )
|
|
{
|
|
return CreateRectRgn32( rect->left, rect->top, rect->right, rect->bottom );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateRectRgnIndirect32 (GDI32.60)
|
|
*/
|
|
HRGN32 WINAPI CreateRectRgnIndirect32( const RECT32* rect )
|
|
{
|
|
return CreateRectRgn32( rect->left, rect->top, rect->right, rect->bottom );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetRectRgn16 (GDI.172)
|
|
*/
|
|
VOID WINAPI SetRectRgn16( HRGN16 hrgn, INT16 left, INT16 top,
|
|
INT16 right, INT16 bottom )
|
|
{
|
|
SetRectRgn32( hrgn, left, top, right, bottom );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetRectRgn32 (GDI32.332)
|
|
*/
|
|
VOID WINAPI SetRectRgn32( HRGN32 hrgn, INT32 left, INT32 top,
|
|
INT32 right, INT32 bottom )
|
|
{
|
|
RGNOBJ * obj;
|
|
|
|
dprintf_region(stddeb, "SetRectRgn: %04x %d,%d-%d,%d\n",
|
|
hrgn, left, top, right, bottom );
|
|
|
|
if (!(obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC ))) return;
|
|
if (obj->xrgn) XDestroyRegion( obj->xrgn );
|
|
if ((right > left) && (bottom > top))
|
|
{
|
|
XRectangle rect = { left, top, right - left, bottom - top };
|
|
if ((obj->xrgn = XCreateRegion()) != 0)
|
|
XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
|
|
}
|
|
else obj->xrgn = 0;
|
|
GDI_HEAP_UNLOCK( hrgn );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateRoundRectRgn16 (GDI.444)
|
|
*/
|
|
HRGN16 WINAPI CreateRoundRectRgn16( INT16 left, INT16 top,
|
|
INT16 right, INT16 bottom,
|
|
INT16 ellipse_width, INT16 ellipse_height )
|
|
{
|
|
return (HRGN16)CreateRoundRectRgn32( left, top, right, bottom,
|
|
ellipse_width, ellipse_height );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateRoundRectRgn32 (GDI32.61)
|
|
*/
|
|
HRGN32 WINAPI CreateRoundRectRgn32( INT32 left, INT32 top,
|
|
INT32 right, INT32 bottom,
|
|
INT32 ellipse_width, INT32 ellipse_height )
|
|
{
|
|
RGNOBJ * obj;
|
|
HRGN32 hrgn;
|
|
XRectangle rect;
|
|
int asq, bsq, d, xd, yd;
|
|
|
|
/* Check if we can do a normal rectangle instead */
|
|
|
|
if ((right <= left) || (bottom <= top) ||
|
|
(ellipse_width <= 0) || (ellipse_height <= 0))
|
|
return CreateRectRgn32( left, top, right, bottom );
|
|
|
|
/* Create region */
|
|
|
|
if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC ))) return 0;
|
|
obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
|
|
obj->xrgn = XCreateRegion();
|
|
dprintf_region(stddeb,"CreateRoundRectRgn(%d,%d-%d,%d %dx%d): return=%04x\n",
|
|
left, top, right, bottom, ellipse_width, ellipse_height, hrgn );
|
|
|
|
/* Check parameters */
|
|
|
|
if (ellipse_width > right-left) ellipse_width = right-left;
|
|
if (ellipse_height > bottom-top) ellipse_height = bottom-top;
|
|
|
|
/* Ellipse algorithm, based on an article by K. Porter */
|
|
/* in DDJ Graphics Programming Column, 8/89 */
|
|
|
|
asq = ellipse_width * ellipse_width / 4; /* a^2 */
|
|
bsq = ellipse_height * ellipse_height / 4; /* b^2 */
|
|
d = bsq - asq * ellipse_height / 2 + asq / 4; /* b^2 - a^2b + a^2/4 */
|
|
xd = 0;
|
|
yd = asq * ellipse_height; /* 2a^2b */
|
|
|
|
rect.x = left + ellipse_width / 2;
|
|
rect.width = right - left - ellipse_width;
|
|
rect.height = 1;
|
|
|
|
/* Loop to draw first half of quadrant */
|
|
|
|
while (xd < yd)
|
|
{
|
|
if (d > 0) /* if nearest pixel is toward the center */
|
|
{
|
|
/* move toward center */
|
|
rect.y = top++;
|
|
XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
|
|
rect.y = --bottom;
|
|
XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
|
|
yd -= 2*asq;
|
|
d -= yd;
|
|
}
|
|
rect.x--; /* next horiz point */
|
|
rect.width += 2;
|
|
xd += 2*bsq;
|
|
d += bsq + xd;
|
|
}
|
|
|
|
/* Loop to draw second half of quadrant */
|
|
|
|
d += (3 * (asq-bsq) / 2 - (xd+yd)) / 2;
|
|
while (yd >= 0)
|
|
{
|
|
/* next vertical point */
|
|
rect.y = top++;
|
|
XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
|
|
rect.y = --bottom;
|
|
XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
|
|
if (d < 0) /* if nearest pixel is outside ellipse */
|
|
{
|
|
rect.x--; /* move away from center */
|
|
rect.width += 2;
|
|
xd += 2*bsq;
|
|
d += xd;
|
|
}
|
|
yd -= 2*asq;
|
|
d += asq - yd;
|
|
}
|
|
|
|
/* Add the inside rectangle */
|
|
|
|
if (top <= bottom)
|
|
{
|
|
rect.y = top;
|
|
rect.height = bottom - top + 1;
|
|
XUnionRectWithRegion( &rect, obj->xrgn, obj->xrgn );
|
|
}
|
|
GDI_HEAP_UNLOCK( hrgn );
|
|
return hrgn;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateEllipticRgn16 (GDI.54)
|
|
*/
|
|
HRGN16 WINAPI CreateEllipticRgn16( INT16 left, INT16 top,
|
|
INT16 right, INT16 bottom )
|
|
{
|
|
return (HRGN16)CreateRoundRectRgn32( left, top, right, bottom,
|
|
right-left, bottom-top );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateEllipticRgn32 (GDI32.39)
|
|
*/
|
|
HRGN32 WINAPI CreateEllipticRgn32( INT32 left, INT32 top,
|
|
INT32 right, INT32 bottom )
|
|
{
|
|
return CreateRoundRectRgn32( left, top, right, bottom,
|
|
right-left, bottom-top );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateEllipticRgnIndirect16 (GDI.55)
|
|
*/
|
|
HRGN16 WINAPI CreateEllipticRgnIndirect16( const RECT16 *rect )
|
|
{
|
|
return CreateRoundRectRgn32( rect->left, rect->top, rect->right,
|
|
rect->bottom, rect->right - rect->left,
|
|
rect->bottom - rect->top );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreateEllipticRgnIndirect32 (GDI32.40)
|
|
*/
|
|
HRGN32 WINAPI CreateEllipticRgnIndirect32( const RECT32 *rect )
|
|
{
|
|
return CreateRoundRectRgn32( rect->left, rect->top, rect->right,
|
|
rect->bottom, rect->right - rect->left,
|
|
rect->bottom - rect->top );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreatePolygonRgn16 (GDI.63)
|
|
*/
|
|
HRGN16 WINAPI CreatePolygonRgn16( const POINT16 * points, INT16 count,
|
|
INT16 mode )
|
|
{
|
|
return CreatePolyPolygonRgn16( points, &count, 1, mode );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreatePolyPolygonRgn16 (GDI.451)
|
|
*/
|
|
HRGN16 WINAPI CreatePolyPolygonRgn16( const POINT16 * points,
|
|
const INT16 * count,
|
|
INT16 nbpolygons, INT16 mode )
|
|
{
|
|
int i,nrofpts;
|
|
LPINT32 count32;
|
|
LPPOINT32 points32;
|
|
HRGN32 ret;
|
|
|
|
nrofpts=0;
|
|
for (i=nbpolygons;i--;)
|
|
nrofpts+=count[i];
|
|
points32 = (LPPOINT32)HeapAlloc( GetProcessHeap(), 0,
|
|
nrofpts*sizeof(POINT32) );
|
|
for (i=nrofpts;i--;)
|
|
CONV_POINT16TO32( &(points[i]), &(points32[i]) );
|
|
count32 = (LPINT32)HeapAlloc( GetProcessHeap(), 0,
|
|
sizeof(INT32)*nbpolygons );
|
|
for (i=nbpolygons;i--;)
|
|
count32[i]=count[i];
|
|
ret = CreatePolyPolygonRgn32(points32,count32,nbpolygons,mode);
|
|
HeapFree( GetProcessHeap(), 0, count32 );
|
|
HeapFree( GetProcessHeap(), 0, points32 );
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreatePolygonRgn32 (GDI32.58)
|
|
*/
|
|
HRGN32 WINAPI CreatePolygonRgn32( const POINT32 *points, INT32 count,
|
|
INT32 mode )
|
|
{
|
|
return CreatePolyPolygonRgn32( points, &count, 1, mode );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CreatePolyPolygonRgn32 (GDI32.57)
|
|
*/
|
|
HRGN32 WINAPI CreatePolyPolygonRgn32( const POINT32 * points,
|
|
const INT32 * count,
|
|
INT32 nbpolygons, INT32 mode )
|
|
{
|
|
RGNOBJ * obj;
|
|
HRGN32 hrgn;
|
|
int i, j, maxPoints;
|
|
XPoint *xpoints, *pt;
|
|
Region xrgn;
|
|
|
|
/* Allocate points array */
|
|
|
|
if (!nbpolygons) return 0;
|
|
for (i = maxPoints = 0; i < nbpolygons; i++)
|
|
if (maxPoints < count[i]) maxPoints = count[i];
|
|
if (!maxPoints) return 0;
|
|
if (!(xpoints = (XPoint *)HeapAlloc( GetProcessHeap(), 0,
|
|
sizeof(XPoint) * maxPoints )))
|
|
return 0;
|
|
|
|
/* Allocate region */
|
|
|
|
if (!(hrgn = GDI_AllocObject( sizeof(RGNOBJ), REGION_MAGIC )))
|
|
{
|
|
HeapFree( GetProcessHeap(), 0, xpoints );
|
|
return 0;
|
|
}
|
|
obj = (RGNOBJ *) GDI_HEAP_LOCK( hrgn );
|
|
obj->xrgn = 0;
|
|
dprintf_region(stddeb, "CreatePolyPolygonRgn: %d polygons, returning %04x\n",
|
|
nbpolygons, hrgn );
|
|
|
|
/* Create X region */
|
|
|
|
for (i = 0; i < nbpolygons; i++, count++)
|
|
{
|
|
if (*count <= 1) continue;
|
|
for (j = *count, pt = xpoints; j > 0; j--, points++, pt++)
|
|
{
|
|
pt->x = points->x;
|
|
pt->y = points->y;
|
|
}
|
|
xrgn = XPolygonRegion( xpoints, *count,
|
|
(mode == WINDING) ? WindingRule : EvenOddRule );
|
|
if (!xrgn)
|
|
{
|
|
if (obj->xrgn) XDestroyRegion( obj->xrgn );
|
|
HeapFree( GetProcessHeap(), 0, xpoints );
|
|
GDI_FreeObject( hrgn );
|
|
return 0;
|
|
}
|
|
if (obj->xrgn)
|
|
{
|
|
Region tmprgn = XCreateRegion();
|
|
if (mode == WINDING) XUnionRegion( xrgn, obj->xrgn, tmprgn );
|
|
else XXorRegion( xrgn, obj->xrgn, tmprgn );
|
|
XDestroyRegion( obj->xrgn );
|
|
obj->xrgn = tmprgn;
|
|
}
|
|
else obj->xrgn = xrgn;
|
|
}
|
|
|
|
HeapFree( GetProcessHeap(), 0, xpoints );
|
|
GDI_HEAP_UNLOCK( hrgn );
|
|
return hrgn;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* PtInRegion16 (GDI.161)
|
|
*/
|
|
BOOL16 WINAPI PtInRegion16( HRGN16 hrgn, INT16 x, INT16 y )
|
|
{
|
|
return PtInRegion32( hrgn, x, y );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* PtInRegion32 (GDI32.278)
|
|
*/
|
|
BOOL32 WINAPI PtInRegion32( HRGN32 hrgn, INT32 x, INT32 y )
|
|
{
|
|
RGNOBJ * obj;
|
|
|
|
if ((obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC )))
|
|
{
|
|
BOOL32 ret;
|
|
if (obj->xrgn)
|
|
ret = XPointInRegion( obj->xrgn, x, y );
|
|
else
|
|
ret = FALSE;
|
|
GDI_HEAP_UNLOCK( hrgn );
|
|
return ret;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* RectInRegion16 (GDI.181)
|
|
*/
|
|
BOOL16 WINAPI RectInRegion16( HRGN16 hrgn, const RECT16 *rect )
|
|
{
|
|
RGNOBJ * obj;
|
|
|
|
if ((obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC )))
|
|
{
|
|
BOOL16 ret;
|
|
if (obj->xrgn)
|
|
ret = (XRectInRegion( obj->xrgn, rect->left, rect->top,
|
|
rect->right-rect->left, rect->bottom-rect->top ) != RectangleOut);
|
|
else
|
|
ret = FALSE;
|
|
GDI_HEAP_UNLOCK( hrgn );
|
|
return ret;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* RectInRegion32 (GDI32.281)
|
|
*/
|
|
BOOL32 WINAPI RectInRegion32( HRGN32 hrgn, const RECT32 *rect )
|
|
{
|
|
RGNOBJ * obj;
|
|
|
|
if ((obj = (RGNOBJ *) GDI_GetObjPtr( hrgn, REGION_MAGIC )))
|
|
{
|
|
BOOL32 ret;
|
|
if (obj->xrgn)
|
|
ret = (XRectInRegion( obj->xrgn, rect->left, rect->top,
|
|
rect->right-rect->left, rect->bottom-rect->top ) != RectangleOut);
|
|
else
|
|
ret = FALSE;
|
|
GDI_HEAP_UNLOCK( hrgn );
|
|
return ret;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* EqualRgn16 (GDI.72)
|
|
*/
|
|
BOOL16 WINAPI EqualRgn16( HRGN16 rgn1, HRGN16 rgn2 )
|
|
{
|
|
return EqualRgn32( rgn1, rgn2 );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* EqualRgn32 (GDI32.90)
|
|
*/
|
|
BOOL32 WINAPI EqualRgn32( HRGN32 rgn1, HRGN32 rgn2 )
|
|
{
|
|
RGNOBJ *obj1, *obj2;
|
|
BOOL32 ret = FALSE;
|
|
|
|
if ((obj1 = (RGNOBJ *) GDI_GetObjPtr( rgn1, REGION_MAGIC )))
|
|
{
|
|
if ((obj2 = (RGNOBJ *) GDI_GetObjPtr( rgn2, REGION_MAGIC )))
|
|
{
|
|
if (!obj1->xrgn || !obj2->xrgn)
|
|
ret = (!obj1->xrgn && !obj2->xrgn);
|
|
else
|
|
ret = XEqualRegion( obj1->xrgn, obj2->xrgn );
|
|
GDI_HEAP_UNLOCK( rgn2 );
|
|
}
|
|
GDI_HEAP_UNLOCK( rgn1 );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* REGION_CopyRegion
|
|
*
|
|
* Copy region src into dest.
|
|
*/
|
|
static INT32 REGION_CopyRegion( RGNOBJ *src, RGNOBJ *dest )
|
|
{
|
|
Region tmprgn;
|
|
if (src->xrgn)
|
|
{
|
|
if (src->xrgn == dest->xrgn) return COMPLEXREGION;
|
|
tmprgn = XCreateRegion();
|
|
if (!dest->xrgn) dest->xrgn = XCreateRegion();
|
|
XUnionRegion( tmprgn, src->xrgn, dest->xrgn );
|
|
XDestroyRegion( tmprgn );
|
|
return COMPLEXREGION;
|
|
}
|
|
else
|
|
{
|
|
if (dest->xrgn) XDestroyRegion( dest->xrgn );
|
|
dest->xrgn = 0;
|
|
return NULLREGION;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* REGION_IsEmpty
|
|
*/
|
|
BOOL32 REGION_IsEmpty( HRGN32 hRgn )
|
|
{
|
|
RGNOBJ* rgnObj = (RGNOBJ*) GDI_GetObjPtr( hRgn, REGION_MAGIC );
|
|
BOOL32 ret = TRUE;
|
|
|
|
if( rgnObj )
|
|
{
|
|
if( rgnObj->xrgn && !XEmptyRegion(rgnObj->xrgn) ) ret = FALSE;
|
|
GDI_HEAP_UNLOCK( hRgn );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* REGION_UnionRectWithRgn
|
|
*
|
|
* Add rc rectangle to the region.
|
|
*/
|
|
BOOL32 REGION_UnionRectWithRgn( HRGN32 hRgn, const RECT32 *rc )
|
|
{
|
|
RGNOBJ* rgnObj = (RGNOBJ*) GDI_GetObjPtr( hRgn, REGION_MAGIC );
|
|
XRectangle rect = { rc->left, rc->top, rc->right - rc->left, rc->bottom - rc->top };
|
|
BOOL32 ret = ERROR;
|
|
|
|
if( rgnObj )
|
|
{
|
|
if( !rgnObj->xrgn )
|
|
{
|
|
if ((rgnObj->xrgn = XCreateRegion()))
|
|
ret = SIMPLEREGION;
|
|
else
|
|
goto done;
|
|
}
|
|
else
|
|
ret = COMPLEXREGION;
|
|
XUnionRectWithRegion( &rect, rgnObj->xrgn, rgnObj->xrgn );
|
|
done:
|
|
GDI_HEAP_UNLOCK( hRgn );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* REGION_CreateFrameRgn
|
|
*
|
|
* Create a region that is a frame around another region
|
|
*/
|
|
BOOL32 REGION_FrameRgn( HRGN32 hDest, HRGN32 hSrc, INT32 x, INT32 y )
|
|
{
|
|
BOOL32 bRet;
|
|
RGNOBJ *srcObj = (RGNOBJ*) GDI_GetObjPtr( hSrc, REGION_MAGIC );
|
|
|
|
if (srcObj->xrgn)
|
|
{
|
|
RGNOBJ* destObj = (RGNOBJ*) GDI_GetObjPtr( hDest, REGION_MAGIC );
|
|
Region resRgn;
|
|
|
|
REGION_CopyRegion( srcObj, destObj );
|
|
XShrinkRegion( destObj->xrgn, -x, -y );
|
|
resRgn = XCreateRegion();
|
|
XSubtractRegion( destObj->xrgn, srcObj->xrgn, resRgn );
|
|
XDestroyRegion( destObj->xrgn );
|
|
destObj->xrgn = resRgn;
|
|
GDI_HEAP_UNLOCK( hDest );
|
|
bRet = TRUE;
|
|
}
|
|
else
|
|
bRet = FALSE;
|
|
GDI_HEAP_UNLOCK( hSrc );
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CombineRgn16 (GDI.451)
|
|
*/
|
|
INT16 WINAPI CombineRgn16(HRGN16 hDest, HRGN16 hSrc1, HRGN16 hSrc2, INT16 mode)
|
|
{
|
|
return (INT16)CombineRgn32( hDest, hSrc1, hSrc2, mode );
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* CombineRgn32 (GDI32.19)
|
|
*
|
|
* Note: The behavior is correct even if src and dest regions are the same.
|
|
*/
|
|
INT32 WINAPI CombineRgn32(HRGN32 hDest, HRGN32 hSrc1, HRGN32 hSrc2, INT32 mode)
|
|
{
|
|
RGNOBJ *destObj = (RGNOBJ *) GDI_GetObjPtr( hDest, REGION_MAGIC);
|
|
INT32 result = ERROR;
|
|
|
|
dprintf_region(stddeb, "CombineRgn: %04x,%04x -> %04x mode=%x\n",
|
|
hSrc1, hSrc2, hDest, mode );
|
|
if (destObj)
|
|
{
|
|
RGNOBJ *src1Obj = (RGNOBJ *) GDI_GetObjPtr( hSrc1, REGION_MAGIC);
|
|
|
|
if (src1Obj)
|
|
{
|
|
if (mode == RGN_COPY)
|
|
result = REGION_CopyRegion( src1Obj, destObj );
|
|
else
|
|
{
|
|
RGNOBJ *src2Obj = (RGNOBJ *) GDI_GetObjPtr( hSrc2, REGION_MAGIC);
|
|
|
|
if (src2Obj)
|
|
{
|
|
if (!src1Obj->xrgn || !src2Obj->xrgn)
|
|
{
|
|
/* Some optimizations for null regions */
|
|
switch( mode )
|
|
{
|
|
case RGN_DIFF:
|
|
if (src1Obj->xrgn)
|
|
{
|
|
result = REGION_CopyRegion( src1Obj, destObj );
|
|
break;
|
|
}
|
|
/* else fall through */
|
|
case RGN_AND:
|
|
if (destObj->xrgn)
|
|
{
|
|
XDestroyRegion( destObj->xrgn );
|
|
destObj->xrgn = 0;
|
|
}
|
|
result = NULLREGION;
|
|
break;
|
|
|
|
case RGN_OR:
|
|
case RGN_XOR:
|
|
#define __SRC_RGN ((src1Obj->xrgn) ? src1Obj : src2Obj)
|
|
result = REGION_CopyRegion( __SRC_RGN, destObj );
|
|
#undef __SRC_RGN
|
|
break;
|
|
|
|
case 0:
|
|
default:
|
|
/* makes gcc generate more efficient code */
|
|
}
|
|
}
|
|
else /* both regions are present */
|
|
{
|
|
Region destRgn = XCreateRegion();
|
|
|
|
if (destRgn)
|
|
{
|
|
switch (mode)
|
|
{
|
|
case RGN_AND:
|
|
XIntersectRegion( src1Obj->xrgn, src2Obj->xrgn, destRgn );
|
|
break;
|
|
case RGN_OR:
|
|
XUnionRegion( src1Obj->xrgn, src2Obj->xrgn, destRgn );
|
|
break;
|
|
case RGN_XOR:
|
|
XXorRegion( src1Obj->xrgn, src2Obj->xrgn, destRgn );
|
|
break;
|
|
case RGN_DIFF:
|
|
XSubtractRegion( src1Obj->xrgn, src2Obj->xrgn, destRgn );
|
|
break;
|
|
|
|
case 0: /* makes gcc generate more efficient code */
|
|
default:
|
|
XDestroyRegion( destRgn );
|
|
goto done;
|
|
}
|
|
|
|
if ( destObj->xrgn )
|
|
XDestroyRegion( destObj->xrgn );
|
|
if ( XEmptyRegion( destRgn ) )
|
|
{
|
|
XDestroyRegion( destRgn );
|
|
destObj->xrgn = 0;
|
|
result = NULLREGION;
|
|
}
|
|
else
|
|
{
|
|
destObj->xrgn = destRgn;
|
|
result = COMPLEXREGION;
|
|
}
|
|
}
|
|
}
|
|
done:
|
|
GDI_HEAP_UNLOCK( hSrc2 );
|
|
}
|
|
}
|
|
GDI_HEAP_UNLOCK( hSrc1 );
|
|
}
|
|
GDI_HEAP_UNLOCK( hDest );
|
|
}
|
|
return result;
|
|
}
|
|
|