2596 lines
82 KiB
C++
2596 lines
82 KiB
C++
/*--------------------------------------------------------------------------*
|
|
*
|
|
* Microsoft Windows
|
|
* Copyright (C) Microsoft Corporation, 1992 - 1999
|
|
*
|
|
* File: menubar.cpp
|
|
*
|
|
* Contents: Implementation file for CMenuBar
|
|
*
|
|
* History: 14-Nov-97 JeffRo Created
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "menubar.h"
|
|
#include "mdiuisim.h"
|
|
#include "amc.h"
|
|
#include "amcdoc.h"
|
|
#include "mainfrm.h"
|
|
#include "tbtrack.h"
|
|
#include "mnemonic.h"
|
|
#include "childfrm.h"
|
|
#include "menubtns.h"
|
|
#include <algorithm>
|
|
#include <mmsystem.h>
|
|
#include <oleacc.h>
|
|
#include "amcview.h"
|
|
#include "favorite.h"
|
|
#include "util.h"
|
|
|
|
/*
|
|
* if we're supporting old platforms, we need to get MSAA definitions
|
|
* from somewhere other than winuser.h
|
|
*/
|
|
#if (_WINNT_WIN32 < 0x0500)
|
|
#include <winable.h>
|
|
#endif
|
|
|
|
/*--------*/
|
|
/* SAccel */
|
|
/*--------*/
|
|
struct SAccel : public ACCEL
|
|
{
|
|
SAccel (WORD key_, WORD cmd_, BYTE fVirt_)
|
|
{
|
|
ZeroMemory (this, sizeof (*this));
|
|
key = key_;
|
|
cmd = cmd_;
|
|
fVirt = fVirt_;
|
|
}
|
|
};
|
|
|
|
|
|
/*--------------------*/
|
|
/* CPopupTrackContext */
|
|
/*--------------------*/
|
|
class CPopupTrackContext
|
|
{
|
|
public:
|
|
CPopupTrackContext (CMenuBar* pMenuBar, int nCurrentPopupIndex);
|
|
~CPopupTrackContext ();
|
|
|
|
// control over monitoring
|
|
void StartMonitoring();
|
|
bool WasAnotherPopupRequested(int& iNewIdx);
|
|
|
|
private:
|
|
typedef std::vector<int> BoundaryCollection;
|
|
typedef BoundaryCollection::iterator BoundIt;
|
|
typedef BoundaryCollection::const_iterator BoundConstIt;
|
|
|
|
BoundaryCollection m_ButtonBoundaries;
|
|
CMenuBar* const m_pMenuBar;
|
|
HHOOK m_hhkMouse;
|
|
HHOOK m_hhkKeyboard;
|
|
HHOOK m_hhkCallWnd;
|
|
CRect m_rectAllButtons;
|
|
CPoint m_ptLastMouseMove;
|
|
int m_nCurrentPopupIndex;
|
|
|
|
CWnd* m_pMaxedMDIChild;
|
|
const CPoint m_ptLButtonDown;
|
|
const UINT m_dwLButtonDownTime;
|
|
const int m_cButtons;
|
|
int m_cCascadedPopups;
|
|
bool m_fCurrentlyOnPopupItem;
|
|
bool m_bPopupMonitorHooksActive;
|
|
int m_iRequestForNewPopup;
|
|
|
|
LRESULT MouseProc (int nCode, UINT msg, LPMOUSEHOOKSTRUCT pmhs);
|
|
LRESULT KeyboardProc (int nCode, int vkey, int cRepeat, bool fDown, LPARAM lParam);
|
|
LRESULT CallWndProc (int nCode, BOOL bCurrentThread, LPCWPSTRUCT lpCWP);
|
|
|
|
int HitTest (CPoint pt) const;
|
|
int MapBoundaryIteratorToButtonIndex (BoundConstIt it) const;
|
|
void MaybeCloseMDIChild (CPoint pt);
|
|
void DismissCurrentPopup (bool fTrackingComplete);
|
|
void NotifyNewPopup (int nNewPopupIndex);
|
|
|
|
void SetPopupMonitorHooks();
|
|
void RemovePopupMonitorHooks();
|
|
static LRESULT CALLBACK MouseProc (int nCode, WPARAM wParam, LPARAM lParam);
|
|
static LRESULT CALLBACK KeyboardProc (int nCode, WPARAM wParam, LPARAM lParam);
|
|
static LRESULT CALLBACK CallWndProc (int nCode, WPARAM wParam, LPARAM lParam);
|
|
static CPopupTrackContext* s_pTrackContext;
|
|
};
|
|
|
|
CPopupTrackContext* CPopupTrackContext::s_pTrackContext = NULL;
|
|
|
|
|
|
|
|
const TCHAR chChildSysMenuMnemonic = _T('-');
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* AddMnemonic
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
template<class OutputIterator>
|
|
static void AddMnemonic (
|
|
TCHAR chMnemonic,
|
|
int cmd,
|
|
BYTE fVirt,
|
|
OutputIterator it)
|
|
{
|
|
ASSERT (chMnemonic != _T('\0'));
|
|
|
|
TCHAR chLower = (TCHAR) tolower (chMnemonic);
|
|
TCHAR chUpper = (TCHAR) toupper (chMnemonic);
|
|
|
|
/*
|
|
* add the lowercase mnemonic
|
|
*/
|
|
*it++ = SAccel (chLower, (WORD) cmd, fVirt);
|
|
|
|
/*
|
|
* if the uppercase mnemonic character is different from the
|
|
* lowercase character, add the uppercase mnemonic as well
|
|
*/
|
|
if (chUpper != chLower)
|
|
*it++ = SAccel (chUpper, (WORD) cmd, fVirt);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* PrepBandInfo
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
static void PrepBandInfo (LPREBARBANDINFO prbi, UINT fMask)
|
|
{
|
|
ZeroMemory (prbi, sizeof (REBARBANDINFO));
|
|
prbi->cbSize = sizeof (REBARBANDINFO);
|
|
prbi->fMask = fMask;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMenuBar
|
|
|
|
BEGIN_MESSAGE_MAP(CMenuBar, CMMCToolBarCtrlEx)
|
|
//{{AFX_MSG_MAP(CMenuBar)
|
|
ON_NOTIFY_REFLECT(TBN_DROPDOWN, OnDropDown)
|
|
ON_NOTIFY_REFLECT(TBN_GETDISPINFO, OnGetDispInfo)
|
|
ON_NOTIFY_REFLECT(TBN_HOTITEMCHANGE, OnHotItemChange)
|
|
ON_NOTIFY_REFLECT(NM_CUSTOMDRAW, OnCustomDraw)
|
|
ON_WM_SYSCOMMAND()
|
|
ON_WM_SETTINGCHANGE()
|
|
ON_WM_DESTROY()
|
|
ON_COMMAND(ID_MTB_ACTIVATE_CURRENT_POPUP, OnActivateCurrentPopup)
|
|
//}}AFX_MSG_MAP
|
|
|
|
ON_MESSAGE(WM_POPUP_ASYNC, OnPopupAsync)
|
|
ON_COMMAND(CMMCToolBarCtrlEx::ID_MTBX_PRESS_HOT_BUTTON, OnActivateCurrentPopup)
|
|
ON_COMMAND_RANGE(ID_MTB_MENU_FIRST, ID_MTB_MENU_LAST, OnAccelPopup)
|
|
ON_UPDATE_COMMAND_UI_RANGE(ID_MTB_MENU_FIRST, ID_MTB_MENU_LAST, OnUpdateAllCmdUI)
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::GetMenuUISimAccel
|
|
*
|
|
* Manages the accelerator table singleton for CMenuBar
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
const CAccel& CMenuBar::GetMenuUISimAccel ()
|
|
{
|
|
static ACCEL aaclTrack[] = {
|
|
{ FVIRTKEY, VK_RETURN, CMenuBar::ID_MTB_ACTIVATE_CURRENT_POPUP },
|
|
{ FVIRTKEY, VK_UP, CMenuBar::ID_MTB_ACTIVATE_CURRENT_POPUP },
|
|
{ FVIRTKEY, VK_DOWN, CMenuBar::ID_MTB_ACTIVATE_CURRENT_POPUP },
|
|
};
|
|
|
|
static const CAccel MenuUISimAccel (aaclTrack, countof (aaclTrack));
|
|
return (MenuUISimAccel);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::CMenuBar
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CMenuBar::CMenuBar ()
|
|
{
|
|
m_pMDIFrame = NULL;
|
|
m_pwndLastActive = NULL;
|
|
m_pRebar = NULL;
|
|
m_hMenuLast = NULL;
|
|
m_hMaxedChildIcon = NULL;
|
|
m_fDestroyChildIcon = false;
|
|
m_fDecorationsShowing = false;
|
|
m_fMaxedChildIconIsInvalid = false;
|
|
m_CommandIDUnUsed.clear();
|
|
m_vMenuAccels.clear();
|
|
m_vTrackingAccels.clear();
|
|
m_bInProgressDisplayingPopup = false;
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::~CMenuBar
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CMenuBar::~CMenuBar ()
|
|
{
|
|
DeleteMaxedChildIcon();
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::Create
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
BOOL CMenuBar::Create (
|
|
CFrameWnd * pwndFrame,
|
|
CRebarDockWindow* pParentRebar,
|
|
DWORD dwStyle,
|
|
UINT idWindow)
|
|
{
|
|
ASSERT_VALID (pwndFrame);
|
|
ASSERT_VALID (pParentRebar);
|
|
|
|
// create the window
|
|
if (!CMMCToolBarCtrlEx::Create (NULL, dwStyle | TBSTYLE_LIST,
|
|
g_rectEmpty, pParentRebar, idWindow))
|
|
return (FALSE);
|
|
|
|
// initialize to hidded accelerator state
|
|
SendMessage( WM_CHANGEUISTATE, MAKEWPARAM(UIS_SET, UISF_HIDEACCEL | UISF_HIDEFOCUS));
|
|
|
|
// insert a hidden button for the maximized child's system menu
|
|
InsertButton (0, (LPCTSTR) NULL, ID_MTB_MENU_SYSMENU, NULL, 0, 0);
|
|
|
|
TBBUTTONINFO btni;
|
|
btni.cbSize = sizeof (btni);
|
|
btni.dwMask = TBIF_STATE | TBIF_SIZE;
|
|
btni.fsState = TBSTATE_HIDDEN;
|
|
btni.cx = static_cast<WORD>(GetSystemMetrics (SM_CXSMICON));
|
|
|
|
SetButtonInfo (ID_MTB_MENU_SYSMENU, &btni);
|
|
|
|
#ifdef SHRINK_PADDING
|
|
CSize sizePad = GetPadding();
|
|
sizePad.cx = 3;
|
|
SetPadding (sizePad);
|
|
#endif // SHRINK_PADDING
|
|
|
|
SetMenuFont ();
|
|
m_pRebar = pParentRebar->GetRebar();
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::Create
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
BOOL CMenuBar::Create (
|
|
CMDIFrameWnd * pwndFrame,
|
|
CRebarDockWindow* pParentRebar,
|
|
DWORD dwStyle,
|
|
UINT idWindow)
|
|
{
|
|
if (!Create ((CFrameWnd*) pwndFrame, pParentRebar, dwStyle, idWindow))
|
|
return (FALSE);
|
|
|
|
m_pMDIFrame = pwndFrame;
|
|
|
|
// this is a menu for an MDI frame window; create MDI decorations
|
|
m_pMDIDec = std::auto_ptr<CMDIMenuDecoration>(new CMDIMenuDecoration);
|
|
m_pMDIDec->Create (NULL, NULL,
|
|
WS_CHILD | MMDS_MINIMIZE |
|
|
MMDS_RESTORE | MMDS_CLOSE | MMDS_AUTOSIZE,
|
|
g_rectEmpty, this, ID_MDIDECORATION);
|
|
|
|
// the rebar will re-parent the decoration, make sure we remain the owner
|
|
m_pMDIDec->SetOwner (this);
|
|
|
|
// insert the MDI decoration band
|
|
REBARBANDINFO rbi;
|
|
PrepBandInfo (&rbi, RBBIM_CHILD | RBBIM_STYLE | RBBIM_ID);
|
|
|
|
rbi.fStyle = RBBS_FIXEDSIZE | RBBS_HIDDEN;
|
|
rbi.hwndChild = m_pMDIDec->m_hWnd;
|
|
rbi.wID = ID_MDIDECORATION;
|
|
|
|
ASSERT (m_pRebar != NULL);
|
|
m_pRebar->InsertBand (&rbi);
|
|
|
|
// resize the decoration window, *after* inserting the band
|
|
SizeDecoration ();
|
|
|
|
// there's bug in rebar which will show a band's
|
|
// child, even with RBBS_HIDDEN, work around it
|
|
m_pMDIDec->ShowWindow (SW_HIDE);
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::PreTranslateMessage
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
BOOL CMenuBar::PreTranslateMessage(MSG* pMsg)
|
|
{
|
|
// show accelerators, since user indicated he wants to control using the keyboard
|
|
if ( (pMsg->message == WM_SYSKEYDOWN ) &&
|
|
(!(pMsg->lParam & 0x40000000)/*not repeating*/) )
|
|
{
|
|
SendMessage( WM_CHANGEUISTATE, MAKEWPARAM(UIS_CLEAR, UISF_HIDEACCEL | UISF_HIDEFOCUS));
|
|
}
|
|
|
|
if (CMMCToolBarCtrlEx::PreTranslateMessage (pMsg))
|
|
return (TRUE);
|
|
|
|
if ((pMsg->message >= WM_KEYFIRST) && (pMsg->message <= WM_KEYLAST))
|
|
{
|
|
CMainFrame* pFrame = AMCGetMainWnd();
|
|
if ((pFrame == NULL) || !pFrame->IsMenuVisible())
|
|
return (FALSE);
|
|
|
|
// if we're in menu mode, check menu mode-only accelerators
|
|
if (IsTrackingToolBar ())
|
|
{
|
|
const CAccel& MenuUISimAccel = GetMenuUISimAccel();
|
|
|
|
ASSERT (MenuUISimAccel != NULL);
|
|
if (MenuUISimAccel.TranslateAccelerator (m_hWnd, pMsg))
|
|
return (TRUE);
|
|
|
|
ASSERT (m_TrackingAccel != NULL);
|
|
if (m_TrackingAccel.TranslateAccelerator (m_hWnd, pMsg))
|
|
return (TRUE);
|
|
}
|
|
|
|
if ((m_MenuAccel != NULL) && m_MenuAccel.TranslateAccelerator (m_hWnd, pMsg))
|
|
return (TRUE);
|
|
|
|
// handle Alt+- when child is maximized
|
|
if (m_fDecorationsShowing &&
|
|
(pMsg->message == WM_SYSCHAR) &&
|
|
(pMsg->wParam == chChildSysMenuMnemonic))
|
|
{
|
|
SendMessage (WM_COMMAND, ID_MTB_MENU_SYSMENU);
|
|
return (TRUE);
|
|
}
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::SetMenu
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::SetMenu (CMenu* pMenu)
|
|
{
|
|
HMENU hMenu = pMenu->GetSafeHmenu();
|
|
|
|
// don't need to do anything if we're setting the same menu as last time
|
|
if (hMenu == m_hMenuLast)
|
|
return;
|
|
|
|
// remember this menu for optimization next time
|
|
m_hMenuLast = hMenu;
|
|
|
|
// delete all but the first existing buttons from the toolbar
|
|
while (DeleteButton(1))
|
|
{
|
|
}
|
|
|
|
// delete the previous dynamic accelerator table
|
|
m_MenuAccel.DestroyAcceleratorTable ();
|
|
m_strAccelerators.Empty ();
|
|
|
|
// this should have been done in CMenuBar::Create
|
|
ASSERT (GetBitmapSize().cx == 0);
|
|
|
|
if (pMenu != NULL)
|
|
{
|
|
CString strMenuText;
|
|
|
|
// Clear the accels before calling InsertButton
|
|
// which adds accels for each button.
|
|
m_vMenuAccels.clear();
|
|
m_vTrackingAccels.clear();
|
|
|
|
int cMenuItems = pMenu->GetMenuItemCount();
|
|
|
|
// Initialize Unused command IDs pool.
|
|
m_CommandIDUnUsed.clear();
|
|
for (INT idCommand = ID_MTB_FIRST_COMMANDID;
|
|
idCommand < ID_MTB_MENU_LAST;
|
|
idCommand++)
|
|
{
|
|
m_CommandIDUnUsed.insert(idCommand);
|
|
}
|
|
|
|
for (int i = 0; i < cMenuItems; i++)
|
|
{
|
|
// get the menu text and add it to the toolbar
|
|
pMenu->GetMenuString (i, strMenuText, MF_BYPOSITION);
|
|
|
|
// sometimes empty items will be appended to the menu, ignore them
|
|
if (strMenuText.IsEmpty ())
|
|
continue;
|
|
|
|
if (m_CommandIDUnUsed.empty())
|
|
{
|
|
ASSERT(FALSE);
|
|
}
|
|
|
|
// See if this top level menu has sub menus, if so when menu is clicked
|
|
// it is popped up else it is Action or View or Favorites menu
|
|
// for which submenu is dynamic and has to be constructured.
|
|
// So we set the TBBUTTON.dwData member with submenu (for static menus)
|
|
// or NULL for for dynamic menus like Action, View, Favorites.
|
|
CMenu* pSubMenu = pMenu->GetSubMenu(i);
|
|
DWORD_PTR dwMenuData = NULL;
|
|
BYTE byState = 0;
|
|
|
|
if (pSubMenu)
|
|
{
|
|
// Get an unused command id for this button.
|
|
CommandIDPool::iterator itCommandID = m_CommandIDUnUsed.begin();
|
|
idCommand = *itCommandID;
|
|
m_CommandIDUnUsed.erase(itCommandID);
|
|
dwMenuData = reinterpret_cast<DWORD_PTR>(pSubMenu->GetSafeHmenu());
|
|
}
|
|
else
|
|
{
|
|
UINT uMenuID = pMenu->GetMenuItemID(i);
|
|
switch (uMenuID)
|
|
{
|
|
case ID_ACTION_MENU:
|
|
idCommand = ID_MTB_MENU_ACTION;
|
|
break;
|
|
|
|
case ID_VIEW_MENU:
|
|
idCommand = ID_MTB_MENU_VIEW;
|
|
break;
|
|
|
|
case ID_FAVORITES_MENU:
|
|
idCommand = ID_MTB_MENU_FAVORITES;
|
|
break;
|
|
|
|
case ID_SNAPIN_MENU_PLACEHOLDER:
|
|
/*
|
|
* We add a hidden menu as a marker. Later when snapin
|
|
* calls to insert a menu button we find the position
|
|
* of this menu and add snapin menu before it.
|
|
*/
|
|
idCommand = ID_MTB_MENU_SNAPIN_PLACEHOLDER;
|
|
byState |= TBSTATE_HIDDEN; // Add this as hidden.
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
return;
|
|
break;
|
|
}
|
|
|
|
bool bShow = IsStandardMenuAllowed(uMenuID);
|
|
if (! bShow)
|
|
byState |= TBSTATE_HIDDEN;
|
|
|
|
}
|
|
|
|
|
|
// append this button to the end of the toolbar
|
|
InsertButton (-1, strMenuText, idCommand, dwMenuData, byState, TBSTYLE_AUTOSIZE);
|
|
}
|
|
|
|
// add the accelerator for the child system menu
|
|
std::back_insert_iterator<AccelVector>
|
|
itTrackingInserter = std::back_inserter (m_vTrackingAccels);
|
|
|
|
AddMnemonic (chChildSysMenuMnemonic, ID_MTB_MENU_SYSMENU, 0, itTrackingInserter);
|
|
}
|
|
|
|
|
|
UpdateToolbarSize ();
|
|
AutoSize ();
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: InsertButton
|
|
//
|
|
// Synopsis: Insert a menu (button) to the main menu and then
|
|
// if there is a mnemonic char add it to accelerator
|
|
// and re-load the accelerators.
|
|
//
|
|
// Arguments: [nIndex] - index after which to insert.
|
|
// [strText] - menu text.
|
|
// [idCommand] - ID of command to notify with.
|
|
// [dwMenuData] - either submenu to be displayed (for static menus)
|
|
// or NULL for Action, View & Favorites.
|
|
// [fsState] - additional button states.
|
|
// [fsStyle] - additional button styles.
|
|
//
|
|
// Returns: BOOL
|
|
//
|
|
// Note: dwMenuData is handle to submenu for File, Window, Help menus whose
|
|
// sub-menu is static. But for top level menus like Action, View, Favorites,
|
|
// and Snapin menus it is NULL.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
BOOL CMenuBar::InsertButton (
|
|
int nIndex,
|
|
const CString& strText,
|
|
int idCommand,
|
|
DWORD_PTR dwMenuData,
|
|
BYTE fsState,
|
|
BYTE fsStyle)
|
|
{
|
|
TBBUTTON btn;
|
|
|
|
btn.iBitmap = nIndex;
|
|
btn.idCommand = idCommand;
|
|
|
|
if (fsState & TBSTATE_HIDDEN)
|
|
btn.fsState = fsState;
|
|
else
|
|
btn.fsState = TBSTATE_ENABLED | fsState;
|
|
|
|
btn.fsStyle = TBSTYLE_DROPDOWN | fsStyle;
|
|
btn.dwData = dwMenuData;
|
|
btn.iString = AddString (strText);
|
|
|
|
ASSERT(GetButtonCount() <= cMaxTopLevelMenuItems);
|
|
ASSERT (btn.idCommand <= ID_MTB_MENU_LAST);
|
|
|
|
BOOL bRet = CMMCToolBarCtrlEx::InsertButton (nIndex, &btn);
|
|
if (bRet == FALSE)
|
|
return bRet;
|
|
|
|
// Successfully added the menu button. Now add
|
|
// the accelerator for this item to our dynamic tables
|
|
TCHAR chMnemonic = GetMnemonicChar (static_cast<LPCTSTR>(strText));
|
|
|
|
if (chMnemonic != _T('\0'))
|
|
{
|
|
|
|
std::back_insert_iterator<AccelVector>
|
|
itMenuInserter = std::back_inserter (m_vMenuAccels);
|
|
std::back_insert_iterator<AccelVector>
|
|
itTrackingInserter = std::back_inserter (m_vTrackingAccels);
|
|
|
|
// add the Alt+<mnemonic> accelerator for use all the time
|
|
AddMnemonic (chMnemonic, idCommand, FALT, itMenuInserter);
|
|
|
|
// add the <mnemonic> accelerator for use when we're in menu mode
|
|
AddMnemonic (chMnemonic, idCommand, 0, itTrackingInserter);
|
|
|
|
m_strAccelerators += (TCHAR) tolower (chMnemonic);
|
|
m_strAccelerators += (TCHAR) toupper (chMnemonic);
|
|
}
|
|
|
|
// Re-load the accelerators
|
|
LoadAccels();
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: LoadAccels
|
|
//
|
|
// Synopsis: Load the accelerators. (This destorys old accel table
|
|
// and creates accel table).
|
|
//
|
|
// Arguments: None.
|
|
//
|
|
// Returns: void
|
|
//
|
|
//--------------------------------------------------------------------
|
|
void CMenuBar::LoadAccels()
|
|
{
|
|
// create the accelerator tables for the menu
|
|
m_MenuAccel .CreateAcceleratorTable (m_vMenuAccels.begin (),
|
|
m_vMenuAccels.size ());
|
|
m_TrackingAccel.CreateAcceleratorTable (m_vTrackingAccels.begin (),
|
|
m_vTrackingAccels.size ());
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: InsertMenuButton
|
|
//
|
|
// Synopsis: Insert a menu button to the main menu, called by
|
|
// CMenuButtonsMgr to add any snapin menus.
|
|
//
|
|
// Arguments: [lpszButtonText] - menu text.
|
|
// [bHidden] - Is this menu to be inserted hidden or not.
|
|
// [iPreferredPos] - The preferred position of this button.
|
|
//
|
|
// Returns: LONG, the command id of the inserted button.
|
|
// -1 if failed.
|
|
//
|
|
// Note: The snapin added menus should be added before the Window menu.
|
|
// For this a hidden menu is added (in SetMenu) which tells the
|
|
// position where snapin menu is to be added. If iPreferredPos is -1
|
|
// then find the position of this menu and add the menu before it.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
LONG CMenuBar::InsertMenuButton(LPCTSTR lpszButtonText,
|
|
BOOL bHidden,
|
|
int iPreferredPos)
|
|
{
|
|
AFX_MANAGE_STATE (AfxGetAppModuleState());
|
|
|
|
if (m_CommandIDUnUsed.size() == 0)
|
|
return -1;
|
|
|
|
// Get a command id for this button from the pool
|
|
CommandIDPool::iterator itCommandID = m_CommandIDUnUsed.begin();
|
|
int idCommand = *itCommandID;
|
|
m_CommandIDUnUsed.erase(itCommandID);
|
|
|
|
CString str = lpszButtonText;
|
|
|
|
// Add snapin menus before the SNAPIN_MENU_PLACE holder.
|
|
// See CMenubar::SetMenu.
|
|
if (-1 == iPreferredPos)
|
|
iPreferredPos = CommandToIndex(ID_MTB_MENU_SNAPIN_PLACEHOLDER);
|
|
|
|
BOOL bSuccess = InsertButton(iPreferredPos,
|
|
str, idCommand,
|
|
NULL,
|
|
bHidden ? TBSTATE_HIDDEN : 0,
|
|
TBSTYLE_AUTOSIZE);
|
|
|
|
if (bSuccess)
|
|
{
|
|
UpdateToolbarSize ();
|
|
AutoSize ();
|
|
return idCommand;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: DeleteMenuButton
|
|
//
|
|
// Synopsis: Delete a menu button from the main menu, called by
|
|
// CMenuButtonsMgr
|
|
//
|
|
// Arguments: [nCommandID] - Command ID of the menu.
|
|
//
|
|
// Returns: BOOL
|
|
//
|
|
// Note: Delete should also delete the accelerator.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
BOOL CMenuBar::DeleteMenuButton(INT nCommandID)
|
|
{
|
|
AFX_MANAGE_STATE (AfxGetAppModuleState());
|
|
|
|
int iIndex = CommandToIndex(nCommandID);
|
|
|
|
// We need to delete the mnemonics. So let us get the old
|
|
// mnemonic before deleting the button.
|
|
|
|
// 1. Get the menu text (string) index.
|
|
TBBUTTON tbbi;
|
|
ZeroMemory(&tbbi, sizeof(tbbi));
|
|
BOOL bSuccess = GetButton(iIndex, &tbbi);
|
|
if (FALSE == bSuccess)
|
|
return bSuccess;
|
|
|
|
// 2. Delete the button.
|
|
bSuccess = DeleteButton(iIndex);
|
|
ASSERT(bSuccess);
|
|
if (FALSE == bSuccess)
|
|
return bSuccess;
|
|
|
|
// Add the command id to the unused pool.
|
|
m_CommandIDUnUsed.insert(nCommandID);
|
|
|
|
// Get the mnemonic and Delete it.
|
|
ASSERT(m_ToolbarStringPool.size() > tbbi.iString);
|
|
CString strText = m_ToolbarStringPool[tbbi.iString];
|
|
for (AccelVector::iterator itAccel = m_vMenuAccels.begin();
|
|
itAccel != m_vMenuAccels.end();
|
|
itAccel++)
|
|
{
|
|
if (itAccel->cmd == (WORD)nCommandID)
|
|
{
|
|
m_vMenuAccels.erase(itAccel);
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (AccelVector::iterator itTrack = m_vTrackingAccels.begin();
|
|
itTrack != m_vTrackingAccels.end();
|
|
itTrack++)
|
|
{
|
|
if (itTrack->cmd == (WORD)nCommandID)
|
|
{
|
|
m_vTrackingAccels.erase(itTrack);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Delete the mnemonic from m_strAccelerators.
|
|
TCHAR chMnemonicOld = GetMnemonicChar (static_cast<LPCTSTR>(strText));
|
|
if (chMnemonicOld != _T('\0'))
|
|
{
|
|
// CString::Remove cannot be used as it is for VC6. We use the tstring
|
|
// to remove chars from the mnemonic string.
|
|
tstring tstrAccels = m_strAccelerators;
|
|
|
|
tstring::iterator itNewEnd = std::remove(tstrAccels.begin(), tstrAccels.end(), toupper(chMnemonicOld));
|
|
tstrAccels.erase(itNewEnd, tstrAccels.end());
|
|
itNewEnd = std::remove(tstrAccels.begin(), tstrAccels.end(), tolower(chMnemonicOld));
|
|
tstrAccels.erase(itNewEnd, tstrAccels.end());
|
|
m_strAccelerators = tstrAccels.data();
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: SetMenuButton
|
|
//
|
|
// Synopsis: Modify menu button text, called by CMenuButtonsMgr
|
|
//
|
|
// Arguments: [nCommandID] - Command ID.
|
|
// [lpszButtonText] - New text.
|
|
//
|
|
// Returns: LONG, command id of the menu (-1 if failed to change).
|
|
//
|
|
// Note: We delete the old button and add a new button with this
|
|
// name and button id.
|
|
// The reason for not calling SetButtonInfo is it does not allow us
|
|
// to change the string index (iString in TBBUTTON).
|
|
//
|
|
//--------------------------------------------------------------------
|
|
LONG CMenuBar::SetMenuButton(INT nCommandID, LPCTSTR lpszButtonText)
|
|
{
|
|
AFX_MANAGE_STATE (AfxGetAppModuleState());
|
|
|
|
// Note the index and hidden state.
|
|
int iIndex = CommandToIndex(nCommandID);
|
|
bool bHidden = IsButtonHidden(nCommandID);
|
|
|
|
// Please see the note above about why we do Delete and Insert
|
|
// instead of Set.
|
|
BOOL bSuccess = DeleteMenuButton(nCommandID);
|
|
|
|
if (bSuccess)
|
|
return InsertMenuButton(lpszButtonText, bHidden, iIndex);
|
|
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::SetMenuFont
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::SetMenuFont ()
|
|
{
|
|
// delete the old font
|
|
m_MenuFont.DeleteObject ();
|
|
|
|
// query the system for the current menu font
|
|
NONCLIENTMETRICS ncm;
|
|
ncm.cbSize = sizeof (ncm);
|
|
SystemParametersInfo (SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
|
|
|
|
// use it here, too
|
|
m_MenuFont.CreateFontIndirect (&ncm.lfMenuFont);
|
|
SetFont (&m_MenuFont, FALSE);
|
|
|
|
/*
|
|
* get the metrics for the menu text, so we can use it's height
|
|
*/
|
|
TEXTMETRIC tm;
|
|
CWindowDC dc(this);
|
|
CFont* pOldFont = dc.SelectObject (&m_MenuFont);
|
|
dc.GetTextMetrics (&tm);
|
|
dc.SelectObject (pOldFont);
|
|
|
|
/*
|
|
* Menu item buttons will contain only text (no bitmaps), so set the
|
|
* bitmap width to 0 so we don't have unwanted whitespace.
|
|
*
|
|
* We need to reserve height for the bitmap, though. If we don't do
|
|
* this, then the toolbar will calculate its own height to be too
|
|
* small when there aren't any buttons with text. (This occurs in MDI
|
|
* user mode when the active child is maximized. In that case, the
|
|
* system menu button is visible, but we have no menu items.)
|
|
*/
|
|
SetBitmapSize (CSize (0, std::_MAX ((int) tm.tmHeight,
|
|
GetSystemMetrics (SM_CXSMICON))));
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::OnActivateCurrentPopup
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::OnActivateCurrentPopup ()
|
|
{
|
|
PopupMenu (GetHotItem(), false /*bHighlightFirstItem*/);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::OnDestroy
|
|
*
|
|
* WM_DESTROY handler for CMenuBar.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::OnDestroy()
|
|
{
|
|
CMMCToolBarCtrlEx::OnDestroy();
|
|
GetMaxedChildIcon (NULL);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::OnSysCommand
|
|
*
|
|
* WM_SYSCOMMAND handler for CMenuBar.
|
|
*
|
|
* If we want to get the right sound effects for the action, we'll need to
|
|
* let DefWindowProc handle the message.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::OnSysCommand(UINT nID, LPARAM lParam)
|
|
{
|
|
ASSERT (m_pMDIFrame != NULL);
|
|
|
|
BOOL bMaximized;
|
|
CMDIChildWnd* pwndActive = m_pMDIFrame->MDIGetActive (&bMaximized);
|
|
|
|
// if the user has quick fingers he may succeed in issuing the command
|
|
// while the document is being closed - thus there may not be any
|
|
// child windows at all. We ignore the command in such case
|
|
// see bug #119775: MMC Crashes when snapin delays in closing down.
|
|
if (pwndActive == NULL)
|
|
return;
|
|
|
|
switch (nID & 0xFFF0)
|
|
{
|
|
case SC_MINIMIZE: pwndActive->ShowWindow (SW_MINIMIZE); break;
|
|
case SC_MAXIMIZE: pwndActive->ShowWindow (SW_MAXIMIZE); break;
|
|
case SC_RESTORE: pwndActive->ShowWindow (SW_RESTORE); break;
|
|
case SC_CLOSE: pwndActive->SendMessage (WM_CLOSE); break;
|
|
default:
|
|
CMMCToolBarCtrlEx::OnSysCommand (nID, lParam);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::OnSettingChange
|
|
*
|
|
* WM_SETTINGCHANGE handler for CMenuBar.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
|
|
{
|
|
if (uFlags == SPI_SETNONCLIENTMETRICS)
|
|
{
|
|
// the system menu font may have changed; update it now
|
|
SetMenuFont ();
|
|
|
|
// resize the decoration window
|
|
SizeDecoration ();
|
|
|
|
// update the size of the system menu button
|
|
TBBUTTONINFO btni;
|
|
btni.cbSize = sizeof (btni);
|
|
btni.dwMask = TBIF_SIZE;
|
|
btni.cx = static_cast<WORD>(GetSystemMetrics (SM_CXSMICON));
|
|
SetButtonInfo (ID_MTB_MENU_SYSMENU, &btni);
|
|
|
|
m_fMaxedChildIconIsInvalid = true;
|
|
|
|
// auto-size the toolbar
|
|
UpdateToolbarSize ();
|
|
AutoSize ();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::SizeDecoration
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::SizeDecoration ()
|
|
{
|
|
if (m_pMDIDec.get() == NULL)
|
|
return;
|
|
|
|
// jiggle the window's size so it will auto-size...
|
|
m_pMDIDec->SetWindowPos (NULL, 0, 0, 10, 10,
|
|
SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
|
|
|
|
CRect rect;
|
|
m_pMDIDec->GetClientRect (rect);
|
|
|
|
// ...and update its band to accomodate it
|
|
REBARBANDINFO rbi;
|
|
PrepBandInfo (&rbi, RBBIM_SIZE | RBBIM_CHILDSIZE);
|
|
rbi.cx = rect.Width();
|
|
rbi.cxMinChild = rect.Width();
|
|
rbi.cyMinChild = rect.Height();
|
|
|
|
m_pRebar->SetBandInfo (GetDecorationBandIndex (), &rbi);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* void CMenuBar::OnDropDown
|
|
*
|
|
* Reflected TBN_DROPDOWN handler for void CMenuBar.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
afx_msg void CMenuBar::OnDropDown (
|
|
NMHDR * pHdr,
|
|
LRESULT * pResult)
|
|
{
|
|
ASSERT (CWnd::FromHandle (pHdr->hwndFrom) == this);
|
|
|
|
// pop up the menu. Use async method, because toolbar will
|
|
// keeb the button hilited until this function returns
|
|
PopupMenuAsync (CommandToIndex (((LPNMTOOLBAR) pHdr)->iItem));
|
|
|
|
// drop down notification handled here
|
|
*pResult = TBDDRET_DEFAULT;
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* void CMenuBar::OnGetDispInfo
|
|
*
|
|
* Reflected TBN_GETDISPINFO handler for void CMenuBar.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
afx_msg void CMenuBar::OnGetDispInfo (
|
|
NMHDR * pHdr,
|
|
LRESULT * pResult)
|
|
{
|
|
ASSERT (CWnd::FromHandle (pHdr->hwndFrom) == this);
|
|
|
|
if (m_fDecorationsShowing)
|
|
{
|
|
NMTBDISPINFO* ptbdi = reinterpret_cast<NMTBDISPINFO *>(pHdr);
|
|
|
|
if ((ptbdi->dwMask & TBNF_IMAGE) &&
|
|
(ptbdi->idCommand != ID_MTB_MENU_SYSMENU))
|
|
{
|
|
ptbdi->iImage = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* void CMenuBar::OnCustomDraw
|
|
*
|
|
* Reflected NM_CUSTOMDRAW handler for void CMenuBar.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
afx_msg void CMenuBar::OnCustomDraw (
|
|
NMHDR * pHdr,
|
|
LRESULT * pResult)
|
|
{
|
|
ASSERT (CWnd::FromHandle (pHdr->hwndFrom) == this);
|
|
LPNMCUSTOMDRAW pnmcd = reinterpret_cast<LPNMCUSTOMDRAW>(pHdr);
|
|
|
|
switch (pnmcd->dwDrawStage)
|
|
{
|
|
case CDDS_PREPAINT:
|
|
// notify for individual buttons
|
|
*pResult = CDRF_NOTIFYITEMDRAW;
|
|
break;
|
|
|
|
case CDDS_ITEMPREPAINT:
|
|
// draw the system menu button manually
|
|
if (pnmcd->dwItemSpec == ID_MTB_MENU_SYSMENU)
|
|
{
|
|
if (m_fMaxedChildIconIsInvalid)
|
|
GetMaxedChildIcon (m_pMDIFrame->MDIGetActive());
|
|
|
|
if (m_hMaxedChildIcon != NULL)
|
|
{
|
|
/*
|
|
* compute the location at which we'll draw,
|
|
* biasing down and to the left
|
|
*/
|
|
CRect rect = pnmcd->rc;
|
|
int dx = (rect.Width() - GetSystemMetrics(SM_CXSMICON) ) / 2;
|
|
int dy = (rect.Height() - GetSystemMetrics(SM_CYSMICON) + 1) / 2;
|
|
|
|
|
|
|
|
/*
|
|
* Preserve icon shape when BitBlitting it to a
|
|
* mirrored DC.
|
|
*/
|
|
DWORD dwLayout=0L;
|
|
if ((dwLayout=GetLayout(pnmcd->hdc)) & LAYOUT_RTL)
|
|
{
|
|
SetLayout(pnmcd->hdc, dwLayout|LAYOUT_BITMAPORIENTATIONPRESERVED);
|
|
}
|
|
|
|
DrawIconEx (pnmcd->hdc,
|
|
rect.left + dx,
|
|
rect.top + dy,
|
|
m_hMaxedChildIcon, 0, 0, 0,
|
|
NULL, DI_NORMAL);
|
|
|
|
|
|
/*
|
|
* Restore the DC to its previous layout state.
|
|
*/
|
|
if (dwLayout & LAYOUT_RTL)
|
|
{
|
|
SetLayout(pnmcd->hdc, dwLayout);
|
|
}
|
|
}
|
|
|
|
// skip the default drawing
|
|
*pResult = CDRF_SKIPDEFAULT;
|
|
}
|
|
else
|
|
{
|
|
// do the default drawing
|
|
*pResult = CDRF_DODEFAULT;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::PopupMenuAsync
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::PopupMenuAsync (int nItemIdex)
|
|
{
|
|
PostMessage (WM_POPUP_ASYNC, nItemIdex);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* void CMenuBar::OnPopupAsync
|
|
*
|
|
* WM_POPUP_ASYNC handler for void CMenuBar.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
afx_msg LRESULT CMenuBar::OnPopupAsync (WPARAM wParam, LPARAM)
|
|
{
|
|
PopupMenu (wParam, false /*bHighlightFirstItem*/);
|
|
return (0);
|
|
}
|
|
|
|
/***************************************************************************\
|
|
*
|
|
* METHOD: CMenuBar::OnHotItemChange
|
|
*
|
|
* PURPOSE: Called when item hiliting changes. Used here to detect when menu
|
|
* is dissmissed to reset the UI
|
|
*
|
|
* PARAMETERS:
|
|
* NMHDR* pNMHDR
|
|
* LRESULT* pResult
|
|
*
|
|
* RETURNS:
|
|
* void
|
|
*
|
|
\***************************************************************************/
|
|
afx_msg void CMenuBar::OnHotItemChange(NMHDR* pNMHDR, LRESULT* pResult)
|
|
{
|
|
DECLARE_SC(sc, TEXT("CMenuBar::OnHotItemChange"));
|
|
|
|
// parameter chack
|
|
sc = ScCheckPointers(pNMHDR, pResult);
|
|
if (sc)
|
|
return;
|
|
|
|
// init out parameter
|
|
*pResult = 0;
|
|
|
|
// let the base class do it's job
|
|
CMMCToolBarCtrlEx::OnHotItemChange(pNMHDR, pResult);
|
|
|
|
// if menu is dismissed and not because of popup being displayed,
|
|
// we need to revert to initial state by hiding accelerators
|
|
LPNMTBHOTITEM lpNmTbHotItem = (LPNMTBHOTITEM)pNMHDR;
|
|
if ( (*pResult == 0) &&
|
|
(lpNmTbHotItem->dwFlags & HICF_LEAVING) &&
|
|
!m_bInProgressDisplayingPopup )
|
|
{
|
|
SendMessage( WM_CHANGEUISTATE, MAKEWPARAM(UIS_SET, UISF_HIDEACCEL | UISF_HIDEFOCUS));
|
|
}
|
|
}
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* CMenuBar::PopupMenu
|
|
*
|
|
* PURPOSE: Displays the popup menu specified by the index.
|
|
*
|
|
* PARAMETERS:
|
|
* int nItemIndex :
|
|
* bool bHighlightFirstItem : true to automatically highlight the first item
|
|
*
|
|
* RETURNS:
|
|
* void
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
void
|
|
CMenuBar::PopupMenu (int nItemIndex, bool bHighlightFirstItem)
|
|
{
|
|
DECLARE_SC(sc, TEXT("CMenuBar::PopupMenu"));
|
|
|
|
// get the rectangle that we don't want the popup to overlap
|
|
CRect rectExclude;
|
|
CPopupTrackContext popupMonitor(this, nItemIndex);
|
|
|
|
/*
|
|
* OnIdle updates various member variables such as
|
|
* m_fDecorationsShowing. It must be called before
|
|
* popup menu is created to ensure accurate information
|
|
*/
|
|
OnIdle();
|
|
|
|
// there is high possibility, that the code in following block
|
|
// adds nothing to the current functionality. It is left as it was
|
|
// in previos implementation, since it isn't obvios if removing it
|
|
// does not break anything.
|
|
// Even if the block is removed, call to EndTracking() at the end of method
|
|
// must still be present to exit tracking if it was put by entering menu
|
|
// via pressing the ALT key
|
|
{
|
|
/*
|
|
* make sure the frame's tracking manager is in tracking mode
|
|
*/
|
|
CMainFrame* pFrame = AMCGetMainWnd();
|
|
if (pFrame != NULL)
|
|
{
|
|
CToolbarTracker* pTracker = pFrame->GetToolbarTracker();
|
|
ASSERT (pTracker != NULL);
|
|
|
|
if (!pTracker->IsTracking())
|
|
pTracker->BeginTracking();
|
|
}
|
|
|
|
BeginTracking ();
|
|
}
|
|
|
|
// following is to indicate that the change in menu (if one does occurr)
|
|
// is because of attempt to switch to another submenu, and should not be
|
|
// treated as dismissing the menu. thus accelerator state should not be changed
|
|
m_bInProgressDisplayingPopup = true;
|
|
|
|
// There are two ways the popup menu is dismissed. it either:
|
|
// - request to display the new popup (left & right arrows, mouse on other item, etc)
|
|
// - or request to close the menu ( command is selected, ESC is pressed )
|
|
// following loop will continue displaying menus until request to close the menu is received
|
|
do {
|
|
|
|
GetItemRect (nItemIndex, rectExclude);
|
|
MapWindowPoints (NULL, rectExclude);
|
|
|
|
// get the information for this button
|
|
TBBUTTON btn;
|
|
GetButton (nItemIndex, &btn);
|
|
|
|
// if the requested button is ignorable, punt
|
|
if (::IsIgnorableButton (btn))
|
|
break;
|
|
|
|
// get the popup menu to display
|
|
HMENU hPopupMenu = (HMENU) btn.dwData;
|
|
|
|
// For system menu hPopupMenu will be NULL.
|
|
// If system menu is requested get it now.
|
|
if (ID_MTB_MENU_SYSMENU == btn.idCommand)
|
|
{
|
|
ASSERT (m_fDecorationsShowing);
|
|
ASSERT (m_pMDIFrame != NULL);
|
|
|
|
CMDIChildWnd* pwndActive = m_pMDIFrame->MDIGetActive();
|
|
ASSERT (pwndActive != NULL);
|
|
if (pwndActive == NULL)
|
|
break;
|
|
|
|
hPopupMenu = pwndActive->GetSystemMenu(FALSE)->GetSafeHmenu();
|
|
}
|
|
|
|
// display the button's popup menu
|
|
TPMPARAMS tpm;
|
|
tpm.cbSize = sizeof(TPMPARAMS);
|
|
tpm.rcExclude = rectExclude;
|
|
|
|
SetHotItem (-1);
|
|
PressButton (btn.idCommand, TRUE);
|
|
|
|
// Get the point where the menu should be popped up.
|
|
bool fLayoutRTL = (GetExStyle() & WS_EX_LAYOUTRTL);
|
|
POINT pt;
|
|
pt.y = rectExclude.bottom;
|
|
pt.x = (fLayoutRTL) ? rectExclude.right : rectExclude.left;
|
|
|
|
/*
|
|
* Bug 17342: TrackPopupMenuEx doesn't place the menu well if the
|
|
* x-coordinate of its origin is off-screen to the left, so prevent
|
|
* this from occurring. TrackPopupMenuEx *does* work fine when the
|
|
* x-coordinate is off-screen to the right or if the y-coordinate is
|
|
* off-screen to the bottom, so we don't need to account for those
|
|
* cases. (The system prevents placing the window such that the
|
|
* y-coordinate would be off-screen to the top.)
|
|
*
|
|
* Bug 173543: We can't assume that an x-coordinate less than 0 is
|
|
* off the screen. For multimon systems with the primary monitor
|
|
* on the right, the left monitor will have negative x coordinates.
|
|
* Our left-most position will be the left edge of the monitor nearest
|
|
* where the menu will be displayed.
|
|
*/
|
|
int xMin = 0;
|
|
HMONITOR hmonMenu = MonitorFromPoint (pt, MONITOR_DEFAULTTONEAREST);
|
|
|
|
if (hmonMenu != NULL)
|
|
{
|
|
MONITORINFO mi = { sizeof(mi) };
|
|
|
|
if (GetMonitorInfo (hmonMenu, &mi))
|
|
xMin = (fLayoutRTL) ? mi.rcWork.right : mi.rcWork.left;
|
|
}
|
|
|
|
if ((!fLayoutRTL && (pt.x < xMin)) || (fLayoutRTL && (pt.x > xMin)))
|
|
pt.x = xMin;
|
|
|
|
// HACK: post a bogus down arrow so the first menu item will be selected
|
|
if(bHighlightFirstItem)
|
|
{
|
|
CWnd* pwndFocus = GetFocus();
|
|
|
|
if (pwndFocus != NULL)
|
|
pwndFocus->PostMessage (WM_KEYDOWN, VK_DOWN, 1);
|
|
}
|
|
|
|
// monitor what's the popup menu fate
|
|
popupMonitor.StartMonitoring();
|
|
|
|
// Child window wont exist if there is no views, so check this ptr before using it.
|
|
CChildFrame* pChildFrame = dynamic_cast<CChildFrame*>(m_pMDIFrame->MDIGetActive());
|
|
|
|
// hPopupMenu exists only if the sub-menus were added thro resource like File, Window
|
|
// and Help menus. The Action, View, Favorites and any snapin added menu's sub-menus
|
|
// are not added thro resources so for them hPopupmenu is null.
|
|
if (! hPopupMenu)
|
|
{
|
|
sc = ScCheckPointers(pChildFrame, E_UNEXPECTED);
|
|
if (sc)
|
|
{
|
|
sc.TraceAndClear();
|
|
break;
|
|
}
|
|
|
|
CAMCView *pAMCView = pChildFrame->GetAMCView();
|
|
sc = ScCheckPointers(pAMCView, E_UNEXPECTED);
|
|
if (sc)
|
|
{
|
|
sc.TraceAndClear();
|
|
break;
|
|
}
|
|
|
|
switch(btn.idCommand)
|
|
{
|
|
case ID_MTB_MENU_ACTION:
|
|
pAMCView->OnActionMenu(pt, rectExclude);
|
|
break;
|
|
|
|
case ID_MTB_MENU_VIEW:
|
|
pAMCView->OnViewMenu(pt, rectExclude);
|
|
break;
|
|
|
|
case ID_MTB_MENU_FAVORITES:
|
|
pAMCView->OnFavoritesMenu(pt, rectExclude);
|
|
break;
|
|
|
|
// Assumption if none of the above then it is snapin added menu.
|
|
// We try to forward this to snapin else we get an error.
|
|
default:
|
|
{
|
|
// If this is one of the MenuButtons inserted by
|
|
// the CMenuButtonsMgrImpl, notify CMenuButtonsMgrImpl
|
|
// to do TrackPopupMenu.
|
|
|
|
// Get the CMenuButtonsMgrImpl from the ChildFrame.
|
|
CMenuButtonsMgrImpl* pMenuBtnsMgr = pChildFrame->GetMenuButtonsMgr();
|
|
sc = ScCheckPointers(pMenuBtnsMgr, E_UNEXPECTED);
|
|
if (sc)
|
|
break;
|
|
|
|
// Notify CMenuButtonsMgr to popup a menu.
|
|
sc = pMenuBtnsMgr->ScNotifyMenuClick(btn.idCommand, pt);
|
|
if (sc)
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (sc)
|
|
{
|
|
sc.TraceAndClear();
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
ASSERT (::IsMenu (hPopupMenu));
|
|
|
|
HWND hwndMenuOwner = AfxGetMainWnd()->GetSafeHwnd();
|
|
|
|
TrackPopupMenuEx (hPopupMenu,
|
|
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_VERTICAL,
|
|
pt.x, pt.y, hwndMenuOwner, &tpm);
|
|
}
|
|
|
|
// Clear the status bar.
|
|
if (pChildFrame)
|
|
sc = pChildFrame->ScSetStatusText(TEXT(""));
|
|
|
|
if (sc)
|
|
sc.TraceAndClear();
|
|
|
|
PressButton (btn.idCommand, FALSE);
|
|
SetHotItem (-1);
|
|
|
|
// the loop will continue if it was requested to display the new popup menu.
|
|
// if it was requested to simply close the menu, execution will exit the loop
|
|
}while ( popupMonitor.WasAnotherPopupRequested(nItemIndex) );
|
|
|
|
m_bInProgressDisplayingPopup = false;
|
|
//reset the UI by hiding the accelerators (since we are done)
|
|
SendMessage( WM_CHANGEUISTATE, MAKEWPARAM(UIS_SET, UISF_HIDEACCEL | UISF_HIDEFOCUS));
|
|
|
|
EndTracking();
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::OnAccelPopup
|
|
*
|
|
* Keyboard accelerator handler for CMenuBar.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::OnAccelPopup (UINT cmd)
|
|
{
|
|
PopupMenu (CommandToIndex (cmd), true /*bHighlightFirstItem*/);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* void CMenuBar::OnUpdateAllCmdUI
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::OnUpdateAllCmdUI (CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable ();
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::AddString
|
|
*
|
|
* The toolbar control doesn't provide a way to delete strings once they've
|
|
* been added, so we'll check our cache of strings that we've already added
|
|
* to the toolbar so we don't add wasteful duplicate strings.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int CMenuBar::AddString (const CString& strAdd)
|
|
{
|
|
// -1 for empty strings
|
|
if (strAdd.IsEmpty())
|
|
return (-1);
|
|
|
|
// check the cache
|
|
ToolbarStringPool::iterator it = std::find (m_ToolbarStringPool.begin(),
|
|
m_ToolbarStringPool.end(),
|
|
strAdd);
|
|
|
|
// if we found a hit in the cache, return the cached index
|
|
if (it != m_ToolbarStringPool.end())
|
|
return (it - m_ToolbarStringPool.begin());
|
|
|
|
|
|
// new string, add it to the cache...
|
|
m_ToolbarStringPool.push_back (strAdd);
|
|
|
|
|
|
// ...and to the toolbar, including a double-NULL
|
|
int cchAdd = strAdd.GetLength() + 1;
|
|
LPTSTR pszAdd = (LPTSTR) _alloca ((cchAdd + 1) * sizeof (TCHAR));
|
|
_tcscpy (pszAdd, strAdd);
|
|
pszAdd[cchAdd] = 0;
|
|
|
|
int nIndex = AddStrings (pszAdd);
|
|
|
|
// make sure the toolbar's string index matches the cache's string index
|
|
ASSERT (nIndex == m_ToolbarStringPool.end()-m_ToolbarStringPool.begin()-1);
|
|
|
|
return (nIndex);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::GetMenuBandIndex
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int CMenuBar::GetMenuBandIndex () const
|
|
{
|
|
return (m_pRebar->IdToIndex (GetDlgCtrlID ()));
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::GetDecorationBandIndex
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int CMenuBar::GetDecorationBandIndex () const
|
|
{
|
|
return (m_pRebar->IdToIndex (ID_MDIDECORATION));
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::GetFirstButtonIndex
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int CMenuBar::GetFirstButtonIndex ()
|
|
{
|
|
// make sure the system menu isn't the first one activated
|
|
return (GetNextButtonIndex (0));
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::OnIdle
|
|
*
|
|
* WM_IDLE handler for CMenuBar.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::OnIdle ()
|
|
{
|
|
/*----------------------------------------------------------*/
|
|
/* If there's no MDI frame, that means this menu is serving */
|
|
/* an SDI window. We don't have to do any special stuff to */
|
|
/* simulate the MDI menu UI, so bail now. */
|
|
/*----------------------------------------------------------*/
|
|
if (m_pMDIFrame == NULL)
|
|
return;
|
|
|
|
ProgramMode eMode = AMCGetApp()->GetMode();
|
|
|
|
// if we're in SDI User mode, bail now as well
|
|
if (eMode == eMode_User_SDI)
|
|
{
|
|
#ifdef DBG
|
|
// the decorations should be hidden
|
|
REBARBANDINFO rbi;
|
|
PrepBandInfo (&rbi, RBBIM_STYLE);
|
|
m_pRebar->GetBandInfo (GetDecorationBandIndex(), &rbi);
|
|
ASSERT (rbi.fStyle & RBBS_HIDDEN);
|
|
#endif
|
|
|
|
return;
|
|
}
|
|
|
|
/*---------------------------------------------------------------*/
|
|
/* We should be able to use MDIGetActive(&fMaximized) to tell */
|
|
/* whether the active window is maximized, instead of calling */
|
|
/* pwndActive->IsZoomed(). However, fMaximized doesn't always */
|
|
/* get initialized correctly in certain low memory/slow machine */
|
|
/* situations. This was the cause of Bug 133179, logged by SQL. */
|
|
/*---------------------------------------------------------------*/
|
|
CMDIChildWnd* pwndActive = m_pMDIFrame->MDIGetActive ();
|
|
bool fShow = (pwndActive != NULL) && pwndActive->IsZoomed();
|
|
|
|
REBARBANDINFO rbi;
|
|
PrepBandInfo (&rbi, RBBIM_STYLE);
|
|
m_pRebar->GetBandInfo (GetMenuBandIndex(), &rbi);
|
|
|
|
// if the menu bar is hidden, the decorations must be hidden as well
|
|
if (rbi.fStyle & RBBS_HIDDEN)
|
|
fShow = false;
|
|
|
|
if (fShow != m_fDecorationsShowing)
|
|
{
|
|
// show/hide the MDI decorations
|
|
m_pRebar->ShowBand (GetDecorationBandIndex(), fShow);
|
|
|
|
GetMaxedChildIcon (pwndActive);
|
|
HideButton (ID_MTB_MENU_SYSMENU, !fShow);
|
|
UpdateToolbarSize ();
|
|
|
|
// remember the new setting
|
|
m_fDecorationsShowing = fShow;
|
|
}
|
|
|
|
// otherwise, see if a window was maximized before but a different one is maxed now
|
|
else if (fShow && (m_pwndLastActive != pwndActive))
|
|
{
|
|
// get the new active window's icon
|
|
GetMaxedChildIcon (pwndActive);
|
|
|
|
// repaint the menu and MDI decorations
|
|
InvalidateRect (NULL);
|
|
m_pMDIDec->InvalidateRect (NULL);
|
|
}
|
|
|
|
// remember the currently active window
|
|
m_pwndLastActive = pwndActive;
|
|
|
|
// insure that it's safe to keep this pointer around
|
|
ASSERT ((m_pwndLastActive == NULL) ||
|
|
(CWnd::FromHandlePermanent (m_pwndLastActive->m_hWnd) != NULL));
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::DeleteMaxedChildIcon
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
void
|
|
CMenuBar::DeleteMaxedChildIcon()
|
|
{
|
|
// destroy the previous icon, if we need to
|
|
if (m_fDestroyChildIcon)
|
|
{
|
|
ASSERT (m_hMaxedChildIcon != NULL);
|
|
DestroyIcon (m_hMaxedChildIcon);
|
|
m_hMaxedChildIcon = NULL;
|
|
m_fDestroyChildIcon = false;
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CMenuBar::GetMaxedChildIcon
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::GetMaxedChildIcon (CWnd* pwnd)
|
|
{
|
|
DeleteMaxedChildIcon();
|
|
|
|
// get the small icon for the given window
|
|
if (IsWindow (pwnd->GetSafeHwnd()))
|
|
{
|
|
HICON hOriginalIcon = pwnd->GetIcon (false /*bBigIcon*/);
|
|
|
|
m_hMaxedChildIcon = (HICON) CopyImage (
|
|
hOriginalIcon, IMAGE_ICON,
|
|
GetSystemMetrics (SM_CXSMICON),
|
|
GetSystemMetrics (SM_CYSMICON),
|
|
LR_COPYFROMRESOURCE | LR_COPYRETURNORG);
|
|
|
|
// if the system had to create a new icon, we'll have to destroy it later
|
|
if ((m_hMaxedChildIcon != NULL) && (m_hMaxedChildIcon != hOriginalIcon))
|
|
m_fDestroyChildIcon = true;
|
|
}
|
|
|
|
m_fMaxedChildIconIsInvalid = false;
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CMenuBar::GetAccelerators
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::GetAccelerators (int cchBuffer, LPTSTR lpBuffer) const
|
|
{
|
|
lstrcpyn (lpBuffer, m_strAccelerators, cchBuffer);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CMenuBar::IsStandardMenuAllowed
|
|
//
|
|
// Synopsis: Is this standard MMC menu allowed or not.
|
|
//
|
|
// Arguments: uMenuID - The menu ID.
|
|
//
|
|
// Returns: bool
|
|
//
|
|
//--------------------------------------------------------------------
|
|
bool CMenuBar::IsStandardMenuAllowed(UINT uMenuID)
|
|
{
|
|
DECLARE_SC(sc, _T("CMenuBar::IsStandardMenuAllowed"));
|
|
|
|
/*
|
|
* We add a hidden menu as a marker. Later when snapin
|
|
* calls to insert a menu button we find the position
|
|
* of this menu and add snapin menu before it.
|
|
* So this acts as Std menu which is always allowed.
|
|
*/
|
|
if (uMenuID == ID_SNAPIN_MENU_PLACEHOLDER)
|
|
return true;
|
|
|
|
// First make sure it is one of the std menus.
|
|
if ( (uMenuID != ID_FAVORITES_MENU) &&
|
|
(uMenuID != ID_ACTION_MENU) &&
|
|
(uMenuID != ID_VIEW_MENU))
|
|
{
|
|
sc = E_INVALIDARG;
|
|
return true;
|
|
}
|
|
|
|
// Ask view data if std menus are allowed.
|
|
|
|
CMainFrame* pMainFrame = AMCGetMainWnd();
|
|
sc = ScCheckPointers(pMainFrame, E_UNEXPECTED);
|
|
if (sc)
|
|
return false;
|
|
|
|
CAMCView *pAMCView = pMainFrame->GetActiveAMCView();
|
|
sc = ScCheckPointers(pAMCView, E_UNEXPECTED);
|
|
if (sc)
|
|
return false;
|
|
|
|
SViewData* pViewData = pAMCView->GetViewData();
|
|
sc = ScCheckPointers(pViewData, E_UNEXPECTED);
|
|
if (sc)
|
|
return false;
|
|
|
|
if (! pViewData->IsStandardMenusAllowed())
|
|
return false;
|
|
|
|
if (uMenuID != ID_FAVORITES_MENU)
|
|
return true;
|
|
|
|
/*
|
|
* Display the Favorites menu button if we are in author mode, or if
|
|
* we're in user mode and we have at least one favorite. If we're in
|
|
* user mode and no favorites are defined, hide the Favorites button.
|
|
*/
|
|
bool fShowFavorites = true;
|
|
CAMCApp* pApp = AMCGetApp();
|
|
|
|
if (pApp != NULL)
|
|
{
|
|
/*
|
|
* show favorites in author mode
|
|
*/
|
|
fShowFavorites = (pApp->GetMode() == eMode_Author);
|
|
|
|
/*
|
|
* not author mode? see if we have any favorites
|
|
*/
|
|
if (!fShowFavorites)
|
|
{
|
|
CAMCDoc* pDoc = CAMCDoc::GetDocument ();
|
|
|
|
if (pDoc != NULL)
|
|
{
|
|
CFavorites* pFavorites = pDoc->GetFavorites();
|
|
|
|
if (pFavorites != NULL)
|
|
fShowFavorites = !pFavorites->IsEmpty();
|
|
}
|
|
}
|
|
}
|
|
|
|
return fShowFavorites;
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CMenuBar::ScShowMMCMenus
|
|
//
|
|
// Synopsis: Show or Hide the MMC menus (Action, View & Favorites).
|
|
// Called from customize view.
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: SC
|
|
//
|
|
// Note: As this is called from Customize view no need to look
|
|
// at viewdata::IsStandardMenusAllowed.
|
|
// Also Favorites button is not added in first place
|
|
// if it is not allowed. So no need for Favorites menu
|
|
// special case.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
SC CMenuBar::ScShowMMCMenus (bool bShow)
|
|
{
|
|
DECLARE_SC(sc, _T("CMenuBar::ScShowMMCMenus"));
|
|
|
|
// Go through the menu buttons & find Action, View & Favorites.
|
|
|
|
TBBUTTON btn;
|
|
int cButtons = GetButtonCount();
|
|
|
|
for (int i = 0; i < cButtons; ++i)
|
|
{
|
|
GetButton (i, &btn);
|
|
|
|
// Skip if button is not action/view/favs.
|
|
if ( (btn.idCommand != ID_MTB_MENU_FAVORITES) &&
|
|
(btn.idCommand != ID_MTB_MENU_ACTION) &&
|
|
(btn.idCommand != ID_MTB_MENU_VIEW) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// For favorites menu see if it is appropriate to un-hide it.
|
|
// In non-author mode if there is no favorites then this menu
|
|
// is hidden.
|
|
if ( bShow &&
|
|
(btn.idCommand == ID_MTB_MENU_FAVORITES) &&
|
|
(! IsStandardMenuAllowed(ID_FAVORITES_MENU)) )
|
|
continue;
|
|
|
|
HideButton(btn.idCommand, !bShow);
|
|
}
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CMenuBar::ScInsertAccPropIDs
|
|
*
|
|
* Inserts the IDs of the accessibility properties supported by CMenuBar
|
|
* (see ScGetPropValue).
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CMenuBar::ScInsertAccPropIDs (PropIDCollection& v)
|
|
{
|
|
DECLARE_SC (sc, _T("CMenuBar::ScInsertAccPropIDs"));
|
|
|
|
/*
|
|
* let the base class do its thing
|
|
*/
|
|
sc = CMMCToolBarCtrlEx::ScInsertAccPropIDs (v);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
/*
|
|
* add our own properties
|
|
*/
|
|
v.push_back (PROPID_ACC_ROLE);
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CMenuBar::ScGetPropValue
|
|
*
|
|
* Returns accessibility properties supported by CMenuBar.
|
|
*
|
|
* If a property is returned, fGotProp is set to true. If it is not
|
|
* returned, the value of fGotProp is unchanged, since the property might
|
|
* have been provided by a base/derived class.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
SC CMenuBar::ScGetPropValue (
|
|
HWND hwnd, // I:accessible window
|
|
DWORD idObject, // I:accessible object
|
|
DWORD idChild, // I:accessible child object
|
|
const MSAAPROPID& idProp, // I:property requested
|
|
VARIANT& varValue, // O:returned property value
|
|
BOOL& fGotProp) // O:was a property returned?
|
|
{
|
|
DECLARE_SC (sc, _T("CMenuBar::ScGetPropValue"));
|
|
|
|
/*
|
|
* call the base class
|
|
*/
|
|
sc = CMMCToolBarCtrlEx::ScGetPropValue (hwnd, idObject, idChild, idProp, varValue, fGotProp);
|
|
if (sc)
|
|
return (sc);
|
|
|
|
/*
|
|
* now handle requests for properties we support...role first
|
|
*/
|
|
if (idProp == PROPID_ACC_ROLE)
|
|
{
|
|
/*
|
|
* don't override the property for child elements,
|
|
* don't return a property
|
|
*/
|
|
if (idChild != CHILDID_SELF)
|
|
{
|
|
Trace (tagToolbarAccessibility, _T("GetPropValue: no role for child %d"), idChild);
|
|
return (sc);
|
|
}
|
|
|
|
/*
|
|
* the control itself has a role of menubar
|
|
*/
|
|
V_VT(&varValue) = VT_I4;
|
|
V_I4(&varValue) = ROLE_SYSTEM_MENUBAR;
|
|
fGotProp = true;
|
|
Trace (tagToolbarAccessibility, _T("GetPropValue: Returning 0x%08x"), V_I4(&varValue));
|
|
}
|
|
else if (idProp == PROPID_ACC_STATE)
|
|
{
|
|
/*
|
|
* Bug 148132: if the base class returned a property, append
|
|
* STATE_SYSTEM_HASPOPUP so Narrator et al will announce "has a
|
|
* submenu" when the menu item is highlighted
|
|
*/
|
|
if (fGotProp)
|
|
{
|
|
ASSERT (V_VT(&varValue) == VT_I4);
|
|
V_I4(&varValue) |= STATE_SYSTEM_HASPOPUP;
|
|
Trace (tagToolbarAccessibility, _T("GetPropValue: Appending STATE_SYSTEM_HASPOPUP, Returning 0x%08x"), V_I4(&varValue));
|
|
}
|
|
else
|
|
{
|
|
V_VT(&varValue) = VT_I4;
|
|
V_I4(&varValue) = STATE_SYSTEM_FOCUSABLE | STATE_SYSTEM_HASPOPUP;
|
|
fGotProp = true;
|
|
|
|
if (IsTrackingToolBar() && (GetHotItem() == (idChild-1) /*0-based*/))
|
|
V_I4(&varValue) |= STATE_SYSTEM_FOCUSED | STATE_SYSTEM_HOTTRACKED;
|
|
|
|
Trace (tagToolbarAccessibility, _T("GetPropValue: Returning 0x%08x"), V_I4(&varValue));
|
|
}
|
|
}
|
|
|
|
return (sc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CMenuBar::BeginTracking2
|
|
*
|
|
* Fires EVENT_SYSTEM_MENUSTART event accessibility event, then call base
|
|
* class.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::BeginTracking2 (CToolbarTrackerAuxWnd* pAuxWnd)
|
|
{
|
|
NotifyWinEvent (EVENT_SYSTEM_MENUSTART, m_hWnd, OBJID_CLIENT, CHILDID_SELF);
|
|
CMMCToolBarCtrlEx::BeginTracking2 (pAuxWnd);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CMenuBar::EndTracking2
|
|
*
|
|
* Fires EVENT_SYSTEM_MENUEND event accessibility event, then call base
|
|
* class.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CMenuBar::EndTracking2 (CToolbarTrackerAuxWnd* pAuxWnd)
|
|
{
|
|
NotifyWinEvent (EVENT_SYSTEM_MENUEND, m_hWnd, OBJID_CLIENT, CHILDID_SELF);
|
|
CMMCToolBarCtrlEx::EndTracking2 (pAuxWnd);
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPopupTrackContext
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::CPopupTrackContext
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CPopupTrackContext::CPopupTrackContext (
|
|
CMenuBar* pMenuBar,
|
|
int nCurrentPopupIndex)
|
|
:
|
|
m_pMenuBar (pMenuBar),
|
|
m_cButtons (pMenuBar->GetButtonCount()),
|
|
m_ptLastMouseMove (GetMessagePos()),
|
|
m_ptLButtonDown (GetMessagePos()),
|
|
m_dwLButtonDownTime (GetMessageTime()),
|
|
m_bPopupMonitorHooksActive(false),
|
|
m_iRequestForNewPopup(-1)
|
|
{
|
|
ASSERT_VALID (pMenuBar);
|
|
ASSERT (s_pTrackContext == NULL);
|
|
|
|
m_nCurrentPopupIndex = nCurrentPopupIndex;
|
|
m_fCurrentlyOnPopupItem = false;
|
|
m_cCascadedPopups = 0;
|
|
|
|
ASSERT (m_nCurrentPopupIndex < m_cButtons);
|
|
ASSERT (m_nCurrentPopupIndex >= 0);
|
|
|
|
// build the vector of button boundaries
|
|
m_ButtonBoundaries.resize (m_cButtons + 1, 0);
|
|
ASSERT (m_ButtonBoundaries.size() == m_cButtons + 1);
|
|
ASSERT (m_ButtonBoundaries.size() >= 2);
|
|
|
|
CRect rectButton (0, 0, 0, 0);
|
|
POINT ptTopLeft = rectButton.TopLeft();
|
|
|
|
for (int i = 0; i < m_cButtons; i++)
|
|
{
|
|
// GetItemRect will fail (acceptably) for hidden buttons,
|
|
// but should otherwise succeed.
|
|
VERIFY (pMenuBar->GetItemRect(i, rectButton) ||
|
|
pMenuBar->IsButtonHidden(pMenuBar->IndexToCommand(i)) );
|
|
|
|
// Do not map rectButton from Client To Screen.
|
|
// Map a copy of it (in ptTopLeft). So if a hidden
|
|
// button follows, it can use the rectButton.TopLeft()
|
|
// value and map it.
|
|
ptTopLeft = rectButton.TopLeft();
|
|
pMenuBar->ClientToScreen (&ptTopLeft);
|
|
m_ButtonBoundaries[i] = ptTopLeft.x;
|
|
|
|
// make m_rectAllButtons as a union of all buttons
|
|
if (i == 0)
|
|
m_rectAllButtons = rectButton;
|
|
else
|
|
m_rectAllButtons |= rectButton;
|
|
}
|
|
|
|
ptTopLeft = rectButton.BottomRight();
|
|
pMenuBar->ClientToScreen (&ptTopLeft);
|
|
m_ButtonBoundaries[m_cButtons] = ptTopLeft.x;
|
|
|
|
pMenuBar->ClientToScreen (&m_rectAllButtons);
|
|
// decrease m_rectAllButtons slightly
|
|
m_rectAllButtons.left = m_rectAllButtons.left + 1;
|
|
m_rectAllButtons.right = m_rectAllButtons.right - 1;
|
|
|
|
#ifdef DBG
|
|
{
|
|
// the button boundaries should naturally fall in ascending(for LTR) order
|
|
for (int j = 0; j < m_ButtonBoundaries.size()-1; j++)
|
|
{
|
|
if (0 == (m_pMenuBar->GetExStyle() & WS_EX_LAYOUTRTL))
|
|
ASSERT (m_ButtonBoundaries[j] <= m_ButtonBoundaries[j+1]);
|
|
else
|
|
ASSERT (m_ButtonBoundaries[j] >= m_ButtonBoundaries[j+1]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*--------------------------------------------------------------------*/
|
|
/* see if we might need to simulate a double-click on the system menu */
|
|
/*--------------------------------------------------------------------*/
|
|
m_pMaxedMDIChild = NULL;
|
|
|
|
// only deal with the system menu if the MDI decorations are showing
|
|
if (m_pMenuBar->m_fDecorationsShowing)
|
|
{
|
|
ASSERT (m_pMenuBar->m_pMDIFrame != NULL);
|
|
CWnd* pMDIChild = m_pMenuBar->m_pMDIFrame->MDIGetActive();
|
|
|
|
// nothing to do if child is already gone
|
|
if ( pMDIChild == NULL )
|
|
return;
|
|
|
|
ASSERT (pMDIChild->IsZoomed());
|
|
|
|
// if the mouse is over the system menu, remember the maximized child
|
|
// (non-NULL m_pMaxedMDIChild is the key later on in MaybeCloseMDIChild)
|
|
if (HitTest (m_ptLButtonDown) == 0)
|
|
m_pMaxedMDIChild = pMDIChild;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::~CPopupTrackContext
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
CPopupTrackContext::~CPopupTrackContext ()
|
|
{
|
|
// release the mouse and keyboard hooks
|
|
RemovePopupMonitorHooks();
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::RemovePopupMonitorHooks
|
|
*
|
|
* Unhooks from the system and stops watching the events
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CPopupTrackContext::RemovePopupMonitorHooks ()
|
|
{
|
|
// ignore if not monitoring yet
|
|
if (m_bPopupMonitorHooksActive)
|
|
{
|
|
// we MUST be the active monitor if we came here
|
|
if (s_pTrackContext != this)
|
|
{
|
|
ASSERT(FALSE && "Popup monitor uninstalled from outside");
|
|
return;
|
|
}
|
|
// release the mouse and keyboard hooks
|
|
UnhookWindowsHookEx (m_hhkMouse);
|
|
UnhookWindowsHookEx (m_hhkKeyboard);
|
|
UnhookWindowsHookEx (m_hhkCallWnd);
|
|
|
|
m_bPopupMonitorHooksActive = false;
|
|
// uninstall itself as hook monitor
|
|
s_pTrackContext = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::SetPopupMonitorHooks
|
|
*
|
|
* Hooks into the system and begins watching the events
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CPopupTrackContext::SetPopupMonitorHooks ()
|
|
{
|
|
// ignore if already set
|
|
if (!m_bPopupMonitorHooksActive)
|
|
{
|
|
// there is only one active menu per app. There is no place for anybody else
|
|
if (s_pTrackContext)
|
|
{
|
|
ASSERT(FALSE && "Popup menu overrun");
|
|
return;
|
|
}
|
|
// install itself as hook monitor
|
|
s_pTrackContext = this;
|
|
|
|
DWORD idCurrentThread = ::GetCurrentThreadId();
|
|
|
|
// hook the mouse for hot tracking
|
|
m_hhkMouse = SetWindowsHookEx (WH_MOUSE, MouseProc, NULL, idCurrentThread);
|
|
|
|
// hook the keyboard for navigation
|
|
m_hhkKeyboard = SetWindowsHookEx (WH_KEYBOARD, KeyboardProc, NULL, idCurrentThread);
|
|
|
|
// hook send messages for Menu_Is_Closed detection
|
|
m_hhkCallWnd = SetWindowsHookEx (WH_CALLWNDPROC, CallWndProc, NULL, idCurrentThread);
|
|
|
|
m_bPopupMonitorHooksActive = true;
|
|
}
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::StartMonitoring
|
|
*
|
|
* Public method to start popup monitoring
|
|
* Hooks into the system and begins watching the events
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CPopupTrackContext::StartMonitoring()
|
|
{
|
|
// reset the request to activate another popup upon finish
|
|
m_iRequestForNewPopup = -1;
|
|
// setup hooks and watch...
|
|
SetPopupMonitorHooks();
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::WasAnotherPopupRequested
|
|
*
|
|
* Used to retrieve the cause the menu was dismissed.
|
|
* If new popupu is requested, button index is returned
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
bool CPopupTrackContext::WasAnotherPopupRequested(int& iNewIdx)
|
|
{
|
|
if (m_iRequestForNewPopup >= 0)
|
|
{
|
|
iNewIdx = m_iRequestForNewPopup;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::MouseProc
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CALLBACK CPopupTrackContext::MouseProc (int nCode, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CPopupTrackContext* this_ = s_pTrackContext;
|
|
ASSERT (this_ != NULL);
|
|
|
|
if (nCode < 0)
|
|
return (CallNextHookEx (this_->m_hhkMouse, nCode, wParam, lParam));
|
|
|
|
return (this_->MouseProc (nCode, wParam, (LPMOUSEHOOKSTRUCT) lParam));
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::MouseProc
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CPopupTrackContext::MouseProc (int nCode, UINT msg, LPMOUSEHOOKSTRUCT pmhs)
|
|
{
|
|
// if this is a mouse message within the menu bar...
|
|
if (m_rectAllButtons.PtInRect (pmhs->pt))
|
|
{
|
|
// eat the button down so we don't get into a TBN_DROPDOWN loop
|
|
if (msg == WM_LBUTTONDOWN)
|
|
{
|
|
DismissCurrentPopup (true);
|
|
MaybeCloseMDIChild (pmhs->pt);
|
|
return (1);
|
|
}
|
|
|
|
// for (non-duplicate) mouse moves, follow the mouse with the active menu
|
|
if ((msg == WM_MOUSEMOVE) &&
|
|
(nCode == HC_ACTION) &&
|
|
(m_ptLastMouseMove != pmhs->pt))
|
|
{
|
|
// determine which button is being tracked over
|
|
m_ptLastMouseMove = pmhs->pt;
|
|
int nNewPopupIndex = HitTest (m_ptLastMouseMove);
|
|
ASSERT (nNewPopupIndex != -1);
|
|
|
|
// if we're not over the same button we were last
|
|
// time, display the popup for the new button
|
|
if (nNewPopupIndex != m_nCurrentPopupIndex)
|
|
NotifyNewPopup (m_nCurrentPopupIndex = nNewPopupIndex);
|
|
}
|
|
}
|
|
|
|
return (CallNextHookEx (m_hhkMouse, nCode, msg, (LPARAM) pmhs));
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::KeyboardProc
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CALLBACK CPopupTrackContext::KeyboardProc (int nCode, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CPopupTrackContext* this_ = s_pTrackContext;
|
|
ASSERT (this_ != NULL);
|
|
|
|
if (nCode < 0)
|
|
return (CallNextHookEx (this_->m_hhkKeyboard, nCode, wParam, lParam));
|
|
|
|
int cRepeat = LOWORD (lParam);
|
|
bool fDown = (lParam & (1 << 31)) == 0;
|
|
|
|
return (this_->KeyboardProc (nCode, wParam, cRepeat, fDown, lParam));
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::KeyboardProc
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CPopupTrackContext::KeyboardProc (
|
|
int nCode,
|
|
int vkey,
|
|
int cRepeat,
|
|
bool fDown,
|
|
LPARAM lParam)
|
|
{
|
|
// if this isn't a real message, ignore it
|
|
if (nCode != HC_ACTION)
|
|
return (CallNextHookEx (m_hhkKeyboard, nCode, vkey, lParam));
|
|
|
|
// if this is a left or right message...
|
|
if ((vkey == VK_LEFT) || (vkey == VK_RIGHT))
|
|
{
|
|
// eat the key release, but don't do anything with it
|
|
if (!fDown)
|
|
return (1);
|
|
|
|
/*
|
|
* let the menu code handle cascaded popups
|
|
*/
|
|
// need to do everything in opposite direction on RTL layout
|
|
// see bug #402620 ntbug9 05/23/2001
|
|
const bool fNext = ( (m_pMenuBar->GetExStyle() & WS_EX_LAYOUTRTL) ? (vkey != VK_RIGHT) : (vkey == VK_RIGHT) ) ;
|
|
|
|
if (m_fCurrentlyOnPopupItem && fNext)
|
|
m_cCascadedPopups++;
|
|
|
|
else if ((m_cCascadedPopups > 0) && !fNext)
|
|
m_cCascadedPopups--;
|
|
|
|
/*
|
|
* not right on a popup item, or left on a popped-up menu
|
|
*/
|
|
else
|
|
{
|
|
m_cCascadedPopups = 0;
|
|
|
|
// figure out the next button
|
|
int nNewPopupIndex = fNext
|
|
? m_pMenuBar->GetNextButtonIndex (m_nCurrentPopupIndex, cRepeat)
|
|
: m_pMenuBar->GetPrevButtonIndex (m_nCurrentPopupIndex, cRepeat);
|
|
|
|
// activate the new button's popup, if it's different from the current one
|
|
if (nNewPopupIndex != m_nCurrentPopupIndex)
|
|
NotifyNewPopup (m_nCurrentPopupIndex = nNewPopupIndex);
|
|
|
|
// eat the key press
|
|
return (1);
|
|
}
|
|
}
|
|
|
|
return (CallNextHookEx (m_hhkKeyboard, nCode, vkey, lParam));
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::CallWndProc
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CALLBACK CPopupTrackContext::CallWndProc(
|
|
int nCode, // hook code
|
|
WPARAM wParam, // current-process flag
|
|
LPARAM lParam // address of structure with message data
|
|
)
|
|
{
|
|
// get the active monitor
|
|
CPopupTrackContext* this_ = s_pTrackContext;
|
|
ASSERT (this_ != NULL);
|
|
|
|
// ignore special cases
|
|
if (nCode < 0)
|
|
return (CallNextHookEx (this_->m_hhkCallWnd, nCode, wParam, lParam));
|
|
|
|
BOOL bCurrentThread = wParam;
|
|
LPCWPSTRUCT lpCWP = reinterpret_cast<LPCWPSTRUCT>(lParam);
|
|
|
|
// forward the request to monitor
|
|
return (this_->CallWndProc (nCode, bCurrentThread, lpCWP));
|
|
}
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::CallWndProc
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CPopupTrackContext::CallWndProc (int nCode, BOOL bCurrentThread, LPCWPSTRUCT lpCWP)
|
|
{
|
|
ASSERT(lpCWP != NULL);
|
|
if (lpCWP)
|
|
{
|
|
// watch for message
|
|
if (lpCWP->message == WM_MENUSELECT)
|
|
{
|
|
// decode params
|
|
const UINT fuFlags = (UINT) HIWORD(lpCWP->wParam); // menu flags
|
|
const HMENU hmenu = (HMENU) lpCWP->lParam; // handle to menu clicked
|
|
|
|
if (fuFlags == 0xFFFF && hmenu == NULL)
|
|
{
|
|
// menu is closed! no more hooking needed
|
|
RemovePopupMonitorHooks ();
|
|
}
|
|
else
|
|
{
|
|
// we stepped on the popup (will use the info when arrows are pressed)
|
|
m_fCurrentlyOnPopupItem = (fuFlags & MF_POPUP);
|
|
}
|
|
}
|
|
}
|
|
// done
|
|
return (CallNextHookEx (m_hhkCallWnd, nCode, bCurrentThread, (LPARAM)lpCWP));
|
|
}
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::DismissCurrentPopup
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CPopupTrackContext::DismissCurrentPopup (bool fTrackingComplete)
|
|
{
|
|
// If the snapin does TrackPopupMenu with a window other than
|
|
// MainFrame as parent then that window should be asked to
|
|
// close the menu by sending WM_CANCELMODE. The window
|
|
// is found by calling GetCapture().
|
|
CWnd* pwndMode = CWnd::GetCapture();
|
|
|
|
if (pwndMode == NULL)
|
|
pwndMode = AfxGetMainWnd();
|
|
|
|
pwndMode->SendMessage (WM_CANCELMODE);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::NotifyNewPopup
|
|
*
|
|
* Notify the menu toolbar that it needs to display a new popup menu.
|
|
* Note that this must be accomplished asynchronously so that we can
|
|
* allow CMenuBar::PopupMenu to unwind after the WM_CANCELMODE from
|
|
* DismissCurrentPopup.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CPopupTrackContext::NotifyNewPopup (int nNewPopupIndex)
|
|
{
|
|
// dismiss the existing popup
|
|
DismissCurrentPopup (false);
|
|
// ask to activate the new popup after this one is closed
|
|
m_iRequestForNewPopup = nNewPopupIndex;
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::HitTest
|
|
*
|
|
* Returns the index of the button under the given point, -1 if none.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int CPopupTrackContext::HitTest (CPoint pt) const
|
|
{
|
|
/*----------------------------------------------------------------*/
|
|
/* Find the range of "hit" buttons. The range will span more */
|
|
/* than one button only if there are hidden buttons in the range, */
|
|
/* and in that case, there will be exactly one non-hidden button */
|
|
/* in the range. */
|
|
/*----------------------------------------------------------------*/
|
|
std::pair<BoundConstIt, BoundConstIt> range;
|
|
|
|
if ( m_pMenuBar->GetExStyle() & WS_EX_LAYOUTRTL )
|
|
{
|
|
range = std::equal_range (m_ButtonBoundaries.begin(),
|
|
m_ButtonBoundaries.end(), pt.x,
|
|
std::greater<BoundaryCollection::value_type>() );
|
|
}
|
|
else
|
|
{
|
|
range = std::equal_range (m_ButtonBoundaries.begin(),
|
|
m_ButtonBoundaries.end(), pt.x);
|
|
}
|
|
|
|
int nLowerHitIndex = MapBoundaryIteratorToButtonIndex (range.first);
|
|
int nUpperHitIndex = MapBoundaryIteratorToButtonIndex (range.second);
|
|
|
|
/*
|
|
* equal_range returns values that are less_than and greater_than
|
|
* given value. The m_ButtonBoundaries has duplicate values (due
|
|
* to hidden buttons). So if the less_than value is one of duplicate
|
|
* values (not unique) then equal_range returns the iterator to
|
|
* last dup item, not first dup item.
|
|
*
|
|
* Below we try to find the first dup item.
|
|
*/
|
|
|
|
// Find the first item with value m_ButtonBoundaries[nLowerHitIndex].
|
|
for (int iIndex = 0; iIndex < nLowerHitIndex; ++iIndex)
|
|
{
|
|
if (m_ButtonBoundaries[iIndex] == m_ButtonBoundaries[nLowerHitIndex])
|
|
{
|
|
// Found first item.
|
|
nLowerHitIndex = iIndex;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT (nLowerHitIndex <= nUpperHitIndex);
|
|
|
|
int nHitIndex;
|
|
|
|
// lower equal upper? no hidden buttons
|
|
if (nLowerHitIndex == nUpperHitIndex)
|
|
nHitIndex = nLowerHitIndex;
|
|
|
|
// otherwise we have some hidden buttons, or we are precisely on a button border
|
|
else
|
|
{
|
|
nHitIndex = -1;
|
|
|
|
if (nUpperHitIndex == -1)
|
|
nUpperHitIndex = m_cButtons;
|
|
|
|
for (int i = nLowerHitIndex;
|
|
i <= nUpperHitIndex; // We should check till we hit nUpperHitIndex? AnandhaG
|
|
++i)
|
|
{
|
|
// See if this button is not hidden.
|
|
if (!m_pMenuBar->IsButtonHidden (m_pMenuBar->IndexToCommand(i)))
|
|
{
|
|
nHitIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// we should have found a visible button
|
|
ASSERT (nHitIndex != -1);
|
|
}
|
|
|
|
ASSERT (nHitIndex >= -1);
|
|
ASSERT (nHitIndex < m_cButtons);
|
|
return (nHitIndex);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::MapBoundaryIteratorToButtonIndex
|
|
*
|
|
* Returns the button index corresponding to the input m_ButtonBoundaries
|
|
* index, -1 for not found.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
int CPopupTrackContext::MapBoundaryIteratorToButtonIndex (BoundConstIt it) const
|
|
{
|
|
return ((it != m_ButtonBoundaries.end())
|
|
? it - m_ButtonBoundaries.begin() - 1
|
|
: -1);
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------*
|
|
* CPopupTrackContext::MaybeCloseMDIChild
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CPopupTrackContext::MaybeCloseMDIChild (CPoint pt)
|
|
{
|
|
// if we didn't find a maxed MDI child when this all started, punt
|
|
if (m_pMaxedMDIChild == NULL)
|
|
return;
|
|
|
|
// if the click didn't happen on the system menu toolbar button, punt
|
|
if (HitTest (pt) != 0)
|
|
return;
|
|
|
|
/*-------------------------------------------------------------------*/
|
|
/* if the double-click time has elapsed, punt */
|
|
/* */
|
|
/* Note: this is called from a mouse hook, which means the value */
|
|
/* returned by GetMessageTime hasn't been updated for this message, */
|
|
/* so it really reflects the time of the *previous* message (most */
|
|
/* likely WM_LBUTTONUP). */
|
|
/* */
|
|
/* GetTickCount returns a close enough approximation to */
|
|
/* GetMessageTime, except when we're debugging through this routine, */
|
|
/* in which case the tick count will continue to spin (and this test */
|
|
/* will always fail) but the message time would have remained fixed. */
|
|
/*-------------------------------------------------------------------*/
|
|
// if ((GetMessageTime() - m_dwLButtonDownTime) > GetDoubleClickTime())
|
|
if ((GetTickCount() - m_dwLButtonDownTime) > GetDoubleClickTime())
|
|
return;
|
|
|
|
// if the second click occurred outside the double-click space, punt
|
|
if ((abs (m_ptLButtonDown.x - pt.x) > GetSystemMetrics (SM_CXDOUBLECLK)) ||
|
|
(abs (m_ptLButtonDown.y - pt.y) > GetSystemMetrics (SM_CYDOUBLECLK)))
|
|
return;
|
|
|
|
// if the window doesn't have a system menu, or its Close item is disabled, punt
|
|
CMenu* pSysMenu = m_pMaxedMDIChild->GetSystemMenu (FALSE);
|
|
|
|
if (pSysMenu == NULL)
|
|
return;
|
|
|
|
UINT nCloseState = pSysMenu->GetMenuState (SC_CLOSE, MF_BYCOMMAND);
|
|
|
|
if ((nCloseState == 0xFFFFFFFF) ||
|
|
(nCloseState & (MF_GRAYED | MF_DISABLED)))
|
|
return;
|
|
|
|
// here: we've identified a double-click on a maximized child's
|
|
// system menu; close it
|
|
m_pMaxedMDIChild->PostMessage (WM_SYSCOMMAND, SC_CLOSE);
|
|
}
|