Classe `CBrush`

Articolo
10/12/2023

Incapsula un pennello GDI (Graphics Device Interface) di Windows.

Sintassi

class CBrush : public CGdiObject

Membri

Costruttori pubblici

Nome	Descrizione
`CBrush::CBrush`	Costruisce un oggetto `CBrush`.

Metodi pubblici

Nome	Descrizione
`CBrush::CreateBrushIndirect`	Inizializza un pennello con lo stile, il colore e il motivo specificati in una `LOGBRUSH` struttura.
`CBrush::CreateDIBPatternBrush`	Inizializza un pennello con un modello specificato da una bitmap indipendente dal dispositivo (DIB).
`CBrush::CreateHatchBrush`	Inizializza un pennello con il motivo e il colore tratteggi specificati.
`CBrush::CreatePatternBrush`	Inizializza un pennello con un modello specificato da una bitmap.
`CBrush::CreateSolidBrush`	Inizializza un pennello con il colore a tinta unita specificato.
`CBrush::CreateSysColorBrush`	Crea un pennello che rappresenta il colore di sistema predefinito.
`CBrush::FromHandle`	Restituisce un puntatore a un `CBrush` oggetto quando viene assegnato un handle a un oggetto Windows `HBRUSH` .
`CBrush::GetLogBrush`	Ottiene una `LOGBRUSH` struttura.

Operatori pubblici

Nome	Descrizione
`CBrush::operator HBRUSH`	Restituisce l'handle di Windows associato all'oggetto `CBrush` .

Osservazioni:

Per usare un CBrush oggetto , costruire un CBrush oggetto e passarlo a qualsiasi CDC funzione membro che richiede un pennello.

I pennelli possono essere solidi, tratteggi o modelli.

Per altre informazioni su CBrush, vedere Oggetti grafici.

Gerarchia di ereditarietà

CObject

CGdiObject

CBrush

Requisiti

Intestazione: afxwin.h

`CBrush::CBrush`

Costruisce un oggetto CBrush.

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

Parametri

crColor
Specifica il colore di primo piano del pennello come colore RGB. Se il pennello è tratteggio, questo parametro specifica il colore del tratteggio.

nIndex
Specifica lo stile del tratteggio del pennello. Può essere uno dei valori seguenti:

HS_BDIAGONAL Tratteggio verso il basso (da sinistra a destra) a 45 gradi
HS_CROSS Crosshatch orizzontale e verticale
HS_DIAGCROSS Crosshatch a 45 gradi
HS_FDIAGONAL Tratteggio verso l'alto (da sinistra a destra) a 45 gradi
HS_HORIZONTAL Tratteggio orizzontale
HS_VERTICAL Tratteggio verticale

pBitmap
Punta a un CBitmap oggetto che specifica una bitmap con cui il pennello disegna.

Osservazioni:

CBrush dispone di quattro costruttori di overload. Il costruttore senza argomenti costruisce un oggetto non inizializzato CBrush che deve essere inizializzato prima di poterlo utilizzare.

Se si usa il costruttore senza argomenti, è necessario inizializzare l'oggetto risultante CBrush con CreateSolidBrush, CreateHatchBrushCreateBrushIndirect, CreatePatternBrush, o CreateDIBPatternBrush. Se si utilizza uno dei costruttori che accettano argomenti, non è necessaria un'ulteriore inizializzazione. I costruttori con argomenti possono generare un'eccezione se vengono rilevati errori, mentre il costruttore senza argomenti avrà sempre esito positivo.

Il costruttore con un singolo COLORREF parametro costruisce un pennello a tinta unita con il colore specificato. Il colore specifica un valore RGB e può essere costruito con la RGB macro in WINDOWS.H.

Il costruttore con due parametri costruisce un pennello di tratteggio. Il nIndex parametro specifica l'indice di un modello tratteggio. Il crColor parametro specifica il colore.

