`CMenu` osztály

Megjegyzés:

A Microsoft Foundation Classes (MFC) könyvtár továbbra is támogatott. A továbbiakban azonban nem adunk hozzá funkciókat, és nem frissítjük a dokumentációt.

A Windows HMENUbeágyazása.

Szemantika

class CMenu : public CObject

Tagok

Nyilvános konstruktorok

Név	Description
`CMenu::CMenu`	Egy `CMenu` objektumot hoz létre.

Nyilvános metódusok

Név	Description
`CMenu::AppendMenu`	Új elemet fűz a menü végéhez.
`CMenu::Attach`	Windows menüfogópontot csatol egy `CMenu` objektumhoz.
`CMenu::CheckMenuItem`	Pipát helyez el az előugró menü egyik menüeleme mellett, vagy eltávolítja a pipát.
`CMenu::CheckMenuRadioItem`	Egy menüelem melletti választógombot helyez el, és eltávolítja a választógombot a csoport összes többi menüpontjából.
`CMenu::CreateMenu`	Létrehoz egy üres menüt, és csatolja egy `CMenu` objektumhoz.
`CMenu::CreatePopupMenu`	Létrehoz egy üres előugró menüt, és csatolja egy `CMenu` objektumhoz.
`CMenu::DeleteMenu`	Egy megadott elem törlése a menüből. Ha a menüelem előugró menüvel rendelkezik, a kezelőpontot az előugró menüben megsemmisíti, és felszabadítja az általa használt memóriát.
`CMenu::DeleteTempMap`	Törli a tagfüggvény által `FromHandle` létrehozott ideiglenes `CMenu` objektumokat.
`CMenu::DestroyMenu`	Megsemmisíti az objektumhoz csatolt menüt `CMenu` , és felszabadítja a menü által elfoglalt memóriát.
`CMenu::Detach`	Leválaszt egy Windows menüfogópontot egy `CMenu` objektumról, és visszaadja a fogópontot.
`CMenu::DrawItem`	A keretrendszer meghívja, amikor egy tulajdonos által rajzolt menü vizuális aspektusa megváltozik.
`CMenu::EnableMenuItem`	Engedélyezi, letiltja vagy halványítja (szürkén) egy menüelemet.
`CMenu::FromHandle`	Egy windowsos menüfogópontot kapott objektumra mutató mutatót `CMenu` ad vissza.
`CMenu::GetDefaultItem`	Meghatározza a megadott menü alapértelmezett menüelemét.
`CMenu::GetMenuContextHelpId`	Lekéri a menühöz társított súgókörnyezet azonosítóját.
`CMenu::GetMenuInfo`	Egy adott menü adatainak lekérése.
`CMenu::GetMenuItemCount`	Meghatározza az előugró vagy felső szintű menü elemeinek számát.
`CMenu::GetMenuItemID`	A megadott helyen található menüelem menüelem-azonosítójának lekérése.
`CMenu::GetMenuItemInfo`	Beolvassa a menüelem adatait.
`CMenu::GetMenuState`	A megadott menüelem állapotát vagy az előugró menü elemeinek számát adja vissza.
`CMenu::GetMenuString`	Lekéri a megadott menüelem címkéjét.
`CMenu::GetSafeHmenu`	`m_hMenu` Az objektum által `CMenu` becsomagolt értéket adja vissza.
`CMenu::GetSubMenu`	Mutatót kér le egy előugró menübe.
`CMenu::InsertMenu`	Beszúr egy új menüelemet a megadott pozícióba, és más elemeket helyez le a menübe.
`CMenu::InsertMenuItem`	Új menüelemet szúr be a megadott pozícióba egy menüben.
`CMenu::LoadMenu`	Betölt egy menüerőforrást a végrehajtható fájlból, és csatolja egy `CMenu` objektumhoz.
`CMenu::LoadMenuIndirect`	Betölt egy menüt egy menüsablonból a memóriában, és csatolja egy `CMenu` objektumhoz.
`CMenu::MeasureItem`	A keretrendszer meghívta a menüdimenziók meghatározására a tulajdonos által rajzolt menü létrehozásakor.
`CMenu::ModifyMenu`	Egy meglévő menüelem módosítása a megadott helyen.
`CMenu::RemoveMenu`	Egy kapcsolódó előugró menüt tartalmazó menüelem törlése a megadott menüből.
`CMenu::SetDefaultItem`	Beállítja a megadott menü alapértelmezett menüelemét.
`CMenu::SetMenuContextHelpId`	Beállítja a súgókörnyezet azonosítóját a menühöz társítva.
`CMenu::SetMenuInfo`	Egy adott menü információinak megadása.
`CMenu::SetMenuItemBitmaps`	A megadott pipa-bitképeket egy menüelemhez társítja.
`CMenu::SetMenuItemInfo`	A menüelem adatainak módosítása.
`CMenu::TrackPopupMenu`	Megjelenít egy lebegő előugró menüt a megadott helyen, és nyomon követi az előugró menü elemeinek kiválasztását.
`CMenu::TrackPopupMenuEx`	Megjelenít egy lebegő előugró menüt a megadott helyen, és nyomon követi az előugró menü elemeinek kiválasztását.

Nyilvános operátorok

Név	Description
`CMenu::operator HMENU`	Lekéri a menüobjektum leíróját.
`CMenu::operator !=`	Meghatározza, hogy két menüobjektum nem egyenlő-e.
`CMenu::operator ==`	Meghatározza, hogy két menüobjektum egyenlő-e.

Nyilvános adatok tagjai

Név	Description
`CMenu::m_hMenu`	Megadja az objektumhoz csatolt Windows menü leíróját `CMenu` .

Megjegyzések

Tagfüggvényeket biztosít egy menü létrehozásához, nyomon követéséhez, frissítéséhez és megsemmisítéséhez.

Hozzon létre egy CMenu objektumot a veremkereten helyiként, majd hívja meg CMenua tagfüggvényeket az új menü szükség szerinti módosításához. Ezután hívja CWnd::SetMenu meg a menüt egy ablakra, majd azonnal hívja meg az CMenu objektum tagfüggvényét Detach . A CWnd::SetMenu tagfüggvény az ablak menüjét az új menüre állítja, az ablakot újrarajzoltuk, hogy tükrözze a menüváltást, és a menü tulajdonjogát is átadja az ablaknak. A hívás Detach leválasztja az HMENU objektumot CMenu , így amikor a helyi CMenu változó kikerül a hatókörből, az CMenu objektummegsemmisítő nem kísérli meg megsemmisíteni a már nem birtokolt menüt. Maga a menü automatikusan elpusztul, amikor az ablak elpusztul.

A tagfüggvény használatával LoadMenuIndirect létrehozhat egy menüt egy sablonból a memóriában, de az erőforrásból egy hívással LoadMenu létrehozott menü könnyebben karbantartható, és magát a menüerőforrást is létrehozhatja és módosíthatja a menüszerkesztő.

Öröklési hierarchia

CObject

CMenu

Requirements

Fejléc:afxwin.h

`CMenu::AppendMenu`

Új elem hozzáfűzése a menü végéhez.

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

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

Paraméterek

nFlags
Az új menüelem állapotával kapcsolatos információkat adja meg a menühöz való hozzáadáskor. A megjegyzések szakaszban felsorolt értékek közül egy vagy többből áll.

