Classe `CMenu`

Articolo
10/12/2023

Incapsulamento di HMENUdi Windows.

Sintassi

class CMenu : public CObject

Membri

Costruttori pubblici

Nome	Descrizione
`CMenu::CMenu`	Costruisce un oggetto `CMenu`.

Metodi pubblici

Nome	Descrizione
`CMenu::AppendMenu`	Aggiunge una nuova voce alla fine del menu.
`CMenu::Attach`	Collega un handle di menu di Windows a un `CMenu` oggetto .
`CMenu::CheckMenuItem`	Posiziona un segno di spunta accanto o rimuove un segno di spunta da una voce di menu nel menu a comparsa.
`CMenu::CheckMenuRadioItem`	Posiziona un pulsante di opzione accanto a una voce di menu e rimuove il pulsante di opzione da tutte le altre voci di menu del gruppo.
`CMenu::CreateMenu`	Crea un menu vuoto e lo collega a un `CMenu` oggetto .
`CMenu::CreatePopupMenu`	Crea un menu a comparsa vuoto e lo collega a un `CMenu` oggetto .
`CMenu::DeleteMenu`	Elimina una voce specificata dal menu. Se la voce di menu ha un menu a comparsa associato, elimina definitivamente l'handle nel menu a comparsa e libera la memoria utilizzata da esso.
`CMenu::DeleteTempMap`	Elimina tutti gli oggetti temporanei `CMenu` creati dalla `FromHandle` funzione membro.
`CMenu::DestroyMenu`	Elimina definitivamente il menu associato a un `CMenu` oggetto e libera qualsiasi memoria occupata dal menu.
`CMenu::Detach`	Scollega un handle di menu di Windows da un `CMenu` oggetto e restituisce l'handle.
`CMenu::DrawItem`	Chiamato dal framework quando cambia un aspetto visivo di un menu creato dal proprietario.
`CMenu::EnableMenuItem`	Abilita, disabilita o disattiva (grigi) una voce di menu.
`CMenu::FromHandle`	Restituisce un puntatore a un oggetto in base a un `CMenu` handle di menu di Windows.
`CMenu::GetDefaultItem`	Determina la voce di menu predefinita nel menu specificato.
`CMenu::GetMenuContextHelpId`	Recupera l'ID di contesto della Guida associato al menu.
`CMenu::GetMenuInfo`	Recupera informazioni in un menu specifico.
`CMenu::GetMenuItemCount`	Determina il numero di elementi in un menu a comparsa o di primo livello.
`CMenu::GetMenuItemID`	Ottiene l'identificatore della voce di menu per una voce di menu che si trova nella posizione specificata.
`CMenu::GetMenuItemInfo`	Recupera informazioni su una voce di menu.
`CMenu::GetMenuState`	Restituisce lo stato della voce di menu specificata o del numero di elementi in un menu a comparsa.
`CMenu::GetMenuString`	Recupera l'etichetta della voce di menu specificata.
`CMenu::GetSafeHmenu`	Restituisce l'oggetto di cui è stato eseguito il `m_hMenu` wrapping da questo `CMenu` oggetto.
`CMenu::GetSubMenu`	Recupera un puntatore a un menu a comparsa.
`CMenu::InsertMenu`	Inserisce una nuova voce di menu nella posizione specificata, spostando le altre voci verso il basso nel menu.
`CMenu::InsertMenuItem`	Inserisce una nuova voce di menu nella posizione specificata in un menu.
`CMenu::LoadMenu`	Carica una risorsa di menu dal file eseguibile e la collega a un `CMenu` oggetto .
`CMenu::LoadMenuIndirect`	Carica un menu da un modello di menu in memoria e lo collega a un `CMenu` oggetto .
`CMenu::MeasureItem`	Chiamato dal framework per determinare le dimensioni del menu quando viene creato un menu creato dal proprietario.
`CMenu::ModifyMenu`	Modifica una voce di menu esistente nella posizione specificata.
`CMenu::RemoveMenu`	Elimina una voce di menu con un menu a comparsa associato dal menu specificato.
`CMenu::SetDefaultItem`	Imposta la voce di menu predefinita per il menu specificato.
`CMenu::SetMenuContextHelpId`	Imposta l'ID di scelta rapida della Guida da associare al menu.
`CMenu::SetMenuInfo`	Imposta informazioni su un menu specifico.
`CMenu::SetMenuItemBitmaps`	Associa le bitmap di segno di spunta specificate a una voce di menu.
`CMenu::SetMenuItemInfo`	Modifica le informazioni su una voce di menu.
`CMenu::TrackPopupMenu`	Visualizza un menu a comparsa mobile nella posizione specificata e tiene traccia della selezione di elementi nel menu a comparsa.
`CMenu::TrackPopupMenuEx`	Visualizza un menu a comparsa mobile nella posizione specificata e tiene traccia della selezione di elementi nel menu a comparsa.

Operatori pubblici

Nome	Descrizione
`CMenu::operator HMENU`	Recupera l'handle dell'oggetto menu.
`CMenu::operator !=`	Determina se due oggetti di menu non sono uguali.
`CMenu::operator ==`	Determina se due oggetti di menu sono uguali.

Membri dati pubblici

Nome	Descrizione
`CMenu::m_hMenu`	Specifica l'handle al menu di Windows associato all'oggetto `CMenu` .

Osservazioni:

Fornisce funzioni membro per la creazione, il rilevamento, l'aggiornamento e l'eliminazione di un menu.

Creare un CMenu oggetto nello stack frame come locale, quindi chiamare CMenule funzioni membro di per modificare il nuovo menu in base alle esigenze. Chiamare CWnd::SetMenu quindi per impostare il menu su una finestra, seguito immediatamente da una chiamata alla CMenu funzione membro dell'oggetto Detach . La CWnd::SetMenu funzione membro imposta il menu della finestra sul nuovo menu, fa sì che la finestra venga ridisegnata in modo da riflettere la modifica del menu e passa anche la proprietà del menu alla finestra. La chiamata a scollega l'oggetto Detach HMENU dall'oggetto, in modo che quando la variabile locale CMenu esce dall'ambitoCMenu, il CMenu distruttore dell'oggetto non tenta di eliminare definitivamente un menu di cui non è più proprietario. Il menu stesso viene eliminato automaticamente quando la finestra viene eliminata definitivamente.

È possibile usare la LoadMenuIndirect funzione membro per creare un menu da un modello in memoria, ma un menu creato da una risorsa da una chiamata a LoadMenu è più facilmente gestito e la risorsa di menu stessa può essere creata e modificata dall'editor di menu.

Gerarchia di ereditarietà

CObject

CMenu

Requisiti

Intestazione: afxwin.h

`CMenu::AppendMenu`

Aggiunge una nuova voce alla fine di un menu.

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

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

