| /* |
| * gdipluspath.h |
| * |
| * GDI+ GraphicsPath class |
| * |
| * This file is part of the w32api package. |
| * |
| * Contributors: |
| * Created by Markus Koenig <markus@stber-koenig.de> |
| * |
| * THIS SOFTWARE IS NOT COPYRIGHTED |
| * |
| * This source code is offered for use in the public domain. You may |
| * use, modify or distribute it freely. |
| * |
| * This code is distributed in the hope that it will be useful but |
| * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY |
| * DISCLAIMED. This includes but is not limited to warranties of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| * |
| */ |
| |
| #ifndef __GDIPLUS_PATH_H |
| #define __GDIPLUS_PATH_H |
| #if __GNUC__ >=3 |
| #pragma GCC system_header |
| #endif |
| |
| #ifndef __cplusplus |
| #error "A C++ compiler is required to include gdipluspath.h." |
| #endif |
| |
| // Note that some methods of GraphicsPath are implemented in gdiplusimpl.h. |
| // This avoids a cyclic dependency on Graphics and Pen. |
| |
| class GraphicsPath: public GdiplusBase |
| { |
| friend class CustomLineCap; |
| friend class Graphics; |
| friend class GraphicsPathIterator; |
| friend class PathGradientBrush; |
| friend class Region; |
| |
| public: |
| GraphicsPath(FillMode fillMode = FillModeAlternate): |
| nativePath(NULL), lastStatus(Ok) |
| { |
| lastStatus = DllExports::GdipCreatePath(fillMode, &nativePath); |
| } |
| GraphicsPath(const PointF *points, const BYTE *types, INT count, |
| FillMode fillMode = FillModeAlternate): |
| nativePath(NULL), lastStatus(Ok) |
| { |
| lastStatus = DllExports::GdipCreatePath2( |
| points, types, count, fillMode, &nativePath); |
| } |
| GraphicsPath(const Point *points, const BYTE *types, INT count, |
| FillMode fillMode = FillModeAlternate): |
| nativePath(NULL), lastStatus(Ok) |
| { |
| lastStatus = DllExports::GdipCreatePath2I( |
| points, types, count, fillMode, &nativePath); |
| } |
| ~GraphicsPath() |
| { |
| DllExports::GdipDeletePath(nativePath); |
| } |
| GraphicsPath* Clone() const |
| { |
| GpPath *clonePath = NULL; |
| Status status = updateStatus(DllExports::GdipClonePath( |
| nativePath, &clonePath)); |
| if (status == Ok) { |
| GraphicsPath *result = new GraphicsPath(clonePath, lastStatus); |
| if (!result) { |
| DllExports::GdipDeletePath(clonePath); |
| lastStatus = OutOfMemory; |
| } |
| return result; |
| } else { |
| return NULL; |
| } |
| } |
| |
| Status AddArc(REAL x, REAL y, REAL width, REAL height, |
| REAL startAngle, REAL sweepAngle) |
| { |
| return updateStatus(DllExports::GdipAddPathArc(nativePath, |
| x, y, width, height, startAngle, sweepAngle)); |
| } |
| Status AddArc(INT x, INT y, INT width, INT height, |
| REAL startAngle, REAL sweepAngle) |
| { |
| return updateStatus(DllExports::GdipAddPathArcI(nativePath, |
| x, y, width, height, startAngle, sweepAngle)); |
| } |
| Status AddArc(const RectF& rect, REAL startAngle, REAL sweepAngle) |
| { |
| return updateStatus(DllExports::GdipAddPathArc(nativePath, |
| rect.X, rect.Y, rect.Width, rect.Height, |
| startAngle, sweepAngle)); |
| } |
| Status AddArc(const Rect& rect, REAL startAngle, REAL sweepAngle) |
| { |
| return updateStatus(DllExports::GdipAddPathArcI(nativePath, |
| rect.X, rect.Y, rect.Width, rect.Height, |
| startAngle, sweepAngle)); |
| } |
| Status AddBezier(REAL x1, REAL y1, REAL x2, REAL y2, |
| REAL x3, REAL y3, REAL x4, REAL y4) |
| { |
| return updateStatus(DllExports::GdipAddPathBezier(nativePath, |
| x1, y1, x2, y2, x3, y3, x4, y4)); |
| } |
| Status AddBezier(INT x1, INT y1, INT x2, INT y2, |
| INT x3, INT y3, INT x4, INT y4) |
| { |
| return updateStatus(DllExports::GdipAddPathBezierI(nativePath, |
| x1, y1, x2, y2, x3, y3, x4, y4)); |
| } |
| Status AddBezier(const PointF& pt1, const PointF& pt2, |
| const PointF& pt3, const PointF& pt4) |
| { |
| return updateStatus(DllExports::GdipAddPathBezier(nativePath, |
| pt1.X, pt1.Y, pt2.X, pt2.Y, |
| pt3.X, pt3.Y, pt4.X, pt4.Y)); |
| } |
| Status AddBezier(const Point& pt1, const Point& pt2, |
| const Point& pt3, const Point& pt4) |
| { |
| return updateStatus(DllExports::GdipAddPathBezierI(nativePath, |
| pt1.X, pt1.Y, pt2.X, pt2.Y, |
| pt3.X, pt3.Y, pt4.X, pt4.Y)); |
| } |
| Status AddBeziers(const PointF *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathBeziers( |
| nativePath, points, count)); |
| } |
| Status AddBeziers(const Point *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathBeziersI( |
| nativePath, points, count)); |
| } |
| Status AddClosedCurve(const PointF *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathClosedCurve( |
| nativePath, points, count)); |
| } |
| Status AddClosedCurve(const Point *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathClosedCurveI( |
| nativePath, points, count)); |
| } |
| Status AddClosedCurve(const PointF *points, INT count, REAL tension) |
| { |
| return updateStatus(DllExports::GdipAddPathClosedCurve2( |
| nativePath, points, count, tension)); |
| } |
| Status AddClosedCurve(const Point *points, INT count, REAL tension) |
| { |
| return updateStatus(DllExports::GdipAddPathClosedCurve2I( |
| nativePath, points, count, tension)); |
| } |
| Status AddCurve(const PointF *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathCurve( |
| nativePath, points, count)); |
| } |
| Status AddCurve(const Point *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathCurveI( |
| nativePath, points, count)); |
| } |
| Status AddCurve(const PointF *points, INT count, REAL tension) |
| { |
| return updateStatus(DllExports::GdipAddPathCurve2( |
| nativePath, points, count, tension)); |
| } |
| Status AddCurve(const Point *points, INT count, REAL tension) |
| { |
| return updateStatus(DllExports::GdipAddPathCurve2I( |
| nativePath, points, count, tension)); |
| } |
| Status AddCurve(const PointF *points, INT count, INT offset, |
| INT numberOfSegments, REAL tension) |
| { |
| return updateStatus(DllExports::GdipAddPathCurve3( |
| nativePath, points, count, |
| offset, numberOfSegments, tension)); |
| } |
| Status AddCurve(const Point *points, INT count, INT offset, |
| INT numberOfSegments, REAL tension) |
| { |
| return updateStatus(DllExports::GdipAddPathCurve3I( |
| nativePath, points, count, |
| offset, numberOfSegments, tension)); |
| } |
| Status AddEllipse(REAL x, REAL y, REAL width, REAL height) |
| { |
| return updateStatus(DllExports::GdipAddPathEllipse(nativePath, |
| x, y, width, height)); |
| } |
| Status AddEllipse(INT x, INT y, INT width, INT height) |
| { |
| return updateStatus(DllExports::GdipAddPathEllipseI(nativePath, |
| x, y, width, height)); |
| } |
| Status AddEllipse(const RectF& rect) |
| { |
| return updateStatus(DllExports::GdipAddPathEllipse(nativePath, |
| rect.X, rect.Y, rect.Width, rect.Height)); |
| } |
| Status AddEllipse(const Rect& rect) |
| { |
| return updateStatus(DllExports::GdipAddPathEllipseI(nativePath, |
| rect.X, rect.Y, rect.Width, rect.Height)); |
| } |
| Status AddLine(REAL x1, REAL y1, REAL x2, REAL y2) |
| { |
| return updateStatus(DllExports::GdipAddPathLine(nativePath, |
| x1, y1, x2, y2)); |
| } |
| Status AddLine(INT x1, INT y1, INT x2, INT y2) |
| { |
| return updateStatus(DllExports::GdipAddPathLineI(nativePath, |
| x1, y1, x2, y2)); |
| } |
| Status AddLine(const PointF& pt1, const PointF& pt2) |
| { |
| return updateStatus(DllExports::GdipAddPathLine(nativePath, |
| pt1.X, pt1.Y, pt2.X, pt2.Y)); |
| } |
| Status AddLine(const Point& pt1, const Point& pt2) |
| { |
| return updateStatus(DllExports::GdipAddPathLineI(nativePath, |
| pt1.X, pt1.Y, pt2.X, pt2.Y)); |
| } |
| Status AddLines(const PointF *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathLine2(nativePath, |
| points, count)); |
| } |
| Status AddLines(const Point *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathLine2I(nativePath, |
| points, count)); |
| } |
| Status AddPath(const GraphicsPath *addingPath, BOOL connect) |
| { |
| return updateStatus(DllExports::GdipAddPathPath(nativePath, |
| addingPath ? addingPath->nativePath : NULL, |
| connect)); |
| } |
| Status AddPie(REAL x, REAL y, REAL width, REAL height, |
| REAL startAngle, REAL sweepAngle) |
| { |
| return updateStatus(DllExports::GdipAddPathPie(nativePath, |
| x, y, width, height, startAngle, sweepAngle)); |
| } |
| Status AddPie(INT x, INT y, INT width, INT height, |
| REAL startAngle, REAL sweepAngle) |
| { |
| return updateStatus(DllExports::GdipAddPathPieI(nativePath, |
| x, y, width, height, startAngle, sweepAngle)); |
| } |
| Status AddPie(const RectF& rect, REAL startAngle, REAL sweepAngle) |
| { |
| return updateStatus(DllExports::GdipAddPathPie(nativePath, |
| rect.X, rect.Y, rect.Width, rect.Height, |
| startAngle, sweepAngle)); |
| } |
| Status AddPie(const Rect& rect, REAL startAngle, REAL sweepAngle) |
| { |
| return updateStatus(DllExports::GdipAddPathPieI(nativePath, |
| rect.X, rect.Y, rect.Width, rect.Height, |
| startAngle, sweepAngle)); |
| } |
| Status AddPolygon(const PointF *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathPolygon(nativePath, |
| points, count)); |
| } |
| Status AddPolygon(const Point *points, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathPolygonI(nativePath, |
| points, count)); |
| } |
| Status AddRectangle(const RectF& rect) |
| { |
| return updateStatus(DllExports::GdipAddPathRectangle(nativePath, |
| rect.X, rect.Y, rect.Width, rect.Height)); |
| } |
| Status AddRectangle(const Rect& rect) |
| { |
| return updateStatus(DllExports::GdipAddPathRectangleI( |
| nativePath, |
| rect.X, rect.Y, rect.Width, rect.Height)); |
| } |
| Status AddRectangles(const RectF *rects, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathRectangles( |
| nativePath, rects, count)); |
| } |
| Status AddRectangles(const Rect *rects, INT count) |
| { |
| return updateStatus(DllExports::GdipAddPathRectanglesI( |
| nativePath, rects, count)); |
| } |
| Status AddString(const WCHAR *string, INT length, |
| const FontFamily *family, INT style, REAL emSize, |
| const PointF& origin, const StringFormat *format) |
| { |
| RectF layoutRect(origin, SizeF(0.0f, 0.0f)); |
| return updateStatus(DllExports::GdipAddPathString(nativePath, |
| string, length, |
| family ? family->nativeFontFamily : NULL, |
| style, emSize, &layoutRect, |
| format ? format->nativeStringFormat : NULL)); |
| } |
| Status AddString(const WCHAR *string, INT length, |
| const FontFamily *family, INT style, REAL emSize, |
| const Point& origin, const StringFormat *format) |
| { |
| Rect layoutRect(origin, Size(0, 0)); |
| return updateStatus(DllExports::GdipAddPathStringI(nativePath, |
| string, length, |
| family ? family->nativeFontFamily : NULL, |
| style, emSize, &layoutRect, |
| format ? format->nativeStringFormat : NULL)); |
| } |
| Status AddString(const WCHAR *string, INT length, |
| const FontFamily *family, INT style, REAL emSize, |
| const RectF& layoutRect, const StringFormat *format) |
| { |
| return updateStatus(DllExports::GdipAddPathString(nativePath, |
| string, length, |
| family ? family->nativeFontFamily : NULL, |
| style, emSize, &layoutRect, |
| format ? format->nativeStringFormat : NULL)); |
| } |
| Status AddString(const WCHAR *string, INT length, |
| const FontFamily *family, INT style, REAL emSize, |
| const Rect& layoutRect, const StringFormat *format) |
| { |
| return updateStatus(DllExports::GdipAddPathStringI(nativePath, |
| string, length, |
| family ? family->nativeFontFamily : NULL, |
| style, emSize, &layoutRect, |
| format ? format->nativeStringFormat : NULL)); |
| } |
| Status ClearMarkers() |
| { |
| return updateStatus(DllExports::GdipClearPathMarkers( |
| nativePath)); |
| } |
| Status CloseAllFigures() |
| { |
| return updateStatus(DllExports::GdipClosePathFigures( |
| nativePath)); |
| } |
| Status CloseFigure() |
| { |
| return updateStatus(DllExports::GdipClosePathFigure( |
| nativePath)); |
| } |
| Status Flatten(const Matrix *matrix = NULL, |
| REAL flatness = FlatnessDefault) |
| { |
| return updateStatus(DllExports::GdipFlattenPath(nativePath, |
| matrix ? matrix->nativeMatrix : NULL, |
| flatness)); |
| } |
| Status GetBounds(RectF *bounds, const Matrix *matrix = NULL, |
| const Pen *pen = NULL) const |
| { |
| return updateStatus(DllExports::GdipGetPathWorldBounds( |
| nativePath, bounds, |
| matrix ? matrix->nativeMatrix : NULL, |
| pen ? pen->nativePen : NULL)); |
| } |
| Status GetBounds(Rect *bounds, const Matrix *matrix = NULL, |
| const Pen *pen = NULL) const |
| { |
| return updateStatus(DllExports::GdipGetPathWorldBoundsI( |
| nativePath, bounds, |
| matrix ? matrix->nativeMatrix : NULL, |
| pen ? pen->nativePen : NULL)); |
| } |
| FillMode GetFillMode() const |
| { |
| FillMode result = FillModeAlternate; |
| updateStatus(DllExports::GdipGetPathFillMode(nativePath, |
| &result)); |
| return result; |
| } |
| Status GetLastPoint(PointF *lastPoint) const |
| { |
| return updateStatus(DllExports::GdipGetPathLastPoint( |
| nativePath, lastPoint)); |
| } |
| Status GetLastStatus() const |
| { |
| Status result = lastStatus; |
| lastStatus = Ok; |
| return result; |
| } |
| Status GetPathData(PathData *pathData) const |
| { |
| if (!pathData) return lastStatus = InvalidParameter; |
| |
| Status status; |
| INT count; |
| |
| status = updateStatus(DllExports::GdipGetPointCount( |
| nativePath, &count)); |
| if (status != Ok) return status; |
| |
| status = updateStatus(pathData->AllocateArrays(count)); |
| if (status != Ok) return status; |
| |
| return updateStatus(DllExports::GdipGetPathData( |
| nativePath, (GpPathData*) pathData)); |
| } |
| Status GetPathPoints(PointF *points, INT count) const |
| { |
| return updateStatus(DllExports::GdipGetPathPoints(nativePath, |
| points, count)); |
| } |
| Status GetPathPoints(Point *points, INT count) const |
| { |
| return updateStatus(DllExports::GdipGetPathPointsI(nativePath, |
| points, count)); |
| } |
| Status GetPathTypes(BYTE *types, INT count) const |
| { |
| return updateStatus(DllExports::GdipGetPathTypes(nativePath, |
| types, count)); |
| } |
| INT GetPointCount() const |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipGetPointCount(nativePath, |
| &result)); |
| return result; |
| } |
| BOOL IsOutlineVisible(REAL x, REAL y, const Pen *pen, |
| const Graphics *g = NULL) const; |
| BOOL IsOutlineVisible(INT x, INT y, const Pen *pen, |
| const Graphics *g = NULL) const; |
| BOOL IsOutlineVisible(const PointF& point, const Pen *pen, |
| const Graphics *g = NULL) const; |
| BOOL IsOutlineVisible(const Point& point, const Pen *pen, |
| const Graphics *g = NULL) const; |
| BOOL IsVisible(REAL x, REAL y, const Graphics *g = NULL) const; |
| BOOL IsVisible(INT x, INT y, const Graphics *g = NULL) const; |
| BOOL IsVisible(const PointF& point, const Graphics *g = NULL) const; |
| BOOL IsVisible(const Point& point, const Graphics *g = NULL) const; |
| Status Outline(const Matrix *matrix = NULL, |
| REAL flatness = FlatnessDefault) |
| { |
| return updateStatus(DllExports::GdipWindingModeOutline( |
| nativePath, |
| matrix ? matrix->nativeMatrix : NULL, |
| flatness)); |
| } |
| Status Reset() |
| { |
| return updateStatus(DllExports::GdipResetPath(nativePath)); |
| } |
| Status Reverse() |
| { |
| return updateStatus(DllExports::GdipReversePath(nativePath)); |
| } |
| Status SetFillMode(FillMode fillMode) |
| { |
| return updateStatus(DllExports::GdipSetPathFillMode( |
| nativePath, fillMode)); |
| } |
| Status SetMarker() |
| { |
| return updateStatus(DllExports::GdipSetPathMarker(nativePath)); |
| } |
| Status StartFigure() |
| { |
| return updateStatus(DllExports::GdipStartPathFigure( |
| nativePath)); |
| } |
| Status Transform(const Matrix *matrix) |
| { |
| return updateStatus(DllExports::GdipTransformPath( |
| nativePath, |
| matrix ? matrix->nativeMatrix : NULL)); |
| } |
| Status Warp(const PointF *destPoints, INT count, const RectF& srcRect, |
| const Matrix *matrix = NULL, |
| WarpMode warpMode = WarpModePerspective, |
| REAL flatness = FlatnessDefault) |
| { |
| return updateStatus(DllExports::GdipWarpPath(nativePath, |
| matrix ? matrix->nativeMatrix : NULL, |
| destPoints, count, |
| srcRect.X, srcRect.Y, |
| srcRect.Width, srcRect.Height, |
| warpMode, flatness)); |
| } |
| Status Widen(const Pen *pen, const Matrix *matrix = NULL, |
| REAL flatness = FlatnessDefault) |
| { |
| return updateStatus(DllExports::GdipWidenPath(nativePath, |
| pen ? pen->nativePen : NULL, |
| matrix ? matrix->nativeMatrix : NULL, |
| flatness)); |
| } |
| |
| private: |
| GraphicsPath(GpPath *path, Status status): |
| nativePath(path), lastStatus(status) {} |
| GraphicsPath(const GraphicsPath&); |
| GraphicsPath& operator=(const GraphicsPath&); |
| |
| Status updateStatus(Status newStatus) const |
| { |
| if (newStatus != Ok) lastStatus = newStatus; |
| return newStatus; |
| } |
| |
| GpPath *nativePath; |
| mutable Status lastStatus; |
| }; |
| |
| class GraphicsPathIterator: public GdiplusBase |
| { |
| public: |
| GraphicsPathIterator(GraphicsPath *path): |
| nativePathIterator(NULL), lastStatus(Ok) |
| { |
| lastStatus = DllExports::GdipCreatePathIter( |
| &nativePathIterator, |
| path ? path->nativePath : NULL); |
| } |
| ~GraphicsPathIterator() |
| { |
| DllExports::GdipDeletePathIter(nativePathIterator); |
| } |
| |
| INT CopyData(PointF *points, BYTE *types, INT startIndex, INT endIndex) |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterCopyData( |
| nativePathIterator, &result, |
| points, types, startIndex, endIndex)); |
| return result; |
| } |
| INT Enumerate(PointF *points, BYTE *types, INT count) |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterEnumerate( |
| nativePathIterator, &result, |
| points, types, count)); |
| return result; |
| } |
| INT GetCount() const |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterGetCount( |
| nativePathIterator, &result)); |
| return result; |
| } |
| Status GetLastStatus() const |
| { |
| Status result = lastStatus; |
| lastStatus = Ok; |
| return result; |
| } |
| INT GetSubpathCount() const |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterGetSubpathCount( |
| nativePathIterator, &result)); |
| return result; |
| } |
| BOOL HasCurve() const |
| { |
| BOOL result = FALSE; |
| updateStatus(DllExports::GdipPathIterHasCurve( |
| nativePathIterator, &result)); |
| return result; |
| } |
| INT NextMarker(INT *startIndex, INT *endIndex) |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterNextMarker( |
| nativePathIterator, &result, |
| startIndex, endIndex)); |
| return result; |
| } |
| INT NextMarker(GraphicsPath *path) |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterNextMarkerPath( |
| nativePathIterator, &result, |
| path ? path->nativePath : NULL)); |
| return result; |
| } |
| INT NextPathType(BYTE *pathType, INT *startIndex, INT *endIndex) |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterNextPathType( |
| nativePathIterator, &result, |
| pathType, startIndex, endIndex)); |
| return result; |
| } |
| INT NextSubpath(INT *startIndex, INT *endIndex, BOOL *isClosed) |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterNextSubpath( |
| nativePathIterator, &result, |
| startIndex, endIndex, isClosed)); |
| return result; |
| } |
| INT NextSubpath(GraphicsPath *path, BOOL *isClosed) |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipPathIterNextSubpathPath( |
| nativePathIterator, &result, |
| path ? path->nativePath : NULL, isClosed)); |
| return result; |
| } |
| VOID Rewind() |
| { |
| updateStatus(DllExports::GdipPathIterRewind( |
| nativePathIterator)); |
| } |
| |
| private: |
| GraphicsPathIterator(GpPathIterator *pathIterator, Status status): |
| nativePathIterator(pathIterator), lastStatus(status) {} |
| GraphicsPathIterator(const GraphicsPathIterator&); |
| GraphicsPathIterator& operator=(const GraphicsPathIterator&); |
| |
| Status updateStatus(Status newStatus) const |
| { |
| if (newStatus != Ok) lastStatus = newStatus; |
| return newStatus; |
| } |
| |
| GpPathIterator *nativePathIterator; |
| mutable Status lastStatus; |
| }; |
| |
| class PathGradientBrush: public Brush |
| { |
| public: |
| PathGradientBrush(const PointF *points, INT count, |
| WrapMode wrapMode = WrapModeClamp) |
| { |
| GpPathGradient *nativePathGradient = NULL; |
| lastStatus = DllExports::GdipCreatePathGradient( |
| points, count, wrapMode, &nativePathGradient); |
| nativeBrush = nativePathGradient; |
| } |
| PathGradientBrush(const Point *points, INT count, |
| WrapMode wrapMode = WrapModeClamp) |
| { |
| GpPathGradient *nativePathGradient = NULL; |
| lastStatus = DllExports::GdipCreatePathGradientI( |
| points, count, wrapMode, &nativePathGradient); |
| nativeBrush = nativePathGradient; |
| } |
| PathGradientBrush(const GraphicsPath *path) |
| { |
| GpPathGradient *nativePathGradient = NULL; |
| lastStatus = DllExports::GdipCreatePathGradientFromPath( |
| path ? path->nativePath : NULL, |
| &nativePathGradient); |
| nativeBrush = nativePathGradient; |
| } |
| virtual PathGradientBrush *Clone() const |
| { |
| GpBrush *cloneBrush = NULL; |
| Status status = updateStatus(DllExports::GdipCloneBrush( |
| nativeBrush, &cloneBrush)); |
| if (status == Ok) { |
| PathGradientBrush *result = |
| new PathGradientBrush(cloneBrush, lastStatus); |
| if (!result) { |
| DllExports::GdipDeleteBrush(cloneBrush); |
| updateStatus(OutOfMemory); |
| } |
| return result; |
| } else { |
| return NULL; |
| } |
| } |
| |
| Status GetBlend(REAL *blendFactors, REAL *blendPositions, |
| INT count) const |
| { |
| return updateStatus(DllExports::GdipGetPathGradientBlend( |
| (GpPathGradient*) nativeBrush, |
| blendFactors, blendPositions, count)); |
| } |
| INT GetBlendCount() const |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipGetPathGradientBlendCount( |
| (GpPathGradient*) nativeBrush, &result)); |
| return result; |
| } |
| Status GetCenterColor(Color *color) const |
| { |
| return updateStatus(DllExports::GdipGetPathGradientCenterColor( |
| (GpPathGradient*) nativeBrush, |
| color ? &color->Value : NULL)); |
| } |
| Status GetCenterPoint(PointF *point) const |
| { |
| return updateStatus(DllExports::GdipGetPathGradientCenterPoint( |
| (GpPathGradient*) nativeBrush, point)); |
| } |
| Status GetCenterPoint(Point *point) const |
| { |
| return updateStatus(DllExports::GdipGetPathGradientCenterPointI( |
| (GpPathGradient*) nativeBrush, point)); |
| } |
| Status GetFocusScales(REAL *xScale, REAL *yScale) const |
| { |
| return updateStatus(DllExports::GdipGetPathGradientFocusScales( |
| (GpPathGradient*) nativeBrush, xScale, yScale)); |
| } |
| BOOL GetGammaCorrection() const |
| { |
| BOOL result = FALSE; |
| updateStatus(DllExports::GdipGetPathGradientGammaCorrection( |
| (GpPathGradient*) nativeBrush, &result)); |
| return result; |
| } |
| //Status GetGraphicsPath(GraphicsPath *path) const |
| //{ |
| // // TODO: implement PathGradientBrush::GetGraphicsPath |
| // return updateStatus(NotImplemented); |
| //} |
| INT GetInterpolationColorCount() const |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipGetPathGradientPresetBlendCount( |
| (GpPathGradient*) nativeBrush, &result)); |
| return result; |
| } |
| Status GetInterpolationColors(Color *presetColors, |
| REAL *blendPositions, INT count) const |
| { |
| if (!presetColors || count <= 0) |
| return lastStatus = InvalidParameter; |
| |
| ARGB *presetArgb = |
| (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB)); |
| if (!presetArgb) |
| return lastStatus = OutOfMemory; |
| |
| Status status = updateStatus(DllExports::GdipGetPathGradientPresetBlend( |
| (GpPathGradient*) nativeBrush, |
| presetArgb, blendPositions, count)); |
| for (INT i = 0; i < count; ++i) { |
| presetColors[i].SetValue(presetArgb[i]); |
| } |
| DllExports::GdipFree((void*) presetArgb); |
| return status; |
| } |
| INT GetPointCount() const |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipGetPathGradientPointCount( |
| (GpPathGradient*) nativeBrush, &result)); |
| return result; |
| } |
| Status GetRectangle(RectF *rect) const |
| { |
| return updateStatus(DllExports::GdipGetPathGradientRect( |
| (GpPathGradient*) nativeBrush, rect)); |
| } |
| Status GetRectangle(Rect *rect) const |
| { |
| return updateStatus(DllExports::GdipGetPathGradientRectI( |
| (GpPathGradient*) nativeBrush, rect)); |
| } |
| INT GetSurroundColorCount() const |
| { |
| INT result = 0; |
| updateStatus(DllExports::GdipGetPathGradientSurroundColorCount( |
| (GpPathGradient*) nativeBrush, &result)); |
| return result; |
| } |
| Status GetSurroundColors(Color *colors, INT *count) |
| { |
| if (!colors || !count || *count <= 0) |
| return lastStatus = InvalidParameter; |
| |
| ARGB *colorsArgb = |
| (ARGB*) DllExports::GdipAlloc(*count * sizeof(ARGB)); |
| if (!colorsArgb) |
| return lastStatus = OutOfMemory; |
| |
| Status status = updateStatus(DllExports::GdipGetPathGradientSurroundColorsWithCount( |
| (GpPathGradient*) nativeBrush, |
| colorsArgb, count)); |
| for (INT i = 0; i < *count; ++i) { |
| colors[i].SetValue(colorsArgb[i]); |
| } |
| DllExports::GdipFree((void*) colorsArgb); |
| return status; |
| } |
| Status GetTransform(Matrix *matrix) const |
| { |
| return updateStatus(DllExports::GdipGetPathGradientTransform( |
| (GpPathGradient*) nativeBrush, |
| matrix ? matrix->nativeMatrix : NULL)); |
| } |
| WrapMode GetWrapMode() const |
| { |
| WrapMode result = WrapModeTile; |
| updateStatus(DllExports::GdipGetPathGradientWrapMode( |
| (GpPathGradient*) nativeBrush, &result)); |
| return result; |
| } |
| Status MultiplyTransform(const Matrix *matrix, |
| MatrixOrder order = MatrixOrderPrepend) |
| { |
| return updateStatus(DllExports::GdipMultiplyPathGradientTransform( |
| (GpPathGradient*) nativeBrush, |
| matrix ? matrix->nativeMatrix : NULL, order)); |
| } |
| Status ResetTransform() |
| { |
| return updateStatus(DllExports::GdipResetPathGradientTransform( |
| (GpPathGradient*) nativeBrush)); |
| } |
| Status RotateTransform(REAL angle, |
| MatrixOrder order = MatrixOrderPrepend) |
| { |
| return updateStatus(DllExports::GdipRotatePathGradientTransform( |
| (GpPathGradient*) nativeBrush, angle, order)); |
| } |
| Status ScaleTransform(REAL sx, REAL sy, |
| MatrixOrder order = MatrixOrderPrepend) |
| { |
| return updateStatus(DllExports::GdipScalePathGradientTransform( |
| (GpPathGradient*) nativeBrush, sx, sy, order)); |
| } |
| Status SetBlend(REAL *blendFactors, REAL *blendPositions, INT count) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientBlend( |
| (GpPathGradient*) nativeBrush, |
| blendFactors, blendPositions, count)); |
| } |
| Status SetBlendBellShape(REAL focus, REAL scale = 1.0f) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientSigmaBlend( |
| (GpPathGradient*) nativeBrush, focus, scale)); |
| } |
| Status SetBlendTriangularShape(REAL focus, REAL scale = 1.0f) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientLinearBlend( |
| (GpPathGradient*) nativeBrush, focus, scale)); |
| } |
| Status SetCenterColor(const Color& color) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientCenterColor( |
| (GpPathGradient*) nativeBrush, |
| color.GetValue())); |
| } |
| Status SetCenterPoint(const PointF& point) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientCenterPoint( |
| (GpPathGradient*) nativeBrush, &point)); |
| } |
| Status SetCenterPoint(const Point& point) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientCenterPointI( |
| (GpPathGradient*) nativeBrush, &point)); |
| } |
| Status SetFocusScales(REAL xScale, REAL yScale) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientFocusScales( |
| (GpPathGradient*) nativeBrush, xScale, yScale)); |
| } |
| Status SetGammaCorrection(BOOL useGammaCorrection) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientGammaCorrection( |
| (GpPathGradient*) nativeBrush, |
| useGammaCorrection)); |
| } |
| //Status SetGraphicsPath(const GraphicsPath *path) |
| //{ |
| // // TODO: implement PathGradientBrush::SetGraphicsPath |
| // return updateStatus(NotImplemented); |
| //} |
| Status SetInterpolationColors(const Color *presetColors, |
| REAL *blendPositions, INT count) |
| { |
| if (!presetColors || count <= 0) |
| return lastStatus = InvalidParameter; |
| |
| ARGB *presetArgb = |
| (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB)); |
| if (!presetArgb) |
| return lastStatus = OutOfMemory; |
| for (INT i = 0; i < count; ++i) { |
| presetArgb[i] = presetColors[i].GetValue(); |
| } |
| |
| Status status = updateStatus(DllExports::GdipSetPathGradientPresetBlend( |
| (GpPathGradient*) nativeBrush, |
| presetArgb, blendPositions, count)); |
| DllExports::GdipFree((void*) presetArgb); |
| return status; |
| } |
| Status SetSurroundColors(const Color *colors, INT *count) |
| { |
| if (!colors || !count || *count <= 0) |
| return lastStatus = InvalidParameter; |
| |
| ARGB *colorsArgb = |
| (ARGB*) DllExports::GdipAlloc(*count * sizeof(ARGB)); |
| if (!colorsArgb) |
| return lastStatus = OutOfMemory; |
| for (INT i = 0; i < *count; ++i) { |
| colorsArgb[i] = colors[i].GetValue(); |
| } |
| |
| Status status = updateStatus(DllExports::GdipSetPathGradientSurroundColorsWithCount( |
| (GpPathGradient*) nativeBrush, |
| colorsArgb, count)); |
| DllExports::GdipFree((void*) colorsArgb); |
| return status; |
| } |
| Status SetTransform(const Matrix *matrix) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientTransform( |
| (GpPathGradient*) nativeBrush, |
| matrix ? matrix->nativeMatrix : NULL)); |
| } |
| Status SetWrapMode(WrapMode wrapMode) |
| { |
| return updateStatus(DllExports::GdipSetPathGradientWrapMode( |
| (GpPathGradient*) nativeBrush, wrapMode)); |
| } |
| Status TranslateTransform(REAL dx, REAL dy, |
| MatrixOrder order = MatrixOrderPrepend) |
| { |
| return updateStatus(DllExports::GdipTranslatePathGradientTransform( |
| (GpPathGradient*) nativeBrush, dx, dy, order)); |
| } |
| |
| private: |
| PathGradientBrush(GpBrush *brush, Status status): Brush(brush, status) {} |
| PathGradientBrush(const PathGradientBrush&); |
| PathGradientBrush& operator=(const PathGradientBrush&); |
| }; |
| |
| |
| |
| #endif /* __GDIPLUS_PATH_H */ |
