Classe `CRect`

Artigo
04/03/2023

Semelhante a uma estrutura RECT do Windows.

Sintaxe

class CRect : public tagRECT

Membros

Construtores públicos

Nome	Descrição
`CRect::CRect`	Constrói um objeto `CRect`.

Métodos públicos

Nome	Descrição
`CRect::BottomRight`	Retorna o ponto inferior direito de `CRect`.
`CRect::CenterPoint`	Retorna o ponto central de `CRect`.
`CRect::CopyRect`	Copia as dimensões de um retângulo de origem para `CRect`.
`CRect::DeflateRect`	Diminui a largura e a altura de `CRect`.
`CRect::EqualRect`	Determina se `CRect` é igual ao retângulo especificado.
`CRect::Height`	Calcula a altura de `CRect`.
`CRect::InflateRect`	Aumenta a largura e a altura de `CRect`.
`CRect::IntersectRect`	Define `CRect` igual à interseção de dois retângulos.
`CRect::IsRectEmpty`	Determina se `CRect` está vazia. `CRect` estará vazia se a largura e/ou a altura forem 0.
`CRect::IsRectNull`	Determina se as variáveis de membro `top`, `bottom`, `left` e `right` são todas iguais a 0.
`CRect::MoveToX`	Move `CRect` para a coordenada X especificada.
`CRect::MoveToXY`	Move `CRect` para as coordenadas X e Y especificadas.
`CRect::MoveToY`	Move `CRect` para a coordenada Y especificada.
`CRect::NormalizeRect`	Padroniza a altura e a largura de `CRect`.
`CRect::OffsetRect`	Move `CRect` pelos deslocamentos especificados.
`CRect::PtInRect`	Determina se o ponto especificado está dentro de `CRect`.
`CRect::SetRect`	Define as dimensões de `CRect`.
`CRect::SetRectEmpty`	Define `CRect` como um retângulo vazio (todas as coordenadas são iguais a 0).
`CRect::Size`	Calcula o tamanho de `CRect`.
`CRect::SubtractRect`	Subtrai um retângulo do outro.
`CRect::TopLeft`	Retorna o ponto superior esquerdo de `CRect`.
`CRect::UnionRect`	Define `CRect` igual à união de dois retângulos.
`CRect::Width`	Calcula a largura de `CRect`.

Operadores públicos

Nome	Descrição
`CRect::operator -`	Subtrai os deslocamentos fornecidos de `CRect` ou desinfla `CRect` e retorna a `CRect` resultante.
`CRect::operator LPCRECT`	Converte um `CRect` em um `LPCRECT`.
`CRect::operator LPRECT`	Converte um `CRect` em um `LPRECT`.
`CRect::operator !=`	Determina se `CRect` não é igual a um retângulo.
`CRect::operator &`	Cria a interseção de `CRect` e um retângulo e retorna a `CRect` resultante.
`CRect::operator &=`	Define `CRect` igual à interseção de `CRect` e um retângulo.
`CRect::operator \|`	Cria a união de `CRect` e um retângulo e retorna a `CRect` resultante.
`CRect::operator \|=`	Define `CRect` igual à união de `CRect` e um retângulo.
`CRect::operator +`	Adiciona os deslocamentos fornecidos a `CRect` ou infla `CRect` e retorna a `CRect` resultante.
`CRect::operator +=`	Adiciona os deslocamentos especificados a `CRect` ou infla `CRect`.
`CRect::operator =`	Copia as dimensões de um retângulo para `CRect`.
`CRect::operator -=`	Subtrai os deslocamentos especificados de `CRect` ou desinfla `CRect`.
`CRect::operator ==`	Determina se `CRect` é igual a um retângulo.

Comentários

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

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

Observação

Essa classe é derivada da estrutura tagRECT. (O nome tagRECT é um nome menos usado para a estrutura RECT.) Isso significa que os membros de dados (left, top, right e bottom) da estrutura RECT são membros de dados acessíveis de CRect.

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

