CRect Classe

Semelhante a uma estrutura do Windows RECT .

Sintaxe

class CRect : public tagRECT

Membros

Construtores Públicos

Métodos Públicos

Operadores Públicos

Observações

CRect também inclui funções de membro para manipular CRect objetos e estruturas do Windows RECT .

Um CRect objeto pode ser passado como um parâmetro de função onde quer que uma RECT estrutura, LPCRECTou LPRECT pode ser passado.

A CRect contém variáveis de membro que definem os pontos superior esquerdo e inferior direito de um retângulo.

Ao especificar um CRect, você deve ter cuidado para construí-lo para que ele seja normalizado — em outras palavras, de modo que o valor da coordenada esquerda seja menor que a direita e o topo seja menor que a inferior. Por exemplo, um canto superior esquerdo de (10,10) e um canto inferior direito de (20,20) definem um retângulo normalizado, mas um canto superior esquerdo de (20,20) e um canto inferior direito de (10,10) definem um retângulo não normalizado. Se o retângulo não estiver normalizado, muitas CRect funções de membro podem retornar resultados incorretos. (Consulte CRect::NormalizeRect para obter uma lista dessas funções.) Antes de chamar uma função que requer retângulos normalizados, você pode normalizar retângulos não normalizados chamando a NormalizeRect função.

Tenha cuidado ao manipular um CRect com as CDC::DPtoLP funções e CDC::LPtoDP membro. Se o modo de mapeamento de um contexto de exibição é tal que a extensão y é negativa, como em MM_LOENGLISH, então CDC::DPtoLP transformará o CRect para que sua parte superior seja maior do que a inferior. Funções como Height e Size retornarão valores negativos para a altura do transformado CRect, e o retângulo não será normalizado.

Ao usar operadores sobrecarregados CRect , o primeiro operando deve ser um CRect; o segundo pode ser uma RECT estrutura ou um CRect objeto.

Hierarquia de herança

tagRECT

CRect

Requerimentos

Cabeçalho:atltypes.h

CRect::BottomRight

As coordenadas são retornadas como uma referência a um CPoint objeto contido em CRect.

CPoint& BottomRight() throw();
const CPoint& BottomRight() const throw();

Valor de retorno

As coordenadas do canto inferior direito do retângulo.

Observações

Você pode usar essa função para obter ou definir o canto inferior direito do retângulo. Defina o canto usando esta função no lado esquerdo do operador de atribuição.

Exemplo

// 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 o ponto central de CRect adicionando os valores esquerdo e direito e dividindo por dois, e adicionando os valores superior e inferior e dividindo por dois.

CPoint CenterPoint() const throw();

Valor de retorno

Um CPoint objeto que é o ponto central do CRect.

Exemplo

// 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 o lpSrcRect retângulo para CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parâmetros

lpSrcRect
Aponta para a RECT estrutura ou CRect objeto a ser copiado.

Exemplo

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

Constrói um 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 a posição esquerda de CRect.

t
Especifica a parte superior do CRect.

r
Especifica a posição correta de CRect.

b
Especifica a parte inferior do CRect.

srcRect
Refere-se à RECT estrutura com as coordenadas para CRect.

lpSrcRect
Aponta para a RECT estrutura com as coordenadas para CRect.

point
Especifica o ponto de origem do retângulo a ser construído. Corresponde ao canto superior esquerdo.

size
Especifica o deslocamento do canto superior esquerdo para o canto inferior direito do retângulo a ser construído.

topLeft
Especifica a posição superior esquerda de CRect.

bottomRight
Especifica a posição inferior direita de CRect.

Observações

Se nenhum argumento for dado, left, , topright, e bottom os membros serão definidos como 0.

Os CRectconstrutores (const RECT&) e CRect(LPCRECT) executam um CopyRectarquivo . Os outros construtores inicializam as variáveis membro do objeto diretamente.

Exemplo