Il costruttore con un CBitmap parametro costruisce un pennello con pattern. Il parametro identifica una bitmap. Si presuppone che la bitmap sia stata creata usando CBitmap::CreateBitmap, CBitmap::CreateBitmapIndirectCBitmap::LoadBitmap, o CBitmap::CreateCompatibleBitmap. La dimensione minima per una bitmap da usare in un motivo di riempimento è di 8 pixel di 8 pixel.

Esempio

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

Inizializza un pennello con uno stile, un colore e un motivo specificati in una LOGBRUSH struttura.

BOOL CreateBrushIndirect(const LOGBRUSH* lpLogBrush);

Parametri

lpLogBrush
Punta a una LOGBRUSH struttura che contiene informazioni sul pennello.

Valore restituito

Diverso da zero se la funzione ha esito positivo; in caso contrario, 0.

Osservazioni:

Successivamente, il pennello può essere selezionato come pennello corrente per qualsiasi contesto di dispositivo.

Un pennello creato usando una bitmap monocromatica (1 piano, 1 bit per pixel) viene disegnata usando il testo e i colori di sfondo correnti. I pixel rappresentati da un bit impostato su 0 verranno disegnati con il colore del testo corrente. I pixel rappresentati da un bit impostato su 1 verranno disegnati con il colore di sfondo corrente.

Esempio

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

Inizializza un pennello con il modello specificato da una bitmap indipendente dal dispositivo (DIB).

BOOL CreateDIBPatternBrush(
    HGLOBAL hPackedDIB,
    UINT nUsage);

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

Parametri

hPackedDIB
Identifica un oggetto global-memory contenente una bitmap indipendente dal dispositivo (DIB) compressa.

nUsage
Specifica se i bmiColors[] campi della struttura di BITMAPINFO dati (una parte del "DIB compresso") contengono valori RGB espliciti o indici nella tavolozza logica attualmente realizzata. Il parametro deve essere uno dei valori seguenti:

DIB_PAL_COLORS La tabella dei colori è costituita da una matrice di indici a 16 bit.
DIB_RGB_COLORS La tabella dei colori contiene valori RGB letterali.

lpPackedDIB
Punta a un DIB compresso costituito da una struttura immediatamente seguita da una BITMAPINFO matrice di byte che definisce i pixel della bitmap.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Osservazioni:

Il pennello può essere selezionato successivamente per qualsiasi contesto di dispositivo che supporta operazioni raster.

Le due versioni differiscono nel modo in cui si gestisce il DIB:

Nella prima versione, per ottenere un handle al DIB chiamare la funzione windows GlobalAlloc per allocare un blocco di memoria globale e quindi riempire la memoria con il diB compresso.
Nella seconda versione non è necessario chiamare GlobalAlloc per allocare memoria per il diB compresso.

Un DIB compresso è costituito da una BITMAPINFO struttura di dati immediatamente seguita dalla matrice di byte che definisce i pixel della bitmap. Le bitmap usate come motivi di riempimento devono essere di 8 pixel per 8 pixel. Se la bitmap è più grande, Windows crea un motivo di riempimento usando solo i bit corrispondenti alle prime 8 righe e 8 colonne di pixel nell'angolo superiore sinistro della bitmap.

