Partager via

La classe CMenu

  • Article

Encapsulation du HMENUWindows.

Syntaxe

class CMenu : public CObject

Membres

Constructeurs publics

Nom Description
CMenu::CMenu Construit un objet CMenu.

Méthodes publiques

Nom Description
CMenu::AppendMenu Ajoute un nouvel élément à la fin de ce menu.
CMenu::Attach Attache un handle de menu Windows à un CMenu objet.
CMenu::CheckMenuItem Place une coche en regard ou supprime une coche d’un élément de menu dans le menu contextuel.
CMenu::CheckMenuRadioItem Place une case d’option en regard d’un élément de menu et supprime la case d’option de tous les autres éléments de menu du groupe.
CMenu::CreateMenu Crée un menu vide et l’attache à un CMenu objet.
CMenu::CreatePopupMenu Crée un menu contextuel vide et l’attache à un CMenu objet.
CMenu::DeleteMenu Supprime un élément spécifié du menu. Si l’élément de menu comporte un menu contextuel associé, détruit la poignée du menu contextuel et libère la mémoire utilisée par celui-ci.
CMenu::DeleteTempMap Supprime tous les objets temporaires CMenu créés par la FromHandle fonction membre.
CMenu::DestroyMenu Détruit le menu attaché à un CMenu objet et libère toute mémoire occupée par le menu.
CMenu::Detach Détache un handle de menu Windows d’un CMenu objet et retourne le handle.
CMenu::DrawItem Appelé par l’infrastructure lorsqu’un aspect visuel d’un menu dessiné par le propriétaire change.
CMenu::EnableMenuItem Active, désactive ou désactive (gris) un élément de menu.
CMenu::FromHandle Retourne un pointeur vers un objet en fonction d’un CMenu handle de menu Windows.
CMenu::GetDefaultItem Détermine l’élément de menu par défaut dans le menu spécifié.
CMenu::GetMenuContextHelpId Récupère l’ID de contexte d’aide associé au menu.
CMenu::GetMenuInfo Récupère des informations dans un menu spécifique.
CMenu::GetMenuItemCount Détermine le nombre d’éléments dans un menu contextuel ou de niveau supérieur.
CMenu::GetMenuItemID Obtient l’identificateur d’élément de menu pour un élément de menu situé à la position spécifiée.
CMenu::GetMenuItemInfo Récupère des informations sur un élément de menu.
CMenu::GetMenuState Retourne l’état de l’élément de menu spécifié ou le nombre d’éléments dans un menu contextuel.
CMenu::GetMenuString Récupère l’étiquette de l’élément de menu spécifié.
CMenu::GetSafeHmenu Retourne le m_hMenu wrapper par cet CMenu objet.
CMenu::GetSubMenu Récupère un pointeur vers un menu contextuel.
CMenu::InsertMenu Insère un nouvel élément de menu à la position spécifiée, déplaçant d’autres éléments vers le bas du menu.
CMenu::InsertMenuItem Insère un nouvel élément de menu à la position spécifiée dans un menu.
CMenu::LoadMenu Charge une ressource de menu à partir du fichier exécutable et l’attache à un CMenu objet.
CMenu::LoadMenuIndirect Charge un menu à partir d’un modèle de menu en mémoire et l’attache à un CMenu objet.
CMenu::MeasureItem Appelé par l’infrastructure pour déterminer les dimensions du menu lors de la création d’un menu dessiné par le propriétaire.
CMenu::ModifyMenu Modifie un élément de menu existant à la position spécifiée.
CMenu::RemoveMenu Supprime un élément de menu avec un menu contextuel associé dans le menu spécifié.
CMenu::SetDefaultItem Définit l’élément de menu par défaut du menu spécifié.
CMenu::SetMenuContextHelpId Définit l’ID de contexte d’aide à associer au menu.
CMenu::SetMenuInfo Définit des informations sur un menu spécifique.
CMenu::SetMenuItemBitmaps Associe les bitmaps de coche spécifiées à un élément de menu.
CMenu::SetMenuItemInfo Modifie les informations relatives à un élément de menu.
CMenu::TrackPopupMenu Affiche un menu contextuel flottant à l’emplacement spécifié et suit la sélection d’éléments dans le menu contextuel.
CMenu::TrackPopupMenuEx Affiche un menu contextuel flottant à l’emplacement spécifié et suit la sélection d’éléments dans le menu contextuel.

Opérateurs publics

Nom Description
CMenu::operator HMENU Récupère le handle de l’objet de menu.
CMenu::operator != Détermine si deux objets de menu ne sont pas égaux.
CMenu::operator == Détermine si deux objets de menu sont égaux.

Membres de données publics

Nom Description
CMenu::m_hMenu Spécifie le handle du menu Windows attaché à l’objet CMenu .

Notes

Il fournit des fonctions membres pour la création, le suivi, la mise à jour et la destruction d’un menu.

Créez un CMenu objet sur le cadre de pile en tant que local, puis appelez les fonctions membres de l’équipe CMenupour manipuler le nouveau menu en fonction des besoins. Ensuite, appelez CWnd::SetMenu pour définir le menu sur une fenêtre, suivi immédiatement d’un appel à la fonction membre de Detach l’objetCMenu. La CWnd::SetMenu fonction membre définit le menu de la fenêtre sur le nouveau menu, entraîne le redéployement de la fenêtre pour refléter la modification du menu et transmet également la propriété du menu à la fenêtre. L’appel à Detach détacher l’objet CMenu HMENU, de sorte que lorsque la variable locale CMenu passe hors de portée, le CMenu destructeur d’objet ne tente pas de détruire un menu qu’il ne possède plus. Le menu lui-même est automatiquement détruit lorsque la fenêtre est détruite.

Vous pouvez utiliser la LoadMenuIndirect fonction membre pour créer un menu à partir d’un modèle en mémoire, mais un menu créé à partir d’une ressource par un appel à est plus facile à LoadMenu gérer, et la ressource de menu elle-même peut être créée et modifiée par l’éditeur de menu.

Hiérarchie d'héritage

CObject

CMenu

Spécifications

En-tête : afxwin.h

CMenu::AppendMenu

Ajoute un nouvel élément à la fin d’un menu.

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

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

Paramètres

nFlags
Spécifie des informations sur l’état du nouvel élément de menu lorsqu’il est ajouté au menu. Il se compose d’une ou plusieurs valeurs répertoriées dans la section Notes.

