Clase CRect
Similar a una estructura RECT
de Windows.
Sintaxis
class CRect : public tagRECT
Miembros
Constructores públicos
Nombre | Descripción |
---|---|
CRect::CRect |
Construye un objeto CRect . |
Métodos públicos
Nombre | Descripción |
---|---|
CRect::BottomRight |
Devuelve el punto inferior derecho de CRect . |
CRect::CenterPoint |
Devuelve el punto central de CRect . |
CRect::CopyRect |
Copia las dimensiones de un rectángulo de origen en CRect . |
CRect::DeflateRect |
Disminuye el ancho y el alto de CRect . |
CRect::EqualRect |
Determina si CRect es igual al rectángulo especificado. |
CRect::Height |
Calcula el alto de CRect . |
CRect::InflateRect |
Aumenta el ancho y el alto de CRect . |
CRect::IntersectRect |
Establece CRect igual a la intersección de dos rectángulos. |
CRect::IsRectEmpty |
Determina si CRect está vacío. CRect está vacío si el ancho o alto son 0. |
CRect::IsRectNull |
Determina si las variables miembro top , bottom , left y right son iguales a 0. |
CRect::MoveToX |
Mueve CRect a la coordenada x especificada. |
CRect::MoveToXY |
Mueve CRect a las coordenadas x e y especificadas. |
CRect::MoveToY |
Mueve CRect a la coordenada y especificada. |
CRect::NormalizeRect |
Estandariza el alto y el ancho de CRect . |
CRect::OffsetRect |
Mueve CRect según los desplazamientos especificados. |
CRect::PtInRect |
Determina si el punto especificado se encuentra dentro de CRect . |
CRect::SetRect |
Establece las dimensiones de CRect . |
CRect::SetRectEmpty |
Establece CRect en un rectángulo vacío (todas las coordenadas iguales a 0). |
CRect::Size |
Calcula el tamaño de CRect . |
CRect::SubtractRect |
Resta un rectángulo de otro. |
CRect::TopLeft |
Devuelve el punto superior izquierdo de CRect . |
CRect::UnionRect |
Establece CRect igual a la unión de dos rectángulos. |
CRect::Width |
Calcula el ancho de CRect . |
Operadores públicos
Nombre | Descripción |
---|---|
CRect::operator - |
Resta los desplazamientos especificados de CRect o desinfla CRect y devuelve el objeto CRect resultante. |
CRect::operator LPCRECT |
Convierte CRect en LPCRECT . |
CRect::operator LPRECT |
Convierte CRect en LPRECT . |
CRect::operator != |
Determina si CRect no es igual a un rectángulo. |
CRect::operator & |
Crea la intersección de CRect y un rectángulo y devuelve el objetoCRect resultante. |
CRect::operator &= |
Establece CRect igual a la intersección de CRect y un rectángulo. |
CRect::operator | |
Crea la unión de CRect y un rectángulo y devuelve el objeto CRect resultante. |
CRect::operator |= |
Establece CRect igual a la unión de CRect y un rectángulo. |
CRect::operator + |
Agrega los desplazamientos especificados a CRect o infla CRect y devuelve el objeto CRect resultante. |
CRect::operator += |
Agrega los desplazamientos especificados a CRect o se infla CRect . |
CRect::operator = |
Copia las dimensiones de un rectángulo en CRect . |
CRect::operator -= |
Resta los desplazamientos especificados de CRect o se desinfla CRect . |
CRect::operator == |
Determina si CRect es igual a un rectángulo. |
Comentarios
CRect
también incluye funciones miembro para manipular objetos CRect
y estructuras RECT
de Windows.
Un objeto CRect
se puede pasar como un parámetro de función siempre que se pueda pasar una estructura RECT
, LPCRECT
o LPRECT
.
Nota:
Esta clase se deriva de la estructura tagRECT
. (El nombre tagRECT
es un nombre que se usa con menos frecuencia para la estructuraRECT
). Esto significa que los miembros de datos (left
, top
, right
y bottom
) de la estructura RECT
son miembros de datos accesibles de CRect
.
CRect
contiene variables miembro que definen los puntos superior izquierdo e inferior derecho de un rectángulo.
Al especificar CRect
, debe tener cuidado de construirlo de forma que se normalice, es decir, de modo que el valor de la coordenada izquierda sea menor que el de la derecha y la parte superior sea menor que la inferior. Por ejemplo, una parte superior izquierda de (10,10) y la parte inferior derecha de (20,20) define un rectángulo normalizado, pero una parte superior izquierda de (20,20) y la parte inferior derecha de (10,10) define un rectángulo no normalizado. Si el rectángulo no está normalizado, muchas funciones miembro CRect
pueden devolver resultados incorrectos. (Consulte CRect::NormalizeRect
para obtener una lista de estas funciones). Antes de llamar a una función que requiere rectángulos normalizados, puede normalizar los rectángulos no normalizados llamando a la función NormalizeRect
.
Tenga cuidado al manipular CRect
con las funciones miembro CDC::DPtoLP
y CDC::LPtoDP
. Si el modo de asignación de un contexto de presentación es tal que la extensión y es negativa, como en MM_LOENGLISH
, CDC::DPtoLP
transformará CRect
para que su parte superior sea mayor que la parte inferior. Las funciones como Height
y Size
devolverán valores negativos para el alto del objeto CRect
transformado y el rectángulo no se normalizará.
Cuando se usan operadores CRect
sobrecargados, el primer operando debe ser CRect
; el segundo puede ser una estructura RECT
o un objeto CRect
.
Jerarquía de herencia
tagRECT
CRect
Requisitos
Encabezado: atltypes.h
CRect::BottomRight
Las coordenadas se devuelven como referencia a un objeto CPoint
que se encuentra en CRect
.
CPoint& BottomRight() throw();
const CPoint& BottomRight() const throw();
Valor devuelto
Coordenadas de la esquina inferior derecha del rectángulo.
Comentarios
Puede usar esta función para obtener o establecer la esquina inferior derecha del rectángulo. Establezca la esquina mediante esta función en el lado izquierdo del operador de asignación.
Ejemplo
// use BottomRight() to retrieve the bottom
// right POINT
CRect rect(210, 150, 350, 900);
CPoint ptDown;
ptDown = rect.BottomRight();
// ptDown is now set to (350, 900)
ASSERT(ptDown == CPoint(350, 900));
// or, use BottomRight() to set the bottom
// right POINT
CRect rect2(10, 10, 350, 350);
CPoint ptLow(180, 180);
CRect rect2(10, 10, 350, 350);
CPoint ptLow(180, 180);
rect2.BottomRight() = ptLow;
// rect2 is now (10, 10, 180, 180)
ASSERT(rect2 == CRect(10, 10, 180, 180));
CRect::CenterPoint
Calcula el punto central de CRect
sumando los valores izquierdo y derecho y dividiendo entre dos, y haciendo lo mismo para los valores superior e inferior.
CPoint CenterPoint() const throw();
Valor devuelto
Un objeto CPoint
que es el punto central de CRect
.
Ejemplo
// Code from this OnPaint() implementation can be pasted into your own application
// to draw lines that would look like a letter "Y" within your dialog.
void CMyDlg::OnPaint()
{
CPaintDC dc(this);
// device context for painting
// get the size and position of the client area of
// your window
CRect rect;
GetClientRect(&rect);
// Move the current pen to the top left of the window. We call the
// TopLeft() member of CRect here and it returns a CPoint object we
// pass to the override of CDC::MoveTo() that accepts a CPoint.
dc.MoveTo(rect.TopLeft());
// Draw a line from the top left to the center of the window.
// CenterPoint() gives us the middle point of the window as a
// CPoint, and since CDC::LineTo() has an override that accepts a
// CPoint, we can just pass it along.
dc.LineTo(rect.CenterPoint());
// Now, draw a line to the top right of the window. There's no
// CRect member which returns a CPoint for the top right of the
// window, so we'll reference the CPoint members directly and call
// the CDC::LineTo() override which takes two integers.
dc.LineTo(rect.right, rect.top);
// The top part of the "Y" is drawn. Now, we'll draw the stem. We
// start from the center point.
dc.MoveTo(rect.CenterPoint());
// and then draw to the middle of the bottom edge of the window.
// We'll get the x-coordinate from the x member of the CPOINT
// returned by CenterPoint(), and the y value comes directly from
// the rect.
dc.LineTo(rect.CenterPoint().x, rect.bottom);
}
CRect::CopyRect
Copia el rectángulo lpSrcRect
en CRect
.
void CopyRect(LPCRECT lpSrcRect) throw();
Parámetros
lpSrcRect
Apunta a la estructura RECT
o al objeto CRect
que se va a copiar.
Ejemplo
CRect rectSource(35, 10, 125, 10);
CRect rectDest;
rectDest.CopyRect(&rectSource);
// rectDest is now set to (35, 10, 125, 10)
RECT rectSource2;
rectSource2.left = 0;
rectSource2.top = 0;
rectSource2.bottom = 480;
rectSource2.right = 640;
rectDest.CopyRect(&rectSource2);
// works against RECT structures, too!
// rectDest is now set to (0, 0, 640, 480)
CRect::CRect
Construye un objeto CRect
.
CRect() throw();
CRect(int l, int t, int r, int b) throw();
CRect(const RECT& srcRect) throw();
CRect(LPCRECT lpSrcRect) throw();
CRect(POINT point, SIZE size) throw();
CRect(POINT topLeft, POINT bottomRight) throw();
Parámetros
l
Especifica la posición izquierda de CRect
.
t
Especifica la parte superior de CRect
.
r
Especifica la posición derecha de CRect
.
b
Especifica la parte inferior de CRect
.
srcRect
Hace referencia a la estructura RECT
con las coordenadas para CRect
.
lpSrcRect
Apunta a la estructura RECT
con las coordenadas para CRect
.
point
Especifica el punto de origen del rectángulo que se va a construir. Corresponde a la esquina superior izquierda.
size
Especifica el desplazamiento desde la esquina superior izquierda hasta la esquina inferior derecha del rectángulo que se va a construir.
topLeft
Especifica la posición superior izquierda de CRect
.
bottomRight
Especifica la posición inferior derecha de CRect
.
Comentarios
Si no se proporcionan argumentos, los miembros left
, top
, right
y bottom
se establecen en 0.
Los constructores CRect
(const RECT&
) y CRect
(LPCRECT
) realizan CopyRect
. Los demás constructores inicializan las variables miembro del objeto directamente.
Ejemplo
// default constructor is equivalent to CRect(0, 0, 0, 0)
CRect emptyRect;
// four-integers are left, top, right, and bottom
CRect rect(0, 0, 100, 50);
ASSERT(rect.Width() == 100);
ASSERT(rect.Height() == 50);
// Initialize from RECT structure
RECT sdkRect;
sdkRect.left = 0;
sdkRect.top = 0;
sdkRect.right = 100;
sdkRect.bottom = 50;
CRect rect2(sdkRect);
// by reference
CRect rect3(&sdkRect);
// by address
ASSERT(rect2 == rect);
ASSERT(rect3 == rect);
// from a point and a size
CPoint pt(0, 0);
CSize sz(100, 50);
CRect rect4(pt, sz);
ASSERT(rect4 == rect2);
// from two points
CPoint ptBottomRight(100, 50);
CRect rect5(pt, ptBottomRight);
ASSERT(rect5 == rect4);
CRect::DeflateRect
DeflateRect
desinfla CRect
al mover los lados hacia su centro.
void DeflateRect(int x, int y) throw();
void DeflateRect(SIZE size) throw();
void DeflateRect(LPCRECT lpRect) throw();
void DeflateRect(int l, int t, int r, int b) throw();
Parámetros
x
Especifica el número de unidades que se desinflan en los lados izquierdo y derecho de CRect
.
y
Especifica el número de unidades que se desinflan en la parte superior e inferior de CRect
.
size
Un valor SIZE
o CSize
que especifica el número de unidades que se desinflan en CRect
. El valor cx
especifica el número de unidades que se desinflan en los lados izquierdo y derecho, y el valor cy
especifica el número de unidades que se desinflan en las partes superior e inferior.
lpRect
Apunta a una estructura RECT
o CRect
que especifica el número de unidades que se desinflan en cada lado.
l
Especifica el número de unidades que se desinflan en el lado izquierdo de CRect
.
t
Especifica el número de unidades que se desinflan en la parte superior de CRect
.
r
Especifica el número de unidades que se desinflan en el lado derecho de CRect
.
b
Especifica el número de unidades que se desinflan en la parte inferior de CRect
.
Comentarios
Para ello, DeflateRect
agrega unidades a la izquierda y a la parte superior, y resta unidades de la derecha y de la parte inferior. Los parámetros de DeflateRect
son valores con firma; los valores positivos desinflan CRect
y los valores negativos lo inflan.
Las dos primeras sobrecargas desinflan ambos pares de lados opuestos de CRect
de modo que su ancho total se reduce dos veces x
(o cx
) y su altura total se reduce dos veces y
(o cy
). Las otras dos sobrecargas desinflan cada lado de CRect
independientemente de las demás.
Ejemplo
CRect rect(10, 10, 50, 50);
rect.DeflateRect(1, 2);
ASSERT(rect.left == 11 && rect.right == 49);
ASSERT(rect.top == 12 && rect.bottom == 48);
CRect rect2(10, 10, 50, 50);
CRect rectDeflate(1, 2, 3, 4);
rect2.DeflateRect(&rectDeflate);
ASSERT(rect2.left == 11 && rect2.right == 47);
ASSERT(rect2.top == 12 && rect2.bottom == 46);
CRect::EqualRect
Determina si CRect
es igual al rectángulo especificado.
BOOL EqualRect(LPCRECT lpRect) const throw();
Parámetros
lpRect
Apunta a una estructura RECT
o un objeto CRect
que contiene las coordenadas de esquina superior izquierda e inferior derecha de un rectángulo.
Valor devuelto
Distinto de cero si los dos rectángulos tienen los mismos valores superior, izquierdo, inferior y derecho; de lo contrario, 0.
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1.EqualRect(rect2));
ASSERT(!rect1.EqualRect(rect3));
// works just fine against RECTs, as well
RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;
ASSERT(rect1.EqualRect(&test));
CRect::Height
Calcula el alto de CRect
restando el valor superior del valor inferior.
int Height() const throw();
Valor devuelto
Alto de CRect
.
Comentarios
El valor resultante puede ser negativo.
Nota:
El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar el rectángulo antes de llamar a esta función.
Ejemplo
CRect rect(20, 30, 80, 70);
int nHt = rect.Height();
// nHt is now 40
ASSERT(nHt == 40);
CRect::InflateRect
InflateRect
infla CRect
al mover los lados fuera de su centro.
void InflateRect(int x, int y) throw();
void InflateRect(SIZE size) throw();
void InflateRect(LPCRECT lpRect) throw();
void InflateRect(int l, int t, int r, int b) throw();
Parámetros
x
Especifica el número de unidades que se inflan en los lados izquierdo y derecho de CRect
.
y
Especifica el número de unidades que se inflan en la parte superior e inferior de CRect
.
size
Un valor SIZE
o CSize
que especifica el número de unidades que se inflan en CRect
. El valor cx
especifica el número de unidades que se inflan en los lados izquierdo y derecho y el valor cy
especifica el número de unidades que se inflan en las partes superior e inferior.
lpRect
Apunta a una estructura RECT
o CRect
que especifica el número de unidades que se inflan cada lado.
l
Especifica el número de unidades que se inflan en el lado izquierdo de CRect
.
t
Especifica el número de unidades que se inflan en la parte superior de CRect
.
r
Especifica el número de unidades que se inflan en el lado derecho de CRect
.
b
Especifica el número de unidades que se inflan en la parte inferior de CRect
.
Comentarios
Para ello, InflateRect
resta unidades de la izquierda y de la parte superior y agrega unidades a la derecha y a la parte inferior. Los parámetros de InflateRect
son valores con firma; los valores positivos inflan CRect
y los valores negativos lo desinflan.
Las dos primeras sobrecargas inflan ambos pares de lados opuestos de CRect
para que su ancho total se incremente dos veces x
(o cx
) y su altura total se incremente dos veces y
(o cy
). Las otras dos sobrecargas inflan cada lado de CRect
independientemente de las demás.
Ejemplo
CRect rect(0, 0, 300, 300);
rect.InflateRect(50, 200);
// rect is now (-50, -200, 350, 500)
ASSERT(rect == CRect(-50, -200, 350, 500));
CRect::IntersectRect
Hace que CRect
sea igual a la intersección de dos rectángulos existentes.
BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();
Parámetros
lpRect1
Apunta a una estructura RECT
o un objeto CRect
que contiene un rectángulo de origen.
lpRect2
Apunta a una estructura RECT
o un objeto CRect
que contiene un rectángulo de origen.
Valor devuelto
Distinto de cero si la intersección no está vacía; 0 si la intersección está vacía.
Comentarios
La intersección es el rectángulo más grande contenido en los dos rectángulos existentes.
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
CRect rectOne(125, 0, 150, 200);
CRect rectTwo(0, 75, 350, 95);
CRect rectInter;
rectInter.IntersectRect(rectOne, rectTwo);
ASSERT(rectInter == CRect(125, 75, 150, 95));
// operator &= can do the same task:
CRect rectInter2 = rectOne;
rectInter2 &= rectTwo;
ASSERT(rectInter2 == CRect(125, 75, 150, 95));
CRect::IsRectEmpty
Determina si CRect
está vacío.
BOOL IsRectEmpty() const throw();
Valor devuelto
Distinto de cero si CRect
está vacío; 0 si CRect
no está vacío.
Comentarios
Un rectángulo está vacío si el ancho o alto son 0 o negativos. Difiere de IsRectNull
, que determina si todas las coordenadas del rectángulo son cero.
Nota:
El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar el rectángulo antes de llamar a esta función.
Ejemplo
CRect rectNone(0, 0, 0, 0);
CRect rectSome(35, 50, 135, 150);
ASSERT(rectNone.IsRectEmpty());
ASSERT(!rectSome.IsRectEmpty());
CRect rectEmpty(35, 35, 35, 35);
ASSERT(rectEmpty.IsRectEmpty());
CRect::IsRectNull
Determina si los valores superior, izquierdo, inferior y derecho de CRect
son iguales a 0.
BOOL IsRectNull() const throw();
Valor devuelto
Distinto de cero si los valores superior, izquierdo, inferior y derecho de CRect
son iguales a 0; de lo contrario, 0.
Comentarios
Difiere de IsRectEmpty
, que determina si el rectángulo está vacío.
Ejemplo
CRect rectNone(0, 0, 0, 0);
CRect rectSome(35, 50, 135, 150);
ASSERT(rectNone.IsRectNull());
ASSERT(!rectSome.IsRectNull());
// note that null means _all_ zeros
CRect rectNotNull(0, 0, 35, 50);
ASSERT(!rectNotNull.IsRectNull());
CRect::MoveToX
Llame a esta función para mover el rectángulo a la coordenada x absoluta especificada por x
.
void MoveToX(int x) throw();
Parámetros
x
Coordenada x absoluta para la esquina superior izquierda del rectángulo.
Ejemplo
CRect rect(0, 0, 100, 100);
rect.MoveToX(10);
// rect is now (10, 0, 110, 100);
ASSERT(rect == CRect(10, 0, 110, 100));
CRect::MoveToXY
Llame a esta función para mover el rectángulo a las coordenadas x e y absolutas especificadas.
void MoveToXY(int x, int y) throw();
void MoveToXY(POINT point) throw();
Parámetros
x
Coordenada x absoluta para la esquina superior izquierda del rectángulo.
y
Coordenada y absoluta para la esquina superior izquierda del rectángulo.
point
Una estructura POINT
que especifica la esquina superior izquierda absoluta del rectángulo.
Ejemplo
CRect rect(0, 0, 100, 100);
rect.MoveToXY(10, 10);
// rect is now (10, 10, 110, 110);
ASSERT(rect == CRect(10, 10, 110, 110));
CRect::MoveToY
Llame a esta función para mover el rectángulo a la coordenada y absoluta especificada por y
.
void MoveToY(int y) throw();
Parámetros
y
Coordenada y absoluta para la esquina superior izquierda del rectángulo.
Ejemplo
CRect rect(0, 0, 100, 100);
rect.MoveToY(10);
// rect is now (0, 10, 100, 110);
ASSERT(rect == CRect(0, 10, 100, 110));
CRect::NormalizeRect
Normaliza CRect
para que tanto el alto como el ancho sean positivos.
void NormalizeRect() throw();
Comentarios
El rectángulo se normaliza para el posicionamiento del cuarto cuadrante, que Windows suele usar para las coordenadas. NormalizeRect
compara los valores superior e inferior y los intercambia si la parte superior es mayor que la parte inferior. De forma similar, intercambia los valores izquierdo y derecho si la izquierda es mayor que la derecha. Esta función es útil cuando se trabaja con diferentes modos de asignación y rectángulos invertidos.
Nota:
Las siguientes funciones miembro CRect
requieren rectángulos normalizados para funcionar de forma correcta: Height
, Width
, Size
, IsRectEmpty
, PtInRect
, EqualRect
, UnionRect
, IntersectRect
, SubtractRect
, operator ==
, operator !=
, operator |
, operator |=
, operator &
y operator &=
.
Ejemplo
CRect rect1(110, 100, 250, 310);
CRect rect2(250, 310, 110, 100);
rect1.NormalizeRect();
rect2.NormalizeRect();
ASSERT(rect1 == rect2);
CRect::OffsetRect
Mueve CRect
según los desplazamientos especificados.
void OffsetRect(int x, int y) throw();
void OffsetRect(POINT point) throw();
void OffsetRect(SIZE size) throw();
Parámetros
x
Especifica cuánto se moverá a la izquierda o a la derecha. Debe ser negativo moverse a la izquierda.
y
Especifica cuánto se moverá hacia arriba o hacia abajo. Debe ser negativo para moverse hacia arriba.
point
Contiene una estructura POINT
o un objeto CPoint
que especifica las dos dimensiones por las que se va a mover.
size
Contiene una estructura SIZE
o un objeto CSize
que especifica las dos dimensiones por las que se va a mover.
Comentarios
Mueve unidades CRect
x
a lo largo del eje X y unidades y
a lo largo del eje Y. Los parámetros x
y y
son valores con firma, por lo CRect
se puede mover a la izquierda o a la derecha y hacia arriba o hacia abajo.
Ejemplo
CRect rect(0, 0, 35, 35);
rect.OffsetRect(230, 230);
// rect is now (230, 230, 265, 265)
ASSERT(rect == CRect(230, 230, 265, 265));
CRect::operator LPCRECT
convierte CRect
en LPCRECT
.
operator LPCRECT() const throw();
Comentarios
Cuando se usa esta función, no se necesita el operador address-of (&
). Este operador se usará de forma automática al pasar un objeto CRect
a una función que espera LPCRECT
.
CRect::operator LPRECT
Convierte CRect
en LPRECT
.
operator LPRECT() throw();
Comentarios
Cuando se usa esta función, no se necesita el operador address-of (&
). Este operador se usará de forma automática al pasar un objeto CRect
a una función que espera LPRECT
.
Ejemplo
Vea el ejemplo de CRect::operator LPCRECT
.
CRect::operator =
Asigna srcRect
a CRect
.
void operator=(const RECT& srcRect) throw();
Parámetros
srcRect
Hace referencia a un rectángulo de origen. Puede ser RECT
o CRect
.
Ejemplo
CRect rect(0, 0, 127, 168);
CRect rect2;
rect2 = rect;
ASSERT(rect2 == CRect(0, 0, 127, 168));
CRect::operator ==
Determina si rect
es igual a CRect
comparando las coordenadas de sus esquinas superior izquierda e inferior derecha.
BOOL operator==(const RECT& rect) const throw();
Parámetros
rect
Hace referencia a un rectángulo de origen. Puede ser RECT
o CRect
.
Valor devuelto
Distinto de cero si es igual; de lo contrario, 0.
Comentarios
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1 == rect2);
// works just fine against RECTs, as well
RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;
ASSERT(rect1 == test);
CRect::operator !=
Determina si rect
no es igual a CRect
comparando las coordenadas de sus esquinas superior izquierda e inferior derecha.
BOOL operator!=(const RECT& rect) const throw();
Parámetros
rect
Hace referencia a un rectángulo de origen. Puede ser RECT
o CRect
.
Valor devuelto
Distinto de cero si no es igual; de lo contrario, 0.
Comentarios
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
CRect rect1(35, 150, 10, 25);
CRect rect2(35, 150, 10, 25);
CRect rect3(98, 999, 6, 3);
ASSERT(rect1 != rect3);
// works just fine against RECTs, as well
RECT test;
test.left = 35;
test.top = 150;
test.right = 10;
test.bottom = 25;
ASSERT(rect3 != test);
CRect::operator +=
Las dos primeras sobrecargas mueven CRect
mediante los desplazamientos especificados.
void operator+=(POINT point) throw();
void operator+=(SIZE size) throw();
void operator+=(LPCRECT lpRect) throw();
Parámetros
point
Una estructura POINT
o un objeto CPoint
que especifica el número de unidades que se va a mover el rectángulo.
size
Una estructura SIZE
o un objeto CSize
que especifica el número de unidades que se va a mover el rectángulo.
lpRect
Apunta a una estructura RECT
o un objeto CRect
que contiene el número de unidades que se inflan en cada lado de CRect
.
Comentarios
Los valores x
y y
del parámetro (o cx
y cy
) se agregan a CRect
.
La tercera sobrecarga infla CRect
mediante el número de unidades especificadas en cada miembro del parámetro.
Ejemplo
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect rect2(135, 300, 235, 400);
rect1 += pt;
ASSERT(rect1 == rect2);
CRect::operator -=
Las dos primeras sobrecargas mueven CRect
mediante los desplazamientos especificados.
void operator-=(POINT point) throw();
void operator-=(SIZE size) throw();
void operator-=(LPCRECT lpRect) throw();
Parámetros
point
Una estructura POINT
o un objeto CPoint
que especifica el número de unidades que se va a mover el rectángulo.
size
Una estructura SIZE
o un objeto CSize
que especifica el número de unidades que se va a mover el rectángulo.
lpRect
Apunta a una estructura RECT
o un objeto CRect
que contiene el número de unidades que se desinfla cada lado de CRect
.
Comentarios
Los valores x
y y
del parámetro (o cx
y cy
) se restan de CRect
.
La tercera sobrecarga desinfla CRect
mediante el número de unidades especificadas en cada miembro del parámetro. Tenga en cuenta que esta sobrecarga funciona como DeflateRect
.
Ejemplo
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
rect1 -= pt;
CRect rectResult(65, 170, 165, 270);
ASSERT(rect1 == rectResult);
CRect::operator &=
Establece CRect
igual a la intersección de CRect
y rect
.
void operator&=(const RECT& rect) throw();
Parámetros
rect
Contiene RECT
o CRect
.
Comentarios
La intersección es el rectángulo más grande que se encuentra en ambos rectángulos.
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
Vea el ejemplo de CRect::IntersectRect
.
CRect::operator |=
Establece CRect
igual a la unión de CRect
y rect
.
void operator|=(const RECT& rect) throw();
Parámetros
rect
Contiene CRect
o RECT
.
Comentarios
La unión es el rectángulo más pequeño que contiene ambos rectángulos de origen.
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
CRect rect1(100, 0, 200, 300);
CRect rect2(0, 100, 300, 200);
rect1 |= rect2;
CRect rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect1);
CRect::operator +
Las dos primeras sobrecargas devuelven un objeto CRect
que es igual a CRect
desplazados por los desplazamientos especificados.
CRect operator+(POINT point) const throw();
CRect operator+(LPCRECT lpRect) const throw();
CRect operator+(SIZE size) const throw();
Parámetros
point
Una estructura POINT
o un objeto CPoint
que especifica el número de unidades que se va a mover el valor devuelto.
size
Una estructura SIZE
o un objeto CSize
que especifica el número de unidades que se va a mover el valor devuelto.
lpRect
Apunta a una estructura RECT
o un objeto CRect
que contiene el número de unidades que se inflan en cada lado del valor devuelto.
Valor devuelto
El valor CRect
resultante de mover o inflar CRect
por el número de unidades especificadas en el parámetro.
Comentarios
Los parámetros x
y y
(o cx
y cy
) del parámetro se agregan a la posición de CRect
.
La tercera sobrecarga devuelve un nuevo valor CRect
que es igual a CRect
inflado por el número de unidades especificadas en cada miembro del parámetro.
Ejemplo
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect rect2;
rect2 = rect1 + pt;
CRect rectResult(135, 300, 235, 400);
ASSERT(rectResult == rect2);
CRect::operator -
Las dos primeras sobrecargas devuelven un objeto CRect
que es igual a CRect
desplazados por los desplazamientos especificados.
CRect operator-(POINT point) const throw();
CRect operator-(SIZE size) const throw();
CRect operator-(LPCRECT lpRect) const throw();
Parámetros
point
Una estructura POINT
o un objeto CPoint
que especifica el número de unidades que se va a mover el valor devuelto.
size
Una estructura SIZE
o un objeto CSize
que especifica el número de unidades que se va a mover el valor devuelto.
lpRect
Apunta a una estructura RECT
o un objeto CRect
que contiene el número de unidades que se desinflan en cada lado del valor devuelto.
Valor devuelto
El valor CRect
resultante de mover o desinflar CRect
por el número de unidades especificadas en el parámetro.
Comentarios
Los parámetros x
y y
(o cx
y cy
) del parámetro se restan de la posición de CRect
.
La tercera sobrecarga devuelve un nuevo valor CRect
que es igual a CRect
desinflado por el número de unidades especificadas en cada miembro del parámetro. Tenga en cuenta que esta sobrecarga funciona como DeflateRect
, no SubtractRect
.
Ejemplo
CRect rect1(100, 235, 200, 335);
CPoint pt(35, 65);
CRect rect2;
rect2 = rect1 - pt;
CRect rectResult(65, 170, 165, 270);
ASSERT(rect2 == rectResult);
CRect::operator &
Devuelve CRect
, que es la intersección de CRect
y rect2.
CRect operator&(const RECT& rect2) const throw();
Parámetros
rect2
Contiene RECT
o CRect
.
Valor devuelto
Un valor CRect
que es la intersección de CRect
y rect2
.
Comentarios
La intersección es el rectángulo más grande que se encuentra en ambos rectángulos.
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
CRect rect1(100, 0, 200, 300);
CRect rect2(0, 100, 300, 200);
CRect rect3;
rect3 = rect1 & rect2;
CRect rectResult(100, 100, 200, 200);
ASSERT(rectResult == rect3);
CRect::operator |
Devuelve un valor CRect
que es la unión de CRect
y rect2
.
CRect operator|(const RECT&
rect2) const throw();
Parámetros
rect2
Contiene RECT
o CRect
.
Valor devuelto
Un valor CRect
que es la unión de CRect
y rect2
.
Comentarios
La unión es el rectángulo más pequeño que contiene ambos rectángulos.
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
CRect rect1(100, 0, 200, 300);
CRect rect2(0, 100, 300, 200);
CRect rect3;
rect3 = rect1 | rect2;
CRect rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect3);
CRect::PtInRect
Determina si el punto especificado se encuentra dentro de CRect
.
BOOL PtInRect(POINT point) const throw();
Parámetros
point
Contiene una estructura POINT
o un objeto CPoint
.
Valor devuelto
Distinto de cero si el punto se encuentra dentro de CRect
; de lo contrario, 0.
Comentarios
Un punto está dentro de CRect
si se encuentra en el lado izquierdo o superior o en el interior de los cuatro lados. Un punto en el lado derecho o inferior está fuera de CRect
.
Nota:
El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar el rectángulo antes de llamar a esta función.
Ejemplo
CRect rect(5, 5, 100, 100);
CPoint pt1(35, 50);
CPoint pt2(125, 298);
// this is true, because pt1 is inside the rectangle
ASSERT(rect.PtInRect(pt1));
// this is NOT true, because pt2 is outside the rectangle
ASSERT(!rect.PtInRect(pt2));
// note that the right and the bottom aren't inside
ASSERT(!rect.PtInRect(CPoint(35, 100)));
ASSERT(!rect.PtInRect(CPoint(100, 98)));
// but the top and the left are inside
ASSERT(rect.PtInRect(CPoint(5, 65)));
ASSERT(rect.PtInRect(CPoint(88, 5)));
// and that PtInRect() works against a POINT, too
POINT pt;
pt.x = 35;
pt.y = 50;
ASSERT(rect.PtInRect(pt));
CRect::SetRect
Establece las dimensiones de CRect
en las coordenadas especificadas.
void SetRect(int x1, int y1, int x2, int y2) throw();
Parámetros
x1
Especifica la coordenada x de la esquina superior izquierda.
y1
Especifica la coordenada y de la esquina superior izquierda.
x2
Especifica la coordenada x de la esquina inferior derecha.
y2
Especifica la coordenada y de la esquina inferior derecha.
Ejemplo
CRect rect;
rect.SetRect(256, 256, 512, 512);
ASSERT(rect == CRect(256, 256, 512, 512));
CRect::SetRectEmpty
Convierte CRect
en un rectángulo nulo al establecer todas las coordenadas en cero.
void SetRectEmpty() throw();
Ejemplo
CRect rect;
rect.SetRectEmpty();
// rect is now (0, 0, 0, 0)
ASSERT(rect.IsRectEmpty());
CRect::SIZE
Los miembros cx
y cy
del valor devuelto contienen el alto y el ancho de CRect
.
CSize Size() const throw();
Valor devuelto
Un objeto CSize
que contiene el tamaño de CRect
.
Comentarios
El alto o el ancho pueden ser negativos.
Nota:
El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar el rectángulo antes de llamar a esta función.
Ejemplo
CRect rect(10, 10, 50, 50);
CSize sz = rect.Size();
ASSERT(sz.cx == 40 && sz.cy == 40);
CRect::SubtractRect
Hace las dimensiones de CRect
iguales a la resta de lpRectSrc1
menos lpRectSrc2
.
BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw();
Parámetros
lpRectSrc1
Apunta a la estructura RECT
o el objeto CRect
del que se va a restar un rectángulo.
lpRectSrc2
Apunta a la estructura RECT
o el objeto CRect
que se va a restar del rectángulo al que apunta el parámetro lpRectSrc1
.
Valor devuelto
Es distinto de cero si la función se realiza correctamente; de lo contrario, es 0.
Comentarios
La resta es el rectángulo más pequeño que contiene todos los puntos de lpRectScr1
que no están en la intersección de lpRectScr1
y lpRectScr2
.
El rectángulo especificado por lpRectSrc1
no se modificará si el rectángulo especificado por lpRectSrc2
no se superpone completamente al rectángulo especificado por lpRectSrc1
en al menos una de las direcciones X o Y.
Por ejemplo, si lpRectSrc1
fuera (10,10, 100,100) y lpRectSrc2
fuera (50,50, 150,150), el rectángulo al que apunta lpRectSrc1
no se modificaría cuando se devolviera la función. Si lpRectSrc1
fuera (10,10, 100,100) y lpRectSrc2
(50,10, 150,150), sin embargo, el rectángulo al que apunta lpRectSrc1
contendría las coordenadas (10,10, 50,100) cuando se devolviera la función.
SubtractRect
no es lo mismo que operador - ni que operador -=. Ninguno de estos operadores llama a SubtractRect
.
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
RECT rectOne;
RECT rectTwo;
rectOne.left = 10;
rectOne.top = 10;
rectOne.bottom = 100;
rectOne.right = 100;
rectTwo.left = 50;
rectTwo.top = 10;
rectTwo.bottom = 150;
rectTwo.right = 150;
CRect rectDiff;
rectDiff.SubtractRect(&rectOne, &rectTwo);
CRect rectResult(10, 10, 50, 100);
ASSERT(rectDiff == rectResult);
// works for CRect, too, since there is
// implicit CRect -> LPCRECT conversion
CRect rect1(10, 10, 100, 100);
CRect rect2(50, 10, 150, 150);
CRect rectOut;
rectOut.SubtractRect(rect1, rect2);
ASSERT(rectResult == rectOut);
CRect::TopLeft
Las coordenadas se devuelven como referencia a un objeto CPoint
que se encuentra en CRect
.
CPoint& TopLeft() throw();
const CPoint& TopLeft() const throw();
Valor devuelto
Las coordenadas de la esquina superior izquierda del rectángulo.
Comentarios
Puede usar esta función para obtener o establecer la esquina superior izquierda del rectángulo. Establezca la esquina mediante esta función en el lado izquierdo del operador de asignación.
Ejemplo
Vea el ejemplo de CRect::CenterPoint
.
CRect::UnionRect
Hace que las dimensiones de CRect
sean iguales a la unión de los dos rectángulos de origen.
BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();
Parámetros
lpRect1
Apunta a un valor RECT
o CRect
que contiene un rectángulo de origen.
lpRect2
Apunta a un valor RECT
o CRect
que contiene un rectángulo de origen.
Valor devuelto
Distinto de cero si la unión no está vacía; 0 si la unión está vacía.
Comentarios
La unión es el rectángulo más pequeño que contiene ambos rectángulos de origen.
Windows omite las dimensiones de un rectángulo vacío; es decir, un rectángulo que no tiene alto o no tiene ancho.
Nota:
Ambos rectángulos deben normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar los rectángulos antes de llamar a esta función.
Ejemplo
CRect rect1(100, 0, 200, 300);
CRect rect2(0, 100, 300, 200);
CRect rect3;
rect3.UnionRect(&rect1, &rect2);
CRect rectResult(0, 0, 300, 300);
ASSERT(rectResult == rect3);
CRect::Width
Calcula el ancho de CRect
restando el valor izquierdo del valor derecho.
int Width() const throw();
Valor devuelto
Ancho de CRect
.
Comentarios
El ancho puede ser negativo.
Nota:
El rectángulo debe normalizarse o esta función podría producir un error. Puede llamar a NormalizeRect
para normalizar el rectángulo antes de llamar a esta función.
Ejemplo
CRect rect(20, 30, 80, 70);
int nWid = rect.Width();
// nWid is now 60
ASSERT(nWid == 60);