reactos/sdk/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 = FALSE)
  28   {
  29     if (useEmbeddedColorManagement)
  30       status = DllExports::GdipLoadImageFromStreamICM(stream, &image);
  31     else
  32       status = DllExports::GdipLoadImageFromStream(stream, &image);
  33   }
  34
  35   Image(const WCHAR *filename, BOOL useEmbeddedColorManagement = FALSE)
  36   {
  37     if (useEmbeddedColorManagement)
  38       status = DllExports::GdipLoadImageFromFileICM(filename, &image);
  39     else
  40       status = DllExports::GdipLoadImageFromFile(filename, &image);
  41   }
  42
  43   Image *Clone(VOID)
  44   {
  45     Image *newImage = new Image();
  46     SetStatus(DllExports::GdipCloneImage(image, &(newImage->image)));
  47     return newImage;
  48   }
  49
  50   static Image *FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement = FALSE)
  51   {
  52     return new Image(filename, useEmbeddedColorManagement);
  53   }
  54
  55   static Image *FromStream(IStream *stream, BOOL useEmbeddedColorManagement = FALSE)
  56   {
  57     return new Image(stream, useEmbeddedColorManagement);
  58   }
  59
  60   Status GetAllPropertyItems(UINT totalBufferSize, UINT numProperties, PropertyItem *allItems)
  61   {
  62     return SetStatus(DllExports::GdipGetAllPropertyItems(image, totalBufferSize, numProperties, allItems));
  63   }
  64
  65   Status GetBounds(RectF *srcRect, Unit *srcUnit)
  66   {
  67     return SetStatus(DllExports::GdipGetImageBounds(image, srcRect, srcUnit));
  68   }
  69
  70   Status GetEncoderParameterList(const CLSID *clsidEncoder, UINT size, EncoderParameters *buffer)
  71   {
  72     return SetStatus(DllExports::GdipGetEncoderParameterList(image, clsidEncoder, size, buffer));
  73   }
  74
  75   UINT GetEncoderParameterListSize(const CLSID *clsidEncoder)
  76   {
  77     UINT size;
  78     SetStatus(DllExports::GdipGetEncoderParameterListSize(image, clsidEncoder, &size));
  79     return size;
  80   }
  81
  82   UINT GetFlags(VOID)
  83   {
  84     UINT flags;
  85     SetStatus(DllExports::GdipGetImageFlags(image, &flags));
  86     return flags;
  87   }
  88
  89   UINT GetFrameCount(const GUID *dimensionID)
  90   {
  91     UINT count;
  92     SetStatus(DllExports::GdipImageGetFrameCount(image, dimensionID, &count));
  93     return count;
  94   }
  95
  96   UINT GetFrameDimensionsCount(VOID)
  97   {
  98     UINT count;
  99     SetStatus(DllExports::GdipImageGetFrameDimensionsCount(image, &count));
 100     return count;
 101   }
 102
 103   Status GetFrameDimensionsList(GUID *dimensionIDs, UINT count)
 104   {
 105     return SetStatus(DllExports::GdipImageGetFrameDimensionsList(image, dimensionIDs, count));
 106   }
 107
 108   UINT GetHeight(VOID)
 109   {
 110     UINT height;
 111     SetStatus(DllExports::GdipGetImageHeight(image, &height));
 112     return height;
 113   }
 114
 115   REAL GetHorizontalResolution(VOID)
 116   {
 117     REAL resolution;
 118     SetStatus(DllExports::GdipGetImageHorizontalResolution(image, &resolution));
 119     return resolution;
 120   }
 121
 122   Status GetLastStatus(VOID)
 123   {
 124     return status;
 125   }
 126
 127   Status GetPalette(ColorPalette *palette, INT size)
 128   {
 129     return SetStatus(DllExports::GdipGetImagePalette(image, palette, size));
 130   }
 131
 132   INT GetPaletteSize(VOID)
 133   {
 134     INT size;
 135     SetStatus(DllExports::GdipGetImagePaletteSize(image, &size));
 136     return size;
 137   }
 138
 139   Status GetPhysicalDimension(SizeF *size)
 140   {
 141     return SetStatus(DllExports::GdipGetImagePhysicalDimension(image, &(size->Width), &(size->Height)));
 142   }
 143
 144   PixelFormat GetPixelFormat(VOID)
 145   {
 146     PixelFormat format;
 147     SetStatus(DllExports::GdipGetImagePixelFormat(image, &format));
 148     return format;
 149   }
 150
 151   UINT GetPropertyCount(VOID)
 152   {
 153     UINT numOfProperty;
 154     SetStatus(DllExports::GdipGetPropertyCount(image, &numOfProperty));
 155     return numOfProperty;
 156   }
 157
 158   Status GetPropertyIdList(UINT numOfProperty, PROPID *list)
 159   {
 160     return SetStatus(DllExports::GdipGetPropertyIdList(image, numOfProperty, list));
 161   }
 162
 163   Status GetPropertyItem(PROPID propId, UINT propSize, PropertyItem *buffer)
 164   {
 165     return SetStatus(DllExports::GdipGetPropertyItem(image, propId, propSize, buffer));
 166   }
 167
 168   UINT GetPropertyItemSize(PROPID propId)
 169   {
 170     UINT size;
 171     SetStatus(DllExports::GdipGetPropertyItemSize(image, propId, &size));
 172     return size;
 173   }
 174
 175   Status GetPropertySize(UINT *totalBufferSize, UINT *numProperties)
 176   {
 177     return SetStatus(DllExports::GdipGetPropertySize(image, totalBufferSize, numProperties));
 178   }
 179
 180   Status GetRawFormat(GUID *format)
 181   {
 182     return SetStatus(DllExports::GdipGetRawFormat(image, format));
 183   }
 184
 185   Image *GetThumbnailImage(UINT thumbWidth, UINT thumbHeight, GetThumbnailImageAbort callback, VOID *callbackData)
 186   {
 187     Image *thumbImage = new Image();
 188     SetStatus(DllExports::GdipGetImageThumbnail(image, thumbWidth, thumbHeight, &(thumbImage->image), callback, callbackData));
 189     return thumbImage;
 190   }
 191
 192   ImageType GetType(VOID)
 193   {
 194     ImageType type;
 195     SetStatus(DllExports::GdipGetImageType(image, &type));
 196     return type;
 197   }
 198
 199   REAL GetVerticalResolution(VOID)
 200   {
 201     REAL resolution;
 202     SetStatus(DllExports::GdipGetImageVerticalResolution(image, &resolution));
 203     return resolution;
 204   }
 205
 206   UINT GetWidth(VOID)
 207   {
 208     UINT width;
 209     SetStatus(DllExports::GdipGetImageWidth(image, &width));
 210     return width;
 211   }
 212
 213   Status RemovePropertyItem(PROPID propId)
 214   {
 215     return SetStatus(DllExports::GdipRemovePropertyItem(image, propId));
 216   }
 217
 218   Status RotateFlip(RotateFlipType rotateFlipType)
 219   {
 220     return SetStatus(DllExports::GdipImageRotateFlip(image, rotateFlipType));
 221   }
 222
 223   Status Save(IStream *stream, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
 224   {
 225     return SetStatus(DllExports::GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams));
 226   }
 227
 228   Status Save(const WCHAR *filename, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
 229   {
 230     return SetStatus(DllExports::GdipSaveImageToFile(image, filename, clsidEncoder, encoderParams));
 231   }
 232
 233   Status SaveAdd(const EncoderParameters* encoderParams)
 234   {
 235     return SetStatus(DllExports::GdipSaveAdd(image, encoderParams));
 236   }
 237
 238   Status SaveAdd(Image *newImage, const EncoderParameters *encoderParams)
 239   {
 240     return SetStatus(DllExports::GdipSaveAddImage(image, newImage->image, encoderParams));
 241   }
 242
 243   Status SelectActiveFrame(const GUID *dimensionID, UINT frameIndex)
 244   {
 245     return SetStatus(DllExports::GdipImageSelectActiveFrame(image, dimensionID, frameIndex));
 246   }
 247
 248   Status SetPalette(const ColorPalette* palette)
 249   {
 250     return SetStatus(DllExports::GdipSetImagePalette(image, palette));
 251   }
 252
 253   Status SetPropertyItem(const PropertyItem* item)
 254   {
 255     return SetStatus(DllExports::GdipSetPropertyItem(image, item));
 256   }
 257
 258 protected:
 259   Image()
 260   {
 261   }
 262
 263 private:
 264   mutable Status status;
 265   GpImage *image;
 266
 267   Status SetStatus(Status status) const
 268   {
 269     if (status == Ok)
 270       return status;
 271     this->status = status;
 272     return status;
 273   }
 274 };
 275
 276
 277 class Bitmap : public Image
 278 {
 279 public:
 280   Bitmap(IDirectDrawSurface7 *surface)
 281   {
 282     status = DllExports::GdipCreateBitmapFromDirectDrawSurface(surface, &bitmap);
 283   }
 284
 285   Bitmap(INT width, INT height, Graphics *target)
 286   {
 287     status = DllExports::GdipCreateBitmapFromGraphics(width, height, target->graphics, &bitmap);
 288   }
 289
 290   Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
 291   {
 292     status = DllExports::GdipCreateBitmapFromGdiDib(gdiBitmapInfo, gdiBitmapData, &bitmap);
 293   }
 294
 295   Bitmap(INT width, INT height, PixelFormat format)
 296   {
 297   }
 298
 299   Bitmap(HBITMAP hbm, HPALETTE hpal)
 300   {
 301     status = DllExports::GdipCreateBitmapFromHBITMAP(hbm, hpal, &bitmap);
 302   }
 303
 304   Bitmap(INT width, INT height, INT stride, PixelFormat format, BYTE *scan0)
 305   {
 306     status = DllExports::GdipCreateBitmapFromScan0(width, height, stride, format, scan0, &bitmap);
 307   }
 308
 309   Bitmap(const WCHAR *filename, BOOL useIcm)
 310   {
 311     if (useIcm)
 312       status = DllExports::GdipCreateBitmapFromFileICM(filename, &bitmap);
 313     else
 314       status = DllExports::GdipCreateBitmapFromFile(filename, &bitmap);
 315   }
 316
 317   Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName)
 318   {
 319     status = DllExports::GdipCreateBitmapFromResource(hInstance, bitmapName, &bitmap);
 320   }
 321
 322   Bitmap(HICON hicon)
 323   {
 324     status = DllExports::GdipCreateBitmapFromHICON(hicon, &bitmap);
 325   }
 326
 327   Bitmap(IStream *stream, BOOL useIcm)
 328   {
 329     if (useIcm)
 330       status = DllExports::GdipCreateBitmapFromStreamICM(stream, &bitmap);
 331     else
 332       status = DllExports::GdipCreateBitmapFromStream(stream, &bitmap);
 333   }
 334
 335   Bitmap *Clone(const Rect &rect, PixelFormat format)
 336   {
 337     Bitmap *dstBitmap = new Bitmap();
 338     SetStatus(DllExports::GdipCloneBitmapAreaI(rect.X, rect.Y, rect.Width, rect.Height, format, bitmap, &(dstBitmap->bitmap)));
 339     return dstBitmap;
 340   }
 341
 342   Bitmap *Clone(const RectF &rect, PixelFormat format)
 343   {
 344     Bitmap *dstBitmap = new Bitmap();
 345     SetStatus(DllExports::GdipCloneBitmapArea(rect.X, rect.Y, rect.Width, rect.Height, format, bitmap, &(dstBitmap->bitmap)));
 346     return dstBitmap;
 347   }
 348
 349   Bitmap *Clone(REAL x, REAL y, REAL width, REAL height, PixelFormat format)
 350   {
 351     Bitmap *dstBitmap = new Bitmap();
 352     SetStatus(DllExports::GdipCloneBitmapArea(x, y, width, height, format, bitmap, &(dstBitmap->bitmap)));
 353     return dstBitmap;
 354   }
 355
 356   Bitmap *Clone(INT x, INT y, INT width, INT height, PixelFormat format)
 357   {
 358     Bitmap *dstBitmap = new Bitmap();
 359     SetStatus(DllExports::GdipCloneBitmapAreaI(x, y, width, height, format, bitmap, &(dstBitmap->bitmap)));
 360     return dstBitmap;
 361   }
 362
 363   static Bitmap *FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
 364   {
 365     return new Bitmap(gdiBitmapInfo, gdiBitmapData);
 366   }
 367
 368   static Bitmap *FromDirectDrawSurface7(IDirectDrawSurface7 *surface)
 369   {
 370     return new Bitmap(surface);
 371   }
 372
 373   static Bitmap *FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
 374   {
 375     return new Bitmap(filename, useEmbeddedColorManagement);
 376   }
 377
 378   static Bitmap *FromHBITMAP(HBITMAP hbm, HPALETTE hpal)
 379   {
 380     return new Bitmap(hbm, hpal);
 381   }
 382
 383   static Bitmap *FromHICON(HICON hicon)
 384   {
 385     return new Bitmap(hicon);
 386   }
 387
 388   static Bitmap *FromResource(HINSTANCE hInstance, const WCHAR *bitmapName)
 389   {
 390     return new Bitmap(hInstance, bitmapName);
 391   }
 392
 393   static Bitmap *FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
 394   {
 395     return new Bitmap(stream, useEmbeddedColorManagement);
 396   }
 397
 398   Status GetHBITMAP(const Color &colorBackground, HBITMAP *hbmReturn)
 399   {
 400     return SetStatus(DllExports::GdipCreateHBITMAPFromBitmap(bitmap, hbmReturn, colorBackground.GetValue()));
 401   }
 402
 403   Status GetHICON(HICON *hicon)
 404   {
 405     return SetStatus(DllExports::GdipCreateHICONFromBitmap(bitmap, hbmReturn));
 406   }
 407
 408   Status GetPixel(INT x, INT y, Color *color)
 409   {
 410     ARGB argb;
 411     Status s = SetStatus(DllExports::GdipBitmapGetPixel(bitmap, x, y, &argb));
 412     if (color != NULL)
 413       color->SetValue(argb);
 414     return s;
 415   }
 416
 417   Status LockBits(const Rect *rect, UINT flags, PixelFormat format, BitmapData *lockedBitmapData)
 418   {
 419     return SetStatus(DllExports::GdipBitmapLockBits(bitmap, rect, flags, format, lockedBitmapData));
 420   }
 421
 422   Status SetPixel(INT x, INT y, const Color &color)
 423   {
 424     return SetStatus(DllExports::GdipBitmapSetPixel(bitmap, x, y, color.GetValue()));
 425   }
 426
 427   Status SetResolution(REAL xdpi, REAL ydpi)
 428   {
 429     return SetStatus(DllExports::GdipBitmapSetResolution(bitmap, xdpi, ydpi));
 430   }
 431
 432   Status UnlockBits(BitmapData *lockedBitmapData)
 433   {
 434     return SetStatus(DllExports::GdipBitmapUnlockBits(bitmap, lockedBitmapData));
 435   }
 436
 437 protected:
 438   Bitmap()
 439   {
 440   }
 441
 442 private:
 443   mutable Status status;
 444   GpBitmap *bitmap;
 445
 446   Status SetStatus(Status status) const
 447   {
 448     if (status == Ok)
 449       return status;
 450     this->status = status;
 451     return status;
 452   }
 453 };
 454
 455
 456 class CachedBitmap : public GdiplusBase
 457 {
 458 public:
 459   CachedBitmap(Bitmap *bitmap, Graphics *graphics)
 460   {
 461     status = DllExports::GdipCreateCachedBitmap(bitmap, graphics, &cachedBitmap);
 462   }
 463
 464   Status GetLastStatus(VOID)
 465   {
 466     return status;
 467   }
 468
 469 private:
 470   mutable Status status;
 471   GpCachedBitmap *cachedBitmap;
 472 };
 473
 474
 475 class Font : public GdiplusBase
 476 {
 477 public:
 478   friend class FontFamily;
 479   friend class FontCollection;
 480   friend class Graphics;
 481
 482   Font(const FontFamily *family, REAL emSize, INT style, Unit unit)
 483   {
 484     status = DllExports::GdipCreateFont(family->fontFamily, emSize, style. unit, &font);
 485   }
 486
 487   Font(HDC hdc, const HFONT hfont)
 488   {
 489   }
 490
 491   Font(HDC hdc, const LOGFONTA *logfont)
 492   {
 493     status = DllExports::GdipCreateFontFromLogfontA(hdc, logfont, &font);
 494   }
 495
 496   Font(HDC hdc, const LOGFONTW *logfont)
 497   {
 498     status = DllExports::GdipCreateFontFromLogfontW(hdc, logfont, &font);
 499   }
 500
 501   Font(const WCHAR *familyName, REAL emSize, INT style, Unit unit, const FontCollection *fontCollection)
 502   {
 503   }
 504
 505   Font(HDC hdc)
 506   {
 507     status = DllExports::GdipCreateFontFromDC(hdc, &font);
 508   }
 509
 510   Font *Clone(VOID) const
 511   {
 512     Font *cloneFont = new Font();
 513     cloneFont->status = DllExports::GdipCloneFont(font, &(cloneFont->font));
 514     return cloneFont;
 515   }
 516
 517   Status GetFamily(FontFamily* family) const
 518   {
 519     return SetStatus(DllExports::GdipGetFamily(font, &(family->fontFamily)));
 520   }
 521
 522   REAL GetHeight(const Graphics* graphics) const
 523   {
 524     REAL height;
 525     SetStatus(DllExports::GdipGetFontHeight(font, graphics->graphics, &height));
 526     return height;
 527   }
 528
 529   REAL GetHeight(REAL dpi) const
 530   {
 531     REAL height;
 532     SetStatus(DllExports::GdipGetFontHeightGivenDPI(font, dpi, &height));
 533     return height;
 534   }
 535
 536   Status GetLastStatus(VOID) const
 537   {
 538     return status;
 539   }
 540
 541   Status GetLogFontA(const Graphics *g, LOGFONTA *logfontA) const
 542   {
 543     return SetStatus(DllExports::GdipGetLogFontA(font, g->graphics, logfontA));
 544   }
 545
 546   Status GetLogFontW(const Graphics *g, LOGFONTW *logfontW) const
 547   {
 548     return SetStatus(DllExports::GdipGetLogFontW(font, g->graphics, logfontW));
 549   }
 550
 551   REAL GetSize(VOID) const
 552   {
 553     REAL size;
 554     SetStatus(DllExports::GdipGetFontSize(font, &size));
 555     return size;
 556   }
 557
 558   INT GetStyle(VOID) const
 559   {
 560     INT style;
 561     SetStatus(DllExports::GdipGetFontStyle(font, &style));
 562     return style;
 563   }
 564
 565   Unit GetUnit(VOID) const
 566   {
 567     Unit unit;
 568     SetStatus(DllExports::GdipGetFontUnit(font, &unit);
 569     return unit;
 570   }
 571
 572   BOOL IsAvailable(VOID) const
 573   {
 574     return FALSE;
 575   }
 576
 577 private:
 578   mutable Status status;
 579   GpFont *font;
 580
 581   Status SetStatus(Status status) const
 582   {
 583     if (status == Ok)
 584       return status;
 585     this->status = status;
 586     return status;
 587   }
 588 };
 589
 590
 591 class FontCollection : public GdiplusBase
 592 {
 593 public:
 594   FontCollection(VOID)
 595   {
 596   }
 597
 598   Status GetFamilies(INT numSought, FontFamily *gpfamilies, INT *numFound) const
 599   {
 600     return NotImplemented;
 601   }
 602
 603   INT GetFamilyCount(VOID) const
 604   {
 605     return 0;
 606   }
 607
 608   Status GetLastStatus(VOID)
 609   {
 610     return NotImplemented;
 611   }
 612 };
 613
 614
 615 class FontFamily : public GdiplusBase
 616 {
 617 public:
 618   FontFamily(VOID)
 619   {
 620   }
 621
 622   FontFamily(const WCHAR *name, const FontCollection *fontCollection)
 623   {
 624     status = DllExports::GdipCreateFontFamilyFromName(name, fontCollection, &fontFamily);
 625   }
 626
 627   FontFamily *Clone(VOID)
 628   {
 629     return NULL;
 630   }
 631
 632   static const FontFamily *GenericMonospace(VOID)
 633   {
 634     FontFamily *genericMonospace = new FontFamily();
 635     genericMonospace->status = DllExports::GdipGetGenericFontFamilyMonospace(&(genericMonospace->fontFamily));
 636     return genericMonospace;
 637   }
 638
 639   static const FontFamily *GenericSansSerif(VOID)
 640   {
 641     FontFamily *genericSansSerif = new FontFamily();
 642     genericSansSerif->status = DllExports::GdipGetGenericFontFamilySansSerif(&(genericSansSerif->fontFamily));
 643     return genericSansSerif;
 644   }
 645
 646   static const FontFamily *GenericSerif(VOID)
 647   {
 648     FontFamily *genericSerif = new FontFamily();
 649     genericSerif->status = DllExports::GdipGetGenericFontFamilyMonospace(&(genericSerif->fontFamily));
 650     return genericSerif;
 651   }
 652
 653   UINT16 GetCellAscent(INT style) const
 654   {
 655     UINT16 CellAscent;
 656     SetStatus(DllExports::GdipGetCellAscent(fontFamily, style, &CellAscent));
 657     return CellAscent;
 658   }
 659
 660   UINT16 GetCellDescent(INT style) const
 661   {
 662     UINT16 CellDescent;
 663     SetStatus(DllExports::GdipGetCellDescent(fontFamily, style, &CellDescent));
 664     return CellDescent;
 665   }
 666
 667   UINT16 GetEmHeight(INT style)
 668   {
 669     UINT16 EmHeight;
 670     SetStatus(DllExports::GdipGetEmHeight(fontFamily, style, &EmHeight));
 671     return EmHeight;
 672   }
 673
 674   Status GetFamilyName(WCHAR name[LF_FACESIZE], WCHAR language) const
 675   {
 676     return SetStatus(DllExports::GdipGetFamilyName(fontFamily, name, language));
 677   }
 678
 679   Status GetLastStatus(VOID) const
 680   {
 681     return status;
 682   }
 683
 684   UINT16 GetLineSpacing(INT style) const
 685   {
 686     UINT16 LineSpacing;
 687     SetStatus(DllExports::GdipGetLineSpacing(fontFamily, style, &LineSpacing));
 688     return LineSpacing;
 689   }
 690
 691   BOOL IsAvailable(VOID) const
 692   {
 693     return FALSE;
 694   }
 695
 696   BOOL IsStyleAvailable(INT style) const
 697   {
 698     BOOL StyleAvailable;
 699     SetStatus(DllExports::GdipIsStyleAvailable(fontFamily, style, &StyleAvailable));
 700     return StyleAvailable;
 701   }
 702
 703 private:
 704   mutable Status status;
 705   GpFontFamily *fontFamily;
 706
 707   Status SetStatus(Status status) const
 708   {
 709     if (status == Ok)
 710       return status;
 711     this->status = status;
 712     return status;
 713   }
 714 };
 715
 716
 717 class InstalledFontFamily : public FontFamily
 718 {
 719 public:
 720   InstalledFontFamily(VOID)
 721   {
 722   }
 723 };
 724
 725
 726 class PrivateFontCollection : public FontCollection
 727 {
 728 public:
 729   PrivateFontCollection(VOID)
 730   {
 731   }
 732
 733   Status AddFontFile(const WCHAR* filename)
 734   {
 735     return NotImplemented;
 736   }
 737
 738   Status AddMemoryFont(const VOID *memory, INT length)
 739   {
 740     return NotImplemented;
 741   }
 742 };
 743
 744
 745 class Region : public GdiplusBase
 746 {
 747 public:
 748   friend class Graphics;
 749   friend class GraphicsPath;
 750   friend class Matrix;
 751
 752   Region(const Rect &rect)
 753   {
 754     status = DllExports::GdipCreateRegionRectI(&rect, &region);
 755   }
 756
 757   Region(VOID)
 758   {
 759     status = DllExports::GdipCreateRegion(&region);
 760   }
 761
 762   Region(const BYTE *regionData, INT size)
 763   {
 764     status = DllExports::GdipCreateRegionRgnData(regionData, size, &region);
 765   }
 766
 767   Region(const GraphicsPath *path)
 768   {
 769     status = DllExports::GdipCreateRegionPath(path->path, &region);
 770   }
 771
 772   Region(HRGN hRgn)
 773   {
 774     status = DllExports::GdipCreateRegionHrgn(hRgn, &region);
 775   }
 776
 777   Region(const RectF &rect)
 778   {
 779     status = DllExports::GdipCreateRegionRectF(&rect, &region);
 780   }
 781
 782   Region *Clone(VOID)
 783   {
 784     region *cloneRegion = new Region();
 785     cloneRegion->status = DllExports::GdipCloneRegion(region, &cloneRegion);
 786     return cloneRegion;
 787   }
 788
 789   Status Complement(const GraphicsPath *path)
 790   {
 791     return SetStatus(DllExports::GdipCombineRegionPath(region, path->path, CombineModeComplement));
 792   }
 793
 794   Status Complement(const Region *region)
 795   {
 796     return SetStatus(DllExports::GdipCombineRegionRegion(this->region, region->region, CombineModeComplement));
 797   }
 798
 799   Status Complement(const Rect &rect)
 800   {
 801     return SetStatus(DllExports::GdipCombineRegionRectI(region, &rect, CombineModeComplement));
 802   }
 803
 804   Status Complement(const RectF &rect)
 805   {
 806     return SetStatus(DllExports::GdipCombineRegionRect(region, &rect, CombineModeComplement));
 807   }
 808
 809   BOOL Equals(const Region *region, const Graphics *g) const
 810   {
 811     BOOL result;
 812     SetStatus(DllExports::GdipIsEqualRegion(this->region, region->region, g->graphics, &result));
 813     return result;
 814   }
 815
 816   Status Exclude(const GraphicsPath *path)
 817   {
 818     return SetStatus(DllExports::GdipCombineRegionPath(region, path->path, CombineModeExclude));
 819   }
 820
 821   Status Exclude(const RectF &rect)
 822   {
 823     return SetStatus(DllExports::GdipCombineRegionRect(region, &rect, CombineModeExclude));
 824   }
 825
 826   Status Exclude(const Rect &rect)
 827   {
 828     return SetStatus(DllExports::GdipCombineRegionRectI(region, &rect, CombineModeExclude));
 829   }
 830
 831   Status Exclude(const Region *region)
 832   {
 833     return SetStatus(DllExports::GdipCombineRegionRegion(this->region, region->region, CombineModeExclude));
 834   }
 835
 836   static Region *FromHRGN(HRGN hRgn)
 837   {
 838     return new Region(hRgn);
 839   }
 840
 841   Status GetBounds(Rect *rect, const Graphics *g) const
 842   {
 843     return SetStatus(DllExports::GdipGetRegionBoundsI(region, g->graphics, rect));
 844   }
 845
 846   Status GetBounds(RectF *rect, const Graphics *g) const
 847   {
 848     return SetStatus(DllExports::GdipGetRegionBounds(region, g->graphics, rect));
 849   }
 850
 851   Status GetData(BYTE *buffer, UINT bufferSize, UINT *sizeFilled) const
 852   {
 853     return SetStatus(DllExports::GdipGetRegionData(region, budder, bufferSize, sizeFilled));
 854   }
 855
 856   UINT GetDataSize(VOID) const
 857   {
 858     UINT bufferSize;
 859     SetStatus(DllExports::GdipGetRegionDataSize(region, &bufferSize));
 860     return bufferSize;
 861   }
 862
 863   HRGN GetHRGN(const Graphics *g) const
 864   {
 865     HRGN hRgn;
 866     SetStatus(DllExports::GdipGetRegionHRgn(region, g->graphics, &hRgn));
 867     return hRgn;
 868   }
 869
 870   Status GetLastStatus(VOID)
 871   {
 872     return status;
 873   }
 874
 875   Status GetRegionScans(const Matrix *matrix, Rect *rects, INT *count) const
 876   {
 877     return SetStatus(DllExports::GdipGetRegionScansI(region, rects, count, matrix->matrix));
 878   }
 879
 880   Status GetRegionScans(const Matrix *matrix, RectF *rects, INT *count) const
 881   {
 882     return SetStatus(DllExports::GdipGetRegionScans(region, rects, count, matrix->matrix));
 883   }
 884
 885   UINT GetRegionScansCount(const Matrix *matrix) const
 886   {
 887     UINT count;
 888     SetStatus(DllExports::GdipGetRegionScansCount(region, &count, matrix->matrix));
 889     return count;
 890   }
 891
 892   Status Intersect(const Rect &rect)
 893   {
 894     return SetStatus(DllExports::GdipCombineRegionRectI(region, &rect, CombineModeIntersect));
 895   }
 896
 897   Status Intersect(const GraphicsPath *path)
 898   {
 899     return SetStatus(DllExports::GdipCombineRegionPath(region, path->path, CombineModeIntersect));
 900   }
 901
 902   Status Intersect(const RectF &rect)
 903   {
 904     return SetStatus(DllExports::GdipCombineRegionRect(region, &rect, CombineModeIntersect));
 905   }
 906
 907   Status Intersect(const Region *region)
 908   {
 909     return SetStatus(DllExports::GdipCombineRegionRegion(this->region, region->region, CombineModeIntersect));
 910   }
 911
 912   BOOL IsEmpty(const Graphics *g) const
 913   {
 914     BOOL result;
 915     SetStatus(DllExports::GdipIsEmptyRegion(region, g->graphics, &result));
 916     return result;
 917   }
 918
 919   BOOL IsInfinite(const Graphics *g) const
 920   {
 921     BOOL result;
 922     SetStatus(DllExports::GdipIsInfiniteRegion(region, g->graphics, &result));
 923     return result;
 924   }
 925
 926   BOOL IsVisible(const PointF &point, const Graphics *g) const
 927   {
 928     BOOL result;
 929     SetStatus(DllExports::GdipIsVisibleRegionPoint(region, point.x, point.y, g->graphics, &result));
 930     return result;
 931   }
 932
 933   BOOL IsVisible(const RectF &rect, const Graphics *g) const
 934   {
 935     BOOL result;
 936     SetStatus(DllExports::GdipIsVisibleRegionRect(region, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, g->graphics, &result));
 937     return result;
 938   }
 939
 940   BOOL IsVisible(const Rect &rect, const Graphics *g) const
 941   {
 942     BOOL result;
 943     SetStatus(DllExports::GdipIsVisibleRegionRectI(region, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, g->graphics, &result));
 944     return result;
 945   }
 946
 947   BOOL IsVisible(INT x, INT y, const Graphics *g) const
 948   {
 949     BOOL result;
 950     SetStatus(DllExports::GdipIsVisibleRegionPointI(region, x, y, g->graphics, &result));
 951     return result;
 952   }
 953
 954   BOOL IsVisible(REAL x, REAL y, const Graphics *g) const
 955   {
 956     BOOL result;
 957     SetStatus(DllExports::GdipIsVisibleRegionPoint(region, x, y, g->graphics, &result));
 958     return result;
 959   }
 960
 961   BOOL IsVisible(INT x, INT y, INT width, INT height, const Graphics *g) const
 962   {
 963     BOOL result;
 964     SetStatus(DllExports::GdipIsVisibleRegionRectI(region, x, y, width, height, g->graphics, &result));
 965     return result;
 966   }
 967
 968   BOOL IsVisible(const Point &point, const Graphics *g) const
 969   {
 970     BOOL result;
 971     SetStatus(DllExports::GdipIsVisibleRegionPointI(region, point.x, point.y, g->graphics, &result));
 972     return result;
 973   }
 974
 975   BOOL IsVisible(REAL x, REAL y, REAL width, REAL height, const Graphics *g) const
 976   {
 977     BOOL result;
 978     SetStatus(DllExports::GdipIsVisibleRegionRect(region, x, y, width, height, g->graphics, &result));
 979     return result;
 980   }
 981
 982   Status MakeEmpty(VOID)
 983   {
 984     return SetStatus(DllExports::GdipSetEmpty(region));
 985   }
 986
 987   Status MakeInfinite(VOID)
 988   {
 989     return SetStatus(DllExports::GdipSetInfinite(region));
 990   }
 991
 992   Status Transform(const Matrix *matrix)
 993   {
 994     return SetStatus(DllExports::GdipTransformRegion(region, matrix->matrix));
 995   }
 996
 997   Status Translate(REAL dx, REAL dy)
 998   {
 999     return SetStatus(DllExports::GdipTranslateRegion(region, dx, dy));
1000   }
1001
1002   Status Translate(INT dx, INT dy)
1003   {
1004     return SetStatus(DllExports::GdipTranslateRegionI(region, dx, dy));
1005   }
1006
1007   Status Union(const Rect &rect)
1008   {
1009     return SetStatus(DllExports::GdipCombineRegionRectI(region, &rect, CombineModeUnion));
1010   }
1011
1012   Status Union(const Region *region)
1013   {
1014     return SetStatus(DllExports::GdipCombineRegionRegion(this->region, region->region, CombineModeUnion));
1015   }
1016
1017   Status Union(const RectF &rect)
1018   {
1019     return SetStatus(DllExports::GdipCombineRegionRect(region, &rect, CombineModeUnion));
1020   }
1021
1022   Status Union(const GraphicsPath *path)
1023   {
1024     return SetStatus(DllExports::GdipCombineRegionPath(region, path->path, CombineModeUnion));
1025   }
1026
1027   Status Xor(const GraphicsPath *path)
1028   {
1029     return SetStatus(DllExports::GdipCombineRegionPath(region, path->path, CombineModeXor));
1030   }
1031
1032   Status Xor(const RectF &rect)
1033   {
1034     return SetStatus(DllExports::GdipCombineRegionRect(region, &rect, CombineModeXor));
1035   }
1036
1037   Status Xor(const Rect &rect)
1038   {
1039     return SetStatus(DllExports::GdipCombineRegionRectI(region, &rect, CombineModeXor));
1040   }
1041
1042   Status Xor(const Region *region)
1043   {
1044     return SetStatus(DllExports::GdipCombineRegionRegion(this->region, region->region, CombineModeXor));
1045   }
1046
1047 private:
1048   mutable Status status;
1049   GpRegion *region;
1050
1051   Status SetStatus(Status status) const
1052   {
1053     if (status == Ok)
1054       return status;
1055     this->status = status;
1056     return status;
1057   }
1058 };
1059
1060
1061 class CustomLineCap : public GdiplusBase
1062 {
1063 public:
1064   CustomLineCap(const GraphicsPath *fillPath, const GraphicsPath *strokePath, LineCap baseCap, REAL baseInset);
1065   CustomLineCap *Clone(VOID);
1066   LineCap GetBaseCap(VOID);
1067   REAL GetBaseInset(VOID);
1068   Status GetLastStatus(VOID);
1069   Status GetStrokeCaps(LineCap *startCap, LineCap *endCap);
1070   LineJoin GetStrokeJoin(VOID);
1071   REAL GetWidthScale(VOID);
1072   Status SetBaseCap(LineCap baseCap);
1073   Status SetBaseInset(REAL inset);
1074   Status SetStrokeCap(LineCap strokeCap);
1075   Status SetStrokeCaps(LineCap startCap, LineCap endCap);
1076   Status SetStrokeJoin(LineJoin lineJoin);
1077   Status SetWidthScale(IN REAL widthScale);
1078 protected:
1079   CustomLineCap();
1080 };
1081
1082 #endif /* _GDIPLUSHEADERS_H */