775 lines
14 KiB
Text
775 lines
14 KiB
Text
class PixSize;
|
|
class PixPoint;
|
|
class PixRect;
|
|
|
|
|
|
struct xPix
|
|
{LONG n;
|
|
xPix():n(0){}
|
|
explicit xPix(LONG x):n(x){}
|
|
};
|
|
struct yPix
|
|
{LONG n;
|
|
yPix():n(0){}
|
|
explicit yPix(LONG x):n(x){}
|
|
};
|
|
|
|
|
|
class PixSize : public SIZE
|
|
{
|
|
public:
|
|
operator xPix(){return xPix(cx);}
|
|
operator yPix(){return yPix(cy);}
|
|
|
|
// Constructors
|
|
PixSize& operator+=(const PixSize& x){cx+=x.cx;
|
|
cy+=x.cy;
|
|
return *this;
|
|
}
|
|
PixSize()
|
|
{
|
|
cx = 0;
|
|
cy = 0;
|
|
}
|
|
|
|
PixSize(int initCX, int initCY)
|
|
{
|
|
cx = initCX;
|
|
cy = initCY;
|
|
}
|
|
|
|
PixSize(SIZE initSize)
|
|
{
|
|
*(SIZE*)this = initSize;
|
|
}
|
|
|
|
PixSize(POINT initPt)
|
|
{
|
|
*(POINT*)this = initPt;
|
|
}
|
|
|
|
PixSize(DWORD dwSize)
|
|
{
|
|
cx = (short)LOWORD(dwSize);
|
|
cy = (short)HIWORD(dwSize);
|
|
}
|
|
|
|
// Operations
|
|
PixSize& operator=(const RECT& r) {cx =r.right-r.left;return *this;}
|
|
PixSize& operator=(LONG sz) {cx =sz;cy=sz ;return *this;}
|
|
|
|
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;
|
|
}
|
|
|
|
void SetSize(int CX, int CY)
|
|
{
|
|
cx = CX;
|
|
cy = CY;
|
|
}
|
|
|
|
// Operators returning PixSize values
|
|
PixSize operator +(SIZE size) const
|
|
{
|
|
return PixSize(cx + size.cx, cy + size.cy);
|
|
}
|
|
|
|
PixSize operator -(SIZE size) const
|
|
{
|
|
return PixSize(cx - size.cx, cy - size.cy);
|
|
}
|
|
|
|
PixSize operator -() const
|
|
{
|
|
return PixSize(-cx, -cy);
|
|
}
|
|
|
|
// Operators returning PixPoint values
|
|
PixPoint operator +(POINT point) const;
|
|
PixPoint operator -(POINT point) const;
|
|
|
|
// Operators returning PixRect values
|
|
PixRect operator +(const RECT* lpRect) const;
|
|
PixRect operator -(const RECT* lpRect) const;
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// PixPoint - Wrapper for Windows POINT structure.
|
|
|
|
class PixPoint : public POINT
|
|
{
|
|
public:
|
|
// Constructors
|
|
PixPoint(const PixSize& a){x =a.cx;y=a.cy;}
|
|
|
|
PixPoint()
|
|
{
|
|
x = 0;
|
|
y = 0;
|
|
}
|
|
|
|
PixPoint(int initX, int initY)
|
|
{
|
|
x = initX;
|
|
y = initY;
|
|
}
|
|
|
|
PixPoint(POINT initPt)
|
|
{
|
|
*(POINT*)this = initPt;
|
|
}
|
|
|
|
PixPoint(SIZE initSize)
|
|
{
|
|
*(SIZE*)this = initSize;
|
|
}
|
|
|
|
PixPoint(DWORD dwPoint)
|
|
{
|
|
x = (short)LOWORD(dwPoint);
|
|
y = (short)HIWORD(dwPoint);
|
|
}
|
|
|
|
// Operations
|
|
PixPoint& operator=(const RECT& b) {x =b.left;y=b.top;return *this;}
|
|
|
|
void Offset(int xOffset, int yOffset)
|
|
{
|
|
x += xOffset;
|
|
y += yOffset;
|
|
}
|
|
|
|
void Offset(POINT point)
|
|
{
|
|
x += point.x;
|
|
y += point.y;
|
|
}
|
|
|
|
void Offset(SIZE size)
|
|
{
|
|
x += size.cx;
|
|
y += size.cy;
|
|
}
|
|
|
|
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 operator +=(SIZE size)
|
|
{
|
|
x += size.cx;
|
|
y += size.cy;
|
|
}
|
|
|
|
void operator -=(SIZE size)
|
|
{
|
|
x -= size.cx;
|
|
y -= size.cy;
|
|
}
|
|
|
|
void operator +=(POINT point)
|
|
{
|
|
x += point.x;
|
|
y += point.y;
|
|
}
|
|
|
|
void operator -=(POINT point)
|
|
{
|
|
x -= point.x;
|
|
y -= point.y;
|
|
}
|
|
|
|
void SetPoint(int X, int Y)
|
|
{
|
|
x = X;
|
|
y = Y;
|
|
}
|
|
|
|
// Operators returning PixPoint values
|
|
PixPoint operator +(SIZE size) const
|
|
{
|
|
return PixPoint(x + size.cx, y + size.cy);
|
|
}
|
|
|
|
PixPoint operator -(SIZE size) const
|
|
{
|
|
return PixPoint(x - size.cx, y - size.cy);
|
|
}
|
|
|
|
PixPoint operator -() const
|
|
{
|
|
return PixPoint(-x, -y);
|
|
}
|
|
|
|
PixPoint operator +(POINT point) const
|
|
{
|
|
return PixPoint(x + point.x, y + point.y);
|
|
}
|
|
|
|
// Operators returning PixSize values
|
|
PixSize operator -(POINT point) const
|
|
{
|
|
return PixSize(x - point.x, y - point.y);
|
|
}
|
|
|
|
// Operators returning PixRect values
|
|
PixRect operator +(const RECT* lpRect) const;
|
|
PixRect operator -(const RECT* lpRect) const;
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// PixRect - Wrapper for Windows RECT structure.
|
|
|
|
class PixRect : public RECT
|
|
{
|
|
public:
|
|
PixRect& adjust()const{const_cast<PixRect*>(this)->right =max(left,right);
|
|
const_cast<PixRect*>(this)->bottom=max(top ,bottom);
|
|
return *const_cast<PixRect*>(this);
|
|
}
|
|
// Constructors
|
|
PixSize size(){adjust();
|
|
if(right < left) right=left;
|
|
if(bottom < top) bottom=top;
|
|
|
|
PixSize s;
|
|
s.cx=right-left;
|
|
s.cy=bottom-top;
|
|
return s;
|
|
}
|
|
PixRect(const PixSize& s){*this =s;}
|
|
PixRect(const PixPoint& x){*this =x;}
|
|
PixRect& sizeMax(const PixRect& plt ,const PixRect& prb)
|
|
{adjust();
|
|
const_cast<PixRect&>(plt).adjust();
|
|
const_cast<PixRect&>(prb).adjust();
|
|
|
|
PixSize nsz=PixRect(plt.left,plt.top,prb.right,prb.bottom).size();
|
|
PixSize sz =size();
|
|
PixSize mx(max(nsz.cx,sz.cx)
|
|
,max(nsz.cy,sz.cy)
|
|
);
|
|
*this =mx;
|
|
return *this;
|
|
}
|
|
|
|
PixRect()
|
|
{
|
|
left = 0;
|
|
top = 0;
|
|
right = 0;
|
|
bottom = 0;
|
|
}
|
|
|
|
PixRect(int l, int t, int r, int b)
|
|
{
|
|
left = l;
|
|
top = t;
|
|
right = r;
|
|
bottom = b;
|
|
}
|
|
|
|
PixRect(const RECT& srERect)
|
|
{
|
|
::CopyRect(this, &srERect);
|
|
}
|
|
|
|
PixRect(LPCRECT lpSrERect)
|
|
{
|
|
::CopyRect(this, lpSrERect);
|
|
}
|
|
|
|
PixRect(POINT point, SIZE size)
|
|
{
|
|
right = (left = point.x) + size.cx;
|
|
bottom = (top = point.y) + size.cy;
|
|
}
|
|
|
|
PixRect(POINT topLeft, POINT bottomRight)
|
|
{
|
|
left = topLeft.x;
|
|
top = topLeft.y;
|
|
right = bottomRight.x;
|
|
bottom = bottomRight.y;
|
|
}
|
|
|
|
// Attributes (in addition to RECT members)
|
|
int Width() const
|
|
{
|
|
adjust();
|
|
return right - left;
|
|
}
|
|
|
|
int Height() const
|
|
{
|
|
adjust();
|
|
return bottom - top;
|
|
}
|
|
|
|
PixSize Size() const
|
|
{
|
|
adjust();
|
|
return PixSize(right - left, bottom - top);
|
|
}
|
|
|
|
PixPoint& TopLeft()
|
|
{
|
|
return *((PixPoint*)this);
|
|
}
|
|
PixPoint& point()
|
|
{
|
|
return *((PixPoint*)this);
|
|
}
|
|
|
|
PixPoint& BottomRight()
|
|
{
|
|
adjust();
|
|
return *((PixPoint*)this + 1);
|
|
}
|
|
|
|
const PixPoint& TopLeft() const
|
|
{
|
|
return *((PixPoint*)this);
|
|
}
|
|
|
|
const PixPoint& BottomRight() const
|
|
{
|
|
adjust();
|
|
return *((PixPoint*)this + 1);
|
|
}
|
|
|
|
PixPoint CenterPoint() const
|
|
{
|
|
adjust();
|
|
return PixPoint((left + right) / 2, (top + bottom) / 2);
|
|
}
|
|
|
|
// convert between PixRect and LPRECT/LPCRECT (no need for &)
|
|
operator LPRECT()
|
|
{
|
|
adjust();
|
|
return this;
|
|
}
|
|
|
|
operator LPCRECT() const
|
|
{
|
|
adjust();
|
|
return this;
|
|
}
|
|
|
|
BOOL IsRectEmpty() const
|
|
{
|
|
adjust();
|
|
return ::IsRectEmpty(this);
|
|
}
|
|
|
|
BOOL IsRectNull() const
|
|
{
|
|
return (left == 0 && right == 0 && top == 0 && bottom == 0);
|
|
}
|
|
|
|
BOOL PtInRect(POINT point) const
|
|
{
|
|
adjust();
|
|
return ::PtInRect(this, point);
|
|
}
|
|
|
|
// Operations
|
|
void SetRect(int x1, int y1, int x2, int y2)
|
|
{
|
|
::SetRect(this, x1, y1, x2, y2);
|
|
}
|
|
|
|
void SetRect(POINT topLeft, POINT bottomRight)
|
|
{
|
|
::SetRect(this, topLeft.x, topLeft.y, bottomRight.x, bottomRight.y);
|
|
}
|
|
|
|
void SetRectEmpty()
|
|
{
|
|
::SetRectEmpty(this);
|
|
}
|
|
|
|
void CopyRect(LPCRECT lpSrERect)
|
|
{
|
|
adjust();
|
|
::CopyRect(this, lpSrERect);
|
|
}
|
|
|
|
BOOL EqualRect(LPCRECT lpRect) const
|
|
{
|
|
adjust();
|
|
return ::EqualRect(this, lpRect);
|
|
}
|
|
|
|
void InflateRect(int x, int y)
|
|
{
|
|
adjust();
|
|
::InflateRect(this, x, y);
|
|
}
|
|
|
|
void InflateRect(SIZE size)
|
|
{
|
|
adjust();
|
|
::InflateRect(this, size.cx, size.cy);
|
|
}
|
|
|
|
void InflateRect(LPCRECT lpRect)
|
|
{
|
|
adjust();
|
|
left -= lpRect->left;
|
|
top -= lpRect->top;
|
|
right += lpRect->right;
|
|
bottom += lpRect->bottom;
|
|
}
|
|
|
|
void InflateRect(int l, int t, int r, int b)
|
|
{
|
|
adjust();
|
|
left -= l;
|
|
top -= t;
|
|
right += r;
|
|
bottom += b;
|
|
}
|
|
|
|
void DeflateRect(int x, int y)
|
|
{
|
|
adjust();
|
|
::InflateRect(this, -x, -y);
|
|
}
|
|
|
|
void DeflateRect(SIZE size)
|
|
{
|
|
adjust();
|
|
::InflateRect(this, -size.cx, -size.cy);
|
|
}
|
|
|
|
void DeflateRect(LPCRECT lpRect)
|
|
{
|
|
adjust();
|
|
left += lpRect->left;
|
|
top += lpRect->top;
|
|
right -= lpRect->right;
|
|
bottom -= lpRect->bottom;
|
|
}
|
|
|
|
void DeflateRect(int l, int t, int r, int b)
|
|
{
|
|
adjust();
|
|
left += l;
|
|
top += t;
|
|
right -= r;
|
|
bottom -= b;
|
|
}
|
|
|
|
void OffsetRect(int x, int y)
|
|
{
|
|
adjust();
|
|
::OffsetRect(this, x, y);
|
|
}
|
|
void OffsetRect(SIZE size)
|
|
{
|
|
adjust();
|
|
::OffsetRect(this, size.cx, size.cy);
|
|
}
|
|
|
|
void OffsetRect(POINT point)
|
|
{
|
|
adjust();
|
|
::OffsetRect(this, point.x, point.y);
|
|
}
|
|
|
|
void NormalizeRect()
|
|
{
|
|
adjust();
|
|
int nTemp;
|
|
if (left > right)
|
|
{
|
|
nTemp = left;
|
|
left = right;
|
|
right = nTemp;
|
|
}
|
|
if (top > bottom)
|
|
{
|
|
nTemp = top;
|
|
top = bottom;
|
|
bottom = nTemp;
|
|
}
|
|
}
|
|
|
|
// absolute position of rectangle
|
|
void MoveToY(int y)
|
|
{
|
|
adjust();
|
|
bottom = Height() + y;
|
|
top = y;
|
|
}
|
|
|
|
void MoveToX(int x)
|
|
{
|
|
adjust();
|
|
right = Width() + x;
|
|
left = x;
|
|
}
|
|
|
|
void MoveToXY(int x, int y)
|
|
{
|
|
adjust();
|
|
MoveToX(x);
|
|
MoveToY(y);
|
|
}
|
|
|
|
void MoveToXY(POINT pt)
|
|
{
|
|
adjust();
|
|
MoveToX(pt.x);
|
|
MoveToY(pt.y);
|
|
}
|
|
|
|
// operations that fill '*this' with result
|
|
BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2)
|
|
{
|
|
adjust();
|
|
return ::IntersectRect(this, lpRect1, lpRect2);
|
|
}
|
|
|
|
BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2)
|
|
{
|
|
adjust();
|
|
return ::UnionRect(this, lpRect1, lpRect2);
|
|
}
|
|
|
|
BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2)
|
|
{
|
|
adjust();
|
|
return ::SubtractRect(this, lpRectSrc1, lpRectSrc2);
|
|
}
|
|
|
|
// Additional Operations
|
|
PixRect& operator=(const POINT& p){left =p.x;top=p.y;return *this;}
|
|
PixRect& operator=(const SIZE& s){right =left+s.cx; bottom=top+s.cy;return *this;}
|
|
|
|
void operator =(const RECT& srERect)
|
|
{
|
|
::CopyRect(this, &srERect);
|
|
}
|
|
|
|
BOOL operator ==(const RECT& rect) const
|
|
{
|
|
adjust();
|
|
return ::EqualRect(this, &rect);
|
|
}
|
|
|
|
BOOL operator !=(const RECT& rect) const
|
|
{
|
|
adjust();
|
|
return !::EqualRect(this, &rect);
|
|
}
|
|
|
|
void operator +=(POINT point)
|
|
{
|
|
adjust();
|
|
::OffsetRect(this, point.x, point.y);
|
|
}
|
|
|
|
void operator +=(SIZE size)
|
|
{
|
|
adjust();
|
|
::OffsetRect(this, size.cx, size.cy);
|
|
}
|
|
|
|
void operator +=(LPCRECT lpRect)
|
|
{
|
|
adjust();
|
|
InflateRect(lpRect);
|
|
}
|
|
|
|
void operator -=(POINT point)
|
|
{
|
|
adjust();
|
|
::OffsetRect(this, -point.x, -point.y);
|
|
}
|
|
|
|
void operator -=(SIZE size)
|
|
{
|
|
adjust();
|
|
::OffsetRect(this, -size.cx, -size.cy);
|
|
}
|
|
|
|
void operator -=(LPCRECT lpRect)
|
|
{
|
|
adjust();
|
|
DeflateRect(lpRect);
|
|
}
|
|
|
|
void operator &=(const RECT& rect)
|
|
{
|
|
adjust();
|
|
::IntersectRect(this, this, &rect);
|
|
}
|
|
|
|
void operator |=(const RECT& rect)
|
|
{
|
|
adjust();
|
|
::UnionRect(this, this, &rect);
|
|
}
|
|
|
|
// Operators returning PixRect values
|
|
PixRect operator +(POINT pt) const
|
|
{
|
|
adjust();
|
|
PixRect rect(*this);
|
|
::OffsetRect(&rect, pt.x, pt.y);
|
|
return rect;
|
|
}
|
|
|
|
PixRect operator -(POINT pt) const
|
|
{
|
|
adjust();
|
|
PixRect rect(*this);
|
|
::OffsetRect(&rect, -pt.x, -pt.y);
|
|
return rect;
|
|
}
|
|
|
|
PixRect operator +(LPCRECT lpRect) const
|
|
{
|
|
adjust();
|
|
PixRect rect(this);
|
|
rect.InflateRect(lpRect);
|
|
return rect;
|
|
}
|
|
|
|
PixRect operator +(SIZE size) const
|
|
{
|
|
adjust();
|
|
PixRect rect(*this);
|
|
::OffsetRect(&rect, size.cx, size.cy);
|
|
return rect;
|
|
}
|
|
|
|
PixRect operator -(SIZE size) const
|
|
{
|
|
adjust();
|
|
PixRect rect(*this);
|
|
::OffsetRect(&rect, -size.cx, -size.cy);
|
|
return rect;
|
|
}
|
|
|
|
PixRect operator -(LPCRECT lpRect) const
|
|
{
|
|
adjust();
|
|
PixRect rect(this);
|
|
rect.DeflateRect(lpRect);
|
|
return rect;
|
|
}
|
|
|
|
PixRect operator &(const RECT& rect2) const
|
|
{
|
|
adjust();
|
|
PixRect rect;
|
|
::IntersectRect(&rect, this, &rect2);
|
|
return rect;
|
|
}
|
|
|
|
PixRect operator |(const RECT& rect2) const
|
|
{
|
|
adjust();
|
|
PixRect rect;
|
|
::UnionRect(&rect, this, &rect2);
|
|
return rect;
|
|
}
|
|
|
|
PixRect MulDiv(int nMultiplier, int nDivisor) const
|
|
{
|
|
adjust();
|
|
return PixRect(
|
|
::MulDiv(left, nMultiplier, nDivisor),
|
|
::MulDiv(top, nMultiplier, nDivisor),
|
|
::MulDiv(right, nMultiplier, nDivisor),
|
|
::MulDiv(bottom, nMultiplier, nDivisor));
|
|
}
|
|
};
|
|
|
|
|
|
// PixSize implementation
|
|
|
|
inline PixPoint PixSize::operator +(POINT point) const
|
|
{ return PixPoint(cx + point.x, cy + point.y); }
|
|
|
|
inline PixPoint PixSize::operator -(POINT point) const
|
|
{ return PixPoint(cx - point.x, cy - point.y); }
|
|
|
|
inline PixRect PixSize::operator +(const RECT* lpRect) const
|
|
{ return PixRect(lpRect) + *this; }
|
|
|
|
inline PixRect PixSize::operator -(const RECT* lpRect) const
|
|
{ return PixRect(lpRect) - *this; }
|
|
|
|
|
|
// PixPoint implementation
|
|
|
|
inline PixRect PixPoint::operator +(const RECT* lpRect) const
|
|
{ return PixRect(lpRect) + *this; }
|
|
|
|
inline PixRect PixPoint::operator -(const RECT* lpRect) const
|
|
{ return PixRect(lpRect) - *this; }
|
|
|
|
|
|
|
|
#if !defined(_WTL_NO_SIZE_SCALAR) && (!defined(_WTL_NO_WTYPES) || defined(__ATLTYPES_H__))
|
|
#ifndef __ATLMISC_H__
|
|
|
|
template <class Num>
|
|
inline PixSize operator *(SIZE s, Num n)
|
|
{
|
|
return PixSize((int)(s.cx * n), (int)(s.cy * n));
|
|
};
|
|
|
|
template <class Num>
|
|
inline void operator *=(SIZE & s, Num n)
|
|
{
|
|
s = s * n;
|
|
};
|
|
|
|
template <class Num>
|
|
inline PixSize operator /(SIZE s, Num n)
|
|
{
|
|
return PixSize((int)(s.cx / n), (int)(s.cy / n));
|
|
};
|
|
|
|
template <class Num>
|
|
inline void operator /=(SIZE & s, Num n)
|
|
{
|
|
s = s / n;
|
|
};
|
|
#endif
|
|
#endif
|
|
|
|
PixSize size(const PixRect& plt ,const PixRect& prb) {return PixSize()=PixRect(plt.left,plt.top,prb.right,prb.bottom);}
|
|
|