CMenu Classe

Uma encapsulação do Windows HMENU.

Sintaxe

class CMenu : public CObject

Membros

Construtores Públicos

Métodos Públicos

Operadores Públicos

Membros de Dados Públicos

Observações

Fornece funções aos membros para criar, rastrear, atualizar e destruir um menu.

Cria um CMenu objeto no frame da pilha como local, depois chama CMenuas funções membros de 's para manipular o novo menu conforme necessário. De seguida, chama CWnd::SetMenu para definir o menu para uma janela, seguida imediatamente por uma chamada para a CMenu função membro do Detach objeto. A CWnd::SetMenu função membro define o menu da janela para o novo menu, faz com que a janela seja redesenhada para refletir a alteração do menu e também passa a propriedade do menu para a janela. A chamada para Detach separar o HMENU do CMenu objeto, de modo que, quando a variável local CMenu sai do âmbito, o CMenu destruidor do objeto não tente destruir um menu que já não possui. O próprio menu é automaticamente destruído quando a janela é destruída.

Podes usar a LoadMenuIndirect função de membro para criar um menu a partir de um modelo na memória, mas um menu criado a partir de um recurso por uma chamada para LoadMenu é mais fácil de manter, e o próprio recurso do menu pode ser criado e modificado pelo editor de menus.

Hierarquia de herança

CObject

CMenu

Requerimentos

Cabeçalho:afxwin.h

CMenu::AppendMenu

Acrescenta um novo item ao final de um menu.

BOOL AppendMenu(
    UINT nFlags,
    UINT_PTR nIDNewItem = 0,
    LPCTSTR lpszNewItem = NULL);

BOOL AppendMenu(
    UINT nFlags,
    UINT_PTR nIDNewItem,
    const CBitmap* pBmp);

Parâmetros

nFlags
Especifica informações sobre o estado do novo item do menu quando este é adicionado ao menu. Consiste em um ou mais dos valores listados na secção de Observações.

nIDNewItem
Especifica o ID do comando do novo item do menu ou, se nFlags estiver definido para MF_POPUP, o handle do menu (HMENU) de um menu pop-up. O nIDNewItem parâmetro é ignorado (não necessário) se nFlags for definido como MF_SEPARATOR.

lpszNewItem
Especifica o conteúdo do novo item do menu. O nFlags parâmetro é usado para interpretar lpszNewItem da seguinte forma:

pBmp
Aponta para um CBitmap objeto que será usado como item do menu.

Valor de retorno

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

Observações

A aplicação pode especificar o estado do item do menu definindo valores em nFlags. Quando nIDNewItem especifica um menu pop-up, este torna-se parte do menu ao qual é adicionado. Se esse menu for destruído, o menu anexo também será destruído. Um menu anexado deve ser destacado de um CMenu objeto para evitar conflitos. Note que MF_STRING e MF_OWNERDRAW não são válidos para a versão bitmap de AppendMenu.

A lista seguinte descreve as bandeiras que podem ser definidas em nFlags:

• MF_CHECKED Funciona como um botão de alternância para MF_UNCHECKED colocar a marca de verificação padrão ao lado do item. Quando a aplicação fornece bitmaps de verificação (ver a SetMenuItemBitmaps função membro), é exibido o bitmap "check mark on".

• MF_UNCHECKED Funciona como uma opção MF_CHECKED para remover uma marca de seleção ao lado do item. Quando a aplicação fornece bitmaps de verificação (ver a SetMenuItemBitmaps função membro), é exibido o bitmap "check mark off".

• MF_DISABLED Desativa o item do menu para que não possa ser selecionado, mas não o diminui.

• MF_ENABLED Ativa o item do menu para que possa ser selecionado e restaura-o do seu estado escurecido.

• MF_GRAYED Desativa o item do menu para que não possa ser selecionado e escurece-o.

• MF_MENUBARBREAK Coloca o item numa nova linha em menus estáticos ou numa nova coluna em menus pop-up. A nova coluna do menu pop-up será separada da coluna antiga por uma linha divisória vertical.

• MF_MENUBREAK Coloca o item numa nova linha em menus estáticos ou numa nova coluna em menus pop-up. Não é colocada qualquer linha divisória entre as colunas.

• MF_OWNERDRAW Especifica que o item é um item de compra do proprietário. Quando o menu é exibido pela primeira vez, a janela que detém o menu recebe uma WM_MEASUREITEM mensagem que recupera a altura e largura do item do menu. A WM_DRAWITEM mensagem é a enviada sempre que o proprietário tem de atualizar a aparência visual do item do menu. Esta opção não é válida para um item de menu de topo.

• MF_POPUP Especifica que o item do menu tem um menu pop-up associado. O parâmetro ID especifica um handle para um menu pop-up que deve ser associado ao item. Isto é usado para adicionar um menu pop-up de topo ou um menu pop-up hierárquico a um item do menu pop-up.

• MF_SEPARATOR Traça uma linha divisória horizontal. Só pode ser usado num menu pop-up. Esta linha não pode ser atenuada, desativada ou destacada. Outros parâmetros são ignorados.

• MF_STRING Especifica que o item do menu é uma cadeia de caracteres.

Cada um dos seguintes grupos lista flags que são mutuamente exclusivos e que não podem ser usados em conjunto:

• MF_DISABLED, MF_ENABLEDe MF_GRAYED

• MF_STRING, MF_OWNERDRAW, MF_SEPARATOR, e a versão bitmap

• MF_MENUBARBREAK e MF_MENUBREAK

• MF_CHECKED e MF_UNCHECKED

Sempre que um menu que reside numa janela é alterado (quer a janela seja ou não exibida), a aplicação deve chamar CWnd::DrawMenuBar.

Example

Veja o exemplo para CMenu::CreateMenu.

CMenu::Attach

Anexa um menu Windows existente a um CMenu objeto.

BOOL Attach(HMENU hMenu);

Parâmetros

hMenu
Especifica um handle para um menu do Windows.

Valor de retorno

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

Observações

Esta função não deve ser chamada se já estiver associado um menu ao CMenu objeto. O handle do menu é armazenado no m_hMenu membro de dados.

Se o menu que queres manipular já estiver associado a uma janela, podes usar a CWnd::GetMenu função para obter um handle para o menu.

Example

CMenu mnu;
HMENU hmnu = AfxGetMainWnd()->GetMenu()->GetSafeHmenu();
mnu.Attach(hmnu);

// Now you can manipulate the window's menu as a CMenu
// object...

mnu.Detach();

CMenu::CheckMenuItem

Adiciona ou remove marcas de seleção dos itens do menu pop-up.

UINT CheckMenuItem(
    UINT nIDCheckItem,
    UINT nCheck);

Parâmetros

nIDCheckItem
Especifica o item do menu a verificar, conforme determinado por nCheck.

nCheck
Especifica como verificar o item do menu e como determinar a posição do item no menu. O nCheck parâmetro pode ser uma combinação de MF_CHECKED ou MF_UNCHECKED com MF_BYPOSITION ou MF_BYCOMMAND flags. Estas flags podem ser combinadas usando o operador OR bit a bit. Têm os seguintes significados:

• MF_BYCOMMAND Especifica que o parâmetro fornece o ID do comando do item existente do menu. Este é o padrão.

• MF_BYPOSITION Especifica que o parâmetro indica a posição do item existente no menu. O primeiro item está na posição 0.

• MF_CHECKED Funciona como um botão de alternância para MF_UNCHECKED colocar a marca de verificação padrão ao lado do item.

