include/gdiplus/gdiplusimpl.h

   1 /**
   2  * @file gdiplusimpl.h
   3  * @copy 2012 MinGW.org project
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24 /* Created by Markus Koenig <markus@stber-koenig.de> */
  25 #ifndef __GDIPLUS_IMPL_H
  26 #define __GDIPLUS_IMPL_H
  27 #pragma GCC system_header
  28 #include <_mingw.h>
  29
  30 /*
  31  * GDI+ Bitmap, CachedBitmap, CustomLineCap, Font, FontCollection, FontFamily,
  32  *      Image, InstalledFontCollection, PrivateFontCollection, Region
  33  *      implementation.  Definitions of these classes are in gdiplusheaders.h.
  34  */
  35
  36 #ifndef __cplusplus
  37 #error "A C++ compiler is required to include gdiplusimpl.h."
  38 #endif
  39
  40 /*
  41  * FIXME: I called this file gdiplusimpl.h, but what should it really be called?
  42  * Or did Microsoft create separate files for each class implemented here?
  43  */
  44
  45
  46 // Image
  47
  48 __inline__ Image* Image::FromFile(const WCHAR *filename,
  49                 BOOL useEmbeddedColorManagement)
  50 {
  51         return new Image(filename, useEmbeddedColorManagement);
  52 }
  53
  54 __inline__ Image* Image::FromStream(IStream *stream,
  55                 BOOL useEmbeddedColorManagement)
  56 {
  57         return new Image(stream, useEmbeddedColorManagement);
  58 }
  59
  60 __inline__ Image::Image(const WCHAR *filename, BOOL useEmbeddedColorManagement):
  61         nativeImage(NULL), lastStatus(Ok)
  62 {
  63         if (useEmbeddedColorManagement) {
  64                 lastStatus = DllExports::GdipLoadImageFromFileICM(
  65                                 filename, &nativeImage);
  66         } else {
  67                 lastStatus = DllExports::GdipLoadImageFromFile(
  68                                 filename, &nativeImage);
  69         }
  70 }
  71
  72 __inline__ Image::Image(IStream *stream, BOOL useEmbeddedColorManagement):
  73         nativeImage(NULL), lastStatus(Ok)
  74 {
  75         if (useEmbeddedColorManagement) {
  76                 lastStatus = DllExports::GdipLoadImageFromStreamICM(
  77                                 stream, &nativeImage);
  78         } else {
  79                 lastStatus = DllExports::GdipLoadImageFromStream(
  80                                 stream, &nativeImage);
  81         }
  82 }
  83
  84 __inline__ Status Image::FindFirstItem(ImageItemData *item)
  85 {
  86         // FIXME: can't test GdipFindFirstImageItem b/c it isn't exported in 1.0
  87         return updateStatus(DllExports::GdipFindFirstImageItem(
  88                         nativeImage, item));
  89 }
  90
  91 __inline__ Status Image::FindNextItem(ImageItemData *item)
  92 {
  93         // FIXME: can't test GdipFindFirstImageItem b/c it isn't exported in 1.0
  94         return updateStatus(DllExports::GdipFindNextImageItem(
  95                         nativeImage, item));
  96 }
  97
  98 __inline__ Status Image::GetAllPropertyItems(UINT totalBufferSize,
  99                 UINT numProperties, PropertyItem *allItems)
 100 {
 101         return updateStatus(DllExports::GdipGetAllPropertyItems(
 102                         nativeImage, totalBufferSize, numProperties, allItems));
 103 }
 104
 105 __inline__ Status Image::GetBounds(RectF *srcRect, Unit *srcUnit)
 106 {
 107         return updateStatus(DllExports::GdipGetImageBounds(
 108                         nativeImage, srcRect, srcUnit));
 109 }
 110
 111 __inline__ Status Image::GetEncoderParameterList(const CLSID *clsidEncoder,
 112                 UINT size, EncoderParameters *buffer)
 113 {
 114         return updateStatus(DllExports::GdipGetEncoderParameterList(
 115                         nativeImage, clsidEncoder, size, buffer));
 116 }
 117
 118 __inline__ UINT Image::GetEncoderParameterListSize(const CLSID *clsidEncoder)
 119 {
 120         UINT result = 0;
 121         updateStatus(DllExports::GdipGetEncoderParameterListSize(
 122                         nativeImage, clsidEncoder, &result));
 123         return result;
 124 }
 125
 126 __inline__ UINT Image::GetFlags()
 127 {
 128         UINT result = 0;
 129         updateStatus(DllExports::GdipGetImageFlags(nativeImage, &result));
 130         return result;
 131 }
 132
 133 __inline__ UINT Image::GetFrameCount(const GUID *dimensionID)
 134 {
 135         UINT result = 0;
 136         updateStatus(DllExports::GdipImageGetFrameCount(
 137                         nativeImage, dimensionID, &result));
 138         return result;
 139 }
 140
 141 __inline__ UINT Image::GetFrameDimensionsCount()
 142 {
 143         UINT result = 0;
 144         updateStatus(DllExports::GdipImageGetFrameDimensionsCount(
 145                         nativeImage, &result));
 146         return result;
 147 }
 148
 149 __inline__ Status Image::GetFrameDimensionsList(GUID *dimensionIDs, UINT count)
 150 {
 151         return updateStatus(DllExports::GdipImageGetFrameDimensionsList(
 152                         nativeImage, dimensionIDs, count));
 153 }
 154
 155 __inline__ UINT Image::GetHeight()
 156 {
 157         UINT result = 0;
 158         updateStatus(DllExports::GdipGetImageHeight(nativeImage, &result));
 159         return result;
 160 }
 161
 162 __inline__ REAL Image::GetHorizontalResolution()
 163 {
 164         REAL result = 0.0f;
 165         updateStatus(DllExports::GdipGetImageHorizontalResolution(
 166                         nativeImage, &result));
 167         return result;
 168 }
 169
 170 __inline__ Status Image::GetItemData(ImageItemData *item)
 171 {
 172         // FIXME: can't test GdipGetImageItemData b/c it isn't exported in 1.0
 173         return updateStatus(DllExports::GdipGetImageItemData(
 174                         nativeImage, item));
 175 }
 176
 177 __inline__ Status Image::GetPalette(ColorPalette *palette, INT size)
 178 {
 179         return updateStatus(DllExports::GdipGetImagePalette(
 180                         nativeImage, palette, size));
 181 }
 182
 183 __inline__ INT Image::GetPaletteSize()
 184 {
 185         INT result = 0;
 186         updateStatus(DllExports::GdipGetImagePaletteSize(nativeImage, &result));
 187         return result;
 188 }
 189
 190 __inline__ Status Image::GetPhysicalDimension(SizeF *size)
 191 {
 192         if (!size) return lastStatus = InvalidParameter;
 193         return updateStatus(DllExports::GdipGetImageDimension(
 194                         nativeImage, &size->Width, &size->Height));
 195 }
 196
 197 __inline__ PixelFormat Image::GetPixelFormat()
 198 {
 199         PixelFormat result = (PixelFormat) 0;
 200         updateStatus(DllExports::GdipGetImagePixelFormat(nativeImage, &result));
 201         return result;
 202 }
 203
 204 __inline__ UINT Image::GetPropertyCount()
 205 {
 206         UINT result = 0;
 207         updateStatus(DllExports::GdipGetPropertyCount(nativeImage, &result));
 208         return result;
 209 }
 210
 211 __inline__ Status Image::GetPropertyIdList(UINT numOfProperty, PROPID *list)
 212 {
 213         return updateStatus(DllExports::GdipGetPropertyIdList(
 214                         nativeImage, numOfProperty, list));
 215 }
 216
 217 __inline__ Status Image::GetPropertyItem(PROPID propId, UINT propSize,
 218                 PropertyItem *buffer)
 219 {
 220         return updateStatus(DllExports::GdipGetPropertyItem(
 221                         nativeImage, propId, propSize, buffer));
 222 }
 223
 224 __inline__ UINT Image::GetPropertyItemSize(PROPID propId)
 225 {
 226         UINT result = 0;
 227         updateStatus(DllExports::GdipGetPropertyItemSize(
 228                         nativeImage, propId, &result));
 229         return result;
 230 }
 231
 232 __inline__ Status Image::GetPropertySize(
 233                 UINT *totalBufferSize, UINT *numProperties)
 234 {
 235         return updateStatus(DllExports::GdipGetPropertySize(
 236                         nativeImage, totalBufferSize, numProperties));
 237 }
 238
 239 __inline__ Status Image::GetRawFormat(GUID *format)
 240 {
 241         return updateStatus(DllExports::GdipGetImageRawFormat(
 242                         nativeImage, format));
 243 }
 244
 245 __inline__ Image* Image::GetThumbnailImage(UINT thumbWidth, UINT thumbHeight,
 246                 GetThumbnailImageAbort callback, VOID *callbackData)
 247 {
 248         GpImage *thumbImage = NULL;
 249         Status status = updateStatus(DllExports::GdipGetImageThumbnail(
 250                         nativeImage, thumbWidth, thumbHeight, &thumbImage,
 251                         callback, callbackData));
 252
 253         if (status == Ok) {
 254                 Image *result = new Image(thumbImage, Ok);
 255                 if (!result) {
 256                         DllExports::GdipDisposeImage(thumbImage);
 257                         lastStatus = OutOfMemory;
 258                 }
 259                 return result;
 260         } else {
 261                 return NULL;
 262         }
 263 }
 264
 265 __inline__ ImageType Image::GetType() const
 266 {
 267         ImageType result = ImageTypeUnknown;
 268         updateStatus(DllExports::GdipGetImageType(nativeImage, &result));
 269         return result;
 270 }
 271
 272 __inline__ REAL Image::GetVerticalResolution()
 273 {
 274         REAL result = 0.0f;
 275         updateStatus(DllExports::GdipGetImageVerticalResolution(
 276                         nativeImage, &result));
 277         return result;
 278 }
 279
 280 __inline__ UINT Image::GetWidth()
 281 {
 282         UINT result = 0;
 283         updateStatus(DllExports::GdipGetImageWidth(nativeImage, &result));
 284         return result;
 285 }
 286
 287 __inline__ Status Image::RemovePropertyItem(PROPID propId)
 288 {
 289         return updateStatus(DllExports::GdipRemovePropertyItem(
 290                         nativeImage, propId));
 291 }
 292
 293 __inline__ Status Image::RotateFlip(RotateFlipType rotateFlipType)
 294 {
 295         return updateStatus(DllExports::GdipImageRotateFlip(
 296                         nativeImage, rotateFlipType));
 297 }
 298
 299 __inline__ Status Image::Save(const WCHAR *filename, const CLSID *clsidEncoder,
 300                 const EncoderParameters *encoderParams)
 301 {
 302         return updateStatus(DllExports::GdipSaveImageToFile(
 303                         nativeImage, filename, clsidEncoder, encoderParams));
 304 }
 305
 306 __inline__ Status Image::Save(IStream *stream, const CLSID *clsidEncoder,
 307                 const EncoderParameters *encoderParams)
 308 {
 309         return updateStatus(DllExports::GdipSaveImageToStream(
 310                         nativeImage, stream, clsidEncoder, encoderParams));
 311 }
 312
 313 __inline__ Status Image::SaveAdd(const EncoderParameters *encoderParams)
 314 {
 315         return updateStatus(DllExports::GdipSaveAdd(
 316                         nativeImage, encoderParams));
 317 }
 318
 319 __inline__ Status Image::SaveAdd(Image *newImage,
 320                 const EncoderParameters *encoderParams)
 321 {
 322         return updateStatus(DllExports::GdipSaveAddImage(
 323                         nativeImage,
 324                         newImage ? newImage->nativeImage : NULL,
 325                         encoderParams));
 326 }
 327
 328 __inline__ Status Image::SelectActiveFrame(
 329                 const GUID *dimensionID, UINT frameIndex)
 330 {
 331         return updateStatus(DllExports::GdipImageSelectActiveFrame(
 332                         nativeImage, dimensionID, frameIndex));
 333 }
 334
 335 __inline__ Status Image::SetAbort(GdiplusAbort *pIAbort)
 336 {
 337         // FIXME: can't test GdipImageSetAbort because it isn't exported in 1.0
 338         return updateStatus(DllExports::GdipImageSetAbort(
 339                         nativeImage, pIAbort));
 340 }
 341
 342 __inline__ Status Image::SetPalette(const ColorPalette *palette)
 343 {
 344         return updateStatus(DllExports::GdipSetImagePalette(
 345                         nativeImage, palette));
 346 }
 347
 348 __inline__ Status Image::SetPropertyItem(const PropertyItem *item)
 349 {
 350         return updateStatus(DllExports::GdipSetPropertyItem(nativeImage, item));
 351 }
 352
 353
 354 // Bitmap
 355
 356 __inline__ Bitmap* Bitmap::FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo,
 357                 VOID *gdiBitmapData)
 358 {
 359         return new Bitmap(gdiBitmapInfo, gdiBitmapData);
 360 }
 361
 362 __inline__ Bitmap* Bitmap::FromDirectDrawSurface7(IDirectDrawSurface7 *surface)
 363 {
 364         return new Bitmap(surface);
 365 }
 366
 367 __inline__ Bitmap* Bitmap::FromFile(const WCHAR *filename,
 368                 BOOL useEmbeddedColorManagement)
 369 {
 370         return new Bitmap(filename, useEmbeddedColorManagement);
 371 }
 372
 373 __inline__ Bitmap* Bitmap::FromHBITMAP(HBITMAP hbm, HPALETTE hpal)
 374 {
 375         return new Bitmap(hbm, hpal);
 376 }
 377
 378 __inline__ Bitmap* Bitmap::FromHICON(HICON icon)
 379 {
 380         return new Bitmap(icon);
 381 }
 382
 383 __inline__ Bitmap* Bitmap::FromResource(
 384                 HINSTANCE hInstance, const WCHAR *bitmapName)
 385 {
 386         return new Bitmap(hInstance, bitmapName);
 387 }
 388
 389 __inline__ Bitmap* Bitmap::FromStream(IStream *stream,
 390                 BOOL useEmbeddedColorManagement)
 391 {
 392         return new Bitmap(stream, useEmbeddedColorManagement);
 393 }
 394
 395 //TODO: [GDI+ 1.1] Bitmap::ApplyEffect
 396 //__inline__ Status Bitmap::ApplyEffect(Bitmap **inputs, INT numInputs,
 397 //              Effect *effect, RECT *ROI, RECT *outputRect, Bitmap **output)
 398 //{
 399 //      return NotImplemented;
 400 //}
 401
 402 __inline__ Status Bitmap::InitializePalette(ColorPalette *palette,
 403                 PaletteType paletteType, INT optimalColors,
 404                 BOOL useTransparentColor, Bitmap *bitmap)
 405 {
 406         // FIXME: can't test GdipInitializePalette b/c it isn't exported in 1.0
 407         return DllExports::GdipInitializePalette(palette, paletteType,
 408                         optimalColors, useTransparentColor,
 409                         bitmap ? (GpBitmap*) bitmap->nativeImage : NULL);
 410 }
 411
 412 __inline__ Bitmap::Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData):
 413         Image(NULL, Ok)
 414 {
 415         GpBitmap *nativeBitmap = NULL;
 416         lastStatus = DllExports::GdipCreateBitmapFromGdiDib(
 417                         gdiBitmapInfo, gdiBitmapData, &nativeBitmap);
 418         nativeImage = nativeBitmap;
 419 }
 420
 421 __inline__ Bitmap::Bitmap(IDirectDrawSurface7 *surface): Image(NULL, Ok)
 422 {
 423         GpBitmap *nativeBitmap = NULL;
 424         lastStatus = DllExports::GdipCreateBitmapFromDirectDrawSurface(
 425                         surface, &nativeBitmap);
 426         nativeImage = nativeBitmap;
 427 }
 428
 429 __inline__ Bitmap::Bitmap(const WCHAR *filename,
 430                 BOOL useEmbeddedColorManagement): Image(NULL, Ok)
 431 {
 432         GpBitmap *nativeBitmap = NULL;
 433         if (useEmbeddedColorManagement) {
 434                 lastStatus = DllExports::GdipCreateBitmapFromFileICM(
 435                                 filename, &nativeBitmap);
 436         } else {
 437                 lastStatus = DllExports::GdipCreateBitmapFromFile(
 438                                 filename, &nativeBitmap);
 439         }
 440         nativeImage = nativeBitmap;
 441 }
 442
 443 __inline__ Bitmap::Bitmap(HBITMAP hbm, HPALETTE hpal):
 444         Image(NULL, Ok)
 445 {
 446         GpBitmap *nativeBitmap = NULL;
 447         lastStatus = DllExports::GdipCreateBitmapFromHBITMAP(
 448                         hbm, hpal, &nativeBitmap);
 449         nativeImage = nativeBitmap;
 450 }
 451
 452 __inline__ Bitmap::Bitmap(HICON hicon):
 453         Image(NULL, Ok)
 454 {
 455         GpBitmap *nativeBitmap = NULL;
 456         lastStatus = DllExports::GdipCreateBitmapFromHICON(hicon, &nativeBitmap);
 457         nativeImage = nativeBitmap;
 458 }
 459
 460 __inline__ Bitmap::Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName):
 461         Image(NULL, Ok)
 462 {
 463         GpBitmap *nativeBitmap = NULL;
 464         lastStatus = DllExports::GdipCreateBitmapFromResource(
 465                         hInstance, bitmapName, &nativeBitmap);
 466         nativeImage = nativeBitmap;
 467 }
 468
 469 __inline__ Bitmap::Bitmap(IStream *stream, BOOL useEmbeddedColorManagement):
 470         Image(NULL, Ok)
 471 {
 472         GpBitmap *nativeBitmap = NULL;
 473         if (useEmbeddedColorManagement) {
 474                 lastStatus = DllExports::GdipCreateBitmapFromStreamICM(
 475                                 stream, &nativeBitmap);
 476         } else {
 477                 lastStatus = DllExports::GdipCreateBitmapFromStream(
 478                                 stream, &nativeBitmap);
 479         }
 480         nativeImage = nativeBitmap;
 481 }
 482
 483 __inline__ Bitmap::Bitmap(INT width, INT height, Graphics *target):
 484         Image(NULL, Ok)
 485 {
 486         GpBitmap *nativeBitmap = NULL;
 487         lastStatus = DllExports::GdipCreateBitmapFromGraphics(
 488                         width, height, target ? target->nativeGraphics : NULL,
 489                         &nativeBitmap);
 490         nativeImage = nativeBitmap;
 491 }
 492
 493 __inline__ Bitmap::Bitmap(INT width, INT height, PixelFormat format):
 494         Image(NULL, Ok)
 495 {
 496         GpBitmap *nativeBitmap = NULL;
 497         lastStatus = DllExports::GdipCreateBitmapFromScan0(
 498                         width, height, 0, format, NULL, &nativeBitmap);
 499         nativeImage = nativeBitmap;
 500 }
 501
 502 __inline__ Bitmap::Bitmap(INT width, INT height, INT stride,
 503                 PixelFormat format, BYTE *scan0): Image(NULL, Ok)
 504 {
 505         GpBitmap *nativeBitmap = NULL;
 506         lastStatus = DllExports::GdipCreateBitmapFromScan0(
 507                         width, height, stride, format, scan0, &nativeBitmap);
 508         nativeImage = nativeBitmap;
 509 }
 510
 511 __inline__ Bitmap* Bitmap::Clone(const RectF& rect, PixelFormat format) const
 512 {
 513         return Clone(rect.X, rect.Y, rect.Width, rect.Height, format);
 514 }
 515
 516 __inline__ Bitmap* Bitmap::Clone(const Rect& rect, PixelFormat format) const
 517 {
 518         return Clone(rect.X, rect.Y, rect.Width, rect.Height, format);
 519 }
 520
 521 __inline__ Bitmap* Bitmap::Clone(REAL x, REAL y, REAL width, REAL height,
 522                 PixelFormat format) const
 523 {
 524         GpBitmap *cloneBitmap = NULL;
 525         Status status = updateStatus(DllExports::GdipCloneBitmapArea(
 526                         x, y, width, height, format,
 527                         (GpBitmap*) nativeImage, &cloneBitmap));
 528         if (status == Ok) {
 529                 Bitmap *result = new Bitmap(cloneBitmap, lastStatus);
 530                 if (!result) {
 531                         DllExports::GdipDisposeImage(cloneBitmap);
 532                         lastStatus = OutOfMemory;
 533                 }
 534                 return result;
 535         } else {
 536                 return NULL;
 537         }
 538 }
 539
 540 __inline__ Bitmap* Bitmap::Clone(INT x, INT y, INT width, INT height,
 541                 PixelFormat format) const
 542 {
 543         GpBitmap *cloneBitmap = NULL;
 544         Status status = updateStatus(DllExports::GdipCloneBitmapAreaI(
 545                         x, y, width, height, format,
 546                         (GpBitmap*) nativeImage, &cloneBitmap));
 547         if (status == Ok) {
 548                 Bitmap *result = new Bitmap(cloneBitmap, lastStatus);
 549                 if (!result) {
 550                         DllExports::GdipDisposeImage(cloneBitmap);
 551                         lastStatus = OutOfMemory;
 552                 }
 553                 return result;
 554         } else {
 555                 return NULL;
 556         }
 557 }
 558
 559 //TODO: [GDI+ 1.1] Bitmap::ApplyEffect
 560 //__inline__ Status Bitmap::ApplyEffect(Effect *effect, RECT *ROI)
 561 //{
 562 //      return NotImplemented;
 563 //}
 564
 565 __inline__ Status Bitmap::ConvertFormat(PixelFormat format,
 566                 DitherType ditherType, PaletteType paletteType,
 567                 ColorPalette *palette, REAL alphaThresholdPercent)
 568 {
 569         // FIXME: can't test GdipBitmapConvertFormat b/c it isn't exported in 1.0
 570         return updateStatus(DllExports::GdipBitmapConvertFormat(
 571                         (GpBitmap*) nativeImage, format, ditherType,
 572                         paletteType, palette, alphaThresholdPercent));
 573 }
 574
 575 __inline__ Status Bitmap::GetHBITMAP(
 576                 const Color& colorBackground, HBITMAP *hbmReturn) const
 577 {
 578         return updateStatus(DllExports::GdipCreateHBITMAPFromBitmap(
 579                         (GpBitmap*) nativeImage, hbmReturn,
 580                         colorBackground.GetValue()));
 581 }
 582
 583 __inline__ Status Bitmap::GetHICON(HICON *icon) const
 584 {
 585         return updateStatus(DllExports::GdipCreateHICONFromBitmap(
 586                         (GpBitmap*) nativeImage, icon));
 587 }
 588
 589 __inline__ Status Bitmap::GetHistogram(HistogramFormat format,
 590                 UINT numberOfEntries,
 591                 UINT *channel0, UINT *channel1,
 592                 UINT *channel2, UINT *channel3) const
 593 {
 594         return updateStatus(DllExports::GdipBitmapGetHistogram(
 595                         (GpBitmap*) nativeImage, format, numberOfEntries,
 596                         channel0, channel1, channel2, channel3));
 597 }
 598
 599 __inline__ Status Bitmap::GetHistogramSize(HistogramFormat format,
 600                 UINT *numberOfEntries) const
 601 {
 602         return updateStatus(DllExports::GdipBitmapGetHistogramSize(
 603                         format, numberOfEntries));
 604 }
 605
 606 __inline__ Status Bitmap::GetPixel(INT x, INT y, Color *color) const
 607 {
 608         return updateStatus(DllExports::GdipBitmapGetPixel(
 609                         (GpBitmap*) nativeImage, x, y,
 610                         color ? &color->Value : NULL));
 611 }
 612
 613 __inline__ Status Bitmap::LockBits(const Rect *rect, UINT flags,
 614                 PixelFormat format, BitmapData *lockedBitmapData)
 615 {
 616         return updateStatus(DllExports::GdipBitmapLockBits(
 617                         (GpBitmap*) nativeImage, rect, flags, format,
 618                         lockedBitmapData));
 619 }
 620
 621 __inline__ Status Bitmap::SetPixel(INT x, INT y, const Color& color)
 622 {
 623         return updateStatus(DllExports::GdipBitmapSetPixel(
 624                         (GpBitmap*) nativeImage, x, y, color.GetValue()));
 625 }
 626
 627 __inline__ Status Bitmap::SetResolution(REAL xdpi, REAL ydpi)
 628 {
 629         return updateStatus(DllExports::GdipBitmapSetResolution(
 630                         (GpBitmap*) nativeImage, xdpi, ydpi));
 631 }
 632
 633 __inline__ Status Bitmap::UnlockBits(BitmapData *lockedBitmapData)
 634 {
 635         return updateStatus(DllExports::GdipBitmapUnlockBits(
 636                         (GpBitmap*) nativeImage, lockedBitmapData));
 637 }
 638
 639
 640 // CachedBitmap
 641
 642 __inline__ CachedBitmap::CachedBitmap(Bitmap *bitmap, Graphics *graphics):
 643         nativeCachedBitmap(NULL), lastStatus(Ok)
 644 {
 645         lastStatus = DllExports::GdipCreateCachedBitmap(
 646                         bitmap ? ((GpBitmap*) bitmap->nativeImage) : NULL,
 647                         graphics ? graphics->nativeGraphics : NULL,
 648                         &nativeCachedBitmap);
 649 }
 650
 651 __inline__ CachedBitmap::~CachedBitmap()
 652 {
 653         DllExports::GdipDeleteCachedBitmap(nativeCachedBitmap);
 654 }
 655
 656
 657 // CustomLineCap
 658
 659 __inline__ CustomLineCap::CustomLineCap(
 660                 const GraphicsPath *fillPath,
 661                 const GraphicsPath *strokePath,
 662                 LineCap baseCap, REAL baseInset):
 663                 nativeCustomLineCap(NULL), lastStatus(Ok)
 664 {
 665         lastStatus = DllExports::GdipCreateCustomLineCap(
 666                         fillPath ? fillPath->nativePath : NULL,
 667                         strokePath ? strokePath->nativePath : NULL,
 668                         baseCap, baseInset, &nativeCustomLineCap);
 669 }
 670
 671 __inline__ LineCap CustomLineCap::GetBaseCap() const
 672 {
 673         LineCap result = LineCapFlat;
 674         updateStatus(DllExports::GdipGetCustomLineCapBaseCap(
 675                         nativeCustomLineCap, &result));
 676         return result;
 677 }
 678
 679 __inline__ REAL CustomLineCap::GetBaseInset() const
 680 {
 681         REAL result = 0.0f;
 682         updateStatus(DllExports::GdipGetCustomLineCapBaseInset(
 683                         nativeCustomLineCap, &result));
 684         return result;
 685 }
 686
 687 __inline__ Status CustomLineCap::GetStrokeCaps(LineCap *startCap,
 688                 LineCap *endCap) const
 689 {
 690         return updateStatus(DllExports::GdipGetCustomLineCapStrokeCaps(
 691                         nativeCustomLineCap, startCap, endCap));
 692 }
 693
 694 __inline__ LineJoin CustomLineCap::GetStrokeJoin() const
 695 {
 696         LineJoin result = LineJoinMiter;
 697         updateStatus(DllExports::GdipGetCustomLineCapStrokeJoin(
 698                         nativeCustomLineCap, &result));
 699         return result;
 700 }
 701
 702 __inline__ REAL CustomLineCap::GetWidthScale() const
 703 {
 704         REAL result = 0.0f;
 705         updateStatus(DllExports::GdipGetCustomLineCapWidthScale(
 706                         nativeCustomLineCap, &result));
 707         return result;
 708 }
 709
 710 __inline__ Status CustomLineCap::SetBaseCap(LineCap baseCap)
 711 {
 712         return updateStatus(DllExports::GdipSetCustomLineCapBaseCap(
 713                         nativeCustomLineCap, baseCap));
 714 }
 715
 716 __inline__ Status CustomLineCap::SetBaseInset(REAL inset)
 717 {
 718         return updateStatus(DllExports::GdipSetCustomLineCapBaseInset(
 719                         nativeCustomLineCap, inset));
 720 }
 721
 722 __inline__ Status CustomLineCap::SetStrokeCap(LineCap strokeCap)
 723 {
 724         return updateStatus(DllExports::GdipSetCustomLineCapStrokeCaps(
 725                         nativeCustomLineCap, strokeCap, strokeCap));
 726 }
 727
 728 __inline__ Status CustomLineCap::SetStrokeCaps(LineCap startCap, LineCap endCap)
 729 {
 730         return updateStatus(DllExports::GdipSetCustomLineCapStrokeCaps(
 731                         nativeCustomLineCap, startCap, endCap));
 732 }
 733
 734 __inline__ Status CustomLineCap::SetStrokeJoin(LineJoin lineJoin)
 735 {
 736         return updateStatus(DllExports::GdipSetCustomLineCapStrokeJoin(
 737                         nativeCustomLineCap, lineJoin));
 738 }
 739
 740 __inline__ Status CustomLineCap::SetWidthScale(REAL widthScale)
 741 {
 742         return updateStatus(DllExports::GdipSetCustomLineCapWidthScale(
 743                         nativeCustomLineCap, widthScale));
 744 }
 745
 746
 747 // Font
 748
 749 __inline__ Font::Font(const FontFamily *family,
 750                 REAL emSize, INT style, Unit unit):
 751                 nativeFont(NULL), lastStatus(Ok)
 752 {
 753         lastStatus = DllExports::GdipCreateFont(
 754                         family ? family->nativeFontFamily : NULL,
 755                         emSize, style, unit, &nativeFont);
 756 }
 757
 758 __inline__ Font::Font(HDC hdc, HFONT hfont):
 759         nativeFont(NULL), lastStatus(Ok)
 760 {
 761         LOGFONTW logfont;
 762         if (GetObject(hfont, sizeof logfont, &logfont)) {
 763                 lastStatus = DllExports::GdipCreateFontFromLogfontW(
 764                                 hdc, &logfont, &nativeFont);
 765         } else {
 766                 lastStatus = DllExports::GdipCreateFontFromDC(
 767                                 hdc, &nativeFont);
 768         }
 769 }
 770
 771 __inline__ Font::Font(HDC hdc, const LOGFONTA *logfont):
 772         nativeFont(NULL), lastStatus(Ok)
 773 {
 774         lastStatus = DllExports::GdipCreateFontFromLogfontA(
 775                         hdc, logfont, &nativeFont);
 776 }
 777
 778 __inline__ Font::Font(HDC hdc, const LOGFONTW *logfont):
 779         nativeFont(NULL), lastStatus(Ok)
 780 {
 781         lastStatus = DllExports::GdipCreateFontFromLogfontW(
 782                         hdc, logfont, &nativeFont);
 783 }
 784
 785 __inline__ Font::Font(HDC hdc):
 786         nativeFont(NULL), lastStatus(Ok)
 787 {
 788         lastStatus = DllExports::GdipCreateFontFromDC(hdc, &nativeFont);
 789 }
 790
 791 __inline__ Font::Font(const WCHAR *familyName, REAL emSize, INT style,
 792                 Unit unit, const FontCollection *fontCollection):
 793                 nativeFont(NULL), lastStatus(Ok)
 794 {
 795         GpFontFamily *nativeFamily = NULL;
 796         lastStatus = DllExports::GdipCreateFontFamilyFromName(
 797                         familyName,
 798                         fontCollection ? fontCollection->nativeFontCollection : NULL,
 799                         &nativeFamily);
 800
 801         if (nativeFamily) {
 802                 lastStatus = DllExports::GdipCreateFont(
 803                                 nativeFamily, emSize, style, unit, &nativeFont);
 804                 DllExports::GdipDeleteFontFamily(nativeFamily);
 805         }
 806 }
 807
 808 __inline__ Font::~Font()
 809 {
 810         DllExports::GdipDeleteFont(nativeFont);
 811 }
 812
 813 __inline__ Font* Font::Clone() const
 814 {
 815         GpFont *cloneFont = NULL;
 816         Status status = updateStatus(DllExports::GdipCloneFont(
 817                         nativeFont, &cloneFont));
 818         if (status == Ok) {
 819                 Font *result = new Font(cloneFont, lastStatus);
 820                 if (!result) {
 821                         DllExports::GdipDeleteFont(cloneFont);
 822                         lastStatus = OutOfMemory;
 823                 }
 824                 return result;
 825         } else {
 826                 return NULL;
 827         }
 828 }
 829
 830 __inline__ Status Font::GetFamily(FontFamily *family) const
 831 {
 832         if (!family) return lastStatus = InvalidParameter;
 833         // FIXME: do we need to call GdipDeleteFontFamily first?
 834         return family->lastStatus = updateStatus(DllExports::GdipGetFamily(
 835                         nativeFont, &family->nativeFontFamily));
 836 }
 837
 838 __inline__ REAL Font::GetHeight(const Graphics *graphics) const
 839 {
 840         REAL result = 0.0f;
 841         updateStatus(DllExports::GdipGetFontHeight(
 842                         nativeFont, graphics ? graphics->nativeGraphics : NULL,
 843                         &result));
 844         return result;
 845 }
 846
 847 __inline__ REAL Font::GetHeight(REAL dpi) const
 848 {
 849         REAL result = 0.0f;
 850         updateStatus(DllExports::GdipGetFontHeightGivenDPI(
 851                         nativeFont, dpi, &result));
 852         return result;
 853 }
 854
 855 __inline__ Status Font::GetLogFontA(const Graphics *graphics, LOGFONTA *logfontA)
 856 const
 857 {
 858         return updateStatus(DllExports::GdipGetLogFontA(
 859                         nativeFont, graphics ? graphics->nativeGraphics : NULL,
 860                         logfontA));
 861 }
 862
 863 __inline__ Status Font::GetLogFontW(const Graphics *graphics, LOGFONTW *logfontW)
 864 const
 865 {
 866         return updateStatus(DllExports::GdipGetLogFontW(
 867                         nativeFont, graphics ? graphics->nativeGraphics : NULL,
 868                         logfontW));
 869 }
 870
 871 __inline__ REAL Font::GetSize() const
 872 {
 873         REAL result = 0.0;
 874         updateStatus(DllExports::GdipGetFontSize(nativeFont, &result));
 875         return result;
 876 }
 877
 878 __inline__ INT Font::GetStyle() const
 879 {
 880         INT result = FontStyleRegular;
 881         updateStatus(DllExports::GdipGetFontStyle(nativeFont, &result));
 882         return result;
 883 }
 884
 885 __inline__ Unit Font::GetUnit() const
 886 {
 887         Unit result = UnitPoint;
 888         updateStatus(DllExports::GdipGetFontUnit(nativeFont, &result));
 889         return result;
 890 }
 891
 892
 893 // FontCollection
 894
 895 __inline__ FontCollection::FontCollection():
 896         nativeFontCollection(NULL), lastStatus(Ok)
 897 {
 898 }
 899
 900 __inline__ Status FontCollection::GetFamilies(INT numSought,
 901                 FontFamily *families, INT *numFound) const
 902 {
 903         if (numSought <= 0 || !families || !numFound)
 904                 return lastStatus = InvalidParameter;
 905
 906         for (int i = 0; i < numSought; ++i) {
 907                 families[i].nativeFontFamily = NULL;
 908                 families[i].lastStatus = FontFamilyNotFound;
 909         }
 910         *numFound = 0;
 911
 912         GpFontFamily **nativeFamilyArray = (GpFontFamily**)
 913                 DllExports::GdipAlloc(numSought * sizeof (GpFontFamily*));
 914         if (!nativeFamilyArray)
 915                 return lastStatus = OutOfMemory;
 916
 917         Status status = updateStatus(DllExports::GdipGetFontCollectionFamilyList(
 918                         nativeFontCollection, numSought, nativeFamilyArray,
 919                         numFound));
 920
 921         // FIXME: must the native GpFontFamily objects be cloned? Seems so.
 922         // (if this is not done, the "Creating a Private Font Collection"
 923         // example crashes on "delete[] pFontFamily")
 924
 925         if (status == Ok) {
 926                 for (int i = 0; i < *numFound; ++i) {
 927                         families[i].lastStatus =
 928                                 updateStatus(DllExports::GdipCloneFontFamily(
 929                                         nativeFamilyArray[i],
 930                                         &families[i].nativeFontFamily));
 931                 }
 932         }
 933
 934         DllExports::GdipFree(nativeFamilyArray);
 935         return status;
 936 }
 937
 938 __inline__ INT FontCollection::GetFamilyCount() const
 939 {
 940         INT result = 0;
 941         updateStatus(DllExports::GdipGetFontCollectionFamilyCount(
 942                         nativeFontCollection, &result));
 943         return result;
 944 }
 945
 946
 947 // FontFamily
 948
 949 // FIXME: do FontFamily::GenericMonospace() et al. need to be thread safe?
 950 // FIXME: maybe put parts of this in gdiplus.c
 951
 952 extern "C" void *_GdipFontFamilyCachedGenericMonospace;
 953 extern "C" void *_GdipFontFamilyCachedGenericSansSerif;
 954 extern "C" void *_GdipFontFamilyCachedGenericSerif;
 955
 956 __inline__ const FontFamily* FontFamily::GenericMonospace()
 957 {
 958         if (!_GdipFontFamilyCachedGenericMonospace) {
 959                 GpFontFamily *nativeFontFamily = 0;
 960                 Status status = DllExports::GdipGetGenericFontFamilyMonospace(
 961                                 &nativeFontFamily);
 962                 if (status == Ok && nativeFontFamily) {
 963                         _GdipFontFamilyCachedGenericMonospace = (void*)
 964                                 new FontFamily(nativeFontFamily, Ok);
 965                 }
 966         }
 967         return (FontFamily*) _GdipFontFamilyCachedGenericMonospace;
 968 }
 969
 970 __inline__ const FontFamily* FontFamily::GenericSansSerif()
 971 {
 972         if (!_GdipFontFamilyCachedGenericSansSerif) {
 973                 GpFontFamily *nativeFontFamily = 0;
 974                 Status status = DllExports::GdipGetGenericFontFamilySansSerif(
 975                                 &nativeFontFamily);
 976                 if (status == Ok && nativeFontFamily) {
 977                         _GdipFontFamilyCachedGenericSansSerif = (void*)
 978                                 new FontFamily(nativeFontFamily, Ok);
 979                 }
 980         }
 981         return (FontFamily*) _GdipFontFamilyCachedGenericSansSerif;
 982 }
 983
 984 __inline__ const FontFamily* FontFamily::GenericSerif()
 985 {
 986         if (!_GdipFontFamilyCachedGenericSerif) {
 987                 GpFontFamily *nativeFontFamily = 0;
 988                 Status status = DllExports::GdipGetGenericFontFamilySerif(
 989                                 &nativeFontFamily);
 990                 if (status == Ok && nativeFontFamily) {
 991                         _GdipFontFamilyCachedGenericSerif = (void*)
 992                                 new FontFamily(nativeFontFamily, Ok);
 993                 }
 994         }
 995         return (FontFamily*) _GdipFontFamilyCachedGenericSerif;
 996 }
 997
 998 __inline__ FontFamily::FontFamily():
 999         nativeFontFamily(NULL), lastStatus(Ok)
