reactos/lib/gdiplus/gdiplus/path.c

   1 #include <windows.h>
   2 #include <GdiPlusPrivate.h>
   3 #include <debug.h>
   4
   5 /*
   6  * @unimplemented
   7  */
   8 GpStatus WINGDIPAPI
   9 GdipCreatePath2(GDIPCONST GpPointF* points,
  10   GDIPCONST BYTE* types,
  11   INT count,
  12   GpFillMode fillMode,
  13   GpPath **path)
  14 {
  15   return NotImplemented;
  16 }
  17
  18 /*
  19  * @unimplemented
  20  */
  21 GpStatus WINGDIPAPI
  22 GdipCreatePath2I(GDIPCONST GpPoint* points,
  23   GDIPCONST BYTE* types,
  24   INT count,
  25   GpFillMode fillMode,
  26   GpPath **path)
  27 {
  28   return NotImplemented;
  29 }
  30
  31 /*
  32  * @unimplemented
  33  */
  34 GpStatus WINGDIPAPI
  35 GdipClonePath(GpPath* path,
  36   GpPath **clonePath)
  37 {
  38   return NotImplemented;
  39 }
  40
  41 /*
  42  * @unimplemented
  43  */
  44 GpStatus WINGDIPAPI
  45 GdipDeletePath(GpPath* path)
  46 {
  47   return NotImplemented;
  48 }
  49
  50 /*
  51  * @unimplemented
  52  */
  53 GpStatus WINGDIPAPI
  54 GdipResetPath(GpPath* path)
  55 {
  56   return NotImplemented;
  57 }
  58
  59 /*
  60  * @unimplemented
  61  */
  62 GpStatus WINGDIPAPI
  63 GdipGetPointCount(GpPath* path,
  64   INT* count)
  65 {
  66   return NotImplemented;
  67 }
  68
  69 /*
  70  * @unimplemented
  71  */
  72 GpStatus WINGDIPAPI
  73 GdipGetPathTypes(GpPath* path,
  74   BYTE* types,
  75   INT count)
  76 {
  77   return NotImplemented;
  78 }
  79
  80 /*
  81  * @unimplemented
  82  */
  83 GpStatus WINGDIPAPI
  84 GdipGetPathPoints(GpPath* path,
  85   GpPointF* points,
  86   INT count)
  87 {
  88   return NotImplemented;
  89 }
  90
  91 /*
  92  * @unimplemented
  93  */
  94 GpStatus WINGDIPAPI
  95 GdipGetPathPointsI(GpPath* path,
  96   GpPoint* points,
  97   INT count)
  98 {
  99   return NotImplemented;
 100 }
 101
 102 /*
 103  * @unimplemented
 104  */
 105 GpStatus WINGDIPAPI
 106 GdipGetPathFillMode(GpPath *path,
 107   GpFillMode *fillmode)
 108 {
 109   return NotImplemented;
 110 }
 111
 112 /*
 113  * @unimplemented
 114  */
 115 GpStatus WINGDIPAPI
 116 GdipSetPathFillMode(GpPath *path,
 117   GpFillMode fillmode)
 118 {
 119   return NotImplemented;
 120 }
 121
 122 /*
 123  * @unimplemented
 124  */
 125 GpStatus WINGDIPAPI
 126 GdipGetPathData(GpPath *path,
 127   GpPathData* pathData)
 128 {
 129   return NotImplemented;
 130 }
 131
 132 /*
 133  * @unimplemented
 134  */
 135 GpStatus WINGDIPAPI
 136 GdipStartPathFigure(GpPath *path)
 137 {
 138   return NotImplemented;
 139 }
 140
 141 /*
 142  * @unimplemented
 143  */
 144 GpStatus WINGDIPAPI
 145 GdipClosePathFigure(GpPath *path)
 146 {
 147   return NotImplemented;
 148 }
 149
 150 /*
 151  * @unimplemented
 152  */
 153 GpStatus WINGDIPAPI
 154 GdipClosePathFigures(GpPath *path)
 155 {
 156   return NotImplemented;
 157 }
 158
 159 /*
 160  * @unimplemented
 161  */
 162 GpStatus WINGDIPAPI
 163 GdipSetPathMarker(GpPath* path)
 164 {
 165   return NotImplemented;
 166 }
 167
 168 /*
 169  * @unimplemented
 170  */
 171 GpStatus WINGDIPAPI
 172 GdipClearPathMarkers(GpPath* path)
 173 {
 174   return NotImplemented;
 175 }
 176
 177 /*
 178  * @unimplemented
 179  */
 180 GpStatus WINGDIPAPI
 181 GdipReversePath(GpPath* path)
 182 {
 183   return NotImplemented;
 184 }
 185
 186 /*
 187  * @unimplemented
 188  */
 189 GpStatus WINGDIPAPI
 190 GdipGetPathLastPoint(GpPath* path,
 191   GpPointF* lastPoint)
 192 {
 193   return NotImplemented;
 194 }
 195
 196 /*
 197  * @unimplemented
 198  */
 199 GpStatus WINGDIPAPI
 200 GdipAddPathLine(GpPath *path,
 201   REAL x1,
 202   REAL y1,
 203   REAL x2,
 204   REAL y2)
 205 {
 206   return NotImplemented;
 207 }
 208
 209 /*
 210  * @unimplemented
 211  */
 212 GpStatus WINGDIPAPI
 213 GdipAddPathLine2(GpPath *path,
 214   GDIPCONST GpPointF *points,
 215   INT count)
 216 {
 217   return NotImplemented;
 218 }
 219
 220 /*
 221  * @unimplemented
 222  */
 223 GpStatus WINGDIPAPI
 224 GdipAddPathArc(GpPath *path,
 225   REAL x,
 226   REAL y,
 227   REAL width,
 228   REAL height,
 229   REAL startAngle,
 230   REAL sweepAngle)
 231 {
 232   return NotImplemented;
 233 }
 234
 235 /*
 236  * @unimplemented
 237  */
 238 GpStatus WINGDIPAPI
 239 GdipAddPathBezier(GpPath *path,
 240   REAL x1,
 241   REAL y1,
 242   REAL x2,
 243   REAL y2,
 244   REAL x3,
 245   REAL y3,
 246   REAL x4,
 247   REAL y4)
 248 {
 249   return NotImplemented;
 250 }
 251
 252 /*
 253  * @unimplemented
 254  */
 255 GpStatus WINGDIPAPI
 256 GdipAddPathBeziers(GpPath *path,
 257   GDIPCONST GpPointF *points,
 258   INT count)
 259 {
 260   return NotImplemented;
 261 }
 262
 263 /*
 264  * @unimplemented
 265  */
 266 GpStatus WINGDIPAPI
 267 GdipAddPathCurve(GpPath *path,
 268   GDIPCONST GpPointF *points,
 269   INT count)
 270 {
 271   return NotImplemented;
 272 }
 273
 274 /*
 275  * @unimplemented
 276  */
 277 GpStatus WINGDIPAPI
 278 GdipAddPathCurve2(GpPath *path,
 279   GDIPCONST GpPointF *points,
 280   INT count,
 281   REAL tension)
 282 {
 283   return NotImplemented;
 284 }
 285
 286 /*
 287  * @unimplemented
 288  */
 289 GpStatus WINGDIPAPI
 290 GdipAddPathCurve3(GpPath *path,
 291   GDIPCONST GpPointF *points,
 292   INT count,
 293   INT offset,
 294   INT numberOfSegments,
 295   REAL tension)
 296 {
 297   return NotImplemented;
 298 }
 299
 300 /*
 301  * @unimplemented
 302  */
 303 GpStatus WINGDIPAPI
 304 GdipAddPathClosedCurve(GpPath *path,
 305   GDIPCONST GpPointF *points,
 306   INT count)
 307 {
 308   return NotImplemented;
 309 }
 310
 311 /*
 312  * @unimplemented
 313  */
 314 GpStatus WINGDIPAPI
 315 GdipAddPathClosedCurve2(GpPath *path,
 316   GDIPCONST GpPointF *points,
 317   INT count,
 318   REAL tension)
 319 {
 320   return NotImplemented;
 321 }
 322
 323 /*
 324  * @unimplemented
 325  */
 326 GpStatus WINGDIPAPI
 327 GdipAddPathRectangle(GpPath *path,
 328   REAL x,
 329   REAL y,
 330   REAL width,
 331   REAL height)
 332 {
 333   return NotImplemented;
 334 }
 335
 336 /*
 337  * @unimplemented
 338  */
 339 GpStatus WINGDIPAPI
 340 GdipAddPathRectangles(GpPath *path,
 341   GDIPCONST GpRectF *rects,
 342   INT count)
 343 {
 344   return NotImplemented;
 345 }
 346
 347 /*
 348  * @unimplemented
 349  */
 350 GpStatus WINGDIPAPI
 351 GdipAddPathEllipse(GpPath *path,
 352   REAL x,
 353   REAL y,
 354   REAL width,
 355   REAL height)
 356 {
 357   return NotImplemented;
 358 }
 359
 360 /*
 361  * @unimplemented
 362  */
 363 GpStatus WINGDIPAPI
 364 GdipAddPathPie(GpPath *path,
 365   REAL x,
 366   REAL y,
 367   REAL width,
 368   REAL height,
 369   REAL startAngle,
 370   REAL sweepAngle)
 371 {
 372   return NotImplemented;
 373 }
 374
 375 /*
 376  * @unimplemented
 377  */
 378 GpStatus WINGDIPAPI
 379 GdipAddPathPolygon(GpPath *path,
 380   GDIPCONST GpPointF *points,
 381   INT count)
 382 {
 383   return NotImplemented;
 384 }
 385
 386 /*
 387  * @unimplemented
 388  */
 389 GpStatus WINGDIPAPI
 390 GdipAddPathPath(GpPath *path,
 391   GDIPCONST GpPath* addingPath,
 392   BOOL connect)
 393 {
 394   return NotImplemented;
 395 }
 396
 397 /*
 398  * @unimplemented
 399  */
 400 GpStatus WINGDIPAPI
 401 GdipAddPathString(GpPath *path,
 402   GDIPCONST WCHAR *string,
 403   INT length,
 404   GDIPCONST GpFontFamily *family,
 405   INT style,
 406   REAL emSize,
 407   GDIPCONST RectF *layoutRect,
 408   GDIPCONST GpStringFormat *format)
 409 {
 410   return NotImplemented;
 411 }
 412
 413 /*
 414  * @unimplemented
 415  */
 416 GpStatus WINGDIPAPI
 417 GdipAddPathStringI(GpPath *path,
 418   GDIPCONST WCHAR *string,
 419   INT length,
 420   GDIPCONST GpFontFamily *family,
 421   INT style,
 422   REAL emSize,
 423   GDIPCONST Rect *layoutRect,
 424   GDIPCONST GpStringFormat *format)
 425 {
 426   return NotImplemented;
 427 }
 428
 429 /*
 430  * @unimplemented
 431  */
 432 GpStatus WINGDIPAPI
 433 GdipAddPathLineI(GpPath *path,
 434   INT x1,
 435   INT y1,
 436   INT x2,
 437   INT y2)
 438 {
 439   return NotImplemented;
 440 }
 441
 442 /*
 443  * @unimplemented
 444  */
 445 GpStatus WINGDIPAPI
 446 GdipAddPathLine2I(GpPath *path,
 447   GDIPCONST GpPoint *points,
 448   INT count)
 449 {
 450   return NotImplemented;
 451 }
 452
 453 /*
 454  * @unimplemented
 455  */
 456 GpStatus WINGDIPAPI
 457 GdipAddPathArcI(GpPath *path,
 458   INT x,
 459   INT y,
 460   INT width,
 461   INT height,
 462   REAL startAngle,
 463   REAL sweepAngle)
 464 {
 465   return NotImplemented;
 466 }
 467
 468 /*
 469  * @unimplemented
 470  */
 471 GpStatus WINGDIPAPI
 472 GdipAddPathBezierI(GpPath *path,
 473   INT x1,
 474   INT y1,
 475   INT x2,
 476   INT y2,
 477   INT x3,
 478   INT y3,
 479   INT x4,
 480   INT y4)
 481 {
 482   return NotImplemented;
 483 }
 484
 485 /*
 486  * @unimplemented
 487  */
 488 GpStatus WINGDIPAPI
 489 GdipAddPathBeziersI(GpPath *path,
 490   GDIPCONST GpPoint *points,
 491   INT count)
 492 {
 493   return NotImplemented;
 494 }
 495
 496 /*
 497  * @unimplemented
 498  */
 499 GpStatus WINGDIPAPI
 500 GdipAddPathCurveI(GpPath *path,
 501   GDIPCONST GpPoint *points,
 502   INT count)
 503 {
 504   return NotImplemented;
 505 }
 506
 507 /*
 508  * @unimplemented
 509  */
 510 GpStatus WINGDIPAPI
 511 GdipAddPathCurve2I(GpPath *path,
 512   GDIPCONST GpPoint *points,
 513   INT count,
 514   REAL tension)
 515 {
 516   return NotImplemented;
 517 }
 518
 519 /*
 520  * @unimplemented
 521  */
 522 GpStatus WINGDIPAPI
 523 GdipAddPathCurve3I(GpPath *path,
 524   GDIPCONST GpPoint *points,
 525   INT count,
 526   INT offset,
 527   INT numberOfSegments,
 528   REAL tension)
 529 {
 530   return NotImplemented;
 531 }
 532
 533 /*
 534  * @unimplemented
 535  */
 536 GpStatus WINGDIPAPI
 537 GdipAddPathClosedCurveI(GpPath *path,
 538   GDIPCONST GpPoint *points,
 539   INT count)
 540 {
 541   return NotImplemented;
 542 }
 543
 544 /*
 545  * @unimplemented
 546  */
 547 GpStatus WINGDIPAPI
 548 GdipAddPathClosedCurve2I(GpPath *path,
 549   GDIPCONST GpPoint *points,
 550   INT count,
 551   REAL tension)
 552 {
 553   return NotImplemented;
 554 }
 555
 556 /*
 557  * @unimplemented
 558  */
 559 GpStatus WINGDIPAPI
 560 GdipAddPathRectangleI(GpPath *path,
 561   INT x,
 562   INT y,
 563   INT width,
 564   INT height)
 565 {
 566   return NotImplemented;
 567 }
 568
 569 /*
 570  * @unimplemented
 571  */
 572 GpStatus WINGDIPAPI
 573 GdipAddPathRectanglesI(GpPath *path,
 574   GDIPCONST GpRect *rects,
 575   INT count)
 576 {
 577   return NotImplemented;
 578 }
 579
 580 /*
 581  * @unimplemented
 582  */
 583 GpStatus WINGDIPAPI
 584 GdipAddPathEllipseI(GpPath *path,
 585   INT x,
 586   INT y,
 587   INT width,
 588   INT height)
 589 {
 590   return NotImplemented;
 591 }
 592
 593 /*
 594  * @unimplemented
 595  */
 596 GpStatus WINGDIPAPI
 597 GdipAddPathPieI(GpPath *path,
 598   INT x,
 599   INT y,
 600   INT width,
 601   INT height,
 602   REAL startAngle,
 603   REAL sweepAngle)
 604 {
 605   return NotImplemented;
 606 }
 607
 608 /*
 609  * @unimplemented
 610  */
 611 GpStatus WINGDIPAPI
 612 GdipAddPathPolygonI(GpPath *path,
 613   GDIPCONST GpPoint *points,
 614   INT count)
 615 {
 616   return NotImplemented;
 617 }
 618
 619 /*
 620  * @unimplemented
 621  */
 622 GpStatus WINGDIPAPI
 623 GdipFlattenPath(GpPath *path,
 624   GpMatrix* matrix,
 625   REAL flatness)
 626 {
 627   return NotImplemented;
 628 }
 629
 630 /*
 631  * @unimplemented
 632  */
 633 GpStatus WINGDIPAPI
 634 GdipWindingModeOutline(GpPath *path,
 635   GpMatrix *matrix,
 636   REAL flatness)
 637 {
 638   return NotImplemented;
 639 }
 640
 641 /*
 642  * @unimplemented
 643  */
 644 GpStatus WINGDIPAPI
 645 GdipWidenPath(GpPath *nativePath,
 646   GpPen *pen,
 647   GpMatrix *matrix,
 648   REAL flatness)
 649 {
 650   return NotImplemented;
 651 }
 652
 653 /*
 654  * @unimplemented
 655  */
 656 GpStatus WINGDIPAPI
 657 GdipWarpPath(GpPath *path,
 658   GpMatrix* matrix,
 659   GDIPCONST GpPointF *points,
 660   INT count,
 661   REAL srcx,
 662   REAL srcy,
 663   REAL srcwidth,
 664   REAL srcheight,
 665   WarpMode warpMode,
 666   REAL flatness)
 667 {
 668   return NotImplemented;
 669 }
 670
 671 /*
 672  * @unimplemented
 673  */
 674 GpStatus WINGDIPAPI
 675 GdipTransformPath(GpPath* path,
 676   GpMatrix* matrix)
 677 {
 678   return NotImplemented;
 679 }
 680
 681 /*
 682  * @unimplemented
 683  */
 684 GpStatus WINGDIPAPI
 685 GdipGetPathWorldBounds(GpPath* path,
 686   GpRectF* bounds,
 687   GDIPCONST GpMatrix *matrix,
 688   GDIPCONST GpPen *pen)
 689 {
 690   return NotImplemented;
 691 }
 692
 693 /*
 694  * @unimplemented
 695  */
 696 GpStatus WINGDIPAPI
 697 GdipGetPathWorldBoundsI(GpPath* path,
 698   GpRect* bounds,
 699   GDIPCONST GpMatrix *matrix,
 700   GDIPCONST GpPen *pen)
 701 {
 702   return NotImplemented;
 703 }
 704
 705 /*
 706  * @unimplemented
 707  */
 708 GpStatus WINGDIPAPI
 709 GdipIsVisiblePathPoint(GpPath* path,
 710   REAL x,
 711   REAL y,
 712   GpGraphics *graphics,
 713   BOOL *result)
 714 {
 715   return NotImplemented;
 716 }
 717
 718 /*
 719  * @unimplemented
 720  */
 721 GpStatus WINGDIPAPI
 722 GdipIsVisiblePathPointI(GpPath* path,
 723   INT x,
 724   INT y,
 725   GpGraphics *graphics,
 726   BOOL *result)
 727 {
 728   return NotImplemented;
 729 }
 730
 731 /*
 732  * @unimplemented
 733  */
 734 GpStatus WINGDIPAPI
 735 GdipIsOutlineVisiblePathPoint(GpPath* path,
 736   REAL x,
 737   REAL y,
 738   GpPen *pen,
 739   GpGraphics *graphics,
 740   BOOL *result)
 741 {
 742   return NotImplemented;
 743 }
 744
 745 /*
 746  * @unimplemented
 747  */
 748 GpStatus WINGDIPAPI
 749 GdipIsOutlineVisiblePathPointI(GpPath* path,
 750   INT x,
 751   INT y,
 752   GpPen *pen,
 753   GpGraphics *graphics,
 754   BOOL *result)
 755 {
 756   return NotImplemented;
 757 }