/win32/MinGW/include/gdiplus/gdiplustypes.h

/*

 * gdiplustypes.h

 *

 * GDI+ basic type declarations

 *

 * This file is part of the w32api package.

 *

 * Contributors:

 *   Created by Markus Koenig <markus@stber-koenig.de>

 *

 * THIS SOFTWARE IS NOT COPYRIGHTED

 *

 * This source code is offered for use in the public domain. You may

 * use, modify or distribute it freely.

 *

 * This code is distributed in the hope that it will be useful but

 * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY

 * DISCLAIMED. This includes but is not limited to warranties of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 *

 */



#ifndef __GDIPLUS_TYPES_H

#define __GDIPLUS_TYPES_H

#if __GNUC__ >=3

#pragma GCC system_header

#endif



#define WINGDIPAPI __stdcall

#define GDIPCONST const



typedef enum GpStatus {

	Ok = 0,

	GenericError = 1,

	InvalidParameter = 2,

	OutOfMemory = 3,

	ObjectBusy = 4,

	InsufficientBuffer = 5,

	NotImplemented = 6,

	Win32Error = 7,

	WrongState = 8,

	Aborted = 9,

	FileNotFound = 10,

	ValueOverflow = 11,

	AccessDenied = 12,

	UnknownImageFormat = 13,

	FontFamilyNotFound = 14,

	FontStyleNotFound = 15,

	NotTrueTypeFont = 16,

	UnsupportedGdiplusVersion = 17,

	GdiplusNotInitialized = 18,

	PropertyNotFound = 19,

	PropertyNotSupported = 20,

	ProfileNotFound = 21

} GpStatus;



#ifdef __cplusplus

typedef GpStatus Status;

#endif



typedef struct Size {

	INT Width;

	INT Height;



	#ifdef __cplusplus

	Size(): Width(0), Height(0) {}

	Size(INT width, INT height): Width(width), Height(height) {}

	Size(const Size& size): Width(size.Width), Height(size.Height) {}

	

	BOOL Empty() const {

		return Width == 0 && Height == 0;

	}

	BOOL Equals(const Size& size) const {

		return Width == size.Width && Height == size.Height;

	}

	Size operator+(const Size& size) const {

		return Size(Width + size.Width, Height + size.Height);

	}

	Size operator-(const Size& size) const {

		return Size(Width - size.Width, Height - size.Height);

	}

	#endif /* __cplusplus */

} Size;



typedef struct SizeF {

	REAL Width;

	REAL Height;



	#ifdef __cplusplus

	SizeF(): Width(0.0f), Height(0.0f) {}

	SizeF(REAL width, REAL height): Width(width), Height(height) {}

	SizeF(const SizeF& size): Width(size.Width), Height(size.Height) {}

	

	BOOL Empty() const {

		return Width == 0.0f && Height == 0.0f;

	}

	BOOL Equals(const SizeF& size) const {

		return Width == size.Width && Height == size.Height;

	}

	SizeF operator+(const SizeF& size) const {

		return SizeF(Width + size.Width, Height + size.Height);

	}

	SizeF operator-(const SizeF& size) const {

		return SizeF(Width - size.Width, Height - size.Height);

	}

	#endif /* __cplusplus */

} SizeF;



typedef struct Point {

	INT X;

	INT Y;



	#ifdef __cplusplus

	Point(): X(0), Y(0) {}

	Point(INT x, INT y): X(x), Y(y) {}

	Point(const Point& point): X(point.X), Y(point.Y) {}

	Point(const Size& size): X(size.Width), Y(size.Height) {}

	

	BOOL Equals(const Point& point) const {

		return X == point.X && Y == point.Y;

	}

	Point operator+(const Point& point) const {

		return Point(X + point.X, Y + point.Y);

	}

	Point operator-(const Point& point) const {

		return Point(X - point.X, Y - point.Y);

	}

	#endif /* __cplusplus */

} Point;



typedef struct PointF {

	REAL X;

	REAL Y;



	#ifdef __cplusplus

	PointF(): X(0.0f), Y(0.0f) {}

	PointF(REAL x, REAL y): X(x), Y(y) {}

	PointF(const PointF& point): X(point.X), Y(point.Y) {}

	PointF(const SizeF& size): X(size.Width), Y(size.Height) {}

	

	BOOL Equals(const PointF& point) const {

		return X == point.X && Y == point.Y;

	}

	PointF operator+(const PointF& point) const {

		return PointF(X + point.X, Y + point.Y);

	}

	PointF operator-(const PointF& point) const {

		return PointF(X - point.X, Y - point.Y);

	}

	#endif /* __cplusplus */

} PointF;