• MF_UNCHECKED Funciona como uma opção MF_CHECKED para remover uma marca de seleção ao lado do item.

Valor de retorno

O estado anterior do item: MF_CHECKED ou MF_UNCHECKED, ou 0xFFFFFFFF se o item do menu não existisse.

Observações

O nIDCheckItem parâmetro especifica o item a ser modificado.

O nIDCheckItem parâmetro pode identificar um item de menu pop-up, bem como um item de menu. Não são necessários passos especiais para verificar um item do menu pop-up. Os itens do menu de topo não podem ser verificados. Um item de menu pop-up deve ser verificado por posição, pois não tem um identificador de item associado a ele.

Example

Veja o exemplo para CMenu::GetMenuState.

CMenu::CheckMenuRadioItem

Verifica um item específico do menu e transforma-o num item de rádio.

BOOL CheckMenuRadioItem(
    UINT nIDFirst,
    UINT nIDLast,
    UINT nIDItem,
    UINT nFlags);

Parâmetros

nIDFirst
Especifica (como um ID ou deslocamento, dependendo do valor de nFlags) o primeiro item do menu no grupo de botões de opção.

nIDLast
Especifica (como ID ou deslocamento, dependendo do valor de nFlags) o último item do menu no grupo de botões de opção.

nIDItem
Especifica (como ID ou deslocamento, dependendo do valor de nFlags) o item no grupo que será verificado com um botão de interação.

nFlags
Especifica a interpretação de nIDFirst, nIDLast, e nIDItem da seguinte forma:

Valor de retorno

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

Observações

Ao mesmo tempo, a função desmarca todos os outros itens do menu no grupo associado e limpa a bandeira de tipo de item de rádio para esses itens. O item verificado é apresentado usando um bitmap de botão de opção (ou bullet) em vez de um bitmap de verificação.

Example

Veja o exemplo para ON_COMMAND_RANGE.

CMenu::CMenu

Cria um menu vazio e anexa-o a um CMenu objeto.

CMenu();

Observações

O menu não é criado até chamar uma das funções de criar ou carregar membros de CMenu:

• CreateMenu

• CreatePopupMenu

• LoadMenu

• LoadMenuIndirect

• Attach

CMenu::CreateMenu

Cria um menu e anexa-o ao CMenu objeto.

BOOL CreateMenu();

Valor de retorno

Diferente de zero se o menu fosse criado com sucesso; caso contrário, 0.

Observações

O menu está inicialmente vazio. Os itens do menu podem ser adicionados usando a AppendMenu função de membro InsertMenu .

Se o menu for atribuído a uma janela, esta é automaticamente destruída quando a janela é destruída.

Antes de sair, uma aplicação deve libertar recursos do sistema associados a um menu caso o menu não esteja atribuído a uma janela. Uma aplicação liberta um menu ao chamar a DestroyMenu função membro.

Example

// The code fragment below shows how to create a new menu for the
// application window using CreateMenu() and CreatePopupMenu().
// Then, the created menu will replace the current menu of the
// application. The old menu will be destroyed with DestroyMenu().
// NOTE: The code fragment below is done in a CFrameWnd-derived class.

// Create a new menu for the application window.
VERIFY(m_NewMenu.CreateMenu());

// Create a "File" popup menu and insert this popup menu to the
// new menu of the application window. The "File" menu has only
// one menu item, i.e. "Exit".
VERIFY(m_FileMenu.CreatePopupMenu());
m_FileMenu.AppendMenu(MF_STRING, ID_APP_EXIT, _T("E&xit"));
m_NewMenu.AppendMenu(MF_POPUP, (UINT_PTR)m_FileMenu.m_hMenu, _T("&File"));

// Remove and destroy old menu
SetMenu(NULL);
CMenu *old_menu = CMenu::FromHandle(m_hMenuDefault);
old_menu->DestroyMenu();

// Add new menu.
SetMenu(&m_NewMenu);

// Assign default menu
m_hMenuDefault = m_NewMenu.m_hMenu;

CMenu::CreatePopupMenu

Cria um menu pop-up e anexa-o ao CMenu objeto.

BOOL CreatePopupMenu();

Valor de retorno

Diferente de zero se o menu pop-up for criado com sucesso; caso contrário, 0.

Observações

O menu está inicialmente vazio. Os itens do menu podem ser adicionados usando a AppendMenu função de membro InsertMenu . A aplicação pode adicionar o menu pop-up a um menu ou menu pop-up existente. A TrackPopupMenu função de membro pode ser usada para mostrar este menu como um menu pop-up flutuante e para acompanhar seleções no menu pop-up.

Se o menu for atribuído a uma janela, esta é automaticamente destruída quando a janela é destruída. Se o menu for adicionado a um menu existente, é automaticamente destruído quando esse menu é destruído.

Antes de sair, uma aplicação deve libertar recursos do sistema associados a um menu pop-up caso o menu não esteja atribuído a uma janela. Uma aplicação liberta um menu ao chamar a DestroyMenu função membro.

Example

Veja o exemplo para CMenu::CreateMenu.

CMenu::DeleteMenu

Apaga um item do menu.

BOOL DeleteMenu(
    UINT nPosition,
    UINT nFlags);

Parâmetros

nPosition
Especifica o item do menu que deve ser eliminado, conforme determinado por nFlags.

nFlags
É usado para interpretar nPosition da seguinte forma:

Valor de retorno

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

Observações

Se o item do menu tiver um menu pop-up associado, DeleteMenu destrói a alavanca do menu pop-up e liberta a memória usada pelo menu pop-up.

Sempre que um menu que reside numa janela é alterado (quer a janela seja ou não exibida), a aplicação deve chamar CWnd::DrawMenuBar.

Example

Veja o exemplo para CWnd::GetMenu.

CMenu::DeleteTempMap

Chamada automaticamente pelo CWinApp handler de tempo ocioso, elimina quaisquer objetos temporários CMenu criados pela FromHandle função membro.

static void PASCAL DeleteTempMap();

Observações

DeleteTempMap desanexa o objeto do menu Windows associado a um objeto temporário CMenu antes de o CMenu eliminar.

Example

// DeleteTempMap() is a static member and does not need
// an instantiated CMenu object.
CMenu::DeleteTempMap();

CMenu::DestroyMenu

Destrói o menu e quaisquer recursos do Windows que tenham sido usados.

BOOL DestroyMenu();

Valor de retorno

Diferente de zero se o menu for destruído; caso contrário, 0.

Observações

O menu é separado do CMenu objeto antes de este ser destruído. A função Windows DestroyMenu é automaticamente chamada no CMenu destruidor.

Example

Veja o exemplo para CMenu::CreateMenu.

CMenu::Detach

Desliga um menu do Windows de um CMenu objeto e devolve o handle.

HMENU Detach();

Valor de retorno

O handle, do tipo HMENU, para um menu do Windows, se for bem-sucedido; caso contrário NULL.

Observações

O m_hMenu membro de dados é definido para NULL.

Example

CMenu mnu;
HMENU hmnu = AfxGetMainWnd()->GetMenu()->GetSafeHmenu();
mnu.Attach(hmnu);

// Now you can manipulate the window's menu as a CMenu
// object...

mnu.Detach();

CMenu::DrawItem

Chamada pelo framework quando um aspeto visual de um menu desenhado pelo proprietário muda.

virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);

Parâmetros

lpDrawItemStruct
Um ponteiro para uma DRAWITEMSTRUCT estrutura que contém informação sobre o tipo de desenho necessário.

