`CBrush` Classe

Observação

A biblioteca Microsoft Foundation Classes (MFC) continua a ser suportada. No entanto, já não estamos a adicionar funcionalidades nem a atualizar a documentação.

Encapsula um pincel de interface de dispositivo gráfico (GDI) do Windows.

Sintaxe

class CBrush : public CGdiObject

Membros

Construtores Públicos

Nome	Description
`CBrush::CBrush`	Constrói um `CBrush` objeto.

Métodos Públicos

Nome	Description
`CBrush::CreateBrushIndirect`	Inicializa um pincel com o estilo, cor e padrão especificados numa `LOGBRUSH` estrutura.
`CBrush::CreateDIBPatternBrush`	Inicializa um pincel com um padrão especificado por um bitmap independente do dispositivo (DIB).
`CBrush::CreateHatchBrush`	Inicializa um pincel com o padrão e a cor de hachuras 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`	Devolve um ponteiro para um `CBrush` objeto quando recebe um handle para um objeto Windows `HBRUSH` .
`CBrush::GetLogBrush`	Ganha uma `LOGBRUSH` estrutura.

Operadores Públicos

Nome	Description
`CBrush::operator HBRUSH`	Devolve a alavanca do Windows ligada ao `CBrush` objeto.

Observações

Para usar um CBrush objeto, constrói um CBrush objeto e passa-o a qualquer CDC função membro que precise de um pincel.

Os pincéis podem ser sólidos, com hachuras ou padrões.

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

Hierarquia de herança

CObject

CGdiObject

CBrush

Requerimentos

Cabeçalho:afxwin.h

`CBrush::CBrush`

Constrói um CBrush objeto.

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

Parâmetros

crColor
Especifica a cor em primeiro plano do pincel como uma cor RGB. Se o pincel for eclosionado, este parâmetro especifica a cor da hachura.

nIndex
Especifica o estilo de hatch da escova. Pode ser qualquer um dos seguintes valores:

HS_BDIAGONAL Escotilha descendente (da esquerda para a direita) a 45 graus
HS_CROSS Hachuras horizontais e verticais
HS_DIAGCROSS Hachura cruzada a 45 graus
HS_FDIAGONAL Escotilha ascendente (da esquerda para a direita) a 45 graus
HS_HORIZONTAL Escotilha horizontal
HS_VERTICAL Escotilha vertical

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

Observações

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

Se usar o construtor sem argumentos, deve inicializar o objeto resultante CBrush com CreateSolidBrush, CreateHatchBrush, CreateBrushIndirect, CreatePatternBrush, ou CreateDIBPatternBrush. Se usar um dos construtores que aceita argumentos, então não é necessária mais inicialização. Os construtores com argumentos podem lançar uma exceção se forem encontrados erros, enquanto o construtor sem argumentos terá sempre sucesso.

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

O construtor, com dois parâmetros, constrói uma escova de escotilha. O nIndex parâmetro especifica o índice de um padrão com hachas. O crColor parâmetro especifica a cor.

O construtor com um CBitmap parâmetro constrói um pincel padronizado. O parâmetro identifica um bitmap. Assume-se que o bitmap foi criado usando CBitmap::CreateBitmap, CBitmap::CreateBitmapIndirect, CBitmap::LoadBitmap, ou CBitmap::CreateCompatibleBitmap. O tamanho mínimo para um bitmap ser usado num padrão de preenchimento é de 8 pixels por 8 pixels.

Example

// 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 numa LOGBRUSH estrutura.

BOOL CreateBrushIndirect(const LOGBRUSH* lpLogBrush);

Parâmetros

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

Valor de retorno

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

Observações

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

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

Example

// 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 bitmap independente do dispositivo (DIB).

BOOL CreateDIBPatternBrush(
    HGLOBAL hPackedDIB,
    UINT nUsage);

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

Parâmetros

hPackedDIB
Identifica um objeto de memória global contendo um bitmap (DIB) independente do dispositivo empacotado.

nUsage
Especifica se os bmiColors[] campos da BITMAPINFO estrutura de dados (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:

DIB_PAL_COLORS A tabela de cores consiste num array de índices de 16 bits.
DIB_RGB_COLORS A tabela de cores contém valores RGB literais.

lpPackedDIB
Aponta para um DIB compacto composto por uma BITMAPINFO estrutura imediatamente seguida por um array de bytes que definem os píxeis do bitmap.

Valor de retorno

Não nulo se for bem-sucedido; caso contrário, 0.

Observações

O pincel pode ser posteriormente selecionado para qualquer contexto de dispositivo que suporte operações raster.

As duas versões diferem na forma como manuseia o DIB:

Na primeira versão, para obter um handle para o DIB chama-se a função Windows GlobalAlloc para alocar um bloco de memória global e depois preencher a memória com o DIB compactado.
Na segunda versão, não é necessário chamar GlobalAlloc para alocar memória para o DIB compactado.

Um DIB empacotado consiste numa BITMAPINFO estrutura de dados imediatamente seguida pelo array de bytes que define os píxeis do bitmap. Os bitmaps usados como padrões de preenchimento devem ter 8 pixels por 8 píxeis. Se o bitmap for maior, o Windows cria um padrão de preenchimento usando apenas os bits correspondentes às primeiras 8 linhas e 8 colunas de píxeis no canto superior esquerdo do bitmap.

Quando uma aplicação seleciona um pincel de padrão DIB de duas cores num contexto de dispositivo monocromático, o Windows ignora as cores especificadas no DIB e, em vez disso, apresenta o pincel do padrão usando o texto atual e as cores de fundo do contexto do dispositivo. Os píxeis mapeados para a primeira cor (no deslocamento 0 na tabela de cores do DIB) do DIB são exibidos usando a cor do texto. Os píxeis mapeados para a segunda cor (no deslocamento 1 na tabela de cores) são exibidos usando a cor de fundo.

Para informações sobre a utilização das seguintes funções do Windows, consulte o SDK do Windows:

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

Example

// 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 de hachuras especificados.

BOOL CreateHatchBrush(
    int nIndex,
    COLORREF crColor);

Parâmetros

nIndex
Especifica o estilo de hatch da escova. Pode ser qualquer um dos seguintes valores:

HS_BDIAGONAL Escotilha descendente (da esquerda para a direita) a 45 graus
HS_CROSS Hachuras horizontais e verticais
HS_DIAGCROSS Hachura cruzada a 45 graus
HS_FDIAGONAL Escotilha ascendente (da esquerda para a direita) a 45 graus
HS_HORIZONTAL Escotilha horizontal
HS_VERTICAL Escotilha vertical

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

Valor de retorno

Não nulo se for bem-sucedido; caso contrário, 0.

Observações

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

Example

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

Não nulo se for bem-sucedido; caso contrário, 0.

Observações

O pincel pode ser posteriormente selecionado para qualquer contexto de dispositivo que suporte operações raster. O bitmap identificado por pBitmap é tipicamente inicializado usando , CBitmap::CreateBitmapCBitmap::CreateBitmapIndirect, CBitmap::LoadBitmap, ou CBitmap::CreateCompatibleBitmap função.

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

Um pincel de padrão pode ser eliminado sem afetar o bitmap associado. Isto 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 (1 plano de cor, 1 bit por pixel) é desenhado usando o texto atual e as cores de fundo. Os píxeis representados por um bit definido para 0 são desenhados com a cor do texto atual. Os píxeis representados por um bit definido como 1 são desenhados com a cor de fundo atual.

Para informações sobre a utilização CreatePatternBrushde , uma função do Windows, consulte o SDK do Windows.

Example

// 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 que especifica COLORREF a cor do pincel. A cor especifica um valor RGB e pode ser construída com a RGB macro em WINDOWS.H.

Valor de retorno

Não nulo se for bem-sucedido; caso contrário, 0.

Observações

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

Quando uma aplicação termina de usar o pincel criado por CreateSolidBrush, deve selecionar o pincel fora do contexto do dispositivo.

Example

Veja o exemplo para CBrush::CBrush.

`CBrush::CreateSysColorBrush`

Inicializa uma cor de pincel.

BOOL CreateSysColorBrush(int nIndex);

Parâmetros

nIndex
Especifica um índice de cor. Este valor corresponde à cor usada para pintar um dos 21 elementos das janelas. Consulte GetSysColor no SDK do Windows para obter uma lista de valores.

Valor de retorno

Não nulo se for bem-sucedido; caso contrário, 0.

Observações

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

Quando uma aplicação termina de usar o pincel criado por CreateSysColorBrush, deve selecionar o pincel fora do contexto do dispositivo.

Example

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

Devolve um ponteiro para um CBrush objeto quando recebe um handle para um objeto Windows HBRUSH .

static CBrush* PASCAL FromHandle(HBRUSH hBrush);

Parâmetros

hBrush
HANDLE para uma escova Windows GDI.

Valor de retorno

Um ponteiro para um CBrush objeto, se bem-sucedido, caso contrário NULL.

Observações

Se um CBrush objeto não estiver já ligado à pega, um objeto temporário CBrush é criado e anexado. Este objeto temporário CBrush é válido apenas até à próxima vez que a aplicação tiver tempo inativo no seu ciclo de eventos. Neste momento, todos os objetos gráficos temporários são eliminados. Por outras palavras, o objeto temporário é válido apenas durante o processamento de uma mensagem de janela.

Para mais informações sobre o uso de objetos gráficos, consulte Objetos Gráficos no SDK do Windows.

Example

Veja o exemplo de CBrush::CBrush.

`CBrush::GetLogBrush`

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

int GetLogBrush(LOGBRUSH* pLogBrush);

Parâmetros

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

Valor de retorno

Se a função tiver sucesso e pLogBrush for um ponteiro válido, o valor de retorno é o número de bytes armazenados no buffer.

Se a função tiver sucesso, e pLogBrush for NULL, o valor de retorno é o número de bytes necessários para armazenar a informação que a função armazenaria no buffer.

Se a função falhar, o valor de retorno é 0.

Observações

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

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

Example

// 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 este operador para obter o handle Windows GDI associado do CBrush objeto.

operator HBRUSH() const;

Valor de retorno

Se for bem-sucedido, um handle para o objeto Windows GDI representado pelo CBrush objeto; caso contrário NULL.

Observações

Este operador é um operador de casting, que suporta o uso direto de um HBRUSH objeto.

Para mais informações sobre o uso de objetos gráficos, consulte Objetos Gráficos no SDK do Windows.

Example

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);

Consulte também

Exemplo MFC PROPDLG
CGdiObject Classe
Gráfico de Hierarquia
CBitmap Classe
CDC Classe

Comentários

Esta página foi útil?

Last updated on 2026-02-23

Partilhar via

CBrush Classe

Sintaxe

Membros

Construtores Públicos

Métodos Públicos

Operadores Públicos

Observações

Hierarquia de herança

Requerimentos

CBrush::CBrush

Parâmetros

Observações

Example

CBrush::CreateBrushIndirect

Parâmetros

Valor de retorno

Observações

Example

CBrush::CreateDIBPatternBrush

Parâmetros

Valor de retorno

Observações

Example

CBrush::CreateHatchBrush

Parâmetros

Valor de retorno

Observações

Example

CBrush::CreatePatternBrush

Parâmetros

Valor de retorno

Observações

Example

CBrush::CreateSolidBrush

Parâmetros

Valor de retorno

Observações

Example

CBrush::CreateSysColorBrush

Parâmetros

Valor de retorno

Observações

Example

CBrush::FromHandle

Parâmetros

Valor de retorno

Observações

Example

CBrush::GetLogBrush

Parâmetros

Valor de retorno

Observações

Example

CBrush::operator HBRUSH

Valor de retorno

Observações

Example

Consulte também

Comentários

Recursos adicionais

`CBrush` Classe

`CBrush::CBrush`

`CBrush::CreateBrushIndirect`

`CBrush::CreateDIBPatternBrush`

`CBrush::CreateHatchBrush`

`CBrush::CreatePatternBrush`

`CBrush::CreateSolidBrush`

`CBrush::CreateSysColorBrush`

`CBrush::FromHandle`

`CBrush::GetLogBrush`

`CBrush::operator HBRUSH`