Condividi tramite

Classe CStatic

  • Articolo

Fornisce la funzionalità di un controllo statico di Windows.

Sintassi

class CStatic : public CWnd

Membri

Costruttori pubblici

Nome Descrizione
CStatic::CStatic Costruisce un oggetto CStatic.

Metodi pubblici

Nome Descrizione
CStatic::Create Crea il controllo statico di Windows e lo collega all'oggetto CStatic .
CStatic::DrawItem Eseguire l'override per disegnare un controllo statico disegnato dal proprietario.
CStatic::GetBitmap Recupera l'handle della bitmap impostata in precedenza con SetBitmap.
CStatic::GetCursor Recupera l'handle dell'immagine del cursore impostata in precedenza con SetCursor.
CStatic::GetEnhMetaFile Recupera l'handle del metafile avanzato impostato in precedenza con SetEnhMetaFile.
CStatic::GetIcon Recupera l'handle dell'icona impostata in precedenza con SetIcon.
CStatic::SetBitmap Specifica una bitmap da visualizzare nel controllo statico.
CStatic::SetCursor Specifica un'immagine del cursore da visualizzare nel controllo statico.
CStatic::SetEnhMetaFile Specifica un metafile avanzato da visualizzare nel controllo statico.
CStatic::SetIcon Specifica un'icona da visualizzare nel controllo statico.

Osservazioni:

Un controllo statico visualizza una stringa di testo, una casella, un rettangolo, un'icona, un cursore, una bitmap o un metafile avanzato. Può essere usato per etichettare, box o separare altri controlli. Un controllo statico normalmente non accetta input e non fornisce alcun output; tuttavia, può notificare al padre i clic del mouse se viene creato con SS_NOTIFY stile.

Creare un controllo statico in due passaggi. Prima di tutto, chiamare il costruttore per costruire l'oggetto CStatic , quindi chiamare la Create funzione membro per creare il controllo statico e collegarlo all'oggetto CStatic .

Se si crea un CStatic oggetto all'interno di una finestra di dialogo (tramite una risorsa di dialogo), l'oggetto CStatic viene eliminato automaticamente quando l'utente chiude la finestra di dialogo.

Se si crea un CStatic oggetto all'interno di una finestra, potrebbe essere necessario eliminarlo definitivamente. Un CStatic oggetto creato nello stack all'interno di una finestra viene eliminato automaticamente. Se si crea l'oggetto nell'heap CStatic usando la new funzione , è necessario chiamare delete sull'oggetto per eliminarlo al termine dell'operazione.

Gerarchia di ereditarietà

CObject

CCmdTarget

CWnd

CStatic

Requisiti

Intestazione:afxwin.h

CStatic::Create

Crea il controllo statico di Windows e lo collega all'oggetto CStatic .

virtual BOOL Create(
    LPCTSTR lpszText,
    DWORD dwStyle,
    const RECT& rect,
    CWnd* pParentWnd,
    UINT nID = 0xffff);

Parametri

lpszText
Specifica il testo da inserire nel controllo . Se NULL, non sarà visibile alcun testo.

dwStyle
Specifica lo stile della finestra del controllo statico. Applicare qualsiasi combinazione di stili di controllo statici al controllo.

rect
Specifica la posizione e le dimensioni del controllo statico. Può essere una RECT struttura o un CRect oggetto .

pParentWnd
Specifica la CStatic finestra padre, in genere un CDialog oggetto . Non deve essere NULL.

nID
Specifica l'ID di controllo del controllo statico.

Valore restituito

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

Osservazioni:

Costruire un CStatic oggetto in due passaggi. Prima di tutto, chiamare il costruttore CStatice quindi chiamare Create, che crea il controllo statico di Windows e lo collega all'oggetto CStatic .

Applicare gli stili di finestra seguenti a un controllo statico:

  • WS_CHILD Sempre

  • WS_VISIBLE Solito

  • WS_DISABLED Raramente

Se si intende visualizzare una bitmap, un cursore, un'icona o un metafile nel controllo statico, è necessario applicare uno degli stili statici seguenti:

  • SS_BITMAP Usa questo stile per le bitmap.

  • SS_ICON Usa questo stile per cursori e icone.

  • SS_ENHMETAFILE Usa questo stile per i metafile avanzati.

Per i cursori, le bitmap o le icone, è anche possibile usare lo stile seguente:

  • SS_CENTERIMAGE Usare per centrare l'immagine nel controllo statico.

Esempio

