| /**************************************************************************\ | |
| * | |
| * Copyright (c) 1998-2000, Microsoft Corp. All Rights Reserved. | |
| * | |
| * Module Name: | |
| * | |
| * GdiplusTypes.h | |
| * | |
| * Abstract: | |
| * | |
| * Basic types used by GDI+ | |
| * | |
| \**************************************************************************/ | |
| #ifndef _GDIPLUSTYPES_H | |
| #define _GDIPLUSTYPES_H | |
| #ifndef DCR_USE_NEW_175866 | |
| //-------------------------------------------------------------------------- | |
| // LIB version initialization functions | |
| //-------------------------------------------------------------------------- | |
| typedef VOID (__cdecl *DEBUGEVENTFUNCTION)(INT level, CHAR *message); | |
| extern "C" BOOL __stdcall InitializeGdiplus(DEBUGEVENTFUNCTION); | |
| extern "C" VOID __stdcall UninitializeGdiplus(); | |
| #endif | |
| //-------------------------------------------------------------------------- | |
| // Callback functions | |
| //-------------------------------------------------------------------------- | |
| extern "C" { | |
| typedef BOOL (CALLBACK * ImageAbort)(VOID *); | |
| typedef ImageAbort DrawImageAbort; | |
| typedef ImageAbort GetThumbnailImageAbort; | |
| } | |
| // Callback for EnumerateMetafile methods. The parameters are: | |
| // recordType WMF, EMF, or EMF+ record type | |
| // flags (always 0 for WMF/EMF records) | |
| // dataSize size of the record data (in bytes), or 0 if no data | |
| // data pointer to the record data, or NULL if no data | |
| // callbackData pointer to callbackData, if any | |
| // This method can then call Metafile::PlayRecord to play the | |
| // record that was just enumerated. If this method returns | |
| // FALSE, the enumeration process is aborted. Otherwise, it continues. | |
| extern "C" { | |
| typedef BOOL (CALLBACK * EnumerateMetafileProc)(EmfPlusRecordType,UINT,UINT,const BYTE*,VOID*); | |
| } | |
| //-------------------------------------------------------------------------- | |
| // Primitive data types | |
| // | |
| // NOTE: | |
| // Types already defined in standard header files: | |
| // INT8 | |
| // UINT8 | |
| // INT16 | |
| // UINT16 | |
| // INT32 | |
| // UINT32 | |
| // INT64 | |
| // UINT64 | |
| // | |
| // Avoid using the following types: | |
| // LONG - use INT | |
| // ULONG - use UINT | |
| // DWORD - use UINT32 | |
| //-------------------------------------------------------------------------- | |
| typedef float REAL; | |
| #define REAL_MAX FLT_MAX | |
| #define REAL_MIN FLT_MIN | |
| #define REAL_TOLERANCE (FLT_MIN * 100) | |
| #define REAL_EPSILON 1.192092896e-07F /* FLT_EPSILON */ | |
| //-------------------------------------------------------------------------- | |
| // Forward declarations of various internal classes | |
| //-------------------------------------------------------------------------- | |
| class Size; | |
| class SizeF; | |
| class Point; | |
| class PointF; | |
| class Rect; | |
| class RectF; | |
| class CharacterRange; | |
| //-------------------------------------------------------------------------- | |
| // Return values from any GDI+ API | |
| //-------------------------------------------------------------------------- | |
| enum Status | |
| { | |
| Ok = 0, | |
| GenericError = 1, | |
| InvalidParameter = 2, | |
| OutOfMemory = 3, | |
| ObjectBusy = 4, | |
| InsufficientBuffer = 5, | |
| NotImplemented = 6, | |
| Win32Error = 7, | |
| WrongState = 8, | |
| Aborted = 9, | |
| #ifdef DCR_USE_NEW_135429 | |
| FileNotFound = 10, | |
| ValueOverflow = 11, | |
| AccessDenied = 12, | |
| UnknownImageFormat = 13, | |
| FontFamilyNotFound = 14, | |
| FontStyleNotFound = 15, | |
| NotTrueTypeFont = 16, | |
| #else | |
| NotFound = 10, | |
| ValueOverflow = 11, | |
| #endif | |
| UnsupportedGdiplusVersion = 17, | |
| GdiplusNotInitialized | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Represents a dimension in a 2D coordinate system | |
| // (floating-point coordinates) | |
| //-------------------------------------------------------------------------- | |
| class SizeF | |
| { | |
| public: | |
| // Default constructor | |
| SizeF() | |
| { | |
| Width = Height = 0.0f; | |
| } | |
| SizeF(IN const SizeF& size) | |
| { | |
| Width = size.Width; | |
| Height = size.Height; | |
| } | |
| SizeF(IN REAL width, | |
| IN REAL height) | |
| { | |
| Width = width; | |
| Height = height; | |
| } | |
| SizeF operator+(IN const SizeF& sz) const | |
| { | |
| return SizeF(Width + sz.Width, | |
| Height + sz.Height); | |
| } | |
| SizeF operator-(IN const SizeF& sz) const | |
| { | |
| return SizeF(Width - sz.Width, | |
| Height - sz.Height); | |
| } | |
| BOOL Equals(IN const SizeF& sz) const | |
| { | |
| return (Width == sz.Width) && (Height == sz.Height); | |
| } | |
| BOOL Empty() const | |
| { | |
| return (Width == 0.0f && Height == 0.0f); | |
| } | |
| public: | |
| REAL Width; | |
| REAL Height; | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Represents a dimension in a 2D coordinate system | |
| // (integer coordinates) | |
| //-------------------------------------------------------------------------- | |
| class Size | |
| { | |
| public: | |
| // Default constructor | |
| Size() | |
| { | |
| Width = Height = 0; | |
| } | |
| Size(IN const Size& size) | |
| { | |
| Width = size.Width; | |
| Height = size.Height; | |
| } | |
| Size(IN INT width, | |
| IN INT height) | |
| { | |
| Width = width; | |
| Height = height; | |
| } | |
| Size operator+(IN const Size& sz) const | |
| { | |
| return Size(Width + sz.Width, | |
| Height + sz.Height); | |
| } | |
| Size operator-(IN const Size& sz) const | |
| { | |
| return Size(Width - sz.Width, | |
| Height - sz.Height); | |
| } | |
| BOOL Equals(IN const Size& sz) const | |
| { | |
| return (Width == sz.Width) && (Height == sz.Height); | |
| } | |
| BOOL Empty() const | |
| { | |
| return (Width == 0 && Height == 0); | |
| } | |
| public: | |
| INT Width; | |
| INT Height; | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Represents a location in a 2D coordinate system | |
| // (floating-point coordinates) | |
| //-------------------------------------------------------------------------- | |
| class PointF | |
| { | |
| public: | |
| PointF() | |
| { | |
| X = Y = 0.0f; | |
| } | |
| PointF(IN const PointF &point) | |
| { | |
| X = point.X; | |
| Y = point.Y; | |
| } | |
| PointF(IN const SizeF &size) | |
| { | |
| X = size.Width; | |
| Y = size.Height; | |
| } | |
| PointF(IN REAL x, | |
| IN REAL y) | |
| { | |
| X = x; | |
| Y = y; | |
| } | |
| PointF operator+(IN const PointF& point) const | |
| { | |
| return PointF(X + point.X, | |
| Y + point.Y); | |
| } | |
| PointF operator-(IN const PointF& point) const | |
| { | |
| return PointF(X - point.X, | |
| Y - point.Y); | |
| } | |
| BOOL Equals(IN const PointF& point) | |
| { | |
| return (X == point.X) && (Y == point.Y); | |
| } | |
| public: | |
| REAL X; | |
| REAL Y; | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Represents a location in a 2D coordinate system | |
| // (integer coordinates) | |
| //-------------------------------------------------------------------------- | |
| class Point | |
| { | |
| public: | |
| Point() | |
| { | |
| X = Y = 0; | |
| } | |
| Point(IN const Point &point) | |
| { | |
| X = point.X; | |
| Y = point.Y; | |
| } | |
| Point(IN const Size &size) | |
| { | |
| X = size.Width; | |
| Y = size.Height; | |
| } | |
| Point(IN INT x, | |
| IN INT y) | |
| { | |
| X = x; | |
| Y = y; | |
| } | |
| Point operator+(IN const Point& point) const | |
| { | |
| return Point(X + point.X, | |
| Y + point.Y); | |
| } | |
| Point operator-(IN const Point& point) const | |
| { | |
| return Point(X - point.X, | |
| Y - point.Y); | |
| } | |
| BOOL Equals(IN const Point& point) | |
| { | |
| return (X == point.X) && (Y == point.Y); | |
| } | |
| public: | |
| INT X; | |
| INT Y; | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Represents a rectangle in a 2D coordinate system | |
| // (floating-point coordinates) | |
| //-------------------------------------------------------------------------- | |
| class RectF | |
| { | |
| public: | |
| // Default constructor | |
| RectF() | |
| { | |
| X = Y = Width = Height = 0.0f; | |
| } | |
| RectF(IN REAL x, | |
| IN REAL y, | |
| IN REAL width, | |
| IN REAL height) | |
| { | |
| X = x; | |
| Y = y; | |
| Width = width; | |
| Height = height; | |
| } | |
| RectF(IN const PointF& location, | |
| IN const SizeF& size) | |
| { | |
| X = location.X; | |
| Y = location.Y; | |
| Width = size.Width; | |
| Height = size.Height; | |
| } | |
| RectF* Clone() const | |
| { | |
| return new RectF(X, Y, Width, Height); | |
| } | |
| VOID GetLocation(OUT PointF* point) const | |
| { | |
| point->X = X; | |
| point->Y = Y; | |
| } | |
| VOID GetSize(OUT SizeF* size) const | |
| { | |
| size->Width = Width; | |
| size->Height = Height; | |
| } | |
| VOID GetBounds(OUT RectF* rect) const | |
| { | |
| rect->X = X; | |
| rect->Y = Y; | |
| rect->Width = Width; | |
| rect->Height = Height; | |
| } | |
| // Return the left, top, right, and bottom | |
| // coordinates of the rectangle | |
| REAL GetLeft() const | |
| { | |
| return X; | |
| } | |
| REAL GetTop() const | |
| { | |
| return Y; | |
| } | |
| REAL GetRight() const | |
| { | |
| return X+Width; | |
| } | |
| REAL GetBottom() const | |
| { | |
| return Y+Height; | |
| } | |
| // Determine if the rectangle is empty | |
| BOOL IsEmptyArea() const | |
| { | |
| return (Width <= REAL_EPSILON) || (Height <= REAL_EPSILON); | |
| } | |
| BOOL Equals(IN const RectF & rect) const | |
| { | |
| return X == rect.X && | |
| Y == rect.Y && | |
| Width == rect.Width && | |
| Height == rect.Height; | |
| } | |
| BOOL Contains(IN REAL x, | |
| IN REAL y) const | |
| { | |
| return x >= X && x < X+Width && | |
| y >= Y && y < Y+Height; | |
| } | |
| BOOL Contains(IN const PointF& pt) const | |
| { | |
| return Contains(pt.X, pt.Y); | |
| } | |
| BOOL Contains(IN const RectF& rect) const | |
| { | |
| return (X <= rect.X) && (rect.GetRight() <= GetRight()) && | |
| (Y <= rect.Y) && (rect.GetBottom() <= GetBottom()); | |
| } | |
| VOID Inflate(IN REAL dx, | |
| IN REAL dy) | |
| { | |
| X -= dx; | |
| Y -= dy; | |
| Width += 2*dx; | |
| Height += 2*dy; | |
| } | |
| VOID Inflate(IN const PointF& point) | |
| { | |
| Inflate(point.X, point.Y); | |
| } | |
| // Intersect the current rect with the specified object | |
| BOOL Intersect(IN const RectF& rect) | |
| { | |
| return Intersect(*this, *this, rect); | |
| } | |
| // Intersect rect a and b and save the result into c | |
| // Notice that c may be the same object as a or b. | |
| static BOOL Intersect(OUT RectF& c, | |
| IN const RectF& a, | |
| IN const RectF& b) | |
| { | |
| REAL right = min(a.GetRight(), b.GetRight()); | |
| REAL bottom = min(a.GetBottom(), b.GetBottom()); | |
| REAL left = max(a.GetLeft(), b.GetLeft()); | |
| REAL top = max(a.GetTop(), b.GetTop()); | |
| c.X = left; | |
| c.Y = top; | |
| c.Width = right - left; | |
| c.Height = bottom - top; | |
| return !c.IsEmptyArea(); | |
| } | |
| // Determine if the specified rect intersects with the | |
| // current rect object. | |
| BOOL IntersectsWith(IN const RectF& rect) const | |
| { | |
| return (GetLeft() < rect.GetRight() && | |
| GetTop() < rect.GetTop() && | |
| GetRight() > rect.GetLeft() && | |
| GetBottom() > rect.GetTop()); | |
| } | |
| static BOOL Union(OUT RectF& c, | |
| IN const RectF& a, | |
| IN const RectF& b) | |
| { | |
| REAL right = max(a.GetRight(), b.GetRight()); | |
| REAL bottom = max(a.GetBottom(), b.GetBottom()); | |
| REAL left = min(a.GetLeft(), b.GetLeft()); | |
| REAL top = min(a.GetTop(), b.GetTop()); | |
| c.X = left; | |
| c.Y = top; | |
| c.Width = right - left; | |
| c.Height = bottom - top; | |
| return !c.IsEmptyArea(); | |
| } | |
| VOID Offset(IN const PointF& point) | |
| { | |
| Offset(point.X, point.Y); | |
| } | |
| VOID Offset(IN REAL dx, | |
| IN REAL dy) | |
| { | |
| X += dx; | |
| Y += dy; | |
| } | |
| public: | |
| REAL X; | |
| REAL Y; | |
| REAL Width; | |
| REAL Height; | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Represents a rectangle in a 2D coordinate system | |
| // (integer coordinates) | |
| //-------------------------------------------------------------------------- | |
| class Rect | |
| { | |
| public: | |
| // Default constructor | |
| Rect() | |
| { | |
| X = Y = Width = Height = 0; | |
| } | |
| Rect(IN INT x, | |
| IN INT y, | |
| IN INT width, | |
| IN INT height) | |
| { | |
| X = x; | |
| Y = y; | |
| Width = width; | |
| Height = height; | |
| } | |
| Rect(IN const Point& location, | |
| IN const Size& size) | |
| { | |
| X = location.X; | |
| Y = location.Y; | |
| Width = size.Width; | |
| Height = size.Height; | |
| } | |
| Rect* Clone() const | |
| { | |
| return new Rect(X, Y, Width, Height); | |
| } | |
| VOID GetLocation(OUT Point* point) const | |
| { | |
| point->X = X; | |
| point->Y = Y; | |
| } | |
| VOID GetSize(OUT Size* size) const | |
| { | |
| size->Width = Width; | |
| size->Height = Height; | |
| } | |
| VOID GetBounds(OUT Rect* rect) const | |
| { | |
| rect->X = X; | |
| rect->Y = Y; | |
| rect->Width = Width; | |
| rect->Height = Height; | |
| } | |
| // Return the left, top, right, and bottom | |
| // coordinates of the rectangle | |
| INT GetLeft() const | |
| { | |
| return X; | |
| } | |
| INT GetTop() const | |
| { | |
| return Y; | |
| } | |
| INT GetRight() const | |
| { | |
| return X+Width; | |
| } | |
| INT GetBottom() const | |
| { | |
| return Y+Height; | |
| } | |
| // Determine if the rectangle is empty | |
| BOOL IsEmptyArea() const | |
| { | |
| return (Width <= 0) || (Height <= 0); | |
| } | |
| BOOL Equals(IN const Rect & rect) const | |
| { | |
| return X == rect.X && | |
| Y == rect.Y && | |
| Width == rect.Width && | |
| Height == rect.Height; | |
| } | |
| BOOL Contains(IN INT x, | |
| IN INT y) const | |
| { | |
| return x >= X && x < X+Width && | |
| y >= Y && y < Y+Height; | |
| } | |
| BOOL Contains(IN const Point& pt) const | |
| { | |
| return Contains(pt.X, pt.Y); | |
| } | |
| BOOL Contains(IN Rect& rect) const | |
| { | |
| return (X <= rect.X) && (rect.GetRight() <= GetRight()) && | |
| (Y <= rect.Y) && (rect.GetBottom() <= GetBottom()); | |
| } | |
| VOID Inflate(IN INT dx, | |
| IN INT dy) | |
| { | |
| X -= dx; | |
| Y -= dy; | |
| Width += 2*dx; | |
| Height += 2*dy; | |
| } | |
| VOID Inflate(IN const Point& point) | |
| { | |
| Inflate(point.X, point.Y); | |
| } | |
| // Intersect the current rect with the specified object | |
| BOOL Intersect(IN const Rect& rect) | |
| { | |
| return Intersect(*this, *this, rect); | |
| } | |
| // Intersect rect a and b and save the result into c | |
| // Notice that c may be the same object as a or b. | |
| static BOOL Intersect(OUT Rect& c, | |
| IN const Rect& a, | |
| IN const Rect& b) | |
| { | |
| INT right = min(a.GetRight(), b.GetRight()); | |
| INT bottom = min(a.GetBottom(), b.GetBottom()); | |
| INT left = max(a.GetLeft(), b.GetLeft()); | |
| INT top = max(a.GetTop(), b.GetTop()); | |
| c.X = left; | |
| c.Y = top; | |
| c.Width = right - left; | |
| c.Height = bottom - top; | |
| return !c.IsEmptyArea(); | |
| } | |
| // Determine if the specified rect intersects with the | |
| // current rect object. | |
| BOOL IntersectsWith(IN const Rect& rect) const | |
| { | |
| return (GetLeft() < rect.GetRight() && | |
| GetTop() < rect.GetTop() && | |
| GetRight() > rect.GetLeft() && | |
| GetBottom() > rect.GetTop()); | |
| } | |
| static BOOL Union(OUT Rect& c, | |
| IN const Rect& a, | |
| IN const Rect& b) | |
| { | |
| INT right = max(a.GetRight(), b.GetRight()); | |
| INT bottom = max(a.GetBottom(), b.GetBottom()); | |
| INT left = min(a.GetLeft(), b.GetLeft()); | |
| INT top = min(a.GetTop(), b.GetTop()); | |
| c.X = left; | |
| c.Y = top; | |
| c.Width = right - left; | |
| c.Height = bottom - top; | |
| return !c.IsEmptyArea(); | |
| } | |
| VOID Offset(IN const Point& point) | |
| { | |
| Offset(point.X, point.Y); | |
| } | |
| VOID Offset(IN INT dx, | |
| IN INT dy) | |
| { | |
| X += dx; | |
| Y += dy; | |
| } | |
| public: | |
| INT X; | |
| INT Y; | |
| INT Width; | |
| INT Height; | |
| }; | |
| // A user must mange memory for PathData. | |
| class PathData | |
| { | |
| public: | |
| PathData() | |
| { | |
| Count = 0; | |
| Points = NULL; | |
| Types = NULL; | |
| } | |
| ~PathData() | |
| { | |
| if (Points != NULL) | |
| { | |
| delete Points; | |
| } | |
| if (Types != NULL) | |
| { | |
| delete Types; | |
| } | |
| } | |
| #ifdef DCR_USE_NEW_250932 | |
| private: | |
| PathData(const PathData &); | |
| PathData& operator=(const PathData &); | |
| #endif | |
| public: | |
| INT Count; | |
| PointF* Points; | |
| BYTE* Types; | |
| }; | |
| //----------------------------- | |
| // text character range | |
| //----------------------------- | |
| class CharacterRange | |
| { | |
| public: | |
| CharacterRange( | |
| INT first, | |
| INT length | |
| ) : | |
| First (first), | |
| Length (length) | |
| {} | |
| CharacterRange() : First(0), Length(0) | |
| {} | |
| CharacterRange & operator = (const CharacterRange &rhs) | |
| { | |
| First = rhs.First; | |
| Length = rhs.Length; | |
| return *this; | |
| } | |
| INT First; | |
| INT Length; | |
| }; | |
| #endif // !_GDIPLUSTYPES_HPP |