typedef struct Rect {

	INT X;

	INT Y;

	INT Width;

	INT Height;



	#ifdef __cplusplus

	Rect(): X(0), Y(0), Width(0), Height(0) {}

	Rect(const Point& location, const Size& size):

		X(location.X), Y(location.Y),

		Width(size.Width), Height(size.Height) {}

	Rect(INT x, INT y, INT width, INT height):

		X(x), Y(y), Width(width), Height(height) {}

	

	Rect* Clone() const {

		return new Rect(X, Y, Width, Height);

	}

	BOOL Contains(INT x, INT y) const {

		return X <= x && Y <= y && x < X+Width && y < Y+Height;

	}

	BOOL Contains(const Point& point) const {

		return Contains(point.X, point.Y);

	}

	BOOL Contains(const Rect& rect) const {

		return X <= rect.X && Y <= rect.Y

			&& rect.X+rect.Width <= X+Width

			&& rect.Y+rect.Height <= Y+Height;

	}

	BOOL Equals(const Rect& rect) const {

		return X == rect.X && Y == rect.Y

			&& Width == rect.Width && Height == rect.Height;

	}

	INT GetBottom() const {

		return Y+Height;

	}

	VOID GetBounds(Rect *rect) const {

		if (rect != NULL) {

			rect->X = X;

			rect->Y = Y;

			rect->Width = Width;

			rect->Height = Height;

		}

	}

	INT GetLeft() const {

		return X;

	}

	VOID GetLocation(Point *point) const {

		if (point != NULL) {

			point->X = X;

			point->Y = Y;

		}

	}

	INT GetRight() const {

		return X+Width;

	}

	VOID GetSize(Size *size) const {

		if (size != NULL) {

			size->Width = Width;

			size->Height = Height;

		}

	}

	INT GetTop() const {

		return Y;

	}

	BOOL IsEmptyArea() const {

		return Width <= 0 || Height <= 0;

	}

	VOID Inflate(INT dx, INT dy) {

		X -= dx;

		Y -= dy;

		Width += 2*dx;

		Height += 2*dy;

	}

	VOID Inflate(const Point& point) {

		Inflate(point.X, point.Y);

	}

	static BOOL Intersect(Rect& c, const Rect& a, const Rect& b) {

		INT intersectLeft   = (a.X < b.X) ? b.X : a.X;

		INT intersectTop    = (a.Y < b.Y) ? b.Y : a.Y; 

		INT intersectRight  = (a.GetRight() < b.GetRight())

					? a.GetRight() : b.GetRight();

		INT intersectBottom = (a.GetBottom() < b.GetBottom())

					? a.GetBottom() : b.GetBottom();

		c.X = intersectLeft;

		c.Y = intersectTop;

		c.Width = intersectRight - intersectLeft;

		c.Height = intersectBottom - intersectTop;

		return !c.IsEmptyArea();  

	}

	BOOL Intersect(const Rect& rect) {

		return Intersect(*this, *this, rect);

	}

	BOOL IntersectsWith(const Rect& rc) const {

		INT intersectLeft   = (X < rc.X) ? rc.X : X;

		INT intersectTop    = (Y < rc.Y) ? rc.Y : Y; 

		INT intersectRight  = (GetRight() < rc.GetRight())

					? GetRight() : rc.GetRight();

		INT intersectBottom = (GetBottom() < rc.GetBottom())

					? GetBottom() : rc.GetBottom();

		return intersectLeft < intersectRight

			&& intersectTop < intersectBottom;

	}

	VOID Offset(INT dx, INT dy) {

		X += dx;

		Y += dy;

	}

	VOID Offset(const Point& point) {

		Offset(point.X, point.Y);

	}

	static BOOL Union(Rect& c, const Rect& a, const Rect& b) {

		INT unionLeft   = (a.X < b.X) ? a.X : b.X;

		INT unionTop    = (a.Y < b.Y) ? a.Y : b.Y; 

		INT unionRight  = (a.GetRight() < b.GetRight())

					? b.GetRight() : a.GetRight();

		INT unionBottom = (a.GetBottom() < b.GetBottom())

					? b.GetBottom() : a.GetBottom();

		c.X = unionLeft;

		c.Y = unionTop;

		c.Width = unionRight - unionLeft;

		c.Height = unionBottom - unionTop;

		return !c.IsEmptyArea();

	}

	#endif /* __cplusplus */

} Rect;