nIDNewItem
Spécifie l’ID de commande du nouvel élément de menu ou, s’il nFlags est défini MF_POPUPsur , le handle de menu (HMENU) d’un menu contextuel. Le nIDNewItem paramètre est ignoré (non nécessaire) s’il nFlags est défini sur MF_SEPARATOR.

lpszNewItem
Spécifie le contenu du nouvel élément de menu. Le nFlags paramètre est utilisé pour interpréter lpszNewItem de la façon suivante :

nFlags Interprétation de lpszNewItem
MF_OWNERDRAW Contient une valeur 32 bits fournie par l’application que l’application peut utiliser pour conserver des données supplémentaires associées à l’élément de menu. Cette valeur 32 bits est disponible pour l’application lorsqu’elle traite WM_MEASUREITEM et WM_DRAWITEM les messages. La valeur est stockée dans le itemData membre de la structure fournie avec ces messages.
MF_STRING Contient un pointeur vers une chaîne terminée par null. Il s’agit de l’interprétation par défaut.
MF_SEPARATOR Le lpszNewItem paramètre est ignoré (non nécessaire).

pBmp
Pointe vers un CBitmap objet qui sera utilisé comme élément de menu.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

L’application peut spécifier l’état de l’élément de menu en définissant des valeurs dans nFlags. Lorsque nIDNewItem vous spécifiez un menu contextuel, il fait partie du menu auquel il est ajouté. Si ce menu est détruit, le menu ajouté est également détruit. Un menu ajouté doit être détaché d’un CMenu objet pour éviter les conflits. Notez que MF_STRING et MF_OWNERDRAW ne sont pas valides pour la version bitmap de AppendMenu.

La liste suivante décrit les indicateurs qui peuvent être définis dans nFlags:

  • MF_CHECKED Agit comme un bouton bascule avec MF_UNCHECKED pour placer la coche par défaut en regard de l’élément. Lorsque l’application fournit des bitmaps de coche (voir la SetMenuItemBitmaps fonction membre), la bitmap « coche activée » s’affiche.

  • MF_UNCHECKED Agit comme un bouton bascule avec MF_CHECKED pour supprimer une coche en regard de l’élément. Lorsque l’application fournit des bitmaps de coche (voir la SetMenuItemBitmaps fonction membre), la bitmap « coche désactivée » s’affiche.

  • MF_DISABLED Désactive l’élément de menu afin qu’il ne puisse pas être sélectionné, mais ne le désactive pas.

  • MF_ENABLED Active l’élément de menu afin qu’il puisse être sélectionné et le restaurer à partir de son état grisé.

  • MF_GRAYED Désactive l’élément de menu afin qu’il ne puisse pas être sélectionné et le désactive.

  • MF_MENUBARBREAK Place l’élément sur une nouvelle ligne dans les menus statiques ou dans une nouvelle colonne dans les menus contextuels. La nouvelle colonne de menu contextuel sera séparée de l’ancienne colonne par une ligne de division verticale.

  • MF_MENUBREAK Place l’élément sur une nouvelle ligne dans les menus statiques ou dans une nouvelle colonne dans les menus contextuels. Aucune ligne de division n’est placée entre les colonnes.

  • MF_OWNERDRAW Spécifie que l’élément est un élément de dessin propriétaire. Lorsque le menu s’affiche pour la première fois, la fenêtre propriétaire du menu reçoit un WM_MEASUREITEM message, qui récupère la hauteur et la largeur de l’élément de menu. Le WM_DRAWITEM message est celui envoyé chaque fois que le propriétaire doit mettre à jour l’apparence visuelle de l’élément de menu. Cette option n’est pas valide pour un élément de menu de niveau supérieur.

  • MF_POPUP Spécifie que l’élément de menu comporte un menu contextuel associé. Le paramètre ID spécifie un handle dans un menu contextuel qui doit être associé à l’élément. Cela est utilisé pour ajouter un menu contextuel de niveau supérieur ou un menu contextuel hiérarchique à un élément de menu contextuel.

  • MF_SEPARATOR Dessine une ligne de division horizontale. Peut être utilisé uniquement dans un menu contextuel. Cette ligne ne peut pas être grisée, désactivée ou mise en surbrillance. D’autres paramètres sont ignorés.

  • MF_STRING Spécifie que l’élément de menu est une chaîne de caractères.

Chacun des groupes suivants répertorie les indicateurs qui s’excluent mutuellement et ne peuvent pas être utilisés ensemble :

  • MF_DISABLED, MF_ENABLED et MF_GRAYED

  • MF_STRING, MF_OWNERDRAW, MF_SEPARATORet la version bitmap

  • MF_MENUBARBREAK et MF_MENUBREAK

  • MF_CHECKED et MF_UNCHECKED

Chaque fois qu’un menu qui réside dans une fenêtre est modifié (si la fenêtre est affichée ou non), l’application doit appeler CWnd::DrawMenuBar.

Exemple

Consultez l’exemple pour CMenu::CreateMenu.

CMenu::Attach

Attache un menu Windows existant à un CMenu objet.

BOOL Attach(HMENU hMenu);

Paramètres

hMenu
Spécifie un handle dans un menu Windows.

Valeur de retour

Différent de zéro si l’opération a réussi ; sinon 0.

Notes

Cette fonction ne doit pas être appelée si un menu est déjà attaché à l’objet CMenu . Le handle de menu est stocké dans le membre de m_hMenu données.

Si le menu que vous souhaitez manipuler est déjà associé à une fenêtre, vous pouvez utiliser la CWnd::GetMenu fonction pour obtenir un handle dans le menu.

Exemple

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

Ajoute ou supprime des coches des éléments de menu dans le menu contextuel.

UINT CheckMenuItem(
    UINT nIDCheckItem,
    UINT nCheck);

Paramètres

nIDCheckItem
Spécifie l’élément de menu à vérifier, tel que déterminé par nCheck.

nCheck
Spécifie comment vérifier l’élément de menu et déterminer la position de l’élément dans le menu. Le nCheck paramètre peut être une combinaison ou MF_CHECKED MF_UNCHECKED avec ou MF_BYCOMMAND des MF_BYPOSITION indicateurs. Ces indicateurs peuvent être combinés à l’aide de l’opérateur OR au niveau du bit. Ils ont les significations suivantes :

  • MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut.

  • MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

  • MF_CHECKED Agit comme un bouton bascule avec MF_UNCHECKED pour placer la coche par défaut en regard de l’élément.

  • MF_UNCHECKED Agit comme un bouton bascule avec MF_CHECKED pour supprimer une coche en regard de l’élément.

Valeur de retour

