CMenuToolbarBase Class Reference

#include <CMenuToolbars.h>

Inheritance diagram for CMenuToolbarBase:

Collaboration diagram for CMenuToolbarBase:

Public Member Functions
	CMenuToolbarBase (CMenuBand *menuBand, BOOL usePager)
virtual	~CMenuToolbarBase ()
HRESULT	IsWindowOwner (HWND hwnd)
HRESULT	CreateToolbar (HWND hwndParent, DWORD dwFlags)
HRESULT	GetWindow (HWND *phwnd)
HRESULT	ShowDW (BOOL fShow)
HRESULT	Close ()
HRESULT	OnWinEvent (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *theResult)
HRESULT	ChangeHotItem (CMenuToolbarBase *toolbar, INT item, DWORD dwFlags)
HRESULT	ChangePopupItem (CMenuToolbarBase *toolbar, INT item)
HRESULT	PopupSubMenu (UINT itemId, UINT index, IShellMenu *childShellMenu, BOOL keyInitiated)
HRESULT	PopupSubMenu (UINT itemId, UINT index, HMENU menu)
HRESULT	TrackContextMenu (IContextMenu *contextMenu, POINT pt)
HRESULT	KeyboardItemChange (DWORD changeType)
HRESULT	PrepareExecuteItem (INT iItem)
HRESULT	ExecuteItem ()
HRESULT	GetSizes (SIZE *pMinSize, SIZE *pMaxSize, SIZE *pIntegralSize)
HRESULT	SetPosSize (int x, int y, int cx, int cy)
void	InvalidateDraw ()
HRESULT	DisableMouseTrack (BOOL bDisable)
virtual HRESULT	FillToolbar (BOOL clearFirst=FALSE)=0
HRESULT	CancelCurrentPopup ()
HRESULT	PopupItem (INT iItem, BOOL keyInitiated)
HRESULT	GetDataFromId (INT iItem, INT *pIndex, DWORD_PTR *pData)
HRESULT	KillPopupTimer ()
HRESULT	MenuBarMouseDown (INT iIndex, BOOL isLButton)
HRESULT	MenuBarMouseUp (INT iIndex, BOOL isLButton)
HRESULT	ProcessClick (INT iItem)
HRESULT	ProcessContextMenu (INT iItem)
HRESULT	BeforeCancelPopup ()

Protected Member Functions
virtual HRESULT	OnDeletingButton (const NMTOOLBAR *tb) PURE
virtual HRESULT	InternalGetTooltip (INT iItem, INT index, DWORD_PTR dwData, LPWSTR pszText, INT cchTextMax) PURE
virtual HRESULT	InternalExecuteItem (INT iItem, INT index, DWORD_PTR dwData) PURE
virtual HRESULT	InternalPopupItem (INT iItem, INT index, DWORD_PTR dwData, BOOL keyInitiated) PURE
virtual HRESULT	InternalHasSubMenu (INT iItem, INT index, DWORD_PTR dwData) PURE
virtual HRESULT	InternalContextMenu (INT iItem, INT index, DWORD_PTR dwData, POINT pt) PURE
HRESULT	AddButton (DWORD commandId, LPCWSTR caption, BOOL hasSubMenu, INT iconId, DWORD_PTR buttonData, BOOL last)
HRESULT	AddSeparator (BOOL last)
HRESULT	AddPlaceholder ()
HRESULT	ClearToolbar ()
HWND	GetToolbar ()

Protected Attributes
CMenuBand *	m_menuBand
DWORD	m_dwMenuFlags
BOOL	m_hasSizes
SIZE	m_idealSize
SIZE	m_itemSize
BOOL	m_usePager
CMenuToolbarBase *	m_hotBar
INT	m_hotItem
CMenuToolbarBase *	m_popupBar
INT	m_popupItem
DWORD	m_initFlags
BOOL	m_isTrackingPopup
INT	m_executeIndex
INT	m_executeItem
DWORD_PTR	m_executeData
BOOL	m_cancelingPopup