Observações

O itemAction elemento da DRAWITEMSTRUCT estrutura define a ação de desenho que deve ser realizada. Substitua esta função de membro para implementar desenho para um objeto proprietário-desenho CMenu . A aplicação deve restaurar todos os objetos da interface do dispositivo gráfico (GDI) selecionados para o contexto de visualização fornecido lpDrawItemStruct antes da terminação desta função membro.

Veja CWnd::OnDrawItem para uma descrição da DRAWITEMSTRUCT estrutura.

Example

O seguinte código é do exemplo MFC CTRLTEST :

// Override DrawItem() to implement drawing for an owner-draw CMenu object.
// CColorMenu is a CMenu-derived class.
void CColorMenu::DrawItem(LPDRAWITEMSTRUCT lpDIS)
{
   CDC *pDC = CDC::FromHandle(lpDIS->hDC);
   COLORREF cr = (COLORREF)lpDIS->itemData; // RGB in item data

   if (lpDIS->itemAction & ODA_DRAWENTIRE)
   {
      // Paint the color item in the color requested
      CBrush br(cr);
      pDC->FillRect(&lpDIS->rcItem, &br);
   }

   if ((lpDIS->itemState & ODS_SELECTED) &&
       (lpDIS->itemAction & (ODA_SELECT | ODA_DRAWENTIRE)))
   {
      // item has been selected - hilite frame
      COLORREF crHilite = RGB(255 - GetRValue(cr),
                              255 - GetGValue(cr), 255 - GetBValue(cr));
      CBrush br(crHilite);
      pDC->FrameRect(&lpDIS->rcItem, &br);
   }

   if (!(lpDIS->itemState & ODS_SELECTED) &&
       (lpDIS->itemAction & ODA_SELECT))
   {
      // Item has been de-selected -- remove frame
      CBrush br(cr);
      pDC->FrameRect(&lpDIS->rcItem, &br);
   }
}

CMenu::EnableMenuItem

Ativa, desativa ou reduz um item do menu.

UINT EnableMenuItem(
    UINT nIDEnableItem,
    UINT nEnable);

Parâmetros

nIDEnableItem
Especifica o item do menu a ser ativado, conforme determinado por nEnable. Este parâmetro pode especificar itens do menu pop-up, bem como itens padrão do menu.

nEnable
Especifica a ação a tomar. Pode ser uma combinação de MF_DISABLED, MF_ENABLED, ou MF_GRAYED, com MF_BYCOMMAND ou MF_BYPOSITION. Estes valores podem ser combinados usando o operador OR bit a bit C++ (|). Estes valores têm os seguintes significados:

• MF_BYCOMMAND Especifica que o parâmetro fornece o ID do comando do item existente do menu. Este é o padrão.

• MF_BYPOSITION Especifica que o parâmetro indica a posição do item existente no menu. O primeiro item está na posição 0.

• MF_DISABLED Desativa o item do menu para que não possa ser selecionado, mas não o diminui.

• MF_ENABLED Ativa o item do menu para que possa ser selecionado e restaura-o do seu estado escurecido.

• MF_GRAYED Desativa o item do menu para que não possa ser selecionado e escurece-o.

Valor de retorno

Estado anterior (MF_DISABLED, MF_ENABLED, ou MF_GRAYED) ou -1 se não for válido.

Observações

As CreateMenufunções , InsertMenu, ModifyMenu, e LoadMenuIndirect membros também podem definir o estado (ativado, desativado ou escurecido) de um item do menu.

Usar o MF_BYPOSITION valor requer que uma aplicação utilize o valor correto CMenu. Se for usada a CMenu barra de menu, um item de menu de topo (um item na barra de menu) é afetado. Para definir o estado de um item num menu pop-up ou pop-up aninhado por posição, uma aplicação deve especificar o CMenu menu pop-up.

Quando uma aplicação especifica a MF_BYCOMMAND bandeira, o Windows verifica todos os itens do menu pop-up que são subordinados ao CMenu; portanto, a menos que existam itens duplicados do menu, usar a CMenu barra de menu é suficiente.

Example

// The code fragment below shows how to disable (and gray out) the
// File\New menu item.
// NOTE: m_bAutoMenuEnable is set to FALSE in the constructor of
// CMainFrame so no ON_UPDATE_COMMAND_UI or ON_COMMAND handlers are
// needed, and CMenu::EnableMenuItem() will work as expected.

CMenu *mmenu = GetMenu();
CMenu *submenu = mmenu->GetSubMenu(0);
submenu->EnableMenuItem(ID_FILE_NEW, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);

CMenu::FromHandle

Devolve um ponteiro para um CMenu objeto dado como handle do Windows para um menu.

static CMenu* PASCAL FromHandle(HMENU hMenu);

Parâmetros

hMenu
Um handle do Windows para um menu.

Valor de retorno

Uma pista para algo CMenu que pode ser temporário ou permanente.

Observações

Se um CMenu objeto ainda não estiver associado ao objeto do menu Windows, um objeto temporário CMenu é criado e anexado.

Este objeto temporário CMenu só é válido até à próxima vez que a aplicação tiver tempo de inatividade no seu ciclo de eventos, altura em que todos os objetos temporários são eliminados.

Example

Veja o exemplo para CMenu::CreateMenu.

CMenu::GetDefaultItem

Determina o item de menu padrão no menu especificado.

UINT GetDefaultItem(
    UINT gmdiFlags,
    BOOL fByPos = FALSE);

Parâmetros

gmdiFlags
Valor que especifica como a função procura itens do menu. Este parâmetro pode ser nenhum, um, ou uma combinação dos seguintes valores:

fByPos
Valor que especifica se deve recuperar o identificador do item do menu ou a sua posição. Se este parâmetro for FALSE, o identificador é devolvido. Caso contrário, a posição é devolvida.

Valor de retorno

Se a função tiver sucesso, o valor de retorno é o identificador ou a posição do item do menu. Se a função falhar, o valor de retorno é - 1.

Observações

Esta função membro implementa o comportamento da função GetMenuDefaultItemWin32 , conforme descrito no SDK do Windows.

Example

Veja o exemplo para CMenu::InsertMenu.

CMenu::GetMenuContextHelpId

Recupera o ID de ajuda de contexto associado a CMenu.

DWORD GetMenuContextHelpId() const;

Valor de retorno

O ID de ajuda de contexto atualmente associado CMenu , se tiver um; zero caso contrário.

Example

Veja o exemplo para CMenu::InsertMenu.

CMenu::GetMenuInfo

Recupera informações para um menu.

BOOL GetMenuInfo(LPMENUINFO lpcmi) const;

Parâmetros

lpcmi
Um ponteiro para uma MENUINFO estrutura contendo informação para o menu.

Valor de retorno

Se a função tiver sucesso, o valor de retorno é diferente de zero; caso contrário, o valor de retorno é zero.

Observações

Ligue para esta função para obter informações sobre o menu.

CMenu::GetMenuItemCount

Determina o número de itens num menu pop-up ou de topo.

UINT GetMenuItemCount() const;

Valor de retorno

O número de itens no menu se a função for bem-sucedida; caso contrário -1.

Example

Veja o exemplo para CWnd::GetMenu.

CMenu::GetMenuItemID

Obtém o identificador de item de menu para um item de menu localizado na posição definida por nPos.

UINT GetMenuItemID(int nPos) const;

Parâmetros

nPos
Especifica a posição (baseada em zero) do item do menu cujo ID está a ser recuperado.

