CSendToMenu Class Reference

#include <CSendToMenu.h>

Inheritance diagram for CSendToMenu:

Collaboration diagram for CSendToMenu:

Classes
struct	SENDTO_ITEM

Public Member Functions
	CSendToMenu ()
	~CSendToMenu ()
STDMETHODIMP	QueryContextMenu (HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
STDMETHODIMP	InvokeCommand (LPCMINVOKECOMMANDINFO lpcmi)
STDMETHODIMP	GetCommandString (UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen)
STDMETHODIMP	HandleMenuMsg2 (UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plResult)
STDMETHODIMP	HandleMenuMsg (UINT uMsg, WPARAM wParam, LPARAM lParam)
STDMETHODIMP	Initialize (PCIDLIST_ABSOLUTE pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID)
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 ()
HRESULT	HandleMenuMsg2 ([in] UINT uMsg, [in] WPARAM wParam, [in] LPARAM lParam, [out] LRESULT *plResult)
HRESULT	HandleMenuMsg ([in] UINT uMsg, [in] WPARAM wParam, [in] LPARAM lParam)
HRESULT	QueryContextMenu ([in] HMENU hmenu, [in] UINT indexMenu, [in] UINT idCmdFirst, [in] UINT idCmdLast, [in] UINT uFlags)
HRESULT	InvokeCommand ([in] LPCMINVOKECOMMANDINFO lpici)
HRESULT	GetCommandString ([in] UINT_PTR idCmd, [in] UINT uType, [out] UINT *pwReserved, [out, size_is(cchMax)] LPSTR pszName, [in] UINT cchMax)
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()
HRESULT	Initialize ([in] PCIDLIST_ABSOLUTE pidlFolder, [in] IDataObject *pdtobj, [in] HKEY hkeyProgID)

Private Member Functions
HRESULT	LoadAllItems (HWND hwnd)
void	UnloadAllItems ()
UINT	InsertSendToItems (HMENU hMenu, UINT idFirst, UINT idMenu)
SENDTO_ITEM *	FindItemFromIdOffset (UINT IdOffset)
HRESULT	DoSendToItem (SENDTO_ITEM *pItem, LPCMINVOKECOMMANDINFO lpici)
HRESULT	DoDrop (IDataObject *pDataObject, IDropTarget *pDropTarget)
HRESULT	GetSpecialFolder (HWND hwnd, IShellFolder **ppFolder, int csidl, PIDLIST_ABSOLUTE *ppidl=NULL)
HRESULT	GetUIObjectFromPidl (HWND hwnd, PIDLIST_ABSOLUTE pidl, REFIID riid, LPVOID *ppvOut)

Private Attributes
HMENU	m_hSubMenu
SENDTO_ITEM *	m_pItems
UINT	m_idCmdFirst
CComPtr< IShellFolder >	m_pDesktop
CComPtr< IShellFolder >	m_pSendTo
CComPtr< IDataObject >	m_pDataObject

Additional Inherited Members
Public Types inherited from IContextMenu3
typedef IContextMenu3 *	LPCONTEXTMENU3
Public Types inherited from IContextMenu2
typedef IContextMenu2 *	LPCONTEXTMENU2
Public Types inherited from IContextMenu
typedef IContextMenu *	LPCONTEXTMENU
typedef struct IContextMenu::tagCMINVOKECOMMANDINFO	CMINVOKECOMMANDINFO
typedef struct IContextMenu::tagCMINVOKECOMMANDINFO *	LPCMINVOKECOMMANDINFO
typedef struct IContextMenu::tagCMInvokeCommandInfoEx	CMINVOKECOMMANDINFOEX
typedef struct IContextMenu::tagCMInvokeCommandInfoEx *	LPCMINVOKECOMMANDINFOEX
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Public Types inherited from IShellExtInit
typedef IShellExtInit *	LPSHELLEXTINIT
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)
Public Attributes inherited from ATL::CComObjectRootBase
LONG	m_dwRef
Static Public Attributes inherited from IContextMenu
static const WCHAR	CMDSTR_NEWFOLDERW [] = {'N','e','w','F','o','l','d','e','r',0}
static const WCHAR	CMDSTR_VIEWLISTW [] = {'V','i','e','w','L','i','s','t',0}
static const WCHAR	CMDSTR_VIEWDETAILSW [] = {'V','i','e','w','D','e','t','a','i','l','s',0}

Detailed Description

