able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/shell32/menuband/mnfolder.cpp

3374 lines
102 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "shellprv.h"
#include "common.h"
#include "menuband.h"
#include "dpastuff.h" // COrderList_*
#include "resource.h"
#include "mnbase.h"
#include "oleacc.h"
#include "mnfolder.h"
#include "icotask.h"
#include "util.h"
#include <uxtheme.h>
#define PGMP_RECALCSIZE 200
HRESULT IUnknown_RefreshParent(IUnknown* punk, LPCITEMIDLIST pidl, DWORD dwFlags)
{
IShellMenu* psm;
HRESULT hr = IUnknown_QueryService(punk, SID_SMenuBandParent, IID_PPV_ARG(IShellMenu, &psm));
if (SUCCEEDED(hr))
{
LPITEMIDLIST pidlParent = ILClone(pidl);
if (pidlParent)
{
SMDATA smd;
ILRemoveLastID(pidlParent);
smd.dwMask = SMDM_SHELLFOLDER;
smd.pidlFolder = pidlParent;
smd.pidlItem = ILFindLastID(pidl);
hr = psm->InvalidateItem(&smd, dwFlags);
ILFree(pidlParent);
}
psm->Release();
}
return hr;
}
void CMenuData::SetSubMenu(IUnknown* punk)
{
ATOMICRELEASE(_punkSubmenu);
_punkSubmenu = punk;
if (_punkSubmenu)
_punkSubmenu->AddRef();
}
HRESULT CMenuData::GetSubMenu(const GUID* pguidService, REFIID riid, void** ppv)
{
// pguidService is for asking specifically for the Shell Folder portion or the Static portion
if (_punkSubmenu)
{
if (pguidService)
{
return IUnknown_QueryService(_punkSubmenu, *pguidService, riid, ppv);
}
else
return _punkSubmenu->QueryInterface(riid, ppv);
}
else
return E_NOINTERFACE;
}
CMenuData::~CMenuData()
{
ATOMICRELEASE(_punkSubmenu);
}
STDMETHODIMP CMenuSFToolbar::QueryInterface(REFIID riid, void** ppvObj)
{
HRESULT hr = CMenuToolbarBase::QueryInterface(riid, ppvObj);
if (FAILED(hr))
hr = CSFToolbar::QueryInterface(riid, ppvObj);
return hr;
}
//-------------------------------------------------------------------------
//
// CMenuSFToolbar class
//
//-------------------------------------------------------------------------
#define SENTINEL_EMPTY 0
#define SENTINEL_CHEVRON 1
#define SENTINEL_SEP 2
#define PIDLSENTINEL(i) ((LPCITEMIDLIST)MAKEINTRESOURCE(i))
#define POISENTINEL(i) ((PORDERITEM) MAKEINTRESOURCE(i))
STDMETHODIMP CMenuSFToolbar::SetSite(IUnknown* punkSite)
{
HRESULT hr = CMenuToolbarBase::SetSite(punkSite);
if (SUCCEEDED(hr))
{
_fMulticolumnMB = BOOLIFY(_pcmb->_dwFlags & SMINIT_MULTICOLUMN);
_fMulticolumn = _fMulticolumnMB;
_fVertical = _fVerticalMB;
if (_fVerticalMB)
_dwStyle |= CCS_VERT;
}
return hr;
}
CMenuSFToolbar::CMenuSFToolbar(CMenuBand* pmb, IShellFolder* psf, LPCITEMIDLIST pidl, HKEY hKey, DWORD dwFlags)
: CMenuToolbarBase(pmb, dwFlags)
, _idCmdSep(-1)
{
// Change this to IStream
_hKey = hKey;
// Do we have a place to persist our reorder?
if (_hKey == NULL)
{
// No, then don't allow it.
_fAllowReorder = FALSE;
}
_dwStyle |= TBSTYLE_REGISTERDROP;
_dwStyle &= ~TBSTYLE_TOOLTIPS; // We handle our own tooltips.
_iDefaultIconIndex = -1;
SetShellFolder(psf, pidl);
_AfterLoad();
}
HRESULT CMenuSFToolbar::SetShellFolder(IShellFolder* psf, LPCITEMIDLIST pidl)
{
HRESULT hr = CSFToolbar::SetShellFolder(psf, pidl);
ATOMICRELEASE(_pasf2);
if (psf)
psf->QueryInterface(IID_PPV_ARG(IAugmentedShellFolder2, &_pasf2));
if (!_pasf2)
{
// SMSET_SEPARATEMERGEFOLDER requires IAugmentedShellFolder2 support
_dwFlags &= ~SMSET_SEPARATEMERGEFOLDER;
}
if (_dwFlags & SMSET_SEPARATEMERGEFOLDER)
{
// Remember the namespace GUID of the one to highlight
DWORD dwNSId;
if (SUCCEEDED(_pasf2->EnumNameSpace(0, &dwNSId)))
{
_pasf2->QueryNameSpace(dwNSId, &_guidAboveSep, NULL);
}
}
return hr;
}
CMenuSFToolbar::~CMenuSFToolbar()
{
ASSERT(_pcmb->_cRef == 0 || _pcmb->_pmtbShellFolder == NULL);
_hwndWorkerWindow = NULL; // This is destroyed by the _pmbState destructor.
// Prevent a double delete which happens in the base class.
ATOMICRELEASE(_pasf2);
if (_hKey)
RegCloseKey(_hKey);
}
void CMenuSFToolbar::v_Close()
{
CMenuToolbarBase::EmptyToolbar();
_UnregisterToolbar();
if (_hwndPager)
{
DestroyWindow(_hwndPager); // Should Destroy Toolbar.
}
else if (_hwndMB)
{
// In the MultiColumn case, there is no pager so we have to
// manually destroy the Toolbar
DestroyWindow(_hwndMB);
}
_hwndPager = NULL;
_hwndMB = NULL;
_hwndTB = NULL;
}
PIBDATA CMenuSFToolbar::_CreateItemData(PORDERITEM poi)
{
return (PIBDATA)new CMenuData(poi);
}
HRESULT CMenuSFToolbar::_AfterLoad()
{
HRESULT hr = CSFToolbar::_AfterLoad();
if (SUCCEEDED(hr))
_LoadOrderStream();
return hr;
}
HRESULT CMenuSFToolbar::_LoadOrderStream()
{
OrderList_Destroy(&_hdpaOrder);
IStream* pstm;
HRESULT hr = E_FAIL;
if (_hKey)
{
// We use "Menu" for Backwards compatibility with shdoc401 start menu, but having no
// sub key is more correct (Other places use it) so on NT5 we use the new method.
pstm = SHOpenRegStream(_hKey, (_pcmb->_dwFlags & SMINIT_LEGACYMENU) ? TEXT("Menu") : TEXT(""),
TEXT("Order"), STGM_READ);
}
else
{
if (S_FALSE == CallCB(NULL, SMC_GETSFOBJECT, (WPARAM)(GUID*)&IID_IStream, (LPARAM)(void**)&pstm))
pstm = NULL;
}
if (pstm)
{
hr = OrderList_LoadFromStream(pstm, &_hdpaOrder, _psf);
_fHasOrder = FALSE;
_fAllowReorder = TRUE;
// Check to see if we have a persisted order. If we don't have a persisted order,
// then all of the items are -1. If just one of those has a number other than
// -1, then we do have "Order" and should use that instead of alphabetizing.
if (_hdpaOrder)
{
for (int i = 0; !_fHasOrder && i < DPA_GetPtrCount(_hdpaOrder); i++)
{
PORDERITEM poi = (PORDERITEM)DPA_FastGetPtr(_hdpaOrder, i);
if (poi->nOrder != MNFOLDER_NORODER)
_fHasOrder = TRUE;
}
}
pstm->Release();
}
return hr;
}
HRESULT CMenuSFToolbar::_SaveOrderStream()
{
IStream* pstm;
HRESULT hr = E_FAIL;
// Persist the new order out to the registry
// It is reasonable to assume that if we don't have an _hdpa we have
// not filled the toolbar yet. Since we have not filled it, we haven't changed
// the order, so we don't need to persist out that order information.
if (_hdpa)
{
// Always save this information
_FindMinPromotedItems(TRUE);
// Did we load an order stream when we initialized this pane?
if (!_fHasOrder)
{
// No; Then we do not want to persist the order. We will initialize
// all of the order items to -1. This is backward compatible because
// IE 4 will merge alphabetically, but revert to a persited order when saving.
for (int i = 0; i < DPA_GetPtrCount(_hdpa); i++)
{
PORDERITEM poi = (PORDERITEM)DPA_FastGetPtr(_hdpa, i);
poi->nOrder = MNFOLDER_NORODER;
}
}
if (_hKey)
{
pstm = SHOpenRegStream(_hKey, (_pcmb->_dwFlags & SMINIT_LEGACYMENU) ? TEXT("Menu") : TEXT(""),
TEXT("Order"), STGM_CREATE | STGM_WRITE);
}
else
{
if (S_OK != CallCB(NULL, SMC_GETSFOBJECT, (WPARAM)(GUID*)&IID_IStream, (LPARAM)(void**)&pstm))
pstm = NULL;
}
if (pstm)
{
hr = OrderList_SaveToStream(pstm, _hdpaOrder ? _hdpaOrder : _hdpa, _psf);
if (SUCCEEDED(hr))
{
CallCB(NULL, SMC_SETSFOBJECT, (WPARAM)(GUID*)&IID_IStream, (LPARAM)(void**)&pstm);
}
pstm->Release();
}
}
if (SUCCEEDED(hr))
hr = CSFToolbar::_SaveOrderStream();
return hr;
}
void CMenuSFToolbar::_Dropped(int nIndex, BOOL fDroppedOnSource)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
ASSERT(_fDropping);
CSFToolbar::_Dropped(nIndex, fDroppedOnSource);
SHPlaySound(TEXT("MoveMenuItem"));
// Set this to false here because it is ugly that we don't behave like a menu right after a drop.
_fEditMode = FALSE;
// Notify the toplevel menuband of the drop in case it was popped open
// because of the drag/drop event.
//
// (There are some functionality/activation problems if we keep the
// menu up after this case. So to avoid those things at this late date,
// we're going to cancel the menu after a timeout.)
IOleCommandTarget * poct;
_pcmb->QueryService(SID_SMenuBandTop, IID_PPV_ARG(IOleCommandTarget, &poct));
if (poct)
{
poct->Exec(&CGID_MenuBand, MBANDCID_ITEMDROPPED, 0, NULL, NULL);
poct->Release();
}
_pcmb->_fDragEntered = FALSE;
}
HMENU CMenuSFToolbar::_GetContextMenu(IContextMenu* pcm, int* pid)
{
*pid += MNIDM_LAST;
HMENU hmenu = CSFToolbar::_GetContextMenu(pcm, pid);
HMENU hmenu2 = SHLoadMenuPopup(HINST_THISDLL, MENU_MNFOLDERCONTEXT);
// now find the properties insertion point and
int iCount = GetMenuItemCount(hmenu);
for (int i = 0; i < iCount; i++)
{
TCHAR szCommand[40];
UINT id = GetMenuItemID(hmenu, i);
if (IsInRange(id, *pid, 0x7fff))
{
id -= *pid;
ContextMenu_GetCommandStringVerb(pcm, id, szCommand, ARRAYSIZE(szCommand));
if (!lstrcmpi(szCommand, TEXT("properties")))
{
break;
}
}
}
Shell_MergeMenus(hmenu, hmenu2, i, 0, 0x7FFF, 0);
DestroyMenu(hmenu2);
return hmenu;
}
void CMenuSFToolbar::_OnDefaultContextCommand(int idCmd)
{
switch (idCmd)
{
case MNIDM_RESORT:
{
// We used to blow away the order stream and refill, but since we use the order stream
// for calculating the presence of new items, this promoted all of the items were were
// sorting.
HDPA hdpa = _hdpa;
// if we have a _hdpaOrder it may be out of sync and we just want to resort the
// ones in _hdpa anyway so ditch the orderlist.
OrderList_Destroy(&_hdpaOrder);
_SortDPA(hdpa);
OrderList_Reorder(hdpa);
_fChangedOrder = TRUE;
// This call knows about _hdpa and _hdpaOrder
_SaveOrderStream();
// MIKESH: this is needed because otherwise FillToolbar will use the current _hdpa
// and nothing gets changed... I think it's because OrderItem_Compare returns failure on some of the pidls
CMenuToolbarBase::EmptyToolbar();
_SetDirty(TRUE);
_LoadOrderStream();
if (_fShow)
{
_FillToolbar();
}
break;
}
}
}
LRESULT CMenuSFToolbar::_OnContextMenu(WPARAM wParam, LPARAM lParam)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
//
// When the NoSetTaskbar restriction is set, this code will disallow
// Context menus. It querys up to the Start menu to ask for permission
// to set.
LRESULT lres = 0;
// No UEM on Context Menus. This avoids the problem where we expand the menubands
// with a context menu present.
_fSuppressUserMonitor = TRUE;
// Allow the selected item to blow away the menus. This is explicitly for the Verbs "Open"
// "Print" and such that launch another process. Inprocess commands are unaffected by this.
LockSetForegroundWindow(LSFW_UNLOCK);
BOOL fOwnerIsTopmost = (WS_EX_TOPMOST & GetWindowLong(_pcmb->_pmbState->GetSubclassedHWND(), GWL_EXSTYLE));
if (fOwnerIsTopmost)
{
::SetWindowPos(_pcmb->_pmbState->GetSubclassedHWND(), HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
KillTimer(_hwndMB, MBTIMER_INFOTIP);
_pcmb->_pmbState->HideTooltip(FALSE);
if (!(_pcmb->_dwFlags & SMINIT_RESTRICT_CONTEXTMENU))
lres = CSFToolbar::_OnContextMenu(wParam, lParam);
if (fOwnerIsTopmost)
{
::SetWindowPos(_pcmb->_pmbState->GetSubclassedHWND(), HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
IUnknown_QueryServiceExec(SAFECAST(_pcmb, IOleCommandTarget*), SID_SMenuBandTop,
&CGID_MenuBand, MBANDCID_REPOSITION, TRUE, NULL, NULL);
}
// Take the capture back after the context menu
GetMessageFilter()->RetakeCapture();
return lres;
}
HRESULT CMenuSFToolbar::_GetInfo(LPCITEMIDLIST pidl, SMINFO* psminfo)
{
if (psminfo->dwMask & SMIM_TYPE)
{
psminfo->dwType = SMIT_STRING;
}
if (psminfo->dwMask & SMIM_FLAGS)
{
psminfo->dwFlags = SMIF_ICON | SMIF_DROPTARGET;
}
if (psminfo->dwMask & SMIM_ICON)
{
psminfo->dwMask &= ~SMIM_ICON;
psminfo->iIcon = -1;
}
DWORD dwAttr = SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_BROWSABLE;
// Folders that behave like shortcuts should not be considered
// as cascading menu items. Channels are an example.
// HACKHACK: to detect channels, we originally planned to GetUIObject
// IShellLink. But this doesn't work on browser-only b/c it doesn't
// pipe down to the shell extension. So as a hack, we'll key off
// the absence of SFGAO_FILESYSTEM.
// Is this a folder?
// And is it NOT a browseable folder? If it's a Browseable folder, this means that it's a namespace
// such as the Internet Namespace. The Internet name space's shell folder does not return real items, so it
// makes it useless in menus. So, filter it out, and treat it like an item.
HRESULT hr = _psf->GetAttributesOf(1, &pidl, &dwAttr);
if (SUCCEEDED(hr) && ((dwAttr & (SFGAO_FOLDER | SFGAO_BROWSABLE)) == SFGAO_FOLDER))
{
// Since SHIsExpandableFolder is such an expensive call, and we only need
// it for legacy Channels support, only do this call where channels are:
// Favorites menu and Start Menu | Favorites.
if (_dwFlags & SMSET_HASEXPANDABLEFOLDERS)
{
// Yes; but does it also behave like a shortcut?
if (SHIsExpandableFolder(_psf, pidl))
psminfo->dwFlags |= SMIF_SUBMENU;
}
else
{
// We're going to assume that if it's a folder, it really is a folder.
psminfo->dwFlags |= SMIF_SUBMENU;
}
}
CallCB(pidl, SMC_GETSFINFO, 0, (LPARAM)psminfo);
return hr;
}
/*----------------------------------------------------------
Purpose: This function determines the toolbar button style for the
given pidl.
Returns S_OK if pdwMIFFlags is also set (i.e., the object
supported IMenuBandItem to provide more info). S_FALSE if only
*pdwStyle is set.
*/
HRESULT CMenuSFToolbar::_TBStyleForPidl(LPCITEMIDLIST pidl,
DWORD * pdwStyle, DWORD* pdwState, DWORD * pdwMIFFlags, int * piIcon)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
HRESULT hr = S_FALSE;
DWORD dwStyle = TBSTYLE_BUTTON | TBSTYLE_DROPDOWN | TBSTYLE_NOPREFIX;
*pdwState = TBSTATE_ENABLED;
*pdwMIFFlags = 0;
*piIcon = -1;
if (!IS_INTRESOURCE(pidl))
{
SMINFO sminfo;
sminfo.dwMask = SMIM_TYPE | SMIM_FLAGS | SMIM_ICON;
if (SUCCEEDED(_GetInfo(pidl, &sminfo)))
{
*pdwMIFFlags = sminfo.dwFlags;
if (sminfo.dwFlags & SMIF_ACCELERATOR)
dwStyle &= ~TBSTYLE_NOPREFIX;
if (sminfo.dwType & SMIT_SEPARATOR)
{
dwStyle &= ~TBSTYLE_BUTTON;
dwStyle |= TBSTYLE_SEP;
}
if (sminfo.dwFlags & SMIF_ICON)
*piIcon = sminfo.iIcon;
if (sminfo.dwFlags & SMIF_DEMOTED &&
!_pcmb->_fExpanded)
{
*pdwState |= TBSTATE_HIDDEN;
_fHasDemotedItems = TRUE;
}
if (sminfo.dwFlags & SMIF_HIDDEN)
*pdwState |= TBSTATE_HIDDEN;
hr = S_OK;
}
}
else if (pidl == PIDLSENTINEL(SENTINEL_EMPTY) ||
pidl == PIDLSENTINEL(SENTINEL_CHEVRON))
{
// For null pidls ("empty" menuitems), there is no icon.
// SMIF_DROPTTARGET is set so the user can drop into an empty submenu.
*pdwMIFFlags = SMIF_DROPTARGET;
// Return S_OK so the pdwMIFFlags is examined.
hr = S_OK;
}
else if (pidl == PIDLSENTINEL(SENTINEL_SEP))
{
dwStyle &= ~TBSTYLE_BUTTON;
dwStyle |= TBSTYLE_SEP;
hr = S_OK;
}
*pdwStyle = dwStyle;
return hr;
}
BOOL CMenuSFToolbar::_FilterPidl(LPCITEMIDLIST pidl)
{
BOOL fRet = FALSE;
if (pidl)
{
fRet = (S_OK == CallCB(pidl, SMC_FILTERPIDL, 0, 0));
}
return fRet;
}
//
// Note: This must return exactly TRUE or FALSE.
//
BOOL CMenuSFToolbar::_IsAboveNSSeparator(LPCITEMIDLIST pidl)
{
GUID guidNS;
return (_dwFlags & SMSET_SEPARATEMERGEFOLDER) &&
SUCCEEDED(_pasf2->GetNameSpaceID(pidl, &guidNS)) &&
IsEqualGUID(guidNS, _guidAboveSep);
}
void CMenuSFToolbar::_FillDPA(HDPA hdpa, HDPA hdpaSort, DWORD dwEnumFlags)
{
_fHasSubMenu = FALSE;
CallCB(NULL, SMC_BEGINENUM, (WPARAM)&dwEnumFlags, 0);
CSFToolbar::_FillDPA(hdpa, hdpaSort, dwEnumFlags);
//
// If we are doing separators, make sure all the "above" items
// come before the "below" items.
//
// The items are almost always in the correct order already,
// with maybe one or two exceptions, so optimize for that case.
//
if (_dwFlags & SMSET_SEPARATEMERGEFOLDER)
{
// Invariant: Items 0..i-1 are _guidAboveSep
// Items i..j-1 are not _guidAboveSep
// Items j... are unknown
int i, j;
for (i = j = 0; j < DPA_GetPtrCount(hdpa); j++)
{
PORDERITEM poi = (PORDERITEM)DPA_FastGetPtr(hdpa, j);
if (_IsAboveNSSeparator(poi->pidl))
{
if (i != j)
{
DPA_InsertPtr(hdpa, i, DPA_DeletePtr(hdpa, j));
}
i++;
}
}
OrderList_Reorder(hdpa); // Recompute item numbers after we shuffled them around
}
// End of separator enforcement
CallCB(NULL, SMC_ENDENUM, 0, 0);
if (0 == DPA_GetPtrCount(hdpa) && _psf)
{
OrderList_Append(hdpa, NULL, 0); // Add a bogus pidl
_fEmpty = TRUE;
_fHasDemotedItems = FALSE;
if (_dwFlags & SMSET_NOEMPTY)
_fDontShowEmpty = TRUE;
}
else
{
_fEmpty = FALSE;
if (_dwFlags & SMSET_NOEMPTY)
_fDontShowEmpty = FALSE;
}
}
void CMenuSFToolbar::_AddChevron()
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
// Does this menu get a chevron button?
if (_fHasDemotedItems && !_pcmb->_fExpanded && _idCmdChevron == -1)
{
// Yes; (we shouldn't get here if the menu is empty)
ASSERT(!_fEmpty);
int iIndex;
// Add the chevron to the top or the bottom
if (_dwFlags & SMSET_TOP && _pcmb->_pmtbTop != _pcmb->_pmtbBottom)
iIndex = 0; // add to top
else
iIndex = ToolBar_ButtonCount(_hwndTB); // append to bottom
PIBDATA pibd = _AddOrderItemTB(POISENTINEL(SENTINEL_CHEVRON), iIndex, NULL);
// Remember where the Chevron ended up
if (pibd)
{
_idCmdChevron = GetButtonCmd(_hwndTB, iIndex);
}
}
}
void CMenuSFToolbar::_RemoveChevron()
{
if (-1 != _idCmdChevron)
{
// Yes; remove the chevron
int iPos = ToolBar_CommandToIndex(_hwndTB, _idCmdChevron);
InlineDeleteButton(iPos);
_idCmdChevron = -1;
}
}
//
// Return the index of the first item that goes below the separator.
//
// For large directories this can get called a lot so try to keep
// the running time sublinear.
//
int CMenuSFToolbar::_GetNSSeparatorPlacement()
{
//
// Invariant:
//
// if... then DPA_GetPtrCount(i) is...
// ------------------------ -----------------------------
// i < iLow above the separator
// iLow <= i < iHigh unknown
// iHigh <= i below the separator
//
// where we pretend that item -1 is above the separator and all items
// past the end of the DPA are below the separator.
//
if (!_hdpa) return -1; // Weird low-memory condition
int iLow = 0;
int iHigh = DPA_GetPtrCount(_hdpa);
while (iLow < iHigh)
{
int iMid = (iLow + iHigh) / 2;
PORDERITEM poi = (PORDERITEM)DPA_FastGetPtr(_hdpa, iMid);
if (_IsAboveNSSeparator(poi->pidl))
{
iLow = iMid + 1;
}
else
{
iHigh = iMid;
}
}
return iLow;
}
void CMenuSFToolbar::_AddNSSeparator()
{
if (_idCmdSep == -1 && (_dwFlags & SMSET_SEPARATEMERGEFOLDER))
{
int iPos = _GetNSSeparatorPlacement();
if (iPos > 0 && iPos < DPA_GetPtrCount(_hdpa))
{
PIBDATA pibd = _AddOrderItemTB(POISENTINEL(SENTINEL_SEP), iPos, NULL);
if (pibd)
{
_idCmdSep = GetButtonCmd(_hwndTB, iPos);
}
}
}
}
void CMenuSFToolbar::_RemoveNSSeparator()
{
if (-1 != _idCmdSep)
{
// Yes; remove the Sep
int iPos = ToolBar_CommandToIndex(_hwndTB, _idCmdSep);
InlineDeleteButton(iPos);
_idCmdSep = -1;
}
}
// Note! This must return exactly TRUE or FALSE.
BOOL CMenuSFToolbar::_IsBelowNSSeparator(int iIndex)
{
if (_idCmdSep != -1)
{
int iPos = ToolBar_CommandToIndex(_hwndTB, _idCmdSep);
if (iPos >= 0 && iIndex >= iPos)
{
return TRUE;
}
}
return FALSE;
}
//
// Our separator line isn't recorded in the DPA so we need to
// subtract it out...
//
int CMenuSFToolbar::v_TBIndexToDPAIndex(int iTBIndex)
{
if (_IsBelowNSSeparator(iTBIndex))
{
iTBIndex--;
}
return iTBIndex;
}
int CMenuSFToolbar::v_DPAIndexToTBIndex(int iIndex)
{
if (_IsBelowNSSeparator(iIndex))
{
iIndex++;
}
return iIndex;
}
void CMenuSFToolbar::_ToolbarChanged()
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
_pcmb->_fForceButtonUpdate = TRUE;
// We shouldn't change the size of the menubar while we're in the middle
// of a delete. Wait until we're done...
if (!_fPreventToolbarChange && _fShow && !_fEmptyingToolbar)
{
// Resize the MenuBar
HWND hwndP = _hwndPager ? GetParent(_hwndPager): GetParent(_hwndTB);
if (hwndP && (GetDesktopWindow() != hwndP))
{
RECT rcOld = {0};
RECT rcNew = {0};
GetClientRect(hwndP, &rcOld);
_pcmb->ResizeMenuBar();
GetClientRect(hwndP, &rcNew);
// If the rect sizes haven't changed, then we need to re-layout the
// band because the button widths may have changed.
if (EqualRect(&rcOld, &rcNew))
NegotiateSize();
// This pane may have changed sizes. If there is a sub menu, then
// we need to have them reposition themselves
if (_pcmb->_fInSubMenu && _pcmb->_pmtbTracked)
{
_pcmb->_pmtbTracked->PositionSubmenu(-1);
IUnknown_QueryServiceExec(_pcmb->_pmpSubMenu, SID_SMenuBandChild,
&CGID_MenuBand, MBANDCID_REPOSITION, 0, NULL, NULL);
}
}
}
}
void CMenuSFToolbar::_FillToolbar()
{
// Don't fill the toolbar if we're not dirty or we're emptying the toolbar
// If we try and fill the toolbar while we're emptying we enter a race condition
// where we could AV. This fixes a bug where when dragging a folder into the
// start menu, and cascade a menu, we empty one toolbar, which causes the
// other toolbar to get destroyed, unregister itself, flush the change notify
// queue, causing the original window to empty again... (lamadio) 7.16.98
if (_fDirty && !_fEmptyingToolbar)
{
LPITEMIDLIST pidlItem = NULL;
IShellMenu* psmSubMenu = NULL;
// Populating the menu will take a long time since we're hitting
// the disk. Give the user some feedback if the cursor is
// IDC_ARROW. (If the cursor is something else, then don't
// mess with it.) Note that we have to use (HCURSOR)-1 as a
// sentinel, because it's possible that the current cursor is NULL.
// Prevent _ToolbarChanged from Doing things. (Perf)
_fPreventToolbarChange = TRUE;
_RemoveNSSeparator();
_RemoveChevron(); // Remove the chevron...
if (S_OK == CallCB(NULL, SMC_DUMPONUPDATE, 0, 0))
{
EmptyToolbar();
}
CSFToolbar::_FillToolbar();
// If we had a Chevron before we refreshed the toolbar,
// then we need to add it back.
_AddChevron();
_AddNSSeparator(); // See if we need a separator now
if (_hwndPager)
SendMessage(_hwndPager, PGMP_RECALCSIZE, (WPARAM) 0, (LPARAM) 0);
_fPreventToolbarChange = FALSE;
_ToolbarChanged();
}
}
void CMenuSFToolbar::v_OnDeleteButton(void *pData)
{
CMenuData* pmd = (CMenuData*)pData;
if (pmd)
delete pmd;
}
void CMenuSFToolbar::v_OnEmptyToolbar()
{
CMenuToolbarBase::v_OnEmptyToolbar();
OrderList_Destroy(&_hdpa);
_fDirty = TRUE;
_nNextCommandID = 0;
}
void CMenuSFToolbar::_ObtainPIDLName(LPCITEMIDLIST pidl, LPTSTR psz, int cchMax)
{
// We overload this function because we have some special sentinel pidls
if (!IS_INTRESOURCE(pidl))
{
CSFToolbar::_ObtainPIDLName(pidl, psz, cchMax);
}
else if (pidl == PIDLSENTINEL(SENTINEL_EMPTY))
{
LoadString(HINST_THISDLL, IDS_EMPTY, psz, cchMax);
}
else
{
ASSERT(pidl == PIDLSENTINEL(SENTINEL_CHEVRON) ||
pidl == PIDLSENTINEL(SENTINEL_SEP));
StrCpyN(psz, TEXT(""), cchMax);
}
}
void CMenuSFToolbar::v_NewItem(LPCITEMIDLIST pidl)
{
// This is called when an item is present in the filesystem
// that is not in the order stream. This occurs when an item is
// created when the menu is not up.
// New items are going to have a weird Promotion state
// if there are multiple clients. Each client is going to be the create, and try to increment this.
// We have to syncronize access to this. I'm not sure how to do this.
// Note, this has not been a problem.
// New items get promoted.
CallCB(pidl, SMC_NEWITEM, 0, 0);
// Since this is a new item, we want to increment the promoted items
// so that we can do chevron tracking.
_cPromotedItems++;
}
void CMenuSFToolbar::_SetDirty(BOOL fDirty)
{
if (fDirty)
_pcmb->_fForceButtonUpdate = TRUE;
CSFToolbar::_SetDirty(fDirty);
}
void CMenuSFToolbar::_NotifyBulkOperation(BOOL fStart)
{
if (fStart)
{
_RemoveNSSeparator();
_RemoveChevron();
}
else
{
_AddChevron();
_AddNSSeparator();
}
}
void CMenuSFToolbar::_OnFSNotifyAdd(LPCITEMIDLIST pidl, DWORD dwFlags, int nIndex)
{
DWORD dwEnumFlags = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
if (!(dwFlags & FSNA_BULKADD))
{
// Removing the separator shuffles the indices around, so compensate for it here
if (_IsBelowNSSeparator(nIndex))
{
nIndex--;
}
if (_fDropping && _tbim.iButton != -1 && _IsBelowNSSeparator(_tbim.iButton))
{
_tbim.iButton--;
}
_NotifyBulkOperation(TRUE); // pretend this is a one-item bulk operation
}
CallCB(NULL, SMC_BEGINENUM, (WPARAM)&dwEnumFlags, 0);
if ((dwFlags & FSNA_ADDDEFAULT) && (_dwFlags & SMSET_SEPARATEMERGEFOLDER) &&
_IsAboveNSSeparator(pidl))
{
dwFlags &= ~FSNA_ADDDEFAULT;
nIndex = _GetNSSeparatorPlacement(); // inserts above the separator
}
CSFToolbar::_OnFSNotifyAdd(pidl, dwFlags, nIndex);
CallCB(NULL, SMC_ENDENUM, 0, 0);
// When we add something to this, we want to promote our parent.
IUnknown_RefreshParent(_pcmb->_punkSite, _pidl, SMINV_PROMOTE);
if (!(dwFlags & FSNA_BULKADD))
{
_NotifyBulkOperation(FALSE); // pretend this is a one-item bulk operation
_SaveOrderStream();
}
}
UINT ToolBar_GetVisibleCount(HWND hwnd)
{
UINT cVis = 0;
int cItems = ToolBar_ButtonCount(hwnd) - 1;
for (; cItems >= 0; cItems--)
{
TBBUTTONINFO tbinfo;
tbinfo.cbSize = sizeof(tbinfo);
tbinfo.dwMask = TBIF_BYINDEX | TBIF_STATE;
if (ToolBar_GetButtonInfo(hwnd, cItems, &tbinfo))
{
if (!(tbinfo.fsState & TBSTATE_HIDDEN))
{
cVis ++;
}
}
}
return cVis;
}
void CMenuSFToolbar::_OnFSNotifyRemove(LPCITEMIDLIST pidl)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
int i;
_RemoveNSSeparator();
_RemoveChevron();
// Check to see if this item is a promoted guy...
LPITEMIDLIST pidlButton;
if (SUCCEEDED(_GetButtonFromPidl(pidl, NULL, &i, &pidlButton)))
{
int idCmd = GetButtonCmd(_hwndMB, i);
// Is he promoted?
if (!(v_GetFlags(idCmd) & SMIF_DEMOTED))
{
// Yes, then we need to decrement the promoted count because
// we are removing a promoted guy.
_cPromotedItems--;
// We should expand if we go to zero
if (_cPromotedItems == 0)
{
// Demote the parent
IUnknown_RefreshParent(_pcmb->_punkSite, _pidl, SMINV_DEMOTE | SMINV_NEXTSHOW);
Expand(TRUE);
}
}
if (_pcmb->_fInSubMenu && _pcmb->_nItemSubMenu == idCmd)
_pcmb->_SubMenuOnSelect(MPOS_CANCELLEVEL);
}
CSFToolbar::_OnFSNotifyRemove(pidl);
//Oooppsss, we removed the only string. Replace with our "(Empty)"
// handler....
if (0 == DPA_GetPtrCount(_hdpa) && _psf && _fVerticalMB)
{
ASSERT(_fEmpty == FALSE);
// If we are Empty, then we cannot have any demoted items
// NOTE: We can have no demoted items and not be empty, so one does
// not imply the other.
_fHasDemotedItems = FALSE;
_AddPidl(NULL, FALSE, 0);
_fEmpty = TRUE;
if (_dwFlags & SMSET_NOEMPTY)
_fDontShowEmpty = TRUE;
}
if (_dwFlags & SMSET_COLLAPSEONEMPTY &&
ToolBar_GetVisibleCount(_hwndMB) == 0)
{
// When we don't want to be shown when empty, collapse.
_pcmb->_SiteOnSelect(MPOS_FULLCANCEL);
}
_AddChevron();
_AddNSSeparator();
}
void CMenuSFToolbar::_OnFSNotifyRename(LPCITEMIDLIST pidlFrom, LPCITEMIDLIST pidlTo)
{
if ((_dwFlags & SMSET_SEPARATEMERGEFOLDER) &&
_IsAboveNSSeparator(pidlFrom) != _IsAboveNSSeparator(pidlTo))
{
// This is a rename of something "to itself" but which crosses
// the separator line. Don't handle it as an internal rename;
// just ignore it and let the upcoming updatedir do the real work.
}
else
{
CSFToolbar::_OnFSNotifyRename(pidlFrom, pidlTo);
}
}
void CMenuSFToolbar::NegotiateSize()
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
HWND hwndP = _hwndPager ? GetParent(_hwndPager): GetParent(_hwndTB);
if (hwndP && (GetDesktopWindow() != hwndP))
{
RECT rc = {0};
GetClientRect(hwndP, &rc);
_pcmb->OnPosRectChangeDB(&rc);
}
}
/*----------------------------------------------------------
Purpose: CDelegateDropTarget::DragEnter
Informs Menuband that a drag has entered it's window.
*/
STDMETHODIMP CMenuSFToolbar::DragEnter(IDataObject *pdtobj, DWORD grfKeyState, POINTL pt, DWORD *pdwEffect)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
_pcmb->_fDragEntered = TRUE;
IOleCommandTarget * poct;
_pcmb->QueryService(SID_SMenuBandTop, IID_PPV_ARG(IOleCommandTarget, &poct));
if (poct)
{
poct->Exec(&CGID_MenuBand, MBANDCID_DRAGENTER, 0, NULL, NULL);
poct->Release();
}
return CSFToolbar::DragEnter(pdtobj, grfKeyState, pt, pdwEffect);
}
/*----------------------------------------------------------
Purpose: CDelegateDropTarget::DragLeave
Informs Menuband that a drag has left it's window.
*/
STDMETHODIMP CMenuSFToolbar::DragLeave(void)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
_pcmb->_fDragEntered = FALSE;
IOleCommandTarget * poct;
_pcmb->QueryService(SID_SMenuBandTop, IID_PPV_ARG(IOleCommandTarget, &poct));
if (poct)
{
poct->Exec(&CGID_MenuBand, MBANDCID_DRAGLEAVE, 0, NULL, NULL);
poct->Release();
}
return CSFToolbar::DragLeave();
}
/*----------------------------------------------------------
Purpose: CDelegateDropTarget::HitTestDDT
Returns the ID to pass to GetObject.
30
*/
HRESULT CMenuSFToolbar::HitTestDDT(UINT nEvent, LPPOINT ppt, DWORD_PTR *pdwId, DWORD *pdwEffect)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
TBINSERTMARK tbim;
DWORD dwFlags = 0;
BOOL fOnButton = FALSE;
// If we're in drag and drop, Take UEM out of the picture
_fSuppressUserMonitor = TRUE;
// Unlike the CISFBand implementation, we always want to insert
// b/t the menu items. So we return a negative index so the
// GetObject method will treat all the drops as if we're dropping
// in b/t the items, even if the cursor is over a menuitem.
switch (nEvent)
{
case HTDDT_ENTER:
// OLE is in its modal drag/drop loop, and it has the capture.
// We shouldn't take the capture back during this time.
if (!(_pcmb->_dwFlags & SMINIT_RESTRICT_DRAGDROP) &&
(S_FALSE == CallCB(NULL, SMC_SFDDRESTRICTED, NULL, NULL)))
{
// Since we've been entered, set the global state as
// having the drag. If at some point the whole menu
// heirarchy does not have the drag inside of it, we want to
// collapse the menu. This is to prevent the hanging menu syndrome.
_pcmb->_pmbState->HasDrag(TRUE);
KillTimer(_hwndMB, MBTIMER_DRAGPOPDOWN);
GetMessageFilter()->PreventCapture(TRUE);
return S_OK;
}
else
return S_FALSE;
case HTDDT_OVER:
BLOCK
{
int iButton = -1;
*pdwEffect = DROPEFFECT_NONE;
POINT pt = *ppt;
ClientToScreen(_hwndTB, &pt);
if (WindowFromPoint(pt) == _hwndPager)
{
iButton = IBHT_PAGER;
tbim.iButton = -1;
tbim.dwFlags = 0;
}
else
{
// Are we sitting BETWEEN buttons?
if (ToolBar_InsertMarkHitTest(_hwndTB, ppt, &tbim))
{
// Yes.
// Is this on the source button?
if (!(tbim.dwFlags & TBIMHT_BACKGROUND) &&
tbim.iButton == _iDragSource)
{
iButton = IBHT_SOURCE; // Yes; don't drop on the source button
}
else
{
iButton = tbim.iButton;
}
}
// No we're either sitting on a button or the background. Button?
else if (tbim.iButton != -1 && !(tbim.dwFlags & TBIMHT_BACKGROUND))
{
// On a Button. Cool.
iButton = tbim.iButton;
fOnButton = TRUE;
}
// Can this drop target even accept the drop?
int idBtn = GetButtonCmd(_hwndTB, tbim.iButton);
dwFlags = v_GetFlags(idBtn);
if (_idCmdChevron != idBtn &&
!(dwFlags & (SMIF_DROPTARGET | SMIF_DROPCASCADE)) ||
((_pcmb->_dwFlags & SMINIT_RESTRICT_DRAGDROP) ||
(S_OK == CallCB(NULL, SMC_SFDDRESTRICTED, NULL, NULL))))
{
// No
return E_FAIL;
}
}
*pdwId = iButton;
}
break;
case HTDDT_LEAVE:
// If the dropped occured in this band, then we don't want to collapse the menu
if (!_fHasDrop)
{
// Since we've been left, set the global state. If moving between panes
// then the pane that will be entered will reset this within the timeout period
_pcmb->_pmbState->HasDrag(FALSE);
_SetTimer(MBTIMER_DRAGPOPDOWN);
}
// We can take the capture back anytime now
GetMessageFilter()->PreventCapture(FALSE);
if (!_fVerticalMB)
{
tbim = _tbim;
}
else
{
// Turn off the insertion mark
tbim.iButton = -1;
tbim.dwFlags = 0;
DAD_ShowDragImage(FALSE);
ToolBar_SetInsertMark(_hwndTB, &tbim);
UpdateWindow(_hwndTB);
DAD_ShowDragImage(TRUE);
}
break;
}
// Did the drop target change?
if (tbim.iButton != _tbim.iButton || tbim.dwFlags != _tbim.dwFlags)
{
DAD_ShowDragImage(FALSE);
// Yes
// If we're sitting on a button, highlight it. Otherwise remove the hightlight.
//ToolBar_SetHotItem(_hwndTB, fOnButton? tbim.iButton : -1);
// No.
// We pop open submenus here during drag and drop. But only
// if the button has changed (not the flags). Otherwise we'd
// get flashing submenus as the cursor moves w/in a single item.
if (tbim.iButton != _tbim.iButton)
{
_SetTimer(MBTIMER_DRAGOVER);
BOOL_PTR fOldAnchor = ToolBar_SetAnchorHighlight(_hwndTB, FALSE);
ToolBar_SetHotItem(_hwndTB, -1);
_pcmb->_SiteOnSelect(MPOS_CHILDTRACKING);
ToolBar_SetAnchorHighlight(_hwndTB, fOldAnchor);
}
// for now I don't want to rely on non-filesystem IShellFolder
// implementations to call our OnChange method when a drop occurs,
// so don't even show the insert mark.
// We do not want to display the Insert mark if we do not allow reorder.
if ((_fFSNotify || _iDragSource >= 0) && (dwFlags & SMIF_DROPTARGET) && _fAllowReorder)
{
ToolBar_SetInsertMark(_hwndTB, &tbim);
}
if (ppt)
_tbim = tbim;
UpdateWindow(_hwndTB);
DAD_ShowDragImage(TRUE);
}
if (!_fVerticalMB && HTDDT_LEAVE == nEvent)
{
// Cursor leaving menuband, reset
_tbim.iButton = -1;
_iDragSource = -1;
}
return S_OK;
}
HRESULT CMenuSFToolbar::GetObjectDDT(DWORD_PTR dwId, REFIID riid, void **ppvObj)
{
HRESULT hr = E_NOINTERFACE;
int nID = (int)dwId;
*ppvObj = NULL;
if (nID == IBHT_PAGER)
{
SendMessage(_hwndPager, PGM_GETDROPTARGET, 0, (LPARAM)ppvObj);
}
// Is the target the source?
else if (nID >= 0)
{
// No; does the shellfolder support IDropTarget?
PORDERITEM poi = (PORDERITEM)DPA_GetPtr(_hdpa, v_TBIndexToDPAIndex(nID));
if (poi)
{
IShellFolder *psfCVO;
hr = _GetFolderForCreateViewObject(_IsAboveNSSeparator(poi->pidl), &psfCVO);
if (SUCCEEDED(hr))
{
// We want to pass the subclassed HWND, because all we want the parent of the context menus to be
// the Subclassed window. This is so we don't loose focus and collapse.
hr = psfCVO->CreateViewObject(_pcmb->_pmbState->GetWorkerWindow(_hwndMB), riid, ppvObj);
psfCVO->Release();
}
}
}
if (*ppvObj)
hr = S_OK;
//TraceMsg(TF_BAND, "ISFBand::GetObject(%d) returns %x", dwId, hr);
return hr;
}
HRESULT CMenuSFToolbar::_GetFolderForCreateViewObject(BOOL fAbove, IShellFolder **ppsf)
{
HRESULT hr;
*ppsf = NULL;
if (!(_dwFlags & SMSET_SEPARATEMERGEFOLDER))
{
*ppsf = _psf;
_psf->AddRef();
return S_OK;
}
//
// Is this folder a mix of items above and below the line?
//
DWORD dwIndex;
DWORD dwNSId;
GUID guid;
int cAbove = 0;
int cBelow = 0;
for (dwIndex = 0; SUCCEEDED(_pasf2->EnumNameSpace(dwIndex, &dwNSId)) &&
SUCCEEDED(_pasf2->QueryNameSpace(dwNSId, &guid, NULL));
dwIndex++)
{
if (IsEqualGUID(guid, _guidAboveSep))
{
cAbove++;
}
else
{
cBelow++;
}
}
if (cAbove == 0 || cBelow == 0)
{
// No, it's all above or all below; we can (and indeed must) use it.
// We must use it because it might be User\Start Menu\Subfolder,
// but we want it to "realize" that it can accept drops from
// a common folder and should create All Users\Start Menu\Subfolder
// as a result.
*ppsf = _psf;
_psf->AddRef();
return S_OK;
}
//
// Create a subset of the merged shell folder to describe
// only the part above or below the line.
//
//
// Create another instance of whatever shellfolder we have.
//
CLSID clsid;
hr = IUnknown_GetClassID(_psf, &clsid);
if (FAILED(hr))
{
return hr;
}
IAugmentedShellFolder *pasfNew;
hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC, IID_PPV_ARG(IAugmentedShellFolder, &pasfNew));
if (SUCCEEDED(hr))
{
// See how many namespaces there are...
hr = _pasf2->EnumNameSpace((DWORD)-1, NULL);
if (SUCCEEDED(hr))
{
// Allocate enough memory to keep track of them...
DWORD cNamespacesAlloc = HRESULT_CODE(hr);
// There had better be some namespaces because we don't even get
// here unless we find one "above" and one "below" namespace.
ASSERT(cNamespacesAlloc);
DWORD cNamespaces = 0;
QUERYNAMESPACEINFO *rgqnsi = new QUERYNAMESPACEINFO[cNamespacesAlloc];
if (rgqnsi)
{
IAugmentedShellFolder3 *pasf3;
hr = _pasf2->QueryInterface(IID_PPV_ARG(IAugmentedShellFolder3, &pasf3));
if (SUCCEEDED(hr))
{
// Collect information about them all, keep the ones we like.
//
// Note that in this loop we do not save the error failure from EnumNameSpace
// because we expect it to fail (with NO_MORE_ITEMS) and we don't want
// that to cause us to panic and bail out
DWORD dwFlagsMissing = ASFF_DEFNAMESPACE_ALL;
QUERYNAMESPACEINFO *pqnsi = rgqnsi;
for (dwIndex = 0; SUCCEEDED(pasf3->EnumNameSpace(dwIndex, &dwNSId)); dwIndex++)
{
ASSERT(cNamespaces < cNamespacesAlloc); // if this assert fires, then EnumNameSpace lied to us!
pqnsi->cbSize = sizeof(QUERYNAMESPACEINFO);
pqnsi->dwMask = ASFQNSI_FLAGS | ASFQNSI_FOLDER | ASFQNSI_GUID | ASFQNSI_PIDL;
hr = pasf3->QueryNameSpace2(dwNSId, pqnsi);
if (FAILED(hr))
{
break; // Fail!
}
if (BOOLIFY(IsEqualGUID(pqnsi->guidObject, _guidAboveSep)) == fAbove)
{
dwFlagsMissing &= ~pqnsi->dwFlags;
pqnsi++;
cNamespaces++;
}
else
{
ATOMICRELEASE(pqnsi->psf);
ILFree(pqnsi->pidl);
}
}
// Any ASFF_DEFNAMESPACE_* flags that nobody claimed,
// give them to the first namespace.
if (cNamespaces)
{
rgqnsi[0].dwFlags |= dwFlagsMissing;
}
// Add in all the namespaces
for (dwIndex = 0; SUCCEEDED(hr) && dwIndex < cNamespaces; dwIndex++)
{
hr = pasfNew->AddNameSpace(&rgqnsi[dwIndex].guidObject,
rgqnsi[dwIndex].psf,
rgqnsi[dwIndex].pidl,
rgqnsi[dwIndex].dwFlags);
}
pasf3->Release();
} // QueryInterface
//
// Now free all the memory we allocated...
//
for (dwIndex = 0; dwIndex < cNamespaces; dwIndex++)
{
ATOMICRELEASE(rgqnsi[dwIndex].psf);
ILFree(rgqnsi[dwIndex].pidl);
}
delete [] rgqnsi;
}
else
{
hr = E_OUTOFMEMORY; // "new" failed
}
}
if (SUCCEEDED(hr))
{
*ppsf = pasfNew; // transfer ownership to caller
}
else
{
pasfNew->Release();
}
}
return hr;
}
// S_OK if the drop was handled. Otherwise S_FALSE.
HRESULT CMenuSFToolbar::OnDropDDT(IDropTarget *pdt, IDataObject *pdtobj, DWORD * pgrfKeyState, POINTL pt, DWORD *pdwEffect)
{
// Since the modal drag-drop loop released the capture, take it
// back so we behave properly.
KillTimer(_hwndMB, MBTIMER_DRAGPOPDOWN);
HRESULT hr = S_FALSE;
// If this drop came from us, but it came from the other side of the
// separator, then act as if it didn't come from us after all.
if (_iDragSource >= 0 &&
(_dwFlags & SMSET_SEPARATEMERGEFOLDER) &&
_IsBelowNSSeparator(_iDragSource) != _IsBelowNSSeparator(_tbim.iButton))
{
_iDragSource = -1; // act as if the object came from somewhere else
}
// We need to say that the last drag leave is really the drop.
_fHasDrop = TRUE;
_idCmdDragging = -1;
LockSetForegroundWindow(LSFW_LOCK);
// Only send an hwnd to the callback if the drop source is external
if (!(_pcmb->_dwFlags & SMINIT_RESTRICT_DRAGDROP) &&
(S_FALSE == CallCB(NULL, SMC_SFDDRESTRICTED, (WPARAM)pdtobj,
(LPARAM)(_iDragSource < 0 ? GetHWNDForUIObject() : NULL))))
{
int iButtonOrig = _tbim.iButton;
// Removing the separator shuffles the indices around, so compensate for it here
if (_iDragSource >= 0 && _IsBelowNSSeparator(_iDragSource))
{
_iDragSource--;
}
if (_tbim.iButton != -1 && _IsBelowNSSeparator(_tbim.iButton))
{
_tbim.iButton--;
}
_RemoveNSSeparator();
_RemoveChevron();
hr = CSFToolbar::OnDropDDT(pdt, pdtobj, pgrfKeyState, pt, pdwEffect);
_AddChevron();
_AddNSSeparator();
_tbim.iButton = iButtonOrig;
}
LockSetForegroundWindow(LSFW_UNLOCK);
return hr;
}
PIBDATA CMenuSFToolbar::_AddOrderItemTB(PORDERITEM poi, int index, TBBUTTON* ptbb)
{
PIBDATA pibd = CSFToolbar::_AddOrderItemTB(poi, index, ptbb);
if (pibd)
{
if (pibd->GetFlags() & SMIF_SUBMENU)
{
_fHasSubMenu = TRUE;
}
}
return pibd;
}
BOOL CMenuSFToolbar::_AddPidl(LPITEMIDLIST pidl, DWORD dwFlags, int index)
{
BOOL bRet;
// Is this item being added to an empty menu?
// also, if the pidl is null then that means we're trying to add an "empty"
// tag. in that case we don't want to run through the code of preemptively
// removing the "empty" menu item and then adding it back on failure,
// so we go right to the else statement.
if (_fEmpty && pidl)
{
// Yes; remove the empty menu item
InlineDeleteButton(0);
DPA_DeletePtr(_hdpa, 0);
_fEmpty = FALSE;
if (_dwFlags & SMSET_NOEMPTY)
_fDontShowEmpty = FALSE;
bRet = CSFToolbar::_AddPidl(pidl, dwFlags, index);
// Failed to add new item?
if (!bRet)
{
// Yes; add the empty menu item back
OrderList_Append(_hdpa, NULL, 0); // Add a bogus pidl
_fEmpty = TRUE;
_fHasDemotedItems = FALSE;
if (_dwFlags & SMSET_NOEMPTY)
_fDontShowEmpty = TRUE;
}
}
else
bRet = CSFToolbar::_AddPidl(pidl, dwFlags, index);
return bRet;
}
BOOL CMenuSFToolbar::_ReBindToFolder(LPCITEMIDLIST pidl)
{
// We may be able to share this code with the code in _FillToolbar, but the difference is,
// in Fill Toolbar, the Toolbar Button does not have a Sub Menu. We reinitialize one we save away,
// and force it back into the child button. Here, we have the luxury of having the Sub Menu still
// in the toolbar button. I may be able to extract common code into a separate function. Left
// as an exercise to the reader.
// Need special Handling for this. We need to free the sub menu and
// rebind to it ifit's up.
BOOL fBound = FALSE;
TBBUTTONINFO tbinfo = {0};
tbinfo.dwMask = TBIF_COMMAND | TBIF_LPARAM;
LPITEMIDLIST pidlItem;
if (SUCCEEDED(_GetButtonFromPidl(ILFindLastID(pidl), &tbinfo, NULL, &pidlItem)))
{
CMenuData* pmd = (CMenuData*)tbinfo.lParam;
if (EVAL(pmd))
{
IShellFolderBand* psfb;
// We have the Toolbar button into, we should see if it has a sub menu associated with it.
if (SUCCEEDED(pmd->GetSubMenu(&SID_MenuShellFolder, IID_PPV_ARG(IShellFolderBand, &psfb))))
{
// It does. Then reuse!
LPITEMIDLIST pidlFull = NULL;
IShellFolder* psf = NULL;
if (_pasf2)
{
LPITEMIDLIST pidlFolder, pidlChild;
// Remember: Folder pidls must be unwrapped.
_pasf2->UnWrapIDList(pidlItem, 1, NULL, &pidlFolder, &pidlChild, NULL);
pidlFull = ILCombine(pidlFolder, pidlChild);
ILFree(pidlChild);
ILFree(pidlFolder);
}
else
{
// Not a wrapped guy, Sweet!
pidlFull = ILCombine(_pidl, pidlItem);
}
_psf->BindToObject(pidlItem, NULL, IID_PPV_ARG(IShellFolder, &psf));
if (psf)
{
if (pidlFull)
{
fBound = SUCCEEDED(psfb->InitializeSFB(psf, pidlFull));
if (fBound)
{
_pcmb->_nItemSubMenu = tbinfo.idCommand;
}
}
psf->Release();
}
ILFree(pidlFull);
psfb->Release();
}
}
}
return fBound;
}
HRESULT CMenuSFToolbar::OnTranslatedChange(LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
HRESULT hr = CSFToolbar::OnTranslatedChange(lEvent, pidl1, pidl2);
if (SUCCEEDED(hr))
{
switch(lEvent)
{
case SHCNE_RENAMEFOLDER:
if (_IsChildID(pidl2, TRUE))
{
_ReBindToFolder(pidl2);
}
break;
case SHCNE_RMDIR:
if (_IsChildID(pidl1, TRUE))
{
_ReBindToFolder(pidl1);
}
break;
case SHCNE_EXTENDED_EVENT:
{
SHChangeDWORDAsIDList UNALIGNED * pdwidl = (SHChangeDWORDAsIDList UNALIGNED *)pidl1;
if (_IsChildID(pidl2, TRUE))
{
if (!SHChangeMenuWasSentByMe(this, pidl1))
{
DWORD dwFlags = SMINV_NOCALLBACK; // So that we don't doubly increment
SMDATA smd = {0};
smd.dwMask = SMDM_SHELLFOLDER;
smd.pidlFolder = _pidl;
smd.pidlItem = ILFindLastID(pidl2);
// Syncronize Promotion state.
if (pdwidl->dwItem1 == SHCNEE_PROMOTEDITEM)
{
dwFlags |= SMINV_PROMOTE;
}
else if (pdwidl->dwItem1 == SHCNEE_DEMOTEDITEM)
{
dwFlags |= SMINV_DEMOTE;
}
// Are we actually doing something?
if (SMINV_NOCALLBACK != dwFlags)
{
v_InvalidateItem(&smd, dwFlags);
}
}
}
}
break;
default:
break;
}
}
return hr;
}
// IShellChangeNotify::OnChange
HRESULT CMenuSFToolbar::OnChange(LONG lEvent, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
HRESULT hr = E_FAIL;
// If we're in the middle of being destroyed, don't process this.
if (!_hwndMB)
return S_OK;
AddRef();
_pcmb->_pmbState->PushChangeNotify();
SMCSHCHANGENOTIFYSTRUCT shns;
shns.lEvent = lEvent;
shns.pidl1 = pidl1;
shns.pidl2 = pidl2;
CallCB(NULL, SMC_SHCHANGENOTIFY, NULL, (LPARAM)&shns); // Ignore return value. Notify only.
// Since we may be removing the selected item, we want the selection to move to the next item
int iHot = ToolBar_GetHotItem(_hwndMB);
hr = CSFToolbar::OnChange(lEvent, pidl1, pidl2);
// Is this a child of this toolbar is some shape or form?
// 1) The changing pidl is a child of this pane.
// 2) What the pidl is changing to is in this pane (For renames)
// 3) Updatedirs. Recursive change notifies must forward update dirs all the way down the chain.
// 4) EXTENDED events with a pidl2 == NULL. This means Reorder all your items.
if (_IsChildID(pidl1, FALSE) ||
_IsChildID(pidl2, FALSE) ||
lEvent == SHCNE_UPDATEDIR ||
(lEvent == SHCNE_EXTENDED_EVENT &&
pidl2 == NULL))
{
// We need to forward this down then.
HRESULT hrInner = _pcmb->ForwardChangeNotify(lEvent, pidl1, pidl2);
// Did either of us handle this change?
if (SUCCEEDED(hrInner) || SUCCEEDED(hr))
{
hr = S_OK;
}
else if (lEvent != SHCNE_EXTENDED_EVENT) // Don't bother with extended events...
{
// Ok so neither of us handled this?
// Must be the SHChangeNotifyCollapsing code that collapses
// the Directory Create and item create into a single item create.
// We need to force an update dir on ourselves so that we get this change.
hr = CSFToolbar::OnChange(SHCNE_UPDATEDIR, pidl1, pidl2);
}
}
// Set the hot item back, wrapping if necessary.
if (ToolBar_GetHotItem(_hwndMB) != iHot)
SetHotItem(1, iHot, -1, 0);
_pcmb->_pmbState->PopChangeNotify();
Release();
return hr;
}
void CMenuSFToolbar::_OnDragBegin(int iItem, DWORD dwPreferredEffect)
{
// During drag and drop, allow dialogs to collapse menu.
LockSetForegroundWindow(LSFW_UNLOCK);
LPCITEMIDLIST pidl = _IDToPidl(iItem, NULL);
dwPreferredEffect = DROPEFFECT_MOVE;
CallCB(pidl, SMC_BEGINDRAG, (WPARAM)&dwPreferredEffect, 0);
CSFToolbar::_OnDragBegin(iItem, dwPreferredEffect);
if (_fEditMode)
SetTimer(_hwndTB, MBTIMER_ENDEDIT, MBTIMER_ENDEDITTIME, 0);
}
void CMenuSFToolbar::v_SendMenuNotification(UINT idCmd, BOOL fClear)
{
if (fClear)
{
// If we're clearing, tell the browser
PostMessage(_pcmb->_pmbState->GetSubclassedHWND(), WM_MENUSELECT,
MAKEWPARAM(0, -1), NULL);
}
else
{
PIBDATA pibdata = _IDToPibData(idCmd);
LPCITEMIDLIST pidl;
// Only send notifications for non submenu items
if (EVAL(pibdata) && (pidl = pibdata->GetPidl()))
{
CallCB(pidl, SMC_SFSELECTITEM, 0, 0);
// Don't free Pidl
}
}
}
LRESULT CMenuSFToolbar::_OnGetObject(NMOBJECTNOTIFY* pnmon)
{
pnmon->hResult = QueryInterface(*pnmon->piid, &pnmon->pObject);
return 1;
}
LRESULT CMenuSFToolbar::_OnNotify(LPNMHDR pnm)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
LRESULT lres = 0;
// These are notifies we handle even when disengaged from the message hook.
switch (pnm->code)
{
case TBN_DELETINGBUTTON:
if (_fEmptyingToolbar)
return 0;
else
goto DoDefault;
break;
case TBN_GETDISPINFOA:
case TBN_GETDISPINFOW:
case NM_CUSTOMDRAW:
goto DoDefault;
}
// Pager notifications MUST be forwarded even when the message hook is disengaged.
if ((pnm->code <= PGN_FIRST) && (pnm->code >= PGN_LAST))
{
goto DoNotify;
}
// Is the Global Message filter Disengaged? This will happen when the Subclassed window
// looses activation to a dialog box of some kind.
if (lres == 0 && !GetMessageFilter()->IsEngaged())
{
// Yes; We've lost activation so we don't want to track like a normal menu...
// For hot item change, return 1 so that the toolbar does not change the hot item.
if (pnm->code == TBN_HOTITEMCHANGE && _pcmb->_fMenuMode)
return 1;
// For all other items, don't do anything....
return 0;
}
DoNotify:
switch (pnm->code)
{
case PGN_SCROLL:
KillTimer(_hwndMB, MBTIMER_DRAGPOPDOWN);
if (_pcmb->_fInSubMenu)
_pcmb->_SubMenuOnSelect(MPOS_CANCELLEVEL);
_fSuppressUserMonitor = TRUE;
break;
case TBN_GETOBJECT:
lres = _OnGetObject((NMOBJECTNOTIFY*)pnm);
break;
case TBN_DRAGOUT:
{
TBNOTIFY *ptbn = (TBNOTIFY*)pnm;
if (!_fEmpty && !_IsSpecialCmd(ptbn->iItem) &&
!(_pcmb->_dwFlags & SMINIT_RESTRICT_DRAGDROP) &&
(S_FALSE == CallCB(NULL, SMC_SFDDRESTRICTED, NULL, NULL)))
{
// We're now in edit mode
_fEditMode = TRUE;
_idCmdDragging = ptbn->iItem;
_MarkItem(ptbn->iItem);
lres = 1; // Allow the drag to occur
goto DoDefault;
}
else
lres = 0; // Do not allow the drag out.
}
break;
default:
DoDefault:
lres = CMenuToolbarBase::_OnNotify(pnm);
if (lres == 0)
{
lres = CSFToolbar::_OnNotify(pnm);
}
break;
}
return lres;
}
HRESULT CMenuSFToolbar::CreateToolbar(HWND hwndParent)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
HRESULT hr = CSFToolbar::_CreateToolbar(hwndParent);
if (SUCCEEDED(hr))
{
if (_hwndPager)
{
SHSetWindowBits(_hwndPager, GWL_STYLE, PGS_DRAGNDROP, PGS_DRAGNDROP);
SHSetWindowBits(_hwndPager, GWL_STYLE, PGS_AUTOSCROLL, PGS_AUTOSCROLL);
SHSetWindowBits(_hwndPager, GWL_STYLE, PGS_HORZ|PGS_VERT,
_fVertical ? PGS_VERT : PGS_HORZ);
}
_hwndMB = _hwndTB;
SetWindowTheme(_hwndMB, L"", L"");
hr = CMenuToolbarBase::CreateToolbar(hwndParent);
// By "Registering optimized" means that someone else is going to pass the change to us,
// we don't need to register for it. This is for the disjoint Fast Items | Programs menu case.
// We still need top level change notify registration for Favorites, Documents, Printers and Control
// Panel (Depending on their visibility)
//
if (_pcmb->_uId == MNFOLDER_IS_PARENT ||
(_dwFlags & SMSET_DONTREGISTERCHANGENOTIFY))
_fRegisterChangeNotify = FALSE;
// This is a good as spot as any to do this:
_RegisterToolbar();
}
return hr;
}
HKEY CMenuSFToolbar::_GetKey(LPCITEMIDLIST pidl)
{
HKEY hMenuKey;
DWORD dwDisp;
TCHAR szDisplay[MAX_PATH];
if (!_hKey)
return NULL;
_ObtainPIDLName(pidl, szDisplay, ARRAYSIZE(szDisplay));
RegCreateKeyEx(_hKey, szDisplay, NULL, NULL,
REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE,
NULL, &hMenuKey, &dwDisp);
TraceMsg(TF_MENUBAND, "%d is setting %s\'s Key to %d", _hKey, szDisplay, hMenuKey);
return hMenuKey;
}
//***
// NOTES
// idtCmd is currently always -1. we'll need other values when we're
// called from CallCB. however we can't do that until we move idtCmd
// 'down' into CallCB.
HRESULT CMenuSFToolbar::v_GetState(int idtCmd, LPSMDATA psmd)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
HRESULT hr = E_FAIL;
CMenuData* pdata;
LPITEMIDLIST pidl = NULL;
psmd->dwMask = SMDM_SHELLFOLDER;
if (idtCmd == -1)
idtCmd = GetButtonCmd(_hwndTB, ToolBar_GetHotItem(_hwndTB));
pdata = (CMenuData*)_IDToPibData(idtCmd);
if (EVAL(pdata))
{
pidl = pdata->GetPidl();
ASSERT(IS_VALID_PIDL(pidl));
}
if (pidl)
{
if (_pasf2 && S_OK == _pasf2->UnWrapIDList(pidl, 1, &psmd->psf, &psmd->pidlFolder, &psmd->pidlItem, NULL))
{
/*NOTHING*/
;
}
else
{
// Then it must be a straight ShellFolder.
psmd->psf = _psf;
if (EVAL(psmd->psf))
psmd->psf->AddRef();
psmd->pidlFolder = ILClone(_pidl);
psmd->pidlItem = ILClone(ILFindLastID(pidl));
}
psmd->uIdParent = _pcmb->_uId;
psmd->punk = SAFECAST(_pcmb, IShellMenu*);
psmd->punk->AddRef();
hr = S_OK;
}
return hr;
}
HRESULT CMenuSFToolbar::CallCB(LPCITEMIDLIST pidl, DWORD dwMsg, WPARAM wParam, LPARAM lParam)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
if (!_pcmb->_psmcb)
return S_FALSE;
SMDATA smd;
HRESULT hr = S_FALSE;
BOOL fDestroy = FALSE;
// todo: call v_GetState (but need idCmd for pidl)
smd.dwMask = SMDM_SHELLFOLDER;
if (pidl)
{
// We used to unwrap the pidl here in the case of AUGMISF, but why? In the Callback, we only
// needed the Full pidl for Executing and for Darwin. The unwrap is an expensive call that in
// the majority case wasn't even used. Put it on the client to unwrap it. Start Menu is the
// only user of Augmented shell folders anyway....
smd.psf = _psf;
smd.pidlFolder = _pidl;
smd.pidlItem = (LPITEMIDLIST)pidl;
}
else
{
// Null pidl means tell the callback about me...
smd.pidlItem = ILClone(ILFindLastID(_pidl));
smd.pidlFolder = ILClone(_pidl);
ILRemoveLastID(smd.pidlFolder);
smd.psf = NULL; // Incase bind fails.
IEBindToObject(smd.pidlFolder, &smd.psf);
fDestroy = TRUE;
}
smd.uIdParent = _pcmb->_uId;
smd.uIdAncestor = _pcmb->_uIdAncestor;
smd.punk = SAFECAST(_pcmb, IShellMenu*);
smd.pvUserData = _pcmb->_pvUserData;
hr = _pcmb->_psmcb->CallbackSM(&smd, dwMsg, wParam, lParam);
if (fDestroy)
{
ATOMICRELEASE(smd.psf);
ILFree(smd.pidlFolder);
ILFree(smd.pidlItem);
}
return hr;
}
HRESULT CMenuSFToolbar::v_CallCBItem(int idtCmd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPCITEMIDLIST pidl = NULL;
CMenuData* pdata = NULL;
// Optimization:
if (uMsg == SMC_CUSTOMDRAW)
{
NMCUSTOMDRAW * pnmcd = (NMCUSTOMDRAW *)lParam;
if (pnmcd ->dwDrawStage & CDDS_ITEM)
{
pdata = (CMenuData*)pnmcd ->lItemlParam;
ASSERT(pdata);
}
}
else
{
pdata = (CMenuData*)_IDToPibData(idtCmd);
ASSERT(pdata);
}
if (pdata)
{
ASSERT(pdata->GetPidl() == NULL || IS_VALID_PIDL(pdata->GetPidl()));
pidl = pdata->GetPidl();
}
return CallCB(pidl, uMsg, wParam, lParam);
}
HRESULT CMenuSFToolbar::v_GetSubMenu(int idCmd, const GUID* pguidService, REFIID riid, void** ppvObj)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
CMenuData* pdata = (CMenuData*)_IDToPibData(idCmd);
HRESULT hr;
ASSERT(IS_VALID_WRITE_PTR(ppvObj, void*));
*ppvObj = NULL;
if (pdata && pdata->GetFlags() & SMIF_SUBMENU)
{
hr = pdata->GetSubMenu(pguidService, riid, (void**)ppvObj);
if (FAILED(hr) && IsEqualGUID(riid, IID_IShellMenu))
{
hr = CallCB(pdata->GetPidl(), SMC_GETSFOBJECT, (WPARAM)&riid, (LPARAM)ppvObj);
if (SUCCEEDED(hr))
{
BOOL fCache = TRUE;
if (S_OK != hr)
{
hr = E_FAIL;
IShellMenu* psm = (IShellMenu*) new CMenuBand();
if (psm)
{
IShellFolder* psf = NULL;
LPITEMIDLIST pidlItem = pdata->GetPidl();
LPITEMIDLIST pidlFolder = _pidl;
BOOL fDestroy = FALSE;
IShellMenuCallback* psmcb;
// Ask the callback if they want to supply a different callback
// object for this sub menu. If they do, then use what they
// pass back NOTE: If they pass back S_OK, it's perfectly Ok,
// for them to pass back a NULL psmcb. This means, I don't want
// my child to have a callback. Use the default.
// If they don't handle it, then use their pointer.
if (S_FALSE == CallCB(pdata->GetPidl(), SMC_GETSFOBJECT,
(WPARAM)&IID_IShellMenuCallback, (LPARAM)&psmcb))
{
psmcb = _pcmb->_psmcb;
if (psmcb)
psmcb->AddRef();
}
// This has to be before the unwrap because it does name resolution through
// the Augmented ISF.
HKEY hMenuKey = _GetKey(pidlItem);
if (_pasf2)
{
if (S_OK == _pasf2->UnWrapIDList(pdata->GetPidl(), 1, &psf, &pidlFolder, &pidlItem, NULL))
{
psf->Release(); // I don't need this
psf = NULL;
fDestroy = TRUE;
}
_pasf2->BindToObject(pdata->GetPidl(), NULL, IID_PPV_ARG(IShellFolder, &psf));
}
// Inherit the flags from the parent...
DWORD dwFlags = SMINIT_VERTICAL |
(_pcmb->_dwFlags & (SMINIT_RESTRICT_CONTEXTMENU |
SMINIT_RESTRICT_DRAGDROP |
SMINIT_MULTICOLUMN));
LPITEMIDLIST pidlFull = ILCombine(pidlFolder, pidlItem);
if (psf == NULL)
{
hr = _psf->BindToObject(pidlItem, NULL, IID_PPV_ARG(IShellFolder, &psf));
}
LPCITEMIDLIST pidlWrappedItem = pdata->GetPidl();
// _psf can be an augmented shell folder. Use the wrapped item....
DWORD dwAttrib = SFGAO_LINK | SFGAO_FOLDER;
if (SUCCEEDED(_psf->GetAttributesOf(1, (LPCITEMIDLIST*)&pidlWrappedItem, &dwAttrib)) &&
(dwAttrib & (SFGAO_LINK | SFGAO_FOLDER)) == (SFGAO_LINK | SFGAO_FOLDER))
{
// folder shortcuts, We're not going to persist anything
RegCloseKey(hMenuKey);
hMenuKey = NULL;
psmcb = NULL; // We're not going to pass a callback. NOTE: We don't need to release this
dwFlags &= ~SMINIT_MULTICOLUMN; // No multi on FShortcut...
fCache = FALSE;
}
UINT uIdAncestor = _pcmb->_uIdAncestor;
if (uIdAncestor == ANCESTORDEFAULT)
uIdAncestor = idCmd;
psm->Initialize(psmcb, MNFOLDER_IS_PARENT, uIdAncestor, dwFlags);
if (psf)
{
hr = psm->SetShellFolder(psf, pidlFull, hMenuKey,
_dwFlags & (SMSET_HASEXPANDABLEFOLDERS | SMSET_USEBKICONEXTRACTION));
if (SUCCEEDED(hr))
{
hr = psm->QueryInterface(riid, ppvObj);
}
psf->Release();
}
ILFree(pidlFull);
_SetMenuBand(psm);
psm->Release();
if (psmcb)
psmcb->Release();
if (fDestroy)
{
ILFree(pidlFolder);
ILFree(pidlItem);
}
}
}
if (*ppvObj)
{
if (fCache)
{
pdata->SetSubMenu((IUnknown*)*ppvObj);
}
VARIANT Var;
Var.vt = VT_UNKNOWN;
Var.byref = SAFECAST(_pcmb->_pmbm, IUnknown*);
// Set the CMenuBandMetrics into the new menuband
IUnknown_Exec((IUnknown*)*ppvObj, &CGID_MenuBand, MBANDCID_SETFONTS, 0, &Var, NULL);
// Set the CMenuBandState into the new menuband
Var.vt = VT_INT_PTR;
Var.byref = _pcmb->_pmbState;
IUnknown_Exec((IUnknown*)*ppvObj, &CGID_MenuBand, MBANDCID_SETSTATEOBJECT, 0, &Var, NULL);
}
}
}
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
}
return hr;
}
DWORD CMenuSFToolbar::v_GetFlags(int idCmd)
{
CMenuData* pdata = (CMenuData*)_IDToPibData(idCmd);
// Toolbar is allowed to pass a bad command in the case of background erase
if (pdata)
return pdata->GetFlags();
else
return 0;
}
// This is to tell all other clients that we updated the promotion state of something.
void CMenuSFToolbar::BroadcastIntelliMenuState(LPCITEMIDLIST pidlItem, BOOL fPromoted)
{
LPITEMIDLIST pidlFolder;
LPITEMIDLIST pidlItemUnwrapped;
LPITEMIDLIST pidlFull;
if (_pasf2 && S_OK == _pasf2->UnWrapIDList(pidlItem, 1, NULL, &pidlFolder, &pidlItemUnwrapped, NULL))
{
pidlFull = ILCombine(pidlFolder, pidlItemUnwrapped);
ILFree(pidlFolder);
ILFree(pidlItemUnwrapped);
}
else
{
pidlFull = ILCombine(_pidl, pidlItem);
}
SHSendChangeMenuNotify(this,
fPromoted ? SHCNEE_PROMOTEDITEM : SHCNEE_DEMOTEDITEM,
0, pidlFull);
ILFree(pidlFull);
}
STDAPI SHInvokeCommandWithFlags(HWND hwnd, IShellFolder* psf, LPCITEMIDLIST pidlItem, DWORD dwFlags, LPCSTR lpVerb)
{
HRESULT hr = E_FAIL;
if (psf)
{
IContextMenu *pcm;
if (SUCCEEDED(psf->GetUIObjectOf(hwnd, 1, &pidlItem, IID_X_PPV_ARG(IContextMenu, 0, &pcm))))
{
dwFlags |= IsOS(OS_WHISTLERORGREATER) ? CMIC_MASK_FLAG_LOG_USAGE : 0;
hr = SHInvokeCommandsOnContextMenu(hwnd, NULL, pcm, dwFlags, lpVerb ? &lpVerb : NULL, lpVerb ? 1 : 0);
pcm->Release();
}
}
return hr;
}
HRESULT CMenuSFToolbar::v_ExecItem(int idCmd)
{
CMenuData* pdata = (CMenuData*)_IDToPibData(idCmd);
HRESULT hr = E_FAIL;
if (pdata && !_fEmpty && !(_IsSpecialCmd(idCmd)))
{
// STRESS: pdata was becomming 0x8 for some reason after the InvokeDefault.
// I assume that this call was causing a flush, which frees our list of pidls.
// So, I'm cloning it. I also changed the order, so that we'll just fire the
// UEM event.
LPITEMIDLIST pidl = ILClone(pdata->GetPidl());
if (pidl)
{
ASSERT(IS_VALID_PIDL(pidl));
SMDATA smd;
smd.dwMask = SMDM_SHELLFOLDER;
smd.pidlFolder = _pidl;
smd.pidlItem = pidl;
// SMINV_FORCE here also tells the Start Menu that the invoke
// came from an Exec
v_InvalidateItem(&smd, SMINV_PROMOTE | SMINV_FORCE);
hr = CallCB(pidl, SMC_SFEXEC, 0, 0);
// Did the Callback handle this execute for us?
if (hr == S_FALSE)
{
// No, Ok, do it ourselves.
hr = SHInvokeCommandWithFlags(_hwndTB, _psf, pidl, CMIC_MASK_ASYNCOK, NULL);
}
ILFree(pidl);
}
}
return hr;
}
HRESULT CMenuSFToolbar::v_GetInfoTip(int idCmd, LPTSTR psz, UINT cch)
{
CMenuData* pdata = (CMenuData*)_IDToPibData(idCmd);
HRESULT hr = E_FAIL;
if (_fEmpty || !pdata)
return hr;
// make a copy of the pidl that we're using, since we can get reentered in the sendmessage
// and free the data from the dpa.
LPITEMIDLIST pidlCopy = ILClone(pdata->GetPidl());
// dont worry about failure -- pdata->GetPidl() can be NULL anyway,
// in which case ILClone will return NULL, and CallCB and GetInfoTip already have NULL checks.
hr = CallCB(pidlCopy, SMC_GETSFINFOTIP, (WPARAM)psz, (LPARAM)cch);
if (S_FALSE == hr)
{
hr = E_FAIL;
if (GetInfoTip(_psf, pidlCopy, psz, cch))
{
hr = S_OK;
}
}
ILFree(pidlCopy);
return hr;
}
void CMenuSFToolbar::v_ForwardMouseMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT rc;
POINT pt;
HWND hwndFwd;
// These are in screen coords
pt.x = GET_X_LPARAM(lParam);
pt.y = GET_Y_LPARAM(lParam);
hwndFwd = _hwndPager ? _hwndPager : _hwndTB;
GetWindowRect(hwndFwd, &rc);
if (PtInRect(&rc, pt))
{
MapWindowPoints(NULL, hwndFwd, &pt, 1);
HWND hwnd = ChildWindowFromPoint(hwndFwd, pt);
if (hwnd)
{
MapWindowPoints(hwndFwd, hwnd, &pt, 1);
}
else
{
hwnd = hwndFwd;
}
SendMessage(hwnd, uMsg, wParam, MAKELONG(pt.x, pt.y));
}
}
HRESULT CMenuSFToolbar::OnWinEvent(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT *plres)
{
switch(uMsg)
{
case WM_SYSCOLORCHANGE:
if (_hwndPager)
Pager_SetBkColor(_hwndPager, GetSysColor(COLOR_MENU));
// Change the color, so that we can see it.
ToolBar_SetInsertMarkColor(_hwndMB, GetSysColor(COLOR_MENUTEXT));
break;
}
HRESULT hr = CMenuToolbarBase::OnWinEvent(hwnd, uMsg, wParam, lParam, plres);
if (hr != S_OK)
hr = CSFToolbar::OnWinEvent(hwnd, uMsg, wParam, lParam, plres);
return hr;
}
BOOL CMenuSFToolbar::v_UpdateIconSize(UINT uIconSize, BOOL fUpdateButtons)
{
if (uIconSize == -1)
uIconSize = _uIconSize;
_uIconSizeMB = uIconSize;
return _UpdateIconSize(_uIconSizeMB, fUpdateButtons);
}
HRESULT CMenuSFToolbar::GetShellFolder(LPITEMIDLIST* ppidl, REFIID riid, void** ppvObj)
{
HRESULT hr = E_FAIL;
*ppvObj = NULL;
if (_psf)
{
hr = _psf->QueryInterface(riid, ppvObj);
}
if (SUCCEEDED(hr) && ppidl)
{
*ppidl = ILClone(_pidl);
if (! *ppidl)
{
(*(IUnknown**)ppvObj)->Release();
*ppvObj = NULL;
hr = E_FAIL;
}
}
return hr;
}
LRESULT CMenuSFToolbar::_OnTimer(WPARAM wParam)
{
switch(wParam)
{
case MBTIMER_ENDEDIT:
KillTimer(_hwndTB, wParam);
_fEditMode = FALSE;
break;
case MBTIMER_CLICKUNHANDLE:
KillTimer(_hwndTB, wParam);
_fClickHandled = FALSE;
break;
default:
return CMenuToolbarBase::_OnTimer(wParam);
}
return 1;
}
LRESULT CMenuSFToolbar::_OnDropDown(LPNMTOOLBAR pnmtb)
{
if (GetAsyncKeyState(VK_LBUTTON) < 0 && _fEditMode)
{
// Are we in edit mode?
if (_fEditMode)
{
// Yes, mark the item as the item that is subject to moving
_MarkItem(pnmtb->iItem);
}
return TBDDRET_TREATPRESSED;
}
return CMenuToolbarBase::_OnDropDown(pnmtb);
}
// In the context of a menuband, marking means putting
// a black rectangle around the item currently being dragged.
void CMenuSFToolbar::_MarkItem(int idCmd)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
// Un-highlight the previously moved button
if (0 <= _pcmb->_nItemMove)
{
// Should item move be a member of SFToolbar?
ToolBar_MarkButton(_hwndTB, _pcmb->_nItemMove, FALSE);
_pcmb->_nItemMove = -1;
}
if (_fEditMode)
{
_pcmb->_nItemMove = idCmd;
ToolBar_MarkButton(_hwndTB, _pcmb->_nItemMove, TRUE);
}
}
STDMETHODIMP CMenuSFToolbar::IsWindowOwner(HWND hwnd)
{
if (_hwndTB == hwnd || _hwndPager == hwnd || HWND_BROADCAST == hwnd)
{
return S_OK;
}
else
{
return S_FALSE;
}
}
void CMenuSFToolbar::SetWindowPos(LPSIZE psize, LPRECT prc, DWORD dwFlags)
{
if (!_hwndPager)
{
CMenuToolbarBase::SetWindowPos(psize, prc, dwFlags);
return;
}
DWORD rectWidth = RECTWIDTH(*prc);
TraceMsg(TF_MENUBAND, "CMSFTB::SetWindowPos %d - (%d,%d,%d,%d)", psize?psize->cx:0,
prc->left, prc->top, prc->right, prc->bottom);
ShowWindow(_hwndPager, SW_SHOW);
::SetWindowPos(_hwndPager, NULL, prc->left, prc->top,
rectWidth, RECTHEIGHT(*prc), SWP_NOZORDER | SWP_NOACTIVATE | dwFlags);
if (psize)
{
int cx = psize->cx;
ToolBar_SetButtonWidth(_hwndTB, cx, cx);
}
SendMessage(_hwndPager, PGMP_RECALCSIZE, 0L, 0L);
}
void CMenuSFToolbar::SetParent(HWND hwndParent)
{
int nCmdShow = SW_SHOW;
if (hwndParent)
{
if (!_hwndTB)
CreateToolbar(hwndParent);
else
{
// make sure width is set correctly . . .
SendMessage(_hwndTB, TB_SETBUTTONWIDTH, 0, MAKELONG(_cxMin, _cxMax));
}
}
else
{
// As an optimization, we implement "disowning" ourselves
// as just moving ourselves offscreen. The previous parent
// still owns us. The parent is invariably the menusite.
RECT rc = {-1,-1,-1,-1};
SetWindowPos(NULL, &rc, 0);
nCmdShow = SW_HIDE;
}
HWND hwnd = _hwndPager ? _hwndPager: _hwndTB;
if (IsWindow(hwnd)) // JANK : Fix for bug #98253
{
if (nCmdShow == SW_HIDE)
{
ShowWindow(hwnd, nCmdShow);
}
::SetParent(hwnd, hwndParent);
SendMessage(hwnd, TB_SETPARENT, (WPARAM)hwndParent, NULL);
if (nCmdShow == SW_SHOW)
{
ShowWindow(hwnd, nCmdShow);
}
}
}
void CMenuSFToolbar::Expand(BOOL fExpand)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
TBBUTTON tbb;
DAD_ShowDragImage(FALSE);
// Since we're not sure if the Chevron is going to be visible we should remove it here
// Later we'll add it back in if it's needed.
_RemoveNSSeparator();
_RemoveChevron();
// Loop through and apply the fExpand
int iNumButtons = ToolBar_ButtonCount(_hwndTB);
// We reset these when iterating.
_cPromotedItems = 0;
_fHasDemotedItems = FALSE;
int iHotItem = ToolBar_GetHotItem(_hwndMB);
// SendMessage(_hwndMB, WM_SETREDRAW, FALSE, 0);
for (int i = 0; i < iNumButtons; i++)
{
if (!ToolBar_GetButton(_hwndMB, i, &tbb))
continue;
CMenuData* pmd = (CMenuData*)tbb.dwData;
// Get the toolbar state. Toolbar can set things like
// TBSTATE_WRAP that we would go nuke.
DWORD dwState = tbb.fsState;
DWORD dwFlags = pmd ? pmd->GetFlags() : 0;
if (dwFlags & SMIF_DEMOTED)
{
// Are we expanding?
if (fExpand)
{
//Yes; Enable the button and remove the hidden state
dwState |= TBSTATE_ENABLED;
dwState &= ~TBSTATE_HIDDEN;
}
else
{
//No; Remove the Enabled state and hide the button
dwState |= TBSTATE_HIDDEN;
dwState &= ~TBSTATE_ENABLED;
}
_fHasDemotedItems = TRUE;
}
else if (dwFlags & SMIF_HIDDEN)
{
dwState |= TBSTATE_HIDDEN;
dwState &= ~TBSTATE_ENABLED;
}
else if (tbb.idCommand != _idCmdChevron)
{
dwState |= TBSTATE_ENABLED;
dwState &= ~TBSTATE_HIDDEN;
_cPromotedItems++;
}
// If the state has changed, then set it into the toolbar.
if (dwState != tbb.fsState)
ToolBar_SetState(_hwndTB, tbb.idCommand, dwState);
}
// _fExpand means "Draw as Expanded". We do not want to
// draw expanded when we have no demoted items.
_pcmb->_fExpanded = _fHasDemotedItems? fExpand : FALSE;
if (fExpand)
{
if (_pcmb->_pmbState)
{
_pcmb->_pmbState->SetExpand(TRUE);
_pcmb->_pmbState->HideTooltip(TRUE);
}
}
else
{
_AddChevron();
}
_AddNSSeparator();
// Have the menubar think about changing its height
IUnknown_QueryServiceExec(_pcmb->_punkSite, SID_SMenuPopup, &CGID_MENUDESKBAR,
MBCID_SETEXPAND, _fHasDemotedItems?(int)_pcmb->_pmbState->GetExpand():FALSE, NULL, NULL);
// SendMessage(_hwndMB, WM_SETREDRAW, TRUE, 0);
_ToolbarChanged();
ToolBar_SetHotItem(_hwndMB, iHotItem);
if (_hwndPager)
UpdateWindow(_hwndPager);
UpdateWindow(_hwndTB);
// DAD_ShowDragImage(TRUE);
}
void CMenuSFToolbar::GetSize(SIZE* psize)
{
CMenuToolbarBase::GetSize(psize);
if (_fEmpty && _fDontShowEmpty)
{
psize->cy = 0;
TraceMsg(TF_MENUBAND, "CMSFT::GetSize (%d, %d)", psize->cx, psize->cy);
}
}
void CMenuSFToolbar::_RefreshInfo()
{
int cButton = ToolBar_ButtonCount(_hwndMB);
for (int iButton = 0; iButton < cButton; iButton++)
{
int idCmd = GetButtonCmd(_hwndTB, iButton);
if (!_IsSpecialCmd(idCmd))
{
// Get the information from that button.
CMenuData* pmd = (CMenuData*)_IDToPibData(idCmd);
if (pmd)
{
SMINFO sminfo;
sminfo.dwMask = SMIM_FLAGS;
if (SUCCEEDED(_GetInfo(pmd->GetPidl(), &sminfo)))
{
pmd->SetFlags(sminfo.dwFlags);
}
}
}
}
}
void CMenuSFToolbar::_FindMinPromotedItems(BOOL fSetOrderStream)
{
// We need to iterate through the buttons and set the Promoted flag.
int cButton = ToolBar_ButtonCount(_hwndMB);
for (int iButton = 0; iButton < cButton; iButton++)
{
int idCmd = GetButtonCmd(_hwndTB, iButton);
if (!_IsSpecialCmd(idCmd))
{
// Get the information from that button.
CMenuData* pmd = (CMenuData*)_IDToPibData(idCmd);
if (pmd)
{
PORDERITEM poi = pmd->GetOrderItem();
if (fSetOrderStream)
{
DWORD dwFlags = pmd->GetFlags();
OrderItem_SetFlags(poi, dwFlags);
}
else // Query the order stream
{
DWORD dwFlags = OrderItem_GetFlags(poi);
DWORD dwOldFlags = pmd->GetFlags();
// When reading the flags from the registry, we only care about the demote flag.
if (dwFlags & SMIF_DEMOTED)
{
dwOldFlags |= SMIF_DEMOTED;
}
else if (!(dwOldFlags & SMIF_SUBMENU)) // Don't promote sub menus.
{
// Force a promote
CallCB(pmd->GetPidl(), SMC_PROMOTE, 0, 0);
dwOldFlags &= ~SMIF_DEMOTED;
}
pmd->SetFlags(dwOldFlags);
}
}
}
}
}
void CMenuSFToolbar::v_Show(BOOL fShow, BOOL fForceUpdate)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
CMenuToolbarBase::v_Show(fShow, fForceUpdate);
if (fShow)
{
BOOL fDirty = _fDirty;
_fClickHandled = FALSE;
_RegisterToolbar();
// this is to flush the whole thing if we got invalidated (like the
// darwin hack makes us do). if we don't clear out, then some
// stale data is left in and _FillToolbar doesn't flush it any more.
if (fDirty)
{
EmptyToolbar();
}
_FillToolbar();
_pcmb->SetTracked(NULL); // Since hot item is NULL
ToolBar_SetHotItem(_hwndTB, -1);
if (_fEmpty && (_dwFlags & SMSET_NOEMPTY))
{
_fDontShowEmpty = TRUE;
}
else if (_fRefreshInfo && !fDirty) // Do we need to refresh our information?
{
// Yes;
_RefreshInfo();
}
// HACKHACK (lamadio) : There is a sizing issue, where the sizing between the
// toolbars gets preemted by a resize of the menubar before the size calculation completes.
// So:
// ShowDW - Asks each toolbar to calc it's width
// CMenuSFToolbar::v_Show - Does a _FillToolbar. Since (in this senario) an item
// Has been added, it calls _ToolbarChanged
// _ToolbarChanged - This says to the menubar, I've changed sizes, recalc.
// ResizeMenuBar - In the depths, it eventually calls OnPosRectChanged, which asks each
// Toolbar what it's size is. Since the menu portion has not calculated it yet,
// It has the old size which is has the old size of the sftoolbar. So everything
// Gets reset to that size.
//
// We only want to Call expand if we are dirty or the expand state has changed. We
// call for the Dirty case, because Expand does some neat stuff in calculating the
// number of promoted items. If the state has changed, we want to reflect that.
BOOL fExpand = _pcmb->_pmbState ? _pcmb->_pmbState->GetExpand() : FALSE;
if ((BOOL)_pcmb->_fExpanded != fExpand || fDirty || _fRefreshInfo)
{
fForceUpdate = TRUE;
Expand(fExpand);
}
// Only do this in the beginning.
if (_fFirstTime)
{
CallCB(NULL, SMC_GETMINPROMOTED, 0, (LPARAM)&_cMinPromotedItems);
if (_cPromotedItems < _cMinPromotedItems)
{
_FindMinPromotedItems(FALSE);
Expand(fExpand);
}
}
// Have the menubar think about changing its height
// we need to do this here because the menubar may have changed it's
// expand state independant of the pane.
IUnknown_QueryServiceExec(_pcmb->_punkSite, SID_SMenuPopup, &CGID_MENUDESKBAR,
MBCID_SETEXPAND, (int)_pcmb->_fExpanded, NULL, NULL);
// If we're dirty, have our parent consider promoting itself if there
// are promoted items in the menu, or demoting itself if there arn't.
// Don't worry, the parent won't do anything if it's already in that state.
if (fDirty)
{
IUnknown_RefreshParent(_pcmb->_punkSite, _pidl,
((_cPromotedItems == 0)? SMINV_DEMOTE : SMINV_PROMOTE) | SMINV_NEXTSHOW);
}
// If it is empty, we want to auto expand.
// We have to do this before the update buttons, so that the size is calculate correctly.
if (_cPromotedItems == 0 && !_pcmb->_fExpanded)
Expand(TRUE);
if (fForceUpdate)
_UpdateButtons();
if (_fHasDemotedItems)
{
if (S_OK == CallCB(NULL, SMC_DISPLAYCHEVRONTIP, 0, 0))
{
_FlashChevron();
}
}
_fFirstTime = FALSE;
_fRefreshInfo = FALSE;
}
else
{
KillTimer(_hwndMB, MBTIMER_UEMTIMEOUT);
}
_fShowMB = _fShow = fShow;
// Reset these so we don't have stale information for the next drag drop cycle. NT #287914 (lamadio) 3.22.99
_tbim.iButton = -1;
_tbim.dwFlags = 0;
_idCmdDragging = -1;
// n.b. for !fShow, we don't kill the tracked site chain. we
// count on this in startmnu.cpp!CStartMenuCallback::_OnExecItem,
// where we walk up the chain to find all hit 'nodes'. if we need
// to change this we could fire a 'pre-exec' event.
}
void CMenuSFToolbar::v_UpdateButtons(BOOL fNegotiateSize)
{
CSFToolbar::_UpdateButtons();
if (_hwndTB && fNegotiateSize && _fVerticalMB)
NegotiateSize();
}
// this method invalidates a single item in the toolbar
HRESULT CMenuSFToolbar::v_InvalidateItem(LPSMDATA psmd, DWORD dwFlags)
{
ASSERT(_pcmb); // if you hit this assert, you haven't initialized yet.. call SetSite first
// Default to not not handling this event.
HRESULT hr = S_FALSE;
if (NULL == psmd)
{
if (dwFlags & SMINV_REFRESH)
{
_Refresh();
hr = S_OK;
}
}
else if (psmd->dwMask & SMDM_SHELLFOLDER)
{
// Yes;
int i;
LPITEMIDLIST pidlButton = NULL;
SMINFO sminfo;
sminfo.dwMask = SMIM_FLAGS;
// Since this pidl is comming from an outside source,
// we may need to translate it to a wrapped pidl.
// Do we have a pidl Translator?
if (_ptscn)
{
// Yes;
LPITEMIDLIST pidlTranslated;
LPITEMIDLIST pidlDummy = NULL;
LPITEMIDLIST pidlToTranslate = ILCombine(psmd->pidlFolder, psmd->pidlItem);
if (pidlToTranslate)
{
LONG lEvent = 0, lEvent2;
LPITEMIDLIST pidlDummy1, pidlDummy2;
if (SUCCEEDED(_ptscn->TranslateIDs(&lEvent, pidlToTranslate, NULL, &pidlTranslated, &pidlDummy,
&lEvent2, &pidlDummy1, &pidlDummy2)))
{
// Get the button in the toolbar that corresponds to this pidl.
_GetButtonFromPidl(ILFindLastID(pidlTranslated), NULL, &i, &pidlButton);
// if pidl does not get translated TranslateIDs returns the same pidl passed
// to the function
if (pidlTranslated != pidlToTranslate)
ILFree(pidlTranslated);
// Don't need to delete pidlDummy because it's not set.
ASSERT(pidlDummy == NULL);
ASSERT(pidlDummy1 == NULL);
ASSERT(pidlDummy2 == NULL);
}
ILFree(pidlToTranslate);
}
}
// Did we come from a non-augmented shell folder, or
// did the caller pass a wrapped pidl?
if (!pidlButton)
{
// Seems like it, we'll try to find the pidl they passed in
// Get the button in the toolbar that corresponds to this pidl.
_GetButtonFromPidl(psmd->pidlItem, NULL, &i, &pidlButton);
}
// Did we find this pidl in the toolbar?
if (pidlButton)
{
int idCmd = GetButtonCmd(_hwndTB, v_DPAIndexToTBIndex(i));
// Yes, Get the information from that button.
CMenuData* pmd = (CMenuData*)_IDToPibData(idCmd);
if (pmd)
{
BOOL fRefresh = FALSE;
DWORD dwFlagsUp = dwFlags;
DWORD dwOldItemFlags = pmd->GetFlags();
DWORD dwNewItemFlags = dwOldItemFlags;
if ((dwFlags & SMINV_DEMOTE) &&
(!(dwOldItemFlags & SMIF_DEMOTED) || dwFlags & SMINV_FORCE))
{
if (!(dwFlags & SMINV_NOCALLBACK))
{
CallCB(pidlButton, SMC_DEMOTE, 0, 0);
BroadcastIntelliMenuState(pidlButton, FALSE);
}
dwNewItemFlags |= SMIF_DEMOTED;
dwFlagsUp |= SMINV_DEMOTE;
}
else if ((dwFlags & SMINV_PROMOTE) &&
((dwOldItemFlags & SMIF_DEMOTED) || dwFlags & SMINV_FORCE))
{
if (!(dwFlags & SMINV_NOCALLBACK))
{
CallCB(pidlButton, SMC_PROMOTE, dwFlags, 0);
BroadcastIntelliMenuState(pidlButton, TRUE);
}
dwNewItemFlags &= ~SMIF_DEMOTED;
dwFlagsUp |= SMINV_PROMOTE;
}
// Was it promoted and now Demoted or
// Was it demoted and now promoted
if ((dwNewItemFlags & SMIF_DEMOTED) ^
(dwOldItemFlags & SMIF_DEMOTED))
{
fRefresh = TRUE;
if (dwNewItemFlags & SMIF_DEMOTED)
{
// Yes; Then decrement the Promoted count
_cPromotedItems--;
// If we're decementing, then we not have a demoted item.
_fHasDemotedItems = TRUE;
// Have we dropped off the face of the earth?
if (_cPromotedItems == 0)
{
dwFlagsUp |= SMINV_DEMOTE;
Expand(TRUE);
}
else
{
fRefresh = FALSE;
}
}
else
{
int cButtons = ToolBar_ButtonCount(_hwndMB);
_cPromotedItems++;
if (cButtons == _cPromotedItems)
{
// if the button count is the number of promoted items,
// then we can't have any demoted items
// then we need to reset the _fHasDemotedItems flag so that
// we don't get a chevron and stuff...
_fHasDemotedItems = FALSE;
}
dwFlagsUp |= SMINV_PROMOTE;
fRefresh = TRUE;
}
}
if (fRefresh || dwFlags & SMINV_FORCE)
IUnknown_RefreshParent(_pcmb->_punkSite, _pidl, dwFlagsUp);
if (dwOldItemFlags != dwNewItemFlags || dwFlags & SMINV_FORCE)
{
if (dwFlags & SMINV_NEXTSHOW || !_fShow)
{
_fRefreshInfo = TRUE;
}
else
{
// Since we updated the flags, set them into the cache
pmd->SetFlags(dwNewItemFlags);
// Based on the new flags, do we enable?
DWORD dwState = ToolBar_GetState(_hwndTB, idCmd);
dwState |= TBSTATE_ENABLED;
if (dwNewItemFlags & SMIF_DEMOTED &&
!_pcmb->_fExpanded)
{
// No; We're not expanded and this is a demoted item
dwState |= TBSTATE_HIDDEN;
dwState &= ~TBSTATE_ENABLED;
_fHasDemotedItems = TRUE;
// Just in case the chevron is not there, we should
// try and add it. This call will never add more than 1
_AddChevron();
}
else if (!_fHasDemotedItems)
{
_RemoveChevron();
}
// Also recalculate the NS separator
_RemoveNSSeparator();
_AddNSSeparator();
// Adjust the state of the button in the toolbar.
ToolBar_SetState(_hwndTB, idCmd, dwState);
_ToolbarChanged();
}
}
}
}
// We handled this one.
hr = S_OK;
}
return hr;
}
LRESULT CMenuSFToolbar::_DefWindowProc(HWND hwnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
switch (uMessage)
{
case WM_GETOBJECT:
// Yet another poor design choice on the part of the accessibility team.
// Typically, if you do not answer a WM_* you return 0. They choose 0 as their success
// code.
return _DefWindowProcMB(hwnd, uMessage, wParam, lParam);
break;
}
return CSFToolbar::_DefWindowProc(hwnd, uMessage, wParam, lParam);
}
void CMenuSFToolbar::_SetFontMetrics()
{
CMenuToolbarBase::_SetFontMetrics();
if (_hwndPager && _pcmb->_pmbm)
Pager_SetBkColor(_hwndPager, _pcmb->_pmbm->_clrBackground);
}
int CMenuSFToolbar::_GetBitmap(int iCommandID, PIBDATA pibdata, BOOL fUseCache)
{
int iIcon = -1;
// If we don't have a pibdata, or we can't get an icon return.
if (!pibdata || pibdata->GetNoIcon())
return -1;
if (_dwFlags & SMSET_USEBKICONEXTRACTION)
{
LPITEMIDLIST pidlItem = pibdata->GetPidl();
// If the caller is using background icon extraction, we need them to provide a
// default icon that we are going to display until we get the real one. This is
// specifically to make favorites fast.
if (_iDefaultIconIndex == -1)
{
TCHAR szIconPath [MAX_PATH];
if (S_OK == CallCB(NULL, SMC_DEFAULTICON, (WPARAM)szIconPath, (LPARAM)&iIcon))
{
_iDefaultIconIndex = Shell_GetCachedImageIndex(szIconPath, iIcon, 0);
}
}
iIcon = _iDefaultIconIndex;
DWORD dwAttrib = SFGAO_FOLDER;
if (pidlItem && SUCCEEDED(_psf->GetAttributesOf(1, (LPCITEMIDLIST*)&pidlItem, &dwAttrib)))
{
if (dwAttrib & SFGAO_FOLDER)
iIcon = II_FOLDER;
}
IShellTaskScheduler* pScheduler = _pcmb->_pmbState->GetScheduler();
if (pScheduler)
{
IShellFolder* psf = NULL;
LPITEMIDLIST pidlFolder = _pidl;
LPITEMIDLIST pidlItemUnwrapped;
// Since this can be an augmented shell folder, we should do the correct thing so that
// the icon extraction with the full pidl takes place correctly.
if (_pasf2 &&
S_OK == _pasf2->UnWrapIDList(pidlItem, 1, NULL, &pidlFolder, &pidlItemUnwrapped, NULL))
{
pidlItem = ILCombine(pidlFolder, pidlItemUnwrapped);
ILFree(pidlFolder);
ILFree(pidlItemUnwrapped);
}
else
{
psf = _psf;
}
// AddIconTask takes ownership of the pidl when psf is NULL and will free it.
HRESULT hr = AddIconTask(pScheduler, psf, pidlFolder, pidlItem,
s_IconCallback, (void *)_hwndTB, iCommandID, NULL);
pScheduler->Release();
if (FAILED(hr))
{
// If that call failed for some reason, default to the shell32 impl.
goto DoSyncMap;
}
}
else
goto DoSyncMap;
}
else
{
DoSyncMap:
iIcon = CSFToolbar::_GetBitmap(iCommandID, pibdata, fUseCache);
}
return iIcon;
}
void CMenuSFToolbar::s_IconCallback(void * pvData, UINT uId, UINT iIconIndex)
{
HWND hwnd = (HWND)pvData;
if (hwnd && IsWindow(hwnd))
{
DAD_ShowDragImage(FALSE);
SendMessage(hwnd, TB_CHANGEBITMAP, uId, iIconIndex);
DAD_ShowDragImage(TRUE);
}
}
HWND CMenuSFToolbar::GetHWNDForUIObject()
{
HWND hwnd = _pcmb->_pmbState->GetWorkerWindow(_hwndMB);
if (hwnd)
::SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE | SWP_NOOWNERZORDER);
return hwnd;
}
HWND CMenuSFToolbar::CreateWorkerWindow()
{
return GetHWNDForUIObject();
}
LRESULT CMenuSFToolbar::v_OnCustomDraw(NMCUSTOMDRAW * pnmcd)
{
LRESULT lRes = CMenuToolbarBase::v_OnCustomDraw(pnmcd);
#ifdef FLATMENU_ICONBAR
// We may have a background banner in Flat Menu Mode.
UINT cBits = GetDeviceCaps(pnmcd->hdc, BITSPIXEL);
if (pnmcd->dwDrawStage == CDDS_PREERASE &&
_pcmb->_pmbm->_fFlatMenuMode && // Only in flat mode
_uIconSizeMB != ISFBVIEWMODE_LARGEICONS && // And designers didn't like it in the large icon mode
cBits > 8) // and only if we're in 16 bit color
{
RECT rcClient;
GetClientRect(_hwndMB, &rcClient);
rcClient.right = GetTBImageListWidth(_hwndMB) + ICONBACKGROUNDFUDGE;
SHFillRectClr(pnmcd->hdc, &rcClient, _pcmb->_pmbm->_clrMenuGrad);
}
#endif
return lRes;
}
Reference in a new issue Copy permalink