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