Quando un'applicazione seleziona un pennello modello DIB a due colori in un contesto di dispositivo monocromatico, Windows ignora i colori specificati nel DIB e visualizza invece il pennello del motivo usando il testo corrente e i colori di sfondo del contesto di dispositivo. I pixel mappati al primo colore (in corrispondenza dell'offset 0 nella tabella dei colori DIB) del DIB vengono visualizzati utilizzando il colore del testo. I pixel mappati al secondo colore (in corrispondenza dell'offset 1 nella tabella dei colori) vengono visualizzati usando il colore di sfondo.

Per informazioni sull'uso delle funzioni di Windows seguenti, vedere Windows SDK:

CreateDIBPatternBrush Questa funzione viene fornita solo per compatibilità con le applicazioni scritte per le versioni di Windows precedenti alla 3.0. Usare la CreateDIBPatternBrushPt funzione .
CreateDIBPatternBrushPt Questa funzione deve essere usata per le applicazioni basate su Win32.
GlobalAlloc

Esempio

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

Inizializza un pennello con il motivo e il colore tratteggi specificati.

BOOL CreateHatchBrush(
    int nIndex,
    COLORREF crColor);

Parametri

nIndex
Specifica lo stile del tratteggio del pennello. Può essere uno dei valori seguenti:

HS_BDIAGONAL Tratteggio verso il basso (da sinistra a destra) a 45 gradi
HS_CROSS Crosshatch orizzontale e verticale
HS_DIAGCROSS Crosshatch a 45 gradi
HS_FDIAGONAL Tratteggio verso l'alto (da sinistra a destra) a 45 gradi
HS_HORIZONTAL Tratteggio orizzontale
HS_VERTICAL Tratteggio verticale

crColor
Specifica il colore di primo piano del pennello come colore RGB (il colore dei tratteggi). Per altre informazioni, vedere COLORREF in Windows SDK.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Osservazioni:

Successivamente, il pennello può essere selezionato come pennello corrente per qualsiasi contesto di dispositivo.

Esempio

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`

Inizializza un pennello con un modello specificato da una bitmap.

BOOL CreatePatternBrush(CBitmap* pBitmap);

Parametri

pBitmap
Identifica una bitmap.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Osservazioni:

Il pennello può essere selezionato successivamente per qualsiasi contesto di dispositivo che supporta operazioni raster. La bitmap identificata da pBitmap viene in genere inizializzata usando la CBitmap::CreateBitmapfunzione , CBitmap::LoadBitmapCBitmap::CreateBitmapIndirect, o CBitmap::CreateCompatibleBitmap .

Le bitmap usate come motivi di riempimento devono essere di 8 pixel per 8 pixel. Se la bitmap è più grande, Windows userà solo i bit corrispondenti alle prime 8 righe e alle colonne di pixel nell'angolo superiore sinistro della bitmap.

Un pennello modello può essere eliminato senza influire sulla bitmap associata. Ciò significa che la bitmap può essere usata per creare un numero qualsiasi di pennelli di motivo.

Un pennello creato usando una bitmap monocromatica (1 piano di colore, 1 bit per pixel) viene disegnato usando il testo e i colori di sfondo correnti. I pixel rappresentati da un bit impostato su 0 vengono disegnati con il colore del testo corrente. I pixel rappresentati da un bit impostato su 1 vengono disegnati con il colore di sfondo corrente.

Per informazioni sull'uso CreatePatternBrushdi , una funzione di Windows, vedere Windows SDK.

Esempio

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

Inizializza un pennello con un colore a tinta unita specificato.

BOOL CreateSolidBrush(COLORREF crColor);

Parametri

crColor
Struttura COLORREF che specifica il colore del pennello. Il colore specifica un valore RGB e può essere costruito con la RGB macro in WINDOWS.H.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Osservazioni:

Successivamente, il pennello può essere selezionato come pennello corrente per qualsiasi contesto di dispositivo.

Al termine dell'uso del pennello creato da CreateSolidBrush, un'applicazione deve selezionare il pennello dal contesto di dispositivo.

Esempio

Vedere l'esempio per CBrush::CBrush.

`CBrush::CreateSysColorBrush`

Inizializza un colore del pennello.

BOOL CreateSysColorBrush(int nIndex);

Parametri

nIndex
Specifica un indice di colore. Questo valore corrisponde al colore utilizzato per disegnare uno degli elementi della finestra 21. Per un elenco di valori, vedere GetSysColor in Windows SDK.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Osservazioni:

Successivamente, il pennello può essere selezionato come pennello corrente per qualsiasi contesto di dispositivo.

Al termine dell'uso del pennello creato da CreateSysColorBrush, un'applicazione deve selezionare il pennello dal contesto di dispositivo.

Esempio

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

Restituisce un puntatore a un CBrush oggetto quando viene assegnato un handle a un oggetto Windows HBRUSH .

static CBrush* PASCAL FromHandle(HBRUSH hBrush);

Parametri

hBrush
HANDLE in un pennello GDI di Windows.

Valore restituito

Puntatore a un CBrush oggetto se ha esito positivo; in caso contrario NULL, .

Osservazioni:

Se un CBrush oggetto non è già collegato all'handle, viene creato e collegato un oggetto temporaneo CBrush . Questo oggetto temporaneo CBrush è valido solo fino alla successiva inattività dell'applicazione nel ciclo di eventi. Al momento, tutti gli oggetti grafici temporanei vengono eliminati. In altre parole, l'oggetto temporaneo è valido solo durante l'elaborazione di un messaggio di finestra.

Per altre informazioni sull'uso di oggetti grafici, vedere Oggetti grafici in Windows SDK.

Esempio

Vedere l'esempio per CBrush::CBrush.

`CBrush::GetLogBrush`

Chiamare questa funzione membro per recuperare la LOGBRUSH struttura.

int GetLogBrush(LOGBRUSH* pLogBrush);

Parametri

pLogBrush
Punta a una LOGBRUSH struttura che contiene informazioni sul pennello.

Valore restituito

Se la funzione ha esito positivo ed pLogBrush è un puntatore valido, il valore restituito corrisponde al numero di byte archiviati nel buffer.

Se la funzione ha esito positivo e pLogBrush è NULL, il valore restituito è il numero di byte necessari per contenere le informazioni che la funzione archivierebbe nel buffer.

Se la funzione ha esito negativo, il valore restituito è 0.

Osservazioni:

La LOGBRUSH struttura definisce lo stile, il colore e il motivo di un pennello.

Ad esempio, chiamare GetLogBrush per trovare la corrispondenza con il colore o il motivo specifico di una bitmap.

Esempio

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

Utilizzare questo operatore per ottenere l'handle GDI di Windows collegato dell'oggetto CBrush .

operator HBRUSH() const;

Valore restituito

In caso di esito positivo, un handle per l'oggetto GDI di Windows rappresentato dall'oggetto CBrush ; in caso contrario NULL, .

Osservazioni:

Questo operatore è un operatore di cast che supporta l'uso diretto di un HBRUSH oggetto .

Per altre informazioni sull'uso di oggetti grafici, vedere Oggetti grafici in Windows SDK.

Esempio

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

Vedi anche

Esempio MFC PROPDLG
CGdiObject Classe
Grafico della gerarchia
CBitmap Classe
CDC Classe

Condividi tramite

Classe CBrush

Sintassi

Membri

Costruttori pubblici

Metodi pubblici

Operatori pubblici

Osservazioni:

Gerarchia di ereditarietà

Requisiti

CBrush::CBrush

Parametri

Osservazioni:

Esempio

CBrush::CreateBrushIndirect

Parametri

Valore restituito

Osservazioni:

Esempio

CBrush::CreateDIBPatternBrush

Parametri

Valore restituito

Osservazioni:

Esempio

CBrush::CreateHatchBrush

Parametri

Valore restituito

Osservazioni:

Esempio

CBrush::CreatePatternBrush

Parametri

Valore restituito

Osservazioni:

Esempio

CBrush::CreateSolidBrush

Parametri

Valore restituito

Osservazioni:

Esempio

CBrush::CreateSysColorBrush

Parametri

Valore restituito

Osservazioni:

Esempio

CBrush::FromHandle

Parametri

Valore restituito

Osservazioni:

Esempio

CBrush::GetLogBrush

Parametri

Valore restituito

Osservazioni:

Esempio

CBrush::operator HBRUSH

Valore restituito

Osservazioni:

Esempio

Vedi anche

Commenti e suggerimenti

Risorse aggiuntive

Classe `CBrush`

`CBrush::CBrush`

`CBrush::CreateBrushIndirect`

`CBrush::CreateDIBPatternBrush`

`CBrush::CreateHatchBrush`

`CBrush::CreatePatternBrush`

`CBrush::CreateSolidBrush`

`CBrush::CreateSysColorBrush`

`CBrush::FromHandle`

`CBrush::GetLogBrush`

`CBrush::operator HBRUSH`