| /**************************************************************************\ | |
| * | |
| * 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 |