CMenuFocusManager Class Reference

#include <CMenuFocusManager.h>

Inheritance diagram for CMenuFocusManager:

Collaboration diagram for CMenuFocusManager:

Classes
struct	StackEntry

Public Member Functions
HRESULT	PushMenuBar (CMenuBand *mb)
HRESULT	PushMenuPopup (CMenuBand *mb)
HRESULT	PushTrackedPopup (HMENU popup)
HRESULT	PopMenuBar (CMenuBand *mb)
HRESULT	PopMenuPopup (CMenuBand *mb)
HRESULT	PopTrackedPopup (HMENU popup)
Public Member Functions inherited from ATL::CComObjectRootEx< CComMultiThreadModelNoCS >
	~CComObjectRootEx ()
ULONG	InternalAddRef ()
ULONG	InternalRelease ()
void	Lock ()
void	Unlock ()
HRESULT	_AtlInitialConstruct ()
Public Member Functions inherited from ATL::CComObjectRootBase
	CComObjectRootBase ()
	~CComObjectRootBase ()
void	SetVoid (void *)
HRESULT	_AtlFinalConstruct ()
HRESULT	FinalConstruct ()
void	InternalFinalConstructAddRef ()
void	InternalFinalConstructRelease ()
void	FinalRelease ()

Static Public Member Functions
static CMenuFocusManager *	AcquireManager ()
static void	ReleaseManager (CMenuFocusManager *obj)
Static Public Member Functions inherited from ATL::CComObjectRootBase
static void WINAPI	ObjectMain (bool)
static const struct _ATL_CATMAP_ENTRY *	GetCategoryMap ()
static HRESULT WINAPI	InternalQueryInterface (void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)

Protected Member Functions
	CMenuFocusManager ()
	~CMenuFocusManager ()

Private Types
enum	StackEntryType { NoEntry , MenuBarEntry , MenuPopupEntry , TrackedMenuEntry }

Private Member Functions
HRESULT	PushToArray (StackEntryType type, CMenuBand *mb, HMENU hmenu)
HRESULT	PopFromArray (StackEntryType *pType, CMenuBand **pMb, HMENU *pHmenu)
LRESULT	GetMsgHook (INT nCode, WPARAM wParam, LPARAM lParam)
LRESULT	MsgFilterHook (INT nCode, WPARAM wParam, LPARAM lParam)
HRESULT	PlaceHooks ()
HRESULT	RemoveHooks ()
HRESULT	UpdateFocus ()
HRESULT	IsTrackedWindow (HWND hWnd, StackEntry **pentry=NULL)
HRESULT	IsTrackedWindowOrParent (HWND hWnd)
void	DisableMouseTrack (HWND parent, BOOL disableThis)
void	SetMenuCapture (HWND child)
LRESULT	ProcessMouseMove (MSG *msg)
LRESULT	ProcessMouseDown (MSG *msg, BOOL isLButton)
LRESULT	ProcessMouseUp (MSG *msg, BOOL isLButton)

Static Private Member Functions
static CMenuFocusManager *	GetManager ()
static LRESULT CALLBACK	s_MsgFilterHook (INT nCode, WPARAM wParam, LPARAM lParam)
static LRESULT CALLBACK	s_GetMsgHook (INT nCode, WPARAM wParam, LPARAM lParam)

Private Attributes
StackEntry *	m_current
StackEntry *	m_parent
StackEntry *	m_menuBar
HHOOK	m_hMsgFilterHook
HHOOK	m_hGetMsgHook
DWORD	m_threadId
BOOL	m_mouseTrackDisabled
POINT	m_ptPrev
HWND	m_captureHwnd
HWND	m_hwndUnderMouse
StackEntry *	m_entryUnderMouse
HMENU	m_selectedMenu
INT	m_selectedItem
DWORD	m_selectedItemFlags
BOOL	m_movedSinceDown
HWND	m_windowAtDown
HWND	m_PreviousForeground
StackEntry	m_bandStack [MAX_RECURSE]
int	m_bandCount
int	m_menuDepth

Static Private Attributes
static DWORD	TlsIndex = 0

Additional Inherited Members
Public Attributes inherited from ATL::CComObjectRootBase
LONG	m_dwRef

Detailed Description

Definition at line 24 of file CMenuFocusManager.h.

Member Enumeration Documentation

StackEntryType

enum CMenuFocusManager::StackEntryType

private

Enumerator
NoEntry
MenuBarEntry
MenuPopupEntry
TrackedMenuEntry

Definition at line 33 of file CMenuFocusManager.h.

    {
        NoEntry,
        MenuBarEntry,
        MenuPopupEntry,
        TrackedMenuEntry
    };

Constructor & Destructor Documentation

CMenuFocusManager()

CMenuFocusManager::CMenuFocusManager ( )

protected

Definition at line 176 of file CMenuFocusManager.cpp.

                                     :
    m_current(NULL),
    m_parent(NULL),
    m_hMsgFilterHook(NULL),
    m_hGetMsgHook(NULL),
    m_mouseTrackDisabled(FALSE),
    m_captureHwnd(0),
    m_hwndUnderMouse(NULL),
    m_entryUnderMouse(NULL),
    m_selectedMenu(NULL),
    m_selectedItem(0),
    m_selectedItemFlags(0),
    m_movedSinceDown(FALSE),
    m_windowAtDown(NULL),
    m_PreviousForeground(NULL),
    m_bandCount(0),
    m_menuDepth(0)
{
    m_ptPrev.x = 0;
    m_ptPrev.y = 0;
    m_threadId = GetCurrentThreadId();
}