Parametri

nFlags
Specifica le informazioni sullo stato della nuova voce di menu quando viene aggiunta al menu. È costituito da uno o più valori elencati nella sezione Osservazioni.

nIDNewItem
Specifica l'ID comando della nuova voce di menu oppure, se nFlags è impostato su MF_POPUP, l'handle di menu (HMENU) di un menu a comparsa. Il nIDNewItem parametro viene ignorato (non necessario) se nFlags è impostato su MF_SEPARATOR.

lpszNewItem
Specifica il contenuto della nuova voce di menu. Il nFlags parametro viene usato per interpretare lpszNewItem nel modo seguente:

`nFlags`	Interpretazione di `lpszNewItem`
`MF_OWNERDRAW`	Contiene un valore a 32 bit fornito dall'applicazione che l'applicazione può usare per mantenere dati aggiuntivi associati alla voce di menu. Questo valore a 32 bit è disponibile per l'applicazione durante l'elaborazione `WM_MEASUREITEM` e `WM_DRAWITEM` i messaggi. Il valore viene archiviato nel `itemData` membro della struttura fornita con tali messaggi.
`MF_STRING`	Contiene un puntatore a una stringa con terminazione Null. Questa è l'interpretazione predefinita.
`MF_SEPARATOR`	Il `lpszNewItem` parametro viene ignorato (non necessario).

pBmp
Punta a un CBitmap oggetto che verrà utilizzato come voce di menu.

Valore restituito

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

Osservazioni:

L'applicazione può specificare lo stato della voce di menu impostando i valori in nFlags. Quando nIDNewItem specifica un menu a comparsa, diventa parte del menu a cui viene accodato. Se il menu viene eliminato definitivamente, verrà eliminato anche il menu aggiunto. Per evitare conflitti, è necessario scollegare un menu accodato da un CMenu oggetto . Si noti che MF_STRING e MF_OWNERDRAW non sono validi per la versione bitmap di AppendMenu.

L'elenco seguente descrive i flag che possono essere impostati in nFlags:

MF_CHECKED Funge da interruttore con MF_UNCHECKED per posizionare il segno di spunta predefinito accanto all'elemento. Quando l'applicazione fornisce bitmap con segno di spunta (vedere la funzione membro), viene visualizzata la SetMenuItemBitmaps bitmap "check mark on".
MF_UNCHECKED Funge da interruttore con MF_CHECKED per rimuovere un segno di spunta accanto all'elemento. Quando l'applicazione fornisce bitmap con segno di spunta (vedere la funzione membro), viene visualizzata la SetMenuItemBitmaps bitmap "check mark off".
MF_DISABLED Disabilita la voce di menu in modo che non possa essere selezionata, ma non lo dim.
MF_ENABLED Abilita la voce di menu in modo che possa essere selezionata e ripristinata dallo stato disattivato.
MF_GRAYED Disabilita la voce di menu in modo che non possa essere selezionata e disattivata.
MF_MENUBARBREAK Inserisce l'elemento in una nuova riga nei menu statici o in una nuova colonna nei menu a comparsa. La nuova colonna del menu a comparsa verrà separata dalla colonna precedente in base a una linea di divisione verticale.
MF_MENUBREAK Inserisce l'elemento in una nuova riga nei menu statici o in una nuova colonna nei menu a comparsa. Nessuna linea di divisione viene posizionata tra le colonne.
MF_OWNERDRAW Specifica che l'elemento è un elemento di disegno proprietario. Quando il menu viene visualizzato per la prima volta, la finestra proprietaria del menu riceve un WM_MEASUREITEM messaggio, che recupera l'altezza e la larghezza della voce di menu. Il WM_DRAWITEM messaggio è quello inviato ogni volta che il proprietario deve aggiornare l'aspetto visivo della voce di menu. Questa opzione non è valida per una voce di menu di primo livello.
MF_POPUP Specifica che alla voce di menu è associato un menu a comparsa. Il parametro ID specifica un handle per un menu a comparsa da associare all'elemento. Viene usato per aggiungere un menu a comparsa di primo livello o un menu a comparsa gerarchico a una voce di menu a comparsa.
MF_SEPARATOR Disegna una linea di divisione orizzontale. Può essere usato solo in un menu a comparsa. Questa riga non può essere disattivata, disabilitata o evidenziata. Gli altri parametri vengono ignorati.
MF_STRING Specifica che la voce di menu è una stringa di caratteri.

Ognuno dei gruppi seguenti elenca i flag che si escludono a vicenda e non possono essere usati insieme:

MF_DISABLED, MF_ENABLED e MF_GRAYED
MF_STRING, MF_OWNERDRAW, MF_SEPARATORe la versione bitmap
MF_MENUBARBREAK e MF_MENUBREAK
MF_CHECKED e MF_UNCHECKED

Ogni volta che un menu che risiede in una finestra viene modificato (indipendentemente dal fatto che venga visualizzata o meno la finestra), l'applicazione deve chiamare CWnd::DrawMenuBar.

Esempio

Vedere l'esempio per CMenu::CreateMenu.

`CMenu::Attach`

Collega un menu di Windows esistente a un CMenu oggetto .

BOOL Attach(HMENU hMenu);

Parametri

hMenu
Specifica un handle per un menu di Windows.

Valore restituito

Diverso da zero se l'operazione ha avuto esito positivo; in caso contrario, 0.

Osservazioni:

Questa funzione non deve essere chiamata se un menu è già associato all'oggetto CMenu . L'handle m_hMenu di menu viene archiviato nel membro dati.

Se il menu che si desidera modificare è già associato a una finestra, è possibile usare la CWnd::GetMenu funzione per ottenere un handle al menu.

