Introducción al uso de la clase CRect
Xin Chen 2013-10-08 21:15:37 
13216 
Colección 14
Columna de clasificación: Control MFC C ++
[Turn] La clase CRect es una clase común de MFC, muy básica, por lo que los principiantes la clasifican como referencia.
Usé Jinshan Express para verificar la palabra "rect". Probablemente sea la abreviatura de rectángulo, que significa rectángulo o rectángulo.
Sistema de coordenadas predeterminado: el origen es la esquina superior izquierda, la derecha es la dirección positiva del eje xy la parte inferior es la dirección positiva del eje y.
El constructor (CRect) tiene cinco prototipos, el segundo prototipo y el tercer prototipo son constructores de copias. Ahora uso los otros tres constructores para construir un
rectángulo con las coordenadas de la esquina superior izquierda (10,20), la longitud del lado en la dirección x es 100 y el lado en la dirección y es 200 de largo.
Prototipo 1:
CRect r1 (10,20,110,220);
Prototipo 4:
POINT pt = {10,20};
SIZE size = {100,200};
CRect r2 (pt, size);
Prototipo 5:
POINT topLeft = {10,20};
POINT bottomRight = {110,220};
CRect r3 (topLeft, bottomRight);
El siguiente código puede verificar el tamaño de un rectángulo, crear un proyecto de documento único Sdi, modificar la función OnDraw:
void CSdiView :: OnDraw (CDC * pDC)
{ CSdiDoc * pDoc = GetDocument (); ASSERT_VALID (pDoc); CRect r1 (10,20,110,220); pDC-> Rectángulo (& r1);
}
int Width () const;
Obtenga el ancho, int iWidth = r1.Width (); iWidth será 100 en la reunión.
int Height () const;
Obtiene la altura, int iHeight = r1.Height (); el resultado de iHeight es 200.
CSize Size () const;
Obtiene ancho y alto, CSize size = r1.Size (); size.cx es 100, size.cy es 200.
CPoint & TopLeft ();
Obtiene las coordenadas de la esquina superior izquierda. Dado que el valor de retorno es una referencia, puede modificar la esquina superior izquierda a través del valor de retorno de esta función.
CRect r1 (10,20,110,220);
r1.TopLeft (). X = 0;
r1.TopLeft (). Y = 0;
Las coordenadas de la esquina superior izquierda de r1 se convierten en (0,0), y la esquina superior izquierda puede también se puede obtener a través de esta función de coordenadas.
CRect r1 (10,20,110,220);
CPoint TopLeft = r1.TopLeft ();
El valor de TopLeft.x es 10 y el valor de TopLeft.y es 20.
BottomRight obtiene las coordenadas de la esquina inferior derecha
CPoint CenterPoint () const; obtiene las coordenadas del centro, CPoint pt = r1.CenterPoint (); pt es (60,120).
BOOL IsRectEmpty () const; Si el asiento largo o el ancho es 0 o ilegal, devuelve verdadero; de lo contrario, devuelve falso.
CRect r1 (210,20,110,220);
bool bEmpty = r1.IsRectEmpty (); El
resultado es verdadero porque el lado izquierdo es más grande que el lado derecho.
CRect :: IsRectNull, las coordenadas de los cuatro lados son todas 0, el resultado es verdadero, de lo contrario es falso.
BOOL PtInRect (POINT point) const; comprueba si un punto está dentro del rectángulo.
CRect r1 (10,20,110,220);
PUNTO pt1 = {10,10};
PUNTO pt2 = {10,30};
bool bIn1 = r1.PtInRect (pt1);
bool bIn2 = r1.PtInRect (pt2);
bIn1 es falso, bIn2 es cierto.
CRect :: SetRect, establece los valores de los cuatro lados, el uso es similar al prototipo del constructor.
CRect :: SetRectEmpty, establezca las coordenadas de los cuatro lados en 0.
void CopyRect (LPCRECT lpSrcRect); Copiar.
CRect r2;
r2.CopyRect (& r1);
El valor de r2 es el mismo que el valor de r1.
CRect :: EqualRect, si los dos rectángulos son iguales, las coordenadas de los cuatro lados deben ser iguales.
CRect r1 (10,20,110,220);
CRect r2 (110,220,10,20);
bool bEqual = r1.EqualRect (r2);
El valor de bEqual es falso, porque sus lados superior, inferior, izquierdo y derecho son diferentes, lo que es al revés.
CRect r1 (110,220,10,20);
CRect r2 (110,220,10,20);
bool bEqual = r1.EqualRect (r2);
bEqual es verdadero porque los cuatro lados son iguales.
CRect :: InflateRect, aumenta el ancho y el alto.
CRect r (0,0,0,0);
r.InflateRect (2,3); // El resultado es (-2, -3,2,3);
SIZE size = {3,2};
r.InflateRect (tamaño); // El resultado es (-5, -5,5,5);
CRect r1 (-5, -5, -5, -5);
r.InflateRect (& r1); // El resultado es ( 0,0, 0,0);
// Mover a la izquierda en -1 a la izquierda (Mover a la derecha en 1), subir en -1 en el lado superior, mover a la derecha en 2, y bajar en el lado inferior by 2
r.InflateRect (-1, -1,2,2); / / El resultado es (1,1,2,2);
CRect :: DeflateRect, reduce el ancho y la altura, el método es similar a InflateRect.
CRect :: NormalizeRect, estandariza, ajusta la parte superior e inferior y los lados izquierdo y derecho para que esté en línea con la lógica humana.
CRect r (10,10,0,0);
r.NormalizeRect (); El
resultado es (0,0,10,10)
CRect :: OffsetRect, mueve todo el rectángulo.
CRect r (0,0,10,10);
r.OffsetRect (1,1); // Mover 1 a la derecha, 1
PUNTO hacia abajo point = {1,1};
r.OffsetRect (point); // De nuevo a la derecha Mover 1, luego bajar 1
TAMAÑO size = {-2, -2};
r.OffsetRect (tamaño); // Mover a la derecha -2, mover hacia abajo -2
CRect :: SubtractRect, lpRectSrc1 menos lpRectSrc2, tenga en cuenta que no es un signo menos. El proceso no es fácil de expresar, puede ver el efecto ejecutando el siguiente código.
void CSdiView :: OnDraw (CDC * pDC)
{ pDC-> SelectStockObject (NULL_BRUSH); CRect r1 (10,10, 100,100); CRect r2 (50,10, 150,150); // y CRect r2 (50,50, 150,150 ); Los resultados son diferentes pDC-> Rectangle (r1); pDC-> Rectangle (r2); {// El área roja es el resultado de SubtractRect CRect r;
r.SubtractRect (r1, r2);
CBrush brush (RGB (255,0,0));
pDC-> SelectObject (& brush);
pDC-> Rectangle (& r);
}
}
CRect :: IntersectRect, encuentra el
vacío de intersección CSdiView :: OnDraw (CDC * pDC)
{ pDC-> SelectStockObject (NULL_BRUSH); CRect r1 (10,10, 100,100); CRect r2 (50,10, 150,150); // y CRect r2 (50,50, 150,150); result No es el mismo pDC-> Rectangle (r1); pDC-> Rectangle (r2); {// El área verde es el resultado de IntersectRect CRect r; r.IntersectRect (r1, r2); CBrush brush (RGB (0,255, 0)); pDC-> SelectObject (& brush); pDC-> Rectangle (& r); } } CRect :: UnionRect, encuentra la unión
void CSdiView :: OnDraw (CDC * pDC)
{ pDC-> SelectStockObject (NULL_BRUSH); CRect r1 (10,10, 100,100); CRect r2 (50,50, 150,150); // y CRect r2 (50,50, 150,150 ); Los resultados son diferentes pDC-> Rectangle (r1); pDC-> Rectangle (r2); {// El borde azul es el resultado de UnionRect CRect r; r.UnionRect (r1, r2); CPen pen (PS_DOT, 1, RGB (0,0,255)); pDC-> SelectObject (& pen); pDC-> Rectangle (& r); } } CRect :: operador LPCRECT, convertido a tipo LPCRECT. CRect :: operador LPRECT se transforma en LPRECT CRect r (0,0,100,100); LPCRECT pCRect = r; LPRECT pRect = r; La segunda línea llamará al operador LPCRECT y la tercera línea llamará al operador LPRECT.
typedef const RECT * LPCRECT; // puntero a lectura / solo
RECT typedef struct tagRECT
{ LONG left; LONG top; LONG right; LONG bottom; } RECT, * PRECT, NEAR * NPRECT, FAR * LPRECT; CRect :: operator =, Sobrecargue el operador "=" para llamar realmente a CopyRect. CRect :: operator ==, sobrecargue el operador "==" y, de hecho, llame a EqualRect. operator! =, sobrecarga el operador "! =" y, de hecho, llama a EqualRect. CRect :: operator + =, sobrecargando el operador "+ =", el primer prototipo y el segundo prototipo llaman a OffsetRect, y el tercer prototipo llama a InflateRect. CRect :: operator - =, sobrecarga el operador "- =", el primer prototipo y el segundo prototipo llaman a OffsetRect, y el tercer prototipo llama a InflateRect. CRect :: operator & =, overload "& =" operator, en realidad llama a IntersectRect. CRect :: operator | = Sobrecarga el operador "| =" y en realidad llama a UnionRect. +, -, &, | son similares a los anteriores, por lo que no los explicaré en detalle.