Classe CRgn

Encapsula uma região de GDI (Graphics Device Interface) do Windows.

Sintaxe

class CRgn : public CGdiObject

Membros

Construtores públicos

Métodos públicos

Operadores públicos

Comentários

Uma região é uma área elíptica ou poligonal dentro de uma janela. Para usar regiões, use as funções membro da classe CRgn com as funções de recorte definidas como membros da classe CDC.

As funções membro de CRgn criam, alteram e recuperam informações sobre o objeto de região para o qual são chamadas.

Para obter mais informações sobre como usar CRgn, consulte Objetos Gráficos.

Hierarquia de herança

CObject

CGdiObject

CRgn

Requisitos

Cabeçalho: afxwin.h

CRgn::CombineRgn

Cria uma região de GDI combinando duas regiões existentes.

int CombineRgn(
    CRgn* pRgn1,
    CRgn* pRgn2,
    int nCombineMode);

Parâmetros

pRgn1
Identifica uma região existente.

pRgn2
Identifica uma região existente.

nCombineMode
Especifica a operação a ser executada ao combinar as duas regiões de origem. Pode ser qualquer um dos seguintes valores:

• RGN_AND Usa áreas sobrepostas das duas regiões (interseção).

• RGN_COPY Cria uma cópia da região 1 (identificada por pRgn1).

• RGN_DIFF Cria uma região composta pelas áreas da região 1 (identificadas por pRgn1) que não fazem parte da região 2 (identificadas por pRgn2).

• RGN_OR Combina as duas regiões em sua totalidade (união).

• RGN_XOR Combina as duas regiões, mas remove áreas sobrepostas.

Valor de retorno

Especifica o tipo da região resultante. Pode ser um dos seguintes valores:

• COMPLEXREGION A nova região tem bordas sobrepostas.

• ERRO Nenhuma região criada.

• NULLREGION A nova região está vazia.

• SIMPLEREGION A nova região não tem bordas sobrepostas.

Comentários

As regiões são combinadas conforme especificado por nCombineMode.

As duas regiões especificadas são combinadas e o identificador da região resultante é armazenado no objeto CRgn. Portanto, qualquer região armazenada no objeto CRgn é substituída pela região combinada.

O tamanho de uma região é limitado a 32.767 por 32.767 unidades lógicas ou 64K de memória, o que for menor.

Use CopyRgn para apenas copiar uma região para outra.

Exemplo

CRgn   rgnA, rgnB, rgnC;

VERIFY(rgnA.CreateRectRgn(50, 50, 150, 150));
VERIFY(rgnB.CreateRectRgn(100, 100, 200, 200));
VERIFY(rgnC.CreateRectRgn(0, 0, 50, 50));

int nCombineResult = rgnC.CombineRgn(&rgnA, &rgnB, RGN_OR);
ASSERT(nCombineResult != ERROR && nCombineResult != NULLREGION);

CBrush br1, br2, br3;
VERIFY(br1.CreateSolidBrush(RGB(255, 0, 0)));  // rgnA Red
VERIFY(pDC->FrameRgn(&rgnA, &br1, 2, 2));
VERIFY(br2.CreateSolidBrush(RGB(0, 255, 0)));  // rgnB Green
VERIFY(pDC->FrameRgn(&rgnB, &br2, 2, 2));
VERIFY(br3.CreateSolidBrush(RGB(0, 0, 255)));  // rgnC Blue
VERIFY(pDC->FrameRgn(&rgnC, &br3, 2, 2));

CRgn::CopyRgn

Copia a região definida por pRgnSrc no objeto CRgn.

int CopyRgn(CRgn* pRgnSrc);

Parâmetros

pRgnSrc
Identifica uma região existente.

Valor de retorno

Especifica o tipo da região resultante. Pode ser um dos seguintes valores:

• COMPLEXREGION A nova região tem bordas sobrepostas.

• ERRO Nenhuma região criada.

• NULLREGION A nova região está vazia.