Esempio

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`

Aggiunge segni di spunta o rimuove i segni di spunta dalle voci di menu nel menu a comparsa.

UINT CheckMenuItem(
    UINT nIDCheckItem,
    UINT nCheck);

Parametri

nIDCheckItem
Specifica la voce di menu da controllare, come determinato da nCheck.

nCheck
Specifica come controllare la voce di menu e come determinare la posizione dell'elemento nel menu. Il nCheck parametro può essere una combinazione di MF_CHECKED o MF_UNCHECKED con MF_BYPOSITION o MF_BYCOMMAND flag. Questi flag possono essere combinati usando l'operatore OR bit per bit. Hanno i significati seguenti:

MF_BYCOMMAND Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Si tratta dell'impostazione predefinita.
MF_BYPOSITION Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.
MF_CHECKED Funge da interruttore con MF_UNCHECKED per posizionare il segno di spunta predefinito accanto all'elemento.
MF_UNCHECKED Funge da interruttore con MF_CHECKED per rimuovere un segno di spunta accanto all'elemento.

Valore restituito

Stato precedente dell'elemento: MF_CHECKED o MF_UNCHECKEDo se 0xFFFFFFFF la voce di menu non esiste.

Osservazioni:

Il nIDCheckItem parametro specifica l'elemento da modificare.

Il nIDCheckItem parametro può identificare una voce di menu a comparsa e una voce di menu. Non sono necessari passaggi speciali per controllare una voce di menu a comparsa. Impossibile controllare le voci di menu di primo livello. Una voce di menu a comparsa deve essere selezionata in base alla posizione perché non dispone di un identificatore di voce di menu associato.

Esempio

Vedere l'esempio per CMenu::GetMenuState.

`CMenu::CheckMenuRadioItem`

Controlla una voce di menu specificata e la rende una voce di opzione.

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

Parametri

nIDFirst
Specifica (come ID o offset, a seconda del valore di ) la prima voce di nFlagsmenu nel gruppo di pulsanti di opzione.

nIDLast
Specifica (come ID o offset, a seconda del valore di ) l'ultima voce di nFlagsmenu nel gruppo di pulsanti di opzione.

nIDItem
Specifica (come ID o offset, a seconda del valore di nFlags) l'elemento nel gruppo che verrà controllato con un pulsante di opzione.

nFlags
Specifica l'interpretazione di nIDFirst, nIDLaste nIDItem nel modo seguente:

nFlags	Interpretazione
`MF_BYCOMMAND`	Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Questa è l'impostazione predefinita se né `MF_BYCOMMAND` `MF_BYPOSITION` né è impostata.
`MF_BYPOSITION`	Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.

Valore restituito

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

Osservazioni:

Allo stesso tempo, la funzione deseleziona tutte le altre voci di menu nel gruppo associato e cancella il flag del tipo di elemento di opzione per tali elementi. L'elemento selezionato viene visualizzato usando una bitmap di un pulsante di opzione (o un punto elenco) anziché una bitmap del segno di spunta.

Esempio

Vedere l'esempio per ON_COMMAND_RANGE.

`CMenu::CMenu`

Crea un menu vuoto e lo collega a un CMenu oggetto .

CMenu();

Osservazioni:

Il menu non viene creato fino a quando non si chiama una delle funzioni membro di creazione o caricamento di CMenu:

CreateMenu
CreatePopupMenu
LoadMenu
LoadMenuIndirect
Attach

`CMenu::CreateMenu`

Crea un menu e lo collega all'oggetto CMenu .

BOOL CreateMenu();

Valore restituito

Diverso da zero se il menu è stato creato correttamente; in caso contrario, 0.

Osservazioni:

Il menu è inizialmente vuoto. È possibile aggiungere voci di menu tramite la AppendMenu funzione membro o InsertMenu .

Se il menu viene assegnato a una finestra, viene eliminato automaticamente quando la finestra viene eliminata definitivamente.

Prima di uscire, un'applicazione deve liberare le risorse di sistema associate a un menu se il menu non è assegnato a una finestra. Un'applicazione libera un menu chiamando la DestroyMenu funzione membro.

Esempio

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

Crea un menu a comparsa e lo collega all'oggetto CMenu .

BOOL CreatePopupMenu();

Valore restituito

Diverso da zero se il menu a comparsa è stato creato correttamente; in caso contrario, 0.

Osservazioni:

Il menu è inizialmente vuoto. È possibile aggiungere voci di menu tramite la AppendMenu funzione membro o InsertMenu . L'applicazione può aggiungere il menu a comparsa a un menu esistente o a un menu a comparsa. La TrackPopupMenu funzione membro può essere usata per visualizzare questo menu come menu a comparsa mobile e per tenere traccia delle selezioni nel menu a comparsa.

Se il menu viene assegnato a una finestra, viene eliminato automaticamente quando la finestra viene eliminata definitivamente. Se il menu viene aggiunto a un menu esistente, viene eliminato automaticamente quando il menu viene eliminato definitivamente.

Prima di uscire, un'applicazione deve liberare le risorse di sistema associate a un menu a comparsa se il menu non è assegnato a una finestra. Un'applicazione libera un menu chiamando la DestroyMenu funzione membro.

Esempio

Vedere l'esempio per CMenu::CreateMenu.

`CMenu::DeleteMenu`

Elimina una voce dal menu.

BOOL DeleteMenu(
    UINT nPosition,
    UINT nFlags);

Parametri

nPosition
Specifica la voce di menu da eliminare, come determinato da nFlags.

nFlags
Viene usato per interpretare nPosition nel modo seguente:

`nFlags`	Interpretazione di `nPosition`
`MF_BYCOMMAND`	Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Questa è l'impostazione predefinita se né `MF_BYCOMMAND` `MF_BYPOSITION` né è impostata.
`MF_BYPOSITION`	Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.

Valore restituito

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

Osservazioni:

Se la voce di menu ha un menu a comparsa associato, DeleteMenu elimina definitivamente l'handle nel menu a comparsa e libera la memoria utilizzata dal menu a comparsa.

Ogni volta che un menu che risiede in una finestra viene modificato (indipendentemente dal fatto che venga visualizzata o meno la finestra), l'applicazione deve chiamare CWnd::DrawMenuBar.

Esempio

Vedere l'esempio per CWnd::GetMenu.

`CMenu::DeleteTempMap`

Chiamato automaticamente dal CWinApp gestore tempo di inattività, elimina tutti gli oggetti temporanei CMenu creati dalla FromHandle funzione membro.

static void PASCAL DeleteTempMap();

Osservazioni:

DeleteTempMap scollega l'oggetto menu di Windows associato a un oggetto temporaneo CMenu prima di eliminare l'oggetto CMenu .

Esempio

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

`CMenu::DestroyMenu`

Elimina definitivamente il menu e tutte le risorse di Windows usate.

BOOL DestroyMenu();

Valore restituito

Diverso da zero se il menu viene distrutto; in caso contrario, 0.

Osservazioni:

Il menu viene scollegato dall'oggetto CMenu prima che venga eliminato definitivamente. La funzione Windows DestroyMenu viene chiamata automaticamente nel CMenu distruttore.

Esempio

Vedere l'esempio per CMenu::CreateMenu.

`CMenu::Detach`

Scollega un menu di Windows da un CMenu oggetto e restituisce l'handle.

HMENU Detach();

Valore restituito

Handle, di tipo HMENU, in un menu di Windows, se ha esito positivo; in caso contrario NULL, .

Osservazioni:

Il m_hMenu membro dati è impostato su NULL.

Esempio

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`

Chiamato dal framework quando cambia un aspetto visivo di un menu creato dal proprietario.

virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);

Parametri

lpDrawItemStruct
Puntatore a una DRAWITEMSTRUCT struttura che contiene informazioni sul tipo di disegno richiesto.

Osservazioni:

Il itemAction membro della DRAWITEMSTRUCT struttura definisce l'azione di disegno da eseguire. Eseguire l'override di questa funzione membro per implementare il disegno per un oggetto di disegno CMenu proprietario. L'applicazione deve ripristinare tutti gli oggetti GDI (Graphics Device Interface) selezionati per il contesto di visualizzazione fornito in lpDrawItemStruct prima della terminazione di questa funzione membro.

Vedere CWnd::OnDrawItem per una descrizione della DRAWITEMSTRUCT struttura.

Esempio

Il codice seguente proviene dall'esempio 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`

Abilita, disabilita o disattiva una voce di menu.

UINT EnableMenuItem(
    UINT nIDEnableItem,
    UINT nEnable);

Parametri

nIDEnableItem
Specifica la voce di menu da abilitare, come determinato da nEnable. Questo parametro può specificare voci di menu a comparsa e voci di menu standard.

nEnable
Specifica l'azione da eseguire. Può essere una combinazione di MF_DISABLED, MF_ENABLEDo MF_GRAYED, con MF_BYCOMMAND o MF_BYPOSITION. Questi valori possono essere combinati usando l'operatore OR bit per bit C++ (|). I valori hanno il significato seguente:

MF_BYCOMMAND Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Si tratta dell'impostazione predefinita.
MF_BYPOSITION Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.
MF_DISABLED Disabilita la voce di menu in modo che non possa essere selezionata, ma non lo dim.
MF_ENABLED Abilita la voce di menu in modo che possa essere selezionata e ripristinata dallo stato disattivato.
MF_GRAYED Disabilita la voce di menu in modo che non possa essere selezionata e disattivata.

Valore restituito

Stato precedente (MF_DISABLED, MF_ENABLEDo MF_GRAYED) o -1 se non valido.

Osservazioni:

Le CreateMenufunzioni membro , InsertMenuModifyMenu, e LoadMenuIndirect possono anche impostare lo stato (abilitato, disabilitato o disattivato) di una voce di menu.

L'uso del MF_BYPOSITION valore richiede che un'applicazione usi l'oggetto corretto CMenu. Se viene utilizzata la CMenu barra dei menu, viene interessata una voce di menu di primo livello (una voce nella barra dei menu). Per impostare lo stato di un elemento in un menu a comparsa o annidato in base alla posizione, un'applicazione deve specificare il CMenu del menu a comparsa.

Quando un'applicazione specifica il MF_BYCOMMAND flag, Windows controlla tutte le voci di menu a comparsa subordinate a CMenu, pertanto, a meno che non siano presenti voci di menu duplicate, l'utilizzo CMenu della barra dei menu è sufficiente.

Esempio

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

Restituisce un puntatore a un CMenu oggetto dato un handle di Windows a un menu.

static CMenu* PASCAL FromHandle(HMENU hMenu);

Parametri

hMenu
Handle di Windows in un menu.

Valore restituito

Puntatore a un CMenu oggetto che può essere temporaneo o permanente.

Osservazioni:

Se un CMenu oggetto non è già collegato all'oggetto menu di Windows, viene creato e associato un oggetto temporaneo CMenu .

Questo oggetto temporaneo CMenu è valido solo alla successiva esecuzione dell'applicazione nel ciclo di eventi, in cui vengono eliminati tutti gli oggetti temporanei.

Esempio

Vedere l'esempio per CMenu::CreateMenu.

`CMenu::GetDefaultItem`

Determina la voce di menu predefinita nel menu specificato.

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

Parametri

gmdiFlags
Valore che specifica il modo in cui la funzione cerca le voci di menu. Questo parametro può essere nessuno, uno o una combinazione dei valori seguenti:

Valore Significato

GMDI_GOINTOPOPUPS Specifica che, se l'elemento predefinito è uno che apre un sottomenu, la funzione consiste nel cercare in modo ricorsivo nel sottomenu corrispondente. Se il sottomenu non ha alcun elemento predefinito, il valore restituito identifica l'elemento che apre il sottomenu.

Per impostazione predefinita, la funzione restituisce la prima voce predefinita nel menu specificato, indipendentemente dal fatto che si tratti di un elemento che apre un sottomenu.

GMDI_USEDISABLED Specifica che la funzione deve restituire un elemento predefinito, anche se è disabilitato.

Per impostazione predefinita, la funzione ignora gli elementi disabilitati o disattivati.

Valore	Significato
`GMDI_GOINTOPOPUPS`	Specifica che, se l'elemento predefinito è uno che apre un sottomenu, la funzione consiste nel cercare in modo ricorsivo nel sottomenu corrispondente. Se il sottomenu non ha alcun elemento predefinito, il valore restituito identifica l'elemento che apre il sottomenu. Per impostazione predefinita, la funzione restituisce la prima voce predefinita nel menu specificato, indipendentemente dal fatto che si tratti di un elemento che apre un sottomenu.
`GMDI_USEDISABLED`	Specifica che la funzione deve restituire un elemento predefinito, anche se è disabilitato. Per impostazione predefinita, la funzione ignora gli elementi disabilitati o disattivati.

fByPos
Valore che specifica se recuperare l'identificatore della voce di menu o la relativa posizione. Se questo parametro è FALSE, viene restituito l'identificatore . In caso contrario, viene restituita la posizione.

Valore restituito

Se la funzione ha esito positivo, il valore restituito è l'identificatore o la posizione della voce di menu. Se la funzione ha esito negativo, il valore restituito è - 1.

Osservazioni:

Questa funzione membro implementa il comportamento della funzione GetMenuDefaultItemWin32 , come descritto in Windows SDK.

Esempio

Vedere l'esempio per CMenu::InsertMenu.

`CMenu::GetMenuContextHelpId`

Recupera l'ID della Guida del contesto associato a CMenu.

DWORD GetMenuContextHelpId() const;

Valore restituito

L'ID della Guida di contesto attualmente associato a CMenu se ne ha uno; in caso contrario, zero.

Esempio

Vedere l'esempio per CMenu::InsertMenu.

`CMenu::GetMenuInfo`

Recupera informazioni per un menu.

BOOL GetMenuInfo(LPMENUINFO lpcmi) const;

Parametri

lpcmi
Puntatore a una MENUINFO struttura contenente informazioni per il menu.

Valore restituito

Se la funzione ha esito positivo, il valore restituito è diverso da zero; in caso contrario, il valore restituito è zero.

Osservazioni:

Chiamare questa funzione per recuperare informazioni sul menu.

`CMenu::GetMenuItemCount`

Determina il numero di elementi in un menu a comparsa o di primo livello.

UINT GetMenuItemCount() const;

Valore restituito

Numero di voci nel menu se la funzione ha esito positivo; in caso contrario -1.

Esempio

Vedere l'esempio per CWnd::GetMenu.

`CMenu::GetMenuItemID`

