www.pudn.com > WinGOS.rar > GosTypes.h

#ifndef _GOS_SHAPES_H_ 
#define _GOS_SHAPES_H_ 
 
#define MemberOffset(Class,Member) DWORD(&((Class*)0)->Member) 
 
typedef struct _tagRGBQUAD{ 
	BYTE rgbBlue; 
	BYTE rgbGreen; 
	BYTE rgbRed; 
	BYTE rgbReserved; 
}RGBQUAD,*PRGBQUAD; 
 
typedef struct _tagSIZE 
{ 
	int cx; 
	int cy; 
}SIZE,*PSIZE,*LPSIZE; 
 
typedef struct _tagPOINT 
{ 
	int x; 
	int y; 
}POINT,*PPOINT,*LPPOINT; 
 
typedef struct _tagRECT 
{ 
	int left; 
	int top; 
    int right; 
    int bottom; 
}RECT,*PRECT,*LPRECT; 
typedef const RECT *LPCRECT; 
 
// CSize 
class CSize : public _tagSIZE 
{ 
public:	 
// Constructors 
	CSize() 
		{ /* random filled */ } 
	CSize(int initCX, int initCY) 
		{ cx = initCX; cy = initCY; } 
	CSize(SIZE initSize) 
		{ *(SIZE*)this = initSize; } 
	CSize(DWORD dwSize) 
	{ 
		cx = LOWORD(dwSize); 
		cy = HIWORD(dwSize); 
	} 
// Operations 
	void SetSize(int CX, int CY) 
		{ cx = CX; cy = CY; }	 
	BOOL operator==(SIZE size) const 
		{ return (cx == size.cx && cy == size.cy); } 
	BOOL operator!=(SIZE size) const 
		{ return (cx != size.cx || cy != size.cy); } 
	void operator+=(SIZE size) 
		{ cx += size.cx; cy += size.cy; } 
	void operator-=(SIZE size) 
		{ cx -= size.cx; cy -= size.cy; } 
	CSize CSize::operator+(SIZE size) const 
		{ return CSize(cx + size.cx, cy + size.cy); } 
	CSize CSize::operator-(SIZE size) const 
		{ return CSize(cx - size.cx, cy - size.cy); } 
	CSize CSize::operator-() const 
		{ return CSize(-cx, -cy); } 
}; 
 
// CPoint 
class CPoint : public _tagPOINT 
{ 
public:	 
// Constructors 
	CPoint() 
		{ /* random filled */ } 
	CPoint(int initX, int initY) 
		{ x = initX; y = initY; } 
	CPoint(POINT initPt) 
		{ *(POINT*)this = initPt; } 
	CPoint(DWORD dwPoint) 
	{ 
		x = LOWORD(dwPoint); 
		y = HIWORD(dwPoint); 
	} 
// Operations 
	void Offset(int xOffset, int yOffset) 
		{ x += xOffset; y += yOffset; } 
	void SetPoint(int X, int Y) 
		{ x = X; y = Y; } 
	BOOL operator==(POINT point) const 
		{ return (x == point.x && y == point.y); } 
	BOOL operator!=(POINT point) const 
		{ return (x != point.x || y != point.y); } 
	void CPoint::operator+=(SIZE size) 
		{ x += size.cx; y += size.cy; } 
	void CPoint::operator-=(SIZE size) 
		{ x -= size.cx; y -= size.cy; } 
	CSize operator-(POINT point) const 
		{ CSize size; size.cx=x-point.x; 
			size.cy=y-point.y; return size; } 
}; 
 