// This code can be placed in OnInitDialog
CStatic myStatic;

// Create a child static control that centers its text horizontally.
myStatic.Create(_T("my static"), WS_CHILD | WS_VISIBLE | SS_CENTER,
                CRect(10, 10, 150, 50), pParentWnd);

CStatic::CStatic

Costruisce un oggetto CStatic.

CStatic();

Esempio

// Create a static object on the stack.
CStatic myStatic;

// Create a static object on the heap.
CStatic *pmyStatic = new CStatic;

CStatic::DrawItem

Chiamato dal framework per disegnare un controllo statico disegnato dal proprietario.

virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);

Parametri

lpDrawItemStruct
Puntatore a una DRAWITEMSTRUCT struttura. La struttura contiene informazioni sull'elemento da disegnare e sul tipo di disegno richiesto.

Osservazioni:

Eseguire l'override di questa funzione per implementare il disegno per un oggetto disegnato dal CStatic proprietario (il controllo ha lo stile SS_OWNERDRAW).

CStatic::GetBitmap

Ottiene l'handle della bitmap, impostata in precedenza con SetBitmap, associata a CStatic.

HBITMAP GetBitmap() const;

Valore restituito

Handle per la bitmap corrente o NULL se non è stata impostata alcuna bitmap.

Esempio

// Code such as this could be placed in the OnInitDialog callback.
// It creates two bitmap static controls on the heap, using members
// _m_pCStatic_A and _m_pCStatic_B to identify them so that they can
// be destroyed when no longer needed.

  CBitmap CBmp;
  CImage CImg;

  // Create a child bitmap static control and load it from a CBitmap object.
  _m_pCStatic_A = new CStatic;
  _m_pCStatic_A->Create(_T("A bitmap static control (A)"), 
      WS_CHILD|WS_BORDER|WS_VISIBLE|SS_BITMAP|SS_CENTERIMAGE, CRect(16,16,64,64),
      pParentWnd);
  CBmp.LoadOEMBitmap(OBM_CLOSE);  // Loads one of the default Windows bitmaps
  _m_pCStatic_A->SetBitmap( HBITMAP(CBmp) );
  _m_pCStatic_A->ShowWindow( SW_SHOW );

  // Create a child bitmap static control and load it from a CImage object.
  _m_pCStatic_B = new CStatic;
  _m_pCStatic_B->Create(_T("A bitmap static control (B)"), 
      WS_CHILD|WS_BORDER|WS_VISIBLE|SS_BITMAP|SS_CENTERIMAGE, CRect(90,16,138,64),
      pParentWnd);
  CImg.Load( _T("test.png") );
  if( _m_pCStatic_B->GetBitmap( ) == NULL )
    _m_pCStatic_B->SetBitmap( HBITMAP(CImg) );

  /* Then, later: 
   delete( _m_pCStatic_A );
   delete( _m_pCStatic_B );
   */

CStatic::GetCursor

Ottiene l'handle del cursore, impostato in precedenza con SetCursor, associato a CStatic.

HCURSOR GetCursor();

Valore restituito

Handle per il cursore corrente o NULL se non è stato impostato alcun cursore.

Esempio

CStatic myStatic;

// Create a child icon static control.
myStatic.Create(_T("my static"),
                WS_CHILD | WS_VISIBLE | SS_ICON | SS_CENTERIMAGE, CRect(10, 10, 150, 50),
                pParentWnd);

// If no image is defined for the static control, define the image
// to the system arrow and question mark cursor.
if (myStatic.GetCursor() == NULL)
   myStatic.SetCursor(::LoadCursor(NULL, IDC_HELP));

CStatic::GetEnhMetaFile

Ottiene l'handle del metafile avanzato, impostato in precedenza con SetEnhMetafile, associato a CStatic.

HENHMETAFILE GetEnhMetaFile() const;

Valore restituito

Handle per il metafile avanzato corrente o NULL se non è stato impostato alcun metafile avanzato.

Esempio

CStatic myStatic;

// Create a child enhanced metafile static control.
myStatic.Create(_T("my static"),
                WS_CHILD | WS_VISIBLE | SS_ENHMETAFILE | SS_CENTERIMAGE,
                CRect(10, 10, 150, 50), pParentWnd);

// If no image is defined for the static control, define the image
// to be "myemf.emf."
if (myStatic.GetEnhMetaFile() == NULL)
   myStatic.SetEnhMetaFile(::GetEnhMetaFile(_T("myemf.emf")));