État précédent de l’élément : MF_CHECKED ou MF_UNCHECKED, ou 0xFFFFFFFF si l’élément de menu n’existait pas.

Notes

Le nIDCheckItem paramètre spécifie l’élément à modifier.

Le nIDCheckItem paramètre peut identifier un élément de menu contextuel ainsi qu’un élément de menu. Aucune étape spéciale n’est nécessaire pour vérifier un élément de menu contextuel. Les éléments de menu de niveau supérieur ne peuvent pas être vérifiés. Un élément de menu contextuel doit être vérifié par position, car il n’a pas d’identificateur d’élément de menu associé à celui-ci.

Exemple

Consultez l’exemple pour CMenu::GetMenuState.

CMenu::CheckMenuRadioItem

Vérifie un élément de menu spécifié et le fait d’un élément radio.

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

Paramètres

nIDFirst
Spécifie (en tant qu’ID ou décalage, en fonction de la valeur de nFlags) le premier élément de menu dans le groupe de cases d’option.

nIDLast
Spécifie (en tant qu’ID ou décalage, en fonction de la valeur de nFlags) le dernier élément de menu du groupe de cases d’option.

nIDItem
Spécifie (en tant qu’ID ou décalage, selon la valeur de nFlags) l’élément du groupe qui sera coché avec une case d’option.

nFlags
Spécifie l’interprétation de nIDFirst, nIDLastet nIDItem de la manière suivante :

nFlags Interprétation
MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut si ni aucune MF_BYCOMMAND n’est MF_BYPOSITION définie.
MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

Valeur de retour

Différent de zéro s’il réussit ; sinon 0

Notes

En même temps, la fonction désactive tous les autres éléments de menu du groupe associé et efface l’indicateur de type d’élément radio pour ces éléments. L’élément vérifié s’affiche à l’aide d’une bitmap de case d’option (ou puce) au lieu d’une bitmap de coche.

Exemple

Consultez l’exemple pour ON_COMMAND_RANGE.

CMenu::CMenu

Crée un menu vide et l’attache à un CMenu objet.

CMenu();

Notes

Le menu n’est pas créé tant que vous n’appelez pas l’une des fonctions de création ou de chargement des membres :CMenu

CMenu::CreateMenu

Crée un menu et l’attache à l’objet CMenu .

BOOL CreateMenu();

Valeur de retour

Différent de zéro si le menu a été créé avec succès ; sinon 0.

Notes

Le menu est initialement vide. Les éléments de menu peuvent être ajoutés à l’aide de la fonction membre ou InsertMenu de la AppendMenu fonction membre.

Si le menu est affecté à une fenêtre, il est automatiquement détruit lorsque la fenêtre est détruite.

Avant de quitter, une application doit libérer les ressources système associées à un menu si le menu n’est pas affecté à une fenêtre. Une application libère un menu en appelant la DestroyMenu fonction membre.

Exemple

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

Crée un menu contextuel et l’attache à l’objet CMenu .

BOOL CreatePopupMenu();

Valeur de retour

Différent de zéro si le menu contextuel a été créé avec succès ; sinon 0.

Notes

Le menu est initialement vide. Les éléments de menu peuvent être ajoutés à l’aide de la fonction membre ou InsertMenu de la AppendMenu fonction membre. L’application peut ajouter le menu contextuel à un menu contextuel existant ou à un menu contextuel. La TrackPopupMenu fonction membre peut être utilisée pour afficher ce menu en tant que menu contextuel flottant et suivre les sélections dans le menu contextuel.

Si le menu est affecté à une fenêtre, il est automatiquement détruit lorsque la fenêtre est détruite. Si le menu est ajouté à un menu existant, il est automatiquement détruit lorsque ce menu est détruit.

Avant de quitter, une application doit libérer des ressources système associées à un menu contextuel si le menu n’est pas affecté à une fenêtre. Une application libère un menu en appelant la DestroyMenu fonction membre.

Exemple

Consultez l’exemple pour CMenu::CreateMenu.

CMenu::DeleteMenu

Supprime un élément du menu.

BOOL DeleteMenu(
    UINT nPosition,
    UINT nFlags);

Paramètres

nPosition
Spécifie l’élément de menu à supprimer, tel que déterminé par nFlags.

nFlags
Est utilisé pour interpréter nPosition de la façon suivante :

nFlags Interprétation de nPosition
MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut si ni aucune MF_BYCOMMAND n’est MF_BYPOSITION définie.
MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

Si l’élément de menu contient un menu contextuel associé, DeleteMenu détruit la poignée du menu contextuel et libère la mémoire utilisée par le menu contextuel.

Chaque fois qu’un menu qui réside dans une fenêtre est modifié (si la fenêtre est affichée ou non), l’application doit appeler CWnd::DrawMenuBar.

Exemple

Consultez l’exemple pour CWnd::GetMenu.

CMenu::DeleteTempMap

Appelé automatiquement par le CWinApp gestionnaire d’inactivité, supprime tous les objets temporaires créés CMenu par la FromHandle fonction membre.

static void PASCAL DeleteTempMap();

Notes

DeleteTempMap détache l’objet de menu Windows attaché à un objet temporaire CMenu avant de supprimer l’objet CMenu .

Exemple

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

CMenu::DestroyMenu

Détruit le menu et toutes les ressources Windows utilisées.

BOOL DestroyMenu();

Valeur de retour

Différent de zéro si le menu est détruit ; sinon 0.

Notes

Le menu est détaché de l’objet CMenu avant sa destruction. La fonction Windows DestroyMenu est automatiquement appelée dans le CMenu destructeur.

Exemple

Consultez l’exemple pour CMenu::CreateMenu.

CMenu::Detach

Détache un menu Windows d’un CMenu objet et retourne le handle.

HMENU Detach();

Valeur de retour

Handle, de type HMENU, à un menu Windows, s’il réussit ; sinon NULL.

Notes

Le m_hMenu membre de données est défini sur NULL.

Exemple

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

Appelé par l’infrastructure lorsqu’un aspect visuel d’un menu dessiné par le propriétaire change.

virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);

Paramètres

lpDrawItemStruct
Pointeur vers une DRAWITEMSTRUCT structure qui contient des informations sur le type de dessin requis.

Notes

Le itemAction membre de la DRAWITEMSTRUCT structure définit l’action de dessin à effectuer. Remplacez cette fonction membre pour implémenter le dessin pour un objet de dessin CMenu propriétaire. L’application doit restaurer tous les objets GDI (Graphics Device Interface) sélectionnés pour le contexte d’affichage fourni lpDrawItemStruct avant l’arrêt de cette fonction membre.