~CMenuFocusManager()

CMenuFocusManager::~CMenuFocusManager ( )

protected

Definition at line 199 of file CMenuFocusManager.cpp.

{
}

Member Function Documentation

AcquireManager()

CMenuFocusManager * CMenuFocusManager::AcquireManager ( )

static

Definition at line 97 of file CMenuFocusManager.cpp.

{
    CMenuFocusManager * obj = NULL;
 
    if (!TlsIndex)
    {
        if ((TlsIndex = TlsAlloc()) == TLS_OUT_OF_INDEXES)
            return NULL;
    }
 
    obj = GetManager();
 
    if (!obj)
    {
        obj = new CComObject<CMenuFocusManager>();
        TlsSetValue(TlsIndex, obj);
    }
 
    obj->AddRef();
 
    return obj;
}

Referenced by CMenuBand::CMenuBand().

DisableMouseTrack()

void CMenuFocusManager::DisableMouseTrack ( HWND  parent, BOOL  disableThis  )

private

Definition at line 204 of file CMenuFocusManager.cpp.

{
    BOOL bDisable = FALSE;
    BOOL lastDisable = FALSE;
 
    int i = m_bandCount;
    while (--i >= 0)
    {
        StackEntry& entry = m_bandStack[i];
 
        if (entry.type != TrackedMenuEntry)
        {
            HWND hwnd;
            HRESULT hr = entry.mb->_GetTopLevelWindow(&hwnd);
            if (FAILED_UNEXPECTEDLY(hr))
                break;
 
            if (hwnd == parent)
            {
                lastDisable = disableThis;
                entry.mb->_DisableMouseTrack(disableThis);
                bDisable = TRUE;
            }
            else
            {
                lastDisable = bDisable;
                entry.mb->_DisableMouseTrack(bDisable);
            }
        }
    }
    m_mouseTrackDisabled = lastDisable;
}

Referenced by GetMsgHook(), ProcessMouseMove(), and UpdateFocus().

GetManager()

CMenuFocusManager * CMenuFocusManager::GetManager ( )

staticprivate

Definition at line 91 of file CMenuFocusManager.cpp.

{
    return reinterpret_cast<CMenuFocusManager *>(TlsGetValue(TlsIndex));
}

Referenced by AcquireManager(), s_GetMsgHook(), and s_MsgFilterHook().

GetMsgHook()

LRESULT CMenuFocusManager::GetMsgHook ( INT  nCode, WPARAM  wParam, LPARAM  lParam  )

private

Definition at line 574 of file CMenuFocusManager.cpp.

{
    BOOL isLButton = FALSE;
    if (nCode < 0)
        return CallNextHookEx(m_hGetMsgHook, nCode, hookWParam, hookLParam);
 
    if (nCode == HC_ACTION)
    {
        BOOL callNext = TRUE;
        MSG* msg = reinterpret_cast<MSG*>(hookLParam);
        POINT pt = msg->pt;
 
        switch (msg->message)
        {
        case WM_CAPTURECHANGED:
            if (m_captureHwnd)
            {
                TRACE("Capture lost.\n");
                m_captureHwnd = NULL;
            }
            break;
 
        case WM_NCLBUTTONDOWN:
        case WM_LBUTTONDBLCLK:
        case WM_LBUTTONDOWN:
            isLButton = TRUE;
            TRACE("LB\n");
 
            if (m_menuBar && m_current->type == MenuPopupEntry)
            {
                POINT pt = msg->pt;
                HWND child = WindowFromPoint(pt);
                BOOL hoveringMenuBar = m_menuBar->mb->IsWindowOwner(child) == S_OK;
                if (hoveringMenuBar)
                {
                    m_current->mb->_MenuItemSelect(MPOS_FULLCANCEL);
                    break;
                }
            }
 
            if (m_current->type == MenuPopupEntry)
            {
                HWND child = WindowFromPoint(pt);
 
                if (IsTrackedWindowOrParent(child) != S_OK)
                {
                    m_current->mb->_MenuItemSelect(MPOS_FULLCANCEL);
                    break;
                }
            }
 
            ProcessMouseDown(msg, isLButton);
 
            break;
        case WM_NCRBUTTONUP:
        case WM_RBUTTONUP:
            ProcessMouseUp(msg, isLButton);
            break;
        case WM_NCLBUTTONUP:
        case WM_LBUTTONUP:
            isLButton = TRUE;
            ProcessMouseUp(msg, isLButton);
            break;
        case WM_MOUSEMOVE:
            callNext = ProcessMouseMove(msg);
            break;
        case WM_MOUSELEAVE:
            callNext = ProcessMouseMove(msg);
            //callNext = ProcessMouseLeave(msg);
            break;
        case WM_SYSKEYDOWN:
        case WM_KEYDOWN:
            if (m_current->type == MenuPopupEntry)
            {
                DisableMouseTrack(m_current->hwnd, TRUE);
                switch (msg->wParam)
                {
                case VK_ESCAPE:
                case VK_MENU:
                case VK_LMENU:
                case VK_RMENU:
                    m_current->mb->_MenuItemSelect(MPOS_FULLCANCEL);
                    break;
                case VK_RETURN:
                    m_current->mb->_MenuItemSelect(MPOS_EXECUTE);
                    break;
                case VK_LEFT:
                    m_current->mb->_MenuItemSelect(VK_LEFT);
                    break;
                case VK_RIGHT:
                    m_current->mb->_MenuItemSelect(VK_RIGHT);
                    break;
                case VK_UP:
                    m_current->mb->_MenuItemSelect(VK_UP);
                    break;
                case VK_DOWN:
                    m_current->mb->_MenuItemSelect(VK_DOWN);
                    break;
                }
                msg->message = WM_NULL;
                msg->lParam = 0;
                msg->wParam = 0;
            }
            break;
        }
 
        if (!callNext)
            return 1;
    }
 
    return CallNextHookEx(m_hGetMsgHook, nCode, hookWParam, hookLParam);
}

