Classe `CBrush`

Artigo
10/12/2023

Encapsula um pincel GDI (Graphics Device Interface) do Windows.

Sintaxe

class CBrush : public CGdiObject

Membros

Construtores públicos

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

Métodos públicos

Nome	Descrição
`CBrush::CreateBrushIndirect`	Inicializa um pincel com o estilo, a cor e o padrão especificados em uma estrutura `LOGBRUSH`.
`CBrush::CreateDIBPatternBrush`	Inicializa um pincel com um padrão especificado por um DIB (bitmap independente do dispositivo).
`CBrush::CreateHatchBrush`	Inicializa um pincel com o padrão e a cor especificados.
`CBrush::CreatePatternBrush`	Inicializa um pincel com um padrão especificado por um bitmap.
`CBrush::CreateSolidBrush`	Inicializa um pincel com a cor sólida especificada.
`CBrush::CreateSysColorBrush`	Cria um pincel que é a cor padrão do sistema.
`CBrush::FromHandle`	Retorna um ponteiro para um objeto `CBrush` quando é determinado um identificador para um objeto `HBRUSH` do Windows.
`CBrush::GetLogBrush`	Obtém uma estrutura `LOGBRUSH`.

Operadores públicos

Nome	Descrição
`CBrush::operator HBRUSH`	Retorna o identificador do Windows anexado ao objeto `CBrush`.

Comentários

Para usar um objeto CBrush, construa um objeto CBrush e passe-o para qualquer função de membro CDC que exija um pincel.

Pincéis podem ser sólidos, hachurados ou padronizados.

Para obter mais informações sobre CBrush, confira Objetos Gráficos.

Hierarquia de herança

CObject

CGdiObject

CBrush

Requisitos

Cabeçalho: afxwin.h

`CBrush::CBrush`

Constrói um objeto CBrush.

CBrush();
CBrush(COLORREF crColor);
CBrush(int nIndex, COLORREF crColor);
explicit CBrush(CBitmap* pBitmap);

Parâmetros

crColor
Especifica a cor de primeiro plano do pincel como uma cor RGB. Se o pincel for hachurado, esse parâmetro especificará a cor da hachura.

nIndex
Especifica o estilo de hachura do pincel. Pode ser qualquer um dos seguintes valores:

HS_BDIAGONAL Hachura para baixo (da esquerda para a direita) a 45 graus
HS_CROSS Hachura cruzada horizontal e vertical
HS_DIAGCROSS Hachura cruzada a 45 graus
HS_FDIAGONAL Hachura para cima (da esquerda para a direita) a 45 graus
HS_HORIZONTAL Hachura horizontal
HS_VERTICAL Hachura vertical

pBitmap
Aponta para um objeto CBitmap que especifica um bitmap com o qual o pincel pinta.

Comentários

CBrush tem quatro construtores sobrecarregados. O construtor sem argumentos constrói um objeto CBrush não inicializado que deve ser inicializado antes de ser usado.

Se você usar o construtor sem argumentos, deverá inicializar o objeto resultante CBrush com CreateSolidBrush, CreateHatchBrush, CreateBrushIndirect, CreatePatternBrush ou CreateDIBPatternBrush. Se você usar um dos construtores que usa argumentos, nenhuma inicialização adicional será necessária. Os construtores com argumentos poderão gerar uma exceção se forem encontrados erros, enquanto o construtor sem argumentos sempre terá êxito.

O construtor com um só parâmetro COLORREF constrói um pincel sólido com a cor especificada. A cor especifica um valor RGB e pode ser construída com a macro RGB em WINDOWS.H.

O construtor com dois parâmetros constrói um pincel hachurado. O parâmetro nIndex especifica o índice de um padrão hachurado. O parâmetro crColor especifica a cor.

O construtor com um parâmetro CBitmap constrói um pincel com padrões. O parâmetro identifica um bitmap. Supõe-se que o bitmap tenha sido criado usando CBitmap::CreateBitmap, CBitmap::CreateBitmapIndirect, CBitmap::LoadBitmap ou CBitmap::CreateCompatibleBitmap. O tamanho mínimo para um bitmap a ser usado em um padrão de preenchimento é de 8 pixels por 8 pixels.

Exemplo

// CBrush::CBrush.
CBrush brush1;                           // Must initialize!
brush1.CreateSolidBrush(RGB(0, 0, 255)); // Blue brush.

CRect rc;
GetClientRect(&rc);
ScreenToClient(&rc);