Consultez CWnd::OnDrawItem une description de la DRAWITEMSTRUCT structure.

Exemple

Le code suivant provient de l’exemple 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

Active, désactive ou désactive un élément de menu.

UINT EnableMenuItem(
    UINT nIDEnableItem,
    UINT nEnable);

Paramètres

nIDEnableItem
Spécifie l’élément de menu à activer, tel que déterminé par nEnable. Ce paramètre peut spécifier des éléments de menu contextuel ainsi que des éléments de menu standard.

nEnable
Spécifie l’action à entreprendre. Il peut s’agir d’une combinaison de MF_DISABLED, MF_ENABLEDou MF_GRAYED, avec MF_BYCOMMAND ou MF_BYPOSITION. Ces valeurs peuvent être combinées à l’aide de l’opérateur OR au niveau du bit C++ (|). Ces valeurs ont les significations suivantes :

  • MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut.

  • MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

  • MF_DISABLED Désactive l’élément de menu afin qu’il ne puisse pas être sélectionné, mais ne le désactive pas.

  • MF_ENABLED Active l’élément de menu afin qu’il puisse être sélectionné et le restaurer à partir de son état grisé.

  • MF_GRAYED Désactive l’élément de menu afin qu’il ne puisse pas être sélectionné et le désactive.

Valeur de retour

État précédent (MF_DISABLED, MF_ENABLEDou ) ou MF_GRAYED-1 s’il n’est pas valide.

Notes

Les CreateMenufonctions , , InsertMenuModifyMenuet LoadMenuIndirect membres peuvent également définir l’état (activé, désactivé ou grisé) d’un élément de menu.

L’utilisation de la MF_BYPOSITION valeur nécessite qu’une application utilise la valeur correcte CMenu. Si la CMenu barre de menus est utilisée, un élément de menu de niveau supérieur (un élément dans la barre de menus) est affecté. Pour définir l’état d’un élément dans un menu contextuel ou imbriqué par position, une application doit spécifier le CMenu menu contextuel.

Lorsqu’une application spécifie l’indicateur MF_BYCOMMAND , Windows vérifie tous les éléments de menu contextuel qui sont subordonnés au CMenu; par conséquent, sauf si des éléments de menu en double sont présents, l’utilisation de la CMenu barre de menus est suffisante.

Exemple

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

Retourne un pointeur vers un objet donné à un CMenu handle Windows vers un menu.

static CMenu* PASCAL FromHandle(HMENU hMenu);

Paramètres

hMenu
Handle Windows vers un menu.

Valeur de retour

Pointeur vers un CMenu pointeur qui peut être temporaire ou permanent.

Notes

Si un CMenu objet n’est pas déjà attaché à l’objet de menu Windows, un objet temporaire CMenu est créé et attaché.

Cet objet temporaire CMenu est valide uniquement jusqu’à la prochaine fois que l’application a un temps d’inactivité dans sa boucle d’événements, à laquelle tous les objets temporaires sont supprimés.

Exemple

Consultez l’exemple pour CMenu::CreateMenu.

CMenu::GetDefaultItem

Détermine l’élément de menu par défaut dans le menu spécifié.

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

Paramètres

gmdiFlags
Valeur spécifiant la façon dont la fonction recherche les éléments de menu. Ce paramètre ne peut être aucun, un ou une combinaison des valeurs suivantes :

Valeur Signification
GMDI_GOINTOPOPUPS Spécifie que, si l’élément par défaut est un élément qui ouvre un sous-menu, la fonction consiste à effectuer une recherche dans le sous-menu correspondant de manière récursive. Si le sous-menu n’a pas d’élément par défaut, la valeur de retour identifie l’élément qui ouvre le sous-menu.

Par défaut, la fonction retourne le premier élément par défaut dans le menu spécifié, qu’il s’agisse d’un élément qui ouvre un sous-menu.
GMDI_USEDISABLED Spécifie que la fonction doit retourner un élément par défaut, même s’il est désactivé.

Par défaut, la fonction ignore les éléments désactivés ou grisés.

fByPos
Valeur spécifiant s’il faut récupérer l’identificateur de l’élément de menu ou sa position. Si ce paramètre est FALSEdéfini, l’identificateur est retourné. Sinon, la position est retournée.

Valeur de retour

Si la fonction réussit, la valeur de retour est l’identificateur ou la position de l’élément de menu. Si la fonction échoue, la valeur de retour est - 1.

Notes

Cette fonction membre implémente le comportement de la fonction Win32 GetMenuDefaultItem, comme décrit dans le SDK Windows.

Exemple

Consultez l’exemple pour CMenu::InsertMenu.

CMenu::GetMenuContextHelpId

Récupère l’ID d’aide du contexte associé à CMenu.

DWORD GetMenuContextHelpId() const;

Valeur de retour

ID d’aide de contexte actuellement associé s’il CMenu en a un ; sinon, zéro.

Exemple

Consultez l’exemple pour CMenu::InsertMenu.

CMenu::GetMenuInfo

Récupère des informations pour un menu.

BOOL GetMenuInfo(LPMENUINFO lpcmi) const;

Paramètres

lpcmi
Pointeur vers une MENUINFO structure contenant des informations pour le menu.

Valeur de retour

Si la fonction réussit, la valeur de retour est différente de zéro ; sinon, la valeur de retour est égale à zéro.

Notes

Appelez cette fonction pour récupérer des informations sur le menu.

CMenu::GetMenuItemCount

Détermine le nombre d’éléments dans un menu contextuel ou de niveau supérieur.

UINT GetMenuItemCount() const;

Valeur de retour

Nombre d’éléments dans le menu si la fonction réussit ; sinon -1.

Exemple

Consultez l’exemple pour CWnd::GetMenu.

CMenu::GetMenuItemID

Obtient l’identificateur d’élément de menu d’un élément de menu situé à la position définie par nPos.

UINT GetMenuItemID(int nPos) const;

Paramètres

nPos
Spécifie la position (de base zéro) de l’élément de menu dont l’ID est récupéré.

Valeur de retour

ID d’élément de l’élément spécifié dans un menu contextuel si la fonction réussit. Si l’élément spécifié est un menu contextuel (par opposition à un élément dans le menu contextuel), la valeur de retour est -1. Si nPos correspond à un SEPARATOR élément de menu, la valeur de retour est 0.

Exemple

Consultez l’exemple pour CMenu::InsertMenu.