nIDNewItem
Megadja az új menüelem parancsazonosítóját, vagy ha nFlags be van állítva MF_POPUP, az előugró menü menüfogópontját (HMENU). A nIDNewItem paraméter figyelmen kívül lesz hagyva (nem szükséges), ha nFlags be van állítva MF_SEPARATOR.

lpszNewItem
Az új menüelem tartalmát adja meg. A nFlags paramétert a következő módon értelmezzük lpszNewItem :

`nFlags`	A `lpszNewItem`
`MF_OWNERDRAW`	Egy alkalmazás által megadott 32 bites értéket tartalmaz, amelyet az alkalmazás a menüelemhez társított további adatok fenntartására használhat. Ez a 32 bites érték akkor érhető el az alkalmazás számára, amikor feldolgozza `WM_MEASUREITEM` és `WM_DRAWITEM` üzeneteket küld. Az érték az `itemData` adott üzenetekhez megadott struktúra tagjában van tárolva.
`MF_STRING`	Null értékű sztringre mutató mutatót tartalmaz. Ez az alapértelmezett értelmezés.
`MF_SEPARATOR`	A `lpszNewItem` paraméter figyelmen kívül lesz hagyva (nem szükséges).

pBmp
CBitmap A menüelemként használt objektumra mutat.

Visszaadott érték

Nonzero, ha a függvény sikeres; egyéb esetben 0.

Megjegyzések

Az alkalmazás a menüelem állapotát a következő értékekkel nFlagsadhatja meg: Amikor nIDNewItem előugró menüt ad meg, az annak a menünek a része lesz, amelyhez hozzá van fűzve. Ha a menü elpusztul, a hozzáfűzött menü is el lesz pusztítva. A hozzáfűzött menüt le kell választani egy CMenu objektumról az ütközés elkerülése érdekében. Vegye figyelembe, hogy MF_STRINGMF_OWNERDRAW a bittérképes AppendMenuverzió nem érvényes.

Az alábbi lista azokat a jelölőket ismerteti, amelyek a következőkben állíthatók be nFlags:

MF_CHECKED Váltógombként MF_UNCHECKED működik az elem melletti alapértelmezett pipa elhelyezéséhez. Amikor az alkalmazás pipa bitképeket biztosít (lásd a SetMenuItemBitmaps tagfüggvényt), megjelenik a "pipa" bitkép.
MF_UNCHECKED Váltógombként MF_CHECKED működik az elem melletti pipa eltávolításához. Amikor az alkalmazás pipa bitképeket biztosít (lásd a SetMenuItemBitmaps tagfüggvényt), megjelenik a "pipa kikapcsolva" bitkép.
MF_DISABLED Letiltja a menüelemet, hogy ne lehessen kijelölni, de ne halványíthassa el.
MF_ENABLED Engedélyezi a menüelemet, hogy kijelölhető legyen, és visszaállítsa a halvány állapotából.
MF_GRAYED Letiltja a menüelemet, hogy ne lehessen kijelölni és halványítani.
MF_MENUBARBREAK Az elemet egy új sorban helyezi el statikus menükben vagy egy új oszlopban az előugró menükben. Az új előugró menüoszlopot függőleges osztásvonal választja el a régi oszloptól.
MF_MENUBREAK Az elemet egy új sorban helyezi el statikus menükben vagy egy új oszlopban az előugró menükben. Az oszlopok között nincs elválasztó vonal.
MF_OWNERDRAW Azt adja meg, hogy az elem egy tulajdonosi rajzelem. Amikor a menü első alkalommal jelenik meg, a menüt tartalmazó ablak kap egy WM_MEASUREITEM üzenetet, amely lekéri a menüelem magasságát és szélességét. Az WM_DRAWITEM üzenet akkor lesz elküldve, ha a tulajdonosnak frissítenie kell a menüelem vizuális megjelenését. Ez a beállítás nem érvényes a felső szintű menüelemre.
MF_POPUP Megadja, hogy a menüelemhez tartozik-e előugró menü. Az azonosító paraméter egy leírót ad meg az elemhez társítandó előugró menühöz. Ez arra szolgál, hogy felső szintű előugró menüt vagy hierarchikus előugró menüt adjon hozzá egy előugró menüelemhez.
MF_SEPARATOR Vízszintes osztóvonalat rajzol. Csak előugró menüben használható. Ez a sor nem halványítható, nem tiltható le és nem emelhető ki. A rendszer figyelmen kívül hagyja az egyéb paramétereket.
MF_STRING Megadja, hogy a menüelem egy karaktersztring.

Az alábbi csoportok felsorolják azokat a jelzőket, amelyek kölcsönösen kizárják egymást, és nem használhatók együtt:

MF_DISABLED, MF_ENABLEDés MF_GRAYED
MF_STRING, MF_OWNERDRAW, MF_SEPARATORés a bitkép verziója
MF_MENUBARBREAK és MF_MENUBREAK
MF_CHECKED és MF_UNCHECKED

Ha egy ablakban található menüt módosítanak (függetlenül attól, hogy megjelenik-e az ablak), az alkalmazásnak hívnia CWnd::DrawMenuBarkell.

Example

Lásd a példát a CMenu::CreateMenu.

`CMenu::Attach`

Meglévő Windows-menü csatolása egy CMenu objektumhoz.

BOOL Attach(HMENU hMenu);

Paraméterek

hMenu
Egy Windows-menü fogópontját adja meg.

Visszaadott érték

Nonzero, ha a művelet sikeres volt; egyéb esetben 0.

Megjegyzések

Ezt a függvényt nem szabad meghívni, ha már van menü az CMenu objektumhoz csatolva. A menükezelőt az m_hMenu adattag tárolja.

Ha a módosítani kívánt menü már hozzá van rendelve egy ablakhoz, a CWnd::GetMenu függvény segítségével lekérheti a menü fogópontját.

Example

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

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

mnu.Detach();

`CMenu::CheckMenuItem`

Bejelöli vagy eltávolítja a pipákat az előugró menü menüelemeiből.

UINT CheckMenuItem(
    UINT nIDCheckItem,
    UINT nCheck);

Paraméterek

nIDCheckItem
A ellenőrizni kívánt menüelemet adja meg, a megadott módon nCheck.

nCheck
Megadja, hogyan ellenőrizheti a menüelemet, és hogyan határozhatja meg az elem pozícióját a menüben. A nCheck paraméter lehet kombinálva MF_CHECKED vagy MF_UNCHECKED jelölőkkel MF_BYPOSITIONMF_BYCOMMAND . Ezek a jelzők a bitenkénti VAGY operátorral kombinálhatók. Jelentéseik a következők:

MF_BYCOMMAND Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett beállítás.
MF_BYPOSITION Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.
MF_CHECKED Váltógombként MF_UNCHECKED működik az elem melletti alapértelmezett pipa elhelyezéséhez.
MF_UNCHECKED Váltógombként MF_CHECKED működik az elem melletti pipa eltávolításához.

Visszaadott érték

Az elem előző állapota: MF_CHECKED vagy MF_UNCHECKED0xFFFFFFFF ha a menüelem nem létezik.

Megjegyzések

A nIDCheckItem paraméter megadja a módosítani kívánt elemet.