// 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 esvazia CRect movendo os lados em direção ao 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 o número de unidades para esvaziar os lados esquerdo e direito do CRect.

y
Especifica o número de unidades para esvaziar a parte superior e inferior do CRect.

size
A SIZE ou CSize que especifica o número de unidades a serem esvaziadas CRect. O cx valor especifica o número de unidades para esvaziar os lados esquerdo e direito e o cy valor especifica o número de unidades para esvaziar a parte superior e inferior.

lpRect
Aponta para uma RECT estrutura ou CRect que especifica o número de unidades para esvaziar cada lado.

l
Especifica o número de unidades para esvaziar o lado esquerdo do CRect.

t
Especifica o número de unidades para esvaziar a parte superior do CRect.

r
Especifica o número de unidades para esvaziar o lado direito do CRect.

b
Especifica o número de unidades para esvaziar a parte inferior do CRect.

Observações

Para fazer isso, DeflateRect adiciona unidades à esquerda e ao topo e subtrai unidades da direita e da parte inferior. Os parâmetros de são valores assinados DeflateRect , valores positivos esvaziam CRect e valores negativos inflacionam.

As duas primeiras sobrecargas esvaziam ambos os pares de lados opostos de modo que sua largura total é diminuída em duas vezes (ou cx) e sua altura total é diminuída CRect em duas vezes y (ou cy).x As outras duas sobrecargas esvaziam cada lado independentemente CRect do outro.

Exemplo

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 se CRect é igual ao retângulo dado.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parâmetros

lpRect
Aponta para uma RECT estrutura ou CRect objeto que contém as coordenadas do canto superior esquerdo e inferior direito de um retângulo.

Valor de retorno

Diferente de zero se os dois retângulos tiverem os mesmos valores superior, esquerdo, inferior e direito; caso contrário, 0.

Exemplo

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 a altura subtraindo CRect o valor superior do valor inferior.

int Height() const throw();

Valor de retorno

A altura de CRect.

Observações

O valor resultante pode ser negativo.

Exemplo

CRect rect(20, 30, 80, 70);
int nHt = rect.Height();

// nHt is now 40
ASSERT(nHt == 40);

CRect::InflateRect

InflateRect infla CRect movendo os lados para longe do 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 o número de unidades para inflar os lados esquerdo e direito do CRect.

y
Especifica o número de unidades para inflar a parte superior e inferior do CRect.

size
A SIZE ou CSize que especifica o número de unidades a inflar CRect. O cx valor especifica o número de unidades para inflar os lados esquerdo e direito e o cy valor especifica o número de unidades para inflar a parte superior e inferior.

lpRect
Aponta para uma RECT estrutura ou CRect que especifica o número de unidades para inflar cada lado.

l
Especifica o número de unidades para inflar o lado esquerdo do CRect.

t
Especifica o número de unidades para inflar a parte superior do CRect.

r
Especifica o número de unidades para inflar o lado direito do CRect.

b
Especifica o número de unidades para inflar a parte inferior do CRect.

Observações

Para fazer isso, InflateRect subtrai unidades da esquerda e do topo e adiciona unidades à direita e à parte inferior. Os parâmetros de são valores assinados InflateRect , valores positivos inflam CRect e valores negativos esvaziam.

As duas primeiras sobrecargas inflam ambos os pares de lados opostos de CRect modo que sua largura total é aumentada em duas vezes x (ou cx) e sua altura total é aumentada em duas vezes y (ou cy). As outras duas sobrecargas inflam cada lado independentemente CRect do outro.

Exemplo

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

Faz um CRect igual à intersecção de dois retângulos existentes.

BOOL IntersectRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

Parâmetros

lpRect1
Aponta para uma RECT estrutura ou CRect objeto que contém um retângulo de origem.

lpRect2
Aponta para uma RECT estrutura ou CRect objeto que contém um retângulo de origem.

Valor de retorno

Diferente de zero se a intersecção não estiver vazia; 0 se o cruzamento estiver vazio.