1000 {
1001 }
1002
1003 __inline__ FontFamily::FontFamily(const WCHAR *name,
1004                 const FontCollection *fontCollection):
1005                 nativeFontFamily(NULL), lastStatus(Ok)
1006 {
1007         lastStatus = DllExports::GdipCreateFontFamilyFromName(name,
1008                         fontCollection ? fontCollection->nativeFontCollection : NULL,
1009                         &nativeFontFamily);
1010 }
1011
1012 __inline__ FontFamily::~FontFamily()
1013 {
1014         DllExports::GdipDeleteFontFamily(nativeFontFamily);
1015 }
1016
1017 __inline__ FontFamily* FontFamily::Clone() const
1018 {
1019         GpFontFamily *cloneFontFamily = NULL;
1020         Status status = updateStatus(DllExports::GdipCloneFontFamily(
1021                         nativeFontFamily, &cloneFontFamily));
1022         if (status == Ok) {
1023                 FontFamily *result = new FontFamily(cloneFontFamily, lastStatus);
1024                 if (!result) {
1025                         DllExports::GdipDeleteFontFamily(cloneFontFamily);
1026                         lastStatus = OutOfMemory;
1027                 }
1028                 return result;
1029         } else {
1030                 return NULL;
1031         }
1032 }
1033
1034 __inline__ UINT16 FontFamily::GetCellAscent(INT style) const
1035 {
1036         UINT16 result = 0;
1037         updateStatus(DllExports::GdipGetCellAscent(
1038                         nativeFontFamily, style, &result));
1039         return result;
1040 }
1041
1042 __inline__ UINT16 FontFamily::GetCellDescent(INT style) const
1043 {
1044         UINT16 result = 0;
1045         updateStatus(DllExports::GdipGetCellDescent(
1046                         nativeFontFamily, style, &result));
1047         return result;
1048 }
1049
1050 __inline__ UINT16 FontFamily::GetEmHeight(INT style) const
1051 {
1052         UINT16 result = 0;
1053         updateStatus(DllExports::GdipGetEmHeight(
1054                         nativeFontFamily, style, &result));
1055         return result;
1056 }
1057
1058 __inline__ Status FontFamily::GetFamilyName(WCHAR name[LF_FACESIZE],
1059                 LANGID language) const
1060 {
1061         return updateStatus(DllExports::GdipGetFamilyName(
1062                         nativeFontFamily, name, language));
1063 }
1064
1065 __inline__ UINT16 FontFamily::GetLineSpacing(INT style) const
1066 {
1067         UINT16 result = 0;
1068         updateStatus(DllExports::GdipGetLineSpacing(
1069                         nativeFontFamily, style, &result));
1070         return result;
1071 }
1072
1073 __inline__ BOOL FontFamily::IsStyleAvailable(INT style) const
1074 {
1075         BOOL result = FALSE;
1076         updateStatus(DllExports::GdipIsStyleAvailable(
1077                         nativeFontFamily, style, &result));
1078         return result;
1079 }
1080
1081
1082 // InstalledFontCollection
1083
1084 __inline__ InstalledFontCollection::InstalledFontCollection()
1085 {
1086         lastStatus = DllExports::GdipNewInstalledFontCollection(
1087                         &nativeFontCollection);
1088 }
1089
1090
1091 // PrivateFontCollection
1092
1093 __inline__ PrivateFontCollection::PrivateFontCollection()
1094 {
1095         lastStatus = DllExports::GdipNewPrivateFontCollection(
1096                         &nativeFontCollection);
1097 }
1098
1099 __inline__ Status PrivateFontCollection::AddFontFile(const WCHAR *filename)
1100 {
1101         return updateStatus(DllExports::GdipPrivateAddFontFile(
1102                         nativeFontCollection, filename));
1103 }
1104
1105 __inline__ Status PrivateFontCollection::AddMemoryFont(
1106                 const VOID *memory, INT length)
1107 {
1108         return updateStatus(DllExports::GdipPrivateAddMemoryFont(
1109                         nativeFontCollection, memory, length));
1110 }
1111
1112
1113 // Region
1114
1115 __inline__ Region* Region::FromHRGN(HRGN hrgn)
1116 {
1117         return new Region(hrgn);
1118 }
1119
1120 __inline__ Region::Region(): nativeRegion(NULL), lastStatus(Ok)
1121 {
1122         lastStatus = DllExports::GdipCreateRegion(&nativeRegion);
1123 }
1124
1125 __inline__ Region::Region(const RectF& rect): nativeRegion(NULL), lastStatus(Ok)
1126 {
1127         lastStatus = DllExports::GdipCreateRegionRect(&rect, &nativeRegion);
1128 }
1129
1130 __inline__ Region::Region(const Rect& rect): nativeRegion(NULL), lastStatus(Ok)
1131 {
1132         lastStatus = DllExports::GdipCreateRegionRectI(&rect, &nativeRegion);
1133 }
1134
1135 __inline__ Region::Region(const GraphicsPath *path):
1136         nativeRegion(NULL), lastStatus(Ok)
1137 {
1138         lastStatus = DllExports::GdipCreateRegionPath(
1139                         path ? path->nativePath : NULL, &nativeRegion);
1140 }
1141
1142 __inline__ Region::Region(const BYTE *regionData, INT size):
1143         nativeRegion(NULL), lastStatus(Ok)
1144 {
1145         lastStatus = DllExports::GdipCreateRegionRgnData(
1146                         regionData, size, &nativeRegion);
1147 }
1148
1149 __inline__ Region::Region(HRGN hrgn): nativeRegion(NULL), lastStatus(Ok)
1150 {
1151         lastStatus = DllExports::GdipCreateRegionHrgn(hrgn, &nativeRegion);
1152 }
1153
1154 __inline__ Region::~Region()
1155 {
1156         DllExports::GdipDeleteRegion(nativeRegion);
1157 }
1158
1159 __inline__ Region* Region::Clone() const
1160 {
1161         GpRegion *cloneRegion = NULL;
1162         Status status = updateStatus(DllExports::GdipCloneRegion(
1163                         nativeRegion, &cloneRegion));
1164         if (status == Ok) {
1165                 Region *result = new Region(cloneRegion, lastStatus);
1166                 if (!result) {
1167                         DllExports::GdipDeleteRegion(cloneRegion);
1168                         lastStatus = OutOfMemory;
1169                 }
1170                 return result;
1171         } else {
1172                 return NULL;
1173         }
1174 }
1175
1176 __inline__ Status Region::Complement(const RectF& rect)
1177 {
1178         return updateStatus(DllExports::GdipCombineRegionRect(
1179                         nativeRegion, &rect, CombineModeComplement));
1180 }
1181
1182 __inline__ Status Region::Complement(const Rect& rect)
1183 {
1184         return updateStatus(DllExports::GdipCombineRegionRectI(
1185                         nativeRegion, &rect, CombineModeComplement));
1186 }
1187
1188 __inline__ Status Region::Complement(const Region *region)
1189 {
1190         return updateStatus(DllExports::GdipCombineRegionRegion(
1191                         nativeRegion, region ? region->nativeRegion : NULL,
1192                         CombineModeComplement));
1193 }
1194
1195 __inline__ Status Region::Complement(const GraphicsPath *path)
1196 {
1197         return updateStatus(DllExports::GdipCombineRegionPath(
1198                         nativeRegion, path ? path->nativePath : NULL,
1199                         CombineModeComplement));
1200 }
1201
1202 __inline__ BOOL Region::Equals(const Region *region, const Graphics *graphics)
1203 const
1204 {
1205         BOOL result = FALSE;
1206         updateStatus(DllExports::GdipIsEqualRegion(
1207                         nativeRegion, region ? region->nativeRegion : NULL,
1208                         graphics ? graphics->nativeGraphics : NULL, &result));
1209         return result;
1210 }
1211
1212 __inline__ Status Region::Exclude(const RectF& rect)
1213 {
1214         return updateStatus(DllExports::GdipCombineRegionRect(
1215                         nativeRegion, &rect, CombineModeExclude));
1216 }
1217
1218 __inline__ Status Region::Exclude(const Rect& rect)
1219 {
1220         return updateStatus(DllExports::GdipCombineRegionRectI(
1221                         nativeRegion, &rect, CombineModeExclude));
1222 }
1223
1224 __inline__ Status Region::Exclude(const Region *region)
1225 {
1226         return updateStatus(DllExports::GdipCombineRegionRegion(
1227                         nativeRegion, region ? region->nativeRegion : NULL,
1228                         CombineModeExclude));
1229 }
1230
1231 __inline__ Status Region::Exclude(const GraphicsPath *path)
1232 {
1233         return updateStatus(DllExports::GdipCombineRegionPath(
1234                         nativeRegion, path ? path->nativePath : NULL,
1235                         CombineModeExclude));
1236 }
1237
1238 __inline__ Status Region::GetBounds(RectF *rect, const Graphics *graphics) const
1239 {
1240         return updateStatus(DllExports::GdipGetRegionBounds(nativeRegion,
1241                         graphics ? graphics->nativeGraphics : NULL, rect));
1242 }
1243
1244 __inline__ Status Region::GetBounds(Rect *rect, const Graphics *graphics) const
1245 {
1246         return updateStatus(DllExports::GdipGetRegionBoundsI(nativeRegion,
1247                         graphics ? graphics->nativeGraphics : NULL, rect));
1248 }
1249
1250 __inline__ Status Region::GetData(BYTE *buffer, UINT bufferSize,
1251                 UINT *sizeFilled) const
1252 {
1253         return updateStatus(DllExports::GdipGetRegionData(
1254                         nativeRegion, buffer, bufferSize, sizeFilled));
1255 }
1256
1257 __inline__ UINT Region::GetDataSize() const
1258 {
1259         UINT result = 0;
1260         updateStatus(DllExports::GdipGetRegionDataSize(nativeRegion, &result));
1261         return result;
1262 }
1263
1264 __inline__ HRGN Region::GetHRGN(const Graphics *graphics) const
1265 {
1266         HRGN result = NULL;
1267         updateStatus(DllExports::GdipGetRegionHRgn(nativeRegion,
1268                         graphics ? graphics->nativeGraphics : NULL, &result));
1269         return result;
1270 }
1271
1272 __inline__ Status Region::GetRegionScans(const Matrix *matrix,
1273                 RectF *rects, INT *count) const
1274 {
1275         return updateStatus(DllExports::GdipGetRegionScans(
1276                         nativeRegion, rects, count,
1277                         matrix ? matrix->nativeMatrix : NULL));
1278 }
1279
1280 __inline__ Status Region::GetRegionScans(const Matrix *matrix,
1281                 Rect *rects, INT *count) const
1282 {
1283         return updateStatus(DllExports::GdipGetRegionScansI(
1284                         nativeRegion, rects, count,
1285                         matrix ? matrix->nativeMatrix : NULL));
1286 }
1287
1288 __inline__ UINT Region::GetRegionScansCount(const Matrix *matrix) const
1289 {
1290         UINT result = 0;
1291         updateStatus(DllExports::GdipGetRegionScansCount(
1292                         nativeRegion, &result,
1293                         matrix ? matrix->nativeMatrix : NULL));
1294         return result;
1295 }
1296
1297 __inline__ Status Region::Intersect(const RectF& rect)
1298 {
1299         return updateStatus(DllExports::GdipCombineRegionRect(
1300                         nativeRegion, &rect, CombineModeIntersect));
1301 }
1302
1303 __inline__ Status Region::Intersect(const Rect& rect)
1304 {
1305         return updateStatus(DllExports::GdipCombineRegionRectI(
1306                         nativeRegion, &rect, CombineModeIntersect));
1307 }
1308
1309 __inline__ Status Region::Intersect(const Region *region)
1310 {
1311         return updateStatus(DllExports::GdipCombineRegionRegion(
1312                         nativeRegion, region ? region->nativeRegion : NULL,
1313                         CombineModeIntersect));
1314 }
1315
1316 __inline__ Status Region::Intersect(const GraphicsPath *path)
1317 {
1318         return updateStatus(DllExports::GdipCombineRegionPath(
1319                         nativeRegion, path ? path->nativePath : NULL,
1320                         CombineModeIntersect));
1321 }
1322
1323 __inline__ BOOL Region::IsEmpty(const Graphics *graphics) const
1324 {
1325         BOOL result = FALSE;
1326         updateStatus(DllExports::GdipIsEmptyRegion(nativeRegion,
1327                         graphics ? graphics->nativeGraphics : NULL, &result));
1328         return result;
1329 }
1330
1331 __inline__ BOOL Region::IsInfinite(const Graphics *graphics) const
1332 {
1333         BOOL result = FALSE;
1334         updateStatus(DllExports::GdipIsInfiniteRegion(nativeRegion,
1335                         graphics ? graphics->nativeGraphics : NULL, &result));
1336         return result;
1337 }
1338
1339 __inline__ BOOL Region::IsVisible(REAL x, REAL y,
1340                 const Graphics *graphics) const
1341 {
1342         BOOL result = FALSE;
1343         updateStatus(DllExports::GdipIsVisibleRegionPoint(
1344                         nativeRegion, x, y,
1345                         graphics ? graphics->nativeGraphics : NULL, &result));
1346         return result;
1347 }
1348
1349 __inline__ BOOL Region::IsVisible(INT x, INT y,
1350                 const Graphics *graphics) const
1351 {
1352         BOOL result = FALSE;
1353         updateStatus(DllExports::GdipIsVisibleRegionPointI(
1354                         nativeRegion, x, y,
1355                         graphics ? graphics->nativeGraphics : NULL, &result));
1356         return result;
1357 }
1358
1359 __inline__ BOOL Region::IsVisible(const PointF& point,
1360                 const Graphics *graphics) const
1361 {
1362         BOOL result = FALSE;
1363         updateStatus(DllExports::GdipIsVisibleRegionPoint(
1364                         nativeRegion, point.X, point.Y,
1365                         graphics ? graphics->nativeGraphics : NULL, &result));
1366         return result;
1367 }
1368
1369 __inline__ BOOL Region::IsVisible(const Point& point,
1370                 const Graphics *graphics) const
1371 {
1372         BOOL result = FALSE;
1373         updateStatus(DllExports::GdipIsVisibleRegionPointI(
1374                         nativeRegion, point.X, point.Y,
1375                         graphics ? graphics->nativeGraphics : NULL, &result));
1376         return result;
1377 }
1378
1379 __inline__ BOOL Region::IsVisible(REAL x, REAL y, REAL width, REAL height,
1380                 const Graphics *graphics) const
1381 {
1382         BOOL result = FALSE;
1383         updateStatus(DllExports::GdipIsVisibleRegionRect(
1384                         nativeRegion, x, y, width, height,
1385                         graphics ? graphics->nativeGraphics : NULL, &result));
1386         return result;
1387 }
1388
1389 __inline__ BOOL Region::IsVisible(INT x, INT y, INT width, INT height,
1390                 const Graphics *graphics) const
1391 {
1392         BOOL result = FALSE;
1393         updateStatus(DllExports::GdipIsVisibleRegionRectI(
1394                         nativeRegion, x, y, width, height,
1395                         graphics ? graphics->nativeGraphics : NULL, &result));
1396         return result;
1397 }
1398
1399 __inline__ BOOL Region::IsVisible(const RectF& rect,
1400                 const Graphics *graphics) const
1401 {
1402         BOOL result = FALSE;
1403         updateStatus(DllExports::GdipIsVisibleRegionRect(
1404                         nativeRegion, rect.X, rect.Y, rect.Width, rect.Height,
1405                         graphics ? graphics->nativeGraphics : NULL, &result));
1406         return result;
1407 }
1408
1409 __inline__ BOOL Region::IsVisible(const Rect& rect,
1410                 const Graphics *graphics) const
1411 {
1412         BOOL result = FALSE;
1413         updateStatus(DllExports::GdipIsVisibleRegionRectI(
1414                         nativeRegion, rect.X, rect.Y, rect.Width, rect.Height,
1415                         graphics ? graphics->nativeGraphics : NULL, &result));
1416         return result;
1417 }
1418
1419 __inline__ Status Region::MakeEmpty()
1420 {
1421         return updateStatus(DllExports::GdipSetEmpty(nativeRegion));
1422 }
1423
1424 __inline__ Status Region::MakeInfinite()
1425 {
1426         return updateStatus(DllExports::GdipSetInfinite(nativeRegion));
1427 }
1428
1429 __inline__ Status Region::Transform(const Matrix *matrix)
1430 {
1431         return updateStatus(DllExports::GdipTransformRegion(
1432                         nativeRegion, matrix ? matrix->nativeMatrix : NULL));
1433 }
1434
1435 __inline__ Status Region::Translate(REAL dx, REAL dy)
1436 {
1437         return updateStatus(DllExports::GdipTranslateRegion(
1438                         nativeRegion, dx, dy));
1439 }
1440
1441 __inline__ Status Region::Translate(INT dx, INT dy)
1442 {
1443         return updateStatus(DllExports::GdipTranslateRegionI(
1444                         nativeRegion, dx, dy));
1445 }
1446
1447 __inline__ Status Region::Union(const RectF& rect)
1448 {
1449         return updateStatus(DllExports::GdipCombineRegionRect(
1450                         nativeRegion, &rect, CombineModeUnion));
1451 }
1452
1453 __inline__ Status Region::Union(const Rect& rect)
1454 {
1455         return updateStatus(DllExports::GdipCombineRegionRectI(
1456                         nativeRegion, &rect, CombineModeUnion));
1457 }
1458
1459 __inline__ Status Region::Union(const Region *region)
1460 {
1461         return updateStatus(DllExports::GdipCombineRegionRegion(
1462                         nativeRegion, region ? region->nativeRegion : NULL,
1463                         CombineModeUnion));
1464 }
1465
1466 __inline__ Status Region::Union(const GraphicsPath *path)
1467 {
1468         return updateStatus(DllExports::GdipCombineRegionPath(
1469                         nativeRegion, path ? path->nativePath : NULL,
1470                         CombineModeUnion));
1471 }
1472
1473 __inline__ Status Region::Xor(const RectF& rect)
1474 {
1475         return updateStatus(DllExports::GdipCombineRegionRect(
1476                         nativeRegion, &rect, CombineModeXor));
1477 }
1478
1479 __inline__ Status Region::Xor(const Rect& rect)
1480 {
1481         return updateStatus(DllExports::GdipCombineRegionRectI(
1482                         nativeRegion, &rect, CombineModeXor));
1483 }
1484
1485 __inline__ Status Region::Xor(const Region *region)
1486 {
1487         return updateStatus(DllExports::GdipCombineRegionRegion(
1488                         nativeRegion, region ? region->nativeRegion : NULL,
1489                         CombineModeXor));
1490 }
1491
1492 __inline__ Status Region::Xor(const GraphicsPath *path)
1493 {
1494         return updateStatus(DllExports::GdipCombineRegionPath(
1495                         nativeRegion, path ? path->nativePath : NULL,
1496                         CombineModeXor));
1497 }
1498
1499
1500 // GraphicsPath
1501
1502 __inline__ BOOL GraphicsPath::IsOutlineVisible(REAL x, REAL y, const Pen *pen,
1503                 const Graphics *g) const
1504 {
1505         BOOL result = FALSE;
1506         updateStatus(DllExports::GdipIsOutlineVisiblePathPoint(
1507                         nativePath, x, y, pen ? pen->nativePen : NULL,
1508                         g ? g->nativeGraphics : NULL, &result));
1509         return result;
1510 }
1511
1512 __inline__ BOOL GraphicsPath::IsOutlineVisible(INT x, INT y, const Pen *pen,
1513                 const Graphics *g) const
1514 {
1515         BOOL result = FALSE;
1516         updateStatus(DllExports::GdipIsOutlineVisiblePathPointI(
1517                         nativePath, x, y, pen ? pen->nativePen : NULL,
1518                         g ? g->nativeGraphics : NULL, &result));
1519         return result;
1520 }
1521
1522 __inline__ BOOL GraphicsPath::IsOutlineVisible(const PointF& point, const Pen *pen,
1523                 const Graphics *g) const
1524 {
1525         BOOL result = FALSE;
1526         updateStatus(DllExports::GdipIsOutlineVisiblePathPoint(
1527                         nativePath, point.X, point.Y,
1528                         pen ? pen->nativePen : NULL,
1529                         g ? g->nativeGraphics : NULL, &result));
1530         return result;
1531 }
1532
1533 __inline__ BOOL GraphicsPath::IsOutlineVisible(const Point& point, const Pen *pen,
1534                 const Graphics *g) const
1535 {
1536         BOOL result = FALSE;
1537         updateStatus(DllExports::GdipIsOutlineVisiblePathPointI(
1538                         nativePath, point.X, point.Y,
1539                         pen ? pen->nativePen : NULL,
1540                         g ? g->nativeGraphics : NULL, &result));
1541         return result;
1542 }
1543
1544 __inline__ BOOL GraphicsPath::IsVisible(REAL x, REAL y, const Graphics *g) const
1545 {
1546         BOOL result = FALSE;
1547         updateStatus(DllExports::GdipIsVisiblePathPoint(
1548                         nativePath, x, y,
1549                         g ? g->nativeGraphics : NULL, &result));
1550         return result;
1551 }
1552 __inline__ BOOL GraphicsPath::IsVisible(INT x, INT y, const Graphics *g) const
1553 {
1554         BOOL result = FALSE;
1555         updateStatus(DllExports::GdipIsVisiblePathPointI(
1556                         nativePath, x, y,
1557                         g ? g->nativeGraphics : NULL, &result));
1558         return result;
1559 }
1560
1561 __inline__ BOOL GraphicsPath::IsVisible(const PointF& point,
1562                 const Graphics *g) const
1563 {
1564         BOOL result = FALSE;
1565         updateStatus(DllExports::GdipIsVisiblePathPoint(
1566                         nativePath, point.X, point.Y,
1567                         g ? g->nativeGraphics : NULL, &result));
1568         return result;
1569 }
1570
1571 __inline__ BOOL GraphicsPath::IsVisible(const Point& point, const Graphics *g) const
1572 {
1573         BOOL result = FALSE;
1574         updateStatus(DllExports::GdipIsVisiblePathPointI(
1575                         nativePath, point.X, point.Y,
1576                         g ? g->nativeGraphics : NULL, &result));
1577         return result;
1578 }
1579
1580
1581 // PathData
1582
1583 __inline__ Status PathData::AllocateArrays(INT capacity)
1584 {
1585         if (capacity < 0) {
1586                 return InvalidParameter;
1587         } else if (Count < capacity) {
1588                 FreeArrays();
1589
1590                 PointF *pointArray = (PointF*)
1591                         DllExports::GdipAlloc(capacity * sizeof(PointF));
1592                 if (!pointArray)
1593                         return OutOfMemory;
1594
1595                 BYTE *typeArray = (BYTE*)
1596                         DllExports::GdipAlloc(capacity * sizeof(BYTE));
1597                 if (!typeArray) {
1598                         DllExports::GdipFree(pointArray);
1599                         return OutOfMemory;
1600                 }
1601
1602                 Count = capacity;
1603                 Points = pointArray;
1604                 Types = typeArray;
1605         }
1606         return Ok;
1607 }
1608
1609 __inline__ VOID PathData::FreeArrays()
1610 {
1611         if (Points) DllExports::GdipFree(Points);
1612         if (Types) DllExports::GdipFree(Types);
1613         Count = 0;
1614         Points = NULL;
1615         Types = NULL;
1616 }
1617
1618 #endif /* __GDIPLUS_IMPL_H */