reactos/include/gdiplusheaders.h

   1 /*
   2  * GdiPlusHeaders.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 _GDIPLUSHEADERS_H
  20 #define _GDIPLUSHEADERS_H
  21
  22 #if __GNUC__ >= 3
  23 #pragma GCC system_header
  24 #endif
  25
  26 class Image : public GdiplusBase
  27 {
  28 public:
  29   friend class Graphics;
  30
  31   Image(IStream *stream, BOOL useEmbeddedColorManagement)
  32   {
  33   }
  34
  35   Image(const WCHAR *filename, BOOL useEmbeddedColorManagement)
  36   {
  37   }
  38
  39   Image *Clone(VOID)
  40   {
  41     return NULL;
  42   }
  43
  44   static Image *FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
  45   {
  46     return NULL;
  47   }
  48
  49   static Image *FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
  50   {
  51     return NULL;
  52   }
  53
  54   Status GetAllPropertyItems(UINT totalBufferSize, UINT numProperties, PropertyItem *allItems)
  55   {
  56     return NotImplemented;
  57   }
  58
  59   Status GetBounds(RectF *srcRect, Unit *srcUnit)
  60   {
  61     return NotImplemented;
  62   }
  63
  64   Status GetEncoderParameterList(const CLSID *clsidEncoder, UINT size, EncoderParameters *buffer)
  65   {
  66     return NotImplemented;
  67   }
  68
  69   UINT GetEncoderParameterListSize(const CLSID *clsidEncoder)
  70   {
  71     return 0;
  72   }
  73
  74   UINT GetFlags(VOID)
  75   {
  76     return 0;
  77   }
  78
  79   UINT GetFrameCount(const GUID *dimensionID)
  80   {
  81     return 0;
  82   }
  83
  84   UINT GetFrameDimensionsCount(VOID)
  85   {
  86     return 0;
  87   }
  88
  89   Status GetFrameDimensionsList(GUID *dimensionIDs, UINT count)
  90   {
  91     return NotImplemented;
  92   }
  93
  94   UINT GetHeight(VOID)
  95   {
  96     return 0;
  97   }
  98
  99   REAL GetHorizontalResolution(VOID)
 100   {
 101     return 0;
 102   }
 103
 104   Status GetLastStatus(VOID)
 105   {
 106     return NotImplemented;
 107   }
 108
 109   Status GetPalette(ColorPalette *palette, INT size)
 110   {
 111     return NotImplemented;
 112   }
 113
 114   INT GetPaletteSize(VOID)
 115   {
 116     return 0;
 117   }
 118
 119   Status GetPhysicalDimension(SizeF *size)
 120   {
 121     return NotImplemented;
 122   }
 123
 124   PixelFormat GetPixelFormat(VOID)
 125   {
 126     return PixelFormatUndefined;
 127   }
 128
 129   UINT GetPropertyCount(VOID)
 130   {
 131     return 0;
 132   }
 133
 134   Status GetPropertyIdList(UINT numOfProperty, PROPID *list)
 135   {
 136     return NotImplemented;
 137   }
 138
 139   Status GetPropertyItem(PROPID propId, UINT propSize, PropertyItem *buffer)
 140   {
 141     return NotImplemented;
 142   }
 143
 144   UINT GetPropertyItemSize(PROPID propId)
 145   {
 146     return 0;
 147   }
 148
 149   Status GetPropertySize(UINT *totalBufferSize, UINT *numProperties)
 150   {
 151     return NotImplemented;
 152   }
 153
 154   Status GetRawFormat(GUID *format)
 155   {
 156     return NotImplemented;
 157   }
 158
 159   Image *GetThumbnailImage(UINT thumbWidth, UINT thumbHeight, GetThumbnailImageAbort callback, VOID *callbackData)
 160   {
 161     return NULL;
 162   }
 163
 164   ImageType GetType(VOID)
 165   {
 166     return ImageTypeUnknown;
 167   }
 168
 169   REAL GetVerticalResolution(VOID)
 170   {
 171     return 0;
 172   }
 173
 174   UINT GetWidth(VOID)
 175   {
 176     return 0;
 177   }
 178
 179   Status RemovePropertyItem(PROPID propId)
 180   {
 181     return NotImplemented;
 182   }
 183
 184   Status RotateFlip(RotateFlipType rotateFlipType)
 185   {
 186     return NotImplemented;
 187   }
 188
 189   Status Save(IStream *stream, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
 190   {
 191     return NotImplemented;
 192   }
 193
 194   Status Save(const WCHAR *filename, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
 195   {
 196     return NotImplemented;
 197   }
 198
 199   Status SaveAdd(const EncoderParameters* encoderParams)
 200   {
 201     return NotImplemented;
 202   }
 203
 204   Status SaveAdd(Image *newImage, const EncoderParameters *encoderParams)
 205   {
 206     return NotImplemented;
 207   }
 208
 209   Status SelectActiveFrame(const GUID *dimensionID, UINT frameIndex)
 210   {
 211     return NotImplemented;
 212   }
 213
 214   Status SetPalette(const ColorPalette* palette)
 215   {
 216     return NotImplemented;
 217   }
 218
 219   Status SetPropertyItem(const PropertyItem* item)
 220   {
 221     return NotImplemented;
 222   }
 223
 224 protected:
 225   Image()
 226   {
 227   }
 228 };
 229
 230
 231 class Bitmap : public Image
 232 {
 233 public:
 234   Bitmap(IDirectDrawSurface7 *surface)
 235   {
 236   }
 237
 238   Bitmap(INT width, INT height, Graphics *target)
 239   {
 240   }
 241
 242   Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
 243   {
 244   }
 245
 246   Bitmap(INT width, INT height, PixelFormat format)
 247   {
 248   }
 249
 250   Bitmap(HBITMAP hbm, HPALETTE hpal)
 251   {
 252   }
 253
 254   Bitmap(INT width, INT height, INT stride, PixelFormat format, BYTE *scan0)
 255   {
 256   }
 257
 258   Bitmap(const WCHAR *filename, BOOL useIcm)
 259   {
 260   }
 261
 262   Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName)
 263   {
 264   }
 265
 266   Bitmap(HICON hicon)
 267   {
 268   }
 269
 270   Bitmap(IStream *stream, BOOL useIcm)
 271   {
 272   }
 273
 274   Bitmap *Clone(const Rect &rect, PixelFormat format)
 275   {
 276     return NULL;
 277   }
 278
 279   Bitmap *Clone(const RectF &rect, PixelFormat format)
 280   {
 281     return NULL;
 282   }
 283
 284   Bitmap *Clone(REAL x, REAL y, REAL width, REAL height, PixelFormat format)
 285   {
 286     return NULL;
 287   }
 288
 289   Bitmap *Clone(INT x, INT y, INT width, INT height, PixelFormat format)
 290   {
 291     return NULL;
 292   }
 293
 294   static Bitmap *FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
 295   {
 296     return NULL;
 297   }
 298
 299   static Bitmap *FromDirectDrawSurface7(IDirectDrawSurface7 *surface)
 300   {
 301     return NULL;
 302   }
 303
 304   static Bitmap *FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
 305   {
 306     return NULL;
 307   }
 308
 309   static Bitmap *FromHBITMAP(HBITMAP hbm, HPALETTE hpal)
 310   {
 311     return NULL;
 312   }
 313
 314   static Bitmap *FromHICON(HICON hicon)
 315   {
 316     return NULL;
 317   }
 318
 319   static Bitmap *FromResource(HINSTANCE hInstance, const WCHAR *bitmapName)
 320   {
 321     return NULL;
 322   }
 323
 324   static Bitmap *FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
 325   {
 326     return NULL;
 327   }
 328
 329   Status GetHBITMAP(const Color &colorBackground, HBITMAP *hbmReturn)
 330   {
 331     return NotImplemented;
 332   }
 333
 334   Status GetHICON(HICON *hicon)
 335   {
 336     return NotImplemented;
 337   }
 338
 339   Status GetPixel(INT x, INT y, Color *color)
 340   {
 341     return NotImplemented;
 342   }
 343
 344   Status LockBits(const Rect *rect, UINT flags, PixelFormat format, BitmapData *lockedBitmapData)
 345   {
 346     return NotImplemented;
 347   }
 348
 349   Status SetPixel(INT x, INT y, const Color &color)
 350   {
 351     return NotImplemented;
 352   }
 353
 354   Status SetResolution(REAL xdpi, REAL ydpi)
 355   {
 356     return NotImplemented;
 357   }
 358
 359   Status UnlockBits(BitmapData *lockedBitmapData)
 360   {
 361     return NotImplemented;
 362   }
 363 };
 364
 365
 366 class CachedBitmap : public GdiplusBase
 367 {
 368 public:
 369   CachedBitmap(Bitmap *bitmap, Graphics *graphics)
 370   {
 371   }
 372
 373   Status GetLastStatus(VOID)
 374   {
 375     return NotImplemented;
 376   }
 377 };
 378
 379
 380 class Font : public GdiplusBase
 381 {
 382 public:
 383   friend class FontFamily;
 384   friend class FontCollection;
 385
 386   Font(const FontFamily *family, REAL emSize, INT style, Unit unit)
 387   {
 388   }
 389
 390   Font(HDC hdc, const HFONT hfont)
 391   {
 392   }
 393
 394   Font(HDC hdc, const LOGFONTA *logfont)
 395   {
 396   }
 397
 398   Font(HDC hdc, const LOGFONTW *logfont)
 399   {
 400   }
 401
 402   Font(const WCHAR *familyName, REAL emSize, INT style, Unit unit, const FontCollection *fontCollection)
 403   {
 404   }
 405
 406   Font(HDC hdc)
 407   {
 408   }
 409
 410   Font *Clone(VOID) const
 411   {
 412     return NULL;
 413   }
 414
 415   Status GetFamily(FontFamily* family) const
 416   {
 417     return NotImplemented;
 418   }
 419
 420   REAL GetHeight(const Graphics* graphics) const
 421   {
 422     return 0;
 423   }
 424
 425   REAL GetHeight(REAL dpi) const
 426   {
 427     return 0;
 428   }
 429
 430   Status GetLastStatus(VOID) const
 431   {
 432     return NotImplemented;
 433   }
 434
 435   Status GetLogFontA(const Graphics *g, LOGFONTA *logfontA) const
 436   {
 437     return NotImplemented;
 438   }
 439
 440   Status GetLogFontW(const Graphics *g, LOGFONTW *logfontW) const
 441   {
 442     return NotImplemented;
 443   }
 444
 445   REAL GetSize(VOID) const
 446   {
 447     return 0;
 448   }
 449
 450   INT GetStyle(VOID) const
 451   {
 452     return 0;
 453   }
 454
 455   Unit GetUnit(VOID) const
 456   {
 457     return UnitWorld;
 458   }
 459
 460   BOOL IsAvailable(VOID) const
 461   {
 462     return FALSE;
 463   }
 464 };
 465
 466
 467 class FontCollection : public GdiplusBase
 468 {
 469 public:
 470   FontCollection(VOID)
 471   {
 472   }
 473
 474   Status GetFamilies(INT numSought, FontFamily *gpfamilies, INT *numFound) const
 475   {
 476     return NotImplemented;
 477   }
 478
 479   INT GetFamilyCount(VOID) const
 480   {
 481     return 0;
 482   }
 483
 484   Status GetLastStatus(VOID)
 485   {
 486     return NotImplemented;
 487   }
 488 };
 489
 490
 491 class FontFamily : public GdiplusBase
 492 {
 493 public:
 494   FontFamily(VOID)
 495   {
 496   }
 497
 498   FontFamily(const WCHAR *name, const FontCollection *fontCollection)
 499   {
 500   }
 501
 502   FontFamily *Clone(VOID)
 503   {
 504     return NULL;
 505   }
 506
 507   static const FontFamily *GenericMonospace(VOID)
 508   {
 509     return NULL;
 510   }
 511
 512   static const FontFamily *GenericSansSerif(VOID)
 513   {
 514     return NULL;
 515   }
 516
 517   static const FontFamily *GenericSerif(VOID)
 518   {
 519     return NULL;
 520   }
 521
 522   UINT16 GetCellAscent(INT style) const
 523   {
 524     return 0;
 525   }
 526
 527   UINT16 GetCellDescent(INT style) const
 528   {
 529     return 0;
 530   }
 531
 532   UINT16 GetEmHeight(INT style)
 533   {
 534     return 0;
 535   }
 536
 537   Status GetFamilyName(WCHAR name[LF_FACESIZE], WCHAR language) const
 538   {
 539     return NotImplemented;
 540   }
 541
 542   Status GetLastStatus(VOID) const
 543   {
 544     return NotImplemented;
 545   }
 546
 547   UINT16 GetLineSpacing(INT style) const
 548   {
 549     return 0;
 550   }
 551
 552   BOOL IsAvailable(VOID) const
 553   {
 554     return FALSE;
 555   }
 556
 557   BOOL IsStyleAvailable(INT style) const
 558   {
 559     return FALSE;
 560   }
 561 };
 562
 563
 564 class InstalledFontFamily : public FontFamily
 565 {
 566 public:
 567   InstalledFontFamily(VOID)
 568   {
 569   }
 570 };
 571
 572
 573 class PrivateFontCollection : public FontCollection
 574 {
 575 public:
 576   PrivateFontCollection(VOID)
 577   {
 578   }
 579
 580   Status AddFontFile(const WCHAR* filename)
 581   {
 582     return NotImplemented;
 583   }
 584
 585   Status AddMemoryFont(const VOID *memory, INT length)
 586   {
 587     return NotImplemented;
 588   }
 589 };
 590
 591
 592 class Region : public GdiplusBase
 593 {
 594 public:
 595   friend class GraphicsPath;
 596   friend class Matrix;
 597
 598   Region(const Rect &rect)
 599   {
 600   }
 601
 602   Region(VOID)
 603   {
 604   }
 605
 606   Region(const BYTE *regionData, INT size)
 607   {
 608   }
 609
 610   Region(const GraphicsPath *path)
 611   {
 612   }
 613
 614   Region(HRGN hRgn)
 615   {
 616   }
 617
 618   Region(const RectF &rect)
 619   {
 620   }
 621
 622   Region *Clone(VOID)
 623   {
 624     return NULL;
 625   }
 626
 627   Status Complement(const GraphicsPath *path)
 628   {
 629     return NotImplemented;
 630   }
 631
 632   Status Complement(const Region *region)
 633   {
 634     return NotImplemented;
 635   }
 636
 637   Status Complement(const Rect &rect)
 638   {
 639     return NotImplemented;
 640   }
 641
 642   Status Complement(const RectF &rect)
 643   {
 644     return NotImplemented;
 645   }
 646
 647   BOOL Equals(const Region *region, const Graphics *g) const
 648   {
 649     return FALSE;
 650   }
 651
 652   Status Exclude(const GraphicsPath *path)
 653   {
 654     return NotImplemented;
 655   }
 656
 657   Status Exclude(const RectF &rect)
 658   {
 659     return NotImplemented;
 660   }
 661
 662   Status Exclude(const Rect &rect)
 663   {
 664     return NotImplemented;
 665   }
 666
 667   Status Exclude(const Region *region)
 668   {
 669     return NotImplemented;
 670   }
 671
 672   static Region *FromHRGN(HRGN hRgn)
 673   {
 674     return NULL;
 675   }
 676
 677   Status GetBounds(Rect *rect, const Graphics *g) const
 678   {
 679     return NotImplemented;
 680   }
 681
 682   Status GetBounds(RectF *rect, const Graphics *g) const
 683   {
 684     return NotImplemented;
 685   }
 686
 687   Status GetData(BYTE *buffer, UINT bufferSize, UINT *sizeFilled) const
 688   {
 689     return NotImplemented;
 690   }
 691
 692   UINT GetDataSize(VOID) const
 693   {
 694     return 0;
 695   }
 696
 697   HRGN GetHRGN(const Graphics *g) const
 698   {
 699     return NULL;
 700   }
 701
 702   Status GetLastStatus(VOID)
 703   {
 704     return NotImplemented;
 705   }
 706
 707   Status GetRegionScans(const Matrix *matrix, Rect *rects, INT *count) const
 708   {
 709     return NotImplemented;
 710   }
 711
 712   Status GetRegionScans(const Matrix *matrix, RectF *rects, INT *count) const
 713   {
 714     return NotImplemented;
 715   }
 716
 717   UINT GetRegionScansCount(const Matrix *matrix) const
 718   {
 719     return 0;
 720   }
 721
 722   Status Intersect(const Rect &rect)
 723   {
 724     return NotImplemented;
 725   }
 726
 727   Status Intersect(const GraphicsPath *path)
 728   {
 729     return NotImplemented;
 730   }
 731
 732   Status Intersect(const RectF &rect)
 733   {
 734     return NotImplemented;
 735   }
 736
 737   Status Intersect(const Region *region)
 738   {
 739     return NotImplemented;
 740   }
 741
 742   BOOL IsEmpty(const Graphics *g) const
 743   {
 744     return NotImplemented;
 745   }
 746
 747   BOOL IsInfinite(const Graphics *g) const
 748   {
 749     return FALSE;
 750   }
 751
 752   BOOL IsVisible(const PointF &point, const Graphics *g) const
 753   {
 754     return FALSE;
 755   }
 756
 757   BOOL IsVisible(const RectF &rect, const Graphics *g) const
 758   {
 759     return FALSE;
 760   }
 761
 762   BOOL IsVisible(const Rect &rect, const Graphics *g) const
 763   {
 764     return FALSE;
 765   }
 766
 767   BOOL IsVisible(INT x, INT y, const Graphics *g) const
 768   {
 769     return FALSE;
 770   }
 771
 772   BOOL IsVisible(REAL x, REAL y, const Graphics *g) const
 773   {
 774     return FALSE;
 775   }
 776
 777   BOOL IsVisible(INT x, INT y, INT width, INT height, const Graphics *g) const
 778   {
 779     return FALSE;
 780   }
 781
 782   BOOL IsVisible(const Point &point, const Graphics *g) const
 783   {
 784     return FALSE;
 785   }
 786
 787   BOOL IsVisible(REAL x, REAL y, REAL width, REAL height, const Graphics *g) const
 788   {
 789     return FALSE;
 790   }
 791
 792   Status MakeEmpty(VOID)
 793   {
 794     return NotImplemented;
 795   }
 796
 797   Status MakeInfinite(VOID)
 798   {
 799     return NotImplemented;
 800   }
 801
 802   Status Transform(const Matrix *matrix)
 803   {
 804     return NotImplemented;
 805   }
 806
 807   Status Translate(REAL dx, REAL dy)
 808   {
 809     return NotImplemented;
 810   }
 811
 812   Status Translate(INT dx, INT dy)
 813   {
 814     return NotImplemented;
 815   }
 816
 817   Status Union(const Rect &rect)
 818   {
 819     return NotImplemented;
 820   }
 821
 822   Status Union(const Region *region)
 823   {
 824     return NotImplemented;
 825   }
 826
 827   Status Union(const RectF &rect)
 828   {
 829     return NotImplemented;
 830   }
 831
 832   Status Union(const GraphicsPath *path)
 833   {
 834     return NotImplemented;
 835   }
 836
 837   Status Xor(const GraphicsPath *path)
 838   {
 839     return NotImplemented;
 840   }
 841
 842   Status Xor(const RectF &rect)
 843   {
 844     return NotImplemented;
 845   }
 846
 847   Status Xor(const Rect &rect)
 848   {
 849     return NotImplemented;
 850   }
 851
 852   Status Xor(const Region *region)
 853   {
 854     return NotImplemented;
 855   }
 856 };
 857
 858
 859 class CustomLineCap : public GdiplusBase
 860 {
 861 public:
 862   CustomLineCap(const GraphicsPath *fillPath, const GraphicsPath *strokePath, LineCap baseCap, REAL baseInset);
 863   CustomLineCap *Clone(VOID);
 864   LineCap GetBaseCap(VOID);
 865   REAL GetBaseInset(VOID);
 866   Status GetLastStatus(VOID);
 867   Status GetStrokeCaps(LineCap *startCap, LineCap *endCap);
 868   LineJoin GetStrokeJoin(VOID);
 869   REAL GetWidthScale(VOID);
 870   Status SetBaseCap(LineCap baseCap);
 871   Status SetBaseInset(REAL inset);
 872   Status SetStrokeCap(LineCap strokeCap);
 873   Status SetStrokeCaps(LineCap startCap, LineCap endCap);
 874   Status SetStrokeJoin(LineJoin lineJoin);
 875   Status SetWidthScale(IN REAL widthScale);
 876 protected:
 877   CustomLineCap();
 878 };
 879
 880 #endif /* _GDIPLUSHEADERS_H */