503 lines
12 KiB
C
503 lines
12 KiB
C
/**************************************************************************\
|
|
*
|
|
* Copyright (c) 1998-2000, Microsoft Corp. All Rights Reserved.
|
|
*
|
|
* Module Name:
|
|
*
|
|
* Region.hpp
|
|
*
|
|
* Abstract:
|
|
*
|
|
* Region API related declarations
|
|
*
|
|
* Created:
|
|
*
|
|
* 2/3/1999 DCurtis
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#ifndef _GDIPLUSREGION_H
|
|
#define _GDIPLUSREGION_H
|
|
|
|
/**
|
|
* Construct a new region object
|
|
*/
|
|
|
|
inline
|
|
Region::Region()
|
|
{
|
|
GpRegion *region = NULL;
|
|
|
|
lastResult = DllExports::GdipCreateRegion(®ion);
|
|
|
|
SetNativeRegion(region);
|
|
}
|
|
|
|
inline
|
|
Region::Region(IN const RectF& rect)
|
|
{
|
|
GpRegion *region = NULL;
|
|
|
|
lastResult = DllExports::GdipCreateRegionRect(&rect, ®ion);
|
|
|
|
SetNativeRegion(region);
|
|
}
|
|
|
|
inline
|
|
Region::Region(IN const Rect& rect)
|
|
{
|
|
GpRegion *region = NULL;
|
|
|
|
lastResult = DllExports::GdipCreateRegionRectI(&rect, ®ion);
|
|
|
|
SetNativeRegion(region);
|
|
}
|
|
|
|
inline
|
|
Region::Region(IN const GraphicsPath* path)
|
|
{
|
|
GpRegion *region = NULL;
|
|
|
|
lastResult = DllExports::GdipCreateRegionPath(path->nativePath, ®ion);
|
|
|
|
SetNativeRegion(region);
|
|
}
|
|
|
|
inline
|
|
Region::Region(IN const BYTE* regionData, IN INT size)
|
|
{
|
|
GpRegion *region = NULL;
|
|
|
|
lastResult = DllExports::GdipCreateRegionRgnData(regionData, size, ®ion);
|
|
|
|
SetNativeRegion(region);
|
|
}
|
|
|
|
inline
|
|
Region::Region(IN HRGN hRgn)
|
|
{
|
|
GpRegion *region = NULL;
|
|
|
|
lastResult = DllExports::GdipCreateRegionHrgn(hRgn, ®ion);
|
|
|
|
SetNativeRegion(region);
|
|
}
|
|
|
|
inline
|
|
Region* Region::FromHRGN(IN HRGN hRgn)
|
|
{
|
|
GpRegion *region = NULL;
|
|
|
|
if (DllExports::GdipCreateRegionHrgn(hRgn, ®ion) == Ok)
|
|
{
|
|
Region* newRegion = new Region(region);
|
|
|
|
if (newRegion == NULL)
|
|
{
|
|
DllExports::GdipDeleteRegion(region);
|
|
}
|
|
|
|
return newRegion;
|
|
}
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
inline
|
|
Region::~Region()
|
|
{
|
|
DllExports::GdipDeleteRegion(nativeRegion);
|
|
}
|
|
|
|
/**
|
|
* Make a copy of the region object
|
|
*/
|
|
inline Region*
|
|
Region::Clone() const
|
|
{
|
|
GpRegion *region = NULL;
|
|
|
|
SetStatus(DllExports::GdipCloneRegion(nativeRegion, ®ion));
|
|
|
|
return new Region(region);
|
|
}
|
|
|
|
inline Status
|
|
Region::MakeInfinite()
|
|
{
|
|
return SetStatus(DllExports::GdipSetInfinite(nativeRegion));
|
|
}
|
|
|
|
inline Status
|
|
Region::MakeEmpty()
|
|
{
|
|
return SetStatus(DllExports::GdipSetEmpty(nativeRegion));
|
|
}
|
|
|
|
/**
|
|
* Region operations
|
|
*/
|
|
inline Status
|
|
Region::Intersect(IN const RectF& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeIntersect));
|
|
}
|
|
|
|
inline Status
|
|
Region::Intersect(IN const Rect& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeIntersect));
|
|
}
|
|
|
|
inline Status
|
|
Region::Intersect(IN const GraphicsPath* path)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion, path->nativePath, CombineModeIntersect));
|
|
}
|
|
|
|
inline Status
|
|
Region::Intersect(IN const Region* region)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRegion(nativeRegion, region->nativeRegion, CombineModeIntersect));
|
|
}
|
|
|
|
inline Status
|
|
Region::Union(IN const RectF& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeUnion));
|
|
}
|
|
|
|
inline Status
|
|
Region::Union(IN const Rect& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeUnion));
|
|
}
|
|
|
|
inline Status
|
|
Region::Union(IN const GraphicsPath* path)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion, path->nativePath, CombineModeUnion));
|
|
}
|
|
|
|
inline Status
|
|
Region::Union(IN const Region* region)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRegion(nativeRegion, region->nativeRegion, CombineModeUnion));
|
|
}
|
|
|
|
inline Status
|
|
Region::Xor(IN const RectF& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeXor));
|
|
}
|
|
|
|
inline Status
|
|
Region::Xor(IN const Rect& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeXor));
|
|
}
|
|
|
|
inline Status
|
|
Region::Xor(IN const GraphicsPath* path)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion, path->nativePath, CombineModeXor));
|
|
}
|
|
|
|
inline Status
|
|
Region::Xor(IN const Region* region)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRegion(nativeRegion, region->nativeRegion, CombineModeXor));
|
|
}
|
|
|
|
inline Status
|
|
Region::Exclude(IN const RectF& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeExclude));
|
|
}
|
|
|
|
inline Status
|
|
Region::Exclude(IN const Rect& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeExclude));
|
|
}
|
|
|
|
inline Status
|
|
Region::Exclude(IN const GraphicsPath* path)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion, path->nativePath, CombineModeExclude));
|
|
}
|
|
|
|
inline Status
|
|
Region::Exclude(IN const Region* region)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRegion(nativeRegion,
|
|
region->nativeRegion, CombineModeExclude));
|
|
}
|
|
|
|
inline Status
|
|
Region::Complement(IN const RectF& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeComplement));
|
|
}
|
|
|
|
inline Status
|
|
Region::Complement(IN const Rect& rect)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeComplement));
|
|
}
|
|
|
|
inline Status
|
|
Region::Complement(IN const GraphicsPath* path)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion,
|
|
path->nativePath, CombineModeComplement));
|
|
}
|
|
|
|
inline Status
|
|
Region::Complement(IN const Region* region)
|
|
{
|
|
return SetStatus(DllExports::GdipCombineRegionRegion(nativeRegion,
|
|
region->nativeRegion, CombineModeComplement));
|
|
}
|
|
|
|
/**
|
|
* Transform operations
|
|
*/
|
|
inline Status
|
|
Region::Translate(IN REAL dx,
|
|
IN REAL dy)
|
|
{
|
|
return SetStatus(DllExports::GdipTranslateRegion(nativeRegion, dx, dy));
|
|
}
|
|
|
|
inline Status
|
|
Region::Translate(IN INT dx,
|
|
IN INT dy)
|
|
{
|
|
return SetStatus(DllExports::GdipTranslateRegionI(nativeRegion, dx, dy));
|
|
}
|
|
|
|
inline Status
|
|
Region::Transform(IN const Matrix* matrix)
|
|
{
|
|
return SetStatus(DllExports::GdipTransformRegion(nativeRegion, matrix->nativeMatrix));
|
|
}
|
|
|
|
/**
|
|
* Get region attributes
|
|
*/
|
|
inline Status
|
|
Region::GetBounds(OUT RectF* rect,
|
|
IN const Graphics* g) const
|
|
{
|
|
return SetStatus(DllExports::GdipGetRegionBounds(nativeRegion,
|
|
g->nativeGraphics,
|
|
rect));
|
|
}
|
|
|
|
inline Status
|
|
Region::GetBounds(OUT Rect* rect,
|
|
IN const Graphics* g) const
|
|
{
|
|
return SetStatus(DllExports::GdipGetRegionBoundsI(nativeRegion,
|
|
g->nativeGraphics,
|
|
rect));
|
|
}
|
|
|
|
inline HRGN
|
|
Region::GetHRGN(IN const Graphics* g) const
|
|
{
|
|
HRGN hrgn;
|
|
|
|
SetStatus(DllExports::GdipGetRegionHRgn(nativeRegion,
|
|
g->nativeGraphics,
|
|
&hrgn));
|
|
|
|
return hrgn;
|
|
}
|
|
|
|
inline BOOL
|
|
Region::IsEmpty(IN const Graphics *g) const
|
|
{
|
|
BOOL booln = FALSE;
|
|
|
|
SetStatus(DllExports::GdipIsEmptyRegion(nativeRegion,
|
|
g->nativeGraphics,
|
|
&booln));
|
|
|
|
return booln;
|
|
}
|
|
|
|
inline BOOL
|
|
Region::IsInfinite(IN const Graphics *g) const
|
|
{
|
|
BOOL booln = FALSE;
|
|
|
|
SetStatus(DllExports::GdipIsInfiniteRegion(nativeRegion,
|
|
g->nativeGraphics,
|
|
&booln));
|
|
|
|
return booln;
|
|
}
|
|
|
|
inline BOOL
|
|
Region::Equals(IN const Region* region,
|
|
IN const Graphics* g) const
|
|
{
|
|
BOOL booln = FALSE;
|
|
|
|
SetStatus(DllExports::GdipIsEqualRegion(nativeRegion,
|
|
region->nativeRegion,
|
|
g->nativeGraphics,
|
|
&booln));
|
|
return booln;
|
|
}
|
|
|
|
// Get the size of the buffer needed for the GetData method
|
|
inline UINT
|
|
Region::GetDataSize() const
|
|
{
|
|
UINT bufferSize = 0;
|
|
|
|
SetStatus(DllExports::GdipGetRegionDataSize(nativeRegion, &bufferSize));
|
|
|
|
return bufferSize;
|
|
}
|
|
|
|
// buffer - where to put the data
|
|
// bufferSize - how big the buffer is (should be at least as big as GetDataSize())
|
|
// sizeFilled - if not NULL, this is an OUT param that says how many bytes
|
|
// of data were written to the buffer.
|
|
inline Status
|
|
Region::GetData(OUT BYTE* buffer,
|
|
IN UINT bufferSize,
|
|
OUT UINT* sizeFilled) const
|
|
{
|
|
return SetStatus(DllExports::GdipGetRegionData(nativeRegion, buffer, bufferSize, sizeFilled));
|
|
}
|
|
|
|
/**
|
|
* Hit testing operations
|
|
*/
|
|
inline BOOL
|
|
Region::IsVisible(IN const PointF& point,
|
|
IN const Graphics* g) const
|
|
{
|
|
BOOL booln = FALSE;
|
|
|
|
SetStatus(DllExports::GdipIsVisibleRegionPoint(nativeRegion,
|
|
point.X, point.Y,
|
|
(g == NULL) ? NULL : g->nativeGraphics,
|
|
&booln));
|
|
return booln;
|
|
}
|
|
|
|
inline BOOL
|
|
Region::IsVisible(IN const RectF& rect,
|
|
IN const Graphics* g) const
|
|
{
|
|
BOOL booln = FALSE;
|
|
|
|
SetStatus(DllExports::GdipIsVisibleRegionRect(nativeRegion, rect.X,
|
|
rect.Y, rect.Width,
|
|
rect.Height,
|
|
(g == NULL) ? NULL : g->nativeGraphics,
|
|
&booln));
|
|
return booln;
|
|
}
|
|
|
|
inline BOOL
|
|
Region::IsVisible(IN const Point& point,
|
|
IN const Graphics* g) const
|
|
{
|
|
BOOL booln = FALSE;
|
|
|
|
|
|
SetStatus(DllExports::GdipIsVisibleRegionPointI(nativeRegion,
|
|
point.X,
|
|
point.Y,
|
|
(g == NULL) ? NULL : g->nativeGraphics,
|
|
&booln));
|
|
return booln;
|
|
}
|
|
|
|
inline BOOL
|
|
Region::IsVisible(IN const Rect& rect,
|
|
IN const Graphics* g) const
|
|
{
|
|
BOOL booln = FALSE;
|
|
|
|
SetStatus(DllExports::GdipIsVisibleRegionRectI(nativeRegion,
|
|
rect.X,
|
|
rect.Y,
|
|
rect.Width,
|
|
rect.Height,
|
|
(g == NULL) ? NULL : g->nativeGraphics,
|
|
&booln));
|
|
return booln;
|
|
}
|
|
|
|
inline UINT
|
|
Region::GetRegionScansCount(IN const Matrix* matrix) const
|
|
{
|
|
UINT count = 0;
|
|
|
|
SetStatus(DllExports::GdipGetRegionScansCount(nativeRegion,
|
|
&count,
|
|
matrix->nativeMatrix));
|
|
return count;
|
|
}
|
|
|
|
inline Status
|
|
Region::GetRegionScans(
|
|
IN const Matrix* matrix,
|
|
OUT RectF* rects,
|
|
IN OUT INT* count) const
|
|
{
|
|
return SetStatus(DllExports::GdipGetRegionScans(nativeRegion,
|
|
rects,
|
|
count,
|
|
matrix->nativeMatrix));
|
|
}
|
|
|
|
// If rects is NULL, return the count of rects in the region.
|
|
// Otherwise, assume rects is big enough to hold all the region rects
|
|
// and fill them in and return the number of rects filled in.
|
|
// The rects are returned in the units specified by the matrix
|
|
// (which is typically a world-to-device transform).
|
|
// Note that the number of rects returned can vary, depending on the
|
|
// matrix that is used.
|
|
inline Status
|
|
Region::GetRegionScans(
|
|
IN const Matrix* matrix,
|
|
OUT Rect* rects, // NULL to just get the count
|
|
IN OUT INT* count) const
|
|
{
|
|
return SetStatus(DllExports::GdipGetRegionScansI(nativeRegion,
|
|
rects,
|
|
count,
|
|
matrix->nativeMatrix));
|
|
}
|
|
|
|
// protected method
|
|
inline Region::Region(GpRegion* nativeRegion)
|
|
{
|
|
SetNativeRegion(nativeRegion);
|
|
}
|
|
|
|
// protected method
|
|
inline VOID Region::SetNativeRegion(GpRegion* nativeRegion)
|
|
{
|
|
this->nativeRegion = nativeRegion;
|
|
}
|
|
|
|
inline Status Region::GetLastStatus() const
|
|
{
|
|
Status lastStatus = lastResult;
|
|
lastResult = Ok;
|
|
|
|
return lastStatus;
|
|
}
|
|
|
|
#endif // !_GDIPLUSREGION_H
|