Classe CRgn

Encapsula uma região GDI (interface de dispositivo gráfico) do Windows.

Sintaxe

class CRgn : public CGdiObject

Membros

Construtores Públicos

Métodos Públicos

Operadores Públicos

Observações

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

As funções de membro de CRgn criar, alterar e recuperar informações sobre o objeto de região para o qual são chamadas.

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

Hierarquia de herança

CObject

CGdiObject

CRgn

Requerimentos

Cabeçalho: afxwin.h

CRgn::CombineRgn

Cria uma nova região 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 Utiliza áreas sobrepostas de ambas as regiões (intersecção).

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

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

• RGN_OR Combina ambas as regiões na sua totalidade (união).

• RGN_XOR Combina ambas as regiões, mas elimina áreas sobrepostas.

Valor de retorno

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

• COMPLEXREGION Nova região tem fronteiras sobrepostas.

• ERRO Nenhuma nova região criada.

• NULLREGION Nova região está vazia.

• SIMPLEREGION Nova região não tem fronteiras sobrepostas.

Observações

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

As duas regiões especificadas são combinadas e o identificador de região resultante é armazenado no CRgn objeto. Assim, qualquer região armazenada no CRgn objeto é 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 simplesmente 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 CRgn objeto.

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 Nova região tem fronteiras sobrepostas.

• ERRO Nenhuma nova região criada.

• NULLREGION Nova região está vazia.

• SIMPLEREGION Nova região não tem fronteiras sobrepostas.

Observações

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

Exemplo

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

Observações

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

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 CreateEllipticRgn função, um aplicativo deve selecionar a região fora do contexto do dispositivo e usar a DeleteObject função 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 RECT estrutura ou um CRect objeto 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.

Observações

A região é definida pela estrutura ou objeto apontado por lpRect e é armazenado no CRgn objeto.

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 CreateEllipticRgnIndirect função, um aplicativo deve selecionar a região fora do contexto do dispositivo e usar a DeleteObject função para removê-la.

Exemplo

Consulte o exemplo de CRgn::CreateRectRgnIndirect.

CRgn::CreateFromData

Cria uma região a partir de determinada região e dados de transformação.

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.

nContagem
Especifica o número de bytes apontados por pRgnData.

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.

Observações

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

CRgn::CreateFromPath

Cria uma região a partir do caminho selecionado para o contexto de determinado dispositivo.

BOOL CreateFromPath(CDC* pDC);

Parâmetros

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

Valor de retorno

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

Observações

O contexto do dispositivo identificado pelo parâmetro pDC deve conter um caminho fechado. Depois CreateFromPath de converter um caminho em uma região, o Windows descarta o caminho fechado do contexto do dispositivo.

CRgn::CreatePolygonRgn

Cria uma região poligonal.

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

Parâmetros

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

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

nContagem
Especifica o número de POINT estruturas ou CPoint objetos na matriz apontados por lpPoints.

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

Valor de retorno

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

Observações

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

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ígonos é ALTERNATIVO, o sistema preenche a área entre os lados do polígono ímpar e par em cada linha de varredura. Ou seja, o sistema preenche a área entre o primeiro e o segundo lado, entre o terceiro e o quarto lado, e assim por diante.

Quando o modo de enchimento de polígonos é WINDING, o sistema usa a direção em que 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 anti-horário. Sempre que uma linha imaginária desenhada de uma área fechada para o exterior de uma figura passa por um segmento de linha no sentido horário, uma contagem é incrementada. Quando a linha passa por um segmento de linha no sentido anti-horário, a contagem é diminuída. A área é preenchida se a contagem for diferente de zero quando a linha atingir a parte externa da figura.

Quando um aplicativo terminar de usar uma região criada com a CreatePolygonRgn função, ele deve selecionar a região fora do contexto do dispositivo e usar a DeleteObject função 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::CreatePolygonPolygonRgn

Cria uma região que consiste em uma série de polígonos fechados.

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

Parâmetros

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

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

lpPolyCounts
Aponta para uma matriz de números 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.

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

nPolyFillMode
Especifica o modo de preenchimento de polígonos. Este valor pode ser ALTERNATE ou WINDING.

Valor de retorno

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

Observações

A região resultante é armazenada no CRgn objeto.