CMenu::GetMenuItemInfo

Récupère des informations sur un élément de menu.

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

Paramètres

uItem
Identificateur ou position de l’élément de menu pour obtenir des informations sur. La signification de ce paramètre dépend de la valeur de ByPos.

lpMenuItemInfo
Pointeur vers un MENUITEMINFOpointeur, comme décrit dans le Kit de développement logiciel (SDK) Windows, qui contient des informations sur le menu.

fByPos
Valeur spécifiant la signification de nIDItem. Par défaut, est FALSE, ByPos qui indique que uItem est un identificateur d’élément de menu. S’il ByPos n’est pas défini FALSEsur , il indique une position d’élément de menu.

Valeur de retour

Si la fonction réussit, la valeur de retour est différente de zéro. Si la fonction échoue, la valeur de retour est égale à zéro. Pour obtenir des informations d’erreur étendues, utilisez la fonction GetLastErrorWin32, comme décrit dans le Kit de développement logiciel (SDK) Windows.

Notes

Cette fonction membre implémente le comportement de la fonction GetMenuItemInfoWin32, comme décrit dans le Kit de développement logiciel (SDK) Windows. Notez que dans l’implémentation MFC de GetMenuItemInfo, vous n’utilisez pas de handle pour un menu.

Exemple

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

Retourne l’état de l’élément de menu spécifié ou le nombre d’éléments dans un menu contextuel.

UINT GetMenuState(
    UINT nID,
    UINT nFlags) const;

Paramètres

nID
Spécifie l’ID de l’élément de menu, tel que déterminé par nFlags.

nFlags
Spécifie la nature de nID. Ce peut être l’une des valeurs suivantes :

  • MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut.

  • MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

Valeur de retour

Valeur 0xFFFFFFFF si l’élément spécifié n’existe pas. Si nId vous identifiez un menu contextuel, l’octet de commande élevée contient le nombre d’éléments dans le menu contextuel et l’octet de faible ordre contient les indicateurs de menu associés au menu contextuel. Sinon, la valeur de retour est un masque (OR booléen) des valeurs de la liste suivante (ce masque décrit l’état de l’élément de menu qui nId identifie) :

  • MF_CHECKED Agit comme un bouton bascule avec MF_UNCHECKED pour placer la coche par défaut en regard de l’élément. Lorsque l’application fournit des bitmaps de coche (voir la SetMenuItemBitmaps fonction membre), la bitmap « coche activée » s’affiche.

  • MF_DISABLED Désactive l’élément de menu afin qu’il ne puisse pas être sélectionné, mais ne le désactive pas.

  • MF_ENABLED Active l’élément de menu afin qu’il puisse être sélectionné et le restaurer à partir de son état grisé. Notez que la valeur de cette constante est 0 ; une application ne doit pas tester la valeur 0 en cas d’échec lors de l’utilisation de cette valeur.

  • MF_GRAYED Désactive l’élément de menu afin qu’il ne puisse pas être sélectionné et le désactive.

  • MF_MENUBARBREAK Place l’élément sur une nouvelle ligne dans les menus statiques ou dans une nouvelle colonne dans les menus contextuels. La nouvelle colonne de menu contextuel sera séparée de l’ancienne colonne par une ligne de division verticale.

  • MF_MENUBREAK Place l’élément sur une nouvelle ligne dans les menus statiques ou dans une nouvelle colonne dans les menus contextuels. Aucune ligne de division n’est placée entre les colonnes.

  • MF_SEPARATOR Dessine une ligne de division horizontale. Peut être utilisé uniquement dans un menu contextuel. Cette ligne ne peut pas être grisée, désactivée ou mise en surbrillance. D’autres paramètres sont ignorés.

  • MF_UNCHECKED Agit comme un bouton bascule avec MF_CHECKED pour supprimer une coche en regard de l’élément. Lorsque l’application fournit des bitmaps de coche (voir la SetMenuItemBitmaps fonction membre), la bitmap « coche désactivée » s’affiche. Notez que la valeur de cette constante est 0 ; une application ne doit pas tester la valeur 0 en cas d’échec lors de l’utilisation de cette valeur.

Exemple

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

Copie l’étiquette de l’élément de menu spécifié dans la mémoire tampon spécifiée.

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

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

Paramètres

nIDItem
Spécifie l’identificateur entier de l’élément de menu ou le décalage de l’élément de menu dans le menu, en fonction de la valeur de nFlags.

lpString
Pointe vers la mémoire tampon qui doit recevoir l’étiquette.

rString
Référence à un CString objet qui doit recevoir la chaîne de menu copiée.

nMaxCount
Spécifie la longueur maximale (en caractères) de l’étiquette à copier. Si l’étiquette est supérieure à la valeur maximale spécifiée, nMaxCountles caractères supplémentaires sont tronqués.

nFlags
Spécifie l’interprétation du nIDItem paramètre. Ce peut être l’une des valeurs suivantes :

nFlags Interprétation de nIDItem
MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut si ni aucune MF_BYCOMMAND n’est MF_BYPOSITION définie.
MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

Valeur de retour

Spécifie le nombre réel de caractères copiés dans la mémoire tampon, sans inclure le point de terminaison Null.

Notes

Le nMaxCount paramètre doit être un plus grand que le nombre de caractères de l’étiquette pour prendre en charge le caractère Null qui met fin à une chaîne.

Exemple

Consultez l’exemple pour CMenu::InsertMenu.

CMenu::GetSafeHmenu

Retourne le HMENU wrapper par cet CMenu objet ou un NULL CMenu pointeur.

HMENU GetSafeHmenu() const;

Exemple

Consultez l’exemple pour CMenu::LoadMenu.

CMenu::GetSubMenu

Récupère l’objet CMenu d’un menu contextuel.

CMenu* GetSubMenu(int nPos) const;

Paramètres

nPos
Spécifie la position du menu contextuel contenu dans le menu. Les valeurs de position commencent à 0 pour le premier élément de menu. L’identificateur du menu contextuel ne peut pas être utilisé dans cette fonction.

Valeur de retour

Pointeur vers un CMenu objet dont m_hMenu le membre contient un handle vers le menu contextuel si un menu contextuel existe à la position donnée ; sinon NULL. S’il n’existe pas d’objet CMenu , un objet temporaire est créé. Le CMenu pointeur retourné ne doit pas être stocké.

Exemple

Consultez l’exemple pour CMenu::TrackPopupMenu.

CMenu::InsertMenu

Insère un nouvel élément de menu à la position spécifiée par nPosition et déplace d’autres éléments vers le bas du 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);

