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