A nIDCheckItem paraméter azonosíthat egy előugró menüelemet, valamint egy menüelemet. Az előugró menüelem ellenőrzéséhez nincs szükség speciális lépésekre. A felső szintű menüelemek nem ellenőrizhetők. Az előugró menüelemeket pozíció szerint kell ellenőrizni, mivel nincs hozzá hozzárendelve menüelem-azonosító.

Example

Lásd a példát a CMenu::GetMenuState.

`CMenu::CheckMenuRadioItem`

Ellenőrzi a megadott menüelemet, és rádióelemként jeleníti meg.

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

Paraméterek

nIDFirst
Megadja (azonosítóként vagy eltolásként, az értéktől nFlagsfüggően) a választógombcsoport első menüelemét.

nIDLast
Megadja (azonosítóként vagy eltolásként, az értéktől nFlagsfüggően) a választógombcsoport utolsó menüelemét.

nIDItem
Megadja (azonosítóként vagy eltolásként, az értéktől függően) a csoport azon elemét nFlags, amelyet egy választógombbal kell ellenőrizni.

nFlags
Az , nIDLastés nIDItem a következő módon adja meg az értelmezéstnIDFirst:

nFlags	Értelmezés
`MF_BYCOMMAND`	Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett érték, ha egyik sem `MF_BYCOMMANDMF_BYPOSITION` van beállítva.
`MF_BYPOSITION`	Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.

Visszaadott érték

Nonzero, ha sikeres; egyéb esetben 0

Megjegyzések

Ezzel egyidejűleg a függvény törli a társított csoport összes többi menüelemének jelölését, és törli az adott elemek választóelem-típusjelzőjét. A bejelölt elem egy választógomb (vagy listajel) bitkép használatával jelenik meg pipa bitkép helyett.

Example

Lásd a példát a ON_COMMAND_RANGE.

`CMenu::CMenu`

Létrehoz egy üres menüt, és csatolja egy CMenu objektumhoz.

CMenu();

Megjegyzések

A menü csak akkor jön létre, ha meghívja a következő létrehozási vagy betöltési tagfüggvények egyikét CMenu:

CreateMenu
CreatePopupMenu
LoadMenu
LoadMenuIndirect
Attach

`CMenu::CreateMenu`

Létrehoz egy menüt, és csatolja az CMenu objektumhoz.

BOOL CreateMenu();

Visszaadott érték

Nonzero, ha a menü sikeresen létrejött; egyéb esetben 0.

Megjegyzések

A menü kezdetben üres. A menüelemek a tagfüggvény vagy InsertMenu a AppendMenu tagfüggvény használatával adhatók hozzá.

Ha a menü egy ablakhoz van rendelve, az automatikusan megsemmisül, amikor az ablak elpusztul.

A kilépés előtt az alkalmazásnak szabaddá kell tennie a menühöz társított rendszererőforrásokat, ha a menü nincs hozzárendelve egy ablakhoz. Az alkalmazás a tagfüggvény meghívásával felszabadít egy menüt DestroyMenu .

Example

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

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

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

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

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

// Assign default menu
m_hMenuDefault = m_NewMenu.m_hMenu;

`CMenu::CreatePopupMenu`

Létrehoz egy előugró menüt, és csatolja az CMenu objektumhoz.

BOOL CreatePopupMenu();

Visszaadott érték

Nem, ha az előugró menü sikeresen létrejött; egyéb esetben 0.

Megjegyzések

A menü kezdetben üres. A menüelemek a tagfüggvény vagy InsertMenu a AppendMenu tagfüggvény használatával adhatók hozzá. Az alkalmazás hozzáadhatja az előugró menüt egy meglévő vagy előugró menühöz. A TrackPopupMenu tagfüggvény használható a menü lebegő előugró menüként való megjelenítésére és az előugró menü kijelöléseinek nyomon követésére.

Ha a menü egy ablakhoz van rendelve, az automatikusan megsemmisül, amikor az ablak elpusztul. Ha a menü egy meglévő menühöz van hozzáadva, az automatikusan el lesz pusztítva, amikor a menü elpusztul.

A kilépés előtt az alkalmazásnak felugró menühöz társított rendszererőforrásokat kell felszabadítania, ha a menü nincs hozzárendelve egy ablakhoz. Az alkalmazás a tagfüggvény meghívásával felszabadít egy menüt DestroyMenu .

Example

Lásd a példát a CMenu::CreateMenu.

`CMenu::DeleteMenu`

Töröl egy elemet a menüből.

BOOL DeleteMenu(
    UINT nPosition,
    UINT nFlags);

Paraméterek

nPosition
Megadja a törölni kívánt menüelemet, a megadott módon nFlags.

nFlags
A következő értelmezésre nPosition szolgál:

`nFlags`	A `nPosition`
`MF_BYCOMMAND`	Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett érték, ha egyik sem `MF_BYCOMMANDMF_BYPOSITION` van beállítva.
`MF_BYPOSITION`	Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.

Visszaadott érték

Nonzero, ha a függvény sikeres; egyéb esetben 0.

Megjegyzések

Ha a menüelemhez tartozik előugró menü, az előugró menüben lévő fogópontot megsemmisíti, DeleteMenu és felszabadítja az előugró menü által használt memóriát.

Amikor egy ablakban található menüt módosítanak (függetlenül attól, hogy megjelenik-e az ablak), az alkalmazásnak hívnia CWnd::DrawMenuBarkell.

Example

Lásd a példát a CWnd::GetMenu.

`CMenu::DeleteTempMap`

Az üresjárati idő kezelője CWinApp automatikusan meghívja, törli a FromHandle tagfüggvény által létrehozott ideiglenes CMenu objektumokat.

static void PASCAL DeleteTempMap();

Megjegyzések

DeleteTempMap Az objektum törlése előtt leválasztja az ideiglenes CMenu objektumhoz csatolt Windows menüobjektumot CMenu .

Example

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

`CMenu::DestroyMenu`

Megsemmisíti a menüt és a használt Windows-erőforrásokat.

BOOL DestroyMenu();

Visszaadott érték

Nonzero, ha a menü megsemmisül; egyéb esetben 0.

Megjegyzések

A menü le lesz választva az CMenu objektumról, mielőtt megsemmisítené. A Rendszer automatikusan meghívja a Windows DestroyMenu függvényt a CMenu destruktorban.

Example

Lásd a példát a CMenu::CreateMenu.

`CMenu::Detach`

Leválaszt egy Windows-menüt egy CMenu objektumról, és visszaadja a leírót.

HMENU Detach();

Visszaadott érték

A leíró típusa HMENUwindowsos menübe, ha sikeres; ellenkező esetben NULL.

Megjegyzések

Az m_hMenu adattag a következőre NULLvan állítva: .

Example

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

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

mnu.Detach();

`CMenu::DrawItem`

A keretrendszer meghívja, amikor egy tulajdonos által rajzolt menü vizuális aspektusa megváltozik.

virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);

Paraméterek

lpDrawItemStruct
Mutató egy DRAWITEMSTRUCT szerkezetre, amely a szükséges rajztípussal kapcsolatos információkat tartalmazza.

Megjegyzések

