reactos/dll/win32/gdiplus/gdiplus/path.c

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