typedef struct RectF {

	REAL X;

	REAL Y;

	REAL Width;

	REAL Height;



	#ifdef __cplusplus

	RectF(): X(0.0f), Y(0.0f), Width(0.0f), Height(0.0f) {}

	RectF(const PointF& location, const SizeF& size):

		X(location.X), Y(location.Y),

		Width(size.Width), Height(size.Height) {}

	RectF(REAL x, REAL y, REAL width, REAL height):

		X(x), Y(y), Width(width), Height(height) {}

	

	RectF* Clone() const {

		return new RectF(X, Y, Width, Height);

	}

	BOOL Contains(REAL x, REAL y) const {

		return X <= x && Y <= y && x < X+Width && y < Y+Height;

	}

	BOOL Contains(const PointF& point) const {

		return Contains(point.X, point.Y);

	}

	BOOL Contains(const RectF& rect) const {

		return X <= rect.X && Y <= rect.Y

			&& rect.X+rect.Width <= X+Width

			&& rect.Y+rect.Height <= Y+Height;

	}

	BOOL Equals(const RectF& rect) const {

		return X == rect.X && Y == rect.Y

			&& Width == rect.Width && Height == rect.Height;

	}

	REAL GetBottom() const {

		return Y+Height;

	}

	VOID GetBounds(RectF *rect) const {

		if (rect != NULL) {

			rect->X = X;

			rect->Y = Y;

			rect->Width = Width;

			rect->Height = Height;

		}

	}

	REAL GetLeft() const {

		return X;

	}

	VOID GetLocation(PointF *point) const {

		if (point != NULL) {

			point->X = X;

			point->Y = Y;

		}

	}

	REAL GetRight() const {

		return X+Width;

	}

	VOID GetSize(SizeF *size) const {

		if (size != NULL) {

			size->Width = Width;

			size->Height = Height;

		}

	}

	REAL GetTop() const {

		return Y;

	}

	BOOL IsEmptyArea() const {

		return Width <= 0.0f || Height <= 0.0f;

	}

	VOID Inflate(REAL dx, REAL dy) {

		X -= dx;

		Y -= dy;

		Width += 2*dx;

		Height += 2*dy;

	}

	VOID Inflate(const PointF& point) {

		Inflate(point.X, point.Y);

	}

	static BOOL Intersect(RectF& c, const RectF& a, const RectF& b) {

		INT intersectLeft   = (a.X < b.X) ? b.X : a.X;

		INT intersectTop    = (a.Y < b.Y) ? b.Y : a.Y; 

		INT intersectRight  = (a.GetRight() < b.GetRight())

					? a.GetRight() : b.GetRight();

		INT intersectBottom = (a.GetBottom() < b.GetBottom())

					? a.GetBottom() : b.GetBottom();

		c.X = intersectLeft;

		c.Y = intersectTop;

		c.Width = intersectRight - intersectLeft;

		c.Height = intersectBottom - intersectTop;

		return !c.IsEmptyArea();  

	}

	BOOL Intersect(const RectF& rect) {

		return Intersect(*this, *this, rect);

	}

	BOOL IntersectsWith(const RectF& rc) const {

		INT intersectLeft   = (X < rc.X) ? rc.X : X;

		INT intersectTop    = (Y < rc.Y) ? rc.Y : Y; 

		INT intersectRight  = (GetRight() < rc.GetRight())

					? GetRight() : rc.GetRight();

		INT intersectBottom = (GetBottom() < rc.GetBottom())

					? GetBottom() : rc.GetBottom();

		return intersectLeft < intersectRight

			&& intersectTop < intersectBottom;

	}

	VOID Offset(REAL dx, REAL dy) {

		X += dx;

		Y += dy;

	}

	VOID Offset(const PointF& point) {

		Offset(point.X, point.Y);

	}

	static BOOL Union(RectF& c, const RectF& a, const RectF& b) {

		INT unionLeft   = (a.X < b.X) ? a.X : b.X;

		INT unionTop    = (a.Y < b.Y) ? a.Y : b.Y; 

		INT unionRight  = (a.GetRight() < b.GetRight())

					? b.GetRight() : a.GetRight();

		INT unionBottom = (a.GetBottom() < b.GetBottom())

					? b.GetBottom() : a.GetBottom();

		c.X = unionLeft;

		c.Y = unionTop;

		c.Width = unionRight - unionLeft;

		c.Height = unionBottom - unionTop;

		return !c.IsEmptyArea();

	}

	#endif /* __cplusplus */

} RectF;



/* FIXME: Are descendants of this class, when compiled with g++,

   binary compatible with MSVC++ code (especially GDIPLUS.DLL of course)? */

#ifdef __cplusplus

struct GdiplusAbort {

	virtual HRESULT __stdcall Abort(void) {}

};

#else

typedef struct GdiplusAbort GdiplusAbort;  /* incomplete type */

#endif



typedef struct CharacterRange {

	INT First;

	INT Length;



	#ifdef __cplusplus

	CharacterRange(): First(0), Length(0) {}

	CharacterRange(INT first, INT length): First(first), Length(length) {}

	CharacterRange& operator=(const CharacterRange& rhs) {

		/* This gracefully handles self-assignment */

		First = rhs.First;

		Length = rhs.Length;

		return *this;

	}

	#endif /* __cplusplus */

} CharacterRange;



typedef struct PathData {

	INT Count;

	PointF *Points;

	BYTE *Types;



	#ifdef __cplusplus

	friend class GraphicsPath;



	PathData(): Count(0), Points(NULL), Types(NULL) {}

	~PathData() {

		FreeArrays();

	}

private:

	/* used by GraphicsPath::GetPathData, defined in gdipluspath.h */

	Status AllocateArrays(INT capacity);

	VOID FreeArrays();

	#endif /* __cplusplus */

} PathData;



/* Callback function types */

/* FIXME: need a correct definition for these function pointer types */

typedef void *DebugEventProc;

typedef BOOL CALLBACK (*EnumerateMetafileProc)(EmfPlusRecordType,UINT,UINT,const BYTE*,VOID*);

typedef void *DrawImageAbort;

typedef void *GetThumbnailImageAbort;





#endif /* __GDIPLUS_TYPES_H */