A itemAction struktúra tagja DRAWITEMSTRUCT határozza meg a végrehajtandó rajzműveletet. A tagfüggvény felülbírálása egy tulajdonosi rajzobjektum CMenu rajzának implementálásához. Az alkalmazásnak vissza kell állítania az összes grafikus eszközillesztő (GDI) objektumot, amely a tagfüggvény bezárása előtt megadott lpDrawItemStruct megjelenítési környezethez van kiválasztva.

Tekintse meg CWnd::OnDrawItem a DRAWITEMSTRUCT szerkezet leírását.

Example

Az alábbi kód az MFC-mintából CTRLTEST származik:

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

Engedélyezi, letiltja vagy halványítja a menüelemet.

UINT EnableMenuItem(
    UINT nIDEnableItem,
    UINT nEnable);

Paraméterek

nIDEnableItem
Megadja az engedélyezendő menüelemet, a megadott módon nEnable. Ez a paraméter megadhatja az előugró menüelemeket és a standard menüelemeket.

nEnable
Megadja a végrehajtandó műveletet. Ez lehet a kombináció, MF_DISABLEDMF_ENABLEDvagy MF_GRAYEDa , vagy .MF_BYCOMMANDMF_BYPOSITION Ezek az értékek a C++ bitenkénti VAGY operátorral (|) kombinálhatók. Ezek az értékek a következő jelentéssel rendelkeznek:

MF_BYCOMMAND Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett beállítás.
MF_BYPOSITION Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.
MF_DISABLED Letiltja a menüelemet, hogy ne lehessen kijelölni, de ne halványíthassa el.
MF_ENABLED Engedélyezi a menüelemet, hogy kijelölhető legyen, és visszaállítsa a halvány állapotából.
MF_GRAYED Letiltja a menüelemet, hogy ne lehessen kijelölni és halványítani.

Visszaadott érték

Előző állapot (MF_DISABLED, MF_ENABLEDvagy ) vagy MF_GRAYED-1, ha érvénytelen.

Megjegyzések

A CreateMenu, InsertMenu, ModifyMenués LoadMenuIndirect tagfüggvények a menüelem állapotát (engedélyezve, letiltva vagy halványítva) is beállíthatják.

Az MF_BYPOSITION érték használatához egy alkalmazásnak a megfelelőt CMenukell használnia. Ha a CMenu menüsávot használja, a rendszer egy felső szintű menüelemet (a menüsáv egyik elemét) érint. Ha egy előugró vagy beágyazott előugró menüben lévő elem állapotát pozíció szerint szeretné beállítani, az alkalmazásnak meg kell adnia az CMenu előugró menüt.

Amikor egy alkalmazás megadja a jelölőt, a Windows ellenőrzi az MF_BYCOMMAND összes előugró menüelemet, amely alá van rendelve a CMenumenünek, ezért ha nem szerepelnek ismétlődő menüelemek, a menüsáv használata CMenu elegendő.

Example

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

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

`CMenu::FromHandle`

Egy windowsos fogópontnak adott objektumra mutató mutatót CMenu ad vissza egy menühöz.

static CMenu* PASCAL FromHandle(HMENU hMenu);

Paraméterek

hMenu
Windows-leíró egy menühöz.

Visszaadott érték

Egy ideiglenes CMenu vagy állandó mutató.

Megjegyzések

Ha egy CMenu objektum még nincs csatolva a Windows menüobjektumhoz, a rendszer létrehoz és csatol egy ideiglenes CMenu objektumot.

Ez az ideiglenes CMenu objektum csak addig érvényes, amíg az alkalmazás következő alkalommal nem rendelkezik tétlen idővel az eseményhurkában, és ekkor az összes ideiglenes objektum törlődik.

Example

Lásd a példát a CMenu::CreateMenu.

`CMenu::GetDefaultItem`

Meghatározza a megadott menü alapértelmezett menüelemét.

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

Paraméterek

gmdiFlags
Érték, amely meghatározza, hogy a függvény hogyan keres menüelemeket. Ez a paraméter a következő értékek egyikét vagy kombinációját sem tartalmazhatja:

Érték Meaning

GMDI_GOINTOPOPUPS Azt adja meg, hogy ha az alapértelmezett elem egy almenüt megnyitó elem, akkor a függvény rekurzív módon keres a megfelelő almenüben. Ha az almenü nem tartalmaz alapértelmezett elemet, a visszatérési érték azonosítja az almenüt megnyitó elemet.

Alapértelmezés szerint a függvény a megadott menü első alapértelmezett elemét adja vissza, függetlenül attól, hogy egy almenüt megnyitó elemről van-e szó.

GMDI_USEDISABLED Megadja, hogy a függvény egy alapértelmezett elemet adjon vissza, még akkor is, ha le van tiltva.

Alapértelmezés szerint a függvény kihagyja a letiltott vagy szürkés elemeket.

Érték	Meaning
`GMDI_GOINTOPOPUPS`	Azt adja meg, hogy ha az alapértelmezett elem egy almenüt megnyitó elem, akkor a függvény rekurzív módon keres a megfelelő almenüben. Ha az almenü nem tartalmaz alapértelmezett elemet, a visszatérési érték azonosítja az almenüt megnyitó elemet. Alapértelmezés szerint a függvény a megadott menü első alapértelmezett elemét adja vissza, függetlenül attól, hogy egy almenüt megnyitó elemről van-e szó.
`GMDI_USEDISABLED`	Megadja, hogy a függvény egy alapértelmezett elemet adjon vissza, még akkor is, ha le van tiltva. Alapértelmezés szerint a függvény kihagyja a letiltott vagy szürkés elemeket.

fByPos
Érték, amely meghatározza, hogy a menüelem azonosítóját vagy pozícióját szeretné-e lekérni. Ha ez a paraméter, FALSEa függvény visszaadja az azonosítót. Ellenkező esetben a függvény visszaadja a pozíciót.

Visszaadott érték

Ha a függvény sikeres, a visszatérési érték a menüelem azonosítója vagy pozíciója. Ha a függvény sikertelen, a visszatérési érték - 1.

Megjegyzések

Ez a tagfüggvény implementálja a Win32 függvény GetMenuDefaultItemviselkedését a Windows SDK-ban leírtak szerint.

Example

Lásd a példát a CMenu::InsertMenu.

`CMenu::GetMenuContextHelpId`

Lekéri a környezethez társított súgóazonosítót CMenu.

DWORD GetMenuContextHelpId() const;

Visszaadott érték

A környezet súgóazonosítója, amelyhez jelenleg társítva van, ha rendelkezik ilyennel CMenu , ellenkező esetben nulla.

Example

Lásd a példát a CMenu::InsertMenu.

`CMenu::GetMenuInfo`

Beolvassa egy menü adatait.

BOOL GetMenuInfo(LPMENUINFO lpcmi) const;

Paraméterek

lpcmi
A menü információját tartalmazó struktúra mutatója MENUINFO .

Visszaadott érték

Ha a függvény sikeres, a visszatérési érték nem nulla; ellenkező esetben a visszatérési érték nulla.

Megjegyzések

Hívja meg ezt a függvényt a menü adatainak lekéréséhez.

`CMenu::GetMenuItemCount`

Meghatározza az előugró vagy felső szintű menü elemeinek számát.

UINT GetMenuItemCount() const;

Visszaadott érték

A menü elemeinek száma, ha a függvény sikeres; egyéb esetben -1.

Example