Referenced by s_GetMsgHook().

IsTrackedWindow()

HRESULT CMenuFocusManager::IsTrackedWindow ( HWND  hWnd, StackEntry **  pentry = NULL  )

private

Definition at line 257 of file CMenuFocusManager.cpp.

{
    if (pentry)
        *pentry = NULL;
 
    for (int i = m_bandCount; --i >= 0;)
    {
        StackEntry& entry = m_bandStack[i];
 
        if (entry.type != TrackedMenuEntry)
        {
            HRESULT hr = entry.mb->IsWindowOwner(hWnd);
            if (FAILED_UNEXPECTEDLY(hr))
                return hr;
            if (hr == S_OK)
            {
                if (pentry)
                    *pentry = &entry;
                return S_OK;
            }
        }
    }
 
    return S_FALSE;
}

Referenced by ProcessMouseDown(), ProcessMouseMove(), and ProcessMouseUp().

IsTrackedWindowOrParent()

HRESULT CMenuFocusManager::IsTrackedWindowOrParent ( HWND  hWnd )

private

Definition at line 283 of file CMenuFocusManager.cpp.

{
    for (int i = m_bandCount; --i >= 0;)
    {
        StackEntry& entry = m_bandStack[i];
 
        if (entry.type != TrackedMenuEntry)
        {
            HRESULT hr = entry.mb->IsWindowOwner(hWnd);
            if (FAILED_UNEXPECTEDLY(hr))
                return hr;
            if (hr == S_OK)
                return S_OK;
            if (entry.mb->_IsPopup() == S_OK)
            {
                CComPtr<IUnknown> site;
                CComPtr<IOleWindow> pw;
                hr = entry.mb->GetSite(IID_PPV_ARG(IUnknown, &site));
                if (FAILED_UNEXPECTEDLY(hr))
                    continue;
                hr = IUnknown_QueryService(site, SID_SMenuBandParent, IID_PPV_ARG(IOleWindow, &pw));
                if (FAILED_UNEXPECTEDLY(hr))
                    continue;
 
                HWND hParent;
                if (pw->GetWindow(&hParent) == S_OK && hParent == hWnd)
                    return S_OK;
            }
        }
    }
 
    return S_FALSE;
}

Referenced by GetMsgHook().

MsgFilterHook()

LRESULT CMenuFocusManager::MsgFilterHook ( INT  nCode, WPARAM  wParam, LPARAM  lParam  )

private

Definition at line 508 of file CMenuFocusManager.cpp.

{
    if (nCode < 0)
        return CallNextHookEx(m_hMsgFilterHook, nCode, hookWParam, hookLParam);
 
    if (nCode == MSGF_MENU)
    {
        BOOL callNext = TRUE;
        MSG* msg = reinterpret_cast<MSG*>(hookLParam);
 
        switch (msg->message)
        {
        case WM_LBUTTONDOWN:
        case WM_RBUTTONDOWN:
            if (m_menuBar && m_current->type == TrackedMenuEntry)
            {
                POINT pt = msg->pt;
                HWND child = WindowFromPoint(pt);
                BOOL hoveringMenuBar = m_menuBar->mb->IsWindowOwner(child) == S_OK;
                if (hoveringMenuBar)
                {
                    m_menuBar->mb->_BeforeCancelPopup();
                }
            }
            break;
        case WM_MOUSEMOVE:
            callNext = ProcessMouseMove(msg);
            break;
        case WM_INITMENUPOPUP:
            TRACE("WM_INITMENUPOPUP %p %p\n", msg->wParam, msg->lParam);
            m_selectedMenu = reinterpret_cast<HMENU>(msg->lParam);
            m_selectedItem = -1;
            m_selectedItemFlags = 0;
            break;
        case WM_MENUSELECT:
            TRACE("WM_MENUSELECT %p %p\n", msg->wParam, msg->lParam);
            m_selectedMenu = reinterpret_cast<HMENU>(msg->lParam);
            m_selectedItem = GET_X_LPARAM(msg->wParam);
            m_selectedItemFlags = HIWORD(msg->wParam);
            break;
        case WM_KEYDOWN:
            switch (msg->wParam)
            {
            case VK_LEFT:
                if (m_current->hmenu == m_selectedMenu)
                {
                    m_parent->mb->_MenuItemSelect(VK_LEFT);
                }
                break;
            case VK_RIGHT:
                if (m_selectedItem < 0 || !(m_selectedItemFlags & MF_POPUP))
                {
                    m_parent->mb->_MenuItemSelect(VK_RIGHT);
                }
                break;
            }
            break;
        }
 
        if (!callNext)
            return 1;
    }
 
    return CallNextHookEx(m_hMsgFilterHook, nCode, hookWParam, hookLParam);
}

