Add a .gitattributes with "* text=auto" so that new lines are
[pdfium.git] / core / src / fxge / Microsoft SDK / include / GdiPlusPath.h
1 /**************************************************************************\
2 *
3 * Copyright (c) 1998-2000, Microsoft Corp.  All Rights Reserved.
4 *
5 * Module Name:
6 *
7 *   GdiplusPath.h
8 *
9 * Abstract:
10 *
11 *   Path related declarations
12 *
13 \**************************************************************************/
14
15 #ifndef _GDIPLUSPATH_H
16 #define _GDIPLUSPATH_H
17
18 class GraphicsPath : public GdiplusBase
19 {
20 public:
21     friend class Graphics;
22     friend class Region;
23     friend class PathGradientBrush;
24     friend class GraphicsPathIterator;
25     friend class CustomLineCap;
26
27     // Path constructors
28
29     GraphicsPath(IN FillMode fillMode = FillModeAlternate)
30     {
31         nativePath = NULL;
32         lastResult = DllExports::GdipCreatePath(fillMode, &nativePath);
33     }
34
35     GraphicsPath(IN const PointF* points,
36                  IN const BYTE* types,
37                  IN INT count,
38                  IN FillMode fillMode = FillModeAlternate)
39     {
40         nativePath = NULL;
41         lastResult = DllExports::GdipCreatePath2(points,
42                                                  types,
43                                                  count,
44                                                  fillMode,
45                                                  &nativePath);
46     }
47
48     GraphicsPath(IN const Point* points,
49                  IN const BYTE* types,
50                  IN INT count,
51                  IN FillMode fillMode = FillModeAlternate)
52     {
53         nativePath = NULL;
54         lastResult = DllExports::GdipCreatePath2I(points,
55                                                   types,
56                                                   count,
57                                                   fillMode,
58                                                   &nativePath);
59     }
60
61     ~GraphicsPath()
62     {
63         DllExports::GdipDeletePath(nativePath);
64     }
65
66     /**
67      * Make a copy of the current path object
68      */
69     GraphicsPath* Clone() const
70     {
71         GpPath *clonepath = NULL;
72
73         SetStatus(DllExports::GdipClonePath(nativePath, &clonepath));
74
75         return new GraphicsPath(clonepath);
76     }
77
78     /**
79      * Reset the path object to empty (and fill mode to FillModeAlternate)
80      */
81     Status Reset()
82     {
83         return SetStatus(DllExports::GdipResetPath(nativePath));
84     }
85
86     /**
87      * Get path fill mode information
88      */
89     FillMode GetFillMode() const
90     {
91         FillMode fillmode = FillModeAlternate;
92
93         SetStatus(DllExports::GdipGetPathFillMode(nativePath, &fillmode));
94
95         return fillmode;
96     }
97
98     /**
99      * Set path fill mode information
100      */
101     Status SetFillMode(IN FillMode fillmode)
102     {
103         return SetStatus(DllExports::GdipSetPathFillMode(nativePath, fillmode));
104     }
105
106     /**
107      * Set/get path data
108      */
109     Status GetPathData(OUT PathData* pathData) const
110     {
111         if (pathData == NULL) 
112         {
113             return SetStatus(InvalidParameter);
114         }
115         
116         INT count = GetPointCount();
117         
118         if ((count <= 0) || (pathData->Count>0 && pathData->Count<count))
119         {
120             pathData->Count = 0;
121             if (pathData->Points)
122             {
123                 delete pathData->Points;
124                 pathData->Points = NULL;
125             }
126
127             if (pathData->Types) 
128             {
129                 delete pathData->Types;
130                 pathData->Types = NULL;
131             }
132
133             if (count <= 0)
134             {
135                 return lastResult;
136             }
137         }
138
139         if (pathData->Count == 0) 
140         {
141             pathData->Points = new PointF[count];
142             if (pathData->Points == NULL) 
143             {
144                 return SetStatus(OutOfMemory);
145             
146             }
147             pathData->Types = new byte[count];
148             if (pathData->Types == NULL) 
149             {
150                 delete pathData->Points;
151                 pathData->Points = NULL;
152
153                 return SetStatus(OutOfMemory);
154             }
155             pathData->Count = count;
156         }
157
158         return SetStatus(DllExports::GdipGetPathData(nativePath, pathData));
159     }
160
161     /**
162      * Start/end a subpath
163      */
164     Status StartFigure()
165     {
166         return SetStatus(DllExports::GdipStartPathFigure(nativePath));
167     }
168
169     Status CloseFigure()
170     {
171         return SetStatus(DllExports::GdipClosePathFigure(nativePath));
172     }
173
174     Status CloseAllFigures()
175     {
176         return SetStatus(DllExports::GdipClosePathFigures(nativePath));
177     }
178
179     Status SetMarker()
180     {
181         return SetStatus(DllExports::GdipSetPathMarker(nativePath));
182     }
183
184     Status ClearMarkers()
185     {
186         return SetStatus(DllExports::GdipClearPathMarkers(nativePath));
187     }
188
189     Status Reverse()
190     {
191         return SetStatus(DllExports::GdipReversePath(nativePath));
192     }
193
194     Status GetLastPoint(OUT PointF* lastPoint) const
195     {
196         return SetStatus(DllExports::GdipGetPathLastPoint(nativePath, lastPoint));
197     }
198
199     /**
200      * Add lines to the path object
201      */
202     // float version
203     Status AddLine(IN const PointF& pt1, 
204                    IN const PointF& pt2)
205     {
206         return AddLine(pt1.X, pt1.Y, pt2.X, pt2.Y);
207     }
208
209     Status AddLine(IN REAL x1,
210                    IN REAL y1, 
211                    IN REAL x2, 
212                    IN REAL y2)
213     {
214         return SetStatus(DllExports::GdipAddPathLine(nativePath, x1, y1, x2, y2));
215     }
216
217     Status AddLines(IN const PointF* points, 
218                     IN INT count)
219     {
220         return SetStatus(DllExports::GdipAddPathLine2(nativePath, points, count));
221     }
222
223     // integer version
224     Status AddLine(IN const Point& pt1, 
225                    IN const Point& pt2)
226     {
227         return AddLine(pt1.X,
228                        pt1.Y,
229                        pt2.X,
230                        pt2.Y);
231     }
232
233     Status AddLine(IN INT x1, 
234                    IN INT y1, 
235                    IN INT x2, 
236                    IN INT y2)
237     {
238         return SetStatus(DllExports::GdipAddPathLineI(nativePath,
239                                                      x1,
240                                                      y1,
241                                                      x2,
242                                                      y2));
243     }
244
245     Status AddLines(IN const Point* points, 
246                     IN INT count)
247     {
248         return SetStatus(DllExports::GdipAddPathLine2I(nativePath,
249                                                        points,
250                                                        count));
251     }
252
253     /**
254      * Add an arc to the path object
255      */
256     // float version
257     Status AddArc(IN const RectF& rect, 
258                   IN REAL startAngle, 
259                   IN REAL sweepAngle)
260     {
261         return AddArc(rect.X, rect.Y, rect.Width, rect.Height,
262                       startAngle, sweepAngle);
263     }
264
265     Status AddArc(IN REAL x, 
266                   IN REAL y, 
267                   IN REAL width, 
268                   IN REAL height,
269                   IN REAL startAngle, 
270                   IN REAL sweepAngle)
271     {
272         return SetStatus(DllExports::GdipAddPathArc(nativePath, x, y, width, height,
273                                       startAngle, sweepAngle));
274     }
275
276     // integer version
277     Status AddArc(IN const Rect& rect, 
278                   IN REAL startAngle, 
279                   IN REAL sweepAngle)
280     {
281         return AddArc(rect.X, rect.Y, rect.Width, rect.Height,
282                       startAngle, sweepAngle);
283     }
284
285     Status AddArc(IN INT x, 
286                   IN INT y, 
287                   IN INT width, 
288                   IN INT height,
289                   IN REAL startAngle, 
290                   IN REAL sweepAngle)
291     {
292         return SetStatus(DllExports::GdipAddPathArcI(nativePath,
293                                                     x,
294                                                     y,
295                                                     width,
296                                                     height,
297                                                     startAngle,
298                                                     sweepAngle));
299     }
300
301     /**
302      * Add Bezier curves to the path object
303      */
304     // float version
305     Status AddBezier(IN const PointF& pt1, 
306                      IN const PointF& pt2,
307                      IN const PointF& pt3, 
308                      IN const PointF& pt4)
309     {
310         return AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X,
311                          pt4.Y);
312     }
313
314     Status AddBezier(IN REAL x1, 
315                      IN REAL y1, 
316                      IN REAL x2, 
317                      IN REAL y2,
318                      IN REAL x3, 
319                      IN REAL y3, 
320                      IN REAL x4, 
321                      IN REAL y4)
322     {
323         return SetStatus(DllExports::GdipAddPathBezier(nativePath, x1, y1, x2, y2,
324                                      x3, y3, x4, y4));
325     }
326
327     Status AddBeziers(IN const PointF* points, 
328                       IN INT count)
329     {
330         return SetStatus(DllExports::GdipAddPathBeziers(nativePath, points, count));
331     }
332
333     // integer version
334     Status AddBezier(IN const Point& pt1, 
335                      IN const Point& pt2,
336                      IN const Point& pt3, 
337                      IN const Point& pt4)
338     {
339        return AddBezier(pt1.X, pt1.Y, pt2.X, pt2.Y, pt3.X, pt3.Y, pt4.X,
340                         pt4.Y);
341     }
342
343     Status AddBezier(IN INT x1, 
344                      IN INT y1, 
345                      IN INT x2, 
346                      IN INT y2,
347                      IN INT x3,
348                      IN INT y3, 
349                      IN INT x4, 
350                      IN INT y4)
351     {
352        return SetStatus(DllExports::GdipAddPathBezierI(nativePath,
353                                                       x1,
354                                                       y1,
355                                                       x2,
356                                                       y2,
357                                                       x3,
358                                                       y3,
359                                                       x4,
360                                                       y4));
361     }
362
363     Status AddBeziers(IN const Point* points,
364                       IN INT count)
365     {
366        return SetStatus(DllExports::GdipAddPathBeziersI(nativePath,
367                                                         points,
368                                                         count));
369     }
370
371     // float version
372     Status AddCurve(IN const PointF* points, 
373                     IN INT count)
374     {
375         return SetStatus(DllExports::GdipAddPathCurve(nativePath,
376                                                       points,
377                                                       count));
378     }
379
380     Status AddCurve(IN const PointF* points, 
381                     IN INT count,
382                     IN REAL tension)
383     {
384         return SetStatus(DllExports::GdipAddPathCurve2(nativePath,
385                                                        points,
386                                                        count,
387                                                        tension));
388     }
389
390     Status AddCurve(IN const PointF* points, 
391                     IN INT count, 
392                     IN INT offset,
393                     IN INT numberOfSegments, 
394                     IN REAL tension)
395     {
396         return SetStatus(DllExports::GdipAddPathCurve3(nativePath,
397                                                        points,
398                                                        count,
399                                                        offset,
400                                                        numberOfSegments,
401                                                        tension));
402     }
403
404     // integer version
405     Status AddCurve(IN const Point* points, 
406                     IN INT count)
407     {
408        return SetStatus(DllExports::GdipAddPathCurveI(nativePath,
409                                                      points,
410                                                      count));
411     }
412
413     Status AddCurve(IN const Point* points, 
414                     IN INT count, 
415                     IN REAL tension)
416     {
417        return SetStatus(DllExports::GdipAddPathCurve2I(nativePath,
418                                                       points,
419                                                       count,
420                                                       tension));
421     }
422
423     Status AddCurve(IN const Point* points, 
424                     IN INT count, 
425                     IN INT offset,
426                     IN INT numberOfSegments, 
427                     IN REAL tension)
428     {
429        return SetStatus(DllExports::GdipAddPathCurve3I(nativePath,
430                                                       points,
431                                                       count,
432                                                       offset,
433                                                       numberOfSegments,
434                                                       tension));
435     }
436
437     // float version
438     Status AddClosedCurve(IN const PointF* points, 
439                           IN INT count)
440     {
441         return SetStatus(DllExports::GdipAddPathClosedCurve(nativePath,
442                                                             points,
443                                                             count));
444     }
445
446     Status AddClosedCurve(IN const PointF* points, 
447                           IN INT count, 
448                           IN REAL tension)
449     {
450         return SetStatus(DllExports::GdipAddPathClosedCurve2(nativePath,
451                                                              points,
452                                                              count,
453                                                              tension));
454     }
455
456     // integer version
457     Status AddClosedCurve(IN const Point* points, 
458                           IN INT count)
459     {
460        return SetStatus(DllExports::GdipAddPathClosedCurveI(nativePath,
461                                                             points,
462                                                             count));
463     }
464
465
466     Status AddClosedCurve(IN const Point* points, 
467                           IN INT count,
468                           IN REAL tension)
469     {
470        return SetStatus(DllExports::GdipAddPathClosedCurve2I(nativePath,
471                                                              points,
472                                                              count,
473                                                              tension));
474     }
475
476
477     /**
478      * Add closed shapes to the path object
479      */
480
481     // float version
482     Status AddRectangle(IN const RectF& rect)
483     {
484         return SetStatus(DllExports::GdipAddPathRectangle(nativePath,
485                                                           rect.X,
486                                                           rect.Y,
487                                                           rect.Width,
488                                                           rect.Height));
489     }
490
491     Status AddRectangles(IN const RectF* rects, 
492                          IN INT count)
493     {
494         return SetStatus(DllExports::GdipAddPathRectangles(nativePath,
495                                                            rects,
496                                                            count));
497     }
498
499     // integer version
500     Status AddRectangle(IN const Rect& rect)
501     {
502         return SetStatus(DllExports::GdipAddPathRectangleI(nativePath,
503                                                           rect.X,
504                                                           rect.Y,
505                                                           rect.Width,
506                                                           rect.Height));
507     }
508
509     Status AddRectangles(IN const Rect* rects, INT count)
510     {
511         return SetStatus(DllExports::GdipAddPathRectanglesI(nativePath,
512                                                            rects,
513                                                            count));
514     }
515
516     // float version
517     Status AddEllipse(IN const RectF& rect)
518     {
519         return AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
520     }
521
522     Status AddEllipse(IN REAL x, 
523                       IN REAL y, 
524                       IN REAL width, 
525                       IN REAL height)
526     {
527         return SetStatus(DllExports::GdipAddPathEllipse(nativePath,
528                                                         x,
529                                                         y,
530                                                         width,
531                                                         height));
532     }
533
534     // integer version
535     Status AddEllipse(IN const Rect& rect)
536     {
537         return AddEllipse(rect.X, rect.Y, rect.Width, rect.Height);
538     }
539
540     Status AddEllipse(IN INT x, 
541                       IN INT y, 
542                       IN INT width, 
543                       IN INT height)
544     {
545         return SetStatus(DllExports::GdipAddPathEllipseI(nativePath,
546                                                         x,
547                                                         y,
548                                                         width,
549                                                         height));
550     }
551
552     // float version
553     Status AddPie(IN const RectF& rect, 
554                   IN REAL startAngle, 
555                   IN REAL sweepAngle)
556     {
557         return AddPie(rect.X, rect.Y, rect.Width, rect.Height, startAngle,
558                       sweepAngle);
559     }
560
561     Status AddPie(IN REAL x, 
562                   IN REAL y, 
563                   IN REAL width, 
564                   IN REAL height, 
565                   IN REAL startAngle,
566                   IN REAL sweepAngle)
567     {
568         return SetStatus(DllExports::GdipAddPathPie(nativePath, x, y, width, height,
569                                       startAngle, sweepAngle));
570     }
571
572     // integer version
573     Status AddPie(IN const Rect& rect, 
574                   IN REAL startAngle, 
575                   IN REAL sweepAngle)
576     {
577         return AddPie(rect.X,
578                       rect.Y,
579                       rect.Width,
580                       rect.Height,
581                       startAngle,
582                       sweepAngle);
583     }
584
585     Status AddPie(IN INT x, 
586                   IN INT y, 
587                   IN INT width, 
588                   IN INT height, 
589                   IN REAL startAngle,
590                   IN REAL sweepAngle)
591     {
592         return SetStatus(DllExports::GdipAddPathPieI(nativePath,
593                                                     x,
594                                                     y,
595                                                     width,
596                                                     height,
597                                                     startAngle,
598                                                     sweepAngle));
599     }
600
601     // float version
602     Status AddPolygon(IN const PointF* points, 
603                       IN INT count)
604     {
605         return SetStatus(DllExports::GdipAddPathPolygon(nativePath, points, count));
606     }
607
608     // integer version
609     Status AddPolygon(IN const Point* points, 
610                       IN INT count)
611     {
612        return SetStatus(DllExports::GdipAddPathPolygonI(nativePath, points, count));
613     }
614
615     Status AddPath(IN const GraphicsPath* addingPath, 
616                    IN BOOL connect)
617     {
618         GpPath* nativePath2 = NULL;
619         if(addingPath)
620             nativePath2 = addingPath->nativePath;
621
622         return SetStatus(DllExports::GdipAddPathPath(nativePath, nativePath2, connect));
623     }
624
625     // AddString point version
626
627     Status AddString(
628         IN const WCHAR         *string,
629         IN INT                  length,
630         IN const FontFamily    *family,
631         IN INT                  style,
632         IN REAL                 emSize,  // In world units
633         IN const PointF        &origin,
634         IN const StringFormat  *format
635     )
636     {
637         RectF rect(origin.X, origin.Y, 0.0f, 0.0f);
638
639         return SetStatus(DllExports::GdipAddPathString(
640             nativePath,
641             string,
642             length,
643             family ? family->nativeFamily : NULL,
644             style,
645             emSize,
646             &rect,
647             format ? format->nativeFormat : NULL
648         ));
649     }
650
651     // AddString rectangle version
652
653     Status AddString(
654         IN const WCHAR         *string,
655         IN INT                  length,
656         IN const FontFamily    *family,
657         IN INT                  style,
658         IN REAL                 emSize,  // In world units
659         IN const RectF         &layoutRect,
660         IN const StringFormat  *format
661     )
662     {
663         return SetStatus(DllExports::GdipAddPathString(
664             nativePath,
665             string,
666             length,
667             family ? family->nativeFamily : NULL,
668             style,
669             emSize,
670             &layoutRect,
671             format ? format->nativeFormat : NULL
672         ));
673     }
674
675     Status AddString(
676         IN const WCHAR         *string,
677         IN INT                  length,
678         IN const FontFamily    *family,
679         IN INT                  style,
680         IN REAL                 emSize,  // In world units
681         IN const Point         &origin,
682         IN const StringFormat  *format
683     )
684     {
685         Rect rect(origin.X, origin.Y, 0, 0);
686
687         return SetStatus(DllExports::GdipAddPathStringI(
688             nativePath,
689             string,
690             length,
691             family ? family->nativeFamily : NULL,
692             style,
693             emSize,
694             &rect,
695             format ? format->nativeFormat : NULL
696         ));
697     }
698
699     // AddString rectangle version
700
701     Status AddString(
702         IN const WCHAR         *string,
703         IN INT                  length,
704         IN const FontFamily    *family,
705         IN INT                  style,
706         IN REAL                 emSize,  // In world units
707         IN const Rect          &layoutRect,
708         IN const StringFormat  *format
709     )
710     {
711         return SetStatus(DllExports::GdipAddPathStringI(
712             nativePath,
713             string,
714             length,
715             family ? family->nativeFamily : NULL,
716             style,
717             emSize,
718             &layoutRect,
719             format ? format->nativeFormat : NULL
720         ));
721     }
722     
723     /**
724      * Transforms the path object
725      */
726     Status Transform(IN const Matrix* matrix)
727     {
728         if(matrix)
729             return SetStatus(DllExports::GdipTransformPath(nativePath, matrix->nativeMatrix));
730         else
731             return Ok;  // No need to transform.
732     }
733
734     /**
735      * Get the bounds of the path object with the given transform.
736      * This is not always the tightest bounds.
737      *
738      * Defined in GdiplusGraphics.h.
739      */
740     Status GetBounds(OUT RectF* bounds, 
741                      IN const Matrix* matrix = NULL, 
742                      IN const Pen* pen = NULL) const;
743
744     // integer version (defined in GdiplusGraphics.h)
745     Status GetBounds(OUT Rect* bounds,
746                      IN const Matrix* matrix = NULL, 
747                      IN const Pen* pen = NULL) const;
748
749     /**
750      * Flatten the path object
751      * Once this is called, the resultant path is made of line segments and
752      * the original path information is lost.
753      * When matrix = NULL, the identity matrix is assumed.
754      */
755     Status Flatten(IN const Matrix* matrix = NULL, 
756                    IN REAL flatness = FlatnessDefault)
757     {
758         GpMatrix* nativeMatrix = NULL;
759         if(matrix)
760         {
761             nativeMatrix = matrix->nativeMatrix;
762         }
763
764         return SetStatus(DllExports::GdipFlattenPath(
765             nativePath, 
766             nativeMatrix, 
767             flatness
768         ));
769     }
770
771 #ifdef DCR_USE_NEW_202903
772     
773     Status Widen(
774         IN const Pen* pen, 
775         IN const Matrix* matrix = NULL,
776         IN REAL flatness = FlatnessDefault
777     )
778     {
779         GpMatrix* nativeMatrix = NULL;
780         if(matrix)
781             nativeMatrix = matrix->nativeMatrix;
782
783         return SetStatus(DllExports::GdipWidenPath(
784             nativePath, 
785             pen->nativePen,
786             nativeMatrix, 
787             flatness
788         ));
789     }
790
791 #else
792
793     /**
794      * Widen the path object
795      * When removeSelfIntersects is TRUE, this returns the widened path
796      * without self intersections.
797      * When it is FALSE, it returns the widened path with selfintersections.
798      * The latter is faster and is usually safficient for filling.
799      */
800     Status Widen(IN const Pen* pen, 
801                  IN const Matrix* matrix = NULL,
802                  IN BOOL removeSelfIntersects = TRUE)
803     {
804         GpMatrix* nativeMatrix = NULL;
805         if(matrix)
806             nativeMatrix = matrix->nativeMatrix;
807
808         return SetStatus(DllExports::GdipWidenPathWithMinimumResolutions(nativePath, pen->nativePen,
809             0, 0, nativeMatrix, removeSelfIntersects));
810     }
811
812     /**
813      * Widen the path object
814      * This is equivalent to Widen() method except that
815      * The widths of the widened path are larger than the given
816      * minimum resolutions in x and y coordinates after the transform.
817      * This is usefull when widening a path with the limited device resolutions.
818      */
819
820     Status Widen(IN const Pen* pen, 
821                  IN REAL minXres, 
822                  IN REAL minYres, 
823                  IN const Matrix* matrix = NULL,
824                  IN BOOL removeSelfIntersects = TRUE)
825     {
826         GpMatrix* nativeMatrix = NULL;
827         if(matrix)
828             nativeMatrix = matrix->nativeMatrix;
829
830         return SetStatus(DllExports::GdipWidenPathWithMinimumResolutions(nativePath, pen->nativePen,
831             minXres, minYres, nativeMatrix, removeSelfIntersects));
832     }
833
834 #endif // DCR_USE_NEW_202903
835
836     Status Outline(
837         IN const Matrix *matrix = NULL,
838         IN REAL flatness = FlatnessDefault
839     )
840     {
841         GpMatrix* nativeMatrix = NULL;
842         if(matrix)
843         {
844             nativeMatrix = matrix->nativeMatrix;
845         }
846
847         return SetStatus(DllExports::GdipWindingModeOutline(
848             nativePath, nativeMatrix, flatness
849         ));
850     }
851     
852     /**
853      * Warp the path object
854      * Once this is called, the resultant path is made of line segments and
855      * the original path information is lost.
856      * When matrix = NULL, the identity matrix is assumed.
857      */
858     Status Warp(IN const PointF* destPoints, 
859                 IN INT count,
860                 IN const RectF& srcRect, 
861                 IN const Matrix* matrix = NULL,
862                 IN WarpMode warpMode = WarpModePerspective,
863                 IN REAL flatness = FlatnessDefault)
864     {
865         GpMatrix* nativeMatrix = NULL;
866         if(matrix)
867             nativeMatrix = matrix->nativeMatrix;
868
869         return SetStatus(DllExports::GdipWarpPath(
870                                         nativePath,
871                                         nativeMatrix,
872                                         destPoints,
873                                         count,
874                                         srcRect.X,
875                                         srcRect.Y,
876                                         srcRect.Width,
877                                         srcRect.Height,
878                                         warpMode,
879                                         flatness));
880     }
881
882     /**
883      * Return the number of points in the current path
884      */
885     INT GetPointCount() const
886     {
887         INT count = 0;
888
889         SetStatus(DllExports::GdipGetPointCount(nativePath, &count));
890
891         return count;
892     }
893
894     /**
895      * Return the path point type information
896      */
897     Status GetPathTypes(OUT BYTE* types, 
898                         IN INT count) const
899     {
900         return SetStatus(DllExports::GdipGetPathTypes(nativePath, types, count));
901     }
902
903     /**
904      * Return the path point coordinate information
905      * @notes Should there be PathData that contains types[] and points[]
906      *        for get & set purposes.
907      */
908     Status GetPathPoints(OUT PointF* points, 
909                          IN INT count) const
910     {
911         return SetStatus(DllExports::GdipGetPathPoints(nativePath, points, count));
912     }
913
914     // integer version
915     Status GetPathPoints(OUT Point* points, 
916                          IN INT count) const
917     {
918         return SetStatus(DllExports::GdipGetPathPointsI(nativePath, points, count));
919     }
920
921     Status GetLastStatus() const
922     {
923         Status lastStatus = lastResult;
924         lastResult = Ok;
925
926         return lastStatus;
927     }
928
929     /**
930      * Hit testing operations
931      *
932      * inline implementation is in gdiplusgraphics.h.
933      */
934
935     BOOL IsVisible(IN const PointF& point, 
936                    IN const Graphics* g = NULL) const
937     {
938         return IsVisible(point.X, point.Y, g);
939     }
940     
941     BOOL IsVisible(IN REAL x, 
942                    IN REAL y, 
943                    IN const Graphics* g = NULL) const;
944
945     BOOL IsVisible(IN const Point& point,
946                    IN const Graphics* g = NULL) const
947     {
948         return IsVisible(point.X, point.Y, g);
949     }
950
951     BOOL IsVisible(IN INT x, 
952                    IN INT y, 
953                    IN const Graphics* g = NULL) const;
954     
955     BOOL IsOutlineVisible(IN const PointF& point,
956                           IN const Pen* pen, 
957                           IN const Graphics* g = NULL) const
958     {
959         return IsOutlineVisible(point.X, point.Y, pen, g);
960     }
961
962     BOOL IsOutlineVisible(IN REAL x, 
963                           IN REAL y, 
964                           IN const Pen* pen, 
965                           IN const Graphics* g = NULL) const;
966
967     BOOL IsOutlineVisible(IN const Point& point,
968                           IN const Pen* pen, 
969                           IN const Graphics* g = NULL) const
970     {
971         return IsOutlineVisible(point.X, point.Y, pen, g);
972     }
973     
974     BOOL IsOutlineVisible(IN INT x, 
975                           IN INT y, 
976                           IN const Pen* pen, 
977                           IN const Graphics* g = NULL) const;
978
979 protected:
980
981     GraphicsPath(const GraphicsPath& path)
982     {
983         GpPath *clonepath = NULL;
984         SetStatus(DllExports::GdipClonePath(path.nativePath, &clonepath));
985         SetNativePath(clonepath);
986     }
987
988 #ifdef DCR_USE_NEW_250932
989
990 private:
991     GraphicsPath& operator=(const GraphicsPath &);
992 protected:
993
994 #else
995
996     GraphicsPath& operator=(const GraphicsPath& path)
997     {
998         path;
999         SetStatus(NotImplemented);
1000         return *this;
1001     }
1002
1003 #endif
1004
1005     GraphicsPath(GpPath* nativePath)
1006     {
1007         lastResult = Ok;
1008         SetNativePath(nativePath);
1009     }
1010
1011     VOID SetNativePath(GpPath *nativePath)
1012     {
1013         this->nativePath = nativePath;
1014     }
1015
1016     Status SetStatus(Status status) const
1017     {
1018         if (status != Ok)
1019             return (lastResult = status);
1020         else
1021             return status;
1022     }
1023
1024 protected:
1025     GpPath* nativePath;
1026     mutable Status lastResult;
1027 };
1028
1029
1030 //--------------------------------------------------------------------------
1031 // GraphisPathIterator class
1032 //--------------------------------------------------------------------------
1033
1034 class GraphicsPathIterator : public GdiplusBase
1035 {
1036 public:
1037
1038     GraphicsPathIterator(IN const GraphicsPath* path)
1039     {
1040         GpPath* nativePath = NULL;
1041         if(path)
1042             nativePath = path->nativePath;
1043
1044         GpPathIterator *iter = NULL;
1045         lastResult = DllExports::GdipCreatePathIter(&iter, nativePath);
1046         SetNativeIterator(iter);
1047     }
1048
1049     ~GraphicsPathIterator()
1050     {
1051         DllExports::GdipDeletePathIter(nativeIterator);
1052     }
1053
1054
1055     INT NextSubpath(OUT INT* startIndex,
1056                     OUT INT* endIndex,
1057                     OUT BOOL* isClosed)
1058     {
1059         INT resultCount;
1060
1061         SetStatus(DllExports::GdipPathIterNextSubpath(nativeIterator,
1062             &resultCount, startIndex, endIndex, isClosed));
1063
1064         return resultCount;
1065     }
1066
1067
1068     INT NextSubpath(IN const GraphicsPath* path, 
1069                     OUT BOOL* isClosed)
1070     {
1071         GpPath* nativePath = NULL;
1072
1073         INT resultCount;
1074
1075         if(path)
1076             nativePath= path->nativePath;
1077
1078         SetStatus(DllExports::GdipPathIterNextSubpathPath(nativeIterator,
1079             &resultCount, nativePath, isClosed));
1080
1081         return resultCount;
1082     }
1083
1084     INT NextPathType(OUT BYTE* pathType, 
1085                      OUT INT* startIndex, 
1086                      OUT INT* endIndex)
1087     {
1088         INT resultCount;
1089
1090         SetStatus(DllExports::GdipPathIterNextPathType(nativeIterator,
1091             &resultCount, pathType, startIndex, endIndex));
1092
1093         return resultCount;
1094     }
1095
1096     INT NextMarker(OUT INT* startIndex, 
1097                    OUT INT* endIndex)
1098     {
1099         INT resultCount;
1100
1101         SetStatus(DllExports::GdipPathIterNextMarker(nativeIterator,
1102             &resultCount, startIndex, endIndex));
1103
1104         return resultCount;
1105     }
1106
1107
1108     INT NextMarker(IN const GraphicsPath* path)
1109     {
1110         GpPath* nativePath = NULL;
1111
1112         INT resultCount;
1113
1114         if(path)
1115             nativePath= path->nativePath;
1116
1117         SetStatus(DllExports::GdipPathIterNextMarkerPath(nativeIterator,
1118             &resultCount, nativePath));
1119
1120         return resultCount;
1121     }
1122
1123     INT GetCount() const
1124     {
1125         INT resultCount;
1126
1127         SetStatus(DllExports::GdipPathIterGetCount(nativeIterator, &resultCount));
1128
1129         return resultCount;
1130     }
1131
1132     INT GetSubpathCount() const
1133     {
1134         INT resultCount;
1135
1136         SetStatus(DllExports::GdipPathIterGetSubpathCount(nativeIterator, &resultCount));
1137
1138         return resultCount;
1139     }
1140
1141     BOOL HasCurve() const
1142     {
1143         BOOL hasCurve;
1144
1145         SetStatus(DllExports::GdipPathIterHasCurve(nativeIterator, &hasCurve));
1146
1147         return hasCurve;
1148     }
1149
1150     VOID Rewind()
1151     {
1152         SetStatus(DllExports::GdipPathIterRewind(nativeIterator));
1153     }
1154
1155     INT Enumerate(OUT PointF *points,
1156                   OUT BYTE *types, 
1157                   IN INT count)
1158     {
1159         INT resultCount;
1160
1161         SetStatus(DllExports::GdipPathIterEnumerate(nativeIterator,
1162             &resultCount, points, types, count));
1163
1164         return resultCount;
1165     }
1166
1167     INT CopyData(OUT PointF* points, 
1168                  OUT BYTE* types,
1169                  IN INT startIndex, 
1170                  IN INT endIndex)
1171     {
1172         INT resultCount;
1173
1174         SetStatus(DllExports::GdipPathIterCopyData(nativeIterator,
1175             &resultCount, points, types, startIndex, endIndex));
1176
1177         return resultCount;
1178     }
1179
1180     Status GetLastStatus() const
1181     {
1182         Status lastStatus = lastResult;
1183         lastResult = Ok;
1184
1185         return lastStatus;
1186     }
1187
1188 #ifdef DCR_USE_NEW_250932
1189
1190 private:
1191     GraphicsPathIterator(const GraphicsPathIterator &);
1192     GraphicsPathIterator& operator=(const GraphicsPathIterator &);
1193
1194 #endif
1195
1196 protected:
1197     VOID SetNativeIterator(GpPathIterator *nativeIterator)
1198     {
1199         this->nativeIterator = nativeIterator;
1200     }
1201
1202     Status SetStatus(Status status) const
1203     {
1204         if (status != Ok)
1205             return (lastResult = status);
1206         else
1207             return status;
1208     }
1209
1210 protected:
1211     GpPathIterator* nativeIterator;
1212     mutable Status lastResult;
1213 };
1214
1215
1216 //--------------------------------------------------------------------------
1217 // Represent polygon gradient brush object
1218 //--------------------------------------------------------------------------
1219
1220 class PathGradientBrush : public Brush
1221 {
1222 public:
1223     friend class Pen;
1224
1225     PathGradientBrush(
1226         IN const PointF* points,
1227         IN INT count,
1228         IN WrapMode wrapMode = WrapModeClamp)
1229     {
1230         GpPathGradient *brush = NULL;
1231
1232         lastResult = DllExports::GdipCreatePathGradient(
1233                                         points, count,
1234                                         wrapMode, &brush);
1235         SetNativeBrush(brush);
1236     }
1237
1238     PathGradientBrush(
1239         IN const Point* points,
1240         IN INT count,
1241         IN WrapMode wrapMode = WrapModeClamp)
1242     {
1243         GpPathGradient *brush = NULL;
1244
1245         lastResult = DllExports::GdipCreatePathGradientI(
1246                                         points, count,
1247                                         wrapMode, &brush);
1248
1249         SetNativeBrush(brush);
1250     }
1251
1252     PathGradientBrush(
1253         IN const GraphicsPath* path
1254         )
1255     {
1256         GpPathGradient *brush = NULL;
1257
1258         lastResult = DllExports::GdipCreatePathGradientFromPath(
1259                                         path->nativePath, &brush);
1260         SetNativeBrush(brush);
1261     }
1262
1263     // Get/set colors
1264
1265     Status GetCenterColor(OUT Color* color) const
1266     {
1267         ARGB argb;
1268         
1269         if (color == NULL) 
1270         {
1271             return SetStatus(InvalidParameter);
1272         }
1273
1274         SetStatus(DllExports::GdipGetPathGradientCenterColor(
1275                        (GpPathGradient*) nativeBrush, &argb));
1276
1277         color->SetValue(argb);
1278
1279         return lastResult;
1280     }
1281
1282     Status SetCenterColor(IN const Color& color)
1283     {
1284         SetStatus(DllExports::GdipSetPathGradientCenterColor(
1285                        (GpPathGradient*) nativeBrush,
1286                        color.GetValue()));
1287
1288         return lastResult;
1289     }
1290
1291     INT GetPointCount() const
1292     {
1293         INT count;
1294
1295         SetStatus(DllExports::GdipGetPathGradientPointCount(
1296                        (GpPathGradient*) nativeBrush, &count));
1297
1298         return count;
1299     }
1300
1301     INT GetSurroundColorCount() const
1302     {
1303         INT count;
1304
1305         SetStatus(DllExports::GdipGetPathGradientSurroundColorCount(
1306                        (GpPathGradient*) nativeBrush, &count));
1307
1308         return count;
1309     }
1310
1311     Status GetSurroundColors(OUT Color* colors, 
1312                              IN OUT INT* count) const
1313     {
1314         if(colors == NULL || count == NULL)
1315         {
1316             return SetStatus(InvalidParameter);
1317         }
1318
1319         INT count1;
1320         
1321         SetStatus(DllExports::GdipGetPathGradientSurroundColorCount(
1322                         (GpPathGradient*) nativeBrush, &count1));
1323
1324         if(lastResult != Ok)
1325             return lastResult;
1326
1327         if((*count < count1) || (count1 <= 0))
1328             return SetStatus(InsufficientBuffer);
1329
1330         ARGB* argbs = (ARGB*) new ARGB[count1];
1331         if(argbs == NULL)
1332             return SetStatus(OutOfMemory);
1333
1334         SetStatus(DllExports::GdipGetPathGradientSurroundColorsWithCount(
1335                     (GpPathGradient*)nativeBrush, argbs, &count1));
1336
1337         if(lastResult == Ok)
1338         {
1339             for(INT i = 0; i < count1; i++)
1340             {
1341                 colors[i].SetValue(argbs[i]);
1342             }        
1343             *count = count1;
1344         }
1345
1346         delete [] argbs;
1347         return lastResult;
1348     }
1349
1350     Status SetSurroundColors(IN const Color* colors, 
1351                              IN OUT INT* count)
1352     {
1353         if(colors == NULL || count == NULL)
1354         {
1355             return SetStatus(InvalidParameter);
1356         }
1357
1358         INT count1 = GetPointCount();
1359
1360         if((*count > count1) || (count1 <= 0))
1361             return SetStatus(InvalidParameter);
1362
1363         count1 = *count;
1364
1365         ARGB* argbs = (ARGB*) new ARGB[count1];
1366         if(argbs == NULL)
1367             return SetStatus(OutOfMemory);
1368
1369         for(INT i = 0; i < count1; i++)
1370         {
1371             argbs[i] = colors[i].GetValue();
1372         }
1373
1374         SetStatus(DllExports::GdipSetPathGradientSurroundColorsWithCount(
1375                     (GpPathGradient*)nativeBrush, argbs, &count1));
1376
1377         if(lastResult == Ok)
1378             *count = count1;
1379
1380         delete [] argbs;
1381
1382         return lastResult;
1383     }
1384
1385     Status GetGraphicsPath(OUT GraphicsPath* path) const
1386     {
1387         if(path == NULL)
1388             return SetStatus(InvalidParameter);
1389
1390         return SetStatus(DllExports::GdipGetPathGradientPath(
1391                     (GpPathGradient*)nativeBrush, path->nativePath));
1392     }
1393
1394     Status SetGraphicsPath(IN const GraphicsPath* path)
1395     {
1396         if(path == NULL)
1397             return SetStatus(InvalidParameter);
1398
1399         return SetStatus(DllExports::GdipSetPathGradientPath(
1400                     (GpPathGradient*)nativeBrush, path->nativePath));
1401     }
1402
1403     Status GetCenterPoint(OUT PointF* point) const
1404     {
1405         return SetStatus(DllExports::GdipGetPathGradientCenterPoint(
1406                                 (GpPathGradient*)nativeBrush,
1407                                 point));
1408     }
1409
1410
1411     Status GetCenterPoint(OUT Point* point) const
1412     {
1413         return SetStatus(DllExports::GdipGetPathGradientCenterPointI(
1414                                 (GpPathGradient*)nativeBrush,
1415                                 point));
1416     }
1417
1418     Status SetCenterPoint(IN const PointF& point)
1419     {
1420         return SetStatus(DllExports::GdipSetPathGradientCenterPoint(
1421                                 (GpPathGradient*)nativeBrush,
1422                                 &point));
1423     }
1424
1425     Status SetCenterPoint(IN const Point& point)
1426     {
1427         return SetStatus(DllExports::GdipSetPathGradientCenterPointI(
1428                                 (GpPathGradient*)nativeBrush,
1429                                 &point));
1430     }
1431
1432     Status GetRectangle(OUT RectF* rect) const
1433     {
1434         return SetStatus(DllExports::GdipGetPathGradientRect(
1435                             (GpPathGradient*)nativeBrush, rect));
1436     }
1437
1438     Status GetRectangle(OUT Rect* rect) const
1439     {
1440         return SetStatus(DllExports::GdipGetPathGradientRectI(
1441                             (GpPathGradient*)nativeBrush, rect));
1442     }
1443
1444     // Gamma correction.
1445
1446     Status SetGammaCorrection(IN BOOL useGammaCorrection)
1447     {
1448         return SetStatus(DllExports::GdipSetPathGradientGammaCorrection(
1449             (GpPathGradient*)nativeBrush, useGammaCorrection));
1450     }
1451
1452     BOOL GetGammaCorrection() const
1453     {
1454         BOOL useGammaCorrection;
1455
1456         SetStatus(DllExports::GdipGetPathGradientGammaCorrection(
1457             (GpPathGradient*)nativeBrush, &useGammaCorrection));
1458
1459         return useGammaCorrection;
1460     }
1461
1462     INT GetBlendCount() const
1463     {
1464        INT count = 0;
1465
1466        SetStatus(DllExports::GdipGetPathGradientBlendCount(
1467                            (GpPathGradient*) nativeBrush, &count));
1468
1469        return count;
1470     }
1471
1472     Status GetBlend(OUT REAL* blendFactors,
1473                     OUT REAL* blendPositions,
1474                     IN INT count) const
1475     {
1476         return SetStatus(DllExports::GdipGetPathGradientBlend(
1477                             (GpPathGradient*)nativeBrush,
1478                             blendFactors, blendPositions, count));
1479     }
1480
1481     Status SetBlend(IN const REAL* blendFactors, 
1482                     IN const REAL* blendPositions, 
1483                     IN INT count)
1484     {
1485         return SetStatus(DllExports::GdipSetPathGradientBlend(
1486                             (GpPathGradient*)nativeBrush,
1487                             blendFactors, blendPositions, count));
1488     }
1489
1490     INT GetInterpolationColorCount() const
1491     {
1492        INT count = 0;
1493
1494        SetStatus(DllExports::GdipGetPathGradientPresetBlendCount(
1495                         (GpPathGradient*) nativeBrush, &count));
1496
1497        return count;
1498     }
1499
1500     Status SetInterpolationColors(IN const Color* presetColors,
1501                                   IN const REAL* blendPositions, 
1502                                   IN INT count)
1503     {
1504         if ((count <= 0) || !presetColors) 
1505         {
1506             return SetStatus(InvalidParameter);
1507         }
1508
1509         ARGB* argbs = (ARGB*) new ARGB[count];
1510         if(argbs)
1511         {
1512             for(INT i = 0; i < count; i++)
1513             {
1514                 argbs[i] = presetColors[i].GetValue();
1515             }
1516
1517             Status status = SetStatus(DllExports::GdipSetPathGradientPresetBlend(
1518                                     (GpPathGradient*) nativeBrush,
1519                                     argbs,
1520                                     blendPositions,
1521                                     count));
1522             delete[] argbs;
1523             return status;
1524         }
1525         else
1526         {
1527             return SetStatus(OutOfMemory);
1528         }
1529     }
1530
1531     Status GetInterpolationColors(OUT Color* presetColors,
1532                                   OUT REAL* blendPositions, 
1533                                   IN INT count) const
1534     {
1535         if ((count <= 0) || !presetColors) 
1536         {
1537             return SetStatus(InvalidParameter);
1538         }
1539
1540         ARGB* argbs = (ARGB*) new ARGB[count];
1541         
1542         if (!argbs)
1543         {
1544             return SetStatus(OutOfMemory);
1545         }
1546
1547         GpStatus status = SetStatus(DllExports::GdipGetPathGradientPresetBlend(
1548                                 (GpPathGradient*)nativeBrush,
1549                                 argbs,
1550                                 blendPositions,
1551                                 count));
1552         
1553         for(INT i = 0; i < count; i++)
1554         {
1555             presetColors[i] = Color(argbs[i]);
1556         }
1557         delete [] argbs;
1558         
1559         return status;
1560     }
1561
1562     Status SetBlendBellShape(IN REAL focus, 
1563                              IN REAL scale = 1.0)
1564     {
1565         return SetStatus(DllExports::GdipSetPathGradientSigmaBlend(
1566                             (GpPathGradient*)nativeBrush, focus, scale));
1567     }
1568
1569     #ifdef DCR_USE_NEW_145135
1570     Status SetBlendTriangularShape(
1571         IN REAL focus,
1572         IN REAL scale = 1.0
1573     )
1574     #else
1575     Status SetBlendTrianglarShape(IN REAL focus,
1576                                   IN REAL scale = 1.0)
1577     #endif                              
1578     {
1579         return SetStatus(DllExports::GdipSetPathGradientLinearBlend(
1580                             (GpPathGradient*)nativeBrush, focus, scale));
1581     }
1582
1583     /**
1584      * Get/set brush transform
1585      */
1586     Status GetTransform(OUT Matrix *matrix) const
1587     {
1588         return SetStatus(DllExports::GdipGetPathGradientTransform(
1589                             (GpPathGradient*) nativeBrush, matrix->nativeMatrix));
1590     }
1591
1592     Status SetTransform(IN const Matrix* matrix)
1593     {
1594         return SetStatus(DllExports::GdipSetPathGradientTransform(
1595                             (GpPathGradient*) nativeBrush, matrix->nativeMatrix));
1596     }
1597
1598     Status ResetTransform()
1599     {
1600         return SetStatus(DllExports::GdipResetPathGradientTransform((GpPathGradient*)nativeBrush));
1601     }
1602
1603     Status MultiplyTransform(IN const Matrix* matrix,
1604                              IN MatrixOrder order = MatrixOrderPrepend)
1605     {
1606         return SetStatus(DllExports::GdipMultiplyPathGradientTransform((GpPathGradient*)nativeBrush,
1607                                                                 matrix->nativeMatrix,
1608                                                                 order));
1609     }
1610
1611     Status TranslateTransform(IN REAL dx, 
1612                               IN REAL dy,
1613                               IN MatrixOrder order = MatrixOrderPrepend)
1614     {
1615         return SetStatus(DllExports::GdipTranslatePathGradientTransform((GpPathGradient*)nativeBrush,
1616                                                                dx, dy, order));
1617     }
1618
1619     Status ScaleTransform(IN REAL sx, 
1620                           IN REAL sy,
1621                           IN MatrixOrder order = MatrixOrderPrepend)
1622     {
1623         return SetStatus(DllExports::GdipScalePathGradientTransform((GpPathGradient*)nativeBrush,
1624                                                              sx, sy, order));
1625     }
1626
1627     Status RotateTransform(IN REAL angle, 
1628                            IN MatrixOrder order = MatrixOrderPrepend)
1629     {
1630         return SetStatus(DllExports::GdipRotatePathGradientTransform((GpPathGradient*)nativeBrush,
1631                                                               angle, order));
1632     }
1633
1634     /**
1635      * Get/set brush focus scales
1636      */
1637     Status GetFocusScales(OUT REAL* xScale, 
1638                           OUT REAL* yScale) const
1639     {
1640         return SetStatus(DllExports::GdipGetPathGradientFocusScales(
1641                             (GpPathGradient*) nativeBrush, xScale, yScale));
1642     }
1643
1644     Status SetFocusScales(IN REAL xScale,
1645                           IN REAL yScale)
1646     {
1647         return SetStatus(DllExports::GdipSetPathGradientFocusScales(
1648                             (GpPathGradient*) nativeBrush, xScale, yScale));
1649     }
1650
1651     /**
1652      * Get/set brush wrapping mode
1653      */
1654     WrapMode GetWrapMode() const
1655     {
1656         WrapMode wrapMode;
1657
1658         SetStatus(DllExports::GdipGetPathGradientWrapMode(
1659                      (GpPathGradient*) nativeBrush, &wrapMode));
1660
1661         return wrapMode;
1662     }
1663
1664     Status SetWrapMode(IN WrapMode wrapMode)
1665     {
1666         return SetStatus(DllExports::GdipSetPathGradientWrapMode(
1667                             (GpPathGradient*) nativeBrush, wrapMode));
1668     }
1669
1670 #ifdef DCR_USE_NEW_250932
1671
1672 private:
1673     PathGradientBrush(const PathGradientBrush &);
1674     PathGradientBrush& operator=(const PathGradientBrush &);
1675
1676 #endif
1677
1678 protected:
1679
1680     PathGradientBrush()
1681     {
1682     }
1683 };
1684
1685
1686 #endif // !_GRAPHICSPATH_HPP