• SIMPLEREGION A nova região não tem bordas sobrepostas.

Comentários

A nova região substitui a região armazenada no objeto CRgn. Essa função é um caso especial da função membro CombineRgn.

Exemplo

Consulte o exemplo de CRgn::CreateEllipticRgn.

CRgn::CreateEllipticRgn

Cria uma região elíptica.

BOOL CreateEllipticRgn(
    int x1,
    int y1,
    int x2,
    int y2);

Parâmetros

x1
Especifica a coordenada x lógica do canto superior esquerdo do retângulo delimitador da elipse.

y1
Especifica a coordenada y lógica do canto superior esquerdo do retângulo delimitador da elipse.

x2
Especifica a coordenada x lógica do canto inferior direito do retângulo delimitador da elipse.

y2
Especifica a coordenada y lógica do canto inferior direito do retângulo delimitador da elipse.

Valor de retorno

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

Comentários

A região é definida pelo retângulo delimitador especificado por x1, y1, x2 e y2. A região é armazenada no objeto CRgn.

O tamanho de uma região é limitado a 32.767 por 32.767 unidades lógicas ou 64K de memória, o que for menor.

Quando terminar de usar uma região criada com a função CreateEllipticRgn, um aplicativo deverá selecionar a região fora do contexto do dispositivo e usar a função DeleteObject para removê-la.

Exemplo

CRgn   rgnA, rgnB, rgnC;

VERIFY(rgnA.CreateEllipticRgn(200, 100, 350, 250));
VERIFY(rgnB.CreateRectRgn(0, 0, 50, 50));
VERIFY(rgnB.CopyRgn(&rgnA));
int nOffsetResult = rgnB.OffsetRgn(-75, 75);
ASSERT(nOffsetResult != ERROR && nOffsetResult != NULLREGION);

VERIFY(rgnC.CreateRectRgn(0, 0, 1, 1));
int nCombineResult = rgnC.CombineRgn(&rgnA, &rgnB, RGN_AND);
ASSERT(nCombineResult != ERROR && nOffsetResult != NULLREGION);

CBrush brA, brB, brC;
VERIFY(brC.CreateHatchBrush(HS_FDIAGONAL, RGB(0, 0, 255))); // Blue
VERIFY(pDC->FillRgn(&rgnC, &brC));
VERIFY(brA.CreateSolidBrush(RGB(255, 0, 0)));  // rgnA Red
VERIFY(pDC->FrameRgn(&rgnA, &brA, 2, 2));
VERIFY(brB.CreateSolidBrush(RGB(0, 255, 0)));  // rgnB Green
VERIFY(pDC->FrameRgn(&rgnB, &brB, 2, 2));

CRgn::CreateEllipticRgnIndirect

Cria uma região elíptica.

BOOL CreateEllipticRgnIndirect(LPCRECT lpRect);

Parâmetros

lpRect
Aponta para uma estrutura RECT ou para um objeto CRect que contém as coordenadas lógicas dos cantos superior esquerdo e inferior direito do retângulo delimitador da elipse.

Valor de retorno

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

Comentários

A região é definida pela estrutura ou pelo objeto para o qual lpRect apontou e é armazenada no objeto CRgn.

O tamanho de uma região é limitado a 32.767 por 32.767 unidades lógicas ou 64K de memória, o que for menor.

Quando terminar de usar uma região criada com a função CreateEllipticRgnIndirect, um aplicativo deverá selecionar a região fora do contexto do dispositivo e usar a função DeleteObject para removê-la.

Exemplo

Consulte o exemplo de CRgn::CreateRectRgnIndirect.

CRgn::CreateFromData

Cria uma região com base nos dados de região e transformação especificados.

BOOL CreateFromData(
    const XFORM* lpXForm,
    int nCount,
    const RGNDATA* pRgnData);

Parâmetros

lpXForm
Aponta para uma estrutura de dados XFORM que define a transformação a ser executada na região. Se esse ponteiro for NULL, a transformação de identidade será usada.

