ReactOS 0.4.15-dev-7659-ga55345b
gdiplusheaders.h
Go to the documentation of this file.
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
22class Image : public GdiplusBase
23{
24 public:
25 friend class Graphics;
26 friend class TextureBrush;
27
28 Image(IStream *stream, BOOL useEmbeddedColorManagement = FALSE) : nativeImage(NULL)
29 {
30 if (useEmbeddedColorManagement)
31 lastStatus = DllExports::GdipLoadImageFromStreamICM(stream, &nativeImage);
32 else
33 lastStatus = DllExports::GdipLoadImageFromStream(stream, &nativeImage);
34 }
35
36 Image(const WCHAR *filename, BOOL useEmbeddedColorManagement = FALSE) : nativeImage(NULL)
37 {
38 if (useEmbeddedColorManagement)
39 lastStatus = DllExports::GdipLoadImageFromFileICM(filename, &nativeImage);
40 else
41 lastStatus = DllExports::GdipLoadImageFromFile(filename, &nativeImage);
42 }
43
44 Image *
46 {
47 GpImage *cloneimage = NULL;
48 SetStatus(DllExports::GdipCloneImage(nativeImage, &cloneimage));
49 return new Image(cloneimage, lastStatus);
50 }
51
52 virtual ~Image()
53 {
54 DllExports::GdipDisposeImage(nativeImage);
55 }
56
57 static Image *
58 FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement = FALSE)
59 {
60 return new Image(filename, useEmbeddedColorManagement);
61 }
62
63 static Image *
64 FromStream(IStream *stream, BOOL useEmbeddedColorManagement = FALSE)
65 {
66 return new Image(stream, useEmbeddedColorManagement);
67 }
68
69 Status
70 GetAllPropertyItems(UINT totalBufferSize, UINT numProperties, PropertyItem *allItems)
71 {
72 if (allItems == NULL)
74 return SetStatus(DllExports::GdipGetAllPropertyItems(nativeImage, totalBufferSize, numProperties, allItems));
75 }
76
77 Status
78 GetBounds(RectF *srcRect, Unit *srcUnit)
79 {
80 return SetStatus(DllExports::GdipGetImageBounds(nativeImage, srcRect, srcUnit));
81 }
82
83 Status
85 {
86#if 1
88#else
89 return SetStatus(DllExports::GdipGetEncoderParameterList(nativeImage, clsidEncoder, size, buffer));
90#endif
91 }
92
93 UINT
95 {
96 UINT size = 0;
97 SetStatus(DllExports::GdipGetEncoderParameterListSize(nativeImage, clsidEncoder, &size));
98 return size;
99 }
100
101 UINT
103 {
104 UINT flags = 0;
105 SetStatus(DllExports::GdipGetImageFlags(nativeImage, &flags));
106 return flags;
107 }
108
109 UINT
110 GetFrameCount(const GUID *dimensionID)
111 {
112 UINT count = 0;
113 SetStatus(DllExports::GdipImageGetFrameCount(nativeImage, dimensionID, &count));
114 return count;
115 }
116
117 UINT
119 {
120 UINT count = 0;
121 SetStatus(DllExports::GdipImageGetFrameDimensionsCount(nativeImage, &count));
122 return count;
123 }
124
125 Status
127 {
128 return SetStatus(DllExports::GdipImageGetFrameDimensionsList(nativeImage, dimensionIDs, count));
129 }
130
131 UINT
133 {
134 UINT height = 0;
135 SetStatus(DllExports::GdipGetImageHeight(nativeImage, &height));
136 return height;
137 }
138
139 REAL
141 {
142 REAL resolution = 0.0f;
143 SetStatus(DllExports::GdipGetImageHorizontalResolution(nativeImage, &resolution));
144 return resolution;
145 }
146
147 Status
149 {
150 return lastStatus;
151 }
152
153 Status
155 {
156 return SetStatus(DllExports::GdipGetImagePalette(nativeImage, palette, size));
157 }
158
159 INT
161 {
162 INT size = 0;
163 SetStatus(DllExports::GdipGetImagePaletteSize(nativeImage, &size));
164 return size;
165 }
166
167 Status
169 {
170 if (size == NULL)
172
173 return SetStatus(DllExports::GdipGetImageDimension(nativeImage, &size->Width, &size->Height));
174 }
175
178 {
180 SetStatus(DllExports::GdipGetImagePixelFormat(nativeImage, &format));
181 return format;
182 }
183
184 UINT
186 {
187 UINT numOfProperty = 0;
188 SetStatus(DllExports::GdipGetPropertyCount(nativeImage, &numOfProperty));
189 return numOfProperty;
190 }
191
192 Status
194 {
195 return SetStatus(DllExports::GdipGetPropertyIdList(nativeImage, numOfProperty, list));
196 }
197
198 Status
200 {
201 return SetStatus(DllExports::GdipGetPropertyItem(nativeImage, propId, propSize, buffer));
202 }
203
204 UINT
206 {
207 UINT size = 0;
208 SetStatus(DllExports::GdipGetPropertyItemSize(nativeImage, propId, &size));
209 return size;
210 }
211
212 Status
213 GetPropertySize(UINT *totalBufferSize, UINT *numProperties)
214 {
215 return SetStatus(DllExports::GdipGetPropertySize(nativeImage, totalBufferSize, numProperties));
216 }
217
218 Status
220 {
221 return SetStatus(DllExports::GdipGetImageRawFormat(nativeImage, format));
222 }
223
224 Image *
225 GetThumbnailImage(UINT thumbWidth, UINT thumbHeight, GetThumbnailImageAbort callback, VOID *callbackData)
226 {
227 GpImage *thumbImage = NULL;
228 SetStatus(DllExports::GdipGetImageThumbnail(
229 nativeImage, thumbWidth, thumbHeight, &thumbImage, callback, callbackData));
230 Image *newImage = new Image(thumbImage, lastStatus);
231 if (newImage == NULL)
232 {
233 DllExports::GdipDisposeImage(thumbImage);
234 }
235 return newImage;
236 }
237
240 {
242 SetStatus(DllExports::GdipGetImageType(nativeImage, &type));
243 return type;
244 }
245
246 REAL
248 {
249 REAL resolution = 0.0f;
250 SetStatus(DllExports::GdipGetImageVerticalResolution(nativeImage, &resolution));
251 return resolution;
252 }
253
254 UINT
256 {
257 UINT width = 0;
258 SetStatus(DllExports::GdipGetImageWidth(nativeImage, &width));
259 return width;
260 }
261
262 Status
264 {
265 return SetStatus(DllExports::GdipRemovePropertyItem(nativeImage, propId));
266 }
267
268 Status
270 {
271 return SetStatus(DllExports::GdipImageRotateFlip(nativeImage, rotateFlipType));
272 }
273
274 Status
275 Save(IStream *stream, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
276 {
277 return SetStatus(DllExports::GdipSaveImageToStream(nativeImage, stream, clsidEncoder, encoderParams));
278 }
279
280 Status
281 Save(const WCHAR *filename, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
282 {
283 return SetStatus(DllExports::GdipSaveImageToFile(nativeImage, filename, clsidEncoder, encoderParams));
284 }
285
286 Status
287 SaveAdd(const EncoderParameters *encoderParams)
288 {
289 return SetStatus(DllExports::GdipSaveAdd(nativeImage, encoderParams));
290 }
291
292 Status
293 SaveAdd(Image *newImage, const EncoderParameters *encoderParams)
294 {
295#if 1
296 // FIXME: Not available yet
298#else
299 if (!newImage)
301
302 return SetStatus(DllExports::GdipSaveAddImage(nativeImage, getNat(newImage), encoderParams));
303#endif
304 }
305
306 Status
307 SelectActiveFrame(const GUID *dimensionID, UINT frameIndex)
308 {
309 return SetStatus(DllExports::GdipImageSelectActiveFrame(nativeImage, dimensionID, frameIndex));
310 }
311
312 Status
314 {
315 return SetStatus(DllExports::GdipSetImagePalette(nativeImage, palette));
316 }
317
318 Status
320 {
321 return SetStatus(DllExports::GdipSetPropertyItem(nativeImage, item));
322 }
323
324#if 0
325 ImageLayout
326 GetLayout() const
327 {
329 }
330
331 Status
332 SetLayout(const ImageLayout layout)
333 {
335 }
336#endif
337
338 protected:
341
343 {
344 }
345
347 {
348 }
349
350 Status
352 {
353 if (status != Ok)
355 return status;
356 }
357
358 void
360 {
362 }
363
364 private:
365 // Image is not copyable
366 Image(const Image &);
367 Image &
368 operator=(const Image &);
369
370 // get native
371 friend inline GpImage *&
373 {
374 return const_cast<Image *>(image)->nativeImage;
375 }
376};
377
378class Bitmap : public Image
379{
380 friend class CachedBitmap;
381
382 public:
383 // Bitmap(IDirectDrawSurface7 *surface) // <-- FIXME: compiler does not like this
384 // {
385 // lastStatus = DllExports::GdipCreateBitmapFromDirectDrawSurface(surface, &bitmap);
386 // }
387
389 {
391 lastStatus = DllExports::GdipCreateBitmapFromGraphics(width, height, target ? getNat(target) : NULL, &bitmap);
393 }
394
395 Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
396 {
398 lastStatus = DllExports::GdipCreateBitmapFromGdiDib(gdiBitmapInfo, gdiBitmapData, &bitmap);
400 }
401
403 {
405 lastStatus = DllExports::GdipCreateBitmapFromScan0(width, height, 0, format, NULL, &bitmap);
407 }
408
409 Bitmap(HBITMAP hbm, HPALETTE hpal)
410 {
412 lastStatus = DllExports::GdipCreateBitmapFromHBITMAP(hbm, hpal, &bitmap);
414 }
415
417 {
419 lastStatus = DllExports::GdipCreateBitmapFromScan0(width, height, stride, format, scan0, &bitmap);
421 }
422
423 Bitmap(const WCHAR *filename, BOOL useIcm)
424 {
426
427 if (useIcm)
428 lastStatus = DllExports::GdipCreateBitmapFromFileICM(filename, &bitmap);
429 else
430 lastStatus = DllExports::GdipCreateBitmapFromFile(filename, &bitmap);
431
433 }
434
435 Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName)
436 {
438 lastStatus = DllExports::GdipCreateBitmapFromResource(hInstance, bitmapName, &bitmap);
440 }
441
443 {
445 lastStatus = DllExports::GdipCreateBitmapFromHICON(hicon, &bitmap);
447 }
448
450 {
452 if (useIcm)
453 lastStatus = DllExports::GdipCreateBitmapFromStreamICM(stream, &bitmap);
454 else
455 lastStatus = DllExports::GdipCreateBitmapFromStream(stream, &bitmap);
457 }
458
459 Bitmap *
461 {
462 return Clone(rect.X, rect.Y, rect.Width, rect.Height, format);
463 }
464
465 Bitmap *
467 {
468 return Clone(rect.X, rect.Y, rect.Width, rect.Height, format);
469 }
470
471 Bitmap *
473 {
475 lastStatus = DllExports::GdipCloneBitmapArea(x, y, width, height, format, GetNativeBitmap(), &bitmap);
476
477 if (lastStatus != Ok)
478 return NULL;
479
480 Bitmap *newBitmap = new Bitmap(bitmap);
481 if (newBitmap == NULL)
482 {
483 DllExports::GdipDisposeImage(bitmap);
484 }
485
486 return newBitmap;
487 }
488
489 Bitmap *
491 {
493 lastStatus = DllExports::GdipCloneBitmapAreaI(x, y, width, height, format, GetNativeBitmap(), &bitmap);
494
495 if (lastStatus != Ok)
496 return NULL;
497
498 Bitmap *newBitmap = new Bitmap(bitmap);
499 if (newBitmap == NULL)
500 {
501 DllExports::GdipDisposeImage(bitmap);
502 }
503
504 return newBitmap;
505 }
506
507 static Bitmap *
508 FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
509 {
510 return new Bitmap(gdiBitmapInfo, gdiBitmapData);
511 }
512
513 // static Bitmap *FromDirectDrawSurface7(IDirectDrawSurface7 *surface) // <-- FIXME: compiler does not like this
514 // {
515 // return new Bitmap(surface);
516 // }
517
518 static Bitmap *
519 FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
520 {
521 return new Bitmap(filename, useEmbeddedColorManagement);
522 }
523
524 static Bitmap *
525 FromHBITMAP(HBITMAP hbm, HPALETTE hpal)
526 {
527 return new Bitmap(hbm, hpal);
528 }
529
530 static Bitmap *
532 {
533 return new Bitmap(hicon);
534 }
535
536 static Bitmap *
538 {
539 return new Bitmap(hInstance, bitmapName);
540 }
541
542 static Bitmap *
543 FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
544 {
545 return new Bitmap(stream, useEmbeddedColorManagement);
546 }
547
548 Status
549 GetHBITMAP(const Color &colorBackground, HBITMAP *hbmReturn)
550 {
551 return SetStatus(
552 DllExports::GdipCreateHBITMAPFromBitmap(GetNativeBitmap(), hbmReturn, colorBackground.GetValue()));
553 }
554
555 Status
557 {
558 return SetStatus(DllExports::GdipCreateHICONFromBitmap(GetNativeBitmap(), hicon));
559 }
560
561 Status
563 {
564 ARGB argb;
565 Status s = SetStatus(DllExports::GdipBitmapGetPixel(GetNativeBitmap(), x, y, &argb));
566 if (color)
567 color->SetValue(argb);
568 return s;
569 }
570
571 Status
573 {
574 return SetStatus(DllExports::GdipBitmapLockBits(GetNativeBitmap(), rect, flags, format, lockedBitmapData));
575 }
576
577 Status
579 {
580 return SetStatus(DllExports::GdipBitmapSetPixel(GetNativeBitmap(), x, y, color.GetValue()));
581 }
582
583 Status
585 {
586 return SetStatus(DllExports::GdipBitmapSetResolution(GetNativeBitmap(), xdpi, ydpi));
587 }
588
589 Status
590 UnlockBits(BitmapData *lockedBitmapData)
591 {
592 return SetStatus(DllExports::GdipBitmapUnlockBits(GetNativeBitmap(), lockedBitmapData));
593 }
594
595 protected:
597 {
598 }
599
600 Bitmap(GpBitmap *nativeBitmap)
601 {
602 lastStatus = Ok;
603 SetNativeImage(nativeBitmap);
604 }
605
606 GpBitmap *
608 {
609 return static_cast<GpBitmap *>(nativeImage);
610 }
611};
612
614{
615 public:
617 {
619 lastStatus = DllExports::GdipCreateCachedBitmap(
620 bitmap->GetNativeBitmap(), graphics ? getNat(graphics) : NULL, &nativeCachedBitmap);
621 }
622
624 {
625 DllExports::GdipDeleteCachedBitmap(nativeCachedBitmap);
626 }
627
628 Status
630 {
631 return lastStatus;
632 }
633
634 protected:
637
638 private:
639 // CachedBitmap is not copyable
643
644 // get native
645 friend inline GpCachedBitmap *&
647 {
648 return const_cast<CachedBitmap *>(cb)->nativeCachedBitmap;
649 }
650};
651
653{
654 friend class FontFamily;
655
656 public:
658 {
659 }
660
662 {
663 }
664
665 Status
666 GetFamilies(INT numSought, FontFamily *gpfamilies, INT *numFound) const
667 {
669 }
670
671 INT
673 {
674 INT numFound = 0;
675 lastStatus = DllExports::GdipGetFontCollectionFamilyCount(nativeFontCollection, &numFound);
676 return numFound;
677 }
678
679 Status
681 {
682 return lastStatus;
683 }
684
685 protected:
688
689 Status
691 {
692 if (status != Ok)
694 return status;
695 }
696
697 private:
698 // FontCollection is not copyable
702
703 // get native
704 friend inline GpFontCollection *&
706 {
707 return const_cast<FontCollection *>(fc)->nativeFontCollection;
708 }
709};
710
712{
713 friend class Font;
714
715 public:
717 {
718 }
719
720 FontFamily(const WCHAR *name, const FontCollection *fontCollection)
721 {
722 GpFontCollection *theCollection = fontCollection ? getNat(fontCollection) : NULL;
723 status = DllExports::GdipCreateFontFamilyFromName(name, theCollection, &fontFamily);
724 }
725
726 FontFamily *
728 {
729 return NULL;
730 }
731
732 static const FontFamily *
734 {
735 FontFamily *genericMonospace = new FontFamily();
736 genericMonospace->status =
737 DllExports::GdipGetGenericFontFamilyMonospace(genericMonospace ? &genericMonospace->fontFamily : NULL);
738 return genericMonospace;
739 }
740
741 static const FontFamily *
743 {
744 FontFamily *genericSansSerif = new FontFamily();
745 genericSansSerif->status =
746 DllExports::GdipGetGenericFontFamilySansSerif(genericSansSerif ? &genericSansSerif->fontFamily : NULL);
747 return genericSansSerif;
748 }
749
750 static const FontFamily *
752 {
753 FontFamily *genericSerif = new FontFamily();
754 genericSerif->status =
755 DllExports::GdipGetGenericFontFamilyMonospace(genericSerif ? &genericSerif->fontFamily : NULL);
756 return genericSerif;
757 }
758
759 UINT16
761 {
762 UINT16 CellAscent;
763 SetStatus(DllExports::GdipGetCellAscent(fontFamily, style, &CellAscent));
764 return CellAscent;
765 }
766
767 UINT16
769 {
770 UINT16 CellDescent;
771 SetStatus(DllExports::GdipGetCellDescent(fontFamily, style, &CellDescent));
772 return CellDescent;
773 }
774
775 UINT16
777 {
778 UINT16 EmHeight;
779 SetStatus(DllExports::GdipGetEmHeight(fontFamily, style, &EmHeight));
780 return EmHeight;
781 }
782
783 Status
785 {
786 return SetStatus(DllExports::GdipGetFamilyName(fontFamily, name, language));
787 }
788
789 Status
791 {
792 return status;
793 }
794
795 UINT16
797 {
798 UINT16 LineSpacing;
799 SetStatus(DllExports::GdipGetLineSpacing(fontFamily, style, &LineSpacing));
800 return LineSpacing;
801 }
802
803 BOOL
805 {
806 return FALSE;
807 }
808
809 BOOL
811 {
812 BOOL StyleAvailable;
813 SetStatus(DllExports::GdipIsStyleAvailable(fontFamily, style, &StyleAvailable));
814 return StyleAvailable;
815 }
816
817 private:
818 mutable Status status;
820
821 Status
823 {
824 if (status == Ok)
825 return status;
826 this->status = status;
827 return status;
828 }
829
830 // get native
831 friend inline GpFontFamily *&
833 {
834 return const_cast<FontFamily *>(ff)->fontFamily;
835 }
836};
837
839{
840 public:
842 {
843 }
844};
845
847{
848 public:
850 {
852 lastStatus = DllExports::GdipNewPrivateFontCollection(&nativeFontCollection);
853 }
854
856 {
857 DllExports::GdipDeletePrivateFontCollection(&nativeFontCollection);
858 }
859
860 Status
862 {
863 return SetStatus(DllExports::GdipPrivateAddFontFile(nativeFontCollection, filename));
864 }
865
866 Status
868 {
869 return SetStatus(DllExports::GdipPrivateAddMemoryFont(nativeFontCollection, memory, length));
870 }
871};
872
873class Font : public GdiplusBase
874{
875 public:
876 friend class FontFamily;
877 friend class FontCollection;
878 friend class Graphics;
879
880 Font(const FontFamily *family, REAL emSize, INT style, Unit unit)
881 {
882 status = DllExports::GdipCreateFont(family->fontFamily, emSize, style, unit, &font);
883 }
884
886 {
887 }
888
889 Font(HDC hdc, const LOGFONTA *logfont)
890 {
891 status = DllExports::GdipCreateFontFromLogfontA(hdc, logfont, &font);
892 }
893
894 Font(HDC hdc, const LOGFONTW *logfont)
895 {
896 status = DllExports::GdipCreateFontFromLogfontW(hdc, logfont, &font);
897 }
898
899 Font(const WCHAR *familyName, REAL emSize, INT style, Unit unit, const FontCollection *fontCollection)
900 {
901 }
902
904 {
905 status = DllExports::GdipCreateFontFromDC(hdc, &font);
906 }
907
908 Font *
909 Clone() const
910 {
911 Font *cloneFont = new Font();
912 cloneFont->status = DllExports::GdipCloneFont(font, cloneFont ? &cloneFont->font : NULL);
913 return cloneFont;
914 }
915
916 Status
917 GetFamily(FontFamily *family) const
918 {
919 return SetStatus(DllExports::GdipGetFamily(font, family ? &family->fontFamily : NULL));
920 }
921
922 REAL
923 GetHeight(const Graphics *graphics) const
924 {
925 REAL height;
926 SetStatus(DllExports::GdipGetFontHeight(font, graphics ? getNat(graphics) : NULL, &height));
927 return height;
928 }
929
930 REAL
932 {
933 REAL height;
934 SetStatus(DllExports::GdipGetFontHeightGivenDPI(font, dpi, &height));
935 return height;
936 }
937
938 Status
940 {
941 return status;
942 }
943
944 Status
945 GetLogFontA(const Graphics *g, LOGFONTA *logfontA) const
946 {
947 return SetStatus(DllExports::GdipGetLogFontA(font, g ? getNat(g) : NULL, logfontA));
948 }
949
950 Status
951 GetLogFontW(const Graphics *g, LOGFONTW *logfontW) const
952 {
953 return SetStatus(DllExports::GdipGetLogFontW(font, g ? getNat(g) : NULL, logfontW));
954 }
955
956 REAL
957 GetSize() const
958 {
959 REAL size;
960 SetStatus(DllExports::GdipGetFontSize(font, &size));
961 return size;
962 }
963
964 INT
965 GetStyle() const
966 {
967 INT style;
968 SetStatus(DllExports::GdipGetFontStyle(font, &style));
969 return style;
970 }
971
972 Unit
973 GetUnit() const
974 {
975 Unit unit;
976 SetStatus(DllExports::GdipGetFontUnit(font, &unit));
977 return unit;
978 }
979
980 BOOL
982 {
983 return FALSE;
984 }
985
986 protected:
988 {
989 }
990
991 private:
992 mutable Status status;
994
995 Status
997 {
998 if (status == Ok)
999 return status;
1000 this->status = status;
1001 return status;
1002 }
1003
1004 // get native
1005 friend inline GpFont *&
1007 {
1008 return const_cast<Font *>(font)->font;
1009 }
1010};
1011
1012class Region : public GdiplusBase
1013{
1014 public:
1015 friend class Graphics;
1016 friend class GraphicsPath;
1017 friend class Matrix;
1018
1020 {
1021 lastStatus = DllExports::GdipCreateRegionRectI(&rect, &nativeRegion);
1022 }
1023
1025 {
1026 lastStatus = DllExports::GdipCreateRegion(&nativeRegion);
1027 }
1028
1029 Region(const BYTE *regionData, INT size)
1030 {
1031 lastStatus = DllExports::GdipCreateRegionRgnData(regionData, size, &nativeRegion);
1032 }
1033
1035 {
1036 lastStatus = DllExports::GdipCreateRegionPath(getNat(path), &nativeRegion);
1037 }
1038
1040 {
1041 lastStatus = DllExports::GdipCreateRegionHrgn(hRgn, &nativeRegion);
1042 }
1043
1045 {
1046 lastStatus = DllExports::GdipCreateRegionRect(&rect, &nativeRegion);
1047 }
1048
1049 Region *
1051 {
1052 Region *cloneRegion = new Region();
1053 cloneRegion->lastStatus =
1054 DllExports::GdipCloneRegion(nativeRegion, cloneRegion ? &cloneRegion->nativeRegion : NULL);
1055 return cloneRegion;
1056 }
1057
1058 Status
1060 {
1061 GpPath *thePath = path ? getNat(path) : NULL;
1062 return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion, thePath, CombineModeComplement));
1063 }
1064
1065 Status
1066 Complement(const Region *region)
1067 {
1068 GpRegion *theRegion = region ? getNat(region) : NULL;
1069 return SetStatus(DllExports::GdipCombineRegionRegion(nativeRegion, theRegion, CombineModeComplement));
1070 }
1071
1072 Status
1074 {
1075 return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeComplement));
1076 }
1077
1078 Status
1080 {
1081 return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeComplement));
1082 }
1083
1084 BOOL
1085 Equals(const Region *region, const Graphics *g) const
1086 {
1087 BOOL result;
1088 SetStatus(
1089 DllExports::GdipIsEqualRegion(nativeRegion, region ? getNat(region) : NULL, g ? getNat(g) : NULL, &result));
1090 return result;
1091 }
1092
1093 Status
1095 {
1096 return SetStatus(
1097 DllExports::GdipCombineRegionPath(nativeRegion, path ? getNat(path) : NULL, CombineModeExclude));
1098 }
1099
1100 Status
1102 {
1103 return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeExclude));
1104 }
1105
1106 Status
1108 {
1109 return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeExclude));
1110 }
1111
1112 Status
1113 Exclude(const Region *region)
1114 {
1115 return SetStatus(
1116 DllExports::GdipCombineRegionRegion(nativeRegion, region ? getNat(region) : NULL, CombineModeExclude));
1117 }
1118
1119 static Region *
1121 {
1122 return new Region(hRgn);
1123 }
1124
1125 Status
1126 GetBounds(Rect *rect, const Graphics *g) const
1127 {
1128 return SetStatus(DllExports::GdipGetRegionBoundsI(nativeRegion, g ? getNat(g) : NULL, rect));
1129 }
1130
1131 Status
1133 {
1134 return SetStatus(DllExports::GdipGetRegionBounds(nativeRegion, g ? getNat(g) : NULL, rect));
1135 }
1136
1137 Status
1138 GetData(BYTE *buffer, UINT bufferSize, UINT *sizeFilled) const
1139 {
1140 return SetStatus(DllExports::GdipGetRegionData(nativeRegion, buffer, bufferSize, sizeFilled));
1141 }
1142
1143 UINT
1145 {
1147 SetStatus(DllExports::GdipGetRegionDataSize(nativeRegion, &bufferSize));
1148 return bufferSize;
1149 }
1150
1151 HRGN
1152 GetHRGN(const Graphics *g) const
1153 {
1154 HRGN hRgn;
1155 SetStatus(DllExports::GdipGetRegionHRgn(nativeRegion, g ? getNat(g) : NULL, &hRgn));
1156 return hRgn;
1157 }
1158
1159 Status
1161 {
1162 return lastStatus;
1163 }
1164
1165 Status
1166 GetRegionScans(const Matrix *matrix, Rect *rects, INT *count) const
1167 {
1168 return SetStatus(DllExports::GdipGetRegionScansI(nativeRegion, rects, count, matrix ? getNat(matrix) : NULL));
1169 }
1170
1171 Status
1172 GetRegionScans(const Matrix *matrix, RectF *rects, INT *count) const
1173 {
1174 return SetStatus(DllExports::GdipGetRegionScans(nativeRegion, rects, count, matrix ? getNat(matrix) : NULL));
1175 }
1176
1177 UINT
1179 {
1180 UINT count;
1181 SetStatus(DllExports::GdipGetRegionScansCount(nativeRegion, &count, matrix ? getNat(matrix) : NULL));
1182 return count;
1183 }
1184
1185 Status
1187 {
1188 return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeIntersect));
1189 }
1190
1191 Status
1193 {
1194 GpPath *thePath = path ? getNat(path) : NULL;
1195 return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion, thePath, CombineModeIntersect));
1196 }
1197
1198 Status
1200 {
1201 return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeIntersect));
1202 }
1203
1204 Status
1205 Intersect(const Region *region)
1206 {
1207 return SetStatus(
1208 DllExports::GdipCombineRegionRegion(nativeRegion, region ? getNat(region) : NULL, CombineModeIntersect));
1209 }
1210
1211 BOOL
1212 IsEmpty(const Graphics *g) const
1213 {
1214 BOOL result;
1215 SetStatus(DllExports::GdipIsEmptyRegion(nativeRegion, g ? getNat(g) : NULL, &result));
1216 return result;
1217 }
1218
1219 BOOL
1220 IsInfinite(const Graphics *g) const
1221 {
1222 BOOL result;
1223 SetStatus(DllExports::GdipIsInfiniteRegion(nativeRegion, g ? getNat(g) : NULL, &result));
1224 return result;
1225 }
1226
1227 BOOL
1228 IsVisible(const PointF &point, const Graphics *g) const
1229 {
1230 BOOL result;
1231 SetStatus(DllExports::GdipIsVisibleRegionPoint(nativeRegion, point.X, point.Y, g ? getNat(g) : NULL, &result));
1232 return result;
1233 }
1234
1235 BOOL
1236 IsVisible(const RectF &rect, const Graphics *g) const
1237 {
1238 BOOL result;
1239 SetStatus(DllExports::GdipIsVisibleRegionRect(
1240 nativeRegion, rect.X, rect.Y, rect.Width, rect.Height, g ? getNat(g) : NULL, &result));
1241 return result;
1242 }
1243
1244 BOOL
1245 IsVisible(const Rect &rect, const Graphics *g) const
1246 {
1247 BOOL result;
1248 SetStatus(DllExports::GdipIsVisibleRegionRectI(
1249 nativeRegion, rect.X, rect.Y, rect.Width, rect.Height, g ? getNat(g) : NULL, &result));
1250 return result;
1251 }
1252
1253 BOOL
1254 IsVisible(INT x, INT y, const Graphics *g) const
1255 {
1256 BOOL result;
1257 SetStatus(DllExports::GdipIsVisibleRegionPointI(nativeRegion, x, y, g ? getNat(g) : NULL, &result));
1258 return result;
1259 }
1260
1261 BOOL
1262 IsVisible(REAL x, REAL y, const Graphics *g) const
1263 {
1264 BOOL result;
1265 SetStatus(DllExports::GdipIsVisibleRegionPoint(nativeRegion, x, y, g ? getNat(g) : NULL, &result));
1266 return result;
1267 }
1268
1269 BOOL
1271 {
1272 BOOL result;
1273 SetStatus(
1274 DllExports::GdipIsVisibleRegionRectI(nativeRegion, x, y, width, height, g ? getNat(g) : NULL, &result));
1275 return result;
1276 }
1277
1278 BOOL
1279 IsVisible(const Point &point, const Graphics *g) const
1280 {
1281 BOOL result;
1282 SetStatus(DllExports::GdipIsVisibleRegionPointI(nativeRegion, point.X, point.Y, g ? getNat(g) : NULL, &result));
1283 return result;
1284 }
1285
1286 BOOL
1288 {
1289 BOOL result;
1290 SetStatus(
1291 DllExports::GdipIsVisibleRegionRect(nativeRegion, x, y, width, height, g ? getNat(g) : NULL, &result));
1292 return result;
1293 }
1294
1295 Status
1297 {
1298 return SetStatus(DllExports::GdipSetEmpty(nativeRegion));
1299 }
1300
1301 Status
1303 {
1304 return SetStatus(DllExports::GdipSetInfinite(nativeRegion));
1305 }
1306
1307 Status
1309 {
1310 return SetStatus(DllExports::GdipTransformRegion(nativeRegion, matrix ? getNat(matrix) : NULL));
1311 }
1312
1313 Status
1315 {
1316 return SetStatus(DllExports::GdipTranslateRegion(nativeRegion, dx, dy));
1317 }
1318
1319 Status
1321 {
1322 return SetStatus(DllExports::GdipTranslateRegionI(nativeRegion, dx, dy));
1323 }
1324
1325 Status
1327 {
1328 return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeUnion));
1329 }
1330
1331 Status
1332 Union(const Region *region)
1333 {
1334 return SetStatus(
1335 DllExports::GdipCombineRegionRegion(nativeRegion, region ? getNat(region) : NULL, CombineModeUnion));
1336 }
1337
1338 Status
1340 {
1341 return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeUnion));
1342 }
1343
1344 Status
1346 {
1347 return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion, path ? getNat(path) : NULL, CombineModeUnion));
1348 }
1349
1350 Status
1352 {
1353 return SetStatus(DllExports::GdipCombineRegionPath(nativeRegion, path ? getNat(path) : NULL, CombineModeXor));
1354 }
1355
1356 Status
1358 {
1359 return SetStatus(DllExports::GdipCombineRegionRect(nativeRegion, &rect, CombineModeXor));
1360 }
1361
1362 Status
1363 Xor(const Rect &rect)
1364 {
1365 return SetStatus(DllExports::GdipCombineRegionRectI(nativeRegion, &rect, CombineModeXor));
1366 }
1367
1368 Status
1369 Xor(const Region *region)
1370 {
1371 return SetStatus(
1372 DllExports::GdipCombineRegionRegion(nativeRegion, region ? getNat(region) : NULL, CombineModeXor));
1373 }
1374
1375 private:
1378
1379 Status
1381 {
1382 if (status != Ok)
1384 return status;
1385 }
1386
1387 // get native
1388 friend inline GpRegion *&
1389 getNat(const Region *region)
1390 {
1391 return const_cast<Region *>(region)->nativeRegion;
1392 }
1393};
1394
1396{
1397 public:
1398 CustomLineCap(const GraphicsPath *fillPath, const GraphicsPath *strokePath, LineCap baseCap, REAL baseInset = 0);
1399
1401
1403 Clone();
1404
1405 LineCap
1406 GetBaseCap();
1407
1408 REAL
1409 GetBaseInset();
1410
1411 Status
1412 GetLastStatus();
1413
1414 Status
1415 GetStrokeCaps(LineCap *startCap, LineCap *endCap);
1416
1417 LineJoin
1418 GetStrokeJoin();
1419
1420 REAL
1421 GetWidthScale();
1422
1423 Status
1424 SetBaseCap(LineCap baseCap);
1425
1426 Status
1427 SetBaseInset(REAL inset);
1428
1429 Status
1430 SetStrokeCap(LineCap strokeCap);
1431
1432 Status
1433 SetStrokeCaps(LineCap startCap, LineCap endCap);
1434
1435 Status
1436 SetStrokeJoin(LineJoin lineJoin);
1437
1438 Status
1439 SetWidthScale(IN REAL widthScale);
1440
1441 protected:
1444
1446 {
1447 }
1448
1450 {
1451 }
1452
1453 void
1455 {
1456 nativeCap = cap;
1457 }
1458
1459 Status
1461 {
1462 if (status == Ok)
1464 return status;
1465 }
1466
1467 private:
1468 // CustomLineCap is not copyable
1472
1473 // get native
1474 friend inline GpCustomLineCap *&
1476 {
1477 return const_cast<CustomLineCap *>(cap)->nativeCap;
1478 }
1479};
1480
1481inline Image *
1483{
1484 GpImage *image = NULL;
1486 SetStatus(DllExports::GdipGetTextureImage(texture, &image));
1487 if (lastStatus != Ok)
1488 return NULL;
1489
1490 Image *newImage = new Image(image, lastStatus);
1491 if (!newImage)
1492 DllExports::GdipDisposeImage(image);
1493 return newImage;
1494}
1495
1496#endif /* _GDIPLUSHEADERS_H */
static HFONT hfont
unsigned short UINT16
Arabic default style
Definition: afstyles.h:94
PFOR_CONTEXT fc
Definition: for.c:57
HINSTANCE hInstance
Definition: charmap.c:19
Bitmap(GpBitmap *nativeBitmap)
static Bitmap * FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement)
Status GetHBITMAP(const Color &colorBackground, HBITMAP *hbmReturn)
static Bitmap * FromHICON(HICON hicon)
static Bitmap * FromBITMAPINFO(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
Bitmap(const WCHAR *filename, BOOL useIcm)
Bitmap(HICON hicon)
Bitmap(IStream *stream, BOOL useIcm)
Bitmap(INT width, INT height, Graphics *target)
static Bitmap * FromStream(IStream *stream, BOOL useEmbeddedColorManagement)
Status UnlockBits(BitmapData *lockedBitmapData)
Bitmap * Clone(const RectF &rect, PixelFormat format)
Bitmap(const BITMAPINFO *gdiBitmapInfo, VOID *gdiBitmapData)
Bitmap * Clone(const Rect &rect, PixelFormat format)
Status SetPixel(INT x, INT y, const Color &color)
GpBitmap * GetNativeBitmap() const
static Bitmap * FromResource(HINSTANCE hInstance, const WCHAR *bitmapName)
static Bitmap * FromHBITMAP(HBITMAP hbm, HPALETTE hpal)
Bitmap * Clone(INT x, INT y, INT width, INT height, PixelFormat format)
Status GetPixel(INT x, INT y, Color *color)
Bitmap(INT width, INT height, INT stride, PixelFormat format, BYTE *scan0)
Bitmap(HINSTANCE hInstance, const WCHAR *bitmapName)
Status GetHICON(HICON *hicon)
Status LockBits(const Rect *rect, UINT flags, PixelFormat format, BitmapData *lockedBitmapData)
Status SetResolution(REAL xdpi, REAL ydpi)
Bitmap(INT width, INT height, PixelFormat format)
Bitmap * Clone(REAL x, REAL y, REAL width, REAL height, PixelFormat format)
Bitmap(HBITMAP hbm, HPALETTE hpal)
Status SetStatus(Status status) const
Definition: gdiplusbrush.h:76
Status lastStatus
Definition: gdiplusbrush.h:65
Status GetLastStatus()
friend GpCachedBitmap *& getNat(const CachedBitmap *cb)
GpCachedBitmap * nativeCachedBitmap
CachedBitmap & operator=(const CachedBitmap &)
CachedBitmap(const CachedBitmap &)
CachedBitmap(Bitmap *bitmap, Graphics *graphics)
CustomLineCap(GpCustomLineCap *cap, Status status)
void SetNativeCap(GpCustomLineCap *cap)
CustomLineCap & operator=(const CustomLineCap &)
Status SetStrokeCap(LineCap strokeCap)
REAL GetWidthScale()
Status GetStrokeCaps(LineCap *startCap, LineCap *endCap)
Status GetLastStatus()
LineJoin GetStrokeJoin()
GpCustomLineCap * nativeCap
Status SetStrokeJoin(LineJoin lineJoin)
Status SetStatus(Status status) const
Status SetWidthScale(IN REAL widthScale)
Status SetBaseInset(REAL inset)
Status SetStrokeCaps(LineCap startCap, LineCap endCap)
CustomLineCap(const CustomLineCap &)
LineCap GetBaseCap()
Status SetBaseCap(LineCap baseCap)
CustomLineCap * Clone()
friend GpCustomLineCap *& getNat(const CustomLineCap *cap)
FontCollection(const FontCollection &)
Status GetLastStatus() const
virtual ~FontCollection()
INT GetFamilyCount() const
friend GpFontCollection *& getNat(const FontCollection *fc)
FontCollection & operator=(const FontCollection &)
Status SetStatus(Status status) const
Status GetFamilies(INT numSought, FontFamily *gpfamilies, INT *numFound) const
GpFontCollection * nativeFontCollection
static const FontFamily * GenericSansSerif()
UINT16 GetCellDescent(INT style) const
static const FontFamily * GenericMonospace()
Status GetLastStatus() const
UINT16 GetCellAscent(INT style) const
FontFamily(const WCHAR *name, const FontCollection *fontCollection)
BOOL IsAvailable() const
UINT16 GetEmHeight(INT style)
Status SetStatus(Status status) const
GpFontFamily * fontFamily
static const FontFamily * GenericSerif()
BOOL IsStyleAvailable(INT style) const
FontFamily * Clone()
Status GetFamilyName(WCHAR name[LF_FACESIZE], WCHAR language) const
UINT16 GetLineSpacing(INT style) const
friend GpFontFamily *& getNat(const FontFamily *ff)
Status GetLogFontA(const Graphics *g, LOGFONTA *logfontA) const
Status GetLastStatus() const
Font(HDC hdc, const HFONT hfont)
friend GpFont *& getNat(const Font *font)
Unit GetUnit() const
Font(HDC hdc, const LOGFONTW *logfont)
Font(HDC hdc)
GpFont * font
INT GetStyle() const
Font(HDC hdc, const LOGFONTA *logfont)
BOOL IsAvailable() const
Font * Clone() const
REAL GetHeight(REAL dpi) const
Status SetStatus(Status status) const
Status GetLogFontW(const Graphics *g, LOGFONTW *logfontW) const
Status GetFamily(FontFamily *family) const
Font(const WCHAR *familyName, REAL emSize, INT style, Unit unit, const FontCollection *fontCollection)
Status status
REAL GetSize() const
REAL GetHeight(const Graphics *graphics) const
Font(const FontFamily *family, REAL emSize, INT style, Unit unit)
Status GetPropertySize(UINT *totalBufferSize, UINT *numProperties)
Status SaveAdd(Image *newImage, const EncoderParameters *encoderParams)
Status GetFrameDimensionsList(GUID *dimensionIDs, UINT count)
void SetNativeImage(GpImage *image)
ImageType GetType()
UINT GetFlags()
Status GetPalette(ColorPalette *palette, INT size)
Status GetAllPropertyItems(UINT totalBufferSize, UINT numProperties, PropertyItem *allItems)
Status lastStatus
Image(GpImage *image, Status status)
INT GetPaletteSize()
virtual ~Image()
UINT GetFrameDimensionsCount()
Status SetPropertyItem(const PropertyItem *item)
Image(IStream *stream, BOOL useEmbeddedColorManagement=FALSE)
Status GetPropertyItem(PROPID propId, UINT propSize, PropertyItem *buffer)
friend GpImage *& getNat(const Image *image)
Image(const Image &)
Status Save(const WCHAR *filename, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
Status SaveAdd(const EncoderParameters *encoderParams)
Status SetStatus(Status status) const
UINT GetPropertyItemSize(PROPID propId)
Status Save(IStream *stream, const CLSID *clsidEncoder, const EncoderParameters *encoderParams)
Status GetPropertyIdList(UINT numOfProperty, PROPID *list)
Status SetPalette(const ColorPalette *palette)
Status SelectActiveFrame(const GUID *dimensionID, UINT frameIndex)
UINT GetPropertyCount()
PixelFormat GetPixelFormat()
Status RemovePropertyItem(PROPID propId)
Status GetRawFormat(GUID *format)
Status GetPhysicalDimension(SizeF *size)
REAL GetVerticalResolution()
UINT GetFrameCount(const GUID *dimensionID)
static Image * FromStream(IStream *stream, BOOL useEmbeddedColorManagement=FALSE)
Status RotateFlip(RotateFlipType rotateFlipType)
static Image * FromFile(const WCHAR *filename, BOOL useEmbeddedColorManagement=FALSE)
UINT GetWidth()
Image * Clone()
REAL GetHorizontalResolution()
Status GetBounds(RectF *srcRect, Unit *srcUnit)
Image * GetThumbnailImage(UINT thumbWidth, UINT thumbHeight, GetThumbnailImageAbort callback, VOID *callbackData)
UINT GetEncoderParameterListSize(const CLSID *clsidEncoder)
Status GetLastStatus()
Status GetEncoderParameterList(const CLSID *clsidEncoder, UINT size, EncoderParameters *buffer)
Image & operator=(const Image &)
GpImage * nativeImage
UINT GetHeight()
Image(const WCHAR *filename, BOOL useEmbeddedColorManagement=FALSE)
Status AddFontFile(const WCHAR *filename)
virtual ~PrivateFontCollection()
Status AddMemoryFont(const VOID *memory, INT length)
GpRegion * nativeRegion
Status Union(const Region *region)
static Region * FromHRGN(HRGN hRgn)
Region(const BYTE *regionData, INT size)
Status GetRegionScans(const Matrix *matrix, RectF *rects, INT *count) const
BOOL IsVisible(const PointF &point, const Graphics *g) const
Status Exclude(const GraphicsPath *path)
Status Xor(const Region *region)
Status Union(const GraphicsPath *path)
Status GetBounds(RectF *rect, const Graphics *g) const
Status Translate(REAL dx, REAL dy)
Status GetLastStatus()
Status Intersect(const GraphicsPath *path)
Status GetBounds(Rect *rect, const Graphics *g) const
BOOL IsVisible(INT x, INT y, const Graphics *g) const
Status Union(const RectF &rect)
Status Exclude(const Rect &rect)
UINT GetDataSize() const
Status Union(const Rect &rect)
Status Xor(const RectF &rect)
Region(const GraphicsPath *path)
Status Exclude(const RectF &rect)
Region(const Rect &rect)
Status lastStatus
HRGN GetHRGN(const Graphics *g) const
Status Transform(const Matrix *matrix)
Status Intersect(const Region *region)
Status Xor(const Rect &rect)
Status GetRegionScans(const Matrix *matrix, Rect *rects, INT *count) const
BOOL IsEmpty(const Graphics *g) const
Status Translate(INT dx, INT dy)
Status Intersect(const RectF &rect)
Region(const RectF &rect)
Status MakeInfinite()
Status Intersect(const Rect &rect)
BOOL IsVisible(const RectF &rect, const Graphics *g) const
BOOL Equals(const Region *region, const Graphics *g) const
Status Complement(const Rect &rect)
Status Xor(const GraphicsPath *path)
Status Complement(const RectF &rect)
BOOL IsVisible(REAL x, REAL y, REAL width, REAL height, const Graphics *g) const
BOOL IsVisible(REAL x, REAL y, const Graphics *g) const
UINT GetRegionScansCount(const Matrix *matrix) const
Status Complement(const GraphicsPath *path)
Status Complement(const Region *region)
BOOL IsInfinite(const Graphics *g) const
Status MakeEmpty()
Status SetStatus(Status status) const
Region * Clone()
Status Exclude(const Region *region)
BOOL IsVisible(const Point &point, const Graphics *g) const
friend GpRegion *& getNat(const Region *region)
BOOL IsVisible(const Rect &rect, const Graphics *g) const
Status GetData(BYTE *buffer, UINT bufferSize, UINT *sizeFilled) const
Region(HRGN hRgn)
BOOL IsVisible(INT x, INT y, INT width, INT height, const Graphics *g) const
Image * GetImage() const
GpTexture * GetNativeTexture() const
Definition: gdiplusbrush.h:633
Definition: list.h:37
#define LF_FACESIZE
Definition: dimm.idl:39
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
float REAL
Definition: types.h:41
POINTL point
Definition: edittest.c:50
unsigned int BOOL
Definition: ntddk_ex.h:94
size_t bufferSize
DWORD WINAPI GetLayout(_In_ HDC hdc)
Definition: coord.c:750
DWORD WINAPI SetLayout(_In_ HDC hdc, _In_ DWORD dwLayout)
Definition: coord.c:780
LineJoin
Definition: gdiplusenums.h:105
ImageType
Definition: gdiplusenums.h:193
@ CombineModeUnion
Definition: gdiplusenums.h:353
@ CombineModeComplement
Definition: gdiplusenums.h:356
@ CombineModeIntersect
Definition: gdiplusenums.h:352
@ CombineModeExclude
Definition: gdiplusenums.h:355
@ CombineModeXor
Definition: gdiplusenums.h:354
LineCap
Definition: gdiplusenums.h:60
Unit
Definition: gdiplusenums.h:26
RotateFlipType
DWORD ARGB
INT PixelFormat
ImageAbort GetThumbnailImageAbort
Definition: gdiplustypes.h:57
Status
Definition: gdiplustypes.h:25
@ Ok
Definition: gdiplustypes.h:26
@ InvalidParameter
Definition: gdiplustypes.h:28
@ NotImplemented
Definition: gdiplustypes.h:32
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLeglImageOES image
Definition: gl.h:2204
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLdouble s
Definition: gl.h:2039
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint texture
Definition: glext.h:6295
GLsizei stride
Definition: glext.h:5848
GLuint buffer
Definition: glext.h:5915
GLuint color
Definition: glext.h:6243
GLuint GLenum matrix
Definition: glext.h:9407
GLbitfield flags
Definition: glext.h:7161
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLboolean GLboolean g
Definition: glext.h:6204
GLuint64EXT * result
Definition: glext.h:11304
GLenum cap
Definition: glext.h:9639
GLenum target
Definition: glext.h:7315
const char * filename
Definition: ioapi.h:137
GLint dy
Definition: linetemp.h:97
GLint dx
Definition: linetemp.h:97
HDC hdc
Definition: main.c:9
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:92
static HICON
Definition: imagelist.c:84
static IPrintDialogCallback callback
Definition: printdlg.c:326
static DWORD layout
Definition: bitmap.c:46
static DWORD *static HFONT(WINAPI *pCreateFontIndirectExA)(const ENUMLOGFONTEXDVA *)
static HRGN hRgn
Definition: mapping.c:33
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
static char memory[1024 *256]
Definition: process.c:116
static const CLSID IPropertyStorage UINT *static const PROPSPEC PROPVARIANT *static UINT const PROPSPEC PROPVARIANT PROPID
Definition: shellole.c:78
static HPALETTE palette
Definition: clipboard.c:1345
static ATOM item
Definition: dde.c:856
Definition: mk_font.cpp:20
unsigned int UINT
Definition: ndis.h:50
_In_ HBITMAP hbm
Definition: ntgdi.h:2776
#define cap
Definition: glfuncs.h:226
png_const_structrp png_const_inforp int * unit
Definition: png.h:2159
& rect
Definition: startmenu.cpp:1413
Definition: uimain.c:89
Definition: name.c:39
Definition: ps.c:97
Definition: parse.h:23
int32_t INT
Definition: typedefs.h:58
#define IN
Definition: typedefs.h:39
#define dpi
Definition: sysparams.c:23
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193