// Save original brush.
CBrush *pOrigBrush = (CBrush *)pDC->SelectObject(&brush1);

// Paint upper left corner with blue brush.
pDC->Rectangle(0, 0, rc.Width() / 2, rc.Height() / 2);

// These constructors throw resource exceptions.
try
{
   // CBrush::CBrush(COLORREF crColor)
   CBrush brush2(RGB(255, 0, 0)); // Solid red brush.

   // CBrush::CBrush(int nIndex, COLORREF crColor)
   // Hatched green brush.
   CBrush brush3(HS_DIAGCROSS, RGB(0, 255, 0));

   // CBrush::CBrush(CBitmap* pBitmap)
   CBitmap bmp;
   // Load a resource bitmap.
   bmp.LoadBitmap(IDB_BRUSH);
   CBrush brush4(&bmp);

   pDC->SelectObject(&brush2);

   // Paint upper right corner with red brush.
   pDC->Rectangle(rc.Width() / 2, 0, rc.Width(),
                  rc.Height() / 2);

   pDC->SelectObject(&brush3);

   // Paint lower left corner with green hatched brush.
   pDC->Rectangle(0, rc.Height() / 2, rc.Width() / 2,
                  rc.Height());

   pDC->SelectObject(&brush4);

   // Paint lower right corner with resource brush.
   pDC->Rectangle(rc.Width() / 2, rc.Height() / 2,
                  rc.Width(), rc.Height());
}
catch (CResourceException *e)
{
   e->ReportError();
   e->Delete();
}

// Reselect original brush into device context.
pDC->SelectObject(pOrigBrush);

`CBrush::CreateBrushIndirect`

Inicializa um pincel com um estilo, cor e padrão especificados em uma estrutura LOGBRUSH.

BOOL CreateBrushIndirect(const LOGBRUSH* lpLogBrush);

Parâmetros

lpLogBrush
Aponta para uma estrutura LOGBRUSH que contém informações sobre o pincel.

Valor de retorno

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

Comentários

O pincel pode ser selecionado posteriormente como o pincel atual para qualquer contexto de dispositivo.

Um pincel criado usando um bitmap monocromático (1 plano, 1 bit por pixel) é desenhado usando o texto atual e as cores da tela de fundo. Pixels representados por um bit definido como 0 serão desenhados com a cor do texto atual. Pixels representados por um bit definido como 1 serão desenhados com a cor da tela de fundo atual.

Exemplo

// Initialize a LOGBRUSH structure.
LOGBRUSH logBrush;
logBrush.lbStyle = BS_HATCHED;
logBrush.lbColor = RGB(0, 192, 192);
logBrush.lbHatch = HS_CROSS;

// Declare an uninitialized CBrush ...
CBrush brush;
// ... and initialize it with the LOGBRUSH.
brush.CreateBrushIndirect(&logBrush);

// Select the brush (and perhaps a pen) into
// the device context.
CBrush *pOldBrush = (CBrush *)pDC->SelectObject(&brush);
CPen *pOldPen = (CPen *)pDC->SelectStockObject(BLACK_PEN);

// Have fun!
pDC->Pie(CRect(100, 100, 300, 300), CPoint(0, 0), CPoint(50, 200));

// Restore the original device context objects.
pDC->SelectObject(pOldBrush);
pDC->SelectObject(pOldPen);

`CBrush::CreateDIBPatternBrush`

Inicializa um pincel com o padrão especificado por um DIB (bitmap independente do dispositivo).

BOOL CreateDIBPatternBrush(
    HGLOBAL hPackedDIB,
    UINT nUsage);

BOOL CreateDIBPatternBrush(
    const void* lpPackedDIB,
    UINT nUsage);

Parâmetros

hPackedDIB
Identifica um objeto de memória global que contém um DIB (bitmap independente do dispositivo) empacotado.

nUsage
Especifica se os campos bmiColors[] da estrutura de dados BITMAPINFO (uma parte do "DIB empacotado") contêm valores ou índices RGB explícitos na paleta lógica atualmente realizada. O parâmetro deve ser um dos seguintes valores de :

DIB_PAL_COLORS A tabela de cores consiste em uma matriz de índices de 16 bits.
DIB_RGB_COLORS A tabela de cores contém valores RGB literais.

lpPackedDIB
Aponta para um DIB empacotado que consiste em uma estrutura BITMAPINFO imediatamente seguida por uma matriz de bytes definindo os pixels do bitmap.