nCount
Especifica o número de bytes para o qual pRgnData apontou.

pRgnData
Aponta para uma estrutura de dados RGNDATA que contém os dados da região.

Valor de retorno

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

Comentários

Um aplicativo pode recuperar dados para uma região chamando a função CRgn::GetRegionData.

CRgn::CreateFromPath

Cria uma região com base no caminho selecionado no contexto de dispositivo fornecido.

BOOL CreateFromPath(CDC* pDC);

Parâmetros

pDC
Identifica um contexto de dispositivo que contém um demarcador fechado.

Valor de retorno

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

Comentários

O contexto do dispositivo identificado pelo parâmetro pDC precisa conter um caminho fechado. Após CreateFromPath converter um caminho em uma região, o Windows descarta o demarcador fechado do contexto do dispositivo.

CRgn::CreatePolygonRgn

Cria uma região poligonal.

BOOL CreatePolygonRgn(
    LPPOINT lpPoints,
    int nCount,
    int nMode);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas POINT ou para uma matriz de objetos CPoint. Cada estrutura especifica a coordenada x e a coordenada y de um vértice do polígono. A estrutura POINT tem a seguinte forma:

typedef struct tagPOINT {
    int x;
    int y;
} POINT;

nCount
Especifica o número de estruturas POINT ou objetos CPoint na matriz para a qual IpPoints apontou.

nMode
Especifica o modo de preenchimento para a região. Esse parâmetro pode ser ALTERNATE ou WINDING.

Valor de retorno

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

Comentários

O sistema fecha o polígono automaticamente, se necessário, desenhando uma linha do último vértice ao primeiro. A região resultante é armazenada no objeto CRgn.

O tamanho de uma região é limitado a 32.767 por 32.767 unidades lógicas ou 64K de memória, o que for menor.

Quando o modo de preenchimento de polígono é ALTERNATE, o sistema preenche a área entre lados de com numeração ímpar e numeração par do polígono em cada linha de verificação. Ou seja, o sistema preenche a área entre o primeiro e o segundo lados, entre o terceiro e o quarto lados e assim por diante.

Quando o modo de preenchimento de polígono é WINDING, o sistema usa a direção na qual uma figura foi desenhada para determinar se uma área deve ser preenchida. Cada segmento de linha em um polígono é desenhado no sentido horário ou no sentido anti-horário. Sempre que uma linha imaginária desenhada de uma área fechada para o lado de fora de uma figura passa por um segmento de linha no sentido horário, a contagem é incrementada. Quando a linha passa por um segmento de linha no sentido anti-horário, a contagem é reduzida. A área será preenchida se a contagem for diferente de zero quando a linha atingir o exterior da figura.

Quando um aplicativo terminar de usar uma região criada com a função CreatePolygonRgn, ele deverá selecionar a região fora do contexto do dispositivo e usar a função DeleteObject para removê-la.

Exemplo

CRgn   rgnA, rgnB;

CPoint ptVertex[5];

ptVertex[0].x = 180;
ptVertex[0].y = 80;
ptVertex[1].x = 100;
ptVertex[1].y = 160;
ptVertex[2].x = 120;
ptVertex[2].y = 260;
ptVertex[3].x = 240;
ptVertex[3].y = 260;
ptVertex[4].x = 260;
ptVertex[4].y = 160;

VERIFY(rgnA.CreatePolygonRgn(ptVertex, 5, ALTERNATE));

CRect rectRgnBox;
int nRgnBoxResult = rgnA.GetRgnBox(&rectRgnBox);
ASSERT(nRgnBoxResult != ERROR && nRgnBoxResult != NULLREGION);

CBrush brA, brB;
VERIFY(brA.CreateSolidBrush(RGB(255, 0, 0)));  // rgnA Red
VERIFY(pDC->FrameRgn(&rgnA, &brA, 2, 2));
VERIFY(brB.CreateSolidBrush(RGB(0, 0, 255)));  // Blue
rectRgnBox.InflateRect(3, 3);
pDC->FrameRect(&rectRgnBox, &brB);