Lásd a példát a CWnd::GetMenu.

`CMenu::GetMenuItemID`

Beolvasja a menüelem azonosítót a megadott helyen található menüelemhez nPos.

UINT GetMenuItemID(int nPos) const;

Paraméterek

nPos
Megadja annak a menüelemnek a helyét (nulla alapú), amelynek azonosítóját lekéri.

Visszaadott érték

Ha a függvény sikeres, a megadott elem elemazonosítója egy előugró menüben. Ha a megadott elem előugró menü (szemben az előugró menü egyik elemével), a visszatérési érték -1. Ha nPos egy SEPARATOR menüelemnek felel meg, a visszatérési érték 0.

Example

Lásd a példát a CMenu::InsertMenu.

`CMenu::GetMenuItemInfo`

Beolvassa a menüelem adatait.

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

Paraméterek

uItem
A menüelem azonosítója vagy pozíciója az információk lekéréséhez. Ennek a paraméternek a jelentése a paraméter értékétől ByPosfügg.

lpMenuItemInfo
A Windows SDK-ban leírt, a menüvel kapcsolatos információkat tartalmazó mutató MENUITEMINFO.

fByPos
A jelentés jelentését nIDItemmeghatározó érték. Alapértelmezés szerint ez azFALSE, amely azt jelzi, ByPos hogy a felhasználói felület egy menüelem-azonosító. Ha ByPos nincs beállítva FALSE, a menüelem pozícióját jelzi.

Visszaadott érték

Ha a függvény sikeres, a visszatérési érték nem lesz nulla. Ha a függvény sikertelen, a visszatérési érték nulla. A kiterjesztett hibainformációk lekéréséhez használja a Win32 függvényt GetLastErrora Windows SDK-ban leírtak szerint.

Megjegyzések

Ez a tagfüggvény implementálja a Win32 függvény GetMenuItemInfoviselkedését a Windows SDK-ban leírtak szerint. Vegye figyelembe, hogy az MFC implementációjában GetMenuItemInfonem használ fogópontot a menühöz.

Example

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

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

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

`CMenu::GetMenuState`

A megadott menüelem állapotát vagy az előugró menü elemeinek számát adja vissza.

UINT GetMenuState(
    UINT nID,
    UINT nFlags) const;

Paraméterek

nID
A menüelem azonosítóját adja meg a megadott módon nFlags.

nFlags
A természetét nIDadja meg. A következő értékek egyike lehet:

MF_BYCOMMAND Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett beállítás.
MF_BYPOSITION Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.

Visszaadott érték

Az érték 0xFFFFFFFF , ha a megadott elem nem létezik. Ha nId egy előugró menüt azonosít, a magas szintű bájt az előugró menü elemeinek számát, az alacsony sorrendű bájt pedig az előugró menühöz társított menüjelölőket tartalmazza. Ellenkező esetben a visszatérési érték az alábbi listából származó értékek maszkja (LOGIKAI VAGY) (ez a maszk az azonosító menüelem nId állapotát írja le):

MF_CHECKED Váltógombként MF_UNCHECKED működik az elem melletti alapértelmezett pipa elhelyezéséhez. Amikor az alkalmazás pipa bitképeket biztosít (lásd a SetMenuItemBitmaps tagfüggvényt), megjelenik a "pipa" bitkép.
MF_DISABLED Letiltja a menüelemet, hogy ne lehessen kijelölni, de ne halványíthassa el.
MF_ENABLED Engedélyezi a menüelemet, hogy kijelölhető legyen, és visszaállítsa a halvány állapotából. Vegye figyelembe, hogy ennek az állandónak az értéke 0; az alkalmazás nem tesztelhet 0-s hibát az érték használatakor.
MF_GRAYED Letiltja a menüelemet, hogy ne lehessen kijelölni és halványítani.
MF_MENUBARBREAK Az elemet egy új sorban helyezi el statikus menükben vagy egy új oszlopban az előugró menükben. Az új előugró menüoszlopot függőleges osztásvonal választja el a régi oszloptól.
MF_MENUBREAK Az elemet egy új sorban helyezi el statikus menükben vagy egy új oszlopban az előugró menükben. Az oszlopok között nincs elválasztó vonal.
MF_SEPARATOR Vízszintes osztóvonalat rajzol. Csak előugró menüben használható. Ez a sor nem halványítható, nem tiltható le és nem emelhető ki. A rendszer figyelmen kívül hagyja az egyéb paramétereket.
MF_UNCHECKED Váltógombként MF_CHECKED működik az elem melletti pipa eltávolításához. Amikor az alkalmazás pipa bitképeket biztosít (lásd a SetMenuItemBitmaps tagfüggvényt), megjelenik a "pipa kikapcsolva" bitkép. Vegye figyelembe, hogy ennek az állandónak az értéke 0; az alkalmazás nem tesztelhet 0-s hibát az érték használatakor.

Example

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

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

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

`CMenu::GetMenuString`

Másolja a megadott menüelem címkéjét a megadott pufferbe.

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

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

Paraméterek

nIDItem
A menüelem vagy a menüelem eltolásának egész számazonosítóját nFlagsadja meg a menü értékétől függően.

lpString
A címkét fogadó pufferre mutat.

rString
Hivatkozás egy CString objektumra, amely a másolt menüsztringet fogadja.

nMaxCount
Megadja a másolandó címke maximális hosszát (karakterben). Ha a címke hosszabb, mint a megadott nMaxCountmaximális érték, a további karakterek csonkulnak.

nFlags
Megadja a paraméter értelmezését nIDItem . A következő értékek egyike lehet:

`nFlags`	A `nIDItem`
`MF_BYCOMMAND`	Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett érték, ha egyik sem `MF_BYCOMMANDMF_BYPOSITION` van beállítva.
`MF_BYPOSITION`	Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.

Visszaadott érték

A pufferbe másolt karakterek tényleges számát adja meg, a null terminátort nem beleértve.

Megjegyzések

A nMaxCount paraméternek egy nagyobbnak kell lennie, mint a címke karaktereinek száma a sztringet megszakító null karakter elhelyezéséhez.

Example

Lásd a példát a CMenu::InsertMenu.

`CMenu::GetSafeHmenu`

HMENU Az objektum vagy mutató NULLCMenu által CMenu becsomagolt értéket adja vissza.

HMENU GetSafeHmenu() const;

Example

Lásd a példát a CMenu::LoadMenu.

`CMenu::GetSubMenu`

Lekéri egy CMenu előugró menü objektumát.

CMenu* GetSubMenu(int nPos) const;

Paraméterek

nPos
A menüben található előugró menü helyét adja meg. A pozícióértékek az első menüelemnél 0-nál kezdődnek. Az előugró menü azonosítója ebben a függvényben nem használható.

Visszaadott érték

Mutató egy CMenu olyan objektumra, amelynek m_hMenu tagja az előugró menühöz tartozó fogópontot tartalmaz, ha az adott helyen előugró menü található; ellenkező esetben NULL. Ha egy CMenu objektum nem létezik, akkor létrejön egy ideiglenes objektum. A CMenu visszaadott mutatót nem szabad tárolni.

Example

Lásd a példát a CMenu::TrackPopupMenu.

`CMenu::InsertMenu`

Beszúr egy új menüelemet a megadott nPosition pozícióba, és más elemeket is áthelyez a menübe.

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éterek

