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