Valor de retorno

O ID do item especificado num menu pop-up se a função for bem-sucedida. Se o item especificado for um menu pop-up (em vez de um item dentro do menu pop-up), o valor de retorno é -1. Se nPos corresponder a um SEPARATOR item do menu, o valor de retorno é 0.

Example

Veja o exemplo para CMenu::InsertMenu.

CMenu::GetMenuItemInfo

Recupera informações sobre um item do menu.

BOOL GetMenuItemInfo(
    UINT uItem,
    LPMENUITEMINFO lpMenuItemInfo,
    BOOL fByPos = FALSE);

Parâmetros

uItem
Identificador ou posição do item do menu para obter informações. O significado deste parâmetro depende do valor de ByPos.

lpMenuItemInfo
Um apontador para um MENUITEMINFO, conforme descrito no SDK do Windows, que contém informação sobre o menu.

fByPos
Valor que especifica o significado de nIDItem. Por defeito, ByPos é FALSE, o que indica que uItem é um identificador de item do menu. Se ByPos não estiver definido para FALSE, indica a posição de um item no menu.

Valor de retorno

Se a função tiver sucesso, o valor de retorno é diferente de zero. Se a função falhar, o valor de retorno será zero. Para obter informação de erro alargada, use a função GetLastErrorWin32 , conforme descrito no SDK do Windows.

Observações

Esta função membro implementa o comportamento da função GetMenuItemInfoWin32 , conforme descrito no SDK do Windows. Note que na implementação MFC de GetMenuItemInfo, não se usa um handle para um menu.

Example

// CMainFrame::OnToggleTestMenuInfo() is a menu command handler for 
// "Toggle Info" menu item (whose resource id is ID_MENU_TOGGLEINFO). It 
// toggles the checked or unchecked state of the "Toggle Info" menu item.
// CMainFrame is a CFrameWnd-derived class.
void CMainFrame::OnToggleTestMenuItemInfo()
{
   // Get the popup menu which contains the "Toggle Info" menu item.
   CMenu* mmenu = GetMenu();
   CMenu* submenu = mmenu->GetSubMenu(4);

   // Check the state of the "Toggle Info" menu item. Check the menu item
   // if it is currently unchecked. Otherwise, uncheck the menu item
   // if it is not currently checked.
   MENUITEMINFO info;
   info.cbSize = sizeof (MENUITEMINFO); // must fill up this field
   info.fMask = MIIM_STATE;             // get the state of the menu item
   VERIFY(submenu->GetMenuItemInfo(ID_MENU_TOGGLEINFO, &info));

   if (info.fState & MF_CHECKED)
      submenu->CheckMenuItem(ID_MENU_TOGGLEINFO, MF_UNCHECKED | MF_BYCOMMAND);
   else
      submenu->CheckMenuItem(ID_MENU_TOGGLEINFO, MF_CHECKED | MF_BYCOMMAND);
}

CMenu::GetMenuState

Devolve o estado do item especificado no menu ou o número de itens num menu pop-up.

UINT GetMenuState(
    UINT nID,
    UINT nFlags) const;

Parâmetros

nID
Especifica o ID do item do menu, conforme determinado por nFlags.

nFlags
Especifica a natureza de nID. Pode ser um dos seguintes valores:

• MF_BYCOMMAND Especifica que o parâmetro fornece o ID do comando do item existente do menu. Este é o padrão.

• MF_BYPOSITION Especifica que o parâmetro indica a posição do item existente no menu. O primeiro item está na posição 0.

Valor de retorno

O valor 0xFFFFFFFF se o item especificado não existir. Se nId identificar um menu pop-up, o byte de ordem alta contém o número de itens no menu pop-up e o byte de ordem baixa contém as bandeiras do menu associadas ao menu pop-up. Caso contrário, o valor de retorno é uma máscara (BOOLEANO OU) dos valores da lista seguinte (esta máscara descreve o estado do item do menu que nId identifica):

• MF_CHECKED Funciona como um botão de alternância para MF_UNCHECKED colocar a marca de verificação padrão ao lado do item. Quando a aplicação fornece bitmaps de verificação (ver a SetMenuItemBitmaps função membro), é exibido o bitmap "check mark on".

• MF_DISABLED Desativa o item do menu para que não possa ser selecionado, mas não o diminui.

• MF_ENABLED Ativa o item do menu para que possa ser selecionado e restaura-o do seu estado escurecido. Note-se que o valor desta constante é 0; uma aplicação não deve testar contra 0 para falha ao usar este valor.

• MF_GRAYED Desativa o item do menu para que não possa ser selecionado e escurece-o.

• MF_MENUBARBREAK Coloca o item numa nova linha em menus estáticos ou numa nova coluna em menus pop-up. A nova coluna do menu pop-up será separada da coluna antiga por uma linha divisória vertical.

• MF_MENUBREAK Coloca o item numa nova linha em menus estáticos ou numa nova coluna em menus pop-up. Não é colocada qualquer linha divisória entre as colunas.

• MF_SEPARATOR Traça uma linha divisória horizontal. Só pode ser usado num menu pop-up. Esta linha não pode ser atenuada, desativada ou destacada. Outros parâmetros são ignorados.

• MF_UNCHECKED Funciona como uma opção MF_CHECKED para remover uma marca de seleção ao lado do item. Quando a aplicação fornece bitmaps de verificação (ver a SetMenuItemBitmaps função membro), é exibido o bitmap "check mark off". Note-se que o valor desta constante é 0; uma aplicação não deve testar contra 0 para falha ao usar este valor.

Example

// CMainFrame::OnToggleTestMenuState() is a menu command handler for
// "Toggle State" menu item (whose resource id is ID_MENU_TOGGLESTATE).
// It toggles the checked or unchecked state of the "Toggle State" menu item.
// CMainFrame is a CFrameWnd-derived class.
void CMainFrame::OnToggleTestMenuState()
{
   // Get the popup menu which contains the "Toggle State" menu item.
   CMenu *mmenu = GetMenu();
   CMenu *submenu = mmenu->GetSubMenu(4);

   // Check the state of the "Toggle State" menu item. Check the menu item
   // if it is currently unchecked. Otherwise, uncheck the menu item
   // if it is not currently checked.
   UINT state = submenu->GetMenuState(ID_MENU_TOGGLESTATE, MF_BYCOMMAND);
   ASSERT(state != 0xFFFFFFFF);

   if (state & MF_CHECKED)
      submenu->CheckMenuItem(ID_MENU_TOGGLESTATE, MF_UNCHECKED | MF_BYCOMMAND);
   else
      submenu->CheckMenuItem(ID_MENU_TOGGLESTATE, MF_CHECKED | MF_BYCOMMAND);
}

CMenu::GetMenuString

Copia a etiqueta do item do menu especificado para o buffer especificado.

int GetMenuString(
    UINT nIDItem,
    LPTSTR lpString,
    int nMaxCount,
    UINT nFlags) const;

int GetMenuString(
    UINT nIDItem,
    CString& rString,
    UINT nFlags) const;

Parâmetros

nIDItem
Especifica o identificador inteiro do item do menu ou o deslocamento do item do menu no menu, dependendo do valor de nFlags.

lpString
Aponta para o buffer que irá receber a etiqueta.

rString
Uma referência a um CString objeto que deve receber a cadeia de menu copiada.

nMaxCount
Especifica o comprimento máximo (em caracteres) da etiqueta a ser copiada. Se a etiqueta for maior do que o máximo especificado em nMaxCount, os caracteres extra são truncados.