nPosition
Megadja azt a menüelemet, amely elé be szeretné szúrni az új menüelemet. A nFlags paraméter a következő módokon értelmezhető nPosition :

`nFlags`	A `nPosition`
`MF_BYCOMMAND`	Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett érték, ha egyik sem `MF_BYCOMMANDMF_BYPOSITION` van beállítva.
`MF_BYPOSITION`	Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van. Ha `nPosition` -1, az új menüelem hozzá lesz fűzve a menü végéhez.

nFlags
Meghatározza az értelmezés módját nPosition , és megadja az új menüelem állapotával kapcsolatos információkat, amikor hozzáadja azt a menühöz. A beállítható jelölők listájáért tekintse meg a tagfüggvényt AppendMenu . Egynél több érték megadásához használja a bitenkénti VAGY operátort, hogy kombinálja őket a jelölővel vagy MF_BYPOSITION a MF_BYCOMMAND jelölővel.

lpszNewItem
Az új menüelem tartalmát adja meg. nFlags a következő módokon értelmezhető lpszNewItem :

`nFlags`	A `lpszNewItem`
`MF_OWNERDRAW`	Egy alkalmazás által megadott 32 bites értéket tartalmaz, amelyet az alkalmazás a menüelemhez társított további adatok fenntartására használhat. Ez a 32 bites érték az alkalmazás számára elérhető az `itemData` és az üzenetek által `WM_MEASUREITEMWM_DRAWITEM` megadott struktúra tagjában. Ezek az üzenetek akkor lesznek elküldve, amikor a menüelem először megjelenik vagy módosul.
`MF_STRING`	Egy null értékű sztringre mutató hosszú mutatót tartalmaz. Ez az alapértelmezett értelmezés.
`MF_SEPARATOR`	A `lpszNewItem` paraméter figyelmen kívül lesz hagyva (nem szükséges).

pBmp
CBitmap A menüelemként használt objektumra mutat.

Visszaadott érték

Nonzero, ha a függvény sikeres; egyéb esetben 0.

Megjegyzések

Az alkalmazás a menüelem állapotát a következő értékekkel nFlagsadhatja meg:

Ha egy ablakban található menüt módosítanak (függetlenül attól, hogy megjelenik-e az ablak), az alkalmazásnak hívnia CWnd::DrawMenuBarkell.

Amikor nIDNewItem előugró menüt ad meg, az annak a menünek a része lesz, amelyben be van szúrva. Ha a menü elpusztul, a beszúrt menü is el lesz pusztítva. A beszúrt menüt le kell választani egy CMenu objektumról az ütközés elkerülése érdekében.

Ha az aktív több dokumentumfelület (MDI) gyermekablaka teljes méretű, és egy alkalmazás előugró menüt szúr be az MDI-alkalmazás menüjébe a függvény meghívásával és a MF_BYPOSITION jelölő megadásával, a menü a vártnál messzebbre lesz beszúrva. Ez azért történik, mert az aktív MDI gyermekablak Vezérlő menüjét beszúrja az MDI-keretablak menüsávjának első helyére. A menü megfelelő elhelyezéséhez az alkalmazásnak 1-et kell hozzáadnia az egyébként használt pozícióértékhez. Az alkalmazás az WM_MDIGETACTIVE üzenet használatával meghatározhatja, hogy az aktuálisan aktív gyermekablak teljes méretű-e.

Example

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

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

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

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

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

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

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

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

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

   return -1;
}

`CMenu::InsertMenuItem`

Új menüelemet szúr be a megadott pozícióba egy menüben.

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

Paraméterek

uItem
uItem A Leírás a Windows SDK-ban InsertMenuItem található.

lpMenuItemInfo
lpmii A Leírás a Windows SDK-ban InsertMenuItem található.

fByPos
fByPosition A Leírás a Windows SDK-ban InsertMenuItem található.

Megjegyzések

Ez a függvény a Windows SDK-ban leírt körbefut InsertMenuItem.

`CMenu::LoadMenu`

Betölt egy menüerőforrást az alkalmazás végrehajtható fájljából, és csatolja az CMenu objektumhoz.

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

Paraméterek

lpszResourceName
Egy null értékű sztringre mutat, amely tartalmazza a betöltendő menüerőforrás nevét.

nIDResource
Megadja a betöltendő menüerőforrás menüazonosítóját.

Visszaadott érték

Nem, ha a menüerőforrás betöltése sikeresen megtörtént; egyéb esetben 0.

Megjegyzések

Example

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

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

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

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

`CMenu::LoadMenuIndirect`

Betölt egy erőforrást egy menüsablonból a memóriába, és csatolja az CMenu objektumhoz.

BOOL LoadMenuIndirect(const void* lpMenuTemplate);

Paraméterek

lpMenuTemplate
Egy menüsablonra mutat (amely egyetlen MENUITEMTEMPLATEHEADER struktúra és egy vagy több MENUITEMTEMPLATE struktúra gyűjteménye). A két struktúrával kapcsolatos további információkért lásd a Windows SDK-t.

Visszaadott érték

Nem, ha a menüerőforrás betöltése sikeresen megtörtént; egyéb esetben 0.

Megjegyzések

A menüsablonok fejlécek, amelyeket egy vagy több MENUITEMTEMPLATE szerkezetből álló gyűjtemény követ, amelyek mindegyike tartalmazhat egy vagy több menüelemet és előugró menüt.

A verziószámnak 0-nak kell lennie.

A mtOption jelzőknek tartalmazniuk MF_END kell az előugró lista utolsó elemét és a fő lista utolsó elemét. AppendMenu A többi jelölő tagfüggvényének megtekintése. A mtId tagot ki kell hagyni a struktúrából, MENUITEMTEMPLATE ha MF_POPUP meg van adva.mtOption

A struktúra számára MENUITEMTEMPLATE lefoglalt területnek elég mtString nagynak kell lennie ahhoz, hogy null értékű sztringként tartalmazza a menüelem nevét.

Example

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

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

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

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

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

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

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

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

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

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

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

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

   return bytes_used;
}

`CMenu::m_hMenu`

HMENU Az objektumhoz csatolt Windows menü leíróját CMenu adja meg.

HMENU m_hMenu;

Example

Lásd a példát a CMenu::LoadMenu.

`CMenu::MeasureItem`

A keretrendszer meghívta, amikor létrejön egy menü a tulajdonos-rajz stílussal.

virtual void MeasureItem(LPMEASUREITEMSTRUCT lpMeasureItemStruct);

Paraméterek

lpMeasureItemStruct
Egy struktúra mutatója MEASUREITEMSTRUCT .

Megjegyzések

Alapértelmezés szerint ez a tagfüggvény nem tesz semmit. Bírálja felül ezt a tagfüggvényt, és töltse ki a struktúrát, MEASUREITEMSTRUCT hogy tájékoztassa a Windowst a menü dimenzióiról.

Tekintse meg CWnd::OnMeasureItem a MEASUREITEMSTRUCT szerkezet leírását.

Example

Az alábbi kód az MFC-mintából CTRLTEST származik:

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

Meglévő menüelem módosítása a megadott nPositionhelyen.

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éterek

nPosition
Megadja a módosítani kívánt menüelemet. A nFlags paraméter a következő módokon értelmezhető nPosition :

