System.Types.TRect
Delphi
TRect = record
C++
struct TRect: public RECT {
TRect() _ALWAYS_INLINE
{ init(0,0,0,0); }
TRect(const TPoint& TL) _ALWAYS_INLINE {
init(TL.x, TL.y, TL.x, TL.y);
}
TRect(const TPoint& TL, int width, int height) _ALWAYS_INLINE {
init (TL.x, TL.y, TL.x + width, TL.y + height);
}
TRect(int l, int t, int r, int b) _ALWAYS_INLINE {
init(l, t, r, b);
}
TRect(const TPoint& TL, const TPoint& BR) _ALWAYS_INLINE {
init(TL.x, TL.y, BR.x, BR.y);
Normalize();
}
TRect(const RECT& r) _ALWAYS_INLINE {
init(r.left, r.top, r.right, r.bottom);
}
void init(int l, int t, int r, int b) _ALWAYS_INLINE {
left = l; top = t;
right = r; bottom = b;
}
TPoint& TopLeft() _ALWAYS_INLINE
{ return *((TPoint* )this); }
TPoint& BottomRight() _ALWAYS_INLINE
{ return *((TPoint* )this+1); }
const TPoint& TopLeft() const _ALWAYS_INLINE
{ return *((TPoint* )this); }
const TPoint& BottomRight() const _ALWAYS_INLINE
{ return *((TPoint* )this+1); }
int Width() const _ALWAYS_INLINE
{ return right - left; }
int Height() const _ALWAYS_INLINE
{ return bottom - top ; }
static TRect Empty() _ALWAYS_INLINE
{ return TRect(); }
void Normalize() _ALWAYS_INLINE {
if (top > bottom) {
top = top ^ bottom;
bottom = top ^ bottom;
top = top ^ bottom;
}
if (left > right) {
left = left ^ right;
right = left ^ right;
left = left ^ right;
}
}
bool operator ==(const TRect& rc) const {
return left == rc.left && top==rc.top &&
right == rc.right && bottom==rc.bottom;
}
bool operator !=(const TRect& rc) const {
return !(rc==*this);
}
TRect operator+(const TRect& rc) const _ALWAYS_INLINE {
return TRect::Union(*this, rc);
}
TRect operator*(const TRect& rc) const _ALWAYS_INLINE {
return TRect::Intersect(*this, rc);
}
TRect& operator+=(const TRect& rhs) _ALWAYS_INLINE {
Union(rhs);
return *this;
}
TRect& operator*=(const TRect& rhs) _ALWAYS_INLINE {
Intersect(rhs);
return *this;
}
bool IsEmpty() const _ALWAYS_INLINE {
return (right == left) || (bottom == top);
}
bool Contains(const TPoint& p) const _ALWAYS_INLINE {
return ((p.x >= left) && (p.y >= top) && (p.x < right) && (p.y < bottom));
}
bool PtInRect(const TPoint& p) const _ALWAYS_INLINE {
return Contains(p);
}
bool Contains(const TRect& r) const _ALWAYS_INLINE {
return Contains(r.TopLeft()) && Contains(r.BottomRight());
}
bool Overlaps(const TRect &r) const _ALWAYS_INLINE {
return IntersectsWith(r);
}
bool Intersects(const TRect &r) const _ALWAYS_INLINE {
return IntersectsWith(r);
}
bool IntersectsWith(const TRect &r) const _ALWAYS_INLINE {
return !( (BottomRight().x < r.TopLeft().x) ||
(BottomRight().y < r.TopLeft().y) ||
(r.BottomRight().x < TopLeft().x) ||
(r.BottomRight().y < TopLeft().y) );
}
static TRect Intersect(const TRect &r1, const TRect &r2);
void Intersect(const TRect &r);
void Union(const TRect &r);
static TRect Union(const TRect &r1, const TRect& r2);
static TRect Union(const TPoint* points, int npoints) _ALWAYS_INLINE {
TPoint tl, br;
if (npoints > 0) {
tl.SetLocation(points[0]);
br.SetLocation(points[0]);
for (int i = npoints; --i > 0;) {
if (points[i].x < tl.x) tl.x = points[i].x;
if (points[i].x > br.x) br.x = points[i].x;
if (points[i].y < tl.y) tl.y = points[i].y;
if (points[i].y > br.y) br.y = points[i].y;
}
}
return TRect(tl, br);
}
bool IntersectRect(const TRect &R1, const TRect &R2);
bool UnionRect(const TRect &R1, const TRect &R2);
void Offset(int DX, int DY) _ALWAYS_INLINE {
left += DX;
right += DX;
top += DY;
bottom += DY;
}
void Offset(const TPoint& p) _ALWAYS_INLINE { Offset(p.x, p.y); }
void SetLocation(int X, int Y) _ALWAYS_INLINE {
Offset(X - left, Y - top);
}
void SetLocation(const TPoint& p) _ALWAYS_INLINE {
Offset(p.x - left, p.y - top);
}
void Inflate(int DX, int DY) _ALWAYS_INLINE {
left -= DX;
right += DX;
top -= DY;
bottom += DY;
}
void Inflate(int l, int t, int r, int b) _ALWAYS_INLINE {
left -= l;
right += r;
top -= t;
bottom += b;
}
void NormalizeRect() _ALWAYS_INLINE {
int i;
if (left > right)
{
i = left;
left = right;
right = i;
}
if (top > bottom)
{
i = top;
top = bottom;
bottom = i;
}
}
TPoint CenterPoint() const _ALWAYS_INLINE {
return TPoint((left+right)/2, (top+bottom)/2);
}
TRect CenteredRect(const TRect &CenteredRect) const _ALWAYS_INLINE {
int w = CenteredRect.Width();
int h = CenteredRect.Height();
int x = (right + left)/2;
int y = (top + bottom)/2;
return TRect(x-w/2, y-h/2, x+(w+1)/2, y+(h+1)/2);
}
TRect SplitRect(TSplitRectType SplitType, int Size) const;
TRect SplitRect(TSplitRectType SplitType, double Percent) const;
#if defined(_WIN32)
bool SubtractRect(const TRect &R1, const TRect &R2) _ALWAYS_INLINE {
return ::SubtractRect(this, &R1, &R2) != 0;
}
#endif
LONG GetWidth() const _ALWAYS_INLINE {
return right - left;
}
void SetWidth(LONG width) _ALWAYS_INLINE {
right = left + width;
}
LONG GetHeight() const _ALWAYS_INLINE {
return bottom - top;
}
void SetHeight(LONG height) _ALWAYS_INLINE {
bottom = top + height;
}
TSize GetSize() const _ALWAYS_INLINE {
TSize r;
r.cx = GetWidth();
r.cy = GetHeight();
return r;
}
void SetSize(const TSize& newSize) _ALWAYS_INLINE {
SetWidth(newSize.cx);
SetHeight(newSize.cy);
}
TPoint GetLocation() const _ALWAYS_INLINE {
return TPoint(left, top);
}
__property LONG Left = { read=left, write=left };
__property LONG Top = { read=top, write=top };
__property LONG Right = { read=right, write=right };
__property LONG Bottom = { read=bottom, write=bottom };
__property TSize Size = { read=GetSize, write=SetSize };
__property TPoint Location = { read=GetLocation, write=SetLocation };
};
Propriétés
| Type | Visibilité | Source | Unité | Parent |
|---|---|---|---|---|
record struct |
public | System.Types.pas SystemTypes.h |
System.Types | System.Types |
Description
TRect définit un rectangle.
TRect représente les dimensions d'un rectangle. Les coordonnées sont spécifiées soit sous la forme de quatre entiers distincts représentant les bords gauche, supérieur, droit et inférieur du rectangle, soit sous la forme de deux points représentant les emplacements des coins supérieur gauche et inférieur droit.
Typiquement, les valeurs TRect représentent des emplacements en pixels, où l'origine du système de coordonnées en pixels correspond au coin supérieur gauche de l'écran (en coordonnées écran) ou au coin supérieur gauche de la zone client d'un contrôle (en coordonnées client). Quand une valeur TRect représente un rectangle sur l'écran, par convention les bords supérieur et gauche sont considérés comme étant à l'intérieur du rectangle et les bords inférieur et droit à l'extérieur du rectangle. Cette convention permet à la largeur du rectangle d'être considérée Droite - Gauche et la hauteur d'être considérée Inférieur - Supérieur.