CStatic::GetIcon

Ottiene l'handle dell'icona, impostato in precedenza con SetIcon, associato a CStatic.

HICON GetIcon() const;

Valore restituito

Handle per l'icona corrente o NULL se non è stata impostata alcuna icona.

Esempio

CStatic myStatic;

// Create a child icon static control.
myStatic.Create(_T("my static"),
                WS_CHILD | WS_VISIBLE | SS_ICON | SS_CENTERIMAGE, CRect(10, 10, 150, 50),
                pParentWnd);

// If no icon is defined for the static control, define the icon
// to the system error icon.
if (myStatic.GetIcon() == NULL)
   myStatic.SetIcon(::LoadIcon(NULL, IDI_ERROR));

CStatic::SetBitmap

Associa una nuova bitmap al controllo statico.

HBITMAP SetBitmap(HBITMAP hBitmap);

Parametri

hBitmap
Handle della bitmap da disegnare nel controllo statico.

Valore restituito

Handle della bitmap precedentemente associata al controllo statico o NULL se non è stata associata alcuna bitmap al controllo statico.

Osservazioni:

La bitmap verrà disegnata automaticamente nel controllo statico. Per impostazione predefinita, verrà disegnato nell'angolo superiore sinistro e il controllo statico verrà ridimensionato in base alle dimensioni della bitmap.

È possibile usare vari stili di controllo statici e finestra, tra cui:

  • SS_BITMAP Usa sempre questo stile per le bitmap.

  • SS_CENTERIMAGE Usare per centrare l'immagine nel controllo statico. Se l'immagine è più grande del controllo statico, verrà ritagliata. Se è inferiore al controllo statico, lo spazio vuoto intorno all'immagine verrà riempito dal colore del pixel nell'angolo superiore sinistro della bitmap.

  • MFC fornisce la classe CBitmap, che è possibile usare quando è necessario eseguire altre operazioni con un'immagine bitmap che semplicemente chiamare la funzione LoadBitmapWin32 . CBitmap, che contiene un tipo di oggetto GDI, viene spesso usato in collaborazione con CStatic, che è una CWnd classe utilizzata per visualizzare un oggetto grafico come controllo statico.

CImage è una classe ATL/MFC che consente di lavorare più facilmente con bitmap indipendenti dal dispositivo (DIB). Per altre informazioni, vedere CImage Classe.

  • L'utilizzo tipico consiste nell'assegnare CStatic::SetBitmap un oggetto GDI restituito dall'operatore HBITMAP di un CBitmap oggetto o CImage . Il codice per eseguire questa operazione è simile alla riga seguente.
MyStaticControl.SetBitmap(HBITMAP(MyBitmap));

Nell'esempio seguente vengono creati due CStatic oggetti nell'heap. Carica quindi una con una bitmap di sistema usando CBitmap::LoadOEMBitmap e l'altra da un file usando CImage::Load.

Esempio

// Code such as this could be placed in the OnInitDialog callback.
// It creates two bitmap static controls on the heap, using members
// _m_pCStatic_A and _m_pCStatic_B to identify them so that they can
// be destroyed when no longer needed.

  CBitmap CBmp;
  CImage CImg;

  // Create a child bitmap static control and load it from a CBitmap object.
  _m_pCStatic_A = new CStatic;
  _m_pCStatic_A->Create(_T("A bitmap static control (A)"), 
      WS_CHILD|WS_BORDER|WS_VISIBLE|SS_BITMAP|SS_CENTERIMAGE, CRect(16,16,64,64),
      pParentWnd);
  CBmp.LoadOEMBitmap(OBM_CLOSE);  // Loads one of the default Windows bitmaps
  _m_pCStatic_A->SetBitmap( HBITMAP(CBmp) );
  _m_pCStatic_A->ShowWindow( SW_SHOW );

  // Create a child bitmap static control and load it from a CImage object.
  _m_pCStatic_B = new CStatic;
  _m_pCStatic_B->Create(_T("A bitmap static control (B)"), 
      WS_CHILD|WS_BORDER|WS_VISIBLE|SS_BITMAP|SS_CENTERIMAGE, CRect(90,16,138,64),
      pParentWnd);
  CImg.Load( _T("test.png") );
  if( _m_pCStatic_B->GetBitmap( ) == NULL )
    _m_pCStatic_B->SetBitmap( HBITMAP(CImg) );

  /* Then, later: 
   delete( _m_pCStatic_A );
   delete( _m_pCStatic_B );
   */