Observações

A intersecção é o maior retângulo contido em ambos os retângulos existentes.

Exemplo

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 se CRect está vazio.

BOOL IsRectEmpty() const throw();

Valor de retorno

Diferente de zero se CRect estiver vazio; 0 se CRect não estiver vazio.

Observações

Um retângulo está vazio se a largura e/ou altura forem 0 ou negativas. Difere de IsRectNull, que determina se todas as coordenadas do retângulo são zero.

Exemplo

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 se os valores superior, esquerdo, inferior e direito de CRect são todos iguais a 0.

BOOL IsRectNull() const throw();

Valor de retorno

Diferente de zero se CRectos valores superior, esquerdo, inferior e direito forem todos iguais a 0, caso contrário 0.

Observações

Difere do IsRectEmpty, que determina se o retângulo está vazio.

Exemplo

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

Chame essa função para mover o retângulo para a coordenada x absoluta especificada por x.

void MoveToX(int x) throw();

Parâmetros

x
A coordenada x absoluta para o canto superior esquerdo do retângulo.

Exemplo

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

Chame essa função para mover o retângulo para as coordenadas x e y absolutas especificadas.

void MoveToXY(int x, int y) throw();
void MoveToXY(POINT point) throw();

Parâmetros

x
A coordenada x absoluta para o canto superior esquerdo do retângulo.

y
A coordenada y absoluta para o canto superior esquerdo do retângulo.

point
Uma POINT estrutura que especifica o canto superior esquerdo absoluto do retângulo.

Exemplo

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

Chame essa função para mover o retângulo para a coordenada y absoluta especificada por y.

void MoveToY(int y) throw();

Parâmetros

y
A coordenada y absoluta para o canto superior esquerdo do retângulo.

Exemplo

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 a altura como a largura sejam positivas.

void NormalizeRect() throw();

Observações

O retângulo é normalizado para posicionamento de quarto quadrante, que o Windows normalmente usa para coordenadas. NormalizeRect compara os valores superior e inferior e os troca se o topo for maior que o inferior. Da mesma forma, ele troca os valores esquerdo e direito se a esquerda for maior que a direita. Esta função é útil ao lidar com diferentes modos de mapeamento e retângulos invertidos.

Exemplo

CRect rect1(110, 100, 250, 310);
CRect rect2(250, 310, 110, 100);
rect1.NormalizeRect();
rect2.NormalizeRect();
ASSERT(rect1 == rect2);

CRect::OffsetRect

Move-se CRect pelos deslocamentos especificados.

void OffsetRect(int x, int y) throw();
void OffsetRect(POINT point) throw();
void OffsetRect(SIZE size) throw();

Parâmetros

x
Especifica a quantidade a ser movida para a esquerda ou para a direita. Deve ser negativo mover-se para a esquerda.

y
Especifica a quantidade a ser movida para cima ou para baixo. Tem de ser negativo para subir.

point
Contém uma POINT estrutura ou CPoint objeto que especifica ambas as dimensões pelas quais mover.

size
Contém uma SIZE estrutura ou CSize objeto que especifica ambas as dimensões pelas quais mover.

Observações

Move CRectx unidades ao longo do eixo x e y unidades ao longo do eixo y. Os x parâmetros e y são valores assinados, portanto CRect , podem ser movidos para a esquerda ou para a direita e para cima ou para baixo.

Exemplo

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

Converte a CRect em um LPCRECTarquivo .

operator LPCRECT() const throw();

Observações

Quando você usa essa função, você não precisa do endereço do operador (&). Esse operador será usado automaticamente quando você passar um CRect objeto para uma função que espera um LPCRECTarquivo .

CRect::operator LPRECT

Converte a CRect em um LPRECTarquivo .

operator LPRECT() throw();

Observações

Quando você usa essa função, você não precisa do endereço do operador (&). Esse operador será usado automaticamente quando você passar um CRect objeto para uma função que espera um LPRECTarquivo .

