/**************************************************************************\ | |
* | |
* Copyright (c) 1998-2000, Microsoft Corp. All Rights Reserved. | |
* | |
* Module Name: | |
* | |
* GdiplusHeaders.h | |
* | |
* Abstract: | |
* | |
* GDI+ Native C++ public header file | |
* | |
\**************************************************************************/ | |
#ifndef _GDIPLUSHEADERS_H | |
#define _GDIPLUSHEADERS_H | |
//-------------------------------------------------------------------------- | |
// Abstract base class for regions | |
//-------------------------------------------------------------------------- | |
// Include the class declarations here and have inline class implementation | |
// in separate file to avoid circular references. | |
class Region : public GdiplusBase | |
{ | |
public: | |
friend class Graphics; | |
Region(); | |
Region(IN const RectF& rect); | |
Region(IN const Rect& rect); | |
Region(IN const GraphicsPath* path); | |
Region(IN const BYTE* regionData, IN INT size); | |
Region(IN HRGN hRgn); | |
static Region* FromHRGN(IN HRGN hRgn); | |
~Region(); | |
Region* Clone() const; | |
Status MakeInfinite(); | |
Status MakeEmpty(); | |
// Get the size of the buffer needed for the GetData method | |
UINT GetDataSize() const; | |
// buffer - where to put the data | |
// bufferSize - how big the buffer is (should be at least as big as GetDataSize()) | |
// sizeFilled - if not NULL, this is an OUT param that says how many bytes | |
// of data were written to the buffer. | |
Status GetData(OUT BYTE* buffer, | |
IN UINT bufferSize, | |
OUT UINT* sizeFilled = NULL) const; | |
Status Intersect(IN const Rect& rect); | |
Status Intersect(IN const RectF& rect); | |
Status Intersect(IN const GraphicsPath* path); | |
Status Intersect(IN const Region* region); | |
Status Union(IN const Rect& rect); | |
Status Union(IN const RectF& rect); | |
Status Union(IN const GraphicsPath* path); | |
Status Union(IN const Region* region); | |
Status Xor(IN const Rect& rect); | |
Status Xor(IN const RectF& rect); | |
Status Xor(IN const GraphicsPath* path); | |
Status Xor(IN const Region* region); | |
Status Exclude(IN const Rect& rect); | |
Status Exclude(IN const RectF& rect); | |
Status Exclude(IN const GraphicsPath* path); | |
Status Exclude(IN const Region* region); | |
Status Complement(IN const Rect& rect); | |
Status Complement(IN const RectF& rect); | |
Status Complement(IN const GraphicsPath* path); | |
Status Complement(IN const Region* region); | |
Status Translate(IN REAL dx, | |
IN REAL dy); | |
Status Translate(IN INT dx, | |
IN INT dy); | |
Status Transform(IN const Matrix* matrix); | |
Status GetBounds(OUT Rect* rect, | |
IN const Graphics* g) const; | |
Status GetBounds(OUT RectF* rect, | |
IN const Graphics* g) const; | |
HRGN GetHRGN (IN const Graphics * g) const; | |
BOOL IsEmpty(IN const Graphics *g) const; | |
BOOL IsInfinite(IN const Graphics *g) const; | |
BOOL IsVisible(IN INT x, | |
IN INT y, | |
IN const Graphics* g = NULL) const | |
{ | |
return IsVisible(Point(x, y), g); | |
} | |
BOOL IsVisible(IN const Point& point, | |
IN const Graphics* g = NULL) const; | |
BOOL IsVisible(IN REAL x, | |
IN REAL y, | |
IN const Graphics* g = NULL) const | |
{ | |
return IsVisible(PointF(x, y), g); | |
} | |
BOOL IsVisible(IN const PointF& point, | |
IN const Graphics* g = NULL) const; | |
BOOL IsVisible(IN INT x, | |
IN INT y, | |
IN INT width, | |
IN INT height, | |
IN const Graphics* g) const | |
{ | |
return IsVisible(Rect(x, y, width, height), g); | |
} | |
BOOL IsVisible(IN const Rect& rect, | |
IN const Graphics* g = NULL) const; | |
BOOL IsVisible(IN REAL x, | |
IN REAL y, | |
IN REAL width, | |
IN REAL height, | |
IN const Graphics* g = NULL) const | |
{ | |
return IsVisible(RectF(x, y, width, height), g); | |
} | |
BOOL IsVisible(IN const RectF& rect, | |
IN const Graphics* g = NULL) const; | |
BOOL Equals(IN const Region* region, | |
IN const Graphics* g) const; | |
UINT GetRegionScansCount(IN const Matrix* matrix) const; | |
Status GetRegionScans(IN const Matrix* matrix, | |
OUT RectF* rects, | |
OUT INT* count) const; | |
Status GetRegionScans(IN const Matrix* matrix, | |
OUT Rect* rects, | |
OUT INT* count) const; | |
Status GetLastStatus() const; | |
protected: | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
Region(const Region ®ion); | |
Region& operator=(const Region ®ion); | |
protected: | |
#else | |
Region(const Region ®ion) | |
{ | |
region; // reference parameter | |
SetStatus(NotImplemented); | |
} | |
Region& operator=(const Region ®ion) | |
{ | |
region; // reference parameter | |
SetStatus(NotImplemented); | |
return *this; | |
} | |
#endif | |
Status SetStatus(Status status) const | |
{ | |
if (status != Ok) | |
return (lastResult = status); | |
else | |
return status; | |
} | |
Region(GpRegion* nativeRegion); | |
VOID SetNativeRegion(GpRegion* nativeRegion); | |
protected: | |
GpRegion* nativeRegion; | |
mutable Status lastResult; | |
}; | |
//-------------------------------------------------------------------------- | |
// Abstract base class for FontFamily | |
//-------------------------------------------------------------------------- | |
class FontFamily : public GdiplusBase | |
{ | |
public: | |
friend class Font; | |
friend class Graphics; | |
friend class GraphicsPath; | |
friend class FontCollection; | |
FontFamily(); | |
FontFamily( | |
IN const WCHAR *name, | |
IN const FontCollection *fontCollection = NULL | |
); | |
~FontFamily(); | |
static const FontFamily *GenericSansSerif(); | |
static const FontFamily *GenericSerif(); | |
static const FontFamily *GenericMonospace(); | |
Status GetFamilyName( | |
OUT WCHAR name[LF_FACESIZE], | |
IN LANGID language = 0 | |
) const; | |
// Copy operator | |
FontFamily * Clone() const; | |
BOOL IsAvailable() const | |
{ | |
return (nativeFamily != NULL); | |
}; | |
BOOL IsStyleAvailable(IN INT style) const; | |
UINT16 GetEmHeight (IN INT style) const; | |
UINT16 GetCellAscent (IN INT style) const; | |
UINT16 GetCellDescent (IN INT style) const; | |
UINT16 GetLineSpacing (IN INT style) const; | |
/////////////////////////////////////////////////////////// | |
Status GetLastStatus() const; | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
FontFamily(const FontFamily &); | |
FontFamily& operator=(const FontFamily &); | |
#endif | |
protected: | |
Status SetStatus(Status status) const; | |
// private constructor for copy | |
FontFamily(GpFontFamily * nativeFamily, Status status); | |
/////////////////////////////////////// | |
// Data members | |
protected: | |
GpFontFamily *nativeFamily; | |
mutable Status lastResult; | |
}; | |
static FontFamily *GenericSansSerifFontFamily = NULL; | |
static FontFamily *GenericSerifFontFamily = NULL; | |
static FontFamily *GenericMonospaceFontFamily = NULL; | |
static BYTE GenericSansSerifFontFamilyBuffer[sizeof(FontFamily)] = {0}; | |
static BYTE GenericSerifFontFamilyBuffer [sizeof(FontFamily)] = {0}; | |
static BYTE GenericMonospaceFontFamilyBuffer[sizeof(FontFamily)] = {0}; | |
//-------------------------------------------------------------------------- | |
// Abstract base class for fonts | |
//-------------------------------------------------------------------------- | |
class Font : public GdiplusBase | |
{ | |
public: | |
friend class Graphics; | |
Font(IN HDC hdc); | |
Font(IN HDC hdc, | |
IN const LOGFONTA* logfont); | |
Font(IN HDC hdc, | |
IN const LOGFONTW* logfont); | |
#ifdef DCR_USE_NEW_127084 | |
Font(IN HDC hdc, | |
IN const HFONT hfont); | |
#endif | |
Font( | |
IN const FontFamily * family, | |
IN REAL emSize, | |
IN INT style = FontStyleRegular, | |
IN Unit unit = UnitPoint | |
); | |
Font( | |
IN const WCHAR * familyName, | |
IN REAL emSize, | |
IN INT style = FontStyleRegular, | |
IN Unit unit = UnitPoint, | |
IN const FontCollection * fontCollection = NULL | |
); | |
Status GetLogFontA(IN const Graphics* g, | |
OUT LOGFONTA * logfontA) const; | |
Status GetLogFontW(IN const Graphics* g, | |
OUT LOGFONTW * logfontW) const; | |
Font* Clone() const; | |
~Font(); | |
BOOL IsAvailable() const; | |
INT GetStyle() const; | |
REAL GetSize() const; | |
Unit GetUnit() const; | |
Status GetLastStatus() const; | |
REAL GetHeight(IN const Graphics *graphics = NULL) const; | |
#ifdef DCR_USE_NEW_125467 | |
REAL GetHeight(IN REAL dpi) const; | |
#endif | |
Status GetFamily(OUT FontFamily *family) const; | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
Font(const Font &); | |
Font& operator=(const Font &); | |
#endif | |
protected: | |
Font(GpFont* font, Status status); | |
VOID SetNativeFont(GpFont *Font); | |
Status SetStatus(Status status) const; | |
protected: | |
/* | |
* handle to native line texture object | |
*/ | |
GpFont* nativeFont; | |
mutable Status lastResult; | |
}; | |
//-------------------------------------------------------------------------- | |
// Abstract base classes for font collections | |
//-------------------------------------------------------------------------- | |
class FontCollection : public GdiplusBase | |
{ | |
public: | |
friend class FontFamily; | |
FontCollection(); | |
virtual ~FontCollection(); | |
INT GetFamilyCount() const; // number of enumerable families in the collection | |
Status GetFamilies( // enumerate the fonts in a collection | |
IN INT numSought, | |
OUT FontFamily * gpfamilies, | |
OUT INT * numFound | |
) const; | |
Status GetLastStatus() const; | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
FontCollection(const FontCollection &); | |
FontCollection& operator=(const FontCollection &); | |
#endif | |
protected: | |
Status SetStatus(Status status) const ; | |
GpFontCollection *nativeFontCollection; | |
mutable Status lastResult; | |
}; | |
class InstalledFontCollection : public FontCollection | |
{ | |
public: | |
InstalledFontCollection(); | |
~InstalledFontCollection(); | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
InstalledFontCollection(const InstalledFontCollection &); | |
InstalledFontCollection& operator=(const InstalledFontCollection &); | |
#endif | |
protected: | |
#ifndef DCR_USE_NEW_235072 | |
Status InstallFontFile(IN const WCHAR* filename); | |
Status UninstallFontFile(IN const WCHAR* filename); | |
#endif | |
Status SetStatus(Status status) const ; | |
}; | |
class PrivateFontCollection : public FontCollection | |
{ | |
public: | |
PrivateFontCollection(); | |
~PrivateFontCollection(); | |
Status AddFontFile(IN const WCHAR* filename); | |
Status AddMemoryFont(IN const VOID* memory, | |
IN INT length); | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
PrivateFontCollection(const PrivateFontCollection &); | |
PrivateFontCollection& operator=(const PrivateFontCollection &); | |
#endif | |
}; | |
//-------------------------------------------------------------------------- | |
// Abstract base class for bitmap image and metafile | |
//-------------------------------------------------------------------------- | |
// !!! Note: | |
// Include the class declarations here and have the inline class | |
// implementation in a separate file. This is done to resolve a | |
// circular dependency since one of the Bitmap methods needs to | |
// access the private member nativeGraphics of the Graphics object. | |
class Image : public GdiplusBase | |
{ | |
public: | |
friend class Brush; | |
friend class TextureBrush; | |
friend class Graphics; | |
#ifndef DCR_USE_NEW_140782 | |
Image( | |
IN const WCHAR* filename | |
); | |
Image( | |
IN IStream* stream | |
); | |
static Image* FromFile( | |
IN const WCHAR* filename | |
); | |
static Image* FromStream( | |
IN IStream* stream | |
); | |
#else | |
Image( | |
IN const WCHAR* filename, | |
IN BOOL useEmbeddedColorManagement = FALSE | |
); | |
Image( | |
IN IStream* stream, | |
IN BOOL useEmbeddedColorManagement = FALSE | |
); | |
static Image* FromFile( | |
IN const WCHAR* filename, | |
IN BOOL useEmbeddedColorManagement = FALSE | |
); | |
static Image* FromStream( | |
IN IStream* stream, | |
IN BOOL useEmbeddedColorManagement = FALSE | |
); | |
#endif | |
virtual ~Image(); | |
virtual Image* Clone(); | |
Status Save(IN const WCHAR* filename, | |
IN const CLSID* clsidEncoder, | |
IN const EncoderParameters *encoderParams = NULL); | |
Status Save(IN IStream* stream, | |
IN const CLSID* clsidEncoder, | |
IN const EncoderParameters *encoderParams = NULL); | |
Status SaveAdd(IN const EncoderParameters* encoderParams); | |
Status SaveAdd(IN Image* newImage, | |
IN const EncoderParameters* encoderParams); | |
ImageType GetType() const; | |
Status GetPhysicalDimension(OUT SizeF* size); | |
Status GetBounds(OUT RectF* srcRect, | |
OUT Unit* srcUnit); | |
UINT GetWidth(); | |
UINT GetHeight(); | |
REAL GetHorizontalResolution(); | |
REAL GetVerticalResolution(); | |
UINT GetFlags(); | |
Status GetRawFormat(OUT GUID *format); | |
PixelFormat GetPixelFormat(); | |
INT GetPaletteSize(); | |
Status GetPalette(OUT ColorPalette* palette, | |
IN INT size); | |
Status SetPalette(IN const ColorPalette* palette); | |
Image* GetThumbnailImage(IN UINT thumbWidth, | |
IN UINT thumbHeight, | |
IN GetThumbnailImageAbort callback = NULL, | |
IN VOID* callbackData = NULL); | |
UINT GetFrameDimensionsCount(); | |
Status GetFrameDimensionsList(OUT GUID* dimensionIDs, | |
IN UINT count); | |
UINT GetFrameCount(IN const GUID* dimensionID); | |
Status SelectActiveFrame(IN const GUID* dimensionID, | |
IN UINT frameIndex); | |
Status RotateFlip(IN RotateFlipType rotateFlipType); | |
UINT GetPropertyCount(); | |
Status GetPropertyIdList(IN UINT numOfProperty, | |
OUT PROPID* list); | |
UINT GetPropertyItemSize(IN PROPID propId); | |
Status GetPropertyItem(IN PROPID propId, | |
IN UINT propSize, | |
OUT PropertyItem* buffer); | |
Status GetPropertySize(OUT UINT* totalBufferSize, | |
OUT UINT* numProperties); | |
Status GetAllPropertyItems(IN UINT totalBufferSize, | |
IN UINT numProperties, | |
OUT PropertyItem* allItems); | |
Status RemovePropertyItem(IN PROPID propId); | |
Status SetPropertyItem(IN const PropertyItem* item); | |
UINT GetEncoderParameterListSize(IN const CLSID* clsidEncoder); | |
Status GetEncoderParameterList(IN const CLSID* clsidEncoder, | |
IN UINT size, | |
OUT EncoderParameters* buffer); | |
// Support for Middle East localization (right-to-left mirroring) | |
ImageLayout GetLayout() const; | |
Status SetLayout(IN const ImageLayout layout); | |
Status GetLastStatus() const; | |
protected: | |
Image() {} | |
Image(GpImage *nativeImage, Status status); | |
VOID SetNativeImage(GpImage* nativeImage); | |
Status SetStatus(Status status) const | |
{ | |
if (status != Ok) | |
return (lastResult = status); | |
else | |
return status; | |
} | |
GpImage* nativeImage; | |
mutable Status lastResult; | |
mutable Status loadStatus; | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
#else | |
protected: | |
#endif | |
// Disable copy constructor and assignment operator | |
Image(IN const Image& C); | |
Image& operator=(IN const Image& C); | |
}; | |
class Bitmap : public Image | |
{ | |
public: | |
friend class Image; | |
friend class CachedBitmap; | |
Bitmap( | |
IN const WCHAR *filename, | |
IN BOOL useEmbeddedColorManagement = FALSE | |
); | |
Bitmap( | |
IN IStream *stream, | |
IN BOOL useEmbeddedColorManagement = FALSE | |
); | |
static Bitmap* FromFile( | |
IN const WCHAR *filename, | |
IN BOOL useEmbeddedColorManagement = FALSE | |
); | |
static Bitmap* FromStream( | |
IN IStream *stream, | |
IN BOOL useEmbeddedColorManagement = FALSE | |
); | |
Bitmap(IN INT width, | |
IN INT height, | |
IN INT stride, PixelFormat format, | |
IN BYTE* scan0); | |
Bitmap(IN INT width, | |
IN INT height, | |
IN PixelFormat format = PixelFormat32bppARGB); | |
Bitmap(IN INT width, | |
IN INT height, | |
IN Graphics* target); | |
Bitmap* Clone(IN const Rect& rect, | |
IN PixelFormat format); | |
Bitmap* Clone(IN INT x, | |
IN INT y, | |
IN INT width, | |
IN INT height, | |
IN PixelFormat format); | |
Bitmap* Clone(IN const RectF& rect, | |
IN PixelFormat format); | |
Bitmap* Clone(IN REAL x, | |
IN REAL y, | |
IN REAL width, | |
IN REAL height, | |
IN PixelFormat format); | |
Status LockBits(IN const Rect& rect, | |
IN UINT flags, | |
IN PixelFormat format, | |
OUT BitmapData* lockedBitmapData); | |
Status UnlockBits(IN BitmapData* lockedBitmapData); | |
Status GetPixel(IN INT x, | |
IN INT y, | |
OUT Color *color); | |
Status SetPixel(IN INT x, | |
IN INT y, | |
IN const Color &color); | |
Status SetResolution(IN REAL xdpi, | |
IN REAL ydpi); | |
// GDI interop: | |
Bitmap(IN IDirectDrawSurface7* surface); | |
Bitmap(IN const BITMAPINFO* gdiBitmapInfo, | |
IN VOID* gdiBitmapData); | |
Bitmap(IN HBITMAP hbm, | |
IN HPALETTE hpal); | |
Bitmap(IN HICON hicon); | |
Bitmap(IN HINSTANCE hInstance, | |
IN const WCHAR * bitmapName); | |
static Bitmap* FromDirectDrawSurface7(IN IDirectDrawSurface7* surface); | |
static Bitmap* FromBITMAPINFO(IN const BITMAPINFO* gdiBitmapInfo, | |
IN VOID* gdiBitmapData); | |
static Bitmap* FromHBITMAP(IN HBITMAP hbm, | |
IN HPALETTE hpal); | |
static Bitmap* FromHICON(IN HICON hicon); | |
static Bitmap* FromResource(IN HINSTANCE hInstance, | |
IN const WCHAR * bitmapName); | |
Status GetHBITMAP(IN const Color& colorBackground, | |
OUT HBITMAP *hbmReturn); | |
Status GetHICON(HICON *hicon); | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
Bitmap(const Bitmap &); | |
Bitmap& operator=(const Bitmap &); | |
#endif | |
protected: | |
Bitmap(GpBitmap *nativeBitmap); | |
}; | |
class CustomLineCap : public GdiplusBase | |
{ | |
public: | |
friend class Pen; | |
CustomLineCap( | |
IN const GraphicsPath* fillPath, | |
IN const GraphicsPath* strokePath, | |
IN LineCap baseCap = LineCapFlat, | |
IN REAL baseInset = 0 | |
); | |
virtual ~CustomLineCap(); | |
CustomLineCap* Clone() const; | |
Status SetStrokeCap(IN LineCap strokeCap) | |
{ | |
// This changes both start and and caps. | |
return SetStrokeCaps(strokeCap, strokeCap); | |
} | |
Status SetStrokeCaps(IN LineCap startCap, | |
IN LineCap endCap); | |
Status GetStrokeCaps(OUT LineCap* startCap, | |
OUT LineCap* endCap) const; | |
Status SetStrokeJoin(IN LineJoin lineJoin); | |
LineJoin GetStrokeJoin() const; | |
Status SetBaseCap(IN LineCap baseCap); | |
LineCap GetBaseCap() const; | |
Status SetBaseInset(IN REAL inset); | |
REAL GetBaseInset() const; | |
Status SetWidthScale(IN REAL widthScale); | |
REAL GetWidthScale() const; | |
protected: | |
CustomLineCap(); | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
CustomLineCap(const CustomLineCap &); | |
CustomLineCap& operator=(const CustomLineCap &); | |
protected: | |
#else | |
CustomLineCap(const CustomLineCap& customLineCap) | |
{ | |
customLineCap; | |
SetStatus(NotImplemented); | |
} | |
CustomLineCap& operator=(const CustomLineCap& customLineCap) | |
{ | |
customLineCap; | |
SetStatus(NotImplemented); | |
return *this; | |
} | |
#endif | |
CustomLineCap(GpCustomLineCap* nativeCap, Status status) | |
{ | |
lastResult = status; | |
SetNativeCap(nativeCap); | |
} | |
VOID SetNativeCap(GpCustomLineCap* nativeCap) | |
{ | |
this->nativeCap = nativeCap; | |
} | |
Status SetStatus(Status status) const | |
{ | |
if (status != Ok) | |
return (lastResult = status); | |
else | |
return status; | |
} | |
protected: | |
GpCustomLineCap* nativeCap; | |
mutable Status lastResult; | |
}; | |
class CachedBitmap : public GdiplusBase | |
{ | |
friend Graphics; | |
public: | |
CachedBitmap(IN Bitmap *bitmap, | |
IN Graphics *graphics); | |
virtual ~CachedBitmap(); | |
Status GetLastStatus() const; | |
#ifdef DCR_USE_NEW_250932 | |
private: | |
CachedBitmap(const CachedBitmap &); | |
CachedBitmap& operator=(const CachedBitmap &); | |
#endif | |
protected: | |
GpCachedBitmap *nativeCachedBitmap; | |
mutable Status lastResult; | |
}; | |
#endif // !_GDIPLUSHEADERS.HPP |