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