Ottiene l'identificatore della voce di menu per una voce di menu che si trova nella posizione definita da nPos.

UINT GetMenuItemID(int nPos) const;

Parametri

nPos
Specifica la posizione (in base zero) della voce di menu il cui ID viene recuperato.

Valore restituito

ID elemento per l'elemento specificato in un menu a comparsa se la funzione ha esito positivo. Se l'elemento specificato è un menu a comparsa anziché un elemento nel menu a comparsa, il valore restituito è -1. Se nPos corrisponde a una SEPARATOR voce di menu, il valore restituito è 0.

Esempio

Vedere l'esempio per CMenu::InsertMenu.

`CMenu::GetMenuItemInfo`

Recupera informazioni su una voce di menu.

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

Parametri

uItem
Identificatore o posizione della voce di menu per ottenere informazioni. Il significato di questo parametro dipende dal valore di ByPos.

lpMenuItemInfo
Puntatore a un oggetto MENUITEMINFO, come descritto in Windows SDK, che contiene informazioni sul menu.

fByPos
Valore che specifica il significato di nIDItem. Per impostazione predefinita, ByPos è FALSE, che indica che uItem è un identificatore di voce di menu. Se ByPos non è impostato su FALSE, indica una posizione della voce di menu.

Valore restituito

Se la funzione ha esito positivo, il valore restituito è diverso da zero. Se la funzione ha esito negativo, il valore restituito è zero. Per ottenere informazioni estese sull'errore, usare la funzione GetLastErrorWin32 , come descritto in Windows SDK.

Osservazioni:

Questa funzione membro implementa il comportamento della funzione GetMenuItemInfoWin32 , come descritto in Windows SDK. Si noti che nell'implementazione MFC di GetMenuItemInfonon si usa un handle per un menu.

Esempio

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

Restituisce lo stato della voce di menu specificata o del numero di elementi in un menu a comparsa.

UINT GetMenuState(
    UINT nID,
    UINT nFlags) const;

Parametri

nID
Specifica l'ID voce di menu, come determinato da nFlags.

nFlags
Specifica la natura di nID. Può essere uno dei valori seguenti:

MF_BYCOMMAND Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Si tratta dell'impostazione predefinita.
MF_BYPOSITION Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.

Valore restituito

Valore 0xFFFFFFFF se l'elemento specificato non esiste. Se nId identifica un menu a comparsa, il byte di ordine elevato contiene il numero di elementi nel menu a comparsa e il byte di ordine basso contiene i flag di menu associati al menu a comparsa. In caso contrario, il valore restituito è una maschera (OR booleano) dei valori dell'elenco seguente (questa maschera descrive lo stato della voce di menu che nId identifica):

MF_CHECKED Funge da interruttore con MF_UNCHECKED per posizionare il segno di spunta predefinito accanto all'elemento. Quando l'applicazione fornisce bitmap con segno di spunta (vedere la funzione membro), viene visualizzata la SetMenuItemBitmaps bitmap "check mark on".
MF_DISABLED Disabilita la voce di menu in modo che non possa essere selezionata, ma non lo dim.
MF_ENABLED Abilita la voce di menu in modo che possa essere selezionata e ripristinata dallo stato disattivato. Si noti che il valore di questa costante è 0; Un'applicazione non deve eseguire il test su 0 in caso di errore quando si usa questo valore.
MF_GRAYED Disabilita la voce di menu in modo che non possa essere selezionata e disattivata.
MF_MENUBARBREAK Inserisce l'elemento in una nuova riga nei menu statici o in una nuova colonna nei menu a comparsa. La nuova colonna del menu a comparsa verrà separata dalla colonna precedente in base a una linea di divisione verticale.
MF_MENUBREAK Inserisce l'elemento in una nuova riga nei menu statici o in una nuova colonna nei menu a comparsa. Nessuna linea di divisione viene posizionata tra le colonne.
MF_SEPARATOR Disegna una linea di divisione orizzontale. Può essere usato solo in un menu a comparsa. Questa riga non può essere disattivata, disabilitata o evidenziata. Gli altri parametri vengono ignorati.
MF_UNCHECKED Funge da interruttore con MF_CHECKED per rimuovere un segno di spunta accanto all'elemento. Quando l'applicazione fornisce bitmap con segno di spunta (vedere la funzione membro), viene visualizzata la SetMenuItemBitmaps bitmap "check mark off". Si noti che il valore di questa costante è 0; Un'applicazione non deve eseguire il test su 0 in caso di errore quando si usa questo valore.

Esempio

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

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

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

`CMenu::GetMenuString`

Copia l'etichetta della voce di menu specificata nel buffer specificato.

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

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

Parametri

nIDItem
Specifica l'identificatore intero della voce di menu o l'offset della voce di menu nel menu, a seconda del valore di nFlags.

lpString
Punta al buffer che deve ricevere l'etichetta.

rString
Riferimento a un CString oggetto che deve ricevere la stringa di menu copiata.

nMaxCount
Specifica la lunghezza massima, espressa in caratteri, dell'etichetta da copiare. Se l'etichetta è più lunga del valore massimo specificato in nMaxCount, i caratteri aggiuntivi vengono troncati.

nFlags
Specifica l'interpretazione del nIDItem parametro. Può essere uno dei valori seguenti:

`nFlags`	Interpretazione di `nIDItem`
`MF_BYCOMMAND`	Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Questa è l'impostazione predefinita se né `MF_BYCOMMAND` `MF_BYPOSITION` né è impostata.
`MF_BYPOSITION`	Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.

Valore restituito

Specifica il numero effettivo di caratteri copiati nel buffer, senza includere il carattere di terminazione Null.

Osservazioni:

Il nMaxCount parametro deve essere maggiore del numero di caratteri nell'etichetta per contenere il carattere Null che termina una stringa.

Esempio

Vedere l'esempio per CMenu::InsertMenu.

`CMenu::GetSafeHmenu`

Restituisce l'oggetto di cui è stato eseguito il HMENU wrapping da questo CMenu oggetto o da un NULL CMenu puntatore.

HMENU GetSafeHmenu() const;

Esempio

Vedere l'esempio per CMenu::LoadMenu.

`CMenu::GetSubMenu`

Recupera l'oggetto CMenu di un menu a comparsa.

CMenu* GetSubMenu(int nPos) const;

Parametri

nPos
Specifica la posizione del menu a comparsa contenuto nel menu. I valori di posizione iniziano da 0 per la prima voce di menu. L'identificatore del menu a comparsa non può essere usato in questa funzione.

Valore restituito

Puntatore a un CMenu oggetto il cui m_hMenu membro contiene un handle al menu a comparsa se esiste un menu a comparsa nella posizione specificata; in caso contrario NULL, . Se un CMenu oggetto non esiste, ne viene creato uno temporaneo. Il CMenu puntatore restituito non deve essere archiviato.