Definition at line 26 of file CSendToMenu.h.

Constructor & Destructor Documentation

CSendToMenu()

CSendToMenu::CSendToMenu

(

)

Definition at line 25 of file CSendToMenu.cpp.

    : m_hSubMenu(NULL)
    , m_pItems(NULL)
    , m_idCmdFirst(0)
{
    HRESULT hr = SHGetDesktopFolder(&m_pDesktop);
    if (FAILED(hr))
    {
        ERR("SHGetDesktopFolder: %08lX\n", hr);
    }
 
    GetSpecialFolder(NULL, &m_pSendTo, CSIDL_SENDTO);
}

~CSendToMenu()

CSendToMenu::~CSendToMenu

(

)

Definition at line 39 of file CSendToMenu.cpp.

{
    UnloadAllItems();
 
    if (m_hSubMenu)
    {
        DestroyMenu(m_hSubMenu);
        m_hSubMenu = NULL;
    }
}

Member Function Documentation

DoDrop()

HRESULT CSendToMenu::DoDrop ( IDataObject *  pDataObject, IDropTarget *  pDropTarget  )

private

Definition at line 50 of file CSendToMenu.cpp.

{
    DWORD dwEffect = DROPEFFECT_MOVE | DROPEFFECT_COPY | DROPEFFECT_LINK;
 
    BOOL bShift = (GetAsyncKeyState(VK_SHIFT) < 0);
    BOOL bCtrl = (GetAsyncKeyState(VK_CONTROL) < 0);
 
    // THIS CODE IS NOT HUMAN-FRIENDLY. SORRY.
    // (We have to translate a SendTo action to a Drop action)
    DWORD dwKeyState = MK_LBUTTON;
    if (bShift && bCtrl)
        dwKeyState |= MK_SHIFT | MK_CONTROL;
    else if (!bShift)
        dwKeyState |= MK_CONTROL;
    if (bCtrl)
        dwKeyState |= MK_SHIFT;
 
    POINTL ptl = { 0, 0 };
    HRESULT hr = pDropTarget->DragEnter(pDataObject, dwKeyState, ptl, &dwEffect);
    if (FAILED_UNEXPECTEDLY(hr))
    {
        pDropTarget->DragLeave();
        return hr;
    }
 
    if (dwEffect == DROPEFFECT_NONE)
    {
        ERR("DROPEFFECT_NONE\n");
        pDropTarget->DragLeave();
        return E_FAIL;
    }
 
    // THIS CODE IS NOT HUMAN-FRIENDLY. SORRY.
    // (We have to translate a SendTo action to a Drop action)
    if (bShift && bCtrl)
        dwEffect = DROPEFFECT_LINK;
    else if (!bShift)
        dwEffect = DROPEFFECT_MOVE;
    else
        dwEffect = DROPEFFECT_COPY;
 
    hr = pDropTarget->Drop(pDataObject, dwKeyState, ptl, &dwEffect);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return hr;
}

Referenced by DoSendToItem().

DoSendToItem()

HRESULT CSendToMenu::DoSendToItem ( SENDTO_ITEM *  pItem, LPCMINVOKECOMMANDINFO  lpici  )

private

Definition at line 266 of file CSendToMenu.cpp.

{
    if (!m_pDataObject)
    {
        ERR("!m_pDataObject\n");
        return E_FAIL;
    }
 
    HRESULT hr;
    CComPtr<IDropTarget> pDropTarget;
    hr = m_pSendTo->GetUIObjectOf(NULL, 1, &pItem->pidlChild, IID_IDropTarget,
                                  NULL, (LPVOID *)&pDropTarget);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    hr = DoDrop(m_pDataObject, pDropTarget);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return hr;
}

Referenced by InvokeCommand().

FindItemFromIdOffset()

CSendToMenu::SENDTO_ITEM * CSendToMenu::FindItemFromIdOffset ( UINT  IdOffset )

private

Definition at line 253 of file CSendToMenu.cpp.

{
    UINT idCmd = m_idCmdFirst + IdOffset;
 
    MENUITEMINFOW mii = { sizeof(mii) };
    mii.fMask = MIIM_DATA;
    if (GetMenuItemInfoW(m_hSubMenu, idCmd, FALSE, &mii))
        return reinterpret_cast<SENDTO_ITEM *>(mii.dwItemData);
 
    ERR("GetMenuItemInfoW: %ld\n", GetLastError());
    return NULL;
}

