huwcampbell.com
Reactos
1/*
2 * GdiPlusPath.h
3 *
4 * Windows GDI+
5 *
6 * This file is part of the w32api package.
7 *
8 * THIS SOFTWARE IS NOT COPYRIGHTED
9 *
10 * This source code is offered for use in the public domain. You may
11 * use, modify or distribute it freely.
12 *
13 * This code is distributed in the hope that it will be useful but
14 * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
15 * DISCLAIMED. This includes but is not limited to warranties of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17 */
18
19#ifndef _GDIPLUSPATH_H
20#define _GDIPLUSPATH_H
21
22class GraphicsPath : public GdiplusBase
23{
24 friend class Region;
25 friend class CustomLineCap;
26 friend class Graphics;
27
28 public:
29 GraphicsPath(const Point *points, const BYTE *types, INT count, FillMode fillMode) : nativePath(NULL)
30 {
31 lastStatus = DllExports::GdipCreatePath2I(points, types, count, fillMode, &nativePath);
32 }
33
34 GraphicsPath(FillMode fillMode = FillModeAlternate) : nativePath(NULL)
35 {
36 lastStatus = DllExports::GdipCreatePath(fillMode, &nativePath);
37 }
38
39 GraphicsPath(const PointF *points, const BYTE *types, INT count, FillMode fillMode = FillModeAlternate)
40 : nativePath(NULL)
41 {
42 lastStatus = DllExports::GdipCreatePath2(points, types, count, fillMode, &nativePath);
43 }
44
45 ~GraphicsPath()
46 {
47 DllExports::GdipDeletePath(nativePath);
48 }
49
50 Status
51 AddArc(const Rect &rect, REAL startAngle, REAL sweepAngle)
52 {
53 return AddArc(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
54 }
55
56 Status
57 AddArc(const RectF &rect, REAL startAngle, REAL sweepAngle)
58 {
59 return AddArc(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
60 }
61
62 Status
63 AddArc(INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
64 {
65 return SetStatus(DllExports::GdipAddPathArcI(nativePath, x, y, width, height, startAngle, sweepAngle));
66 }
67
68 Status
69 AddArc(REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
70 {
71 return SetStatus(DllExports::GdipAddPathArc(nativePath, x, y, width, height, startAngle, sweepAngle));
72 }
73
74 Status
75 AddBezier(const Point &pt1, const Point &pt2, const Point &pt3, const Point &pt4)
76 {
77 return AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
78 }
79
80 Status
81 AddBezier(REAL x1, REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
82 {
83 return SetStatus(DllExports::GdipAddPathBezier(nativePath, x1, y1, x2, y2, x3, y3, x4, y4));
84 }
85
86 Status
87 AddBezier(const PointF &pt1, const PointF &pt2, const PointF &pt3, const PointF &pt4)
88 {
89 return AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X, pt4.Y);
90 }
91
92 Status
93 AddBezier(INT x1, INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
94 {
95 return SetStatus(DllExports::GdipAddPathBezierI(nativePath, x1, y1, x2, y2, x3, y3, x4, y4));
96 }
97
98 Status
99 AddBeziers(const Point *points, INT count)
100 {
101 return SetStatus(DllExports::GdipAddPathBeziersI(nativePath, points, count));
102 }
103
104 Status
105 AddBeziers(const PointF *points, INT count)
106 {
107 return SetStatus(DllExports::GdipAddPathBeziers(nativePath, points, count));
108 }
109
110 Status
111 AddClosedCurve(const Point *points, INT count)
112 {
113 return SetStatus(DllExports::GdipAddPathClosedCurveI(nativePath, points, count));
114 }
115
116 Status
117 AddClosedCurve(const Point *points, INT count, REAL tension)
118 {
119 return SetStatus(DllExports::GdipAddPathClosedCurve2I(nativePath, points, count, tension));
120 }
121
122 Status
123 AddClosedCurve(const PointF *points, INT count, REAL tension)
124 {
125 return SetStatus(DllExports::GdipAddPathClosedCurve2(nativePath, points, count, tension));
126 }
127
128 Status
129 AddClosedCurve(const PointF *points, INT count)
130 {
131 return SetStatus(DllExports::GdipAddPathClosedCurve(nativePath, points, count));
132 }
133
134 Status
135 AddCurve(const Point *points, INT count)
136 {
137 return SetStatus(DllExports::GdipAddPathCurveI(nativePath, points, count));
138 }
139
140 Status
141 AddCurve(const PointF *points, INT count, REAL tension)
142 {
143 return SetStatus(DllExports::GdipAddPathCurve2(nativePath, points, count, tension));
144 }
145
146 Status
147 AddCurve(const PointF *points, INT count)
148 {
149 return SetStatus(DllExports::GdipAddPathCurve(nativePath, points, count));
150 }
151
152 Status
153 AddCurve(const Point *points, INT count, INT offset, INT numberOfSegments, REAL tension)
154 {
155 return SetStatus(DllExports::GdipAddPathCurve3I(nativePath, points, count, offset, numberOfSegments, tension));
156 }
157
158 Status
159 AddCurve(const Point *points, INT count, REAL tension)
160 {
161 return SetStatus(DllExports::GdipAddPathCurve2I(nativePath, points, count, tension));
162 }
163
164 Status
165 AddCurve(const PointF *points, INT count, INT offset, INT numberOfSegments, REAL tension)
166 {
167 return SetStatus(DllExports::GdipAddPathCurve3(nativePath, points, count, offset, numberOfSegments, tension));
168 }
169
170 Status
171 AddEllipse(const Rect &rect)
172 {
173 return AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
174 }
175
176 Status
177 AddEllipse(const RectF &rect)
178 {
179 return AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
180 }
181
182 Status
183 AddEllipse(INT x, INT y, INT width, INT height)
184 {
185 return SetStatus(DllExports::GdipAddPathEllipseI(nativePath, x, y, width, height));
186 }
187
188 Status
189 AddEllipse(REAL x, REAL y, REAL width, REAL height)
190 {
191 return SetStatus(DllExports::GdipAddPathEllipse(nativePath, x, y, width, height));
192 }
193
194 Status
195 AddLine(const Point &pt1, const Point &pt2)
196 {
197 return AddLine(pt1.X, pt1.Y, pt2.X, pt2.Y);
198 }
199
200 Status
201 AddLine(const PointF &pt1, const PointF &pt2)
202 {
203 return AddLine(pt1.X, pt1.Y, pt2.X, pt2.Y);
204 }
205
206 Status
207 AddLine(REAL x1, REAL y1, REAL x2, REAL y2)
208 {
209 return SetStatus(DllExports::GdipAddPathLine(nativePath, x1, y1, x2, y2));
210 }
211
212 Status
213 AddLine(INT x1, INT y1, INT x2, INT y2)
214 {
215 return SetStatus(DllExports::GdipAddPathLineI(nativePath, x1, y1, x2, y2));
216 }
217
218 Status
219 AddLines(const Point *points, INT count)
220 {
221 return SetStatus(DllExports::GdipAddPathLine2I(nativePath, points, count));
222 }
223
224 Status
225 AddLines(const PointF *points, INT count)
226 {
227 return SetStatus(DllExports::GdipAddPathLine2(nativePath, points, count));
228 }
229
230 Status
231 AddPath(const GraphicsPath *addingPath, BOOL connect)
232 {
233 GpPath *nativePath2 = addingPath ? getNat(addingPath) : NULL;
234 return SetStatus(DllExports::GdipAddPathPath(nativePath, nativePath2, connect));
235 }
236
237 Status
238 AddPie(const Rect &rect, REAL startAngle, REAL sweepAngle)
239 {
240 return AddPie(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
241 }
242
243 Status
244 AddPie(INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
245 {
246 return SetStatus(DllExports::GdipAddPathPieI(nativePath, x, y, width, height, startAngle, sweepAngle));
247 }
248
249 Status
250 AddPie(REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
251 {
252 return SetStatus(DllExports::GdipAddPathPie(nativePath, x, y, width, height, startAngle, sweepAngle));
253 }
254
255 Status
256 AddPie(const RectF &rect, REAL startAngle, REAL sweepAngle)
257 {
258 return AddPie(rect.X, rect.Y, rect.Width, rect.Height, startAngle, sweepAngle);
259 }
260
261 Status
262 AddPolygon(const Point *points, INT count)
263 {
264 return SetStatus(DllExports::GdipAddPathPolygonI(nativePath, points, count));
265 }
266
267 Status
268 AddPolygon(const PointF *points, INT count)
269 {
270 return SetStatus(DllExports::GdipAddPathPolygon(nativePath, points, count));
271 }
272
273 Status
274 AddRectangle(const Rect &rect)
275 {
276 return SetStatus(DllExports::GdipAddPathRectangleI(nativePath, rect.X, rect.Y, rect.Width, rect.Height));
277 }
278
279 Status
280 AddRectangle(const RectF &rect)
281 {
282 return SetStatus(DllExports::GdipAddPathRectangle(nativePath, rect.X, rect.Y, rect.Width, rect.Height));
283 }
284
285 Status
286 AddRectangles(const Rect *rects, INT count)
287 {
288 return SetStatus(DllExports::GdipAddPathRectanglesI(nativePath, rects, count));
289 }
290
291 Status
292 AddRectangles(const RectF *rects, INT count)
293 {
294 return SetStatus(DllExports::GdipAddPathRectangles(nativePath, rects, count));
295 }
296
297 Status
298 AddString(
299 const WCHAR *string,
300 INT length,
301 const FontFamily *family,
302 INT style,
303 REAL emSize,
304 const Rect &layoutRect,
305 const StringFormat *format)
306 {
307 return SetStatus(DllExports::GdipAddPathStringI(
308 nativePath, string, length, family ? getNat(family) : NULL, style, emSize, &layoutRect,
309 format ? getNat(format) : NULL));
310 }
311
312 Status
313 AddString(
314 const WCHAR *string,
315 INT length,
316 const FontFamily *family,
317 INT style,
318 REAL emSize,
319 const PointF &origin,
320 const StringFormat *format)
321 {
322 RectF rect(origin.X, origin.Y, 0.0f, 0.0f);
323 return SetStatus(DllExports::GdipAddPathString(
324 nativePath, string, length, family ? getNat(family) : NULL, style, emSize, &rect,
325 format ? getNat(format) : NULL));
326 }
327
328 Status
329 AddString(
330 const WCHAR *string,
331 INT length,
332 const FontFamily *family,
333 INT style,
334 REAL emSize,
335 const Point &origin,
336 const StringFormat *format)
337 {
338 Rect rect(origin.X, origin.Y, 0, 0);
339 return SetStatus(DllExports::GdipAddPathStringI(
340 nativePath, string, length, family ? getNat(family) : NULL, style, emSize, &rect,
341 format ? getNat(format) : NULL));
342 }
343
344 Status
345 AddString(
346 const WCHAR *string,
347 INT length,
348 const FontFamily *family,
349 INT style,
350 REAL emSize,
351 const RectF &layoutRect,
352 const StringFormat *format)
353 {
354 return SetStatus(DllExports::GdipAddPathString(
355 nativePath, string, length, family ? getNat(family) : NULL, style, emSize, &layoutRect,
356 format ? getNat(format) : NULL));
357 }
358
359 Status
360 ClearMarkers()
361 {
362 return SetStatus(DllExports::GdipClearPathMarkers(nativePath));
363 }
364
365 GraphicsPath *
366 Clone()
367 {
368 GpPath *clonepath = NULL;
369 SetStatus(DllExports::GdipClonePath(nativePath, &clonepath));
370 if (lastStatus != Ok)
371 return NULL;
372 return new GraphicsPath(clonepath);
373 }
374
375 Status
376 CloseAllFigures()
377 {
378 return SetStatus(DllExports::GdipClosePathFigures(nativePath));
379 }
380
381 Status
382 CloseFigure()
383 {
384 return SetStatus(DllExports::GdipClosePathFigure(nativePath));
385 }
386
387 Status
388 Flatten(const Matrix *matrix, REAL flatness)
389 {
390 GpMatrix *nativeMatrix = matrix ? getNat(matrix) : NULL;
391 return SetStatus(DllExports::GdipFlattenPath(nativePath, nativeMatrix, flatness));
392 }
393
394 Status
395 GetBounds(Rect *bounds, const Matrix *matrix, const Pen *pen)
396 {
397 return SetStatus(NotImplemented);
398 }
399
400 Status
401 GetBounds(RectF *bounds, const Matrix *matrix, const Pen *pen)
402 {
403 return SetStatus(NotImplemented);
404 }
405
406 FillMode
407 GetFillMode()
408 {
409 FillMode fillmode = FillModeAlternate;
410 SetStatus(DllExports::GdipGetPathFillMode(nativePath, &fillmode));
411 return fillmode;
412 }
413
414 Status
415 GetLastPoint(PointF *lastPoint) const
416 {
417 return SetStatus(DllExports::GdipGetPathLastPoint(nativePath, lastPoint));
418 }
419
420 Status
421 GetLastStatus() const
422 {
423 return lastStatus;
424 }
425
426 Status
427 GetPathData(PathData *pathData)
428 {
429 return NotImplemented;
430 }
431
432 Status
433 GetPathPoints(Point *points, INT count) const
434 {
435 return SetStatus(DllExports::GdipGetPathPointsI(nativePath, points, count));
436 }
437
438 Status
439 GetPathPoints(PointF *points, INT count) const
440 {
441 return SetStatus(DllExports::GdipGetPathPoints(nativePath, points, count));
442 }
443
444 Status
445 GetPathTypes(BYTE *types, INT count) const
446 {
447 return SetStatus(DllExports::GdipGetPathTypes(nativePath, types, count));
448 }
449
450 INT
451 GetPointCount() const
452 {
453 INT count = 0;
454 SetStatus(DllExports::GdipGetPointCount(nativePath, &count));
455 return count;
456 }
457
458 BOOL
459 IsOutlineVisible(const Point &point, const Pen *pen, const Graphics *g) const
460 {
461 return IsOutlineVisible(point.X, point.Y, pen, g);
462 }
463
464 BOOL
465 IsOutlineVisible(REAL x, REAL y, const Pen *pen, const Graphics *g) const
466 {
467 GpGraphics *nativeGraphics = g ? getNat(g) : NULL;
468 GpPen *nativePen = pen ? getNat(pen) : NULL;
469 BOOL flag = FALSE;
470 SetStatus(DllExports::GdipIsOutlineVisiblePathPoint(nativePath, x, y, nativePen, nativeGraphics, &flag));
471 return flag;
472 }
473
474 BOOL
475 IsOutlineVisible(INT x, INT y, const Pen *pen, const Graphics *g) const
476 {
477 GpGraphics *nativeGraphics = g ? getNat(g) : NULL;
478 GpPen *nativePen = pen ? getNat(pen) : NULL;
479 BOOL flag = FALSE;
480 SetStatus(DllExports::GdipIsOutlineVisiblePathPointI(nativePath, x, y, nativePen, nativeGraphics, &flag));
481 return flag;
482 }
483
484 BOOL
485 IsOutlineVisible(const PointF &point, const Pen *pen, const Graphics *g) const
486 {
487 return IsOutlineVisible(point.X, point.Y, pen, g);
488 }
489
490 BOOL
491 IsVisible(REAL x, REAL y, const Graphics *g) const
492 {
493 GpGraphics *nativeGraphics = g ? getNat(g) : NULL;
494 BOOL flag = FALSE;
495 SetStatus(DllExports::GdipIsVisiblePathPoint(nativePath, x, y, nativeGraphics, &flag));
496 return flag;
497 }
498
499 BOOL
500 IsVisible(const PointF &point, const Graphics *g) const
501 {
502 return IsVisible(point.X, point.Y, g);
503 }
504
505 BOOL
506 IsVisible(INT x, INT y, const Graphics *g) const
507 {
508 GpGraphics *nativeGraphics = g ? getNat(g) : NULL;
509 BOOL flag = FALSE;
510 SetStatus(DllExports::GdipIsVisiblePathPointI(nativePath, x, y, nativeGraphics, &flag));
511 return flag;
512 }
513
514 BOOL
515 IsVisible(const Point &point, const Graphics *g) const
516 {
517 return IsVisible(point.X, point.Y, g);
518 }
519
520 Status
521 Outline(const Matrix *matrix, REAL flatness)
522 {
523 GpMatrix *nativeMatrix = matrix ? getNat(matrix) : NULL;
524 return SetStatus(DllExports::GdipWindingModeOutline(nativePath, nativeMatrix, flatness));
525 }
526
527 Status
528 Reset()
529 {
530 return SetStatus(DllExports::GdipResetPath(nativePath));
531 }
532
533 Status
534 Reverse()
535 {
536 return SetStatus(DllExports::GdipReversePath(nativePath));
537 }
538
539 Status
540 SetFillMode(FillMode fillmode)
541 {
542 return SetStatus(DllExports::GdipSetPathFillMode(nativePath, fillmode));
543 }
544
545 Status
546 SetMarker()
547 {
548 return SetStatus(DllExports::GdipSetPathMarker(nativePath));
549 }
550
551 Status
552 StartFigure()
553 {
554 return SetStatus(DllExports::GdipStartPathFigure(nativePath));
555 }
556
557 Status
558 Transform(const Matrix *matrix)
559 {
560 if (!matrix)
561 return Ok;
562 return SetStatus(DllExports::GdipTransformPath(nativePath, matrix->nativeMatrix));
563 }
564
565 Status
566 Warp(
567 const PointF *destPoints,
568 INT count,
569 const RectF &srcRect,
570 const Matrix *matrix,
571 WarpMode warpMode,
572 REAL flatness)
573 {
574 GpMatrix *nativeMatrix = matrix ? getNat(matrix) : NULL;
575 return SetStatus(DllExports::GdipWarpPath(
576 nativePath, nativeMatrix, destPoints, count, srcRect.X, srcRect.Y, srcRect.Width, srcRect.Height, warpMode,
577 flatness));
578 }
579
580 Status
581 Widen(const Pen *pen, const Matrix *matrix, REAL flatness)
582 {
583 return SetStatus(NotImplemented);
584 }
585
586 protected:
587 GpPath *nativePath;
588 mutable Status lastStatus;
589
590 GraphicsPath()
591 {
592 }
593
594 GraphicsPath(GpPath *path) : nativePath(path), lastStatus(Ok)
595 {
596 }
597
598 Status
599 SetStatus(Status status) const
600 {
601 if (status != Ok)
602 lastStatus = status;
603 return status;
604 }
605
606 void
607 SetNativePath(GpPath *path)
608 {
609 nativePath = path;
610 }
611
612 private:
613 // GraphicsPath is not copyable
614 GraphicsPath(const GraphicsPath &);
615 GraphicsPath &
616 operator=(const GraphicsPath &);
617
618 // get native
619 friend inline GpPath *&
620 getNat(const GraphicsPath *path)
621 {
622 return const_cast<GraphicsPath *>(path)->nativePath;
623 }
624};
625
626class GraphicsPathIterator : public GdiplusBase
627{
628 public:
629 GraphicsPathIterator(GraphicsPath *path)
630 {
631 GpPathIterator *it = NULL;
632 GpPath *nativePath = path ? getNat(path) : NULL;
633 lastStatus = DllExports::GdipCreatePathIter(&it, nativePath);
634 nativeIterator = it;
635 }
636
637 ~GraphicsPathIterator()
638 {
639 DllExports::GdipDeletePathIter(nativeIterator);
640 }
641
642 INT
643 CopyData(PointF *points, BYTE *types, INT startIndex, INT endIndex)
644 {
645 INT resultCount;
646 SetStatus(DllExports::GdipPathIterCopyData(nativeIterator, &resultCount, points, types, startIndex, endIndex));
647 return resultCount;
648 }
649
650 INT
651 Enumerate(PointF *points, BYTE *types, INT count)
652 {
653 INT resultCount;
654 SetStatus(DllExports::GdipPathIterEnumerate(nativeIterator, &resultCount, points, types, count));
655 return resultCount;
656 }
657
658 INT
659 GetCount() const
660 {
661 INT resultCount;
662 SetStatus(DllExports::GdipPathIterGetCount(nativeIterator, &resultCount));
663 return resultCount;
664 }
665
666 Status
667 GetLastStatus() const
668 {
669 return lastStatus;
670 }
671
672 INT
673 GetSubpathCount() const
674 {
675 INT resultCount;
676 SetStatus(DllExports::GdipPathIterGetSubpathCount(nativeIterator, &resultCount));
677 return resultCount;
678 }
679
680 BOOL
681 HasCurve() const
682 {
683 BOOL hasCurve;
684 SetStatus(DllExports::GdipPathIterHasCurve(nativeIterator, &hasCurve));
685 return hasCurve;
686 }
687
688 INT
689 NextMarker(GraphicsPath *path)
690 {
691 INT resultCount;
692 GpPath *nativePath = path ? getNat(path) : NULL;
693 SetStatus(DllExports::GdipPathIterNextMarkerPath(nativeIterator, &resultCount, nativePath));
694 return resultCount;
695 }
696
697 INT
698 NextMarker(INT *startIndex, INT *endIndex)
699 {
700 INT resultCount;
701 SetStatus(DllExports::GdipPathIterNextMarker(nativeIterator, &resultCount, startIndex, endIndex));
702 return resultCount;
703 }
704
705 INT
706 NextPathType(BYTE *pathType, INT *startIndex, INT *endIndex)
707 {
708 INT resultCount;
709 SetStatus(DllExports::GdipPathIterNextPathType(nativeIterator, &resultCount, pathType, startIndex, endIndex));
710 return resultCount;
711 }
712
713 INT
714 NextSubpath(GraphicsPath *path, BOOL *isClosed)
715 {
716 GpPath *nativePath = path ? getNat(path) : NULL;
717 INT resultCount;
718 SetStatus(DllExports::GdipPathIterNextSubpathPath(nativeIterator, &resultCount, nativePath, isClosed));
719 return resultCount;
720 }
721
722 INT
723 NextSubpath(INT *startIndex, INT *endIndex, BOOL *isClosed)
724 {
725 INT resultCount;
726 SetStatus(DllExports::GdipPathIterNextSubpath(nativeIterator, &resultCount, startIndex, endIndex, isClosed));
727 return resultCount;
728 }
729
730 VOID
731 Rewind()
732 {
733 SetStatus(DllExports::GdipPathIterRewind(nativeIterator));
734 }
735
736 protected:
737 GpPathIterator *nativeIterator;
738 mutable Status lastStatus;
739
740 Status
741 SetStatus(Status status) const
742 {
743 if (status != Ok)
744 lastStatus = status;
745 return status;
746 }
747};
748
749class PathGradientBrush : public Brush
750{
751 public:
752 friend class Pen;
753
754 PathGradientBrush(const Point *points, INT count, WrapMode wrapMode = WrapModeClamp)
755 {
756 GpPathGradient *brush = NULL;
757 lastStatus = DllExports::GdipCreatePathGradientI(points, count, wrapMode, &brush);
758 SetNativeBrush(brush);
759 }
760
761 PathGradientBrush(const PointF *points, INT count, WrapMode wrapMode = WrapModeClamp)
762 {
763 GpPathGradient *brush = NULL;
764 lastStatus = DllExports::GdipCreatePathGradient(points, count, wrapMode, &brush);
765 SetNativeBrush(brush);
766 }
767
768 PathGradientBrush(const GraphicsPath *path)
769 {
770 GpPathGradient *brush = NULL;
771 lastStatus = DllExports::GdipCreatePathGradientFromPath(getNat(path), &brush);
772 SetNativeBrush(brush);
773 }
774
775 INT
776 GetBlendCount() const
777 {
778 INT count = 0;
779 SetStatus(DllExports::GdipGetPathGradientBlendCount(GetNativeGradient(), &count));
780 return count;
781 }
782
783 Status
784 GetBlend(REAL *blendFactors, REAL *blendPositions, INT count) const
785 {
786 return SetStatus(
787 DllExports::GdipGetPathGradientBlend(GetNativeGradient(), blendFactors, blendPositions, count));
788 }
789
790 Status
791 GetCenterColor(Color *color) const
792 {
793 if (color != NULL)
794 return SetStatus(InvalidParameter);
795
796 ARGB argb;
797 SetStatus(DllExports::GdipGetPathGradientCenterColor(GetNativeGradient(), &argb));
798 color->SetValue(argb);
799 return GetLastStatus();
800 }
801
802 Status
803 GetCenterPoint(Point *point) const
804 {
805 return SetStatus(DllExports::GdipGetPathGradientCenterPointI(GetNativeGradient(), point));
806 }
807
808 Status
809 GetCenterPoint(PointF *point) const
810 {
811 return SetStatus(DllExports::GdipGetPathGradientCenterPoint(GetNativeGradient(), point));
812 }
813
814 Status
815 GetFocusScales(REAL *xScale, REAL *yScale) const
816 {
817 return SetStatus(DllExports::GdipGetPathGradientFocusScales(GetNativeGradient(), xScale, yScale));
818 }
819
820 BOOL
821 GetGammaCorrection() const
822 {
823 BOOL useGammaCorrection;
824 SetStatus(DllExports::GdipGetPathGradientGammaCorrection(GetNativeGradient(), &useGammaCorrection));
825 return useGammaCorrection;
826 }
827
828 Status
829 GetGraphicsPath(GraphicsPath *path) const
830 {
831 if (!path)
832 return SetStatus(InvalidParameter);
833
834 return SetStatus(DllExports::GdipGetPathGradientPath(GetNativeGradient(), getNat(path)));
835 }
836
837 INT
838 GetInterpolationColorCount() const
839 {
840 INT count = 0;
841 SetStatus(DllExports::GdipGetPathGradientPresetBlendCount(GetNativeGradient(), &count));
842 return count;
843 }
844
845 Status
846 GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count) const
847 {
848 return NotImplemented;
849 }
850
851 INT
852 GetPointCount() const
853 {
854 INT count;
855 SetStatus(DllExports::GdipGetPathGradientPointCount(GetNativeGradient(), &count));
856 return count;
857 }
858
859 Status
860 GetRectangle(RectF *rect) const
861 {
862 return SetStatus(DllExports::GdipGetPathGradientRect(GetNativeGradient(), rect));
863 }
864
865 Status
866 GetRectangle(Rect *rect) const
867 {
868 return SetStatus(DllExports::GdipGetPathGradientRectI(GetNativeGradient(), rect));
869 }
870
871 INT
872 GetSurroundColorCount() const
873 {
874 INT count;
875 SetStatus(DllExports::GdipGetPathGradientSurroundColorCount(GetNativeGradient(), &count));
876 return count;
877 }
878
879 Status
880 GetSurroundColors(Color *colors, INT *count) const
881 {
882 return NotImplemented;
883 }
884
885 Status
886 GetTransform(Matrix *matrix) const
887 {
888 return SetStatus(DllExports::GdipGetPathGradientTransform(GetNativeGradient(), getNat(matrix)));
889 }
890
891 WrapMode
892 GetWrapMode() const
893 {
894 WrapMode wrapMode;
895 SetStatus(DllExports::GdipGetPathGradientWrapMode(GetNativeGradient(), &wrapMode));
896 return wrapMode;
897 }
898
899 Status
900 MultiplyTransform(Matrix *matrix, MatrixOrder order = MatrixOrderPrepend)
901 {
902 return SetStatus(DllExports::GdipMultiplyPathGradientTransform(GetNativeGradient(), getNat(matrix), order));
903 }
904
905 Status
906 ResetTransform()
907 {
908 return SetStatus(DllExports::GdipResetPathGradientTransform(GetNativeGradient()));
909 }
910
911 Status
912 RotateTransform(REAL angle, MatrixOrder order = MatrixOrderPrepend)
913 {
914 return SetStatus(DllExports::GdipRotatePathGradientTransform(GetNativeGradient(), angle, order));
915 }
916
917 Status
918 ScaleTransform(REAL sx, REAL sy, MatrixOrder order = MatrixOrderPrepend)
919 {
920 return SetStatus(DllExports::GdipScalePathGradientTransform(GetNativeGradient(), sx, sy, order));
921 }
922
923 Status
924 SetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
925 {
926 return SetStatus(
927 DllExports::GdipSetPathGradientBlend(GetNativeGradient(), blendFactors, blendPositions, count));
928 }
929
930 Status
931 SetBlendBellShape(REAL focus, REAL scale)
932 {
933 return SetStatus(DllExports::GdipSetPathGradientSigmaBlend(GetNativeGradient(), focus, scale));
934 }
935
936 Status
937 SetBlendTriangularShape(REAL focus, REAL scale = 1.0f)
938 {
939 return SetStatus(DllExports::GdipSetPathGradientLinearBlend(GetNativeGradient(), focus, scale));
940 }
941
942 Status
943 SetCenterColor(const Color &color)
944 {
945 return SetStatus(DllExports::GdipSetPathGradientCenterColor(GetNativeGradient(), color.GetValue()));
946 }
947
948 Status
949 SetCenterPoint(const Point &point)
950 {
951 return SetStatus(DllExports::GdipSetPathGradientCenterPointI(GetNativeGradient(), const_cast<Point *>(&point)));
952 }
953
954 Status
955 SetCenterPoint(const PointF &point)
956 {
957 return SetStatus(DllExports::GdipSetPathGradientCenterPoint(GetNativeGradient(), const_cast<PointF *>(&point)));
958 }
959
960 Status
961 SetFocusScales(REAL xScale, REAL yScale)
962 {
963 return SetStatus(DllExports::GdipSetPathGradientFocusScales(GetNativeGradient(), xScale, yScale));
964 }
965
966 Status
967 SetGammaCorrection(BOOL useGammaCorrection)
968 {
969 return SetStatus(DllExports::GdipSetPathGradientGammaCorrection(GetNativeGradient(), useGammaCorrection));
970 }
971
972 Status
973 SetGraphicsPath(const GraphicsPath *path)
974 {
975 if (!path)
976 return SetStatus(InvalidParameter);
977 return SetStatus(DllExports::GdipSetPathGradientPath(GetNativeGradient(), getNat(path)));
978 }
979
980 Status
981 SetInterpolationColors(const Color *presetColors, REAL *blendPositions, INT count)
982 {
983 return NotImplemented;
984 }
985
986 Status
987 SetSurroundColors(const Color *colors, INT *count)
988 {
989 return NotImplemented;
990 }
991
992 Status
993 SetTransform(const Matrix *matrix)
994 {
995 return SetStatus(DllExports::GdipSetPathGradientTransform(GetNativeGradient(), getNat(matrix)));
996 }
997
998 Status
999 SetWrapMode(WrapMode wrapMode)
1000 {
1001 return SetStatus(DllExports::GdipSetPathGradientWrapMode(GetNativeGradient(), wrapMode));
1002 }
1003
1004 Status
1005 TranslateTransform(REAL dx, REAL dy, MatrixOrder order = MatrixOrderPrepend)
1006 {
1007 return SetStatus(DllExports::GdipTranslatePathGradientTransform(GetNativeGradient(), dx, dy, order));
1008 }
1009
1010 protected:
1011 GpPathGradient *
1012 GetNativeGradient() const
1013 {
1014 return static_cast<GpPathGradient *>(nativeBrush);
1015 }
1016
1017 PathGradientBrush()
1018 {
1019 }
1020};
1021
1022#endif /* _GDIPLUSPATH_H */