Exemplo

Veja o exemplo para CRect::operator LPCRECT.

CRect::operator =

Atribui srcRect a CRect.

void operator=(const RECT& srcRect) throw();

Parâmetros

srcRect
Refere-se a um retângulo de origem. Pode ser um RECT ou CRect.

Exemplo

CRect rect(0, 0, 127, 168);
CRect rect2;

rect2 = rect;
ASSERT(rect2 == CRect(0, 0, 127, 168));

CRect::operator ==

Determina se rect é igual comparando CRect as coordenadas dos cantos superior esquerdo e inferior direito.

BOOL operator==(const RECT& rect) const throw();

Parâmetros

rect
Refere-se a um retângulo de origem. Pode ser um RECT ou CRect.

Valor de retorno

Diferente de zero se igual; caso contrário, 0.

Observações

Exemplo

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 se rect não é igual comparando CRect as coordenadas dos cantos superior esquerdo e inferior direito.

BOOL operator!=(const RECT& rect) const throw();

Parâmetros

rect
Refere-se a um retângulo de origem. Pode ser um RECT ou CRect.

Valor de retorno

Diferente de zero, se não igual; caso contrário, 0.

Observações

Exemplo

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 +=

As duas primeiras sobrecargas são movidas CRect pelos deslocamentos especificados.

void operator+=(POINT point) throw();
void operator+=(SIZE size) throw();
void operator+=(LPCRECT lpRect) throw();

Parâmetros

point
Uma POINT estrutura ou CPoint objeto que especifica o número de unidades para mover o retângulo.

size
Uma SIZE estrutura ou CSize objeto que especifica o número de unidades para mover o retângulo.

lpRect
Aponta para uma RECT estrutura ou CRect objeto que contém o número de unidades para inflar cada lado do CRect.

Observações

Os valores do x parâmetro e y (ou cx e cy) são adicionados ao CRect.

A terceira sobrecarga infla pelo número de unidades especificadas CRect em cada membro do parâmetro.

Exemplo

CRect   rect1(100, 235, 200, 335);
CPoint  pt(35, 65);
CRect   rect2(135, 300, 235, 400);

rect1 += pt;
ASSERT(rect1 == rect2);

CRect::operator -=

As duas primeiras sobrecargas são movidas CRect pelos deslocamentos especificados.

void operator-=(POINT point) throw();
void operator-=(SIZE size) throw();
void operator-=(LPCRECT lpRect) throw();

Parâmetros

point
Uma POINT estrutura ou CPoint objeto que especifica o número de unidades para mover o retângulo.

size
Uma SIZE estrutura ou CSize objeto que especifica o número de unidades para mover o retângulo.

lpRect
Aponta para uma RECT estrutura ou CRect objeto que contém o número de unidades para esvaziar cada lado do CRect.

Observações

Os valores do x parâmetro e y (ou cx e cy) são subtraídos do CRect.

A terceira sobrecarga deflaciona pelo número de unidades especificadas CRect em cada membro do parâmetro. Observe que essa sobrecarga funciona como DeflateRect.

Exemplo

CRect   rect1(100, 235, 200, 335);
CPoint pt(35, 65);

rect1 -= pt;
CRect   rectResult(65, 170, 165, 270);
ASSERT(rect1 == rectResult);

CRect::operator &=

Conjuntos CRect iguais à intersecção de CRect e rect.

void operator&=(const RECT& rect) throw();

Parâmetros

rect
Contém um RECT ou CRect.

Observações

A intersecção é o maior retângulo que está contido em ambos os retângulos.

Exemplo

Veja o exemplo para CRect::IntersectRect.

CRect::operator |=

Conjuntos CRect iguais à união de CRect e rect.

void operator|=(const RECT& rect) throw();

Parâmetros

rect
Contém um CRect ou RECT.

Observações