nFlags
Especifica a interpretação do nIDItem parâmetro. Pode ser um dos seguintes valores:

Valor de retorno

Especifica o número real de caracteres copiados para o buffer, não incluindo o terminador nulo.

Observações

O nMaxCount parâmetro deve ser um maior do que o número de caracteres no rótulo para acomodar o carácter nulo que termina uma cadeia.

Example

Veja o exemplo para CMenu::InsertMenu.

CMenu::GetSafeHmenu

Devolve o HMENU wrapped by este CMenu objeto, ou um NULLCMenu apontador.

HMENU GetSafeHmenu() const;

Example

Veja o exemplo para CMenu::LoadMenu.

CMenu::GetSubMenu

Recupera o CMenu objeto de um menu pop-up.

CMenu* GetSubMenu(int nPos) const;

Parâmetros

nPos
Especifica a posição do menu pop-up contido no menu. Os valores de posição começam em 0 para o primeiro item do menu. O identificador do menu pop-up não pode ser usado nesta função.

Valor de retorno

Um apontador para um CMenu objeto cujo m_hMenu membro contém um handle para o menu pop-up se existir um menu pop-up na posição dada; caso contrário NULL. Se um CMenu objeto não existir, então é criado um temporário. O CMenu ponteiro devolvido não deve ser armazenado.

Example

Veja o exemplo para CMenu::TrackPopupMenu.

CMenu::InsertMenu

Insere um novo item do menu na posição especificada por nPosition e move outros itens para baixo no menu.

BOOL InsertMenu(
    UINT nPosition,
    UINT nFlags,
    UINT_PTR nIDNewItem = 0,
    LPCTSTR lpszNewItem = NULL);

BOOL InsertMenu(
    UINT nPosition,
    UINT nFlags,
    UINT_PTR nIDNewItem,
    const CBitmap* pBmp);

Parâmetros

nPosition
Especifica o item do menu antes do qual o novo item deve ser inserido. O nFlags parâmetro pode ser usado para interpretar nPosition das seguintes formas:

nFlags
Especifica como nPosition é interpretado e especifica informações sobre o estado do novo item do menu quando este é adicionado ao menu. Para uma lista das bandeiras que podem ser definidas, veja a AppendMenu função membro. Para especificar mais do que um valor, use o operador OR bit a bit para os combinar com a MF_BYCOMMAND bandeira ou MF_BYPOSITION .

nIDNewItem
Especifica o ID do comando do novo item do menu ou, se nFlags estiver definido para MF_POPUP, o handle do menu (HMENU) do menu pop-up. O nIDNewItem parâmetro é ignorado (não necessário) se nFlags for definido como MF_SEPARATOR.

lpszNewItem
Especifica o conteúdo do novo item do menu. nFlags pode ser usado para interpretar lpszNewItem das seguintes formas:

pBmp
Aponta para um CBitmap objeto que será usado como item do menu.

Valor de retorno

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

Observações

A aplicação pode especificar o estado do item do menu definindo valores em nFlags.

Sempre que um menu que reside numa janela é alterado (quer a janela seja ou não exibida), a aplicação deve chamar CWnd::DrawMenuBar.

Quando nIDNewItem especifica um menu pop-up, este passa a fazer parte do menu onde é inserido. Se esse menu for destruído, o menu inserido também será destruído. Um menu inserido deve ser separado de um CMenu objeto para evitar conflitos.

Se a janela filha da interface ativa de múltiplos documentos (MDI) for maximizada e uma aplicação inserir um menu pop-up no menu da aplicação MDI ao chamar esta função e especificar a MF_BYPOSITION bandeira, o menu é inserido uma posição mais à esquerda do que o esperado. Isto acontece porque o menu Control da janela MDI filha ativa é inserido na primeira posição da barra de menu da janela de frames MDI. Para posicionar corretamente o menu, a aplicação deve adicionar 1 ao valor da posição que, de outra forma, seria utilizado. Uma aplicação pode usar a WM_MDIGETACTIVE mensagem para determinar se a janela filha atualmente ativa está maximizada.

Example

// CMainFrame::OnChangeFileMenu() is a menu command handler for
// CMainFrame class, which in turn is a CFrameWnd-derived class.
// It modifies the File menu by inserting, removing and renaming
// some menu items. Other operations include associating a context
// help id and setting default menu item to the File menu.
// CMainFrame is a CFrameWnd-derived class.
void CMainFrame::OnChangeFileMenu()
{
   // Get the menu from the application window.
   CMenu *mmenu = GetMenu();

   // Look for "File" menu.
   int pos = FindMenuItem(mmenu, _T("&File"));
   if (pos == -1)
      return;

   // Remove "New" menu item from the File menu.
   CMenu *submenu = mmenu->GetSubMenu(pos);
   pos = FindMenuItem(submenu, _T("&New\tCtrl+N"));
   if (pos > -1)
      submenu->RemoveMenu(pos, MF_BYPOSITION);

   // Look for "Open" menu item from the File menu. Insert a new
   // menu item called "Close" right after the "Open" menu item.
   // ID_CLOSEFILE is the command id for the "Close" menu item.
   pos = FindMenuItem(submenu, _T("&Open...\tCtrl+O"));
   if (pos > -1)
      submenu->InsertMenu(pos + 1, MF_BYPOSITION, ID_CLOSEFILE, _T("&Close"));

   // Rename menu item "Exit" to "Exit Application".
   pos = FindMenuItem(submenu, _T("E&xit"));
   if (pos > -1)
   {
      UINT id = submenu->GetMenuItemID(pos);
      submenu->ModifyMenu(id, MF_BYCOMMAND, id, _T("E&xit Application"));
   }

   // Associate a context help ID with File menu, if one is not found.
   // ID_FILE_CONTEXT_HELPID is the context help ID for the File menu
   // that is defined in resource file.
   if (submenu->GetMenuContextHelpId() == 0)
      submenu->SetMenuContextHelpId(ID_FILE_CONTEXT_HELPID);

   // Set "Open" menu item as the default menu item for the File menu,
   // if one is not found. So, when a user double-clicks the File
   // menu, the system sends a command message to the menu's owner
   // window and closes the menu as if the File\Open command item had
   // been chosen.
   if (submenu->GetDefaultItem(GMDI_GOINTOPOPUPS, TRUE) == -1)
   {
      pos = FindMenuItem(submenu, _T("&Open...\tCtrl+O"));
      submenu->SetDefaultItem(pos, TRUE);
   }
}

// FindMenuItem() will find a menu item string from the specified
// popup menu and returns its position (0-based) in the specified
// popup menu. It returns -1 if no such menu item string is found.
int FindMenuItem(CMenu *Menu, LPCTSTR MenuString)
{
   ASSERT(Menu);
   ASSERT(::IsMenu(Menu->GetSafeHmenu()));

   int count = Menu->GetMenuItemCount();
   for (int i = 0; i < count; i++)
   {
      CString str;
      if (Menu->GetMenuString(i, str, MF_BYPOSITION) &&
          str.Compare(MenuString) == 0)
         return i;
   }

   return -1;
}

CMenu::InsertMenuItem

Insere um novo item do menu na posição especificada de um menu.

BOOL InsertMenuItem(
    UINT uItem,
    LPMENUITEMINFO lpMenuItemInfo,
    BOOL fByPos = FALSE);

Parâmetros

uItem
Veja a descrição de uItem em InsertMenuItem no SDK do Windows.