Private Member Functions
HRESULT	UpdateImageLists ()
HRESULT	OnPagerCalcSize (LPNMPGCALCSIZE csize)
HRESULT	OnCustomDraw (LPNMTBCUSTOMDRAW cdraw, LRESULT *theResult)
HRESULT	OnGetInfoTip (NMTBGETINFOTIP *tip)
LRESULT	IsTrackedItem (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	ChangeTrackedItem (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
LRESULT	OnWinEventWrap (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)
HRESULT	OnPopupTimer (UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL &bHandled)

Private Attributes
CContainedWindow	m_pager
HFONT	m_marlett
BOOL	m_useFlatMenus
BOOL	m_disableMouseTrack
BOOL	m_timerEnabled

Detailed Description

Definition at line 28 of file CMenuToolbars.h.

Constructor & Destructor Documentation

CMenuToolbarBase()

CMenuToolbarBase::CMenuToolbarBase	(	CMenuBand *	menuBand,
		BOOL	usePager
	)

Definition at line 271 of file CMenuToolbars.cpp.

                                                                     :
    m_pager(WC_PAGESCROLLER, this),
    m_useFlatMenus(FALSE),
    m_disableMouseTrack(FALSE),
    m_timerEnabled(FALSE),
    m_menuBand(menuBand),
    m_dwMenuFlags(0),
    m_hasSizes(FALSE),
    m_usePager(usePager),
    m_hotBar(NULL),
    m_hotItem(-1),
    m_popupBar(NULL),
    m_popupItem(-1),
    m_isTrackingPopup(FALSE),
    m_cancelingPopup(FALSE)
{
    m_idealSize.cx = 0;
    m_idealSize.cy = 0;
    m_itemSize.cx = 0;
    m_itemSize.cy = 0;
    m_marlett = CreateFont(
        0, 0, 0, 0, 0, 0, 0, 0, DEFAULT_CHARSET,
        OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
        DEFAULT_QUALITY, FF_DONTCARE, L"Marlett");
}

~CMenuToolbarBase()

CMenuToolbarBase::~CMenuToolbarBase ( )

virtual

Definition at line 297 of file CMenuToolbars.cpp.

{
    if (m_hWnd)
    {
        ClearToolbar();
        DestroyWindow();
    }
 
    if (m_pager.m_hWnd)
        m_pager.DestroyWindow();
 
    DeleteObject(m_marlett);
}

Member Function Documentation

AddButton()

HRESULT CMenuToolbarBase::AddButton ( DWORD  commandId, LPCWSTR  caption, BOOL  hasSubMenu, INT  iconId, DWORD_PTR  buttonData, BOOL  last  )

protected

Definition at line 997 of file CMenuToolbars.cpp.

{
    TBBUTTON tbb = { 0 };
 
    tbb.fsState = TBSTATE_ENABLED;
#if !USE_TBSTYLE_EX_VERTICAL
    if (!last && (m_initFlags & SMINIT_VERTICAL))
        tbb.fsState |= TBSTATE_WRAP;
#endif
    tbb.fsStyle = BTNS_CHECKGROUP;
 
    if (hasSubMenu && (m_initFlags & SMINIT_VERTICAL))
        tbb.fsStyle |= BTNS_DROPDOWN;
 
    if (!(m_initFlags & SMINIT_VERTICAL))
        tbb.fsStyle |= BTNS_AUTOSIZE;
 
    tbb.iString = (INT_PTR) caption;
    tbb.idCommand = commandId;
 
    tbb.iBitmap = iconId;
    tbb.dwData = buttonData;
 
    m_hasSizes = FALSE;
 
    if (!AddButtons(1, &tbb))
        return HRESULT_FROM_WIN32(GetLastError());
    return S_OK;
}

Referenced by CMenuStaticToolbar::FillToolbar(), and CMenuSFToolbar::FillToolbar().

AddPlaceholder()

HRESULT CMenuToolbarBase::AddPlaceholder ( )

protected

Definition at line 1047 of file CMenuToolbars.cpp.

{
    TBBUTTON tbb = { 0 };
    WCHAR MenuString[128];
 
    LoadStringW(GetModuleHandle(L"shell32.dll"), IDS_MENU_EMPTY, MenuString, _countof(MenuString));
 
    tbb.fsState = 0;
    tbb.fsStyle = 0;
    tbb.iString = (INT_PTR) MenuString;
    tbb.iBitmap = -1;
 
    m_hasSizes = FALSE;
 
    if (!AddButtons(1, &tbb))
        return HRESULT_FROM_WIN32(GetLastError());
 
    return S_OK;
}

Referenced by CMenuSFToolbar::FillToolbar().

AddSeparator()

HRESULT CMenuToolbarBase::AddSeparator ( BOOL  last )

protected

Definition at line 1027 of file CMenuToolbars.cpp.

{
    TBBUTTON tbb = { 0 };
 
    tbb.fsState = TBSTATE_ENABLED;
#if !USE_TBSTYLE_EX_VERTICAL
    if (!last && (m_initFlags & SMINIT_VERTICAL))
        tbb.fsState |= TBSTATE_WRAP;
#endif
    tbb.fsStyle = BTNS_SEP;
    tbb.iBitmap = 0;
 
    m_hasSizes = FALSE;
 
    if (!AddButtons(1, &tbb))
        return HRESULT_FROM_WIN32(GetLastError());
 
    return S_OK;
}

Referenced by CMenuStaticToolbar::FillToolbar().

BeforeCancelPopup()

HRESULT CMenuToolbarBase::BeforeCancelPopup

(

)

Definition at line 804 of file CMenuToolbars.cpp.

{
    m_cancelingPopup = TRUE;
    TRACE("BeforeCancelPopup\n");
    return S_OK;
}

Referenced by CMenuBand::_BeforeCancelPopup().

CancelCurrentPopup()

HRESULT CMenuToolbarBase::CancelCurrentPopup

(

)

Definition at line 1106 of file CMenuToolbars.cpp.

{
    return m_menuBand->_CancelCurrentPopup();
}

Referenced by OnPopupTimer(), and PopupItem().

ChangeHotItem()

HRESULT CMenuToolbarBase::ChangeHotItem	(	CMenuToolbarBase *	toolbar,
		INT	item,
		DWORD	dwFlags
	)

Definition at line 588 of file CMenuToolbars.cpp.

{
    // Ignore the change if it already matches the stored info
    if (m_hotBar == toolbar && m_hotItem == item)
        return S_FALSE;
 
    // Prevent a change of hot item if the change was triggered by the mouse,
    // and mouse tracking is disabled.
    if (m_disableMouseTrack && dwFlags & HICF_MOUSE)
    {
        TRACE("Hot item change prevented by DisableMouseTrack\n");
        return S_OK;
    }
 
    // Notify the toolbar if the hot-tracking left this toolbar
    if (m_hotBar == this && toolbar != this)
    {
        SetHotItem(-1);
    }
 
    TRACE("Hot item changed from %p %p, to %p %p\n", m_hotBar, m_hotItem, toolbar, item);
    m_hotBar = toolbar;
    m_hotItem = item;
 
    if (m_hotBar == this)
    {
        if (m_isTrackingPopup && !(m_initFlags & SMINIT_VERTICAL))
        {
            // If the menubar has an open submenu, switch to the new item's submenu immediately
            PopupItem(m_hotItem, FALSE);
        }
        else if (dwFlags & HICF_MOUSE)
        {
            // Vertical menus show/hide the submenu after a delay,
            // but only with the mouse.
            if (m_initFlags & SMINIT_VERTICAL)
            {
                DWORD elapsed = 0;
                SystemParametersInfo(SPI_GETMENUSHOWDELAY, 0, &elapsed, 0);
                SetTimer(TIMERID_HOTTRACK, elapsed);
                m_timerEnabled = TRUE;
                TRACE("SetTimer called with m_hotItem=%d\n", m_hotItem);
            }
        }
        else
        {
            TBBUTTONINFO info;
            info.cbSize = sizeof(info);
            info.dwMask = 0;
 
            int index = GetButtonInfo(item, &info);
 
            SetHotItem(index);
        }
    }
 
    InvalidateDraw();
    return S_OK;
}

Referenced by CMenuBand::_ChangeHotItem().

ChangePopupItem()

HRESULT CMenuToolbarBase::ChangePopupItem	(	CMenuToolbarBase *	toolbar,
		INT	item
	)

Definition at line 648 of file CMenuToolbars.cpp.

{
    // Ignore the change if it already matches the stored info
    if (m_popupBar == toolbar && m_popupItem == item)
        return S_FALSE;
 
    // Notify the toolbar if the popup-tracking this toolbar
    if (m_popupBar == this && toolbar != this)
    {
        CheckButton(m_popupItem, FALSE);
        m_isTrackingPopup = FALSE;
    }
 
    m_popupBar = toolbar;
    m_popupItem = item;
 
    if (m_popupBar == this)
    {
        CheckButton(m_popupItem, TRUE);
    }
 
    InvalidateDraw();
    return S_OK;
}

Referenced by CMenuBand::_ChangePopupItem().

ChangeTrackedItem()

LRESULT CMenuToolbarBase::ChangeTrackedItem ( UINT  uMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

private

Definition at line 696 of file CMenuToolbars.cpp.

{
    TBBUTTON btn;
    BOOL wasTracking = LOWORD(lParam);
    BOOL mouse = HIWORD(lParam);
    INT idx = (INT)wParam;
 
    if (idx < 0)
    {
        m_isTrackingPopup = FALSE;
        return m_menuBand->_ChangeHotItem(NULL, -1, HICF_MOUSE);
    }
 
    if (!GetButton(idx, &btn))
        return E_FAIL;
 
    TRACE("ChangeTrackedItem %d, %d\n", idx, wasTracking);
    m_isTrackingPopup = wasTracking;
    return m_menuBand->_ChangeHotItem(this, btn.idCommand, mouse ? HICF_MOUSE : 0);
}

ClearToolbar()

HRESULT CMenuToolbarBase::ClearToolbar ( )

protected

Definition at line 1067 of file CMenuToolbars.cpp.

{
    while (DeleteButton(0))
    {
        // empty;
    }
    m_hasSizes = FALSE;
    return S_OK;
}

Referenced by CMenuStaticToolbar::FillToolbar(), CMenuStaticToolbar::SetMenu(), CMenuSFToolbar::SetShellFolder(), and ~CMenuToolbarBase().

Close()

HRESULT CMenuToolbarBase::Close

(

)

Definition at line 368 of file CMenuToolbars.cpp.

{
    if (m_hWnd)
        DestroyWindow();
 
    if (m_pager.m_hWnd)
        m_pager.DestroyWindow();
 
    return S_OK;
}

Referenced by CMenuBand::CloseDW().

CreateToolbar()

HRESULT CMenuToolbarBase::CreateToolbar	(	HWND	hwndParent,
		DWORD	dwFlags
	)

Definition at line 379 of file CMenuToolbars.cpp.

{
    LONG tbStyles = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
        TBSTYLE_TOOLTIPS | TBSTYLE_TRANSPARENT | TBSTYLE_REGISTERDROP | TBSTYLE_LIST | TBSTYLE_FLAT | TBSTYLE_CUSTOMERASE |
        CCS_NODIVIDER | CCS_NOPARENTALIGN | CCS_NORESIZE | CCS_TOP;
    LONG tbExStyles = TBSTYLE_EX_DOUBLEBUFFER | WS_EX_TOOLWINDOW;
 
    if (dwFlags & SMINIT_VERTICAL)
    {
        // Activate vertical semantics
        tbStyles |= CCS_VERT;
 
#if USE_TBSTYLE_EX_VERTICAL
        tbExStyles |= TBSTYLE_EX_VERTICAL;
#endif
    }
 
    m_initFlags = dwFlags;
 
    // Get a temporary rect to use while creating the toolbar window.
    // Ensure that it is not a null rect.
    RECT rc;
    if (!::GetClientRect(hwndParent, &rc) ||
        (rc.left == rc.right) ||
        (rc.top == rc.bottom))
    {
        rc.left = 0;
        rc.top = 0;
        rc.right = 1;
        rc.bottom = 1;
    }
 
    // HACK & FIXME: CORE-17505
    HWND toolbar = CToolbar::Create(hwndParent, tbStyles, tbExStyles);
    m_hWnd = NULL;
    SubclassWindow(toolbar);
 
    SetWindowTheme(m_hWnd, L"", L"");
 
    SystemParametersInfo(SPI_GETFLATMENU, 0, &m_useFlatMenus, 0);
 
    m_menuBand->AdjustForTheme(m_useFlatMenus);
 
    // If needed, create the pager.
    if (m_usePager)
    {
        LONG pgStyles = PGS_VERT | WS_CHILD | WS_VISIBLE;
        LONG pgExStyles = 0;
 
        HWND hwndPager = CreateWindowEx(
            pgExStyles, WC_PAGESCROLLER, NULL,
            pgStyles, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top,
            hwndParent, NULL, _AtlBaseModule.GetModuleInstance(), 0);
 
        m_pager.SubclassWindow(hwndPager);
 
        ::SetParent(m_hWnd, hwndPager);
 
        m_pager.SendMessageW(PGM_SETCHILD, 0, reinterpret_cast<LPARAM>(m_hWnd));
    }
 
    // Configure the image lists
    UpdateImageLists();
 
    return S_OK;
}

Referenced by CMenuBand::SetMenu(), CMenuBand::SetShellFolder(), and CMenuBand::SetSite().

DisableMouseTrack()

HRESULT CMenuToolbarBase::DisableMouseTrack

(

BOOL

bDisable

)

Definition at line 128 of file CMenuToolbars.cpp.

{
    if (m_disableMouseTrack != bDisable)
    {
        m_disableMouseTrack = bDisable;
        TRACE("DisableMouseTrack %d\n", bDisable);
    }
    return S_OK;
}

Referenced by CMenuBand::_DisableMouseTrack().

ExecuteItem()

HRESULT CMenuToolbarBase::ExecuteItem

(

)

Definition at line 892 of file CMenuToolbars.cpp.

{
    return InternalExecuteItem(m_executeItem, m_executeItem, m_executeData);
}

FillToolbar()

virtual HRESULT CMenuToolbarBase::FillToolbar ( BOOL  clearFirst = FALSE )

pure virtual

Implemented in CMenuStaticToolbar, and CMenuSFToolbar.

GetDataFromId()

HRESULT CMenuToolbarBase::GetDataFromId	(	INT	iItem,
		INT *	pIndex,
		DWORD_PTR *	pData
	)

Definition at line 1077 of file CMenuToolbars.cpp.

{
    if (pData)
        *pData = NULL;
 
    if (pIndex)
        *pIndex = -1;
 
    if (iItem < 0)
        return S_OK;
 
    TBBUTTONINFO info = { 0 };
 
    info.cbSize = sizeof(TBBUTTONINFO);
    info.dwMask = TBIF_COMMAND | TBIF_LPARAM;
 
    int index = GetButtonInfo(iItem, &info);
    if (index < 0)
        return E_FAIL;
 
    if (pIndex)
        *pIndex = index;
 
    if (pData)
        *pData = info.lParam;
 
    return S_OK;
}

Referenced by OnGetInfoTip(), PopupItem(), PrepareExecuteItem(), and ProcessContextMenu().

GetSizes()

HRESULT CMenuToolbarBase::GetSizes	(	SIZE *	pMinSize,
		SIZE *	pMaxSize,
		SIZE *	pIntegralSize
	)

Definition at line 446 of file CMenuToolbars.cpp.

{
    if (pMinSize)
        *pMinSize = m_idealSize;
    if (pMaxSize)
        *pMaxSize = m_idealSize;
    if (pIntegralSize)
        *pIntegralSize = m_itemSize;
 
    if (m_hasSizes)
        return S_OK;
 
    TRACE("Sizes out of date, recalculating.\n");
 
    if (!m_hWnd)
    {
        return S_OK;
    }
 
    // Obtain the ideal size, to be used as min and max
    GetMaxSize(&m_idealSize);
    GetIdealSize((m_initFlags & SMINIT_VERTICAL) != 0, &m_idealSize);
 
    TRACE("Ideal Size: (%d, %d) for %d buttons\n", m_idealSize, GetButtonCount());
 
    // Obtain the button size, to be used as the integral size
    DWORD size = GetButtonSize();
    m_itemSize.cx = GET_X_LPARAM(size);
    m_itemSize.cy = GET_Y_LPARAM(size);
    m_hasSizes = TRUE;
 
    if (pMinSize)
        *pMinSize = m_idealSize;
    if (pMaxSize)
        *pMaxSize = m_idealSize;
    if (pIntegralSize)
        *pIntegralSize = m_itemSize;
 
    return S_OK;
}

Referenced by CMenuBand::GetBandInfo(), OnPagerCalcSize(), and CMenuBand::OnPosRectChangeDB().

GetToolbar()

HWND CMenuToolbarBase::GetToolbar ( )

inlineprotected

Definition at line 118 of file CMenuToolbars.h.

{ return m_hWnd; }

Referenced by CMenuSFToolbar::FillToolbar(), and CMenuSFToolbar::InternalContextMenu().

GetWindow()

HRESULT CMenuToolbarBase::GetWindow

(

HWND *

phwnd

)

Definition at line 518 of file CMenuToolbars.cpp.

{
    if (!phwnd)
        return E_FAIL;
 
    if (m_pager.m_hWnd)
        *phwnd = m_pager.m_hWnd;
    else
        *phwnd = m_hWnd;
 
    return S_OK;
}

Referenced by CMenuBand::GetWindow().

InternalContextMenu()

virtual HRESULT CMenuToolbarBase::InternalContextMenu ( INT  iItem, INT  index, DWORD_PTR  dwData, POINT  pt  )

protectedvirtual

Reimplemented in CMenuStaticToolbar, and CMenuSFToolbar.

Referenced by ProcessContextMenu().

InternalExecuteItem()

virtual HRESULT CMenuToolbarBase::InternalExecuteItem ( INT  iItem, INT  index, DWORD_PTR  dwData  )

protectedvirtual

Reimplemented in CMenuStaticToolbar, and CMenuSFToolbar.

Referenced by ExecuteItem().

InternalGetTooltip()

virtual HRESULT CMenuToolbarBase::InternalGetTooltip ( INT  iItem, INT  index, DWORD_PTR  dwData, LPWSTR  pszText, INT  cchTextMax  )

protectedvirtual

Reimplemented in CMenuStaticToolbar, and CMenuSFToolbar.

Referenced by OnGetInfoTip().

InternalHasSubMenu()

virtual HRESULT CMenuToolbarBase::InternalHasSubMenu ( INT  iItem, INT  index, DWORD_PTR  dwData  )

protectedvirtual

Reimplemented in CMenuStaticToolbar, and CMenuSFToolbar.

Referenced by PopupItem().

InternalPopupItem()

virtual HRESULT CMenuToolbarBase::InternalPopupItem ( INT  iItem, INT  index, DWORD_PTR  dwData, BOOL  keyInitiated  )

protectedvirtual

Reimplemented in CMenuStaticToolbar, and CMenuSFToolbar.

Referenced by PopupItem().

InvalidateDraw()

void CMenuToolbarBase::InvalidateDraw

(

)

Definition at line 311 of file CMenuToolbars.cpp.

{
    InvalidateRect(NULL, FALSE);
}

Referenced by ChangeHotItem(), and ChangePopupItem().

IsTrackedItem()

LRESULT CMenuToolbarBase::IsTrackedItem ( UINT  uMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

private

Definition at line 673 of file CMenuToolbars.cpp.

{
    TBBUTTON btn;
    INT idx = (INT)wParam;
 
    if (m_hotBar != this)
        return S_FALSE;
 
    if (idx < 0)
        return S_FALSE;
 
    if (!GetButton(idx, &btn))
        return E_FAIL;
 
    if (m_hotItem == btn.idCommand)
        return S_OK;
 
    if (m_popupItem == btn.idCommand)
        return S_OK;
 
    return S_FALSE;
}

IsWindowOwner()

HRESULT CMenuToolbarBase::IsWindowOwner

(

HWND

hwnd

)

Definition at line 511 of file CMenuToolbars.cpp.

{
    if (m_hWnd && m_hWnd == hwnd) return S_OK;
    if (m_pager.m_hWnd && m_pager.m_hWnd == hwnd) return S_OK;
    return S_FALSE;
}

Referenced by CMenuBand::_MenuBarMouseDown(), CMenuBand::_MenuBarMouseUp(), CMenuBand::IsWindowOwner(), and CMenuBand::OnWinEvent().

KeyboardItemChange()

HRESULT CMenuToolbarBase::KeyboardItemChange

(

DWORD

changeType

)

Definition at line 897 of file CMenuToolbars.cpp.

{
    int prev = m_hotItem;
    int index = -1;
 
    if (dwSelectType != 0xFFFFFFFF)
    {
        int count = GetButtonCount();
 
        if (dwSelectType == VK_HOME)
        {
            index = 0;
            dwSelectType = VK_DOWN;
        }
        else if (dwSelectType == VK_END)
        {
            index = count - 1;
            dwSelectType = VK_UP;
        }
        else
        {
            if (m_hotItem >= 0)
            {
                TBBUTTONINFO info = { 0 };
                info.cbSize = sizeof(TBBUTTONINFO);
                info.dwMask = 0;
                index = GetButtonInfo(m_hotItem, &info);
            }
 
            if (index < 0)
            {
                if (dwSelectType == VK_UP)
                {
                    index = count - 1;
                }
                else if (dwSelectType == VK_DOWN)
                {
                    index = 0;
                }
            }
            else
            {
                if (dwSelectType == VK_UP)
                {
                    index--;
                }
                else if (dwSelectType == VK_DOWN)
                {
                    index++;
                }
            }
        }
 
        TBBUTTON btn = { 0 };
        while (index >= 0 && index < count)
        {
            DWORD res = GetButton(index, &btn);
            if (!res)
                return E_FAIL;
 
            if (btn.dwData)
            {
                if (prev != btn.idCommand)
                {
                    TRACE("Setting Hot item to %d\n", index);
                    if (!(m_initFlags & SMINIT_VERTICAL) && m_isTrackingPopup)
                    {
                        HWND tlw;
                        m_menuBand->_GetTopLevelWindow(&tlw);
                        ::SendMessageW(tlw, WM_CANCELMODE, 0, 0);
                        PostMessageW(WM_USER_CHANGETRACKEDITEM, index, MAKELPARAM(m_isTrackingPopup, FALSE));
                    }
                    else
                        m_menuBand->_ChangeHotItem(this, btn.idCommand, 0);
                }
                return S_OK;
            }
 
            if (dwSelectType == VK_UP)
            {
                index--;
            }
            else if (dwSelectType == VK_DOWN)
            {
                index++;
            }
        }
 
        return S_FALSE;
    }
 
    if (prev != -1)
    {
        TRACE("Setting Hot item to null\n");
        m_menuBand->_ChangeHotItem(NULL, -1, 0);
    }
 
    return S_FALSE;
}

KillPopupTimer()

HRESULT CMenuToolbarBase::KillPopupTimer

(

)

Definition at line 577 of file CMenuToolbars.cpp.

{
    if (m_timerEnabled)
    {
        m_timerEnabled = FALSE;
        KillTimer(TIMERID_HOTTRACK);
        return S_OK;
    }
    return S_FALSE;
}

Referenced by CMenuBand::_KillPopupTimers().

MenuBarMouseDown()

HRESULT CMenuToolbarBase::MenuBarMouseDown	(	INT	iIndex,
		BOOL	isLButton
	)

Definition at line 850 of file CMenuToolbars.cpp.

{
    TBBUTTON btn;
 
    GetButton(iIndex, &btn);
 
    if ((m_initFlags & SMINIT_VERTICAL)
        || m_popupBar
        || m_cancelingPopup)
    {
        m_cancelingPopup = FALSE;
        return S_OK;
    }
 
    return ProcessClick(btn.idCommand);
}

Referenced by CMenuBand::_MenuBarMouseDown().

MenuBarMouseUp()

HRESULT CMenuToolbarBase::MenuBarMouseUp	(	INT	iIndex,
		BOOL	isLButton
	)

Definition at line 867 of file CMenuToolbars.cpp.

{
    TBBUTTON btn;
 
    m_cancelingPopup = FALSE;
 
    if (!(m_initFlags & SMINIT_VERTICAL))
        return S_OK;
 
    GetButton(iIndex, &btn);
 
    if (isLButton)
        return ProcessClick(btn.idCommand);
    else
        return ProcessContextMenu(btn.idCommand);
}

Referenced by CMenuBand::_MenuBarMouseUp().

OnCustomDraw()

HRESULT CMenuToolbarBase::OnCustomDraw ( LPNMTBCUSTOMDRAW  cdraw, LRESULT *  theResult  )

private

Definition at line 153 of file CMenuToolbars.cpp.

{
    bool     isHot, isPopup, isActive;
    TBBUTTONINFO btni;
 
    switch (cdraw->nmcd.dwDrawStage)
    {
    case CDDS_PREPAINT:
        *theResult = CDRF_NOTIFYITEMDRAW;
        return S_OK;
 
    case CDDS_ITEMPREPAINT:
 
        HWND tlw;
        m_menuBand->_GetTopLevelWindow(&tlw);
 
        // The item with an active submenu gets the CHECKED flag.
        isHot = m_hotBar == this && (int) cdraw->nmcd.dwItemSpec == m_hotItem;
        isPopup = m_popupBar == this && (int) cdraw->nmcd.dwItemSpec == m_popupItem;
        isActive = (GetForegroundWindow() == tlw) || (m_popupBar == this);
 
        if (m_hotItem < 0 && isPopup)
            isHot = TRUE;
 
        if ((m_useFlatMenus && isHot) || (m_initFlags & SMINIT_VERTICAL))
        {
            COLORREF clrText;
            HBRUSH   bgBrush;
            RECT rc = cdraw->nmcd.rc;
            HDC hdc = cdraw->nmcd.hdc;
 
            // Remove HOT and CHECKED flags (will restore HOT if necessary)
            cdraw->nmcd.uItemState &= ~(CDIS_HOT | CDIS_CHECKED);
 
            // Decide on the colors
            if (isHot)
            {
                cdraw->nmcd.uItemState |= CDIS_HOT;
 
                clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
                bgBrush = GetSysColorBrush(m_useFlatMenus ? COLOR_MENUHILIGHT : COLOR_HIGHLIGHT);
            }
            else
            {
                clrText = GetSysColor(COLOR_MENUTEXT);
                bgBrush = GetSysColorBrush(COLOR_MENU);
            }
 
            // Paint the background color with the selected color
            FillRect(hdc, &rc, bgBrush);
 
            // Set the text color in advance, this color will be assigned when the ITEMPOSTPAINT triggers
            SetTextColor(hdc, clrText);
 
            // Set the text color, will be used by the internal drawing code
            cdraw->clrText = clrText;
            cdraw->iListGap += 4;
 
            // Tell the default drawing code we don't want any fanciness, not even a background.
            *theResult = CDRF_NOTIFYPOSTPAINT | TBCDRF_NOBACKGROUND | TBCDRF_NOEDGES | TBCDRF_NOOFFSET | TBCDRF_NOMARK | 0x00800000; // FIXME: the last bit is Vista+, useful for debugging only
        }
        else
        {
            // Set the text color, will be used by the internal drawing code
            cdraw->clrText = GetSysColor(isActive ? COLOR_MENUTEXT : COLOR_GRAYTEXT);
 
            // Remove HOT and CHECKED flags (will restore HOT if necessary)
            cdraw->nmcd.uItemState &= ~CDIS_HOT;
 
            // Decide on the colors
            if (isHot)
            {
                cdraw->nmcd.uItemState |= CDIS_HOT;
            }
 
            *theResult = 0;
        }
 
        return S_OK;
 
    case CDDS_ITEMPOSTPAINT:
 
        // Fetch the button style
        btni.cbSize = sizeof(btni);
        btni.dwMask = TBIF_STYLE;
        GetButtonInfo(cdraw->nmcd.dwItemSpec, &btni);
 
        // Check if we need to draw a submenu arrow
        if (btni.fsStyle & BTNS_DROPDOWN)
        {
            // TODO: Support RTL text modes by drawing a leftwards arrow aligned to the left of the control
 
            // "8" is the rightwards dropdown arrow in the Marlett font
            WCHAR text [] = L"8";
 
            // Configure the font to draw with Marlett, keeping the current background color as-is
            HGDIOBJ hFontOld = SelectObject(cdraw->nmcd.hdc, m_marlett);
            SetBkMode(cdraw->nmcd.hdc, TRANSPARENT);
 
            // Tweak the alignment by 1 pixel so the menu draws like the Windows start menu.
            RECT rc = cdraw->nmcd.rc;
            rc.right += 1;
 
            // The arrow is drawn at the right of the item's rect, aligned vertically.
            DrawTextEx(cdraw->nmcd.hdc, text, 1, &rc, DT_NOCLIP | DT_VCENTER | DT_RIGHT | DT_SINGLELINE, NULL);
 
            SelectObject(cdraw->nmcd.hdc, hFontOld);
        }
        *theResult = TRUE;
        return S_OK;
 
    default:
        *theResult = 0L;
        break;
    }
    return S_OK;
}

Referenced by OnWinEvent().

OnDeletingButton()

virtual HRESULT CMenuToolbarBase::OnDeletingButton ( const NMTOOLBAR *  tb )

protectedvirtual

Reimplemented in CMenuStaticToolbar, and CMenuSFToolbar.

Referenced by OnWinEvent().

OnGetInfoTip()

HRESULT CMenuToolbarBase::OnGetInfoTip ( NMTBGETINFOTIP *  tip )

private

Definition at line 531 of file CMenuToolbars.cpp.

{
    INT index;
    DWORD_PTR dwData;
 
    INT iItem = tip->iItem;
 
    GetDataFromId(iItem, &index, &dwData);
 
    return InternalGetTooltip(iItem, index, dwData, tip->pszText, tip->cchTextMax);
}

Referenced by OnWinEvent().

OnPagerCalcSize()

HRESULT CMenuToolbarBase::OnPagerCalcSize ( LPNMPGCALCSIZE  csize )

private

Definition at line 138 of file CMenuToolbars.cpp.

{
    SIZE tbs;
    GetSizes(NULL, &tbs, NULL);
    if (csize->dwFlag == PGF_CALCHEIGHT)
    {
        csize->iHeight = tbs.cy;
    }
    else if (csize->dwFlag == PGF_CALCWIDTH)
    {
        csize->iWidth = tbs.cx;
    }
    return S_OK;
}

Referenced by OnWinEvent().

OnPopupTimer()

HRESULT CMenuToolbarBase::OnPopupTimer ( UINT  uMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

private

Definition at line 543 of file CMenuToolbars.cpp.

{
    if (wParam != TIMERID_HOTTRACK)
    {
        bHandled = FALSE;
        return 0;
    }
 
    KillTimer(TIMERID_HOTTRACK);
 
    if (!m_timerEnabled)
        return 0;
 
    m_timerEnabled = FALSE;
 
    if (m_hotItem < 0)
        return 0;
 
    // Returns S_FALSE if the current item did not show a submenu
    HRESULT hr = PopupItem(m_hotItem, FALSE);
    if (hr != S_FALSE)
        return 0;
 
    // If we didn't switch submenus, cancel the current popup regardless
    if (m_popupBar)
    {
        HRESULT hr = CancelCurrentPopup();
        if (FAILED_UNEXPECTEDLY(hr))
            return 0;
    }
 
    return 0;
}

OnWinEvent()

HRESULT CMenuToolbarBase::OnWinEvent	(	HWND	hWnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		LRESULT *	theResult
	)

Definition at line 46 of file CMenuToolbars.cpp.

{
    NMHDR * hdr;
    HRESULT hr;
    LRESULT result;
 
    if (theResult)
        *theResult = 0;
    switch (uMsg)
    {
    case WM_COMMAND:
        //return OnCommand(wParam, lParam, theResult);
        return S_OK;
 
    case WM_NOTIFY:
        hdr = reinterpret_cast<LPNMHDR>(lParam);
        switch (hdr->code)
        {
        case TBN_DELETINGBUTTON:
            return OnDeletingButton(reinterpret_cast<LPNMTOOLBAR>(hdr));
 
        case PGN_CALCSIZE:
            return OnPagerCalcSize(reinterpret_cast<LPNMPGCALCSIZE>(hdr));
 
        case TBN_DROPDOWN:
            return ProcessClick(reinterpret_cast<LPNMTOOLBAR>(hdr)->iItem);
 
        case TBN_HOTITEMCHANGE:
            //return OnHotItemChange(reinterpret_cast<LPNMTBHOTITEM>(hdr), theResult);
            return S_OK;
 
        case NM_CUSTOMDRAW:
            hr = OnCustomDraw(reinterpret_cast<LPNMTBCUSTOMDRAW>(hdr), &result);
            if (theResult)
                *theResult = result;
            return hr;
 
        case TBN_GETINFOTIP:
            return OnGetInfoTip(reinterpret_cast<LPNMTBGETINFOTIP>(hdr));
 
            // Silence unhandled items so that they don't print as unknown
        case RBN_CHILDSIZE:
            return S_OK;
 
        case TTN_GETDISPINFO:
            return S_OK;
 
        case NM_RELEASEDCAPTURE:
            break;
 
        case NM_CLICK:
        case NM_RDOWN:
        case NM_LDOWN:
            break;
 
        case TBN_GETDISPINFO:
            break;
 
        case TBN_BEGINDRAG:
        case TBN_ENDDRAG:
            break;
 
        case NM_TOOLTIPSCREATED:
            break;
 
        case TBN_DRAGOUT: return S_FALSE;
 
        default:
            TRACE("WM_NOTIFY unknown code %d, %d\n", hdr->code, hdr->idFrom);
            return S_OK;
        }
        return S_FALSE;
    case WM_WININICHANGE:
        if (wParam == SPI_SETFLATMENU)
        {
            SystemParametersInfo(SPI_GETFLATMENU, 0, &m_useFlatMenus, 0);
        }
    }
 
    return S_FALSE;
}

Referenced by CMenuBand::OnWinEvent(), and OnWinEventWrap().

OnWinEventWrap()

LRESULT CMenuToolbarBase::OnWinEventWrap ( UINT  uMsg, WPARAM  wParam, LPARAM  lParam, BOOL &  bHandled  )

private

Definition at line 39 of file CMenuToolbars.cpp.

{
    LRESULT lr;
    bHandled = OnWinEvent(m_hWnd, uMsg, wParam, lParam, &lr) != S_FALSE;
    return lr;
}

PopupItem()

HRESULT CMenuToolbarBase::PopupItem	(	INT	iItem,
		BOOL	keyInitiated
	)

Definition at line 1111 of file CMenuToolbars.cpp.

{
    INT index;
    DWORD_PTR dwData;
 
    if (iItem < 0)
        return S_OK;
 
    if (m_popupBar == this && m_popupItem == iItem)
        return S_OK;
 
    GetDataFromId(iItem, &index, &dwData);
 
    HRESULT hr = InternalHasSubMenu(iItem, index, dwData);
    if (hr != S_OK)
        return hr;
 
    if (m_popupBar)
    {
        HRESULT hr = CancelCurrentPopup();
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
    }
 
    if (!(m_initFlags & SMINIT_VERTICAL))
    {
        TRACE("PopupItem non-vertical %d %d\n", index, iItem);
        m_menuBand->_ChangeHotItem(this, iItem, 0);
    }
 
    return InternalPopupItem(iItem, index, dwData, keyInitiated);
}

Referenced by CMenuBand::_MenuItemSelect(), ChangeHotItem(), OnPopupTimer(), and ProcessClick().

PopupSubMenu() [1/2]

HRESULT CMenuToolbarBase::PopupSubMenu	(	UINT	itemId,
		UINT	index,
		HMENU	menu
	)

Definition at line 758 of file CMenuToolbars.cpp.

{
    // Calculate the submenu position and exclude area
    RECT rc = { 0 };
 
    if (!GetItemRect(index, &rc))
        return E_FAIL;
 
    POINT a = { rc.left, rc.top };
    POINT b = { rc.right, rc.bottom };
 
    ClientToScreen(&a);
    ClientToScreen(&b);
 
    POINT pt = { a.x, b.y };
    RECT rcl = { a.x, a.y, b.x, b.y };
 
    if (m_initFlags & SMINIT_VERTICAL)
    {
        pt.x = b.x;
        pt.y = a.y;
    }
 
    HMENU popup = GetSubMenu(menu, index);
 
    // Display the submenu
    m_isTrackingPopup = TRUE;
    m_menuBand->_ChangePopupItem(this, iItem);
    m_menuBand->_TrackSubMenu(popup, pt.x, pt.y, rcl);
    m_menuBand->_ChangePopupItem(NULL, -1);
    m_isTrackingPopup = FALSE;
 
    return S_OK;
}

PopupSubMenu() [2/2]

HRESULT CMenuToolbarBase::PopupSubMenu	(	UINT	itemId,
		UINT	index,
		IShellMenu *	childShellMenu,
		BOOL	keyInitiated
	)

Definition at line 717 of file CMenuToolbars.cpp.

{
    // Calculate the submenu position and exclude area
    RECT rc = { 0 };
 
    if (!GetItemRect(index, &rc))
        return E_FAIL;
 
    POINT a = { rc.left, rc.top };
    POINT b = { rc.right, rc.bottom };
 
    ClientToScreen(&a);
    ClientToScreen(&b);
 
    POINTL pt = { a.x, b.y };
    RECTL rcl = { a.x, a.y, b.x, b.y };
 
    if (m_initFlags & SMINIT_VERTICAL)
    {
        // FIXME: Hardcoding this here feels hacky.
        if (IsAppThemed())
        {
            pt.x = b.x - 1;
            pt.y = a.y - 1;
        }
        else
        {
            pt.x = b.x - 3;
            pt.y = a.y - 3;
        }
    }
 
    // Display the submenu
    m_isTrackingPopup = TRUE;
 
    m_menuBand->_ChangePopupItem(this, iItem);
    m_menuBand->_OnPopupSubMenu(childShellMenu, &pt, &rcl, keyInitiated);
 
    return S_OK;
}

Referenced by CMenuStaticToolbar::InternalPopupItem(), and CMenuSFToolbar::InternalPopupItem().

PrepareExecuteItem()

HRESULT CMenuToolbarBase::PrepareExecuteItem

(

INT

iItem

)

Definition at line 884 of file CMenuToolbars.cpp.

{
    this->m_menuBand->_KillPopupTimers();
 
    m_executeItem = iItem;
    return GetDataFromId(iItem, &m_executeIndex, &m_executeData);
}

ProcessClick()

HRESULT CMenuToolbarBase::ProcessClick

(

INT

iItem

)

Definition at line 811 of file CMenuToolbars.cpp.

{
    if (m_disableMouseTrack)
    {
        TRACE("Item click prevented by DisableMouseTrack\n");
        return S_OK;
    }
 
    // If a button is clicked while a submenu was open, cancel the submenu.
    if (!(m_initFlags & SMINIT_VERTICAL) && m_isTrackingPopup)
    {
        TRACE("OnCommand cancelled because it was tracking submenu.\n");
        return S_FALSE;
    }
 
    if (PopupItem(iItem, FALSE) == S_OK)
    {
        TRACE("PopupItem returned S_OK\n");
        return S_FALSE;
    }
 
    TRACE("Executing...\n");
 
    return m_menuBand->_MenuItemSelect(MPOS_EXECUTE);
}

Referenced by MenuBarMouseDown(), MenuBarMouseUp(), and OnWinEvent().

ProcessContextMenu()

HRESULT CMenuToolbarBase::ProcessContextMenu

(

INT

iItem

)

Definition at line 837 of file CMenuToolbars.cpp.

{
    INT index;
    DWORD_PTR data;
 
    GetDataFromId(iItem, &index, &data);
 
    DWORD pos = GetMessagePos();
    POINT pt = { GET_X_LPARAM(pos), GET_Y_LPARAM(pos) };
 
    return InternalContextMenu(iItem, index, data, pt);
}

Referenced by MenuBarMouseUp().

SetPosSize()

HRESULT CMenuToolbarBase::SetPosSize	(	int	x,
		int	y,
		int	cx,
		int	cy
	)

Definition at line 487 of file CMenuToolbars.cpp.

{
    // Update the toolbar or pager to fit the requested rect
    // If we have a pager, set the toolbar height to the ideal height of the toolbar
    if (m_pager.m_hWnd)
    {
        SetWindowPos(NULL, x, y, cx, m_idealSize.cy, 0);
        m_pager.SetWindowPos(NULL, x, y, cx, cy, 0);
    }
    else
    {
        SetWindowPos(NULL, x, y, cx, cy, 0);
    }
 
    // In a vertical menu, resize the buttons to fit the width
    if (m_initFlags & SMINIT_VERTICAL)
    {
        DWORD btnSize = GetButtonSize();
        SetButtonSize(cx, GET_Y_LPARAM(btnSize));
    }
 
    return S_OK;
}

Referenced by CMenuBand::OnPosRectChangeDB().

ShowDW()

HRESULT CMenuToolbarBase::ShowDW

(

BOOL

fShow

)

Definition at line 316 of file CMenuToolbars.cpp.

{
    if (m_hWnd == NULL)
        return S_FALSE;
 
    ShowWindow(fShow ? SW_SHOW : SW_HIDE);
 
    // Ensure that the right image list is assigned to the toolbar
    UpdateImageLists();
 
    // For custom-drawing
    SystemParametersInfo(SPI_GETFLATMENU, 0, &m_useFlatMenus, 0);
 
    return S_OK;
}

Referenced by CMenuBand::ShowDW().

TrackContextMenu()

HRESULT CMenuToolbarBase::TrackContextMenu	(	IContextMenu *	contextMenu,
		POINT	pt
	)

Definition at line 793 of file CMenuToolbars.cpp.

{
    // Cancel submenus
    m_menuBand->_KillPopupTimers();
    if (m_popupBar)
        m_menuBand->_CancelCurrentPopup();
 
    // Display the context menu
    return m_menuBand->_TrackContextMenu(contextMenu, pt.x, pt.y);
}

Referenced by CMenuStaticToolbar::InternalContextMenu(), and CMenuSFToolbar::InternalContextMenu().

UpdateImageLists()

HRESULT CMenuToolbarBase::UpdateImageLists ( )

private

Definition at line 332 of file CMenuToolbars.cpp.

{
    if ((m_initFlags & (SMINIT_TOPLEVEL | SMINIT_VERTICAL)) == SMINIT_TOPLEVEL) // not vertical.
    {
        // No image list, prevents the buttons from having a margin at the left side
        SetImageList(NULL);
        return S_OK;
    }
 
    // Assign the correct imagelist and padding based on the current icon size
 
    int shiml;
    if (m_menuBand->UseBigIcons())
    {
        shiml = SHIL_LARGE;
        SetPadding(4, 0);
    }
    else
    {
        shiml = SHIL_SMALL;
        SetPadding(4, 4);
    }
 
    IImageList * piml;
    HRESULT hr = SHGetImageList(shiml, IID_PPV_ARG(IImageList, &piml));
    if (FAILED_UNEXPECTEDLY(hr))
    {
        SetImageList(NULL);
    }
    else
    {
        SetImageList((HIMAGELIST)piml);
    }
    return S_OK;
}

Referenced by CreateToolbar(), and ShowDW().

Member Data Documentation

m_cancelingPopup

BOOL CMenuToolbarBase::m_cancelingPopup

protected

Definition at line 57 of file CMenuToolbars.h.

Referenced by BeforeCancelPopup(), MenuBarMouseDown(), and MenuBarMouseUp().

m_disableMouseTrack

BOOL CMenuToolbarBase::m_disableMouseTrack

private

Definition at line 35 of file CMenuToolbars.h.

Referenced by ChangeHotItem(), DisableMouseTrack(), and ProcessClick().

m_dwMenuFlags

DWORD CMenuToolbarBase::m_dwMenuFlags

protected

Definition at line 40 of file CMenuToolbars.h.

Referenced by CMenuStaticToolbar::GetMenu(), CMenuSFToolbar::GetShellFolder(), CMenuStaticToolbar::SetMenu(), and CMenuSFToolbar::SetShellFolder().

m_executeData

DWORD_PTR CMenuToolbarBase::m_executeData

protected

Definition at line 55 of file CMenuToolbars.h.

Referenced by ExecuteItem(), and PrepareExecuteItem().

m_executeIndex

INT CMenuToolbarBase::m_executeIndex

protected

Definition at line 53 of file CMenuToolbars.h.

Referenced by PrepareExecuteItem().

m_executeItem

INT CMenuToolbarBase::m_executeItem

protected

Definition at line 54 of file CMenuToolbars.h.

Referenced by ExecuteItem(), and PrepareExecuteItem().

m_hasSizes

BOOL CMenuToolbarBase::m_hasSizes

protected

Definition at line 41 of file CMenuToolbars.h.

Referenced by AddButton(), AddPlaceholder(), AddSeparator(), ClearToolbar(), and GetSizes().

m_hotBar

CMenuToolbarBase* CMenuToolbarBase::m_hotBar

protected

Definition at line 45 of file CMenuToolbars.h.

Referenced by ChangeHotItem(), IsTrackedItem(), and OnCustomDraw().

m_hotItem

INT CMenuToolbarBase::m_hotItem

protected

Definition at line 46 of file CMenuToolbars.h.

Referenced by ChangeHotItem(), IsTrackedItem(), KeyboardItemChange(), OnCustomDraw(), and OnPopupTimer().

m_idealSize

SIZE CMenuToolbarBase::m_idealSize

protected

Definition at line 42 of file CMenuToolbars.h.

Referenced by CMenuToolbarBase(), GetSizes(), and SetPosSize().

m_initFlags

DWORD CMenuToolbarBase::m_initFlags

protected

Definition at line 50 of file CMenuToolbars.h.

Referenced by AddButton(), AddSeparator(), ChangeHotItem(), CreateToolbar(), GetSizes(), KeyboardItemChange(), MenuBarMouseDown(), MenuBarMouseUp(), OnCustomDraw(), PopupItem(), PopupSubMenu(), ProcessClick(), SetPosSize(), and UpdateImageLists().

m_isTrackingPopup

BOOL CMenuToolbarBase::m_isTrackingPopup

protected

Definition at line 51 of file CMenuToolbars.h.

Referenced by ChangeHotItem(), ChangePopupItem(), ChangeTrackedItem(), KeyboardItemChange(), PopupSubMenu(), and ProcessClick().

m_itemSize

SIZE CMenuToolbarBase::m_itemSize

protected

Definition at line 43 of file CMenuToolbars.h.

Referenced by CMenuToolbarBase(), and GetSizes().

m_marlett

HFONT CMenuToolbarBase::m_marlett

private

Definition at line 33 of file CMenuToolbars.h.

Referenced by CMenuToolbarBase(), OnCustomDraw(), and ~CMenuToolbarBase().

m_menuBand

CMenuBand* CMenuToolbarBase::m_menuBand

protected

Definition at line 39 of file CMenuToolbars.h.

Referenced by CancelCurrentPopup(), ChangeTrackedItem(), CreateToolbar(), CMenuStaticToolbar::FillToolbar(), CMenuSFToolbar::FillToolbar(), CMenuStaticToolbar::InternalContextMenu(), CMenuStaticToolbar::InternalExecuteItem(), CMenuSFToolbar::InternalExecuteItem(), CMenuStaticToolbar::InternalPopupItem(), CMenuSFToolbar::InternalPopupItem(), KeyboardItemChange(), OnCustomDraw(), PopupItem(), PopupSubMenu(), PrepareExecuteItem(), ProcessClick(), TrackContextMenu(), and UpdateImageLists().

m_pager

CContainedWindow CMenuToolbarBase::m_pager

private

Definition at line 31 of file CMenuToolbars.h.

Referenced by Close(), CreateToolbar(), GetWindow(), IsWindowOwner(), SetPosSize(), and ~CMenuToolbarBase().

m_popupBar

CMenuToolbarBase* CMenuToolbarBase::m_popupBar

protected

Definition at line 47 of file CMenuToolbars.h.

Referenced by ChangePopupItem(), MenuBarMouseDown(), OnCustomDraw(), OnPopupTimer(), PopupItem(), and TrackContextMenu().

m_popupItem

INT CMenuToolbarBase::m_popupItem

protected

Definition at line 48 of file CMenuToolbars.h.

Referenced by ChangePopupItem(), IsTrackedItem(), OnCustomDraw(), and PopupItem().

m_timerEnabled

BOOL CMenuToolbarBase::m_timerEnabled

private

Definition at line 36 of file CMenuToolbars.h.

Referenced by ChangeHotItem(), KillPopupTimer(), and OnPopupTimer().

m_useFlatMenus

BOOL CMenuToolbarBase::m_useFlatMenus

private

Definition at line 34 of file CMenuToolbars.h.

Referenced by CreateToolbar(), OnCustomDraw(), OnWinEvent(), and ShowDW().

m_usePager

BOOL CMenuToolbarBase::m_usePager

protected

Definition at line 44 of file CMenuToolbars.h.

Referenced by CreateToolbar().

---

The documentation for this class was generated from the following files:

• dll/win32/shell32/shellmenu/CMenuToolbars.h
• dll/win32/shell32/shellmenu/CMenuToolbars.cpp