Ao especificar uma CRect, você deve ter cuidado para gerá-la de modo que ela fique normalizada ou, em outras palavras, de modo que o valor da coordenada esquerda seja menor que o direito e que a parte superior seja menor que a parte inferior. Por exemplo, um canto superior esquerdo (10,10) e um inferior direito (20,20) definem um retângulo normalizado, mas um canto superior esquerdo de (20,20) e um inferior direito (10,10) definem um retângulo não normalizado. Se o retângulo não estiver normalizado, muitas funções de membro CRect poderão retornar resultados incorretos. (Confira 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 função NormalizeRect.

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

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

Hierarquia de herança

tagRECT

CRect

Requisitos

Cabeçalho: atltypes.h

`CRect::BottomRight`

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

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

Valor de retorno

As coordenadas do canto inferior direito do retângulo.

Comentários

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

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 ao adicionar os valores esquerdo e direito e dividir por dois e ao adicionar os valores superior e inferior e dividir por dois.

CPoint CenterPoint() const throw();

Valor de retorno

Um objeto CPoint que é o ponto central de 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 retângulo lpSrcRect em CRect.

void CopyRect(LPCRECT lpSrcRect) throw();

Parâmetros

lpSrcRect
Aponta para a estrutura RECT ou o objeto CRect 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 de CRect.

r
Especifica a posição direita de CRect.

b
Especifica a parte inferior de CRect.

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

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

point
Especifica o ponto de origem para o 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 criado.

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

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

Comentários

Se nenhum argumento for fornecido, os membros left, top, right e bottom serão definidos como 0.

Os construtores CRect(const RECT&) e CRect(LPCRECT) executam uma CopyRect. Os outros construtores inicializam as variáveis de 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 desinfla CRect ao mover seus 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 desinflar os lados esquerdo e direito de CRect.

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

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

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

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

t
Especifica o número de unidades para desinflar o lado superior de CRect.

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

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

Comentários

Para fazer isso, DeflateRect adiciona unidades à esquerda e à parte superior e subtrai unidades do lado direito e da parte inferior. Os parâmetros de DeflateRect são valores assinados; os valores positivos desinflam CRect e os valores negativos o inflam.

As duas primeiras sobrecargas desinflam ambos os pares de lados opostos de modo CRect que sua largura total seja reduzida em duas vezes x (ou cx) e sua altura total seja reduzida em duas vezes y (ou cy). As outras duas sobrecargas desinflam cada lado de CRect independentemente dos outros.

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 especificado.

BOOL EqualRect(LPCRECT lpRect) const throw();

Parâmetros

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

Valor de retorno

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

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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 de CRect ao subtrair o valor superior do valor inferior.

int Height() const throw();

Valor de retorno

A altura de CRect.

Comentários

O valor resultante pode ser negativo.

Observação

O retângulo deve ser normalizado, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar o retângulo antes de chamar essa função.

Exemplo

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

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

`CRect::InflateRect`

InflateRect infla CRect ao mover seus lados para longe de seu 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 de CRect.

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

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

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

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

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

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

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

Comentários

Para fazer isso, InflateRect subtrai unidades da esquerda e da parte superior e adiciona unidades no lado direito e na parte inferior. Os parâmetros de InflateRect são valores assinados; os valores positivos inflam CRect e os valores negativos o desinflam.

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

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`

Torna uma CRect igual à interseção de dois retângulos existentes.

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

Parâmetros

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

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

Valor de retorno

Não zero se a interseção não estiver vazia; 0 se a interseção estiver vazia.

Comentários

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

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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á vazia.

BOOL IsRectEmpty() const throw();

Valor de retorno

Não zero se CRect estiver vazia; 0 se CRect não estiver vazia.

Comentários

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

Observação

O retângulo deve ser normalizado, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar o retângulo antes de chamar essa função.

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

Não zero se os valores superior, esquerdo, inferior e direito de CRect forem todos iguais a 0; caso contrário, 0.

Comentários

Difere de 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 do 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 a coordenada X absoluta especificada por coordenadas Y.

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

Parâmetros

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

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

point
Uma estrutura POINT 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 do 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 a altura e a largura sejam positivas.

void NormalizeRect() throw();

Comentários

O retângulo é normalizado para o posicionamento do quarto quadrante, o qual o Windows normalmente usa para coordenadas. NormalizeRect compara os valores superior e inferior e os troca se a parte superior for maior que a inferior. Da mesma forma, ela troca os valores dos lados esquerdo e direito se o esquerdo for maior que o direito. Essa função ajuda ao lidar com diferentes modos de mapeamento e retângulos invertidos.

Observação

As seguintes funções de membro CRect exigem retângulos normalizados para funcionar corretamente: Height, Width, Size, IsRectEmpty, PtInRect, EqualRect, UnionRect, IntersectRect, SubtractRect, operator ==, operator !=, operator |, operator |=, operator & e operator &=.

Exemplo

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

`CRect::OffsetRect`

Move 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 o valor a ser movido para a esquerda ou para a direita. Deve ser negativo para ser movido para a esquerda.

y
Especifica o valor a ser movido para cima ou para baixo. Deve ser negativo para ser movido para cima.

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

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

Comentários

Move unidades CRectx ao longo do eixo X e unidades y ao longo do eixo Y. Os parâmetros x e y são valores assinados, portanto CRect pode ser movido para a esquerda ou 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 uma `CRect` em uma `LPCRECT`.

operator LPCRECT() const throw();

Comentários

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

`CRect::operator LPRECT`

Converte um CRect em um LPRECT.

operator LPRECT() throw();

Comentários

Exemplo

Confira o exemplo de 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 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 a CRect comparando as coordenadas de seus 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 RECT ou CRect.

Valor de retorno

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

Comentários

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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 a CRect comparando as coordenadas de seus 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 RECT ou CRect.

Valor de retorno

Não zero se não for igual; caso contrário, 0.

Comentários

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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 movem CRect pelos deslocamentos especificados.

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

Parâmetros

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

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

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

Comentários

Os valores dos parâmetros x e y (ou cx e cy) são adicionados a CRect.

A terceira sobrecarga infla CRect pelo número de unidades especificado 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 movem CRect pelos deslocamentos especificados.

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

Parâmetros

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

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

lpRect
Aponta para uma estrutura RECT ou um objeto CRect que contenha o número de unidades para desinflar cada lado de CRect.

Comentários

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

A terceira sobrecarga desinfla CRect pelo número de unidades especificado 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 &=`

Define CRect igual à interseção de CRect e rect.

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

Parâmetros

rect
Contém uma RECT ou CRect.

Comentários

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

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

Exemplo

Confira o exemplo de CRect::IntersectRect.

`CRect::operator |=`

Define CRect igual à união de CRect e rect.

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

Parâmetros

rect
Contém uma CRect ou RECT.

Comentários

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

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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 objeto CRect igual ao CRect movido 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 estrutura POINT ou um objeto CPoint que especifica o número de unidades para mover o valor retornado.

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

lpRect
Aponta para uma estrutura RECT ou um objeto CRect que contenha o número de unidades para inflar cada lado do valor retornado.

Valor de retorno

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

Comentários

Os parâmetros x e y (ou cx e cy) dos parâmetros são adicionados à posição de CRect.

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 objeto CRect igual ao CRect movido 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 estrutura POINT ou um objeto CPoint que especifica o número de unidades para mover o valor retornado.

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

lpRect
Aponta para uma estrutura RECT ou um objeto CRect que contenha o número de unidades para desinflar cada lado do valor retornado.

Valor de retorno

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

Comentários

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

A terceira sobrecarga retorna uma nova CRect que é igual a CRect desinflada 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 uma CRect que é a intersecção de CRect e rect2.

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

Parâmetros

rect2
Contém uma RECT ou CRect.

Valor de retorno

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

Comentários

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

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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 |`

Retorna uma CRect que é a união de CRect e rect2.

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

Parâmetros

rect2
Contém uma RECT ou CRect.

Valor de retorno

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

Comentários

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

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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 estrutura POINT ou um objeto CPoint.

Valor de retorno

Não zero se o ponto estiver dentro de CRect; caso contrário, 0.

Comentários

Um ponto estará dentro de CRect se ele estiver no lado esquerdo ou superior ou se estiver dentro de todos os quatro lados. Um ponto no lado direito ou inferior está fora de CRect.

Observação

O retângulo deve ser normalizado, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar o retângulo antes de chamar essa função.

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`

Torna a 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 membros cx e cy do valor retornado contêm a altura e a largura de CRect.

CSize Size() const throw();

Valor de retorno

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

Comentários

A altura ou a largura podem ser negativas.

Observação

O retângulo deve ser normalizado, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar o retângulo antes de chamar essa função.

Exemplo

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

`CRect::SubtractRect`

Torna as dimensões da CRect iguais à subtração de lpRectSrc2 de lpRectSrc1.

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

Parâmetros

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

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

Valor de retorno

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

Comentários

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

O retângulo especificado por lpRectSrc1 ficará inalterado se o retângulo especificado por lpRectSrc2 não sobrepuser completamente o retângulo especificado por lpRectSrc1 em pelo menos uma das direções X ou Y.

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

SubtractRect não é o mesmo que operator - nem operator -=. Esses operadores nunca chamam SubtractRect.

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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 objeto CPoint contido em CRect.

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

Valor de retorno

As coordenadas do canto superior esquerdo do retângulo.

Comentários

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

Exemplo

Confira o exemplo de CRect::CenterPoint.

`CRect::UnionRect`

Torna as dimensões de CRect iguais à 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

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

Comentários

A união é o menor retângulo que contém os dois 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 que não tem largura.

Observação

Ambos os retângulos devem ser normalizados, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar os retângulos antes de chamar essa função.

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 ao subtrair o valor esquerdo do valor direito.

int Width() const throw();

Valor de retorno

A largura de CRect.

Comentários

A largura pode ser negativa.

Observação

O retângulo deve ser normalizado, ou essa função pode falhar. Você pode chamar NormalizeRect para normalizar o retângulo antes de chamar essa função.

Exemplo

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

Confira também

Classe CPoint
Classe CSize
RECT

Partilhar via

Classe CRect

Sintaxe

Membros

Construtores públicos

Métodos públicos

Operadores públicos

Comentários

Hierarquia de herança

Requisitos

CRect::BottomRight

Valor de retorno

Comentários

Exemplo

CRect::CenterPoint

Valor de retorno

Exemplo

CRect::CopyRect

Parâmetros

Exemplo

CRect::CRect

Parâmetros

Comentários

Exemplo

CRect::DeflateRect

Parâmetros

Comentários

Exemplo

CRect::EqualRect

Parâmetros

Valor de retorno

Exemplo

CRect::Height

Valor de retorno

Comentários

Exemplo

CRect::InflateRect

Parâmetros

Comentários

Exemplo

CRect::IntersectRect

Parâmetros

Valor de retorno

Comentários

Exemplo

CRect::IsRectEmpty

Valor de retorno

Comentários

Exemplo

CRect::IsRectNull

Valor de retorno

Comentários

Exemplo

CRect::MoveToX

Parâmetros

Exemplo

CRect::MoveToXY

Parâmetros

Exemplo

CRect::MoveToY

Parâmetros

Exemplo

CRect::NormalizeRect

Comentários

Exemplo

CRect::OffsetRect

Parâmetros

Comentários

Exemplo

CRect::operator LPCRECT converte uma CRect em uma LPCRECT.

Comentários

CRect::operator LPRECT

Comentários

Exemplo

CRect::operator =

Parâmetros

Exemplo

CRect::operator ==

Parâmetros

Valor de retorno

Classe `CRect`

`CRect::BottomRight`

`CRect::CenterPoint`

`CRect::CopyRect`

`CRect::CRect`

`CRect::DeflateRect`

`CRect::EqualRect`

`CRect::Height`

`CRect::InflateRect`

`CRect::IntersectRect`

`CRect::IsRectEmpty`

`CRect::IsRectNull`

`CRect::MoveToX`

`CRect::MoveToXY`

`CRect::MoveToY`

`CRect::NormalizeRect`

`CRect::OffsetRect`

`CRect::operator LPCRECT` converte uma `CRect` em uma `LPCRECT`.

`CRect::operator LPRECT`

`CRect::operator =`

`CRect::operator ==`

`CRect::operator !=`

`CRect::operator +=`

`CRect::operator -=`

`CRect::operator &=`

`CRect::operator |=`

`CRect::operator +`

`CRect::operator -`

`CRect::operator &`

`CRect::operator |`

`CRect::PtInRect`

`CRect::SetRect`

`CRect::SetRectEmpty`

`CRect::SIZE`

`CRect::SubtractRect`

`CRect::TopLeft`

`CRect::UnionRect`