lpMenuItemInfo
Veja a descrição de lpmii em InsertMenuItem no SDK do Windows.

fByPos
Veja a descrição de fByPosition em InsertMenuItem no SDK do Windows.

Observações

Esta função envolve InsertMenuItem, descrito no SDK do Windows.

CMenu::LoadMenu

Carrega um recurso de menu a partir do ficheiro executável da aplicação e anexa-o ao CMenu objeto.

BOOL LoadMenu(LPCTSTR lpszResourceName);
BOOL LoadMenu(UINT nIDResource);

Parâmetros

lpszResourceName
Aponta para uma cadeia terminada em null que contém o nome do recurso do menu a carregar.

nIDResource
Especifica o ID do menu do recurso do menu a carregar.

Valor de retorno

Diferente de zero se o recurso do menu fosse carregado com sucesso; caso contrário, 0.

Observações

Antes de sair, uma aplicação deve libertar recursos do sistema associados a um menu caso o menu não esteja atribuído a uma janela. Uma aplicação liberta um menu ao chamar a DestroyMenu função membro.

Example

// CMainFrame::OnReplaceMenu() is a menu command handler for CMainFrame
// class, which in turn is a CFrameWnd-derived class. It loads a new
// menu resource and replaces the SDI application window's menu bar with
// this new menu. CMainFrame is a CFrameWnd-derived class.
void CMainFrame::OnReplaceMenu()
{
   // Load the new menu.
   m_ShortMenu.LoadMenu(IDR_SHORT_MENU);
   ASSERT(m_ShortMenu);

   // Remove and destroy the old menu
   SetMenu(NULL);
   ::DestroyMenu(m_hMenuDefault);

   // Add the new menu
   SetMenu(&m_ShortMenu);

   // Assign default menu
   m_hMenuDefault = m_ShortMenu.GetSafeHmenu(); // or m_ShortMenu.m_hMenu;
}

CMenu::LoadMenuIndirect

Carrega um recurso a partir de um modelo de menu na memória e anexa-o ao CMenu objeto.

BOOL LoadMenuIndirect(const void* lpMenuTemplate);

Parâmetros

lpMenuTemplate
Aponta para um modelo de menu (que é uma única MENUITEMTEMPLATEHEADER estrutura e uma coleção de uma ou mais MENUITEMTEMPLATE estruturas). Para mais informações sobre estas duas estruturas, consulte o SDK do Windows.

Valor de retorno

Diferente de zero se o recurso do menu fosse carregado com sucesso; caso contrário, 0.

Observações

Um modelo de menu é um cabeçalho seguido de uma coleção de uma ou mais MENUITEMTEMPLATE estruturas, cada uma das quais pode conter um ou mais itens do menu e menus pop-up.

O número de versão deve ser 0.

Os mtOption flags devem incluir MF_END o último item numa lista pop-up e o último item da lista principal. Consulte a AppendMenu função de membro para outras bandeiras. O mtId elemento deve ser omitido da MENUITEMTEMPLATE estrutura quando MF_POPUP é especificado em mtOption.

O espaço alocado para a MENUITEMTEMPLATE estrutura deve ser suficientemente grande para mtString conter o nome do item do menu como uma cadeia terminada por nulo.

Antes de sair, uma aplicação deve libertar recursos do sistema associados a um menu caso o menu não esteja atribuído a uma janela. Uma aplicação liberta um menu ao chamar a DestroyMenu função membro.

Example

// CMainFrame::OnLoadMenuIndirect() is a menu command handler for
// CMainFrame class, which in turn is a CFrameWnd-derived class. It
// shows how to use LoadMenuIndirect() to load a resource from a
// menu template in memory.
void CMainFrame::OnLoadMenuIndirect()
{
   // For simplicity, allocate 500 bytes from stack. May use
   // GlobalAlloc() to allocate memory bytes from heap.
   BYTE milist[500];
   memset(milist, 0, 500);
   int bytes_left = sizeof(milist);

   // Fill up the MENUITEMTEMPLATEHEADER structure.
   MENUITEMTEMPLATEHEADER *mheader = (MENUITEMTEMPLATEHEADER*)milist;
   mheader->versionNumber = 0;
   mheader->offset = 0;

   int bytes_used = sizeof(MENUITEMTEMPLATEHEADER);
   bytes_left -= bytes_used;

   // Add the following menu items to menu bar:
   // File     Edit
   //   Exit     Copy
   //            Paste
   bytes_used += AddMenuItem(milist + bytes_used, bytes_left, L"&File", 0,
                             TRUE, FALSE);
   bytes_left -= bytes_used;
   bytes_used += AddMenuItem(milist + bytes_used, bytes_left, L"E&xit",
                             ID_APP_EXIT, FALSE, TRUE);
   bytes_left -= bytes_used;
   bytes_used += AddMenuItem(milist + bytes_used, bytes_left, L"&Edit", 0,
                             TRUE, TRUE);
   bytes_left -= bytes_used;
   bytes_used += AddMenuItem(milist + bytes_used, bytes_left, L"&Copy",
                             ID_EDIT_COPY, FALSE, FALSE);
   bytes_left -= bytes_used;
   bytes_used += AddMenuItem(milist + bytes_used, bytes_left, L"&Paste",
                             ID_EDIT_PASTE, FALSE, TRUE);
   bytes_left -= bytes_used;

   // Load resource from a menu template in memory.
   ASSERT(m_IndiMenu.LoadMenuIndirect(milist));

   // Remove and destroy old menu
   SetMenu(NULL);
   ::DestroyMenu(m_hMenuDefault);

   // Add new menu.
   SetMenu(&m_IndiMenu);

   // Assign default menu
   m_hMenuDefault = m_IndiMenu.m_hMenu;
}

// This is a helper function for adding a menu item (either a popup
// or command item) to the specified menu template.
//
//    MenuTemplate  - pointer to a menu template
//    TemplateBytes - space remaining in MenuTemplate
//    MenuString    - string for the menu item to be added
//    MenuID        - id for the command item. Its value is ignored if
//                    IsPopup is TRUE.
//    IsPopup       - TRUE for popup menu (or submenu); FALSE for command
//                    item
//    LastItem      - TRUE if MenuString is the last item for the popup;
//                    FALSE otherwise.
UINT AddMenuItem(LPVOID MenuTemplate, int TemplateBytes, WCHAR *MenuString,
                 WORD MenuID, BOOL IsPopup, BOOL LastItem)
{
   MENUITEMTEMPLATE *mitem = (MENUITEMTEMPLATE*)MenuTemplate;

   UINT bytes_used = 0;
   if (IsPopup) // for popup menu
   {
      if (LastItem)
         mitem->mtOption = MF_POPUP | MF_END;
      else
         mitem->mtOption = MF_POPUP;
      bytes_used += sizeof(mitem->mtOption);

      mitem = (MENUITEMTEMPLATE*)((BYTE*)MenuTemplate + bytes_used);
      // a popup doesn't have mtID!!!

      TemplateBytes -= bytes_used;
      wcscpy_s((WCHAR*)mitem, TemplateBytes / sizeof(WCHAR), MenuString);
      bytes_used += (UINT)(sizeof(WCHAR) * (wcslen(MenuString) + 1)); // include '\0'
   }
   else // for command item
   {
      mitem->mtOption = LastItem ? MF_END : 0;
      mitem->mtID = MenuID;
      TemplateBytes -= bytes_used;
      wcscpy_s(mitem->mtString, TemplateBytes / sizeof(WCHAR), MenuString);
      bytes_used += (UINT)(sizeof(mitem->mtOption) + sizeof(mitem->mtID) +
                           sizeof(WCHAR) * (wcslen(MenuString) + 1)); // include '\0'
   }

   return bytes_used;
}

