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