Esempio

Vedere l'esempio per CMenu::TrackPopupMenu.

`CMenu::InsertMenu`

Inserisce una nuova voce di menu nella posizione specificata da nPosition e sposta le altre voci verso il basso nel 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);

Parametri

nPosition
Specifica la voce di menu prima della quale deve essere inserita la nuova voce di menu. Il nFlags parametro può essere usato per interpretare nPosition nei modi seguenti:

`nFlags`	Interpretazione di `nPosition`
`MF_BYCOMMAND`	Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Questa è l'impostazione predefinita se né `MF_BYCOMMAND` `MF_BYPOSITION` né è impostata.
`MF_BYPOSITION`	Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0. Se `nPosition` è -1, la nuova voce di menu viene aggiunta alla fine del menu.

nFlags
Specifica come nPosition viene interpretato e specifica le informazioni sullo stato della nuova voce di menu quando viene aggiunta al menu. Per un elenco dei flag che possono essere impostati, vedere la AppendMenu funzione membro. Per specificare più valori, usare l'operatore OR bit per bit per combinarli con il MF_BYCOMMAND flag o MF_BYPOSITION .

nIDNewItem
Specifica l'ID comando della nuova voce di menu oppure, se nFlags è impostato su MF_POPUP, l'handle di menu (HMENU) del menu a comparsa. Il nIDNewItem parametro viene ignorato (non necessario) se nFlags è impostato su MF_SEPARATOR.

lpszNewItem
Specifica il contenuto della nuova voce di menu. nFlags può essere usato per interpretare lpszNewItem nei modi seguenti:

`nFlags`	Interpretazione di `lpszNewItem`
`MF_OWNERDRAW`	Contiene un valore a 32 bit fornito dall'applicazione che l'applicazione può usare per mantenere dati aggiuntivi associati alla voce di menu. Questo valore a 32 bit è disponibile per l'applicazione nel `itemData` membro della struttura fornita dai `WM_MEASUREITEM` messaggi e `WM_DRAWITEM` . Questi messaggi vengono inviati quando la voce di menu viene inizialmente visualizzata o modificata.
`MF_STRING`	Contiene un puntatore lungo a una stringa con terminazione Null. Questa è l'interpretazione predefinita.
`MF_SEPARATOR`	Il `lpszNewItem` parametro viene ignorato (non necessario).

pBmp
Punta a un CBitmap oggetto che verrà utilizzato come voce di menu.

Valore restituito

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

Osservazioni:

L'applicazione può specificare lo stato della voce di menu impostando i valori in nFlags.

Ogni volta che un menu che risiede in una finestra viene modificato (indipendentemente dal fatto che venga visualizzata o meno la finestra), l'applicazione deve chiamare CWnd::DrawMenuBar.

Quando nIDNewItem specifica un menu a comparsa, diventa parte del menu in cui viene inserito. Se il menu viene eliminato definitivamente, verrà eliminato anche il menu inserito. Per evitare conflitti, è necessario scollegare un menu inserito da un CMenu oggetto .

Se la finestra figlio MDI (Multiple Document Interface) attiva è ingrandita e un'applicazione inserisce un menu a comparsa nel menu dell'applicazione MDI chiamando questa funzione e specificando il MF_BYPOSITION flag, il menu viene inserito più a sinistra del previsto. Ciò si verifica perché il menu Controllo della finestra figlio MDI attiva viene inserito nella prima posizione della barra dei menu della finestra cornice MDI. Per posizionare correttamente il menu, l'applicazione deve aggiungere 1 al valore di posizione che altrimenti verrebbe usato. Un'applicazione può usare il WM_MDIGETACTIVE messaggio per determinare se la finestra figlio attualmente attiva è ingrandita.

Esempio

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

Inserisce una nuova voce di menu nella posizione specificata in un menu.

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

Parametri

uItem
Vedere la descrizione di uItem in InsertMenuItem In Windows SDK.

lpMenuItemInfo
Vedere la descrizione di lpmii in InsertMenuItem In Windows SDK.

fByPos
Vedere la descrizione di fByPosition in InsertMenuItem In Windows SDK.

Osservazioni:

Questa funzione esegue il wrapping di InsertMenuItem, descritto in Windows SDK.

`CMenu::LoadMenu`

Carica una risorsa di menu dal file eseguibile dell'applicazione e la collega all'oggetto CMenu .

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

Parametri

lpszResourceName
Punta a una stringa con terminazione Null contenente il nome della risorsa di menu da caricare.

nIDResource
Specifica l'ID menu della risorsa di menu da caricare.

Valore restituito

Diverso da zero se la risorsa di menu è stata caricata correttamente; in caso contrario, 0.

Osservazioni:

Esempio

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

Carica una risorsa da un modello di menu in memoria e la collega all'oggetto CMenu .

BOOL LoadMenuIndirect(const void* lpMenuTemplate);

Parametri

lpMenuTemplate
Punta a un modello di menu , ovvero una singola MENUITEMTEMPLATEHEADER struttura e una raccolta di una o più MENUITEMTEMPLATE strutture. Per altre informazioni su queste due strutture, vedere Windows SDK.

Valore restituito

Diverso da zero se la risorsa di menu è stata caricata correttamente; in caso contrario, 0.

Osservazioni:

Un modello di menu è un'intestazione seguita da una raccolta di una o più MENUITEMTEMPLATE strutture, ognuna delle quali può contenere una o più voci di menu e menu a comparsa.

Il numero di versione deve essere 0.

I mtOption flag devono includere MF_END per l'ultimo elemento in un elenco popup e per l'ultimo elemento nell'elenco principale. Vedere la AppendMenu funzione membro per altri flag. Il mtId membro deve essere omesso dalla MENUITEMTEMPLATE struttura quando MF_POPUP viene specificato in mtOption.

Lo spazio allocato per la MENUITEMTEMPLATE struttura deve essere sufficiente per mtString contenere il nome della voce di menu come stringa con terminazione Null.

Esempio

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

Specifica l'handle HMENU del menu di Windows associato all'oggetto CMenu .

HMENU m_hMenu;

Esempio

Vedere l'esempio per CMenu::LoadMenu.

`CMenu::MeasureItem`

Chiamato dal framework quando viene creato un menu con lo stile di disegno proprietario.

virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);

Parametri

lpMeasureItemStruct
Puntatore a una MEASUREITEMSTRUCT struttura.

Osservazioni:

Per impostazione predefinita, questa funzione membro non esegue alcuna operazione. Eseguire l'override di questa funzione membro e compilare la MEASUREITEMSTRUCT struttura per informare Windows delle dimensioni del menu.

Vedere CWnd::OnMeasureItem per una descrizione della MEASUREITEMSTRUCT struttura.

Esempio

Il codice seguente proviene dall'esempio 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`