CRgn::CreatePolyPolygonRgn

Cria uma região composta por uma série de polígonos fechados.

BOOL CreatePolyPolygonRgn(
    LPPOINT lpPoints,
    LPINT lpPolyCounts,
    int nCount,
    int nPolyFillMode);

Parâmetros

lpPoints
Aponta para uma matriz de estruturas POINT ou para uma matriz de objetos CPoint que define os vértices dos polígonos. Cada polígono deve ser fechado explicitamente porque o sistema não os fecha automaticamente. Os polígonos são especificados consecutivamente. A estrutura POINT tem a seguinte forma:

typedef struct tagPOINT {
    int x;
    int y;
} POINT;

lpPolyCounts
Aponta para uma matriz de inteiros. O primeiro inteiro especifica o número de vértices no primeiro polígono na matriz lpPoints, o segundo inteiro especifica o número de vértices no segundo polígono e assim por diante.

nCount
Especifica o número total de inteiros na matriz lpPolyCounts.

nPolyFillMode
Especifica o modo de preenchimento do polígono. Esse valor pode ser ALTERNATE ou WINDING.

Valor de retorno

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

Comentários

A região resultante é armazenada no objeto CRgn.

Os polígonos podem ser desarticulados ou podem se sobrepor.

O tamanho de uma região é limitado a 32.767 por 32.767 unidades lógicas ou 64K de memória, o que for menor.

Quando o modo de preenchimento de polígono é ALTERNATE, o sistema preenche a área entre lados de com numeração ímpar e numeração par do polígono em cada linha de verificação. Ou seja, o sistema preenche a área entre o primeiro e o segundo lados, entre o terceiro e o quarto lados e assim por diante.

Quando o modo de preenchimento de polígono é WINDING, o sistema usa a direção na qual uma figura foi desenhada para determinar se uma área deve ser preenchida. Cada segmento de linha em um polígono é desenhado no sentido horário ou no sentido anti-horário. Sempre que uma linha imaginária desenhada de uma área fechada para o lado de fora de uma figura passa por um segmento de linha no sentido horário, a contagem é incrementada. Quando a linha passa por um segmento de linha no sentido anti-horário, a contagem é reduzida. A área será preenchida se a contagem for diferente de zero quando a linha atingir o exterior da figura.

Quando um aplicativo terminar de usar uma região criada com a função CreatePolyPolygonRgn, ele deverá selecionar a região fora do contexto do dispositivo e usar a função membro CGDIObject::DeleteObject para removê-la.

CRgn::CreateRectRgn

Cria uma região retangular armazenada no objeto CRgn.

BOOL CreateRectRgn(
    int x1,
    int y1,
    int x2,
    int y2);

Parâmetros

x1
Especifica a coordenada x lógica do canto superior esquerdo da região.

y1
Especifica a coordenada y lógica do canto superior esquerdo da região.

x2
Especifica a coordenada x lógica do canto inferior direito da região.

y2
Especifica a coordenada y lógica do canto inferior direito da região.

Valor de retorno

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

Comentários

O tamanho de uma região é limitado a 32.767 por 32.767 unidades lógicas ou 64K de memória, o que for menor.

Quando terminar de usar uma região criada por CreateRectRgn, um aplicativo deverá usar a função membro CGDIObject::DeleteObject para remover a região.

Exemplo

CRgn   rgn;

BOOL bSucceeded = rgn.CreateRectRgn(50, 20, 150, 120);
ASSERT(bSucceeded == TRUE);

Para obter um exemplo adicional, consulte CRgn::CombineRgn.

CRgn::CreateRectRgnIndirect

Cria uma região retangular armazenada no objeto CRgn.

BOOL CreateRectRgnIndirect(LPCRECT lpRect);

Parâmetros

lpRect
Aponta para uma estrutura RECT ou para um objeto CRect que contém as coordenadas lógicas dos cantos superior esquerdo e inferior direito da região. A estrutura RECT tem a seguinte forma:

typedef struct tagRECT {
    int left;
    int top;
    int right;
    int bottom;
} RECT;

Valor de retorno

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

Comentários

O tamanho de uma região é limitado a 32.767 por 32.767 unidades lógicas ou 64K de memória, o que for menor.

Quando terminar de usar uma região criada por CreateRectRgnIndirect, um aplicativo deverá usar a função membro CGDIObject::DeleteObject para remover a região.

Exemplo

CRgn   rgnA, rgnB, rgnC;

CRect rectA(50, 50, 150, 150);
CRect rectB(100, 50, 200, 150);

VERIFY(rgnA.CreateRectRgnIndirect(&rectA));
VERIFY(rgnB.CreateEllipticRgnIndirect(&rectB));
VERIFY(rgnC.CreateRectRgn( 0, 0, 50, 50 ));

int nCombineResult = rgnC.CombineRgn( &rgnA, &rgnB, RGN_AND );
ASSERT( nCombineResult != ERROR && nCombineResult != NULLREGION );

CBrush brA, brB, brC;
VERIFY(brA.CreateSolidBrush( RGB(255, 0, 0) ));  
VERIFY(pDC->FrameRgn( &rgnA, &brA, 2, 2 ));      // rgnA Red

VERIFY(brB.CreateSolidBrush( RGB(0, 255, 0) ));  
VERIFY(pDC->FrameRgn( &rgnB, &brB, 2, 2 ));      // rgnB Green
VERIFY(brC.CreateSolidBrush( RGB(0, 0, 255) ));  // rgnC Blue
VERIFY(pDC->FrameRgn( &rgnC, &brC, 2, 2 ));

CRgn::CreateRoundRectRgn

Cria uma região retangular com cantos arredondados armazenados no objeto CRgn.

BOOL CreateRoundRectRgn(
    int x1,
    int y1,
    int x2,
    int y2,
    int x3,
    int y3);

Parâmetros

x1
Especifica a coordenada x lógica do canto superior esquerdo da região.

y1
Especifica a coordenada y lógica do canto superior esquerdo da região.

x2
Especifica a coordenada x lógica do canto inferior direito da região.

y2
Especifica a coordenada y lógica do canto inferior direito da região.

x3
Especifica a largura da elipse usada para criar os cantos arredondados.

y3
Especifica a altura da elipse usada para criar os cantos arredondados.

Valor de retorno

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

Comentários

O tamanho de uma região é limitado a 32.767 por 32.767 unidades lógicas ou 64K de memória, o que for menor.

Quando um aplicativo terminar de usar uma região criada com a função CreateRoundRectRgn, ele deverá selecionar a região fora do contexto do dispositivo e usar a função membro CGDIObject::DeleteObject para removê-la.

Exemplo

CRgn   rgnA, rgnB, rgnC;

VERIFY(rgnA.CreateRoundRectRgn( 50, 50, 150, 150, 30, 30 ));
VERIFY(rgnB.CreateRoundRectRgn( 200, 75, 250, 125, 50, 50 ));
VERIFY(rgnC.CreateRectRgn( 0, 0, 50, 50 ));

int nCombineResult = rgnC.CombineRgn( &rgnA, &rgnB, RGN_OR );
ASSERT( nCombineResult != ERROR && nCombineResult != NULLREGION );

CBrush brA, brB, brC;
VERIFY(brA.CreateSolidBrush( RGB(255, 0, 0) ));  
VERIFY(pDC->FillRgn( &rgnA, &brA));      // rgnA Red Filled

VERIFY(brB.CreateSolidBrush( RGB(0, 255, 0) ));  
VERIFY(pDC->FillRgn( &rgnB, &brB));      // rgnB Green Filled
VERIFY(brC.CreateSolidBrush( RGB(0, 0, 255) ));  // rgnC Blue
VERIFY(pDC->FrameRgn( &rgnC, &brC, 2, 2 ));

CRgn::CRgn

Constrói um objeto CRgn.