Referenced by InvokeCommand().

GetCommandString()

STDMETHODIMP CSendToMenu::GetCommandString	(	UINT_PTR	idCommand,
		UINT	uFlags,
		UINT *	lpReserved,
		LPSTR	lpszName,
		UINT	uMaxNameLen
	)

Implements IContextMenu.

Definition at line 352 of file CSendToMenu.cpp.

{
    FIXME("%p %lu %u %p %p %u\n", this,
          idCmd, uType, pwReserved, pszName, cchMax);
 
    return E_NOTIMPL;
}

GetSpecialFolder()

HRESULT CSendToMenu::GetSpecialFolder ( HWND  hwnd, IShellFolder **  ppFolder, int  csidl, PIDLIST_ABSOLUTE *  ppidl = NULL  )

private

Definition at line 100 of file CSendToMenu.cpp.

{
    if (!ppFolder)
        return E_POINTER;
    *ppFolder = NULL;
 
    if (ppidl)
        *ppidl = NULL;
 
    CComHeapPtr<ITEMIDLIST_ABSOLUTE> pidl;
    HRESULT hr = SHGetSpecialFolderLocation(hwnd, csidl, &pidl);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    IShellFolder *pFolder = NULL;
    hr = m_pDesktop->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &pFolder));
 
    if (ppidl)
        *ppidl = pidl.Detach();
 
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    *ppFolder = pFolder;
    return hr;
}

Referenced by CSendToMenu(), and LoadAllItems().

GetUIObjectFromPidl()

HRESULT CSendToMenu::GetUIObjectFromPidl ( HWND  hwnd, PIDLIST_ABSOLUTE  pidl, REFIID  riid, LPVOID *  ppvOut  )

private

Definition at line 129 of file CSendToMenu.cpp.

{
    *ppvOut = NULL;
 
    PCITEMID_CHILD pidlLast;
    CComPtr<IShellFolder> pFolder;
    HRESULT hr = SHBindToParent(pidl, IID_PPV_ARG(IShellFolder, &pFolder), &pidlLast);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    hr = pFolder->GetUIObjectOf(hwnd, 1, &pidlLast, riid, NULL, ppvOut);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return hr;
}

HandleMenuMsg()

STDMETHODIMP CSendToMenu::HandleMenuMsg	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Implements IContextMenu2.

Definition at line 365 of file CSendToMenu.cpp.

{
    return S_OK;
}

HandleMenuMsg2()

STDMETHODIMP CSendToMenu::HandleMenuMsg2	(	UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam,
		LRESULT *	plResult
	)

Implements IContextMenu3.

Definition at line 371 of file CSendToMenu.cpp.

{
    UINT cxSmall = GetSystemMetrics(SM_CXSMICON);
    UINT cySmall = GetSystemMetrics(SM_CYSMICON);
 
    switch (uMsg)
    {
    case WM_MEASUREITEM:
        {
            MEASUREITEMSTRUCT* lpmis = reinterpret_cast<MEASUREITEMSTRUCT*>(lParam);
            if (!lpmis || lpmis->CtlType != ODT_MENU)
                break;
 
            UINT cxMenuCheck = GetSystemMetrics(SM_CXMENUCHECK);
            if (lpmis->itemWidth < cxMenuCheck)
                lpmis->itemWidth = cxMenuCheck;
            if (lpmis->itemHeight < cySmall)
                lpmis->itemHeight = cySmall;
 
            if (plResult)
                *plResult = TRUE;
            break;
        }
    case WM_DRAWITEM:
        {
            DRAWITEMSTRUCT* lpdis = reinterpret_cast<DRAWITEMSTRUCT*>(lParam);
            if (!lpdis || lpdis->CtlType != ODT_MENU)
                break;
 
            SENDTO_ITEM *pItem = reinterpret_cast<SENDTO_ITEM *>(lpdis->itemData);
            HICON hIcon = NULL;
            if (pItem)
                hIcon = pItem->hIcon;
            if (!hIcon)
                break;
 
            const RECT& rcItem = lpdis->rcItem;
            INT x = 4;
            INT y = lpdis->rcItem.top;
            y += (rcItem.bottom - rcItem.top - cySmall) / 2;
            DrawIconEx(lpdis->hDC, x, y, hIcon, cxSmall, cySmall,
                       0, NULL, DI_NORMAL);
 
            if (plResult)
                *plResult = TRUE;
        }
    }
 
    return S_OK;
}