Referenced by s_MsgFilterHook().

PlaceHooks()

HRESULT CMenuFocusManager::PlaceHooks ( )

private

Definition at line 687 of file CMenuFocusManager.cpp.

{
    if (m_hGetMsgHook)
    {
        WARN("GETMESSAGE hook already placed!\n");
        return S_OK;
    }
    if (m_hMsgFilterHook)
    {
        WARN("MSGFILTER hook already placed!\n");
        return S_OK;
    }
    if (m_current->type == TrackedMenuEntry)
    {
        TRACE("Entering MSGFILTER hook...\n");
        m_hMsgFilterHook = SetWindowsHookEx(WH_MSGFILTER, s_MsgFilterHook, NULL, m_threadId);
    }
    else
    {
        TRACE("Entering GETMESSAGE hook...\n");
        m_hGetMsgHook = SetWindowsHookEx(WH_GETMESSAGE, s_GetMsgHook, NULL, m_threadId);
    }
    return S_OK;
}

Referenced by UpdateFocus().

PopFromArray()

HRESULT CMenuFocusManager::PopFromArray ( StackEntryType *  pType, CMenuBand **  pMb, HMENU *  pHmenu  )

private

Definition at line 152 of file CMenuFocusManager.cpp.

{
    if (pType)  *pType = NoEntry;
    if (pMb)    *pMb = NULL;
    if (pHmenu) *pHmenu = NULL;
 
    if (m_bandCount <= 0)
        return S_FALSE;
 
    m_bandCount--;
 
    if (pType)  *pType = m_bandStack[m_bandCount].type;
    if (*pType == TrackedMenuEntry)
    {
        if (pHmenu) *pHmenu = m_bandStack[m_bandCount].hmenu;
    }
    else
    {
        if (pMb) *pMb = m_bandStack[m_bandCount].mb;
    }
 
    return S_OK;
}

Referenced by PopMenuBar(), PopMenuPopup(), and PopTrackedPopup().

PopMenuBar()

HRESULT CMenuFocusManager::PopMenuBar

(

CMenuBand *

mb

)

Definition at line 941 of file CMenuFocusManager.cpp.

