Compartilhar via


Classe CStatic

Fornece a funcionalidade de um controle estático do Windows.

Sintaxe

class CStatic : public CWnd

Membros

Construtores públicos

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

Métodos públicos

Nome Descrição
CStatic::Create Cria o controle estático do Windows e o anexa ao objeto CStatic.
CStatic::DrawItem Substitua para desenhar um controle estático desenhado pelo proprietário.
CStatic::GetBitmap Recupera o identificador do bitmap definido anteriormente com SetBitmap.
CStatic::GetCursor Recupera o identificador da imagem do cursor definida anteriormente com SetCursor.
CStatic::GetEnhMetaFile Recupera o identificador do meta-arquivo aprimorado definido anteriormente com SetEnhMetaFile.
CStatic::GetIcon Recupera o identificador do ícone definido anteriormente com SetIcon.
CStatic::SetBitmap Especifica um bitmap a ser exibido no controle estático.
CStatic::SetCursor Especifica uma imagem de cursor a ser exibida no controle estático.
CStatic::SetEnhMetaFile Especifica um meta-arquivo aprimorado a ser exibido no controle estático.
CStatic::SetIcon Especifica um ícone a ser exibido no controle estático.

Comentários

Um controle estático exibe uma cadeia de caracteres de texto, caixa, retângulo, ícone, cursor, bitmap ou meta-arquivo aprimorado. Ele pode ser usado para etiquetar, encaixotar ou separar outros controles. Um controle estático normalmente não usa entrada e não fornece saída; no entanto, ele poderá notificar o pai dos cliques do mouse se ele for criado com o estilo SS_NOTIFY.

Crie um controle estático em duas etapas. Primeiro, chame o construtor para construir o objeto CStatic, então chame a função de membro Create para criar o controle estático e anexá-lo ao objeto CStatic.

Se você criar um objeto CStatic dentro de uma caixa de diálogo (por meio de um recurso de caixa de diálogo), o objeto CStatic será destruído automaticamente quando o usuário fechar a caixa de diálogo.

Se você criar um objeto CStatic dentro de uma janela, talvez também seja necessário destruí-lo. Um objeto CStatic criado na pilha dentro de uma janela é destruído automaticamente. Se você criar o objeto CStatic no heap usando a função new, deverá chamar delete no objeto para destruí-lo quando terminar de usá-lo.

Hierarquia de herança

CObject

CCmdTarget

CWnd

CStatic

Requisitos

Cabeçalho: afxwin.h

CStatic::Create

Cria o controle estático do Windows e o anexa ao objeto CStatic.

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

Parâmetros

lpszText
Especifica o texto a ser colocado no controle. Se NULL, nenhum texto ficará visível.

dwStyle
Especifica o estilo de janela do controle estático. Aplique qualquer combinação de estilos de controle estático ao controle.

rect
Especifica a posição e o tamanho do controle estático. Pode ser uma estrutura RECT ou um objeto CRect.

pParentWnd
Especifica a janela pai CStatic, geralmente um objeto CDialog. Não deve ser NULL.

nID
Especifica a ID de controle do controle estático.

Valor de retorno

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

Comentários

Construa um objeto CStatic em duas etapas. Primeiro chame o construtor CStatic, então chame Create, o que cria o controle estático do Windows e o anexa ao objeto CStatic.

Aplique os seguintes estilos de janela a um controle estático:

  • WS_CHILD Sempre

  • WS_VISIBLE Geralmente

  • WS_DISABLED Raramente

Se você for exibir um bitmap, cursor, ícone ou meta-arquivo no controle estático, será necessário aplicar um dos seguintes estilos estáticos:

  • SS_BITMAP Use esse estilo para bitmaps.

  • SS_ICON Use esse estilo para cursores e ícones.

  • SS_ENHMETAFILE Use esse estilo para meta-arquivos aprimorados.

Para cursores, bitmaps ou ícones, talvez você também queira usar o seguinte estilo:

  • SS_CENTERIMAGE Use para centralizar a imagem no controle estático.

Exemplo

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

Constrói um objeto CStatic.

CStatic();

Exemplo

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

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

CStatic::DrawItem

Chamado pela estrutura para desenhar um controle estático desenhado pelo proprietário.

virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);

Parâmetros

lpDrawItemStruct
Um ponteiro para uma estrutura DRAWITEMSTRUCT. A estrutura contém informações sobre o item a ser desenhado e o tipo de desenho necessário.

Comentários

Substitua essa função para implementar o desenho para um objeto CStatic desenhado pelo proprietário (o controle tem o estilo SS_OWNERDRAW).

CStatic::GetBitmap

Obtém o identificador do bitmap, definido anteriormente com SetBitmap, que está associado a CStatic.

HBITMAP GetBitmap() const;

Valor de retorno

Um identificador para o bitmap atual ou NULL, se nenhum bitmap tiver sido definido.

Exemplo

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

Obtém o identificador do cursor, definido anteriormente com SetCursor, que está associado a CStatic.

HCURSOR GetCursor();

Valor de retorno

Um identificador para o cursor atual ou NULL, se nenhum cursor tiver sido definido.

Exemplo

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

Obtém o identificador do meta-arquivo aprimorado, definido anteriormente com SetEnhMetafile, que está associado a CStatic.

HENHMETAFILE GetEnhMetaFile() const;