CMenu::m_hMenu

Especifica o HMENU handle do menu Windows associado ao CMenu objeto.

HMENU m_hMenu;

Example

Veja o exemplo para CMenu::LoadMenu.

CMenu::MeasureItem

É chamado pelo framework quando é criado um menu com o estilo proprietário-desenho.

virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);

Parâmetros

lpMeasureItemStruct
Um ponteiro para uma MEASUREITEMSTRUCT estrutura.

Observações

Por defeito, esta função membro não faz nada. Substitua esta função membro e preencha a MEASUREITEMSTRUCT estrutura para informar o Windows das dimensões do menu.

Veja CWnd::OnMeasureItem para uma descrição da MEASUREITEMSTRUCT estrutura.

Example

O seguinte código é do exemplo MFC CTRLTEST :

// Override MeasureItem() to return the size of the menu item.
// CColorMenu is a CMenu-derived class.

#define COLOR_BOX_WIDTH 20
#define COLOR_BOX_HEIGHT 20

void CColorMenu::MeasureItem(LPMEASUREITEMSTRUCT lpMIS)
{
   // all items are of fixed size
   lpMIS->itemWidth = COLOR_BOX_WIDTH;
   lpMIS->itemHeight = COLOR_BOX_HEIGHT;
}

CMenu::ModifyMenu

Altera um item de menu existente na posição especificada por nPosition.

BOOL ModifyMenu(
    UINT nPosition,
    UINT nFlags,
    UINT_PTR nIDNewItem = 0,
    LPCTSTR lpszNewItem = NULL);

BOOL ModifyMenu(
    UINT nPosition,
    UINT nFlags,
    UINT_PTR nIDNewItem,
    const CBitmap* pBmp);

Parâmetros

nPosition
Especifica o item do menu a ser alterado. O nFlags parâmetro pode ser usado para interpretar nPosition das seguintes formas:

nFlags
Especifica como nPosition é interpretado e fornece informações sobre as alterações a fazer no item do menu. Para uma lista de flags que podem ser definidos, veja a AppendMenu função membro.

nIDNewItem
Especifica o ID do comando do item modificado do menu ou, se nFlags estiver definido para MF_POPUP, o handle do menu (HMENU) de um menu pop-up. O nIDNewItem parâmetro é ignorado (não necessário) se nFlags for definido como MF_SEPARATOR.

lpszNewItem
Especifica o conteúdo do novo item do menu. O nFlags parâmetro pode ser usado para interpretar lpszNewItem das seguintes formas:

pBmp
Aponta para um CBitmap objeto que será usado como item do menu.

Valor de retorno

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

Observações

A aplicação especifica o novo estado do item do menu definindo valores em nFlags. Se esta função substituir um menu pop-up associado ao item do menu, destrói o menu pop-up antigo e liberta a memória usada pelo menu pop-up.

Quando nIDNewItem especifica um menu pop-up, este passa a fazer parte do menu onde é inserido. Se esse menu for destruído, o menu inserido também será destruído. Um menu inserido deve ser separado de um CMenu objeto para evitar conflitos.

Sempre que um menu que reside numa janela é alterado (quer a janela seja ou não exibida), a aplicação deve chamar CWnd::DrawMenuBar. Para alterar os atributos dos itens existentes do menu, é muito mais rápido usar as CheckMenuItem funções e EnableMenuItem membro.

Example

Veja o exemplo para CMenu::InsertMenu.

CMenu::operator HMENU

Use este operador para recuperar o cabo do CMenu objeto.

operator HMENU() const;

Valor de retorno

Se for bem-sucedido, o cabo do CMenu objeto; caso contrário, NULL.

Observações

Você pode usar o identificador para chamar APIs do Windows diretamente.

CMenu::operator !=

Determina se dois menus não são logicamente iguais.

BOOL operator!=(const CMenu& menu) const;

Parâmetros

menu
Um CMenu objeto para comparação.

Observações

Testa se um objeto de menu no lado esquerdo não é igual a um objeto de menu do lado direito.

CMenu::operator ==

Determina se dois menus são logicamente iguais.

BOOL operator==(const CMenu& menu) const;

Parâmetros

menu
Um CMenu objeto para comparação.

Observações

Testa se um objeto de menu no lado esquerdo é igual (em termos de HMENU valor) a um objeto de menu do lado direito.

CMenu::RemoveMenu

Apaga um item do menu com um menu pop-up associado no menu.

BOOL RemoveMenu(
    UINT nPosition,
    UINT nFlags);

Parâmetros

nPosition
Especifica o item do menu a ser removido. O nFlags parâmetro pode ser usado para interpretar nPosition das seguintes formas:

nFlags
Especifica como nPosition é interpretado.

Valor de retorno

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

Observações

Não destrói a alavanca de um menu pop-up, por isso o menu pode ser reutilizado. Antes de chamar esta função, a aplicação pode chamar a GetSubMenu função membro para recuperar o objeto pop-up CMenu para reutilização.

Sempre que um menu que reside numa janela é alterado (quer a janela seja ou não exibida), a aplicação deve chamar CWnd::DrawMenuBar.

Example

Veja o exemplo para CMenu::InsertMenu.

CMenu::SetDefaultItem

Define o item de menu padrão para o menu especificado.

BOOL SetDefaultItem(
    UINT uItem,
    BOOL fByPos = FALSE);

Parâmetros

uItem
Identificador ou posição do novo item predefinido do menu ou - 1 para nenhum item predefinido. O significado deste parâmetro depende do valor de fByPos.

fByPos
Valor que especifica o significado de uItem. Se este parâmetro for FALSE, uItem é um identificador de item do menu. Caso contrário, é uma posição de item no menu.

Valor de retorno

Se a função tiver sucesso, o valor de retorno é diferente de zero. Se a função falhar, o valor de retorno será zero. Para obter informação de erro alargada, use a função GetLastErrorWin32 , conforme descrito no SDK do Windows.

Observações

Esta função membro implementa o comportamento da função SetMenuDefaultItemWin32 , conforme descrito no SDK do Windows.

Example

Veja o exemplo para CMenu::InsertMenu.

CMenu::SetMenuContextHelpId

Associa um ID de ajuda contextual com CMenu.

BOOL SetMenuContextHelpId(DWORD dwContextHelpId);

Parâmetros

dwContextHelpId
Contexto ajuda ID para associar a CMenu.

Valor de retorno

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

Observações

Todos os itens do menu partilham este identificador — não é possível associar um identificador de contexto de ajuda aos itens individuais do menu.

Example

Veja o exemplo para CMenu::InsertMenu.

CMenu::SetMenuInfo

Define a informação para um menu.

BOOL SetMenuInfo(LPCMENUINFO lpcmi);

Parâmetros

lpcmi
Um ponteiro para uma MENUINFO estrutura contendo informação para o menu.

Valor de retorno

Se a função tiver sucesso, o valor de retorno é diferente de zero; caso contrário, o valor de retorno é zero.

Observações

Ligue para esta função para definir informações específicas sobre o menu.

CMenu::SetMenuItemBitmaps

Associa os bitmaps especificados a um item do menu.

BOOL SetMenuItemBitmaps(
    UINT nPosition,
    UINT nFlags,
    const CBitmap* pBmpUnchecked,
    const CBitmap* pBmpChecked);