Modifica una voce di menu esistente nella posizione specificata da 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);

Parametri

nPosition
Specifica la voce di menu da modificare. Il nFlags parametro può essere usato per interpretare nPosition nei modi seguenti:

`nFlags`	Interpretazione di `nPosition`
`MF_BYCOMMAND`	Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Questa è l'impostazione predefinita se né `MF_BYCOMMAND` `MF_BYPOSITION` né è impostata.
`MF_BYPOSITION`	Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.

nFlags
Specifica come nPosition viene interpretato e fornisce informazioni sulle modifiche da apportare alla voce di menu. Per un elenco di flag che possono essere impostati, vedere la AppendMenu funzione membro.

nIDNewItem
Specifica l'ID comando della voce di menu modificata oppure, se nFlags è impostato su MF_POPUP, l'handle di menu (HMENU) di un menu a comparsa. Il nIDNewItem parametro viene ignorato (non necessario) se nFlags è impostato su MF_SEPARATOR.

lpszNewItem
Specifica il contenuto della nuova voce di menu. Il nFlags parametro può essere usato per interpretare lpszNewItem nei modi seguenti:

`nFlags`	Interpretazione di `lpszNewItem`
`MF_OWNERDRAW`	Contiene un valore a 32 bit fornito dall'applicazione che l'applicazione può usare per mantenere dati aggiuntivi associati alla voce di menu. Questo valore a 32 bit è disponibile per l'applicazione quando elabora `MF_MEASUREITEM` e `MF_DRAWITEM`.
`MF_STRING`	Contiene un puntatore lungo a una stringa con terminazione Null o a un oggetto `CString`.
`MF_SEPARATOR`	Il `lpszNewItem` parametro viene ignorato (non necessario).

pBmp
Punta a un CBitmap oggetto che verrà utilizzato come voce di menu.

Valore restituito

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

Osservazioni:

L'applicazione specifica il nuovo stato della voce di menu impostando i valori in nFlags. Se questa funzione sostituisce un menu a comparsa associato alla voce di menu, elimina definitivamente il menu a comparsa precedente e libera la memoria usata dal menu a comparsa.

Ogni volta che un menu che risiede in una finestra viene modificato (indipendentemente dal fatto che venga visualizzata o meno la finestra), l'applicazione deve chiamare CWnd::DrawMenuBar. Per modificare gli attributi delle voci di menu esistenti, è molto più veloce usare le CheckMenuItem funzioni membro e EnableMenuItem .

Esempio

Vedere l'esempio per CMenu::InsertMenu.

`CMenu::operator HMENU`

Utilizzare questo operatore per recuperare l'handle dell'oggetto CMenu .

operator HMENU() const;

Valore restituito

Se ha esito positivo, l'handle dell'oggetto CMenu ; in caso contrario, NULL.

Osservazioni:

È possibile usare l'handle per chiamare direttamente le API di Windows.

`CMenu::operator !=`

Determina se due menu sono logicamente non uguali.

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

Parametri

menu
Oggetto CMenu per il confronto.

Osservazioni:

Verifica se un oggetto menu a sinistra non è uguale a un oggetto menu a destra.

`CMenu::operator ==`

Determina se due menu sono logicamente uguali.

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

Parametri

menu
Oggetto CMenu per il confronto.

Osservazioni:

Verifica se un oggetto menu a sinistra è uguale (in termini di HMENU valore) a un oggetto menu a destra.

`CMenu::RemoveMenu`

Elimina una voce di menu con un menu a comparsa associato dal menu.

BOOL RemoveMenu(
    UINT nPosition,
    UINT nFlags);

Parametri

nPosition
Specifica la voce di menu da rimuovere. Il nFlags parametro può essere usato per interpretare nPosition nei modi seguenti:

`nFlags`	Interpretazione di `nPosition`
`MF_BYCOMMAND`	Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Questa è l'impostazione predefinita se né `MF_BYCOMMAND` `MF_BYPOSITION` né è impostata.
`MF_BYPOSITION`	Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.

nFlags
Specifica la modalità nPosition di interpretazione.

Valore restituito

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

Osservazioni:

Non elimina definitivamente l'handle per un menu a comparsa, quindi il menu può essere riutilizzato. Prima di chiamare questa funzione, l'applicazione può chiamare la GetSubMenu funzione membro per recuperare l'oggetto popup CMenu per il riutilizzo.

Ogni volta che un menu che risiede in una finestra viene modificato (indipendentemente dal fatto che venga visualizzata o meno la finestra), l'applicazione deve chiamare CWnd::DrawMenuBar.

Esempio

Vedere l'esempio per CMenu::InsertMenu.

`CMenu::SetDefaultItem`

Imposta la voce di menu predefinita per il menu specificato.

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

Parametri

uItem
Identificatore o posizione della nuova voce di menu predefinita o - 1 per nessuna voce predefinita. Il significato di questo parametro dipende dal valore di fByPos.

fByPos
Valore che specifica il significato di uItem. Se questo parametro è FALSE, uItem è un identificatore di voce di menu. In caso contrario, si tratta di una posizione della voce di menu.

Valore restituito

Osservazioni:

Questa funzione membro implementa il comportamento della funzione SetMenuDefaultItemWin32 , come descritto in Windows SDK.

Esempio

Vedere l'esempio per CMenu::InsertMenu.

`CMenu::SetMenuContextHelpId`

Associa un ID della Guida di contesto a CMenu.

BOOL SetMenuContextHelpId(DWORD dwContextHelpId);

Parametri

dwContextHelpId
ID guida del contesto da associare a CMenu.

Valore restituito

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

Osservazioni:

Tutte le voci del menu condividono questo identificatore: non è possibile allegare un identificatore di contesto della Guida alle singole voci di menu.

Esempio

Vedere l'esempio per CMenu::InsertMenu.

`CMenu::SetMenuInfo`

Imposta le informazioni per un menu.

BOOL SetMenuInfo(LPCMENUINFO lpcmi);

Parametri

lpcmi
Puntatore a una MENUINFO struttura contenente informazioni per il menu.

Valore restituito

Se la funzione ha esito positivo, il valore restituito è diverso da zero; in caso contrario, il valore restituito è zero.

Osservazioni:

Chiamare questa funzione per impostare informazioni specifiche sul menu.

`CMenu::SetMenuItemBitmaps`

Associa le bitmap specificate a una voce di menu.

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

Parametri

nPosition
Specifica la voce di menu da modificare. Il nFlags parametro può essere usato per interpretare nPosition nei modi seguenti:

`nFlags`	Interpretazione di nPosition
`MF_BYCOMMAND`	Specifica che il parametro fornisce l'ID comando della voce di menu esistente. Questa è l'impostazione predefinita se né `MF_BYCOMMAND` `MF_BYPOSITION` né è impostata.
`MF_BYPOSITION`	Specifica che il parametro fornisce la posizione della voce di menu esistente. Il primo elemento si trova nella posizione 0.