`nFlags`	A `nPosition`
`MF_BYCOMMAND`	Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett érték, ha egyik sem `MF_BYCOMMANDMF_BYPOSITION` van beállítva.
`MF_BYPOSITION`	Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.

nFlags
Meghatározza az értelmezés módját nPosition , és tájékoztatást ad a menüelemen végrehajtott módosításokról. Az esetlegesen beállított jelzők listájáért tekintse meg a tagfüggvényt AppendMenu .

nIDNewItem
Megadja a módosított menüelem parancsazonosítóját, vagy ha nFlags be van állítva MF_POPUP, az előugró menü menüfogópontját (HMENU). A nIDNewItem paraméter figyelmen kívül lesz hagyva (nem szükséges), ha nFlags be van állítva MF_SEPARATOR.

lpszNewItem
Az új menüelem tartalmát adja meg. A nFlags paraméter a következő módokon értelmezhető lpszNewItem :

`nFlags`	A `lpszNewItem`
`MF_OWNERDRAW`	Egy alkalmazás által megadott 32 bites értéket tartalmaz, amelyet az alkalmazás a menüelemhez társított további adatok fenntartására használhat. Ez a 32 bites érték az alkalmazás számára a folyamatok `MF_MEASUREITEM` és `MF_DRAWITEM`a .
`MF_STRING`	Hosszú mutatót tartalmaz egy null értékű sztringre vagy egy `CString`.
`MF_SEPARATOR`	A `lpszNewItem` paraméter figyelmen kívül lesz hagyva (nem szükséges).

pBmp
CBitmap A menüelemként használt objektumra mutat.

Visszaadott érték

Nonzero, ha a függvény sikeres; egyéb esetben 0.

Megjegyzések

Az alkalmazás a menüelem új állapotát adja meg az értékek beállításával a következőben nFlags: . Ha ez a függvény lecseréli a menüelemhez társított előugró menüt, azzal megsemmisíti a régi előugró menüt, és felszabadítja az előugró menü által használt memóriát.

Ha egy ablakban található menüt módosítanak (függetlenül attól, hogy megjelenik-e az ablak), az alkalmazásnak hívnia CWnd::DrawMenuBarkell. A meglévő menüelemek attribútumainak módosításához sokkal gyorsabban használhatja az és EnableMenuItem a CheckMenuItem tagfüggvényeket.

Example

Lásd a példát a CMenu::InsertMenu.

`CMenu::operator HMENU`

Ezzel az operátorral lekérheti az objektum fogópontját CMenu .

operator HMENU() const;

Visszaadott érték

Ha sikeres, az objektum fogópontja CMenu ; NULLellenkező esetben.

Megjegyzések

A leíróval közvetlenül meghívhatja a Windows API-kat.

`CMenu::operator !=`

Meghatározza, hogy két menü logikailag nem egyenlő-e.

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

Paraméterek

menu
Egy CMenu összehasonlításra szolgáló objektum.

Megjegyzések

Azt ellenőrzi, hogy a bal oldalon lévő menüobjektum nem egyenlő-e a jobb oldalon lévő menüobjektummal.

`CMenu::operator ==`

Meghatározza, hogy két menü logikailag egyenlő-e.

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

Paraméterek

menu
Egy CMenu összehasonlításra szolgáló objektum.

Megjegyzések

Azt ellenőrzi, hogy a bal oldalon lévő menüobjektum egyenlő-e (az HMENU érték szempontjából) a jobb oldalon lévő menüobjektummal.

`CMenu::RemoveMenu`

Töröl egy menüelemet a menüből egy társított előugró menüvel.

BOOL RemoveMenu(
    UINT nPosition,
    UINT nFlags);

Paraméterek

nPosition
Megadja az eltávolítandó menüelemet. A nFlags paraméter a következő módokon értelmezhető nPosition :

`nFlags`	A `nPosition`
`MF_BYCOMMAND`	Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett érték, ha egyik sem `MF_BYCOMMANDMF_BYPOSITION` van beállítva.
`MF_BYPOSITION`	Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.

nFlags
Meghatározza az értelmezés módját nPosition .

Visszaadott érték

Nonzero, ha a függvény sikeres; egyéb esetben 0.

Megjegyzések

Az előugró menü fogópontját nem teszi tönkre, így a menü újra felhasználható. A függvény meghívása előtt az alkalmazás meghívhatja a GetSubMenu tagfüggvényt az előugró CMenu objektum újbóli lekéréséhez.

Amikor egy ablakban található menüt módosítanak (függetlenül attól, hogy megjelenik-e az ablak), az alkalmazásnak hívnia CWnd::DrawMenuBarkell.

Example

Lásd a példát a CMenu::InsertMenu.

`CMenu::SetDefaultItem`

Beállítja a megadott menü alapértelmezett menüelemét.

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

Paraméterek

uItem
Az új alapértelmezett menüelem azonosítója vagy pozíciója, illetve – 1 alapértelmezett elem nélkül. Ennek a paraméternek a jelentése a paraméter értékétől fByPosfügg.

fByPos
A jelentés jelentését uItemmeghatározó érték. Ha ez a FALSEparaméter, uItem akkor a menüelem azonosítója. Ellenkező esetben ez egy menüelem pozíciója.

Visszaadott érték

Megjegyzések

Ez a tagfüggvény implementálja a Win32 függvény SetMenuDefaultItemviselkedését a Windows SDK-ban leírtak szerint.

Example

Lásd a példát a CMenu::InsertMenu.

`CMenu::SetMenuContextHelpId`

Környezet súgóazonosítóját társítja a CMenu.

BOOL SetMenuContextHelpId(DWORD dwContextHelpId);

Paraméterek

dwContextHelpId
A környezet súgóazonosítója, amellyel CMenutársítani kell.

Visszaadott érték

Nonzero, ha sikeres; egyéb esetben 0

Megjegyzések

A menü minden eleme megosztja ezt az azonosítót – az egyes menüelemekhez nem lehet súgókörnyezet-azonosítót csatolni.

Example

Lásd a példát a CMenu::InsertMenu.

`CMenu::SetMenuInfo`

Egy menü információinak beállítása.

BOOL SetMenuInfo(LPCMENUINFO lpcmi);

Paraméterek

lpcmi
A menü információját tartalmazó struktúra mutatója MENUINFO .

Visszaadott érték

Ha a függvény sikeres, a visszatérési érték nem nulla; ellenkező esetben a visszatérési érték nulla.

Megjegyzések

Hívja meg ezt a függvényt a menüre vonatkozó konkrét információk megadásához.

`CMenu::SetMenuItemBitmaps`

A megadott bitképeket egy menüelemhez társítja.

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

Paraméterek

nPosition
Megadja a módosítani kívánt menüelemet. A nFlags paraméter a következő módokon értelmezhető nPosition :

`nFlags`	Az nPosition értelmezése
`MF_BYCOMMAND`	Megadja, hogy a paraméter megadja a meglévő menüelem parancsazonosítóját. Ez az alapértelmezett érték, ha egyik sem `MF_BYCOMMANDMF_BYPOSITION` van beállítva.
`MF_BYPOSITION`	Megadja, hogy a paraméter a meglévő menüelem pozícióját adja meg. Az első elem a 0. pozícióban van.