CStatic::SetCursor

Associa una nuova immagine di cursore al controllo statico.

HCURSOR SetCursor(HCURSOR hCursor);

Parametri

hCursor
Handle del cursore da disegnare nel controllo statico.

Valore restituito

Handle del cursore precedentemente associato al controllo statico o NULL se non è stato associato alcun cursore al controllo statico.

Osservazioni:

Il cursore verrà disegnato automaticamente nel controllo statico. Per impostazione predefinita, verrà disegnato nell'angolo superiore sinistro e il controllo statico verrà ridimensionato in base alle dimensioni del cursore.

È possibile usare vari stili di controllo statici e finestra, tra cui:

  • SS_ICON Usa sempre questo stile per cursori e icone.

  • SS_CENTERIMAGE Usare per allineare al centro il controllo statico. Se l'immagine è più grande del controllo statico, verrà ritagliata. Se è inferiore al controllo statico, lo spazio vuoto intorno all'immagine verrà riempito con il colore di sfondo del controllo statico.

Esempio

CStatic myStatic;

// Create a child icon static control.
myStatic.Create(_T("my static"),
                WS_CHILD | WS_VISIBLE | SS_ICON | SS_CENTERIMAGE, CRect(10, 10, 150, 50),
                pParentWnd);

// If no image is defined for the static control, define the image
// to the system arrow and question mark cursor.
if (myStatic.GetCursor() == NULL)
   myStatic.SetCursor(::LoadCursor(NULL, IDC_HELP));

CStatic::SetEnhMetaFile

Associa una nuova immagine metafile avanzata al controllo statico.

HENHMETAFILE SetEnhMetaFile(HENHMETAFILE hMetaFile);

Parametri

hMetaFile
Handle del metafile avanzato da disegnare nel controllo statico.

Valore restituito

Handle del metafile avanzato precedentemente associato al controllo statico o NULL se al controllo statico non è stato associato alcun metafile avanzato.

Osservazioni:

Il metafile avanzato verrà disegnato automaticamente nel controllo statico. Il metafile avanzato viene ridimensionato in base alle dimensioni del controllo statico.

È possibile usare vari stili di controllo statici e finestra, tra cui:

  • SS_ENHMETAFILE Usa questo stile sempre per i metafile avanzati.

Esempio

CStatic myStatic;

// Create a child enhanced metafile static control.
myStatic.Create(_T("my static"),
                WS_CHILD | WS_VISIBLE | SS_ENHMETAFILE | SS_CENTERIMAGE,
                CRect(10, 10, 150, 50), pParentWnd);

// If no image is defined for the static control, define the image
// to be "myemf.emf."
if (myStatic.GetEnhMetaFile() == NULL)
   myStatic.SetEnhMetaFile(::GetEnhMetaFile(_T("myemf.emf")));

CStatic::SetIcon

Associa una nuova immagine icona al controllo statico.

HICON SetIcon(HICON hIcon);

Parametri

hIcon
Handle dell'icona da disegnare nel controllo statico.

Valore restituito

Handle dell'icona precedentemente associata al controllo statico o NULL se nessuna icona è stata associata al controllo statico.

Osservazioni:

L'icona verrà disegnata automaticamente nel controllo statico. Per impostazione predefinita, verrà disegnato nell'angolo superiore sinistro e il controllo statico verrà ridimensionato in base alle dimensioni dell'icona.

È possibile usare vari stili di controllo statici e finestra, tra cui:

  • SS_ICON Usa sempre questo stile per cursori e icone.

  • SS_CENTERIMAGE Usare per allineare al centro il controllo statico. Se l'immagine è più grande del controllo statico, verrà ritagliata. Se è inferiore al controllo statico, lo spazio vuoto intorno all'immagine verrà riempito con il colore di sfondo del controllo statico.

Esempio

CStatic myStatic;

// Create a child icon static control.
myStatic.Create(_T("my static"),
                WS_CHILD | WS_VISIBLE | SS_ICON | SS_CENTERIMAGE, CRect(10, 10, 150, 50),
                pParentWnd);

// If no icon is defined for the static control, define the icon
// to the system error icon.
if (myStatic.GetIcon() == NULL)
   myStatic.SetIcon(::LoadIcon(NULL, IDI_ERROR));

Vedi anche

CWnd Classe
Grafico della gerarchia
CWnd Classe
CButton Classe
CComboBox Classe
CEdit Classe
CListBox Classe
CScrollBar Classe
CDialog Classe