A união é o menor retângulo que contém ambos os retângulos de origem.

Exemplo

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 +

As duas primeiras sobrecargas retornam um CRect objeto que é igual a CRect deslocado pelos deslocamentos especificados.

CRect operator+(POINT point) const throw();
CRect operator+(LPCRECT lpRect) const throw();
CRect operator+(SIZE size) const throw();

Parâmetros

point
Uma POINT estrutura ou CPoint objeto que especifica o número de unidades para mover o valor de retorno.

size
Uma SIZE estrutura ou CSize objeto que especifica o número de unidades para mover o valor de retorno.

lpRect
Aponta para uma RECT estrutura ou CRect objeto que contém o número de unidades para inflar cada lado do valor de retorno.

Valor de retorno

O CRect resultado de mover ou inflar CRect pelo número de unidades especificadas no parâmetro.

Observações

Os parâmetros do x parâmetro e y (ou cx e cy) são adicionados à CRectposição de .

A terceira sobrecarga retorna uma nova CRect que é igual a CRect inflada pelo número de unidades especificadas em cada membro do parâmetro.

Exemplo

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 -

As duas primeiras sobrecargas retornam um CRect objeto que é igual a CRect deslocado pelos deslocamentos especificados.

CRect operator-(POINT point) const throw();
CRect operator-(SIZE size) const throw();
CRect operator-(LPCRECT lpRect) const throw();

Parâmetros

point
Uma POINT estrutura ou CPoint objeto que especifica o número de unidades para mover o valor de retorno.

size
Uma SIZE estrutura ou CSize objeto que especifica o número de unidades para mover o valor de retorno.

lpRect
Aponta para uma RECT estrutura ou CRect objeto que contém o número de unidades para esvaziar cada lado do valor de retorno.

Valor de retorno

O CRect resultado da movimentação ou deflação CRect pelo número de unidades especificadas no parâmetro.

Observações

Os parâmetros do x parâmetro e y (ou cx e cy) são subtraídos da posição de CRect.

A terceira sobrecarga retorna uma nova CRect que é igual a CRect deflacionada pelo número de unidades especificadas em cada membro do parâmetro. Observe que essa sobrecarga funciona como DeflateRect, não SubtractRect.

Exemplo

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 &

Retorna a CRect que é a interseção de CRect e rect2.

CRect operator&(const RECT& rect2) const throw();

Parâmetros

rect2
Contém um RECT ou CRect.

Valor de retorno

A CRect que é a intersecção de CRect e rect2.

Observações

A intersecção é o maior retângulo que está contido em ambos os retângulos.

Exemplo

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 |

Devolve um CRect que é a união de CRect e rect2.

CRect operator|(const RECT&
rect2) const throw();

Parâmetros

rect2
Contém um RECT ou CRect.

Valor de retorno

A CRect que é a união de CRect e rect2.

Observações

A união é o menor retângulo que contém ambos os retângulos.

Exemplo

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 se o ponto especificado está dentro de CRect.

BOOL PtInRect(POINT point) const throw();

Parâmetros

point
Contém uma POINT estrutura ou CPoint objeto.

Valor de retorno

Diferente de zero se o ponto estiver dentro de CRect; caso contrário 0.

Observações

Um ponto está dentro CRect se estiver no lado esquerdo ou superior ou estiver dentro dos quatro lados. Um ponto no lado direito ou inferior está fora CRect.

Exemplo

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

Define as dimensões de CRect para as coordenadas especificadas.

void SetRect(int x1, int y1, int x2, int y2) throw();

Parâmetros

x1
Especifica a coordenada x do canto superior esquerdo.

y1
Especifica a coordenada y do canto superior esquerdo.

x2
Especifica a coordenada x do canto inferior direito.

y2
Especifica a coordenada y do canto inferior direito.

Exemplo

CRect rect;
rect.SetRect(256, 256, 512, 512);
ASSERT(rect == CRect(256, 256, 512, 512));