Initialize()

STDMETHODIMP CSendToMenu::Initialize	(	PCIDLIST_ABSOLUTE	pidlFolder,
		IDataObject *	pdtobj,
		HKEY	hkeyProgID
	)

Implements IShellExtInit.

Definition at line 424 of file CSendToMenu.cpp.

{
    m_pDataObject = pdtobj;
    return S_OK;
}

InsertSendToItems()

UINT CSendToMenu::InsertSendToItems ( HMENU  hMenu, UINT  idFirst, UINT  idMenu  )

private

Definition at line 214 of file CSendToMenu.cpp.

{
    if (m_pItems == NULL)
    {
        HRESULT hr = LoadAllItems(NULL);
        if (FAILED_UNEXPECTEDLY(hr))
            return 0;
    }
 
    m_idCmdFirst = idCmdFirst;
 
    UINT idCmd = idCmdFirst;
    for (SENDTO_ITEM *pCurItem = m_pItems; pCurItem; pCurItem = pCurItem->pNext)
    {
        const UINT uFlags = MF_BYPOSITION | MF_STRING | MF_ENABLED;
        if (InsertMenuW(hMenu, Pos, uFlags, idCmd, pCurItem->pszText))
        {
            MENUITEMINFOW mii;
            mii.cbSize = sizeof(mii);
            mii.fMask = MIIM_DATA | MIIM_BITMAP;
            mii.dwItemData = reinterpret_cast<ULONG_PTR>(pCurItem);
            mii.hbmpItem = HBMMENU_CALLBACK;
            SetMenuItemInfoW(hMenu, idCmd, FALSE, &mii);
            ++idCmd;
 
            // successful
        }
    }
 
    if (idCmd == idCmdFirst)
    {
        CStringW strNone(MAKEINTRESOURCEW(IDS_NONE));
        AppendMenuW(hMenu, MF_GRAYED | MF_DISABLED | MF_STRING, idCmd, strNone);
        ++idCmd;
    }
 
    return idCmd - idCmdFirst;
}

Referenced by QueryContextMenu().

InvokeCommand()

STDMETHODIMP CSendToMenu::InvokeCommand

(

LPCMINVOKECOMMANDINFO

lpcmi

)

Implements IContextMenu.

Definition at line 334 of file CSendToMenu.cpp.

{
    HRESULT hr = E_FAIL;
 
    WORD idCmd = LOWORD(lpici->lpVerb);
    TRACE("idCmd: %d\n", idCmd);
 
    SENDTO_ITEM *pItem = FindItemFromIdOffset(idCmd);
    if (pItem)
    {
        hr = DoSendToItem(pItem, lpici);
    }
 
    TRACE("CSendToMenu::InvokeCommand %x\n", hr);
    return hr;
}

LoadAllItems()

HRESULT CSendToMenu::LoadAllItems ( HWND  hwnd )

private

Definition at line 159 of file CSendToMenu.cpp.

{
    UnloadAllItems();
 
    CComHeapPtr<ITEMIDLIST_ABSOLUTE> pidlSendTo;
 
    m_pSendTo.Release();
    HRESULT hr = GetSpecialFolder(hwnd, &m_pSendTo, CSIDL_SENDTO, &pidlSendTo);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    CComPtr<IEnumIDList> pEnumIDList;
    hr = m_pSendTo->EnumObjects(hwnd,
                                SHCONTF_FOLDERS | SHCONTF_NONFOLDERS,
                                &pEnumIDList);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    hr = S_OK;
    PITEMID_CHILD child;
    while (pEnumIDList->Next(1, &child, NULL) == S_OK)
    {
        CComHeapPtr<ITEMID_CHILD> pidlChild(child);
 
        STRRET strret;
        hr = m_pSendTo->GetDisplayNameOf(pidlChild, SHGDN_NORMAL, &strret);
        if (FAILED_UNEXPECTEDLY(hr))
            continue;
 
        CComHeapPtr<WCHAR> pszText;
        hr = StrRetToStrW(&strret, pidlChild, &pszText);
        if (FAILED_UNEXPECTEDLY(hr))
            continue;
 
        CComHeapPtr<ITEMIDLIST_ABSOLUTE> pidlAbsolute;
        pidlAbsolute.Attach(ILCombine(pidlSendTo, pidlChild));
 
        SHFILEINFOW fi = { NULL };
        const UINT uFlags = SHGFI_PIDL | SHGFI_TYPENAME |
                            SHGFI_ICON | SHGFI_SMALLICON;
        SHGetFileInfoW(reinterpret_cast<LPWSTR>(static_cast<PIDLIST_ABSOLUTE>(pidlAbsolute)), 0,
                       &fi, sizeof(fi), uFlags);
 
        SENDTO_ITEM *pNewItem =
            new SENDTO_ITEM(pidlChild.Detach(), pszText.Detach(), fi.hIcon);
        if (m_pItems)
        {
            pNewItem->pNext = m_pItems;
        }
        m_pItems = pNewItem;
    }
 
    return hr;
}