Parâmetros

nPosition
Especifica o item do menu a ser alterado. O nFlags parâmetro pode ser usado para interpretar nPosition das seguintes formas:

nFlags
Especifica como nPosition é interpretado.

pBmpUnchecked
Especifica o bitmap a usar para itens do menu que não estão assinalados.

pBmpChecked
Especifica o bitmap a usar para os itens do menu que estão assinalados.

Valor de retorno

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

Observações

Quer o item do menu esteja assinalado ou desmarcado, o Windows mostra o bitmap apropriado ao lado do item do menu.

Se ou pBmpUncheckedpBmpChecked for NULL, então o Windows não mostra nada ao lado do elemento do menu para o atributo correspondente. Se ambos os parâmetros forem NULL, o Windows usa a marca de verificação padrão quando o item está marcado e remove a marca quando o item está desmarcado.

Quando o menu é destruído, estes bitmaps não são destruídos; A candidatura deve destruí-los.

A função Windows GetMenuCheckMarkDimensions recupera as dimensões da marca de verificação padrão usada para os itens do menu. A aplicação utiliza estes valores para determinar o tamanho adequado para os bitmaps fornecidos com esta função. Percebe o tamanho, cria os teus bitmaps e depois define-os.

Example

// The code fragment below is from CMainFrame::OnCreate and shows
// how to associate bitmaps with the "Bitmap" menu item.
// Whether the "Bitmap" menu item is checked or unchecked, Windows
// displays the appropriate bitmap next to the menu item. Both
// IDB_CHECKBITMAP and IDB_UNCHECKBITMAP bitmaps are loaded
// in OnCreate() and destroyed in the destructor of CMainFrame class.
// CMainFrame is a CFrameWnd-derived class.

// Load bitmaps from resource. Both m_CheckBitmap and m_UnCheckBitmap
// are member variables of CMainFrame class of type CBitmap.
ASSERT(m_CheckBitmap.LoadBitmap(IDB_CHECKBITMAP));
ASSERT(m_UnCheckBitmap.LoadBitmap(IDB_UNCHECKBITMAP));

// Associate bitmaps with the "Bitmap" menu item.
CMenu *mmenu = GetMenu();
CMenu *submenu = mmenu->GetSubMenu(4);
ASSERT(submenu->SetMenuItemBitmaps(ID_MENU_BITMAP, MF_BYCOMMAND,
                                   &m_CheckBitmap, &m_UnCheckBitmap));

// This code fragment is taken from CMainFrame::~CMainFrame

// Destroy the bitmap objects if they are loaded successfully
// in OnCreate().
if (m_CheckBitmap.m_hObject)
   m_CheckBitmap.DeleteObject();

if (m_UnCheckBitmap.m_hObject)
   m_UnCheckBitmap.DeleteObject();

CMenu::SetMenuItemInfo

Altera a informação sobre um item do menu.

BOOL SetMenuItemInfo(
    UINT uItem,
    LPMENUITEMINFO lpMenuItemInfo,
    BOOL fByPos = FALSE);

Parâmetros

uItem
Veja a descrição de uItem em SetMenuItemInfo no SDK do Windows.

lpMenuItemInfo
Veja a descrição de lpmii em SetMenuItemInfo no SDK do Windows.

fByPos
Veja a descrição de fByPosition em SetMenuItemInfo no SDK do Windows.

Observações

Esta função envolve SetMenuItemInfo, descrito no SDK do Windows.

CMenu::TrackPopupMenu

Exibe um menu pop-up flutuante no local especificado e acompanha a seleção de itens no menu pop-up.

BOOL TrackPopupMenu(
    UINT nFlags,
    int x,
    int y,
    CWnd* pWnd,
    LPCRECT lpRect = 0);

Parâmetros

nFlags
Especifica flags de posição no ecrã e de posição do rato. Consulte TrackPopupMenu a lista de bandeiras disponíveis.

x
Especifica a posição horizontal nas coordenadas do ecrã do menu pop-up. Dependendo do valor do nFlags parâmetro, o menu pode ser alinhado à esquerda, à direita ou centrado em relação a esta posição.

y
Especifica a posição vertical nas coordenadas do ecrã do topo do menu no ecrã.

pWnd
Identifica a janela que possui o menu pop-up. Este parâmetro não pode ser NULL, mesmo que o TPM_NONOTIFY flag seja especificado. Esta janela recebe todas WM_COMMAND as mensagens do menu. Nas versões 3.1 do Windows e posteriores, a janela não recebe WM_COMMAND mensagens até TrackPopupMenu receber retornos. No Windows 3.0, a janela recebe WM_COMMAND mensagens antes TrackPopupMenu dos retornos.

lpRect
Ignorado.

Valor de retorno

Este método devolve o resultado de chamar TrackPopupMenu o SDK do Windows.

Observações

Um menu pop-up flutuante pode aparecer em qualquer parte do ecrã.

Example

// The code fragment shows how to get the File menu from the
// application window and displays it as a floating popup menu
// when the right mouse button is clicked in view.
// CMdiView is a CView-derived class.
void CMdiView::OnRButtonDown(UINT nFlags, CPoint point)
{
   CView::OnRButtonDown(nFlags, point);

   CMenu *menu_bar = AfxGetMainWnd()->GetMenu();
   CMenu *file_menu = menu_bar->GetSubMenu(0);
   ASSERT(file_menu);

   ClientToScreen(&point);
   file_menu->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x,
                             point.y, this);
}

CMenu::TrackPopupMenuEx

Exibe um menu pop-up flutuante no local especificado e acompanha a seleção de itens no menu pop-up.

BOOL TrackPopupMenuEx(
    UINT fuFlags,
    int x,
    int y,
    CWnd* pWnd,
    LPTPMPARAMS lptpm);

Parâmetros

fuFlags
Especifica várias funções para o menu alargado. Para uma lista de todos os valores e o seu significado, veja TrackPopupMenuEx.

x
Especifica a posição horizontal nas coordenadas do ecrã do menu pop-up.

y
Especifica a posição vertical nas coordenadas do ecrã do topo do menu no ecrã.

pWnd
Um apontador para a janela que possui o menu pop-up e recebe as mensagens do menu criado. Esta janela pode ser qualquer janela da aplicação atual, mas não pode ser NULL. Se especificar TPM_NONOTIFY no fuFlags parâmetro, a função não envia mensagens para pWnd. A função deve retornar para que a janela apontada por pWnd receba a WM_COMMAND mensagem.

lptpm
Apontador para uma TPMPARAMS estrutura que especifica uma área do ecrã, o menu não deve sobrepor-se. Este parâmetro pode ser NULL.

Valor de retorno

Se especificar TPM_RETURNCMD no fuFlags parâmetro, o valor de retorno é o identificador do item do menu do item que o utilizador selecionou. Se o utilizador cancelar o menu sem fazer uma seleção, ou se ocorrer um erro, então o valor de retorno é 0.

Se não especificar TPM_RETURNCMD no fuFlags parâmetro, o valor de retorno é diferente de zero se a função tiver sucesso e 0 se falhar. Para obter informações de erro estendidas, ligue para GetLastError.

Observações

Um menu pop-up flutuante pode aparecer em qualquer parte do ecrã. Para mais informações sobre como lidar com erros ao criar o menu pop-up, consulte TrackPopupMenuEx.

Consulte também

Exemplo MFC CTRLTEST
Exemplo MFC DYNAMENU
CObject Classe
Gráfico de Hierarquia