Paramètres

nPosition
Spécifie l’élément de menu avant lequel le nouvel élément de menu doit être inséré. Le nFlags paramètre peut être utilisé pour interpréter nPosition de la manière suivante :

nFlags Interprétation de nPosition
MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut si ni aucune MF_BYCOMMAND n’est MF_BYPOSITION définie.
MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0. Si nPosition la valeur est -1, le nouvel élément de menu est ajouté à la fin du menu.

nFlags
Spécifie comment nPosition est interprété et spécifie des informations sur l’état du nouvel élément de menu lorsqu’il est ajouté au menu. Pour obtenir la liste des indicateurs qui peuvent être définis, consultez la AppendMenu fonction membre. Pour spécifier plusieurs valeurs, utilisez l’opérateur OR au niveau du bit pour les combiner avec l’indicateur ou MF_BYPOSITION l’indicateurMF_BYCOMMAND.

nIDNewItem
Spécifie l’ID de commande du nouvel élément de menu ou, s’il nFlags est défini MF_POPUPsur , le handle de menu (HMENU) du menu contextuel. Le nIDNewItem paramètre est ignoré (non nécessaire) s’il nFlags est défini sur MF_SEPARATOR.

lpszNewItem
Spécifie le contenu du nouvel élément de menu. nFlags peut être utilisé pour interpréter lpszNewItem de la manière suivante :

nFlags Interprétation de lpszNewItem
MF_OWNERDRAW Contient une valeur 32 bits fournie par l’application que l’application peut utiliser pour conserver des données supplémentaires associées à l’élément de menu. Cette valeur 32 bits est disponible pour l’application dans le membre de la itemData structure fournie par les messages et WM_DRAWITEM les WM_MEASUREITEM messages. Ces messages sont envoyés lorsque l’élément de menu est initialement affiché ou modifié.
MF_STRING Contient un pointeur long vers une chaîne terminée par null. Il s’agit de l’interprétation par défaut.
MF_SEPARATOR Le lpszNewItem paramètre est ignoré (non nécessaire).

pBmp
Pointe vers un CBitmap objet qui sera utilisé comme élément de menu.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

L’application peut spécifier l’état de l’élément de menu en définissant des valeurs dans nFlags.

Chaque fois qu’un menu qui réside dans une fenêtre est modifié (si la fenêtre est affichée ou non), l’application doit appeler CWnd::DrawMenuBar.

Lorsque nIDNewItem vous spécifiez un menu contextuel, il fait partie du menu dans lequel il est inséré. Si ce menu est détruit, le menu inséré est également détruit. Un menu inséré doit être détaché d’un CMenu objet pour éviter les conflits.

Si la fenêtre enfant active de plusieurs interfaces de document (MDI) est agrandie et qu’une application insère un menu contextuel dans le menu de l’application MDI en appelant cette fonction et en spécifiant l’indicateur MF_BYPOSITION , le menu est inséré une position plus à gauche que prévu. Cela se produit parce que le menu Contrôle de la fenêtre enfant MDI active est inséré dans la première position de la barre de menus de la fenêtre cadre MDI. Pour positionner correctement le menu, l’application doit ajouter 1 à la valeur de position qui serait autrement utilisée. Une application peut utiliser le WM_MDIGETACTIVE message pour déterminer si la fenêtre enfant active est agrandie.

Exemple

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

Insère un nouvel élément de menu à la position spécifiée dans un menu.

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

Paramètres

uItem
Consultez la description de uItem ce qui se InsertMenuItem produit dans le Kit de développement logiciel (SDK) Windows.

lpMenuItemInfo
Consultez la description de lpmii ce qui se InsertMenuItem produit dans le Kit de développement logiciel (SDK) Windows.

fByPos
Consultez la description de fByPosition ce qui se InsertMenuItem produit dans le Kit de développement logiciel (SDK) Windows.

Notes

Cette fonction encapsule InsertMenuItem, décrite dans le Kit de développement logiciel (SDK) Windows.

CMenu::LoadMenu

Charge une ressource de menu à partir du fichier exécutable de l’application et l’attache à l’objet CMenu .

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

Paramètres

lpszResourceName
Pointe vers une chaîne terminée par null qui contient le nom de la ressource de menu à charger.

nIDResource
Spécifie l’ID de menu de la ressource de menu à charger.

Valeur de retour

Différent de zéro si la ressource de menu a été chargée correctement ; sinon 0.

Notes

Avant de quitter, une application doit libérer les ressources système associées à un menu si le menu n’est pas affecté à une fenêtre. Une application libère un menu en appelant la DestroyMenu fonction membre.

Exemple

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

Charge une ressource à partir d’un modèle de menu en mémoire et l’attache à l’objet CMenu .

BOOL LoadMenuIndirect(const void* lpMenuTemplate);

Paramètres

lpMenuTemplate
Pointe vers un modèle de menu (qui est une structure unique MENUITEMTEMPLATEHEADER et une collection d’une ou MENUITEMTEMPLATE plusieurs structures). Pour plus d’informations sur ces deux structures, consultez le Kit de développement logiciel (SDK) Windows.

Valeur de retour

Différent de zéro si la ressource de menu a été chargée correctement ; sinon 0.

Notes

Un modèle de menu est un en-tête suivi d’une collection d’une ou MENUITEMTEMPLATE plusieurs structures, chacune pouvant contenir un ou plusieurs éléments de menu et menus contextuels.

Le numéro de version doit être 0.

Les mtOption indicateurs doivent inclure MF_END pour le dernier élément d’une liste contextuelle et pour le dernier élément de la liste principale. Consultez la AppendMenu fonction membre pour d’autres indicateurs. Le mtId membre doit être omis de la MENUITEMTEMPLATE structure lorsqu’il MF_POPUP est spécifié dans mtOption.

L’espace alloué pour la MENUITEMTEMPLATE structure doit être suffisamment grand pour mtString contenir le nom de l’élément de menu sous la forme d’une chaîne terminée par null.

Avant de quitter, une application doit libérer les ressources système associées à un menu si le menu n’est pas affecté à une fenêtre. Une application libère un menu en appelant la DestroyMenu fonction membre.

Exemple

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

Spécifie le HMENU handle du menu Windows attaché à l’objet CMenu .

HMENU m_hMenu;

Exemple

Consultez l’exemple pour CMenu::LoadMenu.

CMenu::MeasureItem

Appelé par l’infrastructure lorsqu’un menu avec le style de dessin propriétaire est créé.

virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);

Paramètres

lpMeasureItemStruct
Pointeur vers une MEASUREITEMSTRUCT structure.

Notes

Par défaut, cette fonction membre ne fait rien. Remplacez cette fonction membre et renseignez la MEASUREITEMSTRUCT structure pour informer Windows des dimensions du menu.

Consultez CWnd::OnMeasureItem une description de la MEASUREITEMSTRUCT structure.

Exemple

Le code suivant provient de l’exemple 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

Modifie un élément de menu existant à la position spécifiée par 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);

Paramètres

nPosition
Spécifie l’élément de menu à modifier. Le nFlags paramètre peut être utilisé pour interpréter nPosition de la manière suivante :

nFlags Interprétation de nPosition
MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut si ni aucune MF_BYCOMMAND n’est MF_BYPOSITION définie.
MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

nFlags
Spécifie comment nPosition est interprété et fournit des informations sur les modifications à apporter à l’élément de menu. Pour obtenir la liste des indicateurs qui peuvent être définis, consultez la AppendMenu fonction membre.

nIDNewItem
Spécifie l’ID de commande de l’élément de menu modifié ou, s’il nFlags est défini MF_POPUPsur , le handle de menu (HMENU) d’un menu contextuel. Le nIDNewItem paramètre est ignoré (non nécessaire) s’il nFlags est défini sur MF_SEPARATOR.

lpszNewItem
Spécifie le contenu du nouvel élément de menu. Le nFlags paramètre peut être utilisé pour interpréter lpszNewItem de la manière suivante :

nFlags Interprétation de lpszNewItem
MF_OWNERDRAW Contient une valeur 32 bits fournie par l’application que l’application peut utiliser pour conserver des données supplémentaires associées à l’élément de menu. Cette valeur 32 bits est disponible pour l’application lorsqu’elle traite MF_MEASUREITEM et MF_DRAWITEM.
MF_STRING Contient un pointeur long vers une chaîne terminée par null ou vers un CString.
MF_SEPARATOR Le lpszNewItem paramètre est ignoré (non nécessaire).

pBmp
Pointe vers un CBitmap objet qui sera utilisé comme élément de menu.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

L’application spécifie le nouvel état de l’élément de menu en définissant des valeurs dans nFlags. Si cette fonction remplace un menu contextuel associé à l’élément de menu, il détruit l’ancien menu contextuel et libère la mémoire utilisée par le menu contextuel.

Lorsque nIDNewItem vous spécifiez un menu contextuel, il fait partie du menu dans lequel il est inséré. Si ce menu est détruit, le menu inséré est également détruit. Un menu inséré doit être détaché d’un CMenu objet pour éviter les conflits.

Chaque fois qu’un menu qui réside dans une fenêtre est modifié (si la fenêtre est affichée ou non), l’application doit appeler CWnd::DrawMenuBar. Pour modifier les attributs des éléments de menu existants, il est beaucoup plus rapide d’utiliser les fonctions membres et EnableMenuItem les CheckMenuItem fonctions membres.

Exemple

Consultez l’exemple pour CMenu::InsertMenu.

CMenu::operator HMENU

Utilisez cet opérateur pour récupérer le handle de l’objet CMenu .

operator HMENU() const;

Valeur de retour

En cas de réussite, le handle de l’objet CMenu ; sinon, NULL.

Notes

Vous pouvez utiliser le handle pour appeler directement les API Windows.

CMenu::operator !=

Détermine si deux menus ne sont pas égaux logiquement.

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

Paramètres

menu
Objet CMenu pour la comparaison.

Notes

Teste si un objet de menu situé à gauche n’est pas égal à un objet de menu situé à droite.

CMenu::operator ==

Détermine si deux menus sont logiquement égaux.

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

Paramètres

menu
Objet CMenu pour la comparaison.

Notes

Teste si un objet de menu situé à gauche est égal (en termes de HMENU valeur) à un objet de menu situé à droite.

CMenu::RemoveMenu

Supprime un élément de menu avec un menu contextuel associé dans le menu.

BOOL RemoveMenu(
    UINT nPosition,
    UINT nFlags);

Paramètres

nPosition
Spécifie l’élément de menu à supprimer. Le nFlags paramètre peut être utilisé pour interpréter nPosition de la manière suivante :

nFlags Interprétation de nPosition
MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut si ni aucune MF_BYCOMMAND n’est MF_BYPOSITION définie.
MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

nFlags
Spécifie la façon dont nPosition l’interprétation est interprétée.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

Il ne détruit pas le handle d’un menu contextuel, de sorte que le menu peut être réutilisé. Avant d’appeler cette fonction, l’application peut appeler la GetSubMenu fonction membre pour récupérer l’objet contextuel CMenu à réutiliser.

Chaque fois qu’un menu qui réside dans une fenêtre est modifié (si la fenêtre est affichée ou non), l’application doit appeler CWnd::DrawMenuBar.

Exemple

Consultez l’exemple pour CMenu::InsertMenu.

CMenu::SetDefaultItem

Définit l’élément de menu par défaut du menu spécifié.

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

Paramètres

uItem
Identificateur ou position du nouvel élément de menu par défaut ou - 1 pour aucun élément par défaut. La signification de ce paramètre dépend de la valeur de fByPos.

fByPos
Valeur spécifiant la signification de uItem. Si ce paramètre est FALSE, uItem est un identificateur d’élément de menu. Sinon, il s’agit d’une position d’élément de menu.

Valeur de retour

Si la fonction réussit, la valeur de retour est différente de zéro. Si la fonction échoue, la valeur de retour est égale à zéro. Pour obtenir des informations d’erreur étendues, utilisez la fonction GetLastErrorWin32, comme décrit dans le Kit de développement logiciel (SDK) Windows.

Notes

Cette fonction membre implémente le comportement de la fonction Win32 SetMenuDefaultItem, comme décrit dans le SDK Windows.

Exemple

Consultez l’exemple pour CMenu::InsertMenu.

CMenu::SetMenuContextHelpId

Associe un ID d’aide de contexte à CMenu.

BOOL SetMenuContextHelpId(DWORD dwContextHelpId);

Paramètres

dwContextHelpId
ID d’aide du contexte à associer à CMenu.

Valeur de retour

Différent de zéro s’il réussit ; sinon 0

Notes

Tous les éléments du menu partagent cet identificateur : il n’est pas possible d’attacher un identificateur de contexte d’aide aux éléments de menu individuels.

Exemple

Consultez l’exemple pour CMenu::InsertMenu.

