/**************************************************************************\
*
* Copyright (c) 1998-2000, Microsoft Corp. All Rights Reserved.
*
* Module Name:
*
* GdiplusPath.h
*
* Abstract:
*
* Path related declarations
*
\**************************************************************************/
#ifndef _GDIPLUSPATH_H
#define _GDIPLUSPATH_H
class GraphicsPath : public GdiplusBase
{
public:
friend class Graphics;
friend class Region;
friend class PathGradientBrush;
friend class GraphicsPathIterator;
friend class CustomLineCap;
// Path constructors
GraphicsPath(IN FillMode fillMode = FillModeAlternate)
{
nativePath = NULL;
lastResult = DllExports::GdipCreatePath(fillMode, &nativePath);
}
GraphicsPath(IN const PointF* points,
IN const BYTE* types,
IN INT count,
IN FillMode fillMode = FillModeAlternate)
{
nativePath = NULL;
lastResult = DllExports::GdipCreatePath2(points,
types,
count,
fillMode,
&nativePath);
}
GraphicsPath(IN const Point* points,
IN const BYTE* types,
IN INT count,
IN FillMode fillMode = FillModeAlternate)
{
nativePath = NULL;
lastResult = DllExports::GdipCreatePath2I(points,
types,
count,
fillMode,
&nativePath);
}
~GraphicsPath()
{
DllExports::GdipDeletePath(nativePath);
}
/**
* Make a copy of the current path object
*/
GraphicsPath* Clone() const
{
GpPath *clonepath = NULL;
SetStatus(DllExports::GdipClonePath(nativePath, &clonepath));
return new GraphicsPath(clonepath);
}
/**
* Reset the path object to empty (and fill mode to FillModeAlternate)
*/
Status Reset()
{
return SetStatus(DllExports::GdipResetPath(nativePath));
}
/**
* Get path fill mode information
*/
FillMode GetFillMode() const
{
FillMode fillmode = FillModeAlternate;
SetStatus(DllExports::GdipGetPathFillMode(nativePath, &fillmode));
return fillmode;
}
/**
* Set path fill mode information
*/
Status SetFillMode(IN FillMode fillmode)
{
return SetStatus(DllExports::GdipSetPathFillMode(nativePath, fillmode));
}
/**
* Set/get path data
*/
Status GetPathData(OUT PathData* pathData) const
{
if (pathData == NULL)
{
return SetStatus(InvalidParameter);
}
INT count = GetPointCount();
if ((count <= 0) || (pathData->Count>0 && pathData->Count<count))
{
pathData->Count = 0;
if (pathData->Points)
{
delete pathData->Points;
pathData->Points = NULL;
}
if (pathData->Types)
{
delete pathData->Types;
pathData->Types = NULL;
}
if (count <= 0)
{
return lastResult;
}
}
if (pathData->Count == 0)
{
pathData->Points = new PointF[count];
if (pathData->Points == NULL)
{
return SetStatus(OutOfMemory);
}
pathData->Types = new byte[count];
if (pathData->Types == NULL)
{
delete pathData->Points;
pathData->Points = NULL;
return SetStatus(OutOfMemory);
}
pathData->Count = count;
}
return SetStatus(DllExports::GdipGetPathData(nativePath, pathData));
}
/**
* Start/end a subpath
*/
Status StartFigure()
{
return SetStatus(DllExports::GdipStartPathFigure(nativePath));
}
Status CloseFigure()
{
return SetStatus(DllExports::GdipClosePathFigure(nativePath));
}
Status CloseAllFigures()
{
return SetStatus(DllExports::GdipClosePathFigures(nativePath));
}
Status SetMarker()
{
return SetStatus(DllExports::GdipSetPathMarker(nativePath));
}
Status ClearMarkers()
{
return SetStatus(DllExports::GdipClearPathMarkers(nativePath));
}
Status Reverse()
{
return SetStatus(DllExports::GdipReversePath(nativePath));
}
Status GetLastPoint(OUT PointF* lastPoint) const
{
return SetStatus(DllExports::GdipGetPathLastPoint(nativePath, lastPoint));
}
/**
* Add lines to the path object
*/
// float version
Status AddLine(IN const PointF& pt1,
IN const PointF& pt2)
{
return AddLine(pt1.X, pt1.Y, pt2.X, pt2.Y);
}
Status AddLine(IN REAL x1,
IN REAL y1,
IN REAL x2,
IN REAL y2)
{
return SetStatus(DllExports::GdipAddPathLine(nativePath, x1, y1, x2, y2));
}
Status AddLines(IN const PointF* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathLine2(nativePath, points, count));
}
// integer version
Status AddLine(IN const Point& pt1,
IN const Point& pt2)
{
return AddLine(pt1.X,
pt1.Y,
pt2.X,
pt2.Y);
}
Status AddLine(IN INT x1,
IN INT y1,
IN INT x2,
IN INT y2)
{
return SetStatus(DllExports::GdipAddPathLineI(nativePath,
x1,
y1,
x2,
y2));
}
Status AddLines(IN const Point* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathLine2I(nativePath,
points,
count));
}
/**
* Add an arc to the path object
*/
// float version
Status AddArc(IN const RectF& rect,
IN REAL startAngle,
IN REAL sweepAngle)
{
return AddArc(rect.X, rect.Y, rect.Width, rect.Height,
startAngle, sweepAngle);
}
Status AddArc(IN REAL x,
IN REAL y,
IN REAL width,
IN REAL height,
IN REAL startAngle,
IN REAL sweepAngle)
{
return SetStatus(DllExports::GdipAddPathArc(nativePath, x, y, width, height,
startAngle, sweepAngle));
}
// integer version
Status AddArc(IN const Rect& rect,
IN REAL startAngle,
IN REAL sweepAngle)
{
return AddArc(rect.X, rect.Y, rect.Width, rect.Height,
startAngle, sweepAngle);
}
Status AddArc(IN INT x,
IN INT y,
IN INT width,
IN INT height,
IN REAL startAngle,
IN REAL sweepAngle)
{
return SetStatus(DllExports::GdipAddPathArcI(nativePath,
x,
y,
width,
height,
startAngle,
sweepAngle));
}
/**
* Add Bezier curves to the path object
*/
// float version
Status AddBezier(IN const PointF& pt1,
IN const PointF& pt2,
IN const PointF& pt3,
IN const PointF& pt4)
{
return AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X,
pt4.Y);
}
Status AddBezier(IN REAL x1,
IN REAL y1,
IN REAL x2,
IN REAL y2,
IN REAL x3,
IN REAL y3,
IN REAL x4,
IN REAL y4)
{
return SetStatus(DllExports::GdipAddPathBezier(nativePath, x1, y1, x2, y2,
x3, y3, x4, y4));
}
Status AddBeziers(IN const PointF* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathBeziers(nativePath, points, count));
}
// integer version
Status AddBezier(IN const Point& pt1,
IN const Point& pt2,
IN const Point& pt3,
IN const Point& pt4)
{
return AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X,
pt4.Y);
}
Status AddBezier(IN INT x1,
IN INT y1,
IN INT x2,
IN INT y2,
IN INT x3,
IN INT y3,
IN INT x4,
IN INT y4)
{
return SetStatus(DllExports::GdipAddPathBezierI(nativePath,
x1,
y1,
x2,
y2,
x3,
y3,
x4,
y4));
}
Status AddBeziers(IN const Point* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathBeziersI(nativePath,
points,
count));
}
// float version
Status AddCurve(IN const PointF* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathCurve(nativePath,
points,
count));
}
Status AddCurve(IN const PointF* points,
IN INT count,
IN REAL tension)
{
return SetStatus(DllExports::GdipAddPathCurve2(nativePath,
points,
count,
tension));
}
Status AddCurve(IN const PointF* points,
IN INT count,
IN INT offset,
IN INT numberOfSegments,
IN REAL tension)
{
return SetStatus(DllExports::GdipAddPathCurve3(nativePath,
points,
count,
offset,
numberOfSegments,
tension));
}
// integer version
Status AddCurve(IN const Point* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathCurveI(nativePath,
points,
count));
}
Status AddCurve(IN const Point* points,
IN INT count,
IN REAL tension)
{
return SetStatus(DllExports::GdipAddPathCurve2I(nativePath,
points,
count,
tension));
}
Status AddCurve(IN const Point* points,
IN INT count,
IN INT offset,
IN INT numberOfSegments,
IN REAL tension)
{
return SetStatus(DllExports::GdipAddPathCurve3I(nativePath,
points,
count,
offset,
numberOfSegments,
tension));
}
// float version
Status AddClosedCurve(IN const PointF* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathClosedCurve(nativePath,
points,
count));
}
Status AddClosedCurve(IN const PointF* points,
IN INT count,
IN REAL tension)
{
return SetStatus(DllExports::GdipAddPathClosedCurve2(nativePath,
points,
count,
tension));
}
// integer version
Status AddClosedCurve(IN const Point* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathClosedCurveI(nativePath,
points,
count));
}
Status AddClosedCurve(IN const Point* points,
IN INT count,
IN REAL tension)
{
return SetStatus(DllExports::GdipAddPathClosedCurve2I(nativePath,
points,
count,
tension));
}
/**
* Add closed shapes to the path object
*/
// float version
Status AddRectangle(IN const RectF& rect)
{
return SetStatus(DllExports::GdipAddPathRectangle(nativePath,
rect.X,
rect.Y,
rect.Width,
rect.Height));
}
Status AddRectangles(IN const RectF* rects,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathRectangles(nativePath,
rects,
count));
}
// integer version
Status AddRectangle(IN const Rect& rect)
{
return SetStatus(DllExports::GdipAddPathRectangleI(nativePath,
rect.X,
rect.Y,
rect.Width,
rect.Height));
}
Status AddRectangles(IN const Rect* rects, INT count)
{
return SetStatus(DllExports::GdipAddPathRectanglesI(nativePath,
rects,
count));
}
// float version
Status AddEllipse(IN const RectF& rect)
{
return AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
}
Status AddEllipse(IN REAL x,
IN REAL y,
IN REAL width,
IN REAL height)
{
return SetStatus(DllExports::GdipAddPathEllipse(nativePath,
x,
y,
width,
height));
}
// integer version
Status AddEllipse(IN const Rect& rect)
{
return AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
}
Status AddEllipse(IN INT x,
IN INT y,
IN INT width,
IN INT height)
{
return SetStatus(DllExports::GdipAddPathEllipseI(nativePath,
x,
y,
width,
height));
}
// float version
Status AddPie(IN const RectF& rect,
IN REAL startAngle,
IN REAL sweepAngle)
{
return AddPie(rect.X, rect.Y, rect.Width, rect.Height, startAngle,
sweepAngle);
}
Status AddPie(IN REAL x,
IN REAL y,
IN REAL width,
IN REAL height,
IN REAL startAngle,
IN REAL sweepAngle)
{
return SetStatus(DllExports::GdipAddPathPie(nativePath, x, y, width, height,
startAngle, sweepAngle));
}
// integer version
Status AddPie(IN const Rect& rect,
IN REAL startAngle,
IN REAL sweepAngle)
{
return AddPie(rect.X,
rect.Y,
rect.Width,
rect.Height,
startAngle,
sweepAngle);
}
Status AddPie(IN INT x,
IN INT y,
IN INT width,
IN INT height,
IN REAL startAngle,
IN REAL sweepAngle)
{
return SetStatus(DllExports::GdipAddPathPieI(nativePath,
x,
y,
width,
height,
startAngle,
sweepAngle));
}
// float version
Status AddPolygon(IN const PointF* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathPolygon(nativePath, points, count));
}
// integer version
Status AddPolygon(IN const Point* points,
IN INT count)
{
return SetStatus(DllExports::GdipAddPathPolygonI(nativePath, points, count));
}
Status AddPath(IN const GraphicsPath* addingPath,
IN BOOL connect)
{
GpPath* nativePath2 = NULL;
if(addingPath)
nativePath2 = addingPath->nativePath;
return SetStatus(DllExports::GdipAddPathPath(nativePath, nativePath2, connect));
}
// AddString point version
Status AddString(
IN const WCHAR *string,
IN INT length,
IN const FontFamily *family,
IN INT style,
IN REAL emSize, // In world units
IN const PointF &origin,
IN const StringFormat *format
)
{
RectF rect(origin.X, origin.Y, 0.0f, 0.0f);
return SetStatus(DllExports::GdipAddPathString(
nativePath,
string,
length,
family ? family->nativeFamily : NULL,
style,
emSize,
&rect,
format ? format->nativeFormat : NULL
));
}
// AddString rectangle version
Status AddString(
IN const WCHAR *string,
IN INT length,
IN const FontFamily *family,
IN INT style,
IN REAL emSize, // In world units
IN const RectF &layoutRect,
IN const StringFormat *format
)
{
return SetStatus(DllExports::GdipAddPathString(
nativePath,
string,
length,
family ? family->nativeFamily : NULL,
style,
emSize,
&layoutRect,
format ? format->nativeFormat : NULL
));
}
Status AddString(
IN const WCHAR *string,
IN INT length,
IN const FontFamily *family,
IN INT style,
IN REAL emSize, // In world units
IN const Point &origin,
IN const StringFormat *format
)
{
Rect rect(origin.X, origin.Y, 0, 0);
return SetStatus(DllExports::GdipAddPathStringI(
nativePath,
string,
length,
family ? family->nativeFamily : NULL,
style,
emSize,
&rect,
format ? format->nativeFormat : NULL
));
}
// AddString rectangle version
Status AddString(
IN const WCHAR *string,
IN INT length,
IN const FontFamily *family,
IN INT style,
IN REAL emSize, // In world units
IN const Rect &layoutRect,
IN const StringFormat *format
)
{
return SetStatus(DllExports::GdipAddPathStringI(
nativePath,
string,
length,
family ? family->nativeFamily : NULL,
style,
emSize,
&layoutRect,
format ? format->nativeFormat : NULL
));
}
/**
* Transforms the path object
*/
Status Transform(IN const Matrix* matrix)
{
if(matrix)
return SetStatus(DllExports::GdipTransformPath(nativePath, matrix->nativeMatrix));
else
return Ok; // No need to transform.
}
/**
* Get the bounds of the path object with the given transform.
* This is not always the tightest bounds.
*
* Defined in GdiplusGraphics.h.
*/
Status GetBounds(OUT RectF* bounds,
IN const Matrix* matrix = NULL,
IN const Pen* pen = NULL) const;
// integer version (defined in GdiplusGraphics.h)
Status GetBounds(OUT Rect* bounds,
IN const Matrix* matrix = NULL,
IN const Pen* pen = NULL) const;
/**
* Flatten the path object
* Once this is called, the resultant path is made of line segments and
* the original path information is lost.
* When matrix = NULL, the identity matrix is assumed.
*/
Status Flatten(IN const Matrix* matrix = NULL,
IN REAL flatness = FlatnessDefault)
{
GpMatrix* nativeMatrix = NULL;
if(matrix)
{
nativeMatrix = matrix->nativeMatrix;
}
return SetStatus(DllExports::GdipFlattenPath(
nativePath,
nativeMatrix,
flatness
));
}
#ifdef DCR_USE_NEW_202903
Status Widen(
IN const Pen* pen,
IN const Matrix* matrix = NULL,
IN REAL flatness = FlatnessDefault
)
{
GpMatrix* nativeMatrix = NULL;
if(matrix)
nativeMatrix = matrix->nativeMatrix;
return SetStatus(DllExports::GdipWidenPath(
nativePath,
pen->nativePen,
nativeMatrix,
flatness
));
}
#else
/**
* Widen the path object
* When removeSelfIntersects is TRUE, this returns the widened path
* without self intersections.
* When it is FALSE, it returns the widened path with selfintersections.
* The latter is faster and is usually safficient for filling.
*/
Status Widen(IN const Pen* pen,
IN const Matrix* matrix = NULL,
IN BOOL removeSelfIntersects = TRUE)
{
GpMatrix* nativeMatrix = NULL;
if(matrix)
nativeMatrix = matrix->nativeMatrix;
return SetStatus(DllExports::GdipWidenPathWithMinimumResolutions(nativePath, pen->nativePen,
0, 0, nativeMatrix, removeSelfIntersects));
}
/**
* Widen the path object
* This is equivalent to Widen() method except that
* The widths of the widened path are larger than the given
* minimum resolutions in x and y coordinates after the transform.
* This is usefull when widening a path with the limited device resolutions.
*/
Status Widen(IN const Pen* pen,
IN REAL minXres,
IN REAL minYres,
IN const Matrix* matrix = NULL,
IN BOOL removeSelfIntersects = TRUE)
{
GpMatrix* nativeMatrix = NULL;
if(matrix)
nativeMatrix = matrix->nativeMatrix;
return SetStatus(DllExports::GdipWidenPathWithMinimumResolutions(nativePath, pen->nativePen,
minXres, minYres, nativeMatrix, removeSelfIntersects));
}
#endif // DCR_USE_NEW_202903
Status Outline(
IN const Matrix *matrix = NULL,
IN REAL flatness = FlatnessDefault
)
{
GpMatrix* nativeMatrix = NULL;
if(matrix)
{
nativeMatrix = matrix->nativeMatrix;
}
return SetStatus(DllExports::GdipWindingModeOutline(
nativePath, nativeMatrix, flatness
));
}
/**
* Warp the path object
* Once this is called, the resultant path is made of line segments and
* the original path information is lost.
* When matrix = NULL, the identity matrix is assumed.
*/
Status Warp(IN const PointF* destPoints,
IN INT count,
IN const RectF& srcRect,
IN const Matrix* matrix = NULL,
IN WarpMode warpMode = WarpModePerspective,
IN REAL flatness = FlatnessDefault)
{
GpMatrix* nativeMatrix = NULL;
if(matrix)
nativeMatrix = matrix->nativeMatrix;
return SetStatus(DllExports::GdipWarpPath(
nativePath,
nativeMatrix,
destPoints,
count,
srcRect.X,
srcRect.Y,
srcRect.Width,
srcRect.Height,
warpMode,
flatness));
}
/**
* Return the number of points in the current path
*/
INT GetPointCount() const
{
INT count = 0;
SetStatus(DllExports::GdipGetPointCount(nativePath, &count));
return count;
}
/**
* Return the path point type information
*/
Status GetPathTypes(OUT BYTE* types,
IN INT count) const
{
return SetStatus(DllExports::GdipGetPathTypes(nativePath, types, count));
}
/**
* Return the path point coordinate information
* @notes Should there be PathData that contains types[] and points[]
* for get & set purposes.
*/
Status GetPathPoints(OUT PointF* points,
IN INT count) const
{
return SetStatus(DllExports::GdipGetPathPoints(nativePath, points, count));
}
// integer version
Status GetPathPoints(OUT Point* points,
IN INT count) const
{
return SetStatus(DllExports::GdipGetPathPointsI(nativePath, points, count));
}
Status GetLastStatus() const
{
Status lastStatus = lastResult;
lastResult = Ok;
return lastStatus;
}
/**
* Hit testing operations
*
* inline implementation is in gdiplusgraphics.h.
*/
BOOL IsVisible(IN const PointF& point,
IN const Graphics* g = NULL) const
{
return IsVisible(point.X, point.Y, g);
}
BOOL IsVisible(IN REAL x,
IN REAL y,
IN const Graphics* g = NULL) const;
BOOL IsVisible(IN const Point& point,
IN const Graphics* g = NULL) const
{
return IsVisible(point.X, point.Y, g);
}
BOOL IsVisible(IN INT x,
IN INT y,
IN const Graphics* g = NULL) const;
BOOL IsOutlineVisible(IN const PointF& point,
IN const Pen* pen,
IN const Graphics* g = NULL) const
{
return IsOutlineVisible(point.X, point.Y, pen, g);
}
BOOL IsOutlineVisible(IN REAL x,
IN REAL y,
IN const Pen* pen,
IN const Graphics* g = NULL) const;
BOOL IsOutlineVisible(IN const Point& point,
IN const Pen* pen,
IN const Graphics* g = NULL) const
{
return IsOutlineVisible(point.X, point.Y, pen, g);
}
BOOL IsOutlineVisible(IN INT x,
IN INT y,
IN const Pen* pen,
IN const Graphics* g = NULL) const;
protected:
GraphicsPath(const GraphicsPath& path)
{
GpPath *clonepath = NULL;
SetStatus(DllExports::GdipClonePath(path.nativePath, &clonepath));
SetNativePath(clonepath);
}
#ifdef DCR_USE_NEW_250932
private:
GraphicsPath& operator=(const GraphicsPath &);
protected:
#else
GraphicsPath& operator=(const GraphicsPath& path)
{
path;
SetStatus(NotImplemented);
return *this;
}
#endif
GraphicsPath(GpPath* nativePath)
{
lastResult = Ok;
SetNativePath(nativePath);
}
VOID SetNativePath(GpPath *nativePath)
{
this->nativePath = nativePath;
}
Status SetStatus(Status status) const
{
if (status != Ok)
return (lastResult = status);
else
return status;
}
protected:
GpPath* nativePath;
mutable Status lastResult;
};
//--------------------------------------------------------------------------
// GraphisPathIterator class
//--------------------------------------------------------------------------
class GraphicsPathIterator : public GdiplusBase
{
public:
GraphicsPathIterator(IN const GraphicsPath* path)
{
GpPath* nativePath = NULL;
if(path)
nativePath = path->nativePath;
GpPathIterator *iter = NULL;
lastResult = DllExports::GdipCreatePathIter(&iter, nativePath);
SetNativeIterator(iter);
}
~GraphicsPathIterator()
{
DllExports::GdipDeletePathIter(nativeIterator);
}
INT NextSubpath(OUT INT* startIndex,
OUT INT* endIndex,
OUT BOOL* isClosed)
{
INT resultCount;
SetStatus(DllExports::GdipPathIterNextSubpath(nativeIterator,
&resultCount, startIndex, endIndex, isClosed));
return resultCount;
}
INT NextSubpath(IN const GraphicsPath* path,
OUT BOOL* isClosed)
{
GpPath* nativePath = NULL;
INT resultCount;
if(path)
nativePath= path->nativePath;
SetStatus(DllExports::GdipPathIterNextSubpathPath(nativeIterator,
&resultCount, nativePath, isClosed));
return resultCount;
}
INT NextPathType(OUT BYTE* pathType,
OUT INT* startIndex,
OUT INT* endIndex)
{
INT resultCount;
SetStatus(DllExports::GdipPathIterNextPathType(nativeIterator,
&resultCount, pathType, startIndex, endIndex));
return resultCount;
}
INT NextMarker(OUT INT* startIndex,
OUT INT* endIndex)
{
INT resultCount;
SetStatus(DllExports::GdipPathIterNextMarker(nativeIterator,
&resultCount, startIndex, endIndex));
return resultCount;
}
INT NextMarker(IN const GraphicsPath* path)
{
GpPath* nativePath = NULL;
INT resultCount;
if(path)
nativePath= path->nativePath;
SetStatus(DllExports::GdipPathIterNextMarkerPath(nativeIterator,
&resultCount, nativePath));
return resultCount;
}
INT GetCount() const
{
INT resultCount;
SetStatus(DllExports::GdipPathIterGetCount(nativeIterator, &resultCount));
return resultCount;
}
INT GetSubpathCount() const
{
INT resultCount;
SetStatus(DllExports::GdipPathIterGetSubpathCount(nativeIterator, &resultCount));
return resultCount;
}
BOOL HasCurve() const
{
BOOL hasCurve;
SetStatus(DllExports::GdipPathIterHasCurve(nativeIterator, &hasCurve));
return hasCurve;
}
VOID Rewind()
{
SetStatus(DllExports::GdipPathIterRewind(nativeIterator));
}
INT Enumerate(OUT PointF *points,
OUT BYTE *types,
IN INT count)
{
INT resultCount;
SetStatus(DllExports::GdipPathIterEnumerate(nativeIterator,
&resultCount, points, types, count));
return resultCount;
}
INT CopyData(OUT PointF* points,
OUT BYTE* types,
IN INT startIndex,
IN INT endIndex)
{
INT resultCount;
SetStatus(DllExports::GdipPathIterCopyData(nativeIterator,
&resultCount, points, types, startIndex, endIndex));
return resultCount;
}
Status GetLastStatus() const
{
Status lastStatus = lastResult;
lastResult = Ok;
return lastStatus;
}
#ifdef DCR_USE_NEW_250932
private:
GraphicsPathIterator(const GraphicsPathIterator &);
GraphicsPathIterator& operator=(const GraphicsPathIterator &);
#endif
protected:
VOID SetNativeIterator(GpPathIterator *nativeIterator)
{
this->nativeIterator = nativeIterator;
}
Status SetStatus(Status status) const
{
if (status != Ok)
return (lastResult = status);
else
return status;
}
protected:
GpPathIterator* nativeIterator;
mutable Status lastResult;
};
//--------------------------------------------------------------------------
// Represent polygon gradient brush object
//--------------------------------------------------------------------------
class PathGradientBrush : public Brush
{
public:
friend class Pen;
PathGradientBrush(
IN const PointF* points,
IN INT count,
IN WrapMode wrapMode = WrapModeClamp)
{
GpPathGradient *brush = NULL;
lastResult = DllExports::GdipCreatePathGradient(
points, count,
wrapMode, &brush);
SetNativeBrush(brush);
}
PathGradientBrush(
IN const Point* points,
IN INT count,
IN WrapMode wrapMode = WrapModeClamp)
{
GpPathGradient *brush = NULL;
lastResult = DllExports::GdipCreatePathGradientI(
points, count,
wrapMode, &brush);
SetNativeBrush(brush);
}
PathGradientBrush(
IN const GraphicsPath* path
)
{
GpPathGradient *brush = NULL;
lastResult = DllExports::GdipCreatePathGradientFromPath(
path->nativePath, &brush);
SetNativeBrush(brush);
}
// Get/set colors
Status GetCenterColor(OUT Color* color) const
{
ARGB argb;
if (color == NULL)
{
return SetStatus(InvalidParameter);
}
SetStatus(DllExports::GdipGetPathGradientCenterColor(
(GpPathGradient*) nativeBrush, &argb));
color->SetValue(argb);
return lastResult;
}
Status SetCenterColor(IN const Color& color)
{
SetStatus(DllExports::GdipSetPathGradientCenterColor(
(GpPathGradient*) nativeBrush,
color.GetValue()));
return lastResult;
}
INT GetPointCount() const
{
INT count;
SetStatus(DllExports::GdipGetPathGradientPointCount(
(GpPathGradient*) nativeBrush, &count));
return count;
}
INT GetSurroundColorCount() const
{
INT count;
SetStatus(DllExports::GdipGetPathGradientSurroundColorCount(
(GpPathGradient*) nativeBrush, &count));
return count;
}
Status GetSurroundColors(OUT Color* colors,
IN OUT INT* count) const
{
if(colors == NULL || count == NULL)
{
return SetStatus(InvalidParameter);
}
INT count1;
SetStatus(DllExports::GdipGetPathGradientSurroundColorCount(
(GpPathGradient*) nativeBrush, &count1));
if(lastResult != Ok)
return lastResult;
if((*count < count1) || (count1 <= 0))
return SetStatus(InsufficientBuffer);
ARGB* argbs = (ARGB*) new ARGB[count1];
if(argbs == NULL)
return SetStatus(OutOfMemory);
SetStatus(DllExports::GdipGetPathGradientSurroundColorsWithCount(
(GpPathGradient*)nativeBrush, argbs, &count1));
if(lastResult == Ok)
{
for(INT i = 0; i < count1; i++)
{
colors[i].SetValue(argbs[i]);
}
*count = count1;
}
delete [] argbs;
return lastResult;
}
Status SetSurroundColors(IN const Color* colors,
IN OUT INT* count)
{
if(colors == NULL || count == NULL)
{
return SetStatus(InvalidParameter);
}
INT count1 = GetPointCount();
if((*count > count1) || (count1 <= 0))
return SetStatus(InvalidParameter);
count1 = *count;
ARGB* argbs = (ARGB*) new ARGB[count1];
if(argbs == NULL)
return SetStatus(OutOfMemory);
for(INT i = 0; i < count1; i++)
{
argbs[i] = colors[i].GetValue();
}
SetStatus(DllExports::GdipSetPathGradientSurroundColorsWithCount(
(GpPathGradient*)nativeBrush, argbs, &count1));
if(lastResult == Ok)
*count = count1;
delete [] argbs;
return lastResult;
}
Status GetGraphicsPath(OUT GraphicsPath* path) const
{
if(path == NULL)
return SetStatus(InvalidParameter);
return SetStatus(DllExports::GdipGetPathGradientPath(
(GpPathGradient*)nativeBrush, path->nativePath));
}
Status SetGraphicsPath(IN const GraphicsPath* path)
{
if(path == NULL)
return SetStatus(InvalidParameter);
return SetStatus(DllExports::GdipSetPathGradientPath(
(GpPathGradient*)nativeBrush, path->nativePath));
}
Status GetCenterPoint(OUT PointF* point) const
{
return SetStatus(DllExports::GdipGetPathGradientCenterPoint(
(GpPathGradient*)nativeBrush,
point));
}
Status GetCenterPoint(OUT Point* point) const
{
return SetStatus(DllExports::GdipGetPathGradientCenterPointI(
(GpPathGradient*)nativeBrush,
point));
}
Status SetCenterPoint(IN const PointF& point)
{
return SetStatus(DllExports::GdipSetPathGradientCenterPoint(
(GpPathGradient*)nativeBrush,
&point));
}
Status SetCenterPoint(IN const Point& point)
{
return SetStatus(DllExports::GdipSetPathGradientCenterPointI(
(GpPathGradient*)nativeBrush,
&point));
}
Status GetRectangle(OUT RectF* rect) const
{
return SetStatus(DllExports::GdipGetPathGradientRect(
(GpPathGradient*)nativeBrush, rect));
}
Status GetRectangle(OUT Rect* rect) const
{
return SetStatus(DllExports::GdipGetPathGradientRectI(
(GpPathGradient*)nativeBrush, rect));
}
// Gamma correction.
Status SetGammaCorrection(IN BOOL useGammaCorrection)
{
return SetStatus(DllExports::GdipSetPathGradientGammaCorrection(
(GpPathGradient*)nativeBrush, useGammaCorrection));
}
BOOL GetGammaCorrection() const
{
BOOL useGammaCorrection;
SetStatus(DllExports::GdipGetPathGradientGammaCorrection(
(GpPathGradient*)nativeBrush, &useGammaCorrection));
return useGammaCorrection;
}
INT GetBlendCount() const
{
INT count = 0;
SetStatus(DllExports::GdipGetPathGradientBlendCount(
(GpPathGradient*) nativeBrush, &count));
return count;
}
Status GetBlend(OUT REAL* blendFactors,
OUT REAL* blendPositions,
IN INT count) const
{
return SetStatus(DllExports::GdipGetPathGradientBlend(
(GpPathGradient*)nativeBrush,
blendFactors, blendPositions, count));
}
Status SetBlend(IN const REAL* blendFactors,
IN const REAL* blendPositions,
IN INT count)
{
return SetStatus(DllExports::GdipSetPathGradientBlend(
(GpPathGradient*)nativeBrush,
blendFactors, blendPositions, count));
}
INT GetInterpolationColorCount() const
{
INT count = 0;
SetStatus(DllExports::GdipGetPathGradientPresetBlendCount(
(GpPathGradient*) nativeBrush, &count));
return count;
}
Status SetInterpolationColors(IN const Color* presetColors,
IN const REAL* blendPositions,
IN INT count)
{
if ((count <= 0) || !presetColors)
{
return SetStatus(InvalidParameter);
}
ARGB* argbs = (ARGB*) new ARGB[count];
if(argbs)
{
for(INT i = 0; i < count; i++)
{
argbs[i] = presetColors[i].GetValue();
}
Status status = SetStatus(DllExports::GdipSetPathGradientPresetBlend(
(GpPathGradient*) nativeBrush,
argbs,
blendPositions,
count));
delete[] argbs;
return status;
}
else
{
return SetStatus(OutOfMemory);
}
}
Status GetInterpolationColors(OUT Color* presetColors,
OUT REAL* blendPositions,
IN INT count) const
{
if ((count <= 0) || !presetColors)
{
return SetStatus(InvalidParameter);
}
ARGB* argbs = (ARGB*) new ARGB[count];
if (!argbs)
{
return SetStatus(OutOfMemory);
}
GpStatus status = SetStatus(DllExports::GdipGetPathGradientPresetBlend(
(GpPathGradient*)nativeBrush,
argbs,
blendPositions,
count));
for(INT i = 0; i < count; i++)
{
presetColors[i] = Color(argbs[i]);
}
delete [] argbs;
return status;
}
Status SetBlendBellShape(IN REAL focus,
IN REAL scale = 1.0)
{
return SetStatus(DllExports::GdipSetPathGradientSigmaBlend(
(GpPathGradient*)nativeBrush, focus, scale));
}
#ifdef DCR_USE_NEW_145135
Status SetBlendTriangularShape(
IN REAL focus,
IN REAL scale = 1.0
)
#else
Status SetBlendTrianglarShape(IN REAL focus,
IN REAL scale = 1.0)
#endif
{
return SetStatus(DllExports::GdipSetPathGradientLinearBlend(
(GpPathGradient*)nativeBrush, focus, scale));
}
/**
* Get/set brush transform
*/
Status GetTransform(OUT Matrix *matrix) const
{
return SetStatus(DllExports::GdipGetPathGradientTransform(
(GpPathGradient*) nativeBrush, matrix->nativeMatrix));
}
Status SetTransform(IN const Matrix* matrix)
{
return SetStatus(DllExports::GdipSetPathGradientTransform(
(GpPathGradient*) nativeBrush, matrix->nativeMatrix));
}
Status ResetTransform()
{
return SetStatus(DllExports::GdipResetPathGradientTransform((GpPathGradient*)nativeBrush));
}
Status MultiplyTransform(IN const Matrix* matrix,
IN MatrixOrder order = MatrixOrderPrepend)
{
return SetStatus(DllExports::GdipMultiplyPathGradientTransform((GpPathGradient*)nativeBrush,
matrix->nativeMatrix,
order));
}
Status TranslateTransform(IN REAL dx,
IN REAL dy,
IN MatrixOrder order = MatrixOrderPrepend)
{
return SetStatus(DllExports::GdipTranslatePathGradientTransform((GpPathGradient*)nativeBrush,
dx, dy, order));
}
Status ScaleTransform(IN REAL sx,
IN REAL sy,
IN MatrixOrder order = MatrixOrderPrepend)
{
return SetStatus(DllExports::GdipScalePathGradientTransform((GpPathGradient*)nativeBrush,
sx, sy, order));
}
Status RotateTransform(IN REAL angle,
IN MatrixOrder order = MatrixOrderPrepend)
{
return SetStatus(DllExports::GdipRotatePathGradientTransform((GpPathGradient*)nativeBrush,
angle, order));
}
/**
* Get/set brush focus scales
*/
Status GetFocusScales(OUT REAL* xScale,
OUT REAL* yScale) const
{
return SetStatus(DllExports::GdipGetPathGradientFocusScales(
(GpPathGradient*) nativeBrush, xScale, yScale));
}
Status SetFocusScales(IN REAL xScale,
IN REAL yScale)
{
return SetStatus(DllExports::GdipSetPathGradientFocusScales(
(GpPathGradient*) nativeBrush, xScale, yScale));
}
/**
* Get/set brush wrapping mode
*/
WrapMode GetWrapMode() const
{
WrapMode wrapMode;
SetStatus(DllExports::GdipGetPathGradientWrapMode(
(GpPathGradient*) nativeBrush, &wrapMode));
return wrapMode;
}
Status SetWrapMode(IN WrapMode wrapMode)
{
return SetStatus(DllExports::GdipSetPathGradientWrapMode(
(GpPathGradient*) nativeBrush, wrapMode));
}
#ifdef DCR_USE_NEW_250932
private:
PathGradientBrush(const PathGradientBrush &);
PathGradientBrush& operator=(const PathGradientBrush &);
#endif
protected:
PathGradientBrush()
{
}
};
#endif // !_GRAPHICSPATH_HPP
Submit an article or tip