// CRect 
class CRect : public _tagRECT 
{ 
public:	 
// Constructors 
	CRect() 
		{ /* random filled */ } 
	CRect(int l, int t, int r, int b) 
		{ left = l; top = t; right = r; bottom = b; } 
	CRect(POINT point, SIZE size) 
		{ right = (left = point.x) + size.cx; bottom = (top = point.y) + size.cy; } 
	CRect(POINT topLeft, POINT bottomRight) 
		{ left = topLeft.x; top = topLeft.y; 
			right = bottomRight.x; bottom = bottomRight.y; } 
	CRect(LPCRECT lpSrcRect) 
		{ *(RECT*)this = *lpSrcRect; } 
	CRect(const RECT& srcRect) 
		{ *(RECT*)this = srcRect; } 
// Operations 
	int Width() const 
		{ return right - left; } 
	int Height() const 
		{ return bottom - top; } 
	CSize Size() const 
		{ return CSize(right - left, bottom - top); } 
	CPoint& TopLeft() 
		{ return *((CPoint*)this); } 
	const CPoint& TopLeft() const 
		{ return *((CPoint*)this); } 
	CPoint& BottomRight() 
		{ return *((CPoint*)this+1); } 
	const CPoint& BottomRight() const 
		{ return *((CPoint*)this+1); } 
	CPoint CenterPoint() const 
		{ return CPoint((left+right)>>1, (top+bottom)>>1); } 
	BOOL IsRectEmpty() const 
		{ return left >= right || top >= bottom; } 
	BOOL PtInRect(int x,int y) const 
		{ return x >= left && x < right && y >= top && y < bottom; } 
	BOOL PtInRect(POINT point) const 
		{ return point.x >= left && point.x < right 
			&& point.y >= top && point.y < bottom; } 
	BOOL IncludeRect(LPCRECT lpRect) const 
		{ return left <= lpRect->left && top <= lpRect->top && 
			right >= lpRect->right && bottom >= lpRect->bottom; } 
	void SetRect(int x1, int y1, int x2, int y2) 
		{ left = x1; top = y1; right = x2; bottom = y2; } 
	void SetRect(POINT topLeft, POINT bottomRight) 
		{ left = topLeft.x; top = topLeft.y; right = bottomRight.x; bottom = bottomRight.y; } 
	void SetRect(POINT point, SIZE size) 
		{ right = (left = point.x) + size.cx; bottom = (top = point.y) + size.cy; } 
	void CopyRect(LPCRECT lpSrcRect) 
		{ *(RECT*)this = *lpSrcRect; } 
	BOOL EqualRect(LPCRECT lpRect) const 
		{ return left == lpRect->left && top == lpRect->top && 
			right == lpRect->right && bottom == lpRect->bottom; } 
	void CRect::InflateRect(int cxy) 
		{ left -= cxy; top -= cxy; right += cxy; bottom += cxy; } 
	void CRect::InflateRect(int cx,int cy) 
		{ left -= cx; top -= cy; right += cx; bottom += cy; } 
	void CRect::InflateRect(SIZE size) 
		{ left -= size.cx; top -= size.cy; right += size.cx; bottom += size.cy; } 
	void CRect::InflateRect(int l, int t, int r, int b) 
		{ left -= l; top -= t; right += r; bottom += b; } 
	void CRect::DeflateRect(int cxy) 
		{ left += cxy; top += cxy; right -= cxy; bottom -= cxy; } 
	void CRect::DeflateRect(int cx,int cy) 
		{ left += cx; top += cy; right -= cx; bottom -= cy; } 
	void CRect::DeflateRect(SIZE size) 
		{ left += size.cx; top += size.cy; right -= size.cx; bottom -= size.cy; } 
	void CRect::DeflateRect(int l, int t, int r, int b) 
		{ left += l; top += t; right -= r; bottom -= b; } 
	void OffsetRect(int cx, int cy) 
		{ left += cx; top += cy; right += cx; bottom += cy; } 
	void OffsetRect(POINT pt) 
		{ left += pt.x; top += pt.y; right += pt.x; bottom += pt.y; } 
	void OffsetRect(SIZE size) 
		{ left += size.cx; top += size.cy; right += size.cx; bottom += size.cy; } 
	void OffsetRectX(int cx) 
		{ left += cx; right += cx; } 
	void OffsetRectY(int cy) 
		{ top += cy; bottom += cy; } 
	void MoveTo(int x,int y) 
		{ right -= left; right += x; left = x; 
			bottom -= top; bottom += y; top = y; } 
	void MoveTo(POINT pt) 
		{ right -= left; right += pt.x; left = pt.x; 
			bottom -= top; bottom += pt.y; top = pt.y; } 
	void MoveToX(int x) 
		{ right -= left; right += x; left = x; } 
	void MoveToY(int y) 
		{ bottom -= top; bottom += y; top = y; } 
	void CenterTo(int x,int y) 
		{ int wh=right-left; left = x-(wh>>1); right=left+wh; 
			wh=bottom-top; top=y-(wh>>1); bottom=top+wh;} 
	void CenterTo(POINT pt) 
		{ int wh=right-left; left = pt.x-(wh>>1); right=left+wh; 
			wh=bottom-top; top=pt.y-(wh>>1); bottom=top+wh;} 
	void SetSize(int cx,int cy) 
		{ right = left + cx; bottom = top + cy; } 
	void SetSize(SIZE size) 
		{ right = left + size.cx; bottom = top + size.cy; } 
	void NormalizeRect() 
		{ int nTemp; 
			if (left > right){nTemp = left;	left = right; right = nTemp; } 
			if (top > bottom){nTemp = top; top = bottom;bottom = nTemp;	}} 
	void IntersectRect(LPCRECT pRect) 
		{ if(left < pRect->left)left = pRect->left; 
			if(top < pRect->top)top = pRect->top; 
			if(right > pRect->right)right = pRect->right; 
			if(bottom > pRect->bottom)bottom = pRect->bottom; } 
	void IntersectRect(LPCRECT pRect1,LPCRECT pRect2) 
		{ left = pRect1->left > pRect2->left ? pRect1->left : pRect2->left; 
			top = pRect1->top > pRect2->top ? pRect1->top : pRect2->top; 
			right = pRect1->right < pRect2->right? pRect1->right : pRect2->right; 
			bottom = pRect1->bottom < pRect2->bottom? pRect1->bottom : pRect2->bottom; } 
	void UnionRect(LPCRECT pRect) 
		{ if(left > pRect->left)left = pRect->left; 
			if(top > pRect->top)top = pRect->top; 
			if(right < pRect->right)right = pRect->right; 
			if(bottom < pRect->bottom)bottom = pRect->bottom; } 
	void UnionRect(LPCRECT pRect1,LPCRECT pRect2) 
		{ left = pRect1->left < pRect2->left ? pRect1->left : pRect2->left; 
			top = pRect1->top < pRect2->top ? pRect1->top : pRect2->top; 
			right = pRect1->right > pRect2->right? pRect1->right : pRect2->right; 
			bottom = pRect1->bottom > pRect2->bottom? pRect1->bottom : pRect2->bottom; } 
	BOOL SubtractRect(LPCRECT pRect); 
	BOOL SubtractRect(LPCRECT pRect1,LPCRECT pRect2) 
		{ *(RECT*)this = *pRect1; return SubtractRect(pRect2); } 
// Additional Operations 
	operator LPRECT() 
		{ return this; } 
	operator LPCRECT() const 
		{ return this; } 
	void operator=(const RECT& srcRect) 
		{ *(RECT*)this = srcRect; } 
}; 
 
class CPlex 
{ 
public: 
	void* data() { return this+1; } 
	void FreeDataChain(); 
	static PVOID CreateHead(CPlex* &pHead,int nBytes); 
	static PVOID CreateTail(CPlex* &pTail,int nBytes); 
public: 
	CPlex* m_pNext; 
}; 
 
#endif	// _GOS_SHAPES_H_