summaryrefslogtreecommitdiff
path: root/core/src/fxge/Microsoft SDK/include/GdiPlusPath.h
diff options
context:
space:
mode:
Diffstat (limited to 'core/src/fxge/Microsoft SDK/include/GdiPlusPath.h')
-rw-r--r--core/src/fxge/Microsoft SDK/include/GdiPlusPath.h3372
1 files changed, 1686 insertions, 1686 deletions
diff --git a/core/src/fxge/Microsoft SDK/include/GdiPlusPath.h b/core/src/fxge/Microsoft SDK/include/GdiPlusPath.h
index cff0e1d9ce..99f8afdda8 100644
--- a/core/src/fxge/Microsoft SDK/include/GdiPlusPath.h
+++ b/core/src/fxge/Microsoft SDK/include/GdiPlusPath.h
@@ -1,1686 +1,1686 @@
-/**************************************************************************\
-*
-* 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
+/**************************************************************************\
+*
+* 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
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-01 16:21:01 +0000