CRgn();

Comentários

O membro de dados m_hObject não contém uma região de GDI do Windows válida até que o objeto seja inicializado com uma ou mais das outras funções membro CRgn.

Exemplo

Consulte o exemplo de CRgn::CreateRoundRectRgn.

CRgn::EqualRgn

Determina se a região fornecida é equivalente à região armazenada no objeto CRgn.

BOOL EqualRgn(CRgn* pRgn) const;

Parâmetros

pRgn
Identifica uma região.

Valor de retorno

Diferente de zero se as duas regiões forem equivalentes; caso contrário, 0.

Exemplo

CRgn   rgnA, rgnB;

VERIFY(rgnA.CreateEllipticRgn(200, 100, 350, 250));
VERIFY(rgnB.CreateRectRgn(0, 0, 50, 50));
VERIFY(rgnB.CopyRgn(&rgnA));
int nOffsetResult = rgnB.OffsetRgn(-75, 75);
ASSERT(nOffsetResult != ERROR && nOffsetResult != NULLREGION);
ASSERT(FALSE == rgnB.EqualRgn(&rgnA));

CRgn::FromHandle

Retorna um ponteiro para um objeto CRgn quando recebe um identificador de uma região do Windows.

static CRgn* PASCAL FromHandle(HRGN hRgn);

Parâmetros

hRgn
Especifica um identificador para uma região do Windows.

Valor de retorno

Um ponteiro para um objeto CRgn. Se a função não tiver sido bem-sucedida, o valor retornado será NULL.

Comentários

Se um objeto CRgn não estiver anexado ao identificador, um objeto temporário CRgn será criado e anexado. Esse objeto temporário CRgn é válido somente até a próxima vez que o aplicativo tiver tempo ocioso em seu loop de eventos, momento em que todos os objetos gráficos temporários são excluídos. Outra maneira de dizer isso é que o objeto temporário é válido somente durante o processamento de uma mensagem de janela.

CRgn::GetRegionData

Preenche o buffer especificado com dados que descrevem a região.

int GetRegionData(
    LPRGNDATA lpRgnData,
    int nCount) const;

Parâmetros

lpRgnData
Aponta para uma estrutura de dados RGNDATA que recebe as informações. Se esse parâmetro for NULL, o valor retornado conterá o número de bytes necessários para os dados da região.

nCount
Especifica o tamanho, em bytes, do buffer lpRgnData.

Valor de retorno

Se a função for bem-sucedida e nCount especificar um número adequado de bytes, o valor retornado sempre será nCount. Se a função falhar ou se nCount especificar um número menor do que o número adequado de bytes, o valor retornado será 0 (erro).

Comentários

Esses dados incluem as dimensões dos retângulos que compõem a região. Essa função é usada em conjunto com a função CRgn::CreateFromData.

CRgn::GetRgnBox

Recupera as coordenadas do retângulo delimitador do objeto CRgn.

int GetRgnBox(LPRECT lpRect) const;

Parâmetros

lpRect
Aponta para uma estrutura RECT ou para um objeto CRect para receber as coordenadas do retângulo delimitador. A estrutura RECT tem a seguinte forma:

typedef struct tagRECT {
    int left;
    int top;
    int right;
    int bottom;
} RECT;

Valor de retorno

Especifica o tipo da região. Pode ser qualquer um dos seguintes valores:

• COMPLEXREGION A região tem bordas sobrepostas.

• NULLREGION A região está vazia.

• ERROR O objeto CRgn não especifica uma região válida.

• SIMPLEREGION A região não tem bordas sobrepostas.

Exemplo

Consulte o exemplo de CRgn::CreatePolygonRgn.

CRgn::OffsetRgn

Move a região armazenada no objeto CRgn segundo os deslocamentos especificados.

int OffsetRgn(
    int x,
    int y);

int OffsetRgn(POINT point);

Parâmetros

x
Especifica o número de unidades a serem movidas para a esquerda ou para a direita.

y
Especifica o número de unidades a serem movidas para cima ou para baixo.