nFlags
Meghatározza az értelmezés módját nPosition .

pBmpUnchecked
Megadja a nem bejelölt menüelemekhez használni kívánt bitképet.

pBmpChecked
Megadja az ellenőrzött menüelemekhez használni kívánt bitképet.

Visszaadott érték

Nonzero, ha a függvény sikeres; egyéb esetben 0.

Megjegyzések

Függetlenül attól, hogy a menüelem be van jelölve vagy nincs bejelölve, a Windows megjeleníti a megfelelő bitképet a menüelem mellett.

Ha vagy pBmpUncheckedpBmpChecked igen NULL, akkor a Windows nem jelenít meg semmit a megfelelő attribútum menüeleme mellett. Mindkét paraméter NULLesetén a Windows az alapértelmezett pipát használja az elem ellenőrzésekor, és eltávolítja a pipát, ha az elem nincs bejelölve.

Ha a menü elpusztul, ezek a bitképek nem lesznek megsemmisítve; az alkalmazásnak meg kell semmisítenie őket.

A Windows GetMenuCheckMarkDimensions függvény lekéri a menüelemekhez használt alapértelmezett pipa dimenzióit. Az alkalmazás ezeket az értékeket használja a függvényhez megadott bitképek megfelelő méretének meghatározásához. Kérje le a méretet, hozza létre a bitképeket, majd állítsa be őket.

Example

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

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

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

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

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

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

`CMenu::SetMenuItemInfo`

A menüelem adatainak módosítása.

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

Paraméterek

uItem
uItem A Leírás a Windows SDK-ban SetMenuItemInfo található.

lpMenuItemInfo
lpmii A Leírás a Windows SDK-ban SetMenuItemInfo található.

fByPos
fByPosition A Leírás a Windows SDK-ban SetMenuItemInfo található.

Megjegyzések

Ez a függvény a Windows SDK-ban leírt körbefut SetMenuItemInfo.

`CMenu::TrackPopupMenu`

Megjelenít egy lebegő előugró menüt a megadott helyen, és nyomon követi az előugró menü elemeinek kiválasztását.

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

Paraméterek

nFlags
Megadja a képernyő-pozíció és az egér helyzetjelzőit. Tekintse meg TrackPopupMenu az elérhető jelzők listáját.

x
Az előugró menü képernyőkoordinátáinak vízszintes pozícióját adja meg. A paraméter értékétől nFlags függően a menü ehhez a pozícióhoz képest balra igazítható, jobbra igazítható vagy középre igazítható.

y
A képernyő tetejének képernyőkoordinátáiban megadott függőleges pozíciót adja meg.

pWnd
Azonosítja az előugró menüt tartalmazó ablakot. Ez a paraméter még akkor sem lehet NULL, ha a TPM_NONOTIFY jelölő meg van adva. Ez az ablak az összes WM_COMMAND üzenetet megkapja a menüből. A Windows 3.1-s és újabb verzióiban az ablak nem kap üzeneteket, amíg TrackPopupMenu vissza nem térWM_COMMAND. A Windows 3.0-ban az ablak a visszatérés előtt TrackPopupMenu üzeneteket fogadWM_COMMAND.

lpRect
Figyelmen kívül hagyott.

Visszaadott érték

Ez a metódus a Windows SDK-ban történő hívás TrackPopupMenu eredményét adja vissza.

Megjegyzések

A lebegő előugró menü bárhol megjelenhet a képernyőn.

Example

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

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

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

`CMenu::TrackPopupMenuEx`

Megjelenít egy lebegő előugró menüt a megadott helyen, és nyomon követi az előugró menü elemeinek kiválasztását.

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

Paraméterek

fuFlags
A kiterjesztett menü különböző függvényeit adja meg. Az összes érték és jelentés felsorolását lásd TrackPopupMenuEx: .

x
Az előugró menü képernyőkoordinátáinak vízszintes pozícióját adja meg.

y
A képernyő tetejének képernyőkoordinátáiban megadott függőleges pozíciót adja meg.

pWnd
Az előugró menüt birtokba vevő ablakra mutató mutató, amely a létrehozott menüből fogadja az üzeneteket. Ez az ablak az aktuális alkalmazás bármelyik ablaka lehet, de nem lehet NULL. Ha a paraméterben adja megTPM_NONOTIFY, fuFlags a függvény nem küld üzeneteket.pWnd A függvénynek vissza kell térnie ahhoz az ablakhoz, amely pWnd az üzenet fogadására WM_COMMAND mutat.

lptpm
Mutasson egy TPMPARAMS olyan struktúrára, amely a képernyő egy területét határozza meg, és a menü nem fedhet át átfedést. Ez a paraméter lehet NULL.

Visszaadott érték

Ha a paraméterben adja meg TPM_RETURNCMD , fuFlags a visszatérési érték a felhasználó által kiválasztott elem menüelem-azonosítója. Ha a felhasználó kijelölés nélkül megszakítja a menüt, vagy hiba történik, akkor a visszatérési érték 0.

Ha nem adja meg TPM_RETURNCMD a fuFlags paramétert, a visszatérési érték nem lesz nulla, ha a függvény sikeres, és 0, ha sikertelen. A kiterjesztett hibainformációk lekéréséhez hívja meg a következőt GetLastError:

Megjegyzések

A lebegő előugró menü bárhol megjelenhet a képernyőn. További információ az előugró menü létrehozásakor felmerülő hibák kezeléséről: TrackPopupMenuEx.

Lásd még

MFC-minta CTRLTEST
MFC-minta DYNAMENU
CObject osztály
hierarchiadiagram

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-02-23

Megosztás a következőn keresztül:

CMenu osztály

Szemantika

Tagok

Nyilvános konstruktorok

Nyilvános metódusok

Nyilvános operátorok

Nyilvános adatok tagjai

Megjegyzések

Öröklési hierarchia

Requirements

CMenu::AppendMenu

Paraméterek

Visszaadott érték

Megjegyzések

Example

CMenu::Attach

Paraméterek

Visszaadott érték

Megjegyzések

Example

CMenu::CheckMenuItem

Paraméterek

Visszaadott érték

Megjegyzések

Example

CMenu::CheckMenuRadioItem

Paraméterek

Visszaadott érték

Megjegyzések

Example

CMenu::CMenu

Megjegyzések

CMenu::CreateMenu

Visszaadott érték

Megjegyzések

Example

CMenu::CreatePopupMenu

Visszaadott érték

Megjegyzések

Example

CMenu::DeleteMenu

Paraméterek

Visszaadott érték

Megjegyzések

Example

CMenu::DeleteTempMap

Megjegyzések

Example

CMenu::DestroyMenu

Visszaadott érték

Megjegyzések

Example

CMenu::Detach

Visszaadott érték

Megjegyzések

Example

CMenu::DrawItem

Paraméterek

Megjegyzések

Example

CMenu::EnableMenuItem

Paraméterek

Visszaadott érték

Megjegyzések

Example

CMenu::FromHandle

Paraméterek

Visszaadott érték

Megjegyzések

Example

CMenu::GetDefaultItem

Paraméterek

Visszaadott érték

Megjegyzések

Example

CMenu::GetMenuContextHelpId

Visszaadott érték

Example

CMenu::GetMenuInfo

`CMenu` osztály

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