nFlags
Specifica la modalità nPosition di interpretazione.

pBmpUnchecked
Specifica la bitmap da utilizzare per le voci di menu non controllate.

pBmpChecked
Specifica la bitmap da utilizzare per le voci di menu controllate.

Valore restituito

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

Osservazioni:

Se la voce di menu è selezionata o deselezionata, Windows visualizza la bitmap appropriata accanto alla voce di menu.

pBmpUnchecked Se o pBmpChecked è NULL, Windows non visualizza nulla accanto alla voce di menu per l'attributo corrispondente. Se entrambi i parametri sono NULL, Windows usa il segno di spunta predefinito quando l'elemento viene selezionato e rimuove il segno di spunta quando l'elemento è deselezionato.

Quando il menu viene eliminato definitivamente, queste bitmap non vengono distrutte; l'applicazione deve distruggerli.

La funzione Windows GetMenuCheckMarkDimensions recupera le dimensioni del segno di spunta predefinito utilizzato per le voci di menu. L'applicazione usa questi valori per determinare le dimensioni appropriate per le bitmap fornite con questa funzione. Ottenere le dimensioni, creare le bitmap e quindi impostarle.

Esempio

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

Modifica le informazioni su una voce di menu.

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

Parametri

uItem
Vedere la descrizione di uItem in SetMenuItemInfo In Windows SDK.

lpMenuItemInfo
Vedere la descrizione di lpmii in SetMenuItemInfo In Windows SDK.

fByPos
Vedere la descrizione di fByPosition in SetMenuItemInfo In Windows SDK.

Osservazioni:

Questa funzione esegue il wrapping di SetMenuItemInfo, descritto in Windows SDK.

`CMenu::TrackPopupMenu`

Visualizza un menu a comparsa mobile nella posizione specificata e tiene traccia della selezione di elementi nel menu a comparsa.

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

Parametri

nFlags
Specifica i flag di posizione dello schermo e posizione del mouse. Vedere TrackPopupMenu per un elenco dei flag disponibili.

x
Specifica la posizione orizzontale nelle coordinate dello schermo del menu a comparsa. A seconda del valore del nFlags parametro, il menu può essere allineato a sinistra, allineato a destra o centrato rispetto a questa posizione.

y
Specifica la posizione verticale nelle coordinate dello schermo della parte superiore del menu sullo schermo.

pWnd
Identifica la finestra proprietaria del menu a comparsa. Questo parametro non può essere NULL, anche se il TPM_NONOTIFY flag è specificato. Questa finestra riceve tutti i WM_COMMAND messaggi dal menu. Nelle versioni di Windows 3.1 e successive la finestra non riceve WM_COMMAND messaggi fino a TrackPopupMenu quando non viene restituito. In Windows 3.0 la finestra riceve i messaggi prima TrackPopupMenu che vengano restituitiWM_COMMAND.

lpRect
Ignorato.

Valore restituito

Questo metodo restituisce il risultato della chiamata TrackPopupMenu in Windows SDK.

Osservazioni:

Un menu a comparsa mobile può essere visualizzato ovunque sullo schermo.

Esempio

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

Visualizza un menu a comparsa mobile nella posizione specificata e tiene traccia della selezione di elementi nel menu a comparsa.

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

Parametri

fuFlags
Specifica varie funzioni per il menu esteso. Per un elenco di tutti i valori e il relativo significato, vedere TrackPopupMenuEx.

x
Specifica la posizione orizzontale nelle coordinate dello schermo del menu a comparsa.

y
Specifica la posizione verticale nelle coordinate dello schermo della parte superiore del menu sullo schermo.

pWnd
Puntatore alla finestra proprietaria del menu a comparsa e ricezione dei messaggi dal menu creato. Questa finestra può essere qualsiasi finestra dell'applicazione corrente, ma non può essere NULL. Se si specifica TPM_NONOTIFY nel fuFlags parametro , la funzione non invia messaggi a pWnd. La funzione deve restituire per la finestra a cui pWnd punta per ricevere il WM_COMMAND messaggio.

lptpm
Puntatore a una TPMPARAMS struttura che specifica un'area dello schermo che il menu non deve sovrapporsi. Questo parametro può essere NULL.

Valore restituito

Se si specifica TPM_RETURNCMD nel fuFlags parametro , il valore restituito è l'identificatore della voce di menu dell'elemento selezionato dall'utente. Se l'utente annulla il menu senza effettuare una selezione o se si verifica un errore, il valore restituito è 0.

Se non si specifica TPM_RETURNCMD nel fuFlags parametro , il valore restituito è diverso da zero se la funzione ha esito positivo e 0 in caso di errore. Per ottenere informazioni estese sull'errore, chiamare GetLastError.

Osservazioni:

Un menu a comparsa mobile può essere visualizzato ovunque sullo schermo. Per altre informazioni sulla gestione degli errori durante la creazione del menu a comparsa, vedere TrackPopupMenuEx.

Vedi anche

Esempio MFC CTRLTEST
Esempio MFC DYNAMENU
CObject Classe
Grafico della gerarchia

Condividi tramite

Classe CMenu

Sintassi

Membri

Costruttori pubblici

Metodi pubblici

Operatori pubblici

Membri dati pubblici

Osservazioni:

Gerarchia di ereditarietà

Requisiti

CMenu::AppendMenu

Parametri

Valore restituito

Osservazioni:

Esempio

CMenu::Attach

Parametri

Valore restituito

Osservazioni:

Esempio

CMenu::CheckMenuItem

Parametri

Valore restituito

Osservazioni:

Esempio

CMenu::CheckMenuRadioItem

Parametri

Valore restituito

Osservazioni:

Esempio

CMenu::CMenu

Osservazioni:

CMenu::CreateMenu

Valore restituito

Osservazioni:

Esempio

CMenu::CreatePopupMenu

Valore restituito

Osservazioni:

Esempio

CMenu::DeleteMenu

Parametri

Valore restituito

Osservazioni:

Esempio

CMenu::DeleteTempMap

Osservazioni:

Esempio

CMenu::DestroyMenu

Valore restituito

Osservazioni:

Esempio

CMenu::Detach

Valore restituito

Osservazioni:

Esempio

CMenu::DrawItem

Parametri

Osservazioni:

Esempio

CMenu::EnableMenuItem

Parametri

Valore restituito

Osservazioni:

Esempio

CMenu::FromHandle

Parametri

Valore restituito

Osservazioni:

Esempio

CMenu::GetDefaultItem

Parametri

Valore restituito

Osservazioni:

Esempio

CMenu::GetMenuContextHelpId

Valore restituito

Esempio

CMenu::GetMenuInfo

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`