ponto
A coordenada x de point especifica o número de unidades a mover para a esquerda ou para a direita. A coordenada y de point especifica o número de unidades a mover para cima ou para baixo. O parâmetro point pode ser uma estrutura POINT ou um objeto CPoint.

Valor de retorno

O tipo da nova região. Pode ser qualquer um dos seguintes valores:

• COMPLEXREGION A região tem bordas sobrepostas.

• ERRO O identificador de região não é válido.

• NULLREGION A região está vazia.

• SIMPLEREGION A região não tem bordas sobrepostas.

Comentários

A função move a região x unidades ao longo do eixo x e y unidades ao longo do eixo y.

Os valores de coordenada de uma região devem ser menores ou iguais a 32.767 e maiores ou iguais a -32.768. Os parâmetros x e y precisam ser escolhidos cuidadosamente para evitar coordenadas de região inválidas.

Exemplo

Consulte o exemplo de CRgn::CreateEllipticRgn.

CRgn::operator HRGN

Use esse operador para obter o identificador GDI do Windows anexado do objeto CRgn.

operator HRGN() const;

Valor de retorno

Se tiver êxito, um identificador para o objeto GDI do Windows representado pelo objeto CRgn; caso contrário, NULL.

Comentários

Esse é um operador de conversão que dá suporte ao uso direto de um objeto HRGN.

Para obter mais informações sobre como usar objetos gráficos, confira o artigo Objetos Gráficos no SDK do Windows.

CRgn::P tInRegion

Verifica se o ponto fornecido por x e y está na região armazenada no objeto CRgn.

BOOL PtInRegion(
    int x,
    int y) const;

BOOL PtInRegion(POINT point) const;

Parâmetros

x
Especifica a coordenada x lógica do ponto a ser testado.

y
Especifica a coordenada y lógica do ponto a ser testado.

ponto
As coordenadas x e y de point especificam as coordenadas x e y do ponto cujo valor deve ser testado. O parâmetro point pode ser uma estrutura POINT ou um objeto CPoint.

Valor de retorno

Diferente de zero se o ponto estiver na região; caso contrário, 0.

CRgn::RectInRegion

Determina se alguma parte do retângulo especificado por lpRect está dentro dos limites da região armazenada no objeto CRgn.

BOOL RectInRegion(LPCRECT lpRect) const;

Parâmetros

lpRect
Aponta para uma estrutura RECT ou um objeto CRect. A estrutura RECT tem a seguinte forma:

typedef struct tagRECT {
    int left;
    int top;
    int right;
    int bottom;
} RECT;

Valor de retorno

Diferente de zero se alguma parte do retângulo especificado estiver dentro dos limites da região; caso contrário, 0.

CRgn::SetRectRgn

Cria uma região retangular.

void SetRectRgn(
    int x1,
    int y1,
    int x2,
    int y2);

void SetRectRgn(LPCRECT lpRect);

Parâmetros

x1
Especifica a coordenada x do canto superior esquerdo da região retangular.

y1
Especifica a coordenada y do canto superior esquerdo da região retangular.

x2
Especifica a coordenada x do canto inferior direito da região retangular.

y2
Especifica a coordenada y do canto inferior direito da região retangular.

lpRect
Especifica a região retangular. Pode ser um ponteiro para uma estrutura RECT ou um objeto CRect.

Comentários

Diferente de CreateRectRgn, no entanto, ele não aloca nenhuma memória adicional do heap de aplicativos do Windows local. Em vez disso, ele usa o espaço alocado para a região armazenada no objeto CRgn. Isso significa que o objeto CRgn precisa ter sido inicializado com uma região válida do Windows antes de chamar SetRectRgn. Os pontos fornecidos por x1, y1, x2 e y2 especificam o tamanho mínimo do espaço alocado.

Use essa função em vez da função membro CreateRectRgn para evitar chamadas ao gerenciador de memória local.

Confira também

Classe CWnd
Gráfico da hierarquia