{
    StackEntryType type;
    CMenuBand * mbc;
    HRESULT hr;
 
    TRACE("PopMenuBar %p\n", mb);
 
    if (m_current == m_entryUnderMouse)
    {
        m_entryUnderMouse = NULL;
    }
 
    hr = PopFromArray(&type, &mbc, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
    {
        UpdateFocus();
        return hr;
    }
 
    _ASSERT(type == MenuBarEntry);
    if (type != MenuBarEntry)
        return E_FAIL;
 
    if (!mbc)
        return E_FAIL;
 
    mbc->_SetParentBand(NULL);
 
    mbc->Release();
 
    hr = UpdateFocus();
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    if (m_current)
    {
        _ASSERT(m_current->type != TrackedMenuEntry);
        m_current->mb->_SetChildBand(NULL);
    }
 
    return S_OK;
}

Referenced by CMenuBand::ShowDW().

PopMenuPopup()

HRESULT CMenuFocusManager::PopMenuPopup

(

CMenuBand *

mb

)

Definition at line 986 of file CMenuFocusManager.cpp.

{
    StackEntryType type;
    CMenuBand * mbc;
    HRESULT hr;
 
    TRACE("PopMenuPopup %p\n", mb);
 
    if (m_current == m_entryUnderMouse)
    {
        m_entryUnderMouse = NULL;
    }
 
    m_menuDepth--;
 
    hr = PopFromArray(&type, &mbc, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
    {
        UpdateFocus();
        return hr;
    }
 
    _ASSERT(type == MenuPopupEntry);
    if (type != MenuPopupEntry)
        return E_FAIL;
 
    if (!mbc)
        return E_FAIL;
 
    mbc->_SetParentBand(NULL);
 
    mbc->Release();
 
    hr = UpdateFocus();
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    if (m_current)
    {
        _ASSERT(m_current->type != TrackedMenuEntry);
        m_current->mb->_SetChildBand(NULL);
    }
 
    return S_OK;
}

Referenced by CMenuBand::ShowDW().

PopTrackedPopup()

HRESULT CMenuFocusManager::PopTrackedPopup

(

HMENU

popup

)

Definition at line 1033 of file CMenuFocusManager.cpp.

{
    StackEntryType type;
    HMENU hmenu;
    HRESULT hr;
 
    TRACE("PopTrackedPopup %p\n", popup);
 
    hr = PopFromArray(&type, NULL, &hmenu);
    if (FAILED_UNEXPECTEDLY(hr))
    {
        UpdateFocus();
        return hr;
    }
 
    _ASSERT(type == TrackedMenuEntry);
    if (type != TrackedMenuEntry)
        return E_FAIL;
 
    if (hmenu != popup)
        return E_FAIL;
 
    hr = UpdateFocus();
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return S_OK;
}

Referenced by CMenuBand::_TrackContextMenu(), and CMenuBand::_TrackSubMenu().

ProcessMouseDown()

LRESULT CMenuFocusManager::ProcessMouseDown ( MSG *  msg, BOOL  isLButton  )

private

Definition at line 416 of file CMenuFocusManager.cpp.

{
    HWND child;
    int iHitTestResult = -1;
 
    TRACE("ProcessMouseDown %d %d %d\n", msg->message, msg->wParam, msg->lParam);
 
    // Don't do anything if another window is capturing the mouse.
    HWND cCapture = ::GetCapture();
    if (cCapture && cCapture != m_captureHwnd && m_current->type != TrackedMenuEntry)
    {
        TRACE("Foreign capture active.\n");
        return TRUE;
    }
 
    POINT pt = msg->pt;
 
    child = WindowFromPoint(pt);
 
    StackEntry * entry = NULL;
    if (IsTrackedWindow(child, &entry) != S_OK)
    {
        TRACE("Foreign window detected.\n");
        return TRUE;
    }
 
    if (entry->type == MenuBarEntry)
    {
        if (entry != m_current)
        {
            TRACE("Menubar with popup active.\n");
            return TRUE;
        }
    }
 
    if (entry)
    {
        ScreenToClient(child, &pt);
        iHitTestResult = SendMessageW(child, TB_HITTEST, 0, (LPARAM) &pt);
 
        if (iHitTestResult >= 0)
        {
            TRACE("MouseDown send %d\n", iHitTestResult);
            entry->mb->_MenuBarMouseDown(child, iHitTestResult, isLButton);
        }
    }
 
    msg->message = WM_NULL;
 
    m_movedSinceDown = FALSE;
    m_windowAtDown = child;
 
    TRACE("MouseDown end\n");
 
    return TRUE;
}

Referenced by GetMsgHook().

ProcessMouseMove()

LRESULT CMenuFocusManager::ProcessMouseMove ( MSG *  msg )

private

Definition at line 317 of file CMenuFocusManager.cpp.

{
    HWND child;
    int iHitTestResult = -1;
 
    POINT pt2 = { GET_X_LPARAM(msg->lParam), GET_Y_LPARAM(msg->lParam) };
    ClientToScreen(msg->hwnd, &pt2);
 
    POINT pt = msg->pt;
 
    // Don't do anything if another window is capturing the mouse.
    HWND cCapture = ::GetCapture();
    if (cCapture && cCapture != m_captureHwnd && m_current->type != TrackedMenuEntry)
        return TRUE;
 
    m_movedSinceDown = TRUE;
 
    m_ptPrev = pt;
 
    child = WindowFromPoint(pt);
 
    StackEntry * entry = NULL;
    if (IsTrackedWindow(child, &entry) == S_OK)
    {
        TRACE("MouseMove\n");
    }
 
    BOOL isTracking = FALSE;
    if (entry && (entry->type == MenuBarEntry || m_current->type != TrackedMenuEntry))
    {
        ScreenToClient(child, &pt);
        iHitTestResult = SendMessageW(child, TB_HITTEST, 0, (LPARAM) &pt);
        isTracking = entry->mb->_IsTracking();
 
        if (iHitTestResult < -1)
        {
            // TB_HITTEST would return negative numbers for separators
            iHitTestResult = -iHitTestResult;
        }
        else if (iHitTestResult == -1)
        {
            // TB_HITTEST would return -1 in two cases:
            // 1. the mouse is outside the toolbar;
            // 2. the mouse is over the first item, and that item is a separator.
            // Confirm the second scenario by checking first item's rect.
            RECT rc;
            SendMessageW(child, TB_GETITEMRECT, 1, (LPARAM)&rc);
            if (PtInRect(&rc, pt))
                iHitTestResult = 1;
        }
 
        if (SendMessage(child, WM_USER_ISTRACKEDITEM, iHitTestResult, 0) == S_FALSE)
        {
            // The current tracked item has changed, notify the toolbar
 
            TRACE("Hot item tracking detected a change (capture=%p / cCapture=%p)...\n", m_captureHwnd, cCapture);
            DisableMouseTrack(NULL, FALSE);
            if (isTracking && iHitTestResult >= 0 && m_current->type == TrackedMenuEntry)
                SendMessage(entry->hwnd, WM_CANCELMODE, 0, 0);
            PostMessage(child, WM_USER_CHANGETRACKEDITEM, iHitTestResult, MAKELPARAM(isTracking, TRUE));
            if (m_current->type == TrackedMenuEntry)
                return FALSE;
        }
    }
 
    if (m_entryUnderMouse != entry)
    {
        // Mouse moved away from a tracked window
        if (m_entryUnderMouse)
        {
            m_entryUnderMouse->mb->_ChangeHotItem(NULL, -1, HICF_MOUSE);
        }
    }
 
    if (m_hwndUnderMouse != child)
    {
        if (entry)
        {
            // Mouse moved to a tracked window
            if (m_current->type == MenuPopupEntry)
            {
                ScreenToClient(child, &pt2);
                SendMessage(child, WM_MOUSEMOVE, msg->wParam, MAKELPARAM(pt2.x, pt2.y));
            }
        }
 
        m_hwndUnderMouse = child;
        m_entryUnderMouse = entry;
    }
 
    if (m_current->type == MenuPopupEntry)
    {
        HWND parent = GetAncestor(child, GA_ROOT);
        DisableMouseTrack(parent, FALSE);
    }
 
    return TRUE;
}

Referenced by GetMsgHook(), and MsgFilterHook().

ProcessMouseUp()

LRESULT CMenuFocusManager::ProcessMouseUp ( MSG *  msg, BOOL  isLButton  )

private

Definition at line 473 of file CMenuFocusManager.cpp.

{
    HWND child;
    int iHitTestResult = -1;
 
    TRACE("ProcessMouseUp %d %d %d\n", msg->message, msg->wParam, msg->lParam);
 
    // Don't do anything if another window is capturing the mouse.
    HWND cCapture = ::GetCapture();
    if (cCapture && cCapture != m_captureHwnd && m_current->type != TrackedMenuEntry)
        return TRUE;
 
    POINT pt = msg->pt;
 
    child = WindowFromPoint(pt);
 
    StackEntry * entry = NULL;
    if (IsTrackedWindow(child, &entry) != S_OK)
        return TRUE;
 
    if (entry)
    {
        ScreenToClient(child, &pt);
        iHitTestResult = SendMessageW(child, TB_HITTEST, 0, (LPARAM) &pt);
 
        if (iHitTestResult >= 0)
        {
            TRACE("MouseUp send %d\n", iHitTestResult);
            entry->mb->_MenuBarMouseUp(child, iHitTestResult, isLButton);
        }
    }
 
    return TRUE;
}

Referenced by GetMsgHook().

PushMenuBar()

HRESULT CMenuFocusManager::PushMenuBar

(

CMenuBand *

mb

)

Definition at line 879 of file CMenuFocusManager.cpp.

{
    TRACE("PushMenuBar %p\n", mb);
 
    mb->AddRef();
 
    _ASSERT(m_bandCount == 0);
 
    HRESULT hr = PushToArray(MenuBarEntry, mb, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return UpdateFocus();
}

Referenced by CMenuBand::ShowDW().

PushMenuPopup()

HRESULT CMenuFocusManager::PushMenuPopup

(

CMenuBand *

mb

)

Definition at line 895 of file CMenuFocusManager.cpp.

{
    TRACE("PushTrackedPopup %p\n", mb);
 
    mb->AddRef();
 
    _ASSERT(!m_current || m_current->type != TrackedMenuEntry);
 
    HRESULT hr = PushToArray(MenuPopupEntry, mb, NULL);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    hr = UpdateFocus();
 
    m_menuDepth++;
 
    if (m_parent && m_parent->type != TrackedMenuEntry)
    {
        m_parent->mb->_SetChildBand(mb);
        mb->_SetParentBand(m_parent->mb);
    }
 
    return hr;
}

Referenced by CMenuBand::ShowDW().

PushToArray()

HRESULT CMenuFocusManager::PushToArray ( StackEntryType  type, CMenuBand *  mb, HMENU  hmenu  )

private

Definition at line 139 of file CMenuFocusManager.cpp.

{
    if (m_bandCount >= MAX_RECURSE)
        return E_OUTOFMEMORY;
 
    m_bandStack[m_bandCount].type = type;
    m_bandStack[m_bandCount].mb = mb;
    m_bandStack[m_bandCount].hmenu = hmenu;
    m_bandCount++;
 
    return S_OK;
}

Referenced by PushMenuBar(), PushMenuPopup(), and PushTrackedPopup().

PushTrackedPopup()

HRESULT CMenuFocusManager::PushTrackedPopup

(

HMENU

popup

)

Definition at line 921 of file CMenuFocusManager.cpp.

{
    TRACE("PushTrackedPopup %p\n", popup);
 
    _ASSERT(m_bandCount > 0);
    _ASSERT(!m_current || m_current->type != TrackedMenuEntry);
 
    HRESULT hr = PushToArray(TrackedMenuEntry, NULL, popup);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    TRACE("PushTrackedPopup %p\n", popup);
    m_selectedMenu = popup;
    m_selectedItem = -1;
    m_selectedItemFlags = 0;
 
    return UpdateFocus();
}

Referenced by CMenuBand::_TrackContextMenu(), and CMenuBand::_TrackSubMenu().

ReleaseManager()

void CMenuFocusManager::ReleaseManager ( CMenuFocusManager *  obj )

static

Definition at line 121 of file CMenuFocusManager.cpp.

{
    if (!obj->Release())
    {
        TlsSetValue(TlsIndex, NULL);
    }
}

Referenced by CMenuBand::~CMenuBand().

RemoveHooks()

HRESULT CMenuFocusManager::RemoveHooks ( )

private

Definition at line 712 of file CMenuFocusManager.cpp.

{
    if (m_hMsgFilterHook)
    {
        TRACE("Removing MSGFILTER hook...\n");
        UnhookWindowsHookEx(m_hMsgFilterHook);
        m_hMsgFilterHook = NULL;
    }
    if (m_hGetMsgHook)
    {
        TRACE("Removing GETMESSAGE hook...\n");
        UnhookWindowsHookEx(m_hGetMsgHook);
        m_hGetMsgHook = NULL;
    }
    return S_OK;
}

Referenced by UpdateFocus().

s_GetMsgHook()

LRESULT CALLBACK CMenuFocusManager::s_GetMsgHook ( INT  nCode, WPARAM  wParam, LPARAM  lParam  )

staticprivate

Definition at line 134 of file CMenuFocusManager.cpp.

{
    return GetManager()->GetMsgHook(nCode, wParam, lParam);
}

Referenced by PlaceHooks().

s_MsgFilterHook()

LRESULT CALLBACK CMenuFocusManager::s_MsgFilterHook ( INT  nCode, WPARAM  wParam, LPARAM  lParam  )

staticprivate

Definition at line 129 of file CMenuFocusManager.cpp.

{
    return GetManager()->MsgFilterHook(nCode, wParam, lParam);
}

Referenced by PlaceHooks().

SetMenuCapture()

void CMenuFocusManager::SetMenuCapture ( HWND  child )

private

Definition at line 237 of file CMenuFocusManager.cpp.

{
    if (m_captureHwnd != child)
    {
        if (child)
        {
            ::SetCapture(child);
            m_captureHwnd = child;
            TRACE("Capturing %p\n", child);
        }
        else
        {
            ::ReleaseCapture();
            m_captureHwnd = NULL;
            TRACE("Capture is now off\n");
        }
 
    }
}

Referenced by UpdateFocus().

UpdateFocus()

HRESULT CMenuFocusManager::UpdateFocus ( )

private

Definition at line 730 of file CMenuFocusManager.cpp.

{
    HRESULT hr;
    StackEntry * old = m_current;
 
    TRACE("UpdateFocus\n");
 
    // Assign the new current item
    if (m_bandCount > 0)
        m_current = &(m_bandStack[m_bandCount - 1]);
    else
        m_current = NULL;
 
    // Remove the menu capture if necesary
    if (!m_current || m_current->type != MenuPopupEntry)
    {
        SetMenuCapture(NULL);
        if (old && old->type == MenuPopupEntry && m_PreviousForeground)
        {
            ::SetForegroundWindow(m_PreviousForeground);
            m_PreviousForeground = NULL;
        }
    }
 
    // Obtain the top-level window for the new active menu
    if (m_current && m_current->type != TrackedMenuEntry)
    {
        hr = m_current->mb->_GetTopLevelWindow(&(m_current->hwnd));
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
    }
 
    // Refresh the parent pointer
    if (m_bandCount >= 2)
    {
        m_parent = &(m_bandStack[m_bandCount - 2]);
        _ASSERT(m_parent->type != TrackedMenuEntry);
    }
    else
    {
        m_parent = NULL;
    }
 
    // Refresh the menubar pointer, if applicable
    if (m_bandCount >= 1 && m_bandStack[0].type == MenuBarEntry)
    {
        m_menuBar = &(m_bandStack[0]);
    }
    else
    {
        m_menuBar = NULL;
    }
 
    // Remove the old hooks if the menu type changed, or we don't have a menu anymore
    if (old && (!m_current || old->type != m_current->type))
    {
        if (m_current && m_current->type != TrackedMenuEntry)
        {
            DisableMouseTrack(m_current->hwnd, FALSE);
        }
 
        hr = RemoveHooks();
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
    }
 
    // And place new ones if necessary
    if (m_current && (!old || old->type != m_current->type))
    {
        hr = PlaceHooks();
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
    }
 
    // Give the user a chance to move the mouse to the new menu
    if (m_parent)
    {
        DisableMouseTrack(m_parent->hwnd, TRUE);
    }
 
    if (m_current && m_current->type == MenuPopupEntry)
    {
        if (m_captureHwnd == NULL)
        {
            // We need to restore the capture after a non-shell submenu or context menu is shown
            StackEntry * topMenu = m_bandStack;
            if (topMenu->type == MenuBarEntry)
                topMenu++;
 
            // Get the top-level window from the top popup
            CComPtr<IServiceProvider> bandSite;
            CComPtr<IOleWindow> deskBar;
            hr = topMenu->mb->GetSite(IID_PPV_ARG(IServiceProvider, &bandSite));
            if (FAILED(hr))
                goto NoCapture;
            hr = bandSite->QueryService(SID_SMenuPopup, IID_PPV_ARG(IOleWindow, &deskBar));
            if (FAILED(hr))
                goto NoCapture;
 
            CComPtr<IOleWindow> deskBarSite;
            hr = IUnknown_GetSite(deskBar, IID_PPV_ARG(IOleWindow, &deskBarSite));
            if (FAILED(hr))
                goto NoCapture;
 
            // FIXME: Find the correct place for this
            HWND hWndOwner;
            hr = deskBarSite->GetWindow(&hWndOwner);
            if (FAILED(hr))
                goto NoCapture;
 
            m_PreviousForeground = ::GetForegroundWindow();
            if (m_PreviousForeground != hWndOwner)
                ::SetForegroundWindow(hWndOwner);
            else
                m_PreviousForeground = NULL;
 
            // Get the HWND of the top-level window
            HWND hWndSite;
            hr = deskBar->GetWindow(&hWndSite);
            if (FAILED(hr))
                goto NoCapture;
            SetMenuCapture(hWndSite);
        }
NoCapture:
 
        if (!m_parent || m_parent->type == MenuBarEntry)
        {
            if (old && old->type == TrackedMenuEntry)
            {
                // FIXME: Debugging code, probably not right
                POINT pt2;
                RECT rc2;
                GetCursorPos(&pt2);
                ScreenToClient(m_current->hwnd, &pt2);
                GetClientRect(m_current->hwnd, &rc2);
                if (PtInRect(&rc2, pt2))
                    SendMessage(m_current->hwnd, WM_MOUSEMOVE, 0, MAKELPARAM(pt2.x, pt2.y));
                else
                    SendMessage(m_current->hwnd, WM_MOUSELEAVE, 0, 0);
            }
        }
    }
 
    _ASSERT(!m_parent || m_parent->type != TrackedMenuEntry);
 
    return S_OK;
}

Referenced by PopMenuBar(), PopMenuPopup(), PopTrackedPopup(), PushMenuBar(), PushMenuPopup(), and PushTrackedPopup().

Member Data Documentation

m_bandCount

int CMenuFocusManager::m_bandCount

private

Definition at line 88 of file CMenuFocusManager.h.

Referenced by DisableMouseTrack(), IsTrackedWindow(), IsTrackedWindowOrParent(), PopFromArray(), PushMenuBar(), PushToArray(), PushTrackedPopup(), and UpdateFocus().

m_bandStack

StackEntry CMenuFocusManager::m_bandStack[MAX_RECURSE]

private

Definition at line 87 of file CMenuFocusManager.h.

Referenced by DisableMouseTrack(), IsTrackedWindow(), IsTrackedWindowOrParent(), PopFromArray(), PushToArray(), and UpdateFocus().

m_captureHwnd

HWND CMenuFocusManager::m_captureHwnd

private

Definition at line 71 of file CMenuFocusManager.h.

Referenced by GetMsgHook(), ProcessMouseDown(), ProcessMouseMove(), ProcessMouseUp(), SetMenuCapture(), and UpdateFocus().

m_current

StackEntry* CMenuFocusManager::m_current

private

Definition at line 59 of file CMenuFocusManager.h.

Referenced by GetMsgHook(), MsgFilterHook(), PlaceHooks(), PopMenuBar(), PopMenuPopup(), ProcessMouseDown(), ProcessMouseMove(), ProcessMouseUp(), PushMenuPopup(), PushTrackedPopup(), and UpdateFocus().

m_entryUnderMouse

StackEntry* CMenuFocusManager::m_entryUnderMouse

private

Definition at line 74 of file CMenuFocusManager.h.

Referenced by PopMenuBar(), PopMenuPopup(), and ProcessMouseMove().

m_hGetMsgHook

HHOOK CMenuFocusManager::m_hGetMsgHook

private

Definition at line 64 of file CMenuFocusManager.h.

Referenced by GetMsgHook(), PlaceHooks(), and RemoveHooks().

m_hMsgFilterHook

HHOOK CMenuFocusManager::m_hMsgFilterHook

private

Definition at line 63 of file CMenuFocusManager.h.

Referenced by MsgFilterHook(), PlaceHooks(), and RemoveHooks().

m_hwndUnderMouse

HWND CMenuFocusManager::m_hwndUnderMouse

private

Definition at line 73 of file CMenuFocusManager.h.

Referenced by ProcessMouseMove().

m_menuBar

StackEntry* CMenuFocusManager::m_menuBar

private

Definition at line 61 of file CMenuFocusManager.h.

Referenced by GetMsgHook(), MsgFilterHook(), and UpdateFocus().

m_menuDepth

int CMenuFocusManager::m_menuDepth

private

Definition at line 89 of file CMenuFocusManager.h.

Referenced by PopMenuPopup(), and PushMenuPopup().

m_mouseTrackDisabled

BOOL CMenuFocusManager::m_mouseTrackDisabled

private

Definition at line 67 of file CMenuFocusManager.h.

Referenced by DisableMouseTrack().

m_movedSinceDown

BOOL CMenuFocusManager::m_movedSinceDown

private

Definition at line 80 of file CMenuFocusManager.h.

Referenced by ProcessMouseDown(), and ProcessMouseMove().

m_parent

StackEntry* CMenuFocusManager::m_parent

private

Definition at line 60 of file CMenuFocusManager.h.

Referenced by MsgFilterHook(), PushMenuPopup(), and UpdateFocus().

m_PreviousForeground

HWND CMenuFocusManager::m_PreviousForeground

private

Definition at line 83 of file CMenuFocusManager.h.

Referenced by UpdateFocus().

m_ptPrev

POINT CMenuFocusManager::m_ptPrev

private

Definition at line 69 of file CMenuFocusManager.h.

Referenced by CMenuFocusManager(), and ProcessMouseMove().

m_selectedItem

INT CMenuFocusManager::m_selectedItem

private

Definition at line 77 of file CMenuFocusManager.h.

Referenced by MsgFilterHook(), and PushTrackedPopup().

m_selectedItemFlags

DWORD CMenuFocusManager::m_selectedItemFlags

private

Definition at line 78 of file CMenuFocusManager.h.

Referenced by MsgFilterHook(), and PushTrackedPopup().

m_selectedMenu

HMENU CMenuFocusManager::m_selectedMenu

private

Definition at line 76 of file CMenuFocusManager.h.

Referenced by MsgFilterHook(), and PushTrackedPopup().

m_threadId

DWORD CMenuFocusManager::m_threadId

private

Definition at line 65 of file CMenuFocusManager.h.

Referenced by CMenuFocusManager(), and PlaceHooks().

m_windowAtDown

HWND CMenuFocusManager::m_windowAtDown

private

Definition at line 81 of file CMenuFocusManager.h.

Referenced by ProcessMouseDown().

TlsIndex

DWORD CMenuFocusManager::TlsIndex = 0

staticprivate

Definition at line 29 of file CMenuFocusManager.h.

Referenced by AcquireManager(), GetManager(), and ReleaseManager().

---

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

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