source: Daodan/MinGW/include/gdiplus/gdipluspath.h@ 1089

Last change on this file since 1089 was 1046, checked in by alloc, 8 years ago

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