CMenu::SetMenuInfo

Définit des informations pour un menu.

BOOL SetMenuInfo(LPCMENUINFO lpcmi);

Paramètres

lpcmi
Pointeur vers une MENUINFO structure contenant des informations pour le menu.

Valeur de retour

Si la fonction réussit, la valeur de retour est différente de zéro ; sinon, la valeur de retour est égale à zéro.

Notes

Appelez cette fonction pour définir des informations spécifiques sur le menu.

CMenu::SetMenuItemBitmaps

Associe les bitmaps spécifiées à un élément de menu.

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

Paramètres

nPosition
Spécifie l’élément de menu à modifier. Le nFlags paramètre peut être utilisé pour interpréter nPosition de la manière suivante :

nFlags Interprétation de nPosition
MF_BYCOMMAND Spécifie que le paramètre donne l’ID de commande de l’élément de menu existant. Il s’agit de la valeur par défaut si ni aucune MF_BYCOMMAND n’est MF_BYPOSITION définie.
MF_BYPOSITION Spécifie que le paramètre donne la position de l’élément de menu existant. Le premier élément est à la position 0.

nFlags
Spécifie la façon dont nPosition l’interprétation est interprétée.

pBmpUnchecked
Spécifie la bitmap à utiliser pour les éléments de menu qui ne sont pas vérifiés.

pBmpChecked
Spécifie la bitmap à utiliser pour les éléments de menu vérifiés.

Valeur de retour

Une valeur différente de zéro si la fonction réussit ; sinon, 0.

Notes

Que l’élément de menu soit activé ou désactivé, Windows affiche la bitmap appropriée en regard de l’élément de menu.

Si l’un pBmpUnchecked ou pBmpChecked l’autre est NULL, Windows n’affiche rien en regard de l’élément de menu de l’attribut correspondant. Si les deux paramètres sont NULL, Windows utilise la coche par défaut lorsque l’élément est activé et supprime la coche lorsque l’élément est désactivé.

Lorsque le menu est détruit, ces bitmaps ne sont pas détruites ; l’application doit les détruire.

La fonction Windows GetMenuCheckMarkDimensions récupère les dimensions de la coche par défaut utilisée pour les éléments de menu. L’application utilise ces valeurs pour déterminer la taille appropriée pour les bitmaps fournies avec cette fonction. Obtenez la taille, créez vos bitmaps, puis définissez-les.

Exemple

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

Modifie les informations relatives à un élément de menu.

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

Paramètres

uItem
Consultez la description de uItem ce qui se SetMenuItemInfo produit dans le Kit de développement logiciel (SDK) Windows.

lpMenuItemInfo
Consultez la description de lpmii ce qui se SetMenuItemInfo produit dans le Kit de développement logiciel (SDK) Windows.

fByPos
Consultez la description de fByPosition ce qui se SetMenuItemInfo produit dans le Kit de développement logiciel (SDK) Windows.

Notes

Cette fonction encapsule SetMenuItemInfo, décrite dans le Kit de développement logiciel (SDK) Windows.

CMenu::TrackPopupMenu

Affiche un menu contextuel flottant à l’emplacement spécifié et suit la sélection d’éléments dans le menu contextuel.

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

Paramètres

nFlags
Spécifie la position de l’écran et les indicateurs de position de la souris. Consultez TrackPopupMenu la liste des indicateurs disponibles.

x
Spécifie la position horizontale dans les coordonnées de l’écran du menu contextuel. Selon la valeur du nFlags paramètre, le menu peut être aligné à gauche, aligné à droite ou centré par rapport à cette position.

y
Spécifie la position verticale dans les coordonnées de l’écran du haut du menu sur l’écran.

pWnd
Identifie la fenêtre propriétaire du menu contextuel. Ce paramètre ne peut pas être NULL, même si l’indicateur TPM_NONOTIFY est spécifié. Cette fenêtre reçoit tous les WM_COMMAND messages du menu. Dans les versions 3.1 et ultérieures de Windows, la fenêtre ne reçoit WM_COMMAND pas de messages tant qu’elle TrackPopupMenu n’est pas retournée. Dans Windows 3.0, la fenêtre reçoit les WM_COMMAND messages avant TrackPopupMenu de retourner.

lpRect
Ignoré.

Valeur de retour

Cette méthode retourne le résultat de l’appel TrackPopupMenu dans le Kit de développement logiciel (SDK) Windows.

Notes

Un menu contextuel flottant peut apparaître n’importe où sur l’écran.

Exemple

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

Affiche un menu contextuel flottant à l’emplacement spécifié et suit la sélection d’éléments dans le menu contextuel.

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

Paramètres

fuFlags
Spécifie différentes fonctions pour le menu étendu. Pour obtenir une liste de toutes les valeurs et leur signification, consultez TrackPopupMenuEx.

x
Spécifie la position horizontale dans les coordonnées de l’écran du menu contextuel.

y
Spécifie la position verticale dans les coordonnées de l’écran du haut du menu sur l’écran.

pWnd
Pointeur vers la fenêtre propriétaire du menu contextuel et réception des messages à partir du menu créé. Cette fenêtre peut être n’importe quelle fenêtre de l’application active, mais ne peut pas être NULL. Si vous spécifiez TPM_NONOTIFY dans le fuFlags paramètre, la fonction n’envoie aucun message à pWnd. La fonction doit retourner la fenêtre vers laquelle pointe pWnd le WM_COMMAND message.

lptpm
Pointeur vers une TPMPARAMS structure qui spécifie une zone de l’écran, le menu ne doit pas se chevaucher. Ce paramètre peut être NULL.

Valeur de retour

Si vous spécifiez TPM_RETURNCMD dans le fuFlags paramètre, la valeur de retour est l’identificateur d’élément de menu de l’élément sélectionné par l’utilisateur. Si l’utilisateur annule le menu sans effectuer de sélection ou si une erreur se produit, la valeur de retour est 0.

Si vous ne spécifiez TPM_RETURNCMD pas dans le fuFlags paramètre, la valeur de retour n’est pas nulle si la fonction réussit et 0 si elle échoue. Pour obtenir des informations plus complètes sur les erreurs, appelez GetLastError.

Notes

Un menu contextuel flottant peut apparaître n’importe où sur l’écran. Pour plus d’informations sur la gestion des erreurs lors de la création du menu contextuel, consultez TrackPopupMenuEx.

Voir aussi

Exemple MFC CTRLTEST
Exemple MFC DYNAMENU
CObject Classe
Graphique hiérarchique