Referenced by InsertSendToItems().

QueryContextMenu()

STDMETHODIMP CSendToMenu::QueryContextMenu	(	HMENU	hMenu,
		UINT	indexMenu,
		UINT	idCmdFirst,
		UINT	idCmdLast,
		UINT	uFlags
	)

Implements IContextMenu.

Definition at line 289 of file CSendToMenu.cpp.

{
    TRACE("%p %p %u %u %u %u\n", this,
          hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
 
    if (uFlags & (CMF_NOVERBS | CMF_VERBSONLY))
        return MAKE_HRESULT(SEVERITY_SUCCESS, 0, idCmdFirst);
 
    HMENU hSubMenu = CreateMenu();
    if (!hSubMenu)
    {
        ERR("CreateMenu: %ld\n", GetLastError());
        return E_FAIL;
    }
 
    UINT cItems = InsertSendToItems(hSubMenu, idCmdFirst, 0);
 
    CStringW strSendTo(MAKEINTRESOURCEW(IDS_SENDTO_MENU));
 
    MENUITEMINFOW mii = { sizeof(mii) };
    mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE | MIIM_SUBMENU;
    mii.fType = MFT_STRING;
    mii.wID = -1;
    mii.dwTypeData = strSendTo.GetBuffer();
    mii.cch = wcslen(mii.dwTypeData);
    mii.fState = MFS_ENABLED;
    mii.hSubMenu = hSubMenu;
    if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
    {
        ERR("InsertMenuItemW: %ld\n", GetLastError());
        return E_FAIL;
    }
 
    HMENU hOldSubMenu = m_hSubMenu;
    m_hSubMenu = hSubMenu;
    DestroyMenu(hOldSubMenu);
 
    return MAKE_HRESULT(SEVERITY_SUCCESS, 0, idCmdFirst + cItems);
}

UnloadAllItems()

void CSendToMenu::UnloadAllItems ( )

private

Definition at line 147 of file CSendToMenu.cpp.

{
    SENDTO_ITEM *pItems = m_pItems;
    m_pItems = NULL;
    while (pItems)
    {
        SENDTO_ITEM *pCurItem = pItems;
        pItems = pItems->pNext;
        delete pCurItem;
    }
}

Referenced by LoadAllItems(), and ~CSendToMenu().

Member Data Documentation

m_hSubMenu

HMENU CSendToMenu::m_hSubMenu

private

Definition at line 61 of file CSendToMenu.h.

Referenced by FindItemFromIdOffset(), QueryContextMenu(), and ~CSendToMenu().

m_idCmdFirst

UINT CSendToMenu::m_idCmdFirst

private

Definition at line 63 of file CSendToMenu.h.

Referenced by FindItemFromIdOffset(), and InsertSendToItems().

m_pDataObject

CComPtr<IDataObject> CSendToMenu::m_pDataObject

private

Definition at line 67 of file CSendToMenu.h.

Referenced by DoSendToItem(), and Initialize().

m_pDesktop

CComPtr<IShellFolder> CSendToMenu::m_pDesktop

private

Definition at line 65 of file CSendToMenu.h.

Referenced by CSendToMenu(), and GetSpecialFolder().

m_pItems

SENDTO_ITEM* CSendToMenu::m_pItems

private

Definition at line 62 of file CSendToMenu.h.

Referenced by InsertSendToItems(), LoadAllItems(), and UnloadAllItems().

m_pSendTo

CComPtr<IShellFolder> CSendToMenu::m_pSendTo

private

Definition at line 66 of file CSendToMenu.h.

Referenced by CSendToMenu(), DoSendToItem(), and LoadAllItems().

---

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

• dll/win32/shell32/CSendToMenu.h
• dll/win32/shell32/CSendToMenu.cpp