Valor de retorno

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

O pincel pode ser selecionado posteriormente para qualquer contexto de dispositivo compatível com operações de varredura.

As duas versões diferem na maneira como você lida com o DIB:

Na primeira versão, para obter um identificador para o DIB, você chama a função GlobalAlloc do Windows para alocar um bloco de memória global e preencher a memória com o DIB empacotado.
Na segunda versão, não é necessário chamar GlobalAlloc para alocar memória para o DIB empacotado.

Um DIB empacotado consiste em uma estrutura de dados BITMAPINFO imediatamente seguida pela matriz de bytes que define os pixels do bitmap. Os bitmaps usados como padrões de preenchimento devem ser de 8 pixels por 8 pixels. Se o bitmap for maior, o Windows criará um padrão de preenchimento usando apenas os bits correspondentes às primeiras oito linhas e oito colunas de pixels no canto superior esquerdo do bitmap.

Quando um aplicativo seleciona um pincel de padrão DIB de duas cores em um contexto de dispositivo monocromático, o Windows ignora as cores especificadas no DIB e exibe o pincel de padrão usando o texto atual e as cores de tela de fundo do contexto do dispositivo. Pixels mapeados para a primeira cor (no deslocamento 0 na tabela de cores DIB) do DIB são exibidos usando a cor do texto. Pixels mapeados para a segunda cor (no deslocamento 1 na tabela de cores) são exibidos usando a cor da tela de fundo.

Para informações sobre como usar as seguintes funções do Windows, confira o SDK do Windows:

CreateDIBPatternBrush (Essa função é fornecida apenas para compatibilidade com aplicativos gravados para versões do Windows anteriores à 3.0; use a função CreateDIBPatternBrushPt.)
CreateDIBPatternBrushPt (Essa função deve ser usada para aplicativos baseados em Win32.)
GlobalAlloc

Exemplo

// Resource handle to bitmap.
HRSRC hRes;
// Global handles to bitmap resource.
HGLOBAL hData;
void *hLockedData;
CBrush brush;

// Find the resource handle.
hRes = ::FindResource(AfxGetResourceHandle(),
                      MAKEINTRESOURCE(IDB_BRUSH), RT_BITMAP);
if (hRes != NULL)
{
   // Lock and Load (or Load and Lock).
   if (((hData = ::LoadResource(AfxGetResourceHandle(),
                                hRes)) != NULL) &&
       ((hLockedData = ::LockResource(hData)) != NULL))
   {
      // Initialize the brush.
      brush.CreateDIBPatternBrush((const void *)hLockedData,
                                  DIB_RGB_COLORS);

      // Select the brush into the device context.
      CBrush *pOldBrush = pDC->SelectObject(&brush);

      // Draw.
      pDC->Rectangle(50, 50, 200, 200);

      // Restore the original device context.
      pDC->SelectObject(pOldBrush);

      // Free the resource.
      ::FreeResource(hLockedData);
   }
}

`CBrush::CreateHatchBrush`

Inicializa um pincel com o padrão e a cor especificados.

BOOL CreateHatchBrush(
    int nIndex,
    COLORREF crColor);

Parâmetros

nIndex
Especifica o estilo de hachura do pincel. Pode ser qualquer um dos seguintes valores:

HS_BDIAGONAL Hachura para baixo (da esquerda para a direita) a 45 graus
HS_CROSS Hachura cruzada horizontal e vertical
HS_DIAGCROSS Hachura cruzada a 45 graus
HS_FDIAGONAL Hachura para cima (da esquerda para a direita) a 45 graus
HS_HORIZONTAL Hachura horizontal
HS_VERTICAL Hachura vertical

crColor
Especifica a cor de primeiro plano do pincel como uma cor RGB (a cor das hachuras). Confira COLORREF no SDK do Windows para mais informações.

Valor de retorno

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

O pincel pode ser selecionado posteriormente como o pincel atual para qualquer contexto de dispositivo.

Exemplo

CBrush brush;
brush.CreateHatchBrush(HS_BDIAGONAL, RGB(255, 0, 0));

CBrush *pOldBrush;
CPen *pOldPen;

pOldBrush = (CBrush *)pDC->SelectObject(&brush);
pOldPen = (CPen *)pDC->SelectStockObject(NULL_PEN);
pDC->Ellipse(CRect(50, 50, 250, 250));

pDC->SelectObject(pOldBrush);
pDC->SelectObject(pOldPen);