Valor de retorno

Um identificador para o meta-arquivo aprimorado atual ou NULL, se nenhum meta-arquivo aprimorado tiver sido definido.

Exemplo

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

Obtém o identificador do ícone, definido anteriormente com SetIcon, que está associado a CStatic.

HICON GetIcon() const;

Valor de retorno

Um identificador para o ícone atual ou NULL se nenhum ícone tiver sido definido.

Exemplo

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 um novo bitmap ao controle estático.

HBITMAP SetBitmap(HBITMAP hBitmap);

Parâmetros

hBitmap
Identificador do bitmap a ser desenhado no controle estático.

Valor de retorno

O identificador do bitmap que foi anteriormente associado ao controle estático ou NULL se nenhum bitmap tiver sido associado ao controle estático.

Comentários

O bitmap será desenhado automaticamente no controle estático. Por padrão, ele será desenhado no canto superior esquerdo e o controle estático será redimensionado para o tamanho do bitmap.

Você pode usar vários estilos de janela e controle estático, incluindo estes:

  • SS_BITMAP Use esse estilo sempre para bitmaps.

  • SS_CENTERIMAGE Use para centralizar a imagem no controle estático. Se a imagem for maior que o controle estático, ela será cortada. Se for menor que o controle estático, o espaço vazio ao redor da imagem será preenchido pela cor do pixel no canto superior esquerdo do bitmap.

  • O MFC fornece a classe CBitmap, que você pode usar quando precisa fazer mais com uma imagem bitmap do que apenas chamar a função Win32 LoadBitmap. CBitmap, que contém um tipo de objeto GDI, costuma ser usado em cooperação a CStatic, que é uma classe CWnd usada para exibir um objeto gráfico como um controle estático.

CImage é uma classe ATL/MFC que permite que você trabalhe mais facilmente com DIB (bitmaps independentes do dispositivo). Para obter mais informações, consulte CImage Classe.

  • O uso típico é fornecer a CStatic::SetBitmap um objeto GDI retornado pelo operador HBITMAP de um objeto CBitmap ou CImage. O código para fazer isso se assemelha à linha a seguir.
MyStaticControl.SetBitmap(HBITMAP(MyBitmap));

O exemplo a seguir cria dois objetos CStatic no heap. Então, ele carrega um com um bitmap do sistema usando CBitmap::LoadOEMBitmap e o outro de um arquivo usando CImage::Load.

Exemplo

// 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 uma nova imagem de cursor ao controle estático.

HCURSOR SetCursor(HCURSOR hCursor);

Parâmetros

hCursor
Manipule o cursor a ser desenhado no controle estático.

Valor de retorno

O identificador do cursor anteriormente associado ao controle estático ou NULL se nenhum cursor tiver sido associado ao controle estático.

Comentários

O cursor será desenhado automaticamente no controle estático. Por padrão, ele será desenhado no canto superior esquerdo e o controle estático será redimensionado para o tamanho do cursor.

Você pode usar vários estilos de controle estático e de janela, incluindo o seguinte:

  • SS_ICON Use esse estilo sempre para cursores e ícones.

  • SS_CENTERIMAGE Use para centralizar no controle estático. Se a imagem for maior que o controle estático, ela será cortada. Se for menor que o controle estático, o espaço vazio ao redor da imagem será preenchido com a cor da tela de fundo do controle estático.

Exemplo

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 uma nova imagem de meta-arquivo aprimorada ao controle estático.

HENHMETAFILE SetEnhMetaFile(HENHMETAFILE hMetaFile);

Parâmetros

hMetaFile
Manipular o meta-arquivo aprimorado a ser desenhado no controle estático.

Valor de retorno

O identificador do meta-arquivo aprimorado anteriormente associado ao controle estático ou NULL se nenhum meta-arquivo aprimorado tiver sido associado ao controle estático.

Comentários

O meta-arquivo aprimorado será desenhado automaticamente no controle estático. O meta-arquivo aprimorado é dimensionado para se ajustar ao tamanho do controle estático.

Você pode usar vários estilos de controle estático e de janela, incluindo o seguinte:

  • SS_ENHMETAFILE Use esse estilo sempre para meta-arquivos aprimorados.

Exemplo

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 uma nova imagem de ícone ao controle estático.

HICON SetIcon(HICON hIcon);

Parâmetros

hIcon
Manipular o ícone a ser desenhado no controle estático.

Valor de retorno

O identificador do ícone anteriormente associado ao controle estático ou NULL se nenhum ícone tiver sido associado ao controle estático.

Comentários

O ícone será desenhado automaticamente no controle estático. Por padrão, ele será desenhado no canto superior esquerdo e o controle estático será redimensionado para o tamanho do ícone.

Você pode usar vários estilos de controle estático e de janela, incluindo o seguinte:

  • SS_ICON Use esse estilo sempre para cursores e ícones.

  • SS_CENTERIMAGE Use para centralizar no controle estático. Se a imagem for maior que o controle estático, ela será cortada. Se for menor que o controle estático, o espaço vazio ao redor da imagem será preenchido com a cor da tela de fundo do controle estático.

Exemplo

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

Confira também

Classe CWnd
Gráfico da hierarquia
Classe CWnd
Classe CButton
Classe CComboBox
Classe CEdit
Classe CListBox
Classe CScrollBar
Classe CDialog