Os polígonos podem estar disjuntos, ou podem sobrepor-se.

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ígonos é ALTERNATIVO, o sistema preenche a área entre os lados do polígono ímpar e par em cada linha de varredura. Ou seja, o sistema preenche a área entre o primeiro e o segundo lado, entre o terceiro e o quarto lado, e assim por diante.

Quando o modo de enchimento de polígonos é WINDING, o sistema usa a direção em que 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 anti-horário. Sempre que uma linha imaginária desenhada de uma área fechada para o exterior de uma figura passa por um segmento de linha no sentido horário, uma contagem é incrementada. Quando a linha passa por um segmento de linha no sentido anti-horário, a contagem é diminuída. A área é preenchida se a contagem for diferente de zero quando a linha atingir a parte externa da figura.

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

CRgn::CreateRectRgn

Cria uma região retangular que é armazenada no CRgn objeto.

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.

Observações

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 pelo CreateRectRgn, um aplicativo deverá usar a função de membro CGDIObject::D eleteObject 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 que é armazenada no CRgn objeto.

BOOL CreateRectRgnIndirect(LPCRECT lpRect);

Parâmetros

lpRect
Aponta para uma RECT estrutura ou CRect objeto que contém as coordenadas lógicas dos cantos superior esquerdo e inferior direito da região. A RECT estrutura 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.

Observações

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 pelo CreateRectRgnIndirect, um aplicativo deverá usar a função de membro CGDIObject::D eleteObject 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 que é armazenada no CRgn objeto.

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.

Observações

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 CreateRoundRectRgn função, ele deve selecionar a região fora do contexto do dispositivo e usar a função de membro CGDIObject::D eleteObject 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();

Observações

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

Exemplo

Veja o exemplo de CRgn::CreateRoundRectRgn.

CRgn::EqualRgn

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

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 CRgn objeto quando recebe um identificador para 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 CRgn objeto. Se a função não foi bem-sucedida, o valor de retorno é NULL.

Observações

Se um CRgn objeto ainda não estiver anexado à alça, 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 serão excluídos. Outra maneira de dizer isso é que o objeto temporário só é válido 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 de retorno conterá o número de bytes necessários para os dados da região.

nContagem
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 de retorno será sempre nCount. Se a função falhar ou se nCount especificar um número inferior ao número adequado de bytes, o valor de retorno será 0 (erro).

Observações

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

CRgn::GetRgnBox

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

int GetRgnBox(LPRECT lpRect) const;

Parâmetros

lpRect
Aponta para uma RECT estrutura ou CRect objeto para receber as coordenadas do retângulo delimitador. A RECT estrutura 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:

• A região COMPLEXREGION tem fronteiras sobrepostas.

• Região NULLREGION está vazia.

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

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

Exemplo

Veja o exemplo de CRgn::CreatePolygonRgn.

CRgn::OffsetRgn

Move a CRgn região armazenada no objeto pelos 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 do ponto especifica o número de unidades a serem movidas para a esquerda ou para a direita. A coordenada y do ponto especifica o número de unidades a serem movidas para cima ou para baixo. O parâmetro point pode ser uma POINT estrutura ou um CPoint objeto.

Valor de retorno

O novo tipo de região. Pode ser qualquer um dos seguintes valores:

• A região COMPLEXREGION tem fronteiras sobrepostas.

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

• Região NULLREGION está vazia.

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

Observações

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

Os valores de coordenadas 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 devem ser cuidadosamente escolhidos para evitar coordenadas de região inválidas.

Exemplo

Veja o exemplo de CRgn::CreateEllipticRgn.

CRgn::operador HRGN

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

operator HRGN() const;

Valor de retorno

Se for bem-sucedido, um identificador para o objeto GDI do Windows representado pelo CRgn objeto, caso contrário, NULL.

Observações

Este operador é um operador de fundição, que suporta o uso direto de um objeto HRGN.

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

CRgn::P tInRegion

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

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 do ponto especificam as coordenadas x e y do ponto para testar o valor de. O parâmetro point pode ser uma POINT estrutura ou um CPoint objeto.

Valor de retorno

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

CRgn::RectInRegion

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

BOOL RectInRegion(LPCRECT lpRect) const;

Parâmetros

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

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

Valor de retorno

Diferente de zero se qualquer 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 RECT estrutura ou um CRect objeto.

Observações

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

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

Ver também

CWnd Classe
Gráfico de Hierarquia