CRect::SetRectEmpty

Cria CRect um retângulo nulo definindo todas as coordenadas como zero.

void SetRectEmpty() throw();

Exemplo

CRect rect;
rect.SetRectEmpty();

// rect is now (0, 0, 0, 0)
ASSERT(rect.IsRectEmpty());

CRect::SIZE

Os cx e cy membros do valor de retorno contêm a altura e a largura de CRect.

CSize Size() const throw();

Valor de retorno

Um CSize objeto que contém o tamanho de CRect.

Observações

Tanto a altura como a largura podem ser negativas.

Exemplo

CRect rect(10, 10, 50, 50);
CSize sz = rect.Size();
ASSERT(sz.cx == 40 && sz.cy == 40);

CRect::SubtractRect

Torna as dimensões do CRect igual à subtração de lpRectSrc2lpRectSrc1de .

BOOL SubtractRect(LPCRECT lpRectSrc1, LPCRECT lpRectSrc2) throw();

Parâmetros

lpRectSrc1
Aponta para a RECT estrutura ou CRect objeto do qual um retângulo deve ser subtraído.

lpRectSrc2
Aponta para a RECT estrutura ou CRect objeto que deve ser subtraído do retângulo apontado lpRectSrc1 pelo parâmetro.

Valor de retorno

Diferente de zero se a função for bem-sucedida; caso contrário, 0.

Observações

A subtração é o menor retângulo que contém todos os pontos em lpRectScr1 que não estão na intersecção de lpRectScr1 e lpRectScr2.

O retângulo especificado por lpRectSrc1 permanecerá inalterado se o retângulo especificado por lpRectSrc2 não se sobrepuser completamente ao retângulo especificado por lpRectSrc1 pelo menos em uma das direções x ou y.

Por exemplo, se lpRectSrc1 fossem (10,10, 100,100) e lpRectSrc2 fossem (50,50, 150,150), o retângulo apontado por lpRectSrc1 ficaria inalterado quando a função retornasse. Se lpRectSrc1 fossem (10,10, 100,100) e lpRectSrc2 fossem (50,10, 150,150), no entanto, o retângulo apontado por lpRectSrc1 conteria as coordenadas (10,10, 50,100) quando a função retornasse.

SubtractRect não é o mesmo que operador - nem operador -=. Nenhum destes operadores telefona SubtractRect.

Exemplo

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

As coordenadas são retornadas como uma referência a um CPoint objeto contido em CRect.

CPoint& TopLeft() throw();
const CPoint& TopLeft() const throw();

Valor de retorno

As coordenadas do canto superior esquerdo do retângulo.

Observações

Você pode usar essa função para obter ou definir o canto superior esquerdo do retângulo. Defina o canto usando esta função no lado esquerdo do operador de atribuição.

Exemplo

Veja o exemplo para CRect::CenterPoint.

CRect::UnionRect

Torna as dimensões iguais CRect à união dos dois retângulos de origem.

BOOL UnionRect(LPCRECT lpRect1, LPCRECT lpRect2) throw();

Parâmetros

lpRect1
Aponta para um RECT ou CRect que contém um retângulo de origem.

lpRect2
Aponta para um RECT ou CRect que contém um retângulo de origem.

Valor de retorno

Diferente de zero se a união não estiver vazia; 0 se a união estiver vazia.

Observações

A união é o menor retângulo que contém ambos os retângulos de origem.

O Windows ignora as dimensões de um retângulo vazio; ou seja, um retângulo que não tem altura ou não tem largura.

Exemplo

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 a largura de CRect subtraindo o valor esquerdo do valor direito.

int Width() const throw();

Valor de retorno

A largura de CRect.

Observações

A largura pode ser negativa.

Exemplo

CRect rect(20, 30, 80, 70);
int nWid = rect.Width();
// nWid is now 60
ASSERT(nWid == 60);

Ver também

CPoint Classe
CSize Classe
RECT