La classe `CMenu`

Article
10/12/2023

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 marque case activée en regard ou supprime une marque de case activée 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 marque case activée 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 CMenuHMENU, 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êteafxwin.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_CHECKEDAgit comme un bouton bascule avec MF_UNCHECKED pour placer la marque de case activée par défaut en regard de l’élément. Lorsque l’application fournit des bitmaps de marque case activée (voir la SetMenuItemBitmaps fonction membre), la bitmap « case activée marquer sur » s’affiche.
MF_UNCHECKEDAgit comme un bouton bascule avec MF_CHECKED pour supprimer une marque case activée en regard de l’élément. Lorsque l’application fournit des bitmaps de marque case activée (voir la SetMenuItemBitmaps fonction membre), la bitmap « case activée marquer 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 case activée marques à ou supprime case activée marques 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 à case activée, tel que déterminé par nCheck.

nCheck
Spécifie comment case activée l’élément de menu et comment déterminer la position de l’élément dans le menu. Le nCheck paramètre peut être une combinaison ou MF_CHECKEDMF_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_CHECKEDAgit comme un bouton bascule avec MF_UNCHECKED pour placer la marque de case activée par défaut en regard de l’élément.
MF_UNCHECKEDAgit comme un bouton bascule avec MF_CHECKED pour supprimer une marque case activée 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 case activée un élément de menu contextuel. Les éléments de menu de niveau supérieur ne peuvent pas être case activée. Un élément de menu contextuel doit être case activée 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 case activée 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 un case activée 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 case activée est affiché à l’aide d’une bitmap de case d’option (ou puce) au lieu d’une bitmap de marque case activée.

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

CreateMenu
CreatePopupMenu
LoadMenu
LoadMenuIndirect
Attach

`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’indicateurMF_BYCOMMAND, Windows case activée s tous les éléments de menu contextuel subordonnés à l’élément CMenu; par conséquent, sauf si des éléments de menu en double sont présents, l’utilisation de la CMenu barre de menus suffit.

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 :

Value 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.

Value	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 GetMenuDefaultItemWin32, comme décrit dans le Kit de développement logiciel (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_CHECKEDAgit comme un bouton bascule avec MF_UNCHECKED pour placer la marque de case activée par défaut en regard de l’élément. Lorsque l’application fournit des bitmaps de marque case activée (voir la SetMenuItemBitmaps fonction membre), la bitmap « case activée marquer sur » 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_UNCHECKEDAgit comme un bouton bascule avec MF_CHECKED pour supprimer une marque case activée en regard de l’élément. Lorsque l’application fournit des bitmaps de marque case activée (voir la SetMenuItemBitmaps fonction membre), la bitmap « case activée marquer 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 NULLCMenu 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

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.

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.

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

Notes

Cette fonction membre implémente le comportement de la fonction SetMenuDefaultItemWin32, comme décrit dans le Kit de développement logiciel (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 case activée ed.

pBmpChecked
Spécifie la bitmap à utiliser pour les éléments de menu qui sont case activée ed.

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 case activée ou non case activée ed, 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 sontNULL, Windows utilise la marque de case activée par défaut lorsque l’élément est case activée et supprime la marque case activée lorsque l’élément n’est pas case activée ed.

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 marque de case activée 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

Share via

La classe CMenu

Syntaxe

Membres

Constructeurs publics

Méthodes publiques

Opérateurs publics

Membres de données publics

Notes

Hiérarchie d'héritage

Spécifications

CMenu::AppendMenu

Paramètres

Valeur de retour

Notes

Exemple

CMenu::Attach

Paramètres

Valeur de retour

Notes

Exemple

CMenu::CheckMenuItem

Paramètres

Valeur de retour

Notes

Exemple

CMenu::CheckMenuRadioItem

Paramètres

Valeur de retour

Notes

Exemple

CMenu::CMenu

Notes

CMenu::CreateMenu

Valeur de retour

Notes

Exemple

CMenu::CreatePopupMenu

Valeur de retour

Notes

Exemple

CMenu::DeleteMenu

Paramètres

Valeur de retour

Notes

Exemple

CMenu::DeleteTempMap

Notes

Exemple

CMenu::DestroyMenu

Valeur de retour

Notes

Exemple

CMenu::Detach

Valeur de retour

Notes

Exemple

CMenu::DrawItem

Paramètres

Notes

Exemple

CMenu::EnableMenuItem

Paramètres

Valeur de retour

Notes

Exemple

CMenu::FromHandle

Paramètres

Valeur de retour

Notes

Exemple

CMenu::GetDefaultItem

Paramètres

Valeur de retour

Notes

Exemple

CMenu::GetMenuContextHelpId

Valeur de retour

Exemple

CMenu::GetMenuInfo

La classe `CMenu`

`CMenu::AppendMenu`

`CMenu::Attach`

`CMenu::CheckMenuItem`

`CMenu::CheckMenuRadioItem`

`CMenu::CMenu`

`CMenu::CreateMenu`

`CMenu::CreatePopupMenu`

`CMenu::DeleteMenu`

`CMenu::DeleteTempMap`

`CMenu::DestroyMenu`

`CMenu::Detach`

`CMenu::DrawItem`

`CMenu::EnableMenuItem`

`CMenu::FromHandle`

`CMenu::GetDefaultItem`

`CMenu::GetMenuContextHelpId`

`CMenu::GetMenuInfo`

`CMenu::GetMenuItemCount`

`CMenu::GetMenuItemID`

`CMenu::GetMenuItemInfo`

`CMenu::GetMenuState`

`CMenu::GetMenuString`

`CMenu::GetSafeHmenu`

`CMenu::GetSubMenu`

`CMenu::InsertMenu`

`CMenu::InsertMenuItem`

`CMenu::LoadMenu`

`CMenu::LoadMenuIndirect`

`CMenu::m_hMenu`

`CMenu::MeasureItem`

`CMenu::ModifyMenu`

`CMenu::operator HMENU`

`CMenu::operator !=`

`CMenu::operator ==`

`CMenu::RemoveMenu`