pollymc/mmc_updater/depends/win32cpp/menu.h

601 lines
18 KiB
C
Raw Normal View History

// Win32++ Version 7.2
// Released: 5th AUgust 2011
//
// David Nash
// email: dnash@bigpond.net.au
// url: https://sourceforge.net/projects/win32-framework
//
//
// Copyright (c) 2005-2011 David Nash
//
// Permission is hereby granted, free of charge, to
// any person obtaining a copy of this software and
// associated documentation files (the "Software"),
// to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify,
// merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom
// the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice
// shall be included in all copies or substantial portions
// of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
// OR OTHER DEALINGS IN THE SOFTWARE.
//
////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
// menu.h
// Declaration of the CMenu class
// Notes
// 1) Owner-drawn menus send the WM_MEASUREITEM and WM_DRAWITEM messages
// to the window that owns the menu. To manage owner drawing for menus,
// handle these two messages in the CWnd's WndProc function.
//
// 2) The CMenu pointer returned by FromHandle might be a temporary pointer. It
// should be used immediately, not saved for later use.
//
// 3) The CMenu pointers returned by FromHandle or GetSubMenu do not need
// to be deleted. They are automatically deleted by the Win32++.
//
// 4) CMenu pointers returned by GetSubMenu are deleted when the parent CMenu is
// detached, destroyed or deconstructed.
//
// 5) The HMENU that is attached to a CMenu object (using the attach function) is
// automatically deleted when the CMenu object goes out of scope. Detach the
// HMENU to stop it being deleted when CMenu's destructor is called.
//
// 6) Pass CMenu objects by reference or by pointer when passing them as function
// arguments.
//
// 7) In those functions that use a MENUITEMINFO structure, its cbSize member is
// automatically set to the correct value.
// Program sample
// --------------
// void CView::CreatePopup()
// {
// CPoint pt = GetCursorPos();
//
// // Create the menu
// CMenu Popup;
// Popup.CreatePopupMenu();
//
// // Add some menu items
// Popup.AppendMenu(MF_STRING, 101, _T("Menu Item &1"));
// Popup.AppendMenu(MF_STRING, 102, _T("Menu Item &2"));
// Popup.AppendMenu(MF_STRING, 103, _T("Menu Item &3"));
// Popup.AppendMenu(MF_SEPARATOR);
// Popup.AppendMenu(MF_STRING, 104, _T("Menu Item &4"));
//
// // Set menu item states
// Popup.CheckMenuRadioItem(101, 101, 101, MF_BYCOMMAND);
// Popup.CheckMenuItem(102, MF_BYCOMMAND | MF_CHECKED);
// Popup.EnableMenuItem(103, MF_BYCOMMAND | MF_GRAYED);
// Popup.SetDefaultItem(104);
//
// // Display the popup menu
// Popup.TrackPopupMenu(0, pt.x, pt.y, this);
// }
#if !defined(_WIN32XX_MENU_H_) && !defined(_WIN32_WCE)
#define _WIN32XX_MENU_H_
#include "wincore.h"
#include "gdi.h"
namespace Win32xx
{
// Forward declarations
class CBitmap;
class CMenu
{
friend class CWinApp;
public:
//Construction
CMenu() : m_hMenu(0), m_IsTmpMenu(FALSE) {}
CMenu(UINT nID) : m_IsTmpMenu(FALSE)
{
m_hMenu = ::LoadMenu(GetApp()->GetResourceHandle(), MAKEINTRESOURCE(nID));
}
~CMenu();
//Initialization
void Attach(HMENU hMenu);
void CreateMenu();
void CreatePopupMenu();
void DestroyMenu();
HMENU Detach();
HMENU GetHandle() const;
BOOL LoadMenu(LPCTSTR lpszResourceName);
BOOL LoadMenu(UINT uIDResource);
BOOL LoadMenuIndirect(const void* lpMenuTemplate);
//Menu Operations
BOOL TrackPopupMenu(UINT uFlags, int x, int y, CWnd* pWnd, LPCRECT lpRect = 0);
BOOL TrackPopupMenuEx(UINT uFlags, int x, int y, CWnd* pWnd, LPTPMPARAMS lptpm);
//Menu Item Operations
BOOL AppendMenu(UINT uFlags, UINT_PTR uIDNewItem = 0, LPCTSTR lpszNewItem = NULL);
BOOL AppendMenu(UINT uFlags, UINT_PTR uIDNewItem, const CBitmap* pBmp);
UINT CheckMenuItem(UINT uIDCheckItem, UINT uCheck);
BOOL CheckMenuRadioItem(UINT uIDFirst, UINT uIDLast, UINT uIDItem, UINT uFlags);
BOOL DeleteMenu(UINT uPosition, UINT uFlags);
UINT EnableMenuItem(UINT uIDEnableItem, UINT uEnable);
UINT GetDefaultItem(UINT gmdiFlags, BOOL fByPos = FALSE);
DWORD GetMenuContextHelpId() const;
#if(WINVER >= 0x0500) // Minimum OS required is Win2000
BOOL GetMenuInfo(LPMENUINFO lpcmi) const;
BOOL SetMenuInfo(LPCMENUINFO lpcmi);
#endif
UINT GetMenuItemCount() const;
UINT GetMenuItemID(int nPos) const;
BOOL GetMenuItemInfo(UINT uItem, LPMENUITEMINFO lpMenuItemInfo, BOOL fByPos = FALSE);
UINT GetMenuState(UINT uID, UINT uFlags) const;
int GetMenuString(UINT uIDItem, LPTSTR lpString, int nMaxCount, UINT uFlags) const;
int GetMenuString(UINT uIDItem, CString& rString, UINT uFlags) const;
CMenu* GetSubMenu(int nPos);
BOOL InsertMenu(UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem = 0, LPCTSTR lpszNewItem = NULL);
BOOL InsertMenu(UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, const CBitmap* pBmp);
BOOL InsertMenuItem(UINT uItem, LPMENUITEMINFO lpMenuItemInfo, BOOL fByPos = FALSE);
BOOL ModifyMenu(UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem = 0, LPCTSTR lpszNewItem = NULL);
BOOL ModifyMenu(UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, const CBitmap* pBmp);
BOOL RemoveMenu(UINT uPosition, UINT uFlags);
BOOL SetDefaultItem(UINT uItem, BOOL fByPos = FALSE);
BOOL SetMenuContextHelpId(DWORD dwContextHelpId);
BOOL SetMenuItemBitmaps(UINT uPosition, UINT uFlags, const CBitmap* pBmpUnchecked, const CBitmap* pBmpChecked);
BOOL SetMenuItemInfo(UINT uItem, LPMENUITEMINFO lpMenuItemInfo, BOOL fByPos = FALSE);
//Operators
BOOL operator != (const CMenu& menu) const;
BOOL operator == (const CMenu& menu) const;
operator HMENU () const;
private:
CMenu(const CMenu&); // Disable copy construction
CMenu& operator = (const CMenu&); // Disable assignment operator
void AddToMap();
BOOL RemoveFromMap();
std::vector<MenuPtr> m_vSubMenus; // A vector of smart pointers to CMenu
HMENU m_hMenu;
BOOL m_IsTmpMenu;
};
inline CMenu::~CMenu()
{
if (m_hMenu)
{
if (!m_IsTmpMenu)
{
::DestroyMenu(m_hMenu);
}
RemoveFromMap();
}
m_vSubMenus.clear();
}
inline void CMenu::AddToMap()
// Store the HMENU and CMenu pointer in the HMENU map
{
assert( GetApp() );
assert(m_hMenu);
GetApp()->m_csMapLock.Lock();
GetApp()->m_mapHMENU.insert(std::make_pair(m_hMenu, this));
GetApp()->m_csMapLock.Release();
}
inline BOOL CMenu::RemoveFromMap()
{
BOOL Success = FALSE;
if (GetApp())
{
// Allocate an iterator for our HDC map
std::map<HMENU, CMenu*, CompareHMENU>::iterator m;
CWinApp* pApp = GetApp();
if (pApp)
{
// Erase the CDC pointer entry from the map
pApp->m_csMapLock.Lock();
for (m = pApp->m_mapHMENU.begin(); m != pApp->m_mapHMENU.end(); ++m)
{
if (this == m->second)
{
pApp->m_mapHMENU.erase(m);
Success = TRUE;
break;
}
}
pApp->m_csMapLock.Release();
}
}
return Success;
}
inline BOOL CMenu::AppendMenu(UINT uFlags, UINT_PTR uIDNewItem /*= 0*/, LPCTSTR lpszNewItem /*= NULL*/)
// Appends a new item to the end of the specified menu bar, drop-down menu, submenu, or shortcut menu.
{
assert(IsMenu(m_hMenu));
return ::AppendMenu(m_hMenu, uFlags, uIDNewItem, lpszNewItem);
}
inline BOOL CMenu::AppendMenu(UINT uFlags, UINT_PTR uIDNewItem, const CBitmap* pBmp)
// Appends a new item to the end of the specified menu bar, drop-down menu, submenu, or shortcut menu.
{
assert(IsMenu(m_hMenu));
assert(pBmp);
return ::AppendMenu(m_hMenu, uFlags, uIDNewItem, (LPCTSTR)pBmp->GetHandle());
}
inline void CMenu::Attach(HMENU hMenu)
// Attaches an existing menu to this CMenu
{
if (m_hMenu != NULL && m_hMenu != hMenu)
{
::DestroyMenu(Detach());
}
if (hMenu)
{
m_hMenu = hMenu;
AddToMap();
}
}
inline UINT CMenu::CheckMenuItem(UINT uIDCheckItem, UINT uCheck)
// Sets the state of the specified menu item's check-mark attribute to either selected or clear.
{
assert(IsMenu(m_hMenu));
return ::CheckMenuItem(m_hMenu, uIDCheckItem, uCheck);
}
inline BOOL CMenu::CheckMenuRadioItem(UINT uIDFirst, UINT uIDLast, UINT uIDItem, UINT uFlags)
// Checks a specified menu item and makes it a radio item. At the same time, the function clears
// all other menu items in the associated group and clears the radio-item type flag for those items.
{
assert(IsMenu(m_hMenu));
return ::CheckMenuRadioItem(m_hMenu, uIDFirst, uIDLast, uIDItem, uFlags);
}
inline void CMenu::CreateMenu()
// Creates an empty menu.
{
assert(NULL == m_hMenu);
m_hMenu = ::CreateMenu();
AddToMap();
}
inline void CMenu::CreatePopupMenu()
// Creates a drop-down menu, submenu, or shortcut menu. The menu is initially empty.
{
assert(NULL == m_hMenu);
m_hMenu = ::CreatePopupMenu();
AddToMap();
}
inline BOOL CMenu::DeleteMenu(UINT uPosition, UINT uFlags)
// Deletes an item from the specified menu.
{
assert(IsMenu(m_hMenu));
return ::DeleteMenu(m_hMenu, uPosition, uFlags);
}
inline void CMenu::DestroyMenu()
// Destroys the menu and frees any memory that the menu occupies.
{
if (::IsMenu(m_hMenu))
::DestroyMenu(m_hMenu);
m_hMenu = 0;
RemoveFromMap();
m_vSubMenus.clear();
}
inline HMENU CMenu::Detach()
// Detaches the HMENU from this CMenu. If the HMENU is not detached it will be
// destroyed when this CMenu is deconstructed.
{
assert(IsMenu(m_hMenu));
HMENU hMenu = m_hMenu;
m_hMenu = 0;
RemoveFromMap();
m_vSubMenus.clear();
return hMenu;
}
inline HMENU CMenu::GetHandle() const
// Returns the HMENU assigned to this CMenu
{
return m_hMenu;
}
inline UINT CMenu::EnableMenuItem(UINT uIDEnableItem, UINT uEnable)
// Enables, disables, or grays the specified menu item.
// The uEnable parameter must be a combination of either MF_BYCOMMAND or MF_BYPOSITION
// and MF_ENABLED, MF_DISABLED, or MF_GRAYED.
{
assert(IsMenu(m_hMenu));
return ::EnableMenuItem(m_hMenu, uIDEnableItem, uEnable);
}
inline UINT CMenu::GetDefaultItem(UINT gmdiFlags, BOOL fByPos /*= FALSE*/)
// Determines the default menu item.
// The gmdiFlags parameter specifies how the function searches for menu items.
// This parameter can be zero or more of the following values: GMDI_GOINTOPOPUPS; GMDI_USEDISABLED.
{
assert(IsMenu(m_hMenu));
return ::GetMenuDefaultItem(m_hMenu, fByPos, gmdiFlags);
}
inline DWORD CMenu::GetMenuContextHelpId() const
// Retrieves the Help context identifier associated with the menu.
{
assert(IsMenu(m_hMenu));
return ::GetMenuContextHelpId(m_hMenu);
}
#if(WINVER >= 0x0500)
// minimum OS required : Win2000
inline BOOL CMenu::GetMenuInfo(LPMENUINFO lpcmi) const
// Retrieves the menu information.
{
assert(IsMenu(m_hMenu));
return ::GetMenuInfo(m_hMenu, lpcmi);
}
inline BOOL CMenu::SetMenuInfo(LPCMENUINFO lpcmi)
// Sets the menu information from the specified MENUINFO structure.
{
assert(IsMenu(m_hMenu));
return ::SetMenuInfo(m_hMenu, lpcmi);
}
#endif
inline UINT CMenu::GetMenuItemCount() const
// Retrieves the number of menu items.
{
assert(IsMenu(m_hMenu));
return ::GetMenuItemCount(m_hMenu);
}
inline UINT CMenu::GetMenuItemID(int nPos) const
// Retrieves the menu item identifier of a menu item located at the specified position
{
assert(IsMenu(m_hMenu));
return ::GetMenuItemID(m_hMenu, nPos);
}
inline BOOL CMenu::GetMenuItemInfo(UINT uItem, LPMENUITEMINFO lpMenuItemInfo, BOOL fByPos /*= FALSE*/)
// retrieves information about the specified menu item.
{
assert(IsMenu(m_hMenu));
assert(lpMenuItemInfo);
lpMenuItemInfo->cbSize = GetSizeofMenuItemInfo();
return ::GetMenuItemInfo(m_hMenu, uItem, fByPos, lpMenuItemInfo);
}
inline UINT CMenu::GetMenuState(UINT uID, UINT uFlags) const
// Retrieves the menu flags associated with the specified menu item.
// Possible values for uFlags are: MF_BYCOMMAND (default) or MF_BYPOSITION.
{
assert(IsMenu(m_hMenu));
return ::GetMenuState(m_hMenu, uID, uFlags);
}
inline int CMenu::GetMenuString(UINT uIDItem, LPTSTR lpString, int nMaxCount, UINT uFlags) const
// Copies the text string of the specified menu item into the specified buffer.
{
assert(IsMenu(m_hMenu));
assert(lpString);
return ::GetMenuString(m_hMenu, uIDItem, lpString, nMaxCount, uFlags);
}
inline int CMenu::GetMenuString(UINT uIDItem, CString& rString, UINT uFlags) const
// Copies the text string of the specified menu item into the specified buffer.
{
assert(IsMenu(m_hMenu));
return ::GetMenuString(m_hMenu, uIDItem, (LPTSTR)rString.c_str(), rString.GetLength(), uFlags);
}
inline CMenu* CMenu::GetSubMenu(int nPos)
// Retrieves the CMenu object of a pop-up menu.
{
assert(IsMenu(m_hMenu));
CMenu* pMenu = new CMenu;
pMenu->m_hMenu = ::GetSubMenu(m_hMenu, nPos);
pMenu->m_IsTmpMenu = TRUE;
m_vSubMenus.push_back(pMenu);
return pMenu;
}
inline BOOL CMenu::InsertMenu(UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem /*= 0*/, LPCTSTR lpszNewItem /*= NULL*/)
// Inserts a new menu item into a menu, moving other items down the menu.
{
assert(IsMenu(m_hMenu));
return ::InsertMenu(m_hMenu, uPosition, uFlags, uIDNewItem, lpszNewItem);
}
inline BOOL CMenu::InsertMenu(UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, const CBitmap* pBmp)
// Inserts a new menu item into a menu, moving other items down the menu.
{
assert(IsMenu(m_hMenu));
return ::InsertMenu(m_hMenu, uPosition, uFlags, uIDNewItem, (LPCTSTR)pBmp->GetHandle());
}
inline BOOL CMenu::InsertMenuItem(UINT uItem, LPMENUITEMINFO lpMenuItemInfo, BOOL fByPos /*= FALSE*/)
// Inserts a new menu item at the specified position in a menu.
{
assert(IsMenu(m_hMenu));
assert(lpMenuItemInfo);
lpMenuItemInfo->cbSize = GetSizeofMenuItemInfo();
return ::InsertMenuItem(m_hMenu, uItem, fByPos, lpMenuItemInfo);
}
inline BOOL CMenu::LoadMenu(LPCTSTR lpszResourceName)
// Loads the menu from the specified windows resource.
{
assert(NULL == m_hMenu);
assert(lpszResourceName);
m_hMenu = ::LoadMenu(GetApp()->GetResourceHandle(), lpszResourceName);
if (m_hMenu) AddToMap();
return NULL != m_hMenu;
}
inline BOOL CMenu::LoadMenu(UINT uIDResource)
// Loads the menu from the specified windows resource.
{
assert(NULL == m_hMenu);
m_hMenu = ::LoadMenu(GetApp()->GetResourceHandle(), MAKEINTRESOURCE(uIDResource));
if (m_hMenu) AddToMap();
return NULL != m_hMenu;
}
inline BOOL CMenu::LoadMenuIndirect(const void* lpMenuTemplate)
// Loads the specified menu template and assigns it to this CMenu.
{
assert(NULL == m_hMenu);
assert(lpMenuTemplate);
m_hMenu = ::LoadMenuIndirect(lpMenuTemplate);
if (m_hMenu) AddToMap();
return NULL != m_hMenu;
}
inline BOOL CMenu::ModifyMenu(UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem /*= 0*/, LPCTSTR lpszNewItem /*= NULL*/)
// Changes an existing menu item. This function is used to specify the content, appearance, and behavior of the menu item.
{
assert(IsMenu(m_hMenu));
return ::ModifyMenu(m_hMenu, uPosition, uFlags, uIDNewItem, lpszNewItem);
}
inline BOOL CMenu::ModifyMenu(UINT uPosition, UINT uFlags, UINT_PTR uIDNewItem, const CBitmap* pBmp)
// Changes an existing menu item. This function is used to specify the content, appearance, and behavior of the menu item.
{
assert(IsMenu(m_hMenu));
assert(pBmp);
return ::ModifyMenu(m_hMenu, uPosition, uFlags, uIDNewItem, (LPCTSTR)pBmp->GetHandle());
}
inline BOOL CMenu::RemoveMenu(UINT uPosition, UINT uFlags)
// Deletes a menu item or detaches a submenu from the menu.
{
assert(IsMenu(m_hMenu));
return ::RemoveMenu(m_hMenu, uPosition, uFlags);
}
inline BOOL CMenu::SetDefaultItem(UINT uItem, BOOL fByPos /*= FALSE*/)
// sets the default menu item for the menu.
{
assert(IsMenu(m_hMenu));
return ::SetMenuDefaultItem(m_hMenu, uItem, fByPos);
}
inline BOOL CMenu::SetMenuContextHelpId(DWORD dwContextHelpId)
// Associates a Help context identifier with the menu.
{
assert(IsMenu(m_hMenu));
return ::SetMenuContextHelpId(m_hMenu, dwContextHelpId);
}
inline BOOL CMenu::SetMenuItemBitmaps(UINT uPosition, UINT uFlags, const CBitmap* pBmpUnchecked, const CBitmap* pBmpChecked)
// Associates the specified bitmap with a menu item.
{
assert(IsMenu(m_hMenu));
return ::SetMenuItemBitmaps(m_hMenu, uPosition, uFlags, *pBmpUnchecked, *pBmpChecked);
}
inline BOOL CMenu::SetMenuItemInfo(UINT uItem, LPMENUITEMINFO lpMenuItemInfo, BOOL fByPos /*= FALSE*/)
// Changes information about a menu item.
{
assert(IsMenu(m_hMenu));
assert(lpMenuItemInfo);
lpMenuItemInfo->cbSize = GetSizeofMenuItemInfo();
return ::SetMenuItemInfo(m_hMenu, uItem, fByPos, lpMenuItemInfo);
}
inline BOOL CMenu::TrackPopupMenu(UINT uFlags, int x, int y, CWnd* pWnd, LPCRECT lpRect /*= 0*/)
// Displays a shortcut menu at the specified location and tracks the selection of items on the menu.
{
assert(IsMenu(m_hMenu));
HWND hWnd = pWnd? pWnd->GetHwnd() : 0;
return ::TrackPopupMenu(m_hMenu, uFlags, x, y, 0, hWnd, lpRect);
}
inline BOOL CMenu::TrackPopupMenuEx(UINT uFlags, int x, int y, CWnd* pWnd, LPTPMPARAMS lptpm)
// Displays a shortcut menu at the specified location and tracks the selection of items on the shortcut menu.
{
assert(IsMenu(m_hMenu));
HWND hWnd = pWnd? pWnd->GetHwnd() : 0;
return ::TrackPopupMenuEx(m_hMenu, uFlags, x, y, hWnd, lptpm);
}
inline BOOL CMenu::operator != (const CMenu& menu) const
// Returns TRUE if the two menu objects are not equal.
{
return menu.m_hMenu != m_hMenu;
}
inline BOOL CMenu::operator == (const CMenu& menu) const
// Returns TRUE of the two menu object are equal
{
return menu.m_hMenu == m_hMenu;
}
inline CMenu::operator HMENU () const
// Retrieves the menu's handle.
{
return m_hMenu;
}
///////////////////////////////////////
// Global functions
//
inline CMenu* FromHandle(HMENU hMenu)
// Returns the CMenu object associated with the menu handle (HMENU).
{
assert( GetApp() );
CMenu* pMenu = GetApp()->GetCMenuFromMap(hMenu);
if (::IsMenu(hMenu) && pMenu == 0)
{
GetApp()->AddTmpMenu(hMenu);
pMenu = GetApp()->GetCMenuFromMap(hMenu);
}
return pMenu;
}
} // namespace Win32xx
#endif // _WIN32XX_MENU_H_