sdk/include/psdk/gdipluspath.h

   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
  22 class FontFamily;
  23 class Graphics;
  24
  25 class GraphicsPath : public GdiplusBase
  26 {
  27   friend class Region;
  28
  29 public:
  30   GraphicsPath(const Point *points, const BYTE *types, INT count, FillMode fillMode)
  31   {
  32   }
  33
  34   GraphicsPath(FillMode fillMode)
  35   {
  36   }
  37
  38   GraphicsPath(const PointF *points, const BYTE *types, INT count, FillMode fillMode)
  39   {
  40   }
  41
  42   Status AddArc(const Rect &rect, REAL startAngle, REAL sweepAngle)
  43   {
  44     return NotImplemented;
  45   }
  46
  47   Status AddArc(const RectF &rect, REAL startAngle, REAL sweepAngle)
  48   {
  49     return NotImplemented;
  50   }
  51
  52   Status AddArc(INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
  53   {
  54     return NotImplemented;
  55   }
  56
  57   Status AddArc(REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
  58   {
  59     return NotImplemented;
  60   }
  61
  62   Status AddBezier(const Point &pt1, const Point &pt2, const Point &pt3, const Point &pt4)
  63   {
  64     return NotImplemented;
  65   }
  66
  67   Status AddBezier(REAL x1, REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
  68   {
  69     return NotImplemented;
  70   }
  71
  72   Status AddBezier(const PointF &pt1, const PointF &pt2, const PointF &pt3, const PointF &pt4)
  73   {
  74     return NotImplemented;
  75   }
  76
  77   Status AddBezier(INT x1, INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
  78   {
  79     return NotImplemented;
  80   }
  81
  82   Status AddBeziers(const Point *points, INT count)
  83   {
  84     return NotImplemented;
  85   }
  86
  87   Status AddBeziers(const PointF *points, INT count)
  88   {
  89     return NotImplemented;
  90   }
  91
  92   Status AddClosedCurve(const Point *points, INT count)
  93   {
  94     return NotImplemented;
  95   }
  96
  97   Status AddClosedCurve(const Point *points, INT count, REAL tension)
  98   {
  99     return NotImplemented;
 100   }
 101
 102   Status AddClosedCurve(const PointF *points, INT count, REAL tension)
 103   {
 104     return NotImplemented;
 105   }
 106
 107   Status AddClosedCurve(const PointF *points, INT count)
 108   {
 109     return NotImplemented;
 110   }
 111
 112   Status AddCurve(const Point *points, INT count)
 113   {
 114     return NotImplemented;
 115   }
 116
 117   Status AddCurve(const PointF *points, INT count, REAL tension)
 118   {
 119     return NotImplemented;
 120   }
 121
 122   Status AddCurve(const PointF *points, INT count)
 123   {
 124     return NotImplemented;
 125   }
 126
 127   Status AddCurve(const Point *points, INT count, INT offset, INT numberOfSegments, REAL tension)
 128   {
 129     return NotImplemented;
 130   }
 131
 132   Status AddCurve(const Point *points, INT count, REAL tension)
 133   {
 134     return NotImplemented;
 135   }
 136
 137   Status AddCurve(const PointF *points, INT count, INT offset, INT numberOfSegments, REAL tension)
 138   {
 139     return NotImplemented;
 140   }
 141
 142   Status AddEllipse(const Rect &rect)
 143   {
 144     return NotImplemented;
 145   }
 146
 147   Status AddEllipse(const RectF &rect)
 148   {
 149     return NotImplemented;
 150   }
 151
 152   Status AddEllipse(INT x, INT y, INT width, INT height)
 153   {
 154     return NotImplemented;
 155   }
 156
 157   Status AddEllipse(REAL x, REAL y, REAL width, REAL height)
 158   {
 159     return NotImplemented;
 160   }
 161
 162   Status AddLine(const Point &pt1, const Point &pt2)
 163   {
 164     return NotImplemented;
 165   }
 166
 167   Status AddLine(const PointF &pt1, const PointF &pt2)
 168   {
 169     return NotImplemented;
 170   }
 171
 172   Status AddLine(REAL x1, REAL y1, REAL x2, REAL y2)
 173   {
 174     return NotImplemented;
 175   }
 176
 177   Status AddLine(INT x1, INT y1, INT x2, INT y2)
 178   {
 179     return NotImplemented;
 180   }
 181
 182   Status AddLines(const Point *points, INT count)
 183   {
 184     return NotImplemented;
 185   }
 186
 187   Status AddLines(const PointF *points, INT count)
 188   {
 189     return NotImplemented;
 190   }
 191
 192   Status AddPath(const GraphicsPath *addingPath, BOOL connect)
 193   {
 194     return NotImplemented;
 195   }
 196
 197   Status AddPie(const Rect &rect, REAL startAngle, REAL sweepAngle)
 198   {
 199     return NotImplemented;
 200   }
 201
 202   Status AddPie(INT x, INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
 203   {
 204     return NotImplemented;
 205   }
 206
 207   Status AddPie(REAL x, REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
 208   {
 209     return NotImplemented;
 210   }
 211
 212   Status AddPie(const RectF &rect, REAL startAngle, REAL sweepAngle)
 213   {
 214     return NotImplemented;
 215   }
 216
 217   Status AddPolygon(const Point *points, INT count)
 218   {
 219     return NotImplemented;
 220   }
 221
 222   Status AddPolygon(const PointF *points, INT count)
 223   {
 224     return NotImplemented;
 225   }
 226
 227   Status AddRectangle(const Rect &rect)
 228   {
 229     return NotImplemented;
 230   }
 231
 232   Status AddRectangle(const RectF &rect)
 233   {
 234     return NotImplemented;
 235   }
 236
 237   Status AddRectangles(const Rect *rects, INT count)
 238   {
 239     return NotImplemented;
 240   }
 241
 242   Status AddRectangles(const RectF *rects, INT count)
 243   {
 244     return NotImplemented;
 245   }
 246
 247   Status AddString(const WCHAR *string, INT length, const FontFamily *family, INT style, REAL emSize, const Rect &layoutRect, const StringFormat *format)
 248   {
 249     return NotImplemented;
 250   }
 251
 252   Status AddString(const WCHAR *string, INT length, const FontFamily *family, INT style, REAL emSize, const PointF &origin, const StringFormat *format)
 253   {
 254     return NotImplemented;
 255   }
 256
 257   Status AddString(const WCHAR *string, INT length, const FontFamily *family, INT style, REAL emSize, const Point &origin, const StringFormat *format)
 258   {
 259     return NotImplemented;
 260   }
 261
 262   Status AddString(const WCHAR *string, INT length, const FontFamily *family, INT style, REAL emSize, const RectF &layoutRect, const StringFormat *format)
 263   {
 264     return NotImplemented;
 265   }
 266
 267   Status ClearMarkers(VOID)
 268   {
 269     return NotImplemented;
 270   }
 271
 272   GraphicsPath *Clone(VOID)
 273   {
 274     return NULL;
 275   }
 276
 277   Status CloseAllFigures(VOID)
 278   {
 279     return NotImplemented;
 280   }
 281
 282   Status CloseFigure(VOID)
 283   {
 284     return NotImplemented;
 285   }
 286
 287   Status Flatten(const Matrix *matrix, REAL flatness)
 288   {
 289     return NotImplemented;
 290   }
 291
 292   Status GetBounds(Rect *bounds, const Matrix *matrix, const Pen *pen)
 293   {
 294     return NotImplemented;
 295   }
 296
 297   Status GetBounds(RectF *bounds, const Matrix *matrix, const Pen *pen)
 298   {
 299     return NotImplemented;
 300   }
 301
 302   FillMode GetFillMode(VOID)
 303   {
 304     return FillModeAlternate;
 305   }
 306
 307   Status GetLastPoint(PointF *lastPoint)
 308   {
 309     return NotImplemented;
 310   }
 311
 312   Status GetLastStatus(VOID)
 313   {
 314     return NotImplemented;
 315   }
 316
 317   Status GetPathData(PathData *pathData)
 318   {
 319     return NotImplemented;
 320   }
 321
 322   Status GetPathPoints(Point *points, INT count)
 323   {
 324     return NotImplemented;
 325   }
 326
 327   Status GetPathPoints(PointF *points, INT count)
 328   {
 329     return NotImplemented;
 330   }
 331
 332   Status GetPathTypes(BYTE *types, INT count)
 333   {
 334     return NotImplemented;
 335   }
 336
 337   INT GetPointCount(VOID)
 338   {
 339     return 0;
 340   }
 341
 342   BOOL IsOutlineVisible(const Point &point, const Pen *pen, const Graphics *g)
 343   {
 344     return FALSE;
 345   }
 346
 347   BOOL IsOutlineVisible(REAL x, REAL y, const Pen *pen, const Graphics *g)
 348   {
 349     return FALSE;
 350   }
 351
 352   BOOL IsOutlineVisible(INT x, INT y, const Pen *pen, const Graphics *g)
 353   {
 354     return FALSE;
 355   }
 356
 357   BOOL IsOutlineVisible(const PointF &point, const Pen *pen, const Graphics *g)
 358   {
 359     return FALSE;
 360   }
 361
 362   BOOL IsVisible(REAL x, REAL y, const Graphics *g)
 363   {
 364     return FALSE;
 365   }
 366
 367   BOOL IsVisible(const PointF &point, const Graphics *g)
 368   {
 369     return FALSE;
 370   }
 371
 372   BOOL IsVisible(INT x, INT y, const Graphics *g)
 373   {
 374     return FALSE;
 375   }
 376
 377   BOOL IsVisible(const Point &point, const Graphics *g)
 378   {
 379     return NotImplemented;
 380   }
 381
 382   Status Outline(const Matrix *matrix, REAL flatness)
 383   {
 384     return NotImplemented;
 385   }
 386
 387   Status Reset(VOID)
 388   {
 389     return NotImplemented;
 390   }
 391
 392   Status Reverse(VOID)
 393   {
 394     return NotImplemented;
 395   }
 396
 397   Status SetFillMode(FillMode fillmode)
 398   {
 399     return NotImplemented;
 400   }
 401
 402   Status SetMarker(VOID)
 403   {
 404     return NotImplemented;
 405   }
 406
 407   Status StartFigure(VOID)
 408   {
 409     return NotImplemented;
 410   }
 411
 412   Status Transform(const Matrix *matrix)
 413   {
 414     return NotImplemented;
 415   }
 416
 417   Status Warp(const PointF *destPoints, INT count, const RectF &srcRect, const Matrix *matrix, WarpMode warpMode, REAL flatness)
 418   {
 419     return NotImplemented;
 420   }
 421
 422   Status Widen(const Pen *pen, const Matrix *matrix, REAL flatness)
 423   {
 424     return NotImplemented;
 425   }
 426
 427 private:
 428   GpPath *path;
 429 };
 430
 431
 432 class GraphicsPathIterator : public GdiplusBase
 433 {
 434 public:
 435   GraphicsPathIterator(GraphicsPath *path)
 436   {
 437   }
 438
 439   INT CopyData(PointF *points, BYTE *types, INT startIndex, INT endIndex)
 440   {
 441     return 0;
 442   }
 443
 444   INT Enumerate(PointF *points, BYTE *types, INT count)
 445   {
 446     return 0;
 447   }
 448
 449   INT GetCount(VOID)
 450   {
 451     return 0;
 452   }
 453
 454   Status GetLastStatus(VOID)
 455   {
 456     return NotImplemented;
 457   }
 458
 459   INT GetSubpathCount(VOID)
 460   {
 461     return 0;
 462   }
 463
 464   BOOL HasCurve(VOID)
 465   {
 466     return FALSE;
 467   }
 468
 469   INT NextMarker(GraphicsPath *path)
 470   {
 471     return 0;
 472   }
 473
 474   INT NextMarker(INT *startIndex, INT *endIndex)
 475   {
 476     return 0;
 477   }
 478
 479   INT NextPathType(BYTE *pathType, INT *startIndex, INT *endIndex)
 480   {
 481     return 0;
 482   }
 483
 484   INT NextSubpath(GraphicsPath *path, BOOL *isClosed)
 485   {
 486     return 0;
 487   }
 488
 489   INT NextSubpath(INT *startIndex, INT *endIndex, BOOL *isClosed)
 490   {
 491     return 0;
 492   }
 493
 494   VOID Rewind(VOID)
 495   {
 496   }
 497 };
 498
 499
 500 class PathGradientBrush : public Brush
 501 {
 502 public:
 503   PathGradientBrush(const Point *points, INT count, WrapMode wrapMode)
 504   {
 505   }
 506
 507   PathGradientBrush(const PointF *points, INT count, WrapMode wrapMode)
 508   {
 509   }
 510
 511   PathGradientBrush(const GraphicsPath *path)
 512   {
 513   }
 514
 515   INT GetBlendCount(VOID)
 516   {
 517     return 0;
 518   }
 519
 520   Status GetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
 521   {
 522     return NotImplemented;
 523   }
 524
 525   Status GetCenterColor(Color *color)
 526   {
 527     return NotImplemented;
 528   }
 529
 530   Status GetCenterPoint(Point *point)
 531   {
 532     return NotImplemented;
 533   }
 534
 535   Status GetCenterPoint(PointF *point)
 536   {
 537     return NotImplemented;
 538   }
 539
 540   Status GetFocusScales(REAL *xScale, REAL *yScale)
 541   {
 542     return NotImplemented;
 543   }
 544
 545   BOOL GetGammaCorrection(VOID)
 546   {
 547     return FALSE;
 548   }
 549
 550   Status GetGraphicsPath(GraphicsPath *path)
 551   {
 552     return NotImplemented;
 553   }
 554
 555   INT GetInterpolationColorCount(VOID)
 556   {
 557     return 0;
 558   }
 559
 560   Status GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count)
 561   {
 562     return NotImplemented;
 563   }
 564
 565   INT GetPointCount(VOID)
 566   {
 567     return 0;
 568   }
 569
 570   Status GetRectangle(RectF *rect)
 571   {
 572     return NotImplemented;
 573   }
 574
 575   Status GetRectangle(Rect *rect)
 576   {
 577     return NotImplemented;
 578   }
 579
 580   INT GetSurroundColorCount(VOID)
 581   {
 582     return 0;
 583   }
 584
 585   Status GetSurroundColors(Color *colors, INT *count)
 586   {
 587     return NotImplemented;
 588   }
 589
 590   Status GetTransform(Matrix *matrix)
 591   {
 592     return NotImplemented;
 593   }
 594
 595   WrapMode GetWrapMode(VOID)
 596   {
 597     return WrapModeTile;
 598   }
 599
 600   Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
 601   {
 602     return NotImplemented;
 603   }
 604
 605   Status ResetTransform(VOID)
 606   {
 607     return NotImplemented;
 608   }
 609
 610   Status RotateTransform(REAL angle, MatrixOrder order)
 611   {
 612     return NotImplemented;
 613   }
 614
 615   Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
 616   {
 617     return NotImplemented;
 618   }
 619
 620   Status SetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
 621   {
 622     return NotImplemented;
 623   }
 624
 625   Status SetBlendBellShape(REAL focus, REAL scale)
 626   {
 627     return NotImplemented;
 628   }
 629
 630   Status SetBlendTriangularShape(REAL focus, REAL scale)
 631   {
 632     return NotImplemented;
 633   }
 634
 635   Status SetCenterColor(const Color &color)
 636   {
 637     return NotImplemented;
 638   }
 639
 640   Status SetCenterPoint(const Point &point)
 641   {
 642     return NotImplemented;
 643   }
 644
 645   Status SetCenterPoint(const PointF &point)
 646   {
 647     return NotImplemented;
 648   }
 649
 650   Status SetFocusScales(REAL xScale, REAL yScale)
 651   {
 652     return NotImplemented;
 653   }
 654
 655   Status SetGammaCorrection(BOOL useGammaCorrection)
 656   {
 657     return NotImplemented;
 658   }
 659
 660   Status SetGraphicsPath(const GraphicsPath* path)
 661   {
 662     return NotImplemented;
 663   }
 664
 665   Status SetInterpolationColors(const Color *presetColors, REAL *blendPositions, INT count)
 666   {
 667     return NotImplemented;
 668   }
 669
 670   Status SetSurroundColors(const Color *colors, INT *count)
 671   {
 672     return NotImplemented;
 673   }
 674
 675   Status SetTransform(const Matrix *matrix)
 676   {
 677     return NotImplemented;
 678   }
 679
 680   Status SetWrapMode(WrapMode wrapMode)
 681   {
 682     return NotImplemented;
 683   }
 684
 685   Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
 686   {
 687     return NotImplemented;
 688   }
 689 };
 690
 691 #endif /* _GDIPLUSPATH_H */