`CBrush::CreatePatternBrush`

Inicializa um pincel com um padrão especificado por um bitmap.

BOOL CreatePatternBrush(CBitmap* pBitmap);

Parâmetros

pBitmap
Identifica um bitmap.

Valor de retorno

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

O pincel pode ser selecionado posteriormente para qualquer contexto de dispositivo compatível com operações de varredura. O bitmap identificado por pBitmap normalmente é inicializado usando a função CBitmap::CreateBitmap, CBitmap::CreateBitmapIndirect, CBitmap::LoadBitmap ou CBitmap::CreateCompatibleBitmap.

Os bitmaps usados como padrões de preenchimento devem ser de 8 pixels por 8 pixels. Se o bitmap for maior, o Windows usará apenas os bits correspondentes às oito primeiras linhas e colunas de pixels no canto superior esquerdo do bitmap.

Um pincel de padrão pode ser excluído sem afetar o bitmap associado. Isso significa que o bitmap pode ser usado para criar qualquer número de pincéis de padrão.

Um pincel criado usando um bitmap monocromático (plano de 1 cor, 1 bit por pixel) é desenhado usando o texto atual e as cores de tela de fundo. Os pixels representados por um bit definido como 0 são desenhados com a cor do texto atual. Pixels representados por um bit definido como 1 são desenhados com a cor da tela de fundo atual.

Para informações sobre como usar CreatePatternBrush, uma função do Windows, confira o SDK do Windows.

Exemplo

// Create a hatched bit pattern.
WORD HatchBits[8] = {0x11, 0x22, 0x44, 0x88, 0x11,
                     0x22, 0x44, 0x88};

// Use the bit pattern to create a bitmap.
CBitmap bm;
bm.CreateBitmap(8, 8, 1, 1, HatchBits);

// Create a pattern brush from the bitmap.
CBrush brush;
brush.CreatePatternBrush(&bm);

// Select the brush into a device context, and draw.
CBrush *pOldBrush = (CBrush *)pDC->SelectObject(&brush);
pDC->RoundRect(CRect(50, 50, 200, 200), CPoint(10, 10));

// Restore the original brush.
pDC->SelectObject(pOldBrush);

`CBrush::CreateSolidBrush`

Inicializa um pincel com uma cor sólida especificada.

BOOL CreateSolidBrush(COLORREF crColor);

Parâmetros

crColor
Uma estrutura COLORREF que especifica a cor do pincel. A cor especifica um valor RGB e pode ser construída com a macro RGB em WINDOWS.H.

Valor de retorno

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

O pincel pode ser selecionado posteriormente como o pincel atual para qualquer contexto de dispositivo.

Quando um aplicativo terminar de usar o pincel criado por CreateSolidBrush, ele deverá selecionar o pincel fora do contexto do dispositivo.

Exemplo

Confira o exemplo de CBrush::CBrush.

`CBrush::CreateSysColorBrush`

Inicializa uma cor de pincel.

BOOL CreateSysColorBrush(int nIndex);

Parâmetros

nIndex
Especifica um índice de cores. Esse valor corresponde à cor usada para pintar um dos 21 elementos de janela. Confira GetSysColor no SDK do Windows uma lista de valores.

Valor de retorno

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

O pincel pode ser selecionado posteriormente como o pincel atual para qualquer contexto de dispositivo.

Quando um aplicativo terminar de usar o pincel criado por CreateSysColorBrush, ele deverá selecionar o pincel fora do contexto do dispositivo.

Exemplo

// Declare a CBrush and initialize to a system color.
CBrush brush;
brush.CreateSysColorBrush(COLOR_BTNFACE);

// Select the brush into the device context.
CBrush *pOldBrush = (CBrush *)pDC->SelectObject(&brush);

// Draw.
CRect rect(50, 50, 150, 150);
pDC->Rectangle(rect);

// Reselect the original brush.
pDC->SelectObject(pOldBrush);

`CBrush::FromHandle`

Retorna um ponteiro para um objeto CBrush quando é determinado um identificador para um objeto HBRUSH do Windows.

static CBrush* PASCAL FromHandle(HBRUSH hBrush);

Parâmetros

hBrush
Identificador para um pincel GDI do Windows.

Valor de retorno

Um ponteiro para um objeto CBrush se tiver êxito; caso contrário, NULL.

Comentários

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

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

Exemplo

Confira o exemplo de CBrush::CBrush.

`CBrush::GetLogBrush`

Chame essa função de membro para recuperar a estrutura LOGBRUSH.

int GetLogBrush(LOGBRUSH* pLogBrush);

Parâmetros

pLogBrush
Aponta para uma estrutura LOGBRUSH que contém informações sobre o pincel.

Valor de retorno

Se a função for bem-sucedida e pLogBrush for um ponteiro válido, o valor retornado será o número de bytes armazenados no buffer.

Se a função tiver êxito e pLogBrush for NULL, o valor retornado será o número de bytes necessários para manter as informações que a função armazenaria no buffer.

Se a função falhar, o valor retornado será 0.

Comentários

A estrutura LOGBRUSH define o estilo, a cor e o padrão de um pincel.

Por exemplo, chame GetLogBrush para corresponder à cor ou padrão específico de um bitmap.

Exemplo

// Example for CBrush::GetLogBrush
LOGBRUSH logbrush;
brushExisting.GetLogBrush(&logbrush);
CBrush brushOther(logbrush.lbColor);

// Another example
// Declare a LOGBRUSH
LOGBRUSH logBrush;

// Using a bitmap for this example.
// The bitmap should be a project resource.
CBitmap bm;
bm.LoadBitmap(IDB_BRUSH);

try
{
   // Create a brush
   CBrush brush1(&bm);

   // Use GetLogBrush to fill the LOGBRUSH structure
   brush1.GetLogBrush(&logBrush);

   // Create a second brush using the LOGBRUSH data
   CBrush brush2;
   brush2.CreateBrushIndirect(&logBrush);

   // Use the first brush
   CBrush *pOldBrush = (CBrush *)pDC->SelectObject(&brush1);
   pDC->Rectangle(CRect(50, 50, 150, 150));

   // The second brush has the specified characteristics
   // of the first brush
   pDC->SelectObject(&brush2);
   pDC->Ellipse(200, 50, 300, 150);

   // Reselect the original brush
   pDC->SelectObject(pOldBrush);
}
catch (CResourceException *e)
{
   e->ReportError();
   e->Delete();
}

`CBrush::operator HBRUSH`

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

operator HBRUSH() const;

Valor de retorno

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

Comentários

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

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

Exemplo

RECT rc = {50, 50, 200, 200};

Rectangle(pDC->GetSafeHdc(), rc.left, rc.top, rc.right, rc.bottom);

// The Win32 call to FillRect requires an HBRUSH.
// The HBRUSH operator casts the CBrush object
// to the required type.
CBrush brush;
brush.CreateSysColorBrush(COLOR_BTNFACE);
FillRect(pDC->GetSafeHdc(), &rc, (HBRUSH)brush);

Confira também

Exemplo de MFC PROPDLG
Classe CGdiObject
Gráfico da hierarquia
Classe CBitmap
Classe CDC

Partilhar via

Classe CBrush

Sintaxe

Membros

Construtores públicos

Métodos públicos

Operadores públicos

Comentários

Hierarquia de herança

Requisitos

CBrush::CBrush

Parâmetros

Comentários

Exemplo

CBrush::CreateBrushIndirect

Parâmetros

Valor de retorno

Comentários

Exemplo

CBrush::CreateDIBPatternBrush

Parâmetros

Valor de retorno

Comentários

Exemplo

CBrush::CreateHatchBrush

Parâmetros

Valor de retorno

Comentários

Exemplo

CBrush::CreatePatternBrush

Parâmetros

Valor de retorno

Comentários

Exemplo

CBrush::CreateSolidBrush

Parâmetros

Valor de retorno

Comentários

Exemplo

CBrush::CreateSysColorBrush

Parâmetros

Valor de retorno

Comentários

Exemplo

CBrush::FromHandle

Parâmetros

Valor de retorno

Comentários

Exemplo

CBrush::GetLogBrush

Parâmetros

Valor de retorno

Comentários

Exemplo

CBrush::operator HBRUSH

Valor de retorno

Comentários

Exemplo

Confira também

Comentários

Recursos adicionais

Classe `CBrush`

`CBrush::CBrush`

`CBrush::CreateBrushIndirect`

`CBrush::CreateDIBPatternBrush`

`CBrush::CreateHatchBrush`

`CBrush::CreatePatternBrush`

`CBrush::CreateSolidBrush`

`CBrush::CreateSysColorBrush`

`CBrush::FromHandle`

`CBrush::GetLogBrush`

`CBrush::operator HBRUSH`