#include "stdafx.h"
#include <browseui.h>
#include "sfthost.h"
#include <shellp.h>
#include "startmnu.h"
#define TF_HOST 0x00000010
#define TF_HOSTDD 0x00000040 // drag/drop
#define TF_HOSTPIN 0x00000080 // pin
#define ANIWND_WIDTH 80
#define ANIWND_HEIGHT 50
EXTERN_C void Tray_UnlockStartPane();
//---------BEGIN HACKS OF DEATH -------------
// HACKHACK - desktopp.h and browseui.h both define SHCreateFromDesktop
// What's worse, browseui.h includes desktopp.h! So you have to sneak it
// out in this totally wacky way.
#include <desktopp.h>
#define SHCreateFromDesktop _SHCreateFromDesktop
#include <browseui.h>
//---------END HACKS OF DEATH -------------
//****************************************************************************
//
// Dummy IContextMenu
//
// We use this when we can't get the real IContextMenu for an item.
// If the user pins an object and then deletes the underlying
// file, attempting to get the IContextMenu from the shell will fail,
// but we need something there so we can add the "Remove from this list"
// menu item.
//
// Since this dummy context menu has no state, we can make it a static
// singleton object.
class CEmptyContextMenu
: public IContextMenu
{
public:
// *** IUnknown ***
STDMETHODIMP QueryInterface(REFIID riid, void** ppvObj)
{
static const QITAB qit[] = {
QITABENT(CEmptyContextMenu, IContextMenu),
{ 0 },
};
return QISearch(this, qit, riid, ppvObj);
}
STDMETHODIMP_(ULONG) AddRef(void) { return 3; }
STDMETHODIMP_(ULONG) Release(void) { return 2; }
// *** IContextMenu ***
STDMETHODIMP QueryContextMenu(HMENU hmenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
{
return ResultFromShort(0); // No items added
}
STDMETHODIMP InvokeCommand(LPCMINVOKECOMMANDINFO pici)
{
ASSERT(FALSE);
return E_FAIL;
}
STDMETHODIMP GetCommandString(UINT_PTR idCmd, UINT uType, UINT *pwRes, LPSTR pszName, UINT cchMax)
{
return E_INVALIDARG; // no commands; therefore, no command strings!
}
public:
IContextMenu *GetContextMenu()
{
// Don't need to AddRef since we are a static object
return this;
}
};
static CEmptyContextMenu s_EmptyContextMenu;
//****************************************************************************
#define WC_SFTBARHOST TEXT("DesktopSFTBarHost")
BOOL GetFileCreationTime(LPCTSTR pszFile, FILETIME *pftCreate)
{
WIN32_FILE_ATTRIBUTE_DATA wfad;
BOOL fRc = GetFileAttributesEx(pszFile, GetFileExInfoStandard, &wfad);
if (fRc)
{
*pftCreate = wfad.ftCreationTime;
}
return fRc;
}
// {2A1339D7-523C-4E21-80D3-30C97B0698D2}
const CLSID TOID_SFTBarHostBackgroundEnum = {
0x2A1339D7, 0x523C, 0x4E21,
{ 0x80, 0xD3, 0x30, 0xC9, 0x7B, 0x06, 0x98, 0xD2} };
BOOL SFTBarHost::Register()
{
WNDCLASS wc;
wc.style = 0;
wc.lpfnWndProc = _WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = sizeof(void *);
wc.hInstance = _Module.GetModuleInstance();
wc.hIcon = 0;
// We specify a cursor so the OOBE window gets something
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = 0;
wc.lpszClassName = WC_SFTBARHOST;
return ::SHRegisterClass(&wc);
}
BOOL SFTBarHost::Unregister()
{
return ::UnregisterClass(WC_SFTBARHOST, _Module.GetModuleInstance());
}
LRESULT CALLBACK SFTBarHost::_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
SFTBarHost *self = reinterpret_cast<SFTBarHost *>(GetWindowPtr0(hwnd));
if (uMsg == WM_NCCREATE)
{
return _OnNcCreate(hwnd, uMsg, wParam, lParam);
}
else if (self)
{
#define HANDLE_SFT_MESSAGE(wm, fn) case wm: return self->fn(hwnd, uMsg, wParam, lParam)
switch (uMsg)
{
HANDLE_SFT_MESSAGE(WM_CREATE, _OnCreate);
HANDLE_SFT_MESSAGE(WM_DESTROY, _OnDestroy);
HANDLE_SFT_MESSAGE(WM_NCDESTROY, _OnNcDestroy);
HANDLE_SFT_MESSAGE(WM_NOTIFY, _OnNotify);
HANDLE_SFT_MESSAGE(WM_SIZE, _OnSize);
HANDLE_SFT_MESSAGE(WM_ERASEBKGND, _OnEraseBackground);
HANDLE_SFT_MESSAGE(WM_CONTEXTMENU, _OnContextMenu);
HANDLE_SFT_MESSAGE(WM_CTLCOLORSTATIC,_OnCtlColorStatic);
HANDLE_SFT_MESSAGE(WM_TIMER, _OnTimer);
HANDLE_SFT_MESSAGE(WM_SETFOCUS, _OnSetFocus);
HANDLE_SFT_MESSAGE(WM_INITMENUPOPUP,_OnMenuMessage);
HANDLE_SFT_MESSAGE(WM_DRAWITEM, _OnMenuMessage);
HANDLE_SFT_MESSAGE(WM_MENUCHAR, _OnMenuMessage);
HANDLE_SFT_MESSAGE(WM_MEASUREITEM, _OnMenuMessage);
HANDLE_SFT_MESSAGE(WM_SYSCOLORCHANGE, _OnSysColorChange);
HANDLE_SFT_MESSAGE(WM_DISPLAYCHANGE, _OnForwardMessage);
HANDLE_SFT_MESSAGE(WM_SETTINGCHANGE, _OnForwardMessage);
HANDLE_SFT_MESSAGE(WM_UPDATEUISTATE, _OnUpdateUIState);
HANDLE_SFT_MESSAGE(SFTBM_REPOPULATE,_OnRepopulate);
HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+0,_OnChangeNotify);
HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+1,_OnChangeNotify);
HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+2,_OnChangeNotify);
HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+3,_OnChangeNotify);
HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+4,_OnChangeNotify);
HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+5,_OnChangeNotify);
HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+6,_OnChangeNotify);
HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+7,_OnChangeNotify);
HANDLE_SFT_MESSAGE(SFTBM_REFRESH, _OnRefresh);
HANDLE_SFT_MESSAGE(SFTBM_CASCADE, _OnCascade);
HANDLE_SFT_MESSAGE(SFTBM_ICONUPDATE, _OnIconUpdate);
}
// If this assert fires, you need to add more
// HANDLE_SFT_MESSAGE(SFTBM_CHANGENOTIFY+... entries.
COMPILETIME_ASSERT(SFTHOST_MAXNOTIFY == 8);
#undef HANDLE_SFT_MESSAGE
return self->OnWndProc(hwnd, uMsg, wParam, lParam);
}
return ::DefWindowProc(hwnd, uMsg, wParam, lParam);
}
LRESULT SFTBarHost::_OnNcCreate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
SMPANEDATA *pspld = PaneDataFromCreateStruct(lParam);
SFTBarHost *self = NULL;
switch (pspld->iPartId)
{
case SPP_PROGLIST:
self = ByUsage_CreateInstance();
break;
case SPP_PLACESLIST:
self = SpecList_CreateInstance();
break;
default:
TraceMsg(TF_ERROR, "Unknown panetype %d", pspld->iPartId);
}
if (self)
{
SetWindowPtr0(hwnd, self);
self->_hwnd = hwnd;
self->_hTheme = pspld->hTheme;
if (FAILED(self->Initialize()))
{
TraceMsg(TF_ERROR, "SFTBarHost::NcCreate Initialize call failed");
return FALSE;
}
return ::DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return FALSE;
}
//
// The tile height is max(imagelist height, text height) + some margin
// The margin is "scientifically computed" to be the value that looks
// reasonably close to the bitmaps the designers gave us.
//
void SFTBarHost::_ComputeTileMetrics()
{
int cyTile = _cyIcon;
HDC hdc = GetDC(_hwndList);
if (hdc)
{
// SOMEDAY - get this to play friendly with themes
HFONT hf = GetWindowFont(_hwndList);
HFONT hfPrev = SelectFont(hdc, hf);
SIZE siz;
if (GetTextExtentPoint(hdc, TEXT("0"), 1, &siz))
{
if (_CanHaveSubtitles())
{
// Reserve space for the subtitle too
siz.cy *= 2;
}
if (cyTile < siz.cy)
cyTile = siz.cy;
}
SelectFont(hdc, hfPrev);
ReleaseDC(_hwndList, hdc);
}
// Listview draws text at left margin + icon + edge
_cxIndent = _cxMargin + _cxIcon + GetSystemMetrics(SM_CXEDGE);
_cyTile = cyTile + (4 * _cyMargin) + _cyTilePadding;
}
void SFTBarHost::_SetTileWidth(int cxTile)
{
LVTILEVIEWINFO tvi;
tvi.cbSize = sizeof(tvi);
tvi.dwMask = LVTVIM_TILESIZE | LVTVIM_COLUMNS;
tvi.dwFlags = LVTVIF_FIXEDSIZE;
// If we support cascading, then reserve space for the cascade arrows
if (_dwFlags & HOSTF_CASCADEMENU)
{
// WARNING! _OnLVItemPostPaint uses these margins
tvi.dwMask |= LVTVIM_LABELMARGIN;
tvi.rcLabelMargin.left = 0;
tvi.rcLabelMargin.top = 0;
tvi.rcLabelMargin.right = _cxMarlett;
tvi.rcLabelMargin.bottom = 0;
}
// Reserve space for subtitles if necessary
tvi.cLines = _CanHaveSubtitles() ? 1 : 0;
// _cyTile has the padding into account, but we want each item to be the height without padding
tvi.sizeTile.cy = _cyTile - _cyTilePadding;
tvi.sizeTile.cx = cxTile;
ListView_SetTileViewInfo(_hwndList, &tvi);
_cxTile = cxTile;
}
LRESULT SFTBarHost::_OnSize(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (_hwndList)
{
SIZE sizeClient = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
sizeClient.cx -= (_margins.cxLeftWidth + _margins.cxRightWidth);
sizeClient.cy -= (_margins.cyTopHeight + _margins.cyBottomHeight);
SetWindowPos(_hwndList, NULL, _margins.cxLeftWidth, _margins.cyTopHeight,
sizeClient.cx, sizeClient.cy,
SWP_NOZORDER | SWP_NOOWNERZORDER);
_SetTileWidth(sizeClient.cx);
if (HasDynamicContent())
{
_InternalRepopulateList();
}
}
return 0;
}
LRESULT SFTBarHost::_OnSysColorChange(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// if we're in unthemed mode, then we need to update our colors
if (!_hTheme)
{
ListView_SetTextColor(_hwndList, GetSysColor(COLOR_MENUTEXT));
_clrHot = GetSysColor(COLOR_MENUTEXT);
_clrBG = GetSysColor(COLOR_MENU);
_clrSubtitle = CLR_NONE;
ListView_SetBkColor(_hwndList, _clrBG);
ListView_SetTextBkColor(_hwndList, _clrBG);
}
return _OnForwardMessage(hwnd, uMsg, wParam, lParam);
}
LRESULT SFTBarHost::_OnCtlColorStatic(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// Use the same colors as the listview itself.
HDC hdc = GET_WM_CTLCOLOR_HDC(wParam, lParam, uMsg);
SetTextColor(hdc, ListView_GetTextColor(_hwndList));
COLORREF clrBk = ListView_GetTextBkColor(_hwndList);
if (clrBk == CLR_NONE)
{
// The animate control really wants to get a text background color.
// It doesn't support transparency.
if (GET_WM_CTLCOLOR_HWND(wParam, lParam, uMsg) == _hwndAni)
{
if (_hTheme)
{
if (!_hBrushAni)
{
// We need to paint the theme background in a bitmap and use that
// to create a brush for the background of the flashlight animation
RECT rcClient;
GetClientRect(hwnd, &rcClient);
int x = (RECTWIDTH(rcClient) - ANIWND_WIDTH)/2; // IDA_SEARCH is ANIWND_WIDTH pix wide
int y = (RECTHEIGHT(rcClient) - ANIWND_HEIGHT)/2; // IDA_SEARCH is ANIWND_HEIGHT pix tall
RECT rc;
rc.top = y;
rc.bottom = y + ANIWND_HEIGHT;
rc.left = x;
rc.right = x + ANIWND_WIDTH;
HDC hdcBMP = CreateCompatibleDC(hdc);
HBITMAP hbmp = CreateCompatibleBitmap(hdc, ANIWND_WIDTH, ANIWND_HEIGHT);
POINT pt = {0, 0};
// Offset the viewport so that DrawThemeBackground draws the part that we care about
// at the right place
OffsetViewportOrgEx(hdcBMP, -x, -y, &pt);
SelectObject(hdcBMP, hbmp);
DrawThemeBackground(_hTheme, hdcBMP, _iThemePart, 0, &rcClient, 0);
// Our bitmap is now ready!
_hBrushAni = CreatePatternBrush(hbmp);
// Cleanup
SelectObject(hdcBMP, NULL);
DeleteObject(hbmp);
DeleteObject(hdcBMP);
}
return (LRESULT)_hBrushAni;
}
else
{
return (LRESULT)GetSysColorBrush(COLOR_MENU);
}
}
SetBkMode(hdc, TRANSPARENT);
return (LRESULT)GetStockBrush(HOLLOW_BRUSH);
}
else
{
return (LRESULT)GetSysColorBrush(COLOR_MENU);
}
}
//
// Appends the PaneItem to _dpaEnum, or deletes it (and nulls it out)
// if unable to append.
//
int SFTBarHost::_AppendEnumPaneItem(PaneItem *pitem)
{
int iItem = _dpaEnumNew.AppendPtr(pitem);
if (iItem < 0)
{
delete pitem;
iItem = -1;
}
return iItem;
}
BOOL SFTBarHost::AddItem(PaneItem *pitem, IShellFolder *psf, LPCITEMIDLIST pidlChild)
{
BOOL fSuccess = FALSE;
ASSERT(_fEnumerating);
if (_AppendEnumPaneItem(pitem) >= 0)
{
fSuccess = TRUE;
}
return fSuccess;
}
void SFTBarHost::_RepositionItems()
{
DEBUG_CODE(_fListUnstable++);
int iItem;
for (iItem = ListView_GetItemCount(_hwndList) - 1; iItem >= 0; iItem--)
{
PaneItem *pitem = _GetItemFromLV(iItem);
if (pitem)
{
POINT pt;
_ComputeListViewItemPosition(pitem->_iPos, &pt);
ListView_SetItemPosition(_hwndList, iItem, pt.x, pt.y);
}
}
DEBUG_CODE(_fListUnstable--);
}
int SFTBarHost::AddImage(HICON hIcon)
{
int iIcon = -1;
if (_IsPrivateImageList())
{
iIcon = ImageList_AddIcon(_himl, hIcon);
}
return iIcon;
}
//
// pvData = the window to receive the icon
// pvHint = pitem whose icon we just extracted
// iIconIndex = the icon we got
//
void SFTBarHost::SetIconAsync(LPCITEMIDLIST pidl, LPVOID pvData, LPVOID pvHint, INT iIconIndex, INT iOpenIconIndex)
{
HWND hwnd = (HWND)pvData;
if (IsWindow(hwnd))
{
PostMessage(hwnd, SFTBM_ICONUPDATE, iIconIndex, (LPARAM)pvHint);
}
}
//
// wParam = icon index
// lParam = pitem to update
//
LRESULT SFTBarHost::_OnIconUpdate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
//
// Do not dereference lParam (pitem) until we are sure it is valid.
//
LVFINDINFO fi;
LVITEM lvi;
fi.flags = LVFI_PARAM;
fi.lParam = lParam;
lvi.iItem = ListView_FindItem(_hwndList, -1, &fi);
if (lvi.iItem >= 0)
{
lvi.mask = LVIF_IMAGE;
lvi.iSubItem = 0;
lvi.iImage = (int)wParam;
ListView_SetItem(_hwndList, &lvi);
// Now, we need to go update our cached bitmap version of the start menu.
_SendNotify(_hwnd, SMN_NEEDREPAINT, NULL);
}
return 0;
}
// An over-ridable method to let client direct an item at a particular image
int SFTBarHost::AddImageForItem(PaneItem *pitem, IShellFolder *psf, LPCITEMIDLIST pidl, int iPos)
{
if (_IsPrivateImageList())
{
return _ExtractImageForItem(pitem, psf, pidl);
}
else
{
// system image list: Make the shell do the work.
int iIndex;
SHMapIDListToImageListIndexAsync(_psched, psf, pidl, 0, SetIconAsync, _hwnd, pitem, &iIndex, NULL);
return iIndex;
}
}
HICON _IconOf(IShellFolder *psf, LPCITEMIDLIST pidl, int cxIcon)
{
HRESULT hr;
HICON hicoLarge = NULL, hicoSmall = NULL;
IExtractIcon *pxi;
hr = psf->GetUIObjectOf(NULL, 1, &pidl, IID_PPV_ARG_NULL(IExtractIcon, &pxi));
if (SUCCEEDED(hr))
{
TCHAR szPath[MAX_PATH];
int iIndex;
UINT uiFlags;
hr = pxi->GetIconLocation(0, szPath, ARRAYSIZE(szPath), &iIndex, &uiFlags);
// S_FALSE means "Please use the generic document icon"
if (hr == S_FALSE)
{
lstrcpyn(szPath, TEXT("shell32.dll"), ARRAYSIZE(szPath));
iIndex = II_DOCNOASSOC;
hr = S_OK;
}
if (SUCCEEDED(hr))
{
// Even though we don't care about the small icon, we have to
// ask for it anyway because some people fault on NULL.
hr = pxi->Extract(szPath, iIndex, &hicoLarge, &hicoSmall, cxIcon);
// S_FALSE means "I am too lazy to extract the icon myself.
// You do it for me."
if (hr == S_FALSE)
{
hr = SHDefExtractIcon(szPath, iIndex, uiFlags, &hicoLarge, &hicoSmall, cxIcon);
}
}
pxi->Release();
}
// If we can't get an icon (e.g., object is on a slow link),
// then use a generic folder or generic document, as appropriate.
if (FAILED(hr))
{
SFGAOF attr = SFGAO_FOLDER;
int iIndex;
if (SUCCEEDED(psf->GetAttributesOf(1, &pidl, &attr)) &&
(attr & SFGAO_FOLDER))
{
iIndex = II_FOLDER;
}
else
{
iIndex = II_DOCNOASSOC;
}
hr = SHDefExtractIcon(TEXT("shell32.dll"), iIndex, 0, &hicoLarge, &hicoSmall, cxIcon);
}
// Finally! we have an icon or have exhausted all attempts at getting
// one. If we got one, go add it and clean up.
if (hicoSmall)
DestroyIcon(hicoSmall);
return hicoLarge;
}
int SFTBarHost::_ExtractImageForItem(PaneItem *pitem, IShellFolder *psf, LPCITEMIDLIST pidl)
{
int iIcon = -1; // assume no icon
HICON hIcon = _IconOf(psf, pidl, _cxIcon);
if (hIcon)
{
iIcon = AddImage(hIcon);
DestroyIcon(hIcon);
}
return iIcon;
}
//
// There are two sets of numbers that keep track of items. Sorry.
// (I tried to reduce it to one, but things got hairy.)
//
// 1. Position numbers. Separators occupy a position number.
// 2. Item numbers (listview). Separators do not consume an item number.
//
// Example:
//
// iPos iItem
//
// A 0 0
// B 1 1
// ---- 2 N/A
// C 3 2
// ---- 4 N/A
// D 5 3
//
// _rgiSep[] = { 2, 4 };
//
// _PosToItemNo and _ItemNoToPos do the conversion.
int SFTBarHost::_PosToItemNo(int iPos)
{
// Subtract out the slots occupied by separators.
int iItem = iPos;
for (int i = 0; i < _cSep && _rgiSep[i] < iPos; i++)
{
iItem--;
}
return iItem;
}
int SFTBarHost::_ItemNoToPos(int iItem)
{
// Add in the slots occupied by separators.
int iPos = iItem;
for (int i = 0; i < _cSep && _rgiSep[i] <= iPos; i++)
{
iPos++;
}
return iPos;
}
void SFTBarHost::_ComputeListViewItemPosition(int iItem, POINT *pptOut)
{
// WARNING! _InternalRepopulateList uses an incremental version of this
// algorithm. Keep the two in sync!
ASSERT(_cyTilePadding >= 0);
int y = iItem * _cyTile;
// Adjust for all the separators in the list
for (int i = 0; i < _cSep; i++)
{
if (_rgiSep[i] < iItem)
{
y = y - _cyTile + _cySepTile;
}
}
pptOut->x = _cxMargin;
pptOut->y = y;
}
int SFTBarHost::_InsertListViewItem(int iPos, PaneItem *pitem)
{
ASSERT(pitem);
int iItem = -1;
IShellFolder *psf = NULL;
LPCITEMIDLIST pidl = NULL;
LVITEM lvi;
lvi.pszText = NULL;
lvi.mask = 0;
// If necessary, tell listview that we want to use column 1
// as the subtitle.
if (_iconsize == ICONSIZE_LARGE && pitem->HasSubtitle())
{
const static UINT One = 1;
lvi.mask = LVIF_COLUMNS;
lvi.cColumns = 1;
lvi.puColumns = const_cast<UINT*>(&One);
}
ASSERT(!pitem->IsSeparator());
lvi.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
if (FAILED(GetFolderAndPidl(pitem, &psf, &pidl)))
{
goto exit;
}
if (lvi.mask & LVIF_IMAGE)
{
lvi.iImage = AddImageForItem(pitem, psf, pidl, iPos);
}
if (lvi.mask & LVIF_TEXT)
{
if (_iconsize == ICONSIZE_SMALL && pitem->HasSubtitle())
{
lvi.pszText = SubtitleOfItem(pitem, psf, pidl);
}
else
{
lvi.pszText = DisplayNameOfItem(pitem, psf, pidl, SHGDN_NORMAL);
}
if (!lvi.pszText)
{
goto exit;
}
}
lvi.iItem = iPos;
lvi.iSubItem = 0;
lvi.lParam = reinterpret_cast<LPARAM>(pitem);
iItem = ListView_InsertItem(_hwndList, &lvi);
// If the item has a subtitle, add it.
// If this fails, don't worry. The subtitle is just a fluffy bonus thing.
if (iItem >= 0 && (lvi.mask & LVIF_COLUMNS))
{
lvi.iItem = iItem;
lvi.iSubItem = 1;
lvi.mask = LVIF_TEXT;
SHFree(lvi.pszText);
lvi.pszText = SubtitleOfItem(pitem, psf, pidl);
if (lvi.pszText)
{
ListView_SetItem(_hwndList, &lvi);
}
}
exit:
ATOMICRELEASE(psf);
SHFree(lvi.pszText);
return iItem;
}
// Add items to our view, or at least as many as will fit
void SFTBarHost::_RepopulateList()
{
//
// Kill the async enum animation now that we're ready
//
if (_idtAni)
{
KillTimer(_hwnd, _idtAni);
_idtAni = 0;
}
if (_hwndAni)
{
if (_hBrushAni)
{
DeleteObject(_hBrushAni);
_hBrushAni = NULL;
}
DestroyWindow(_hwndAni);
_hwndAni = NULL;
}
// Let's see if anything changed
BOOL fChanged = FALSE;
if (_fForceChange)
{
_fForceChange = FALSE;
fChanged = TRUE;
}
else if (_dpaEnum.GetPtrCount() == _dpaEnumNew.GetPtrCount())
{
int iMax = _dpaEnum.GetPtrCount();
int i;
for (i=0; i<iMax; i++)
{
if (!_dpaEnum.FastGetPtr(i)->IsEqual(_dpaEnumNew.FastGetPtr(i)))
{
fChanged = TRUE;
break;
}
}
}
else
{
fChanged = TRUE;
}
// No need to do any real work if nothing changed.
if (fChanged)
{
// Now move the _dpaEnumNew to _dpaEnum
// Clear out the old DPA, we don't need it anymore
_dpaEnum.EnumCallbackEx(PaneItem::DPAEnumCallback, (void *)NULL);
_dpaEnum.DeleteAllPtrs();
// switch DPAs now
CDPA<PaneItem> dpaTemp = _dpaEnum;
_dpaEnum = _dpaEnumNew;
_dpaEnumNew = dpaTemp;
_InternalRepopulateList();
}
else
{
// Clear out the new DPA, we don't need it anymore
_dpaEnumNew.EnumCallbackEx(PaneItem::DPAEnumCallback, (void *)NULL);
_dpaEnumNew.DeleteAllPtrs();
}
_fNeedsRepopulate = FALSE;
}
// The internal version is when we decide to repopulate on our own,
// not at the prompting of the background thread. (Therefore, we
// don't nuke the animation.)
void SFTBarHost::_InternalRepopulateList()
{
//
// Start with a clean slate.
//
ListView_DeleteAllItems(_hwndList);
if (_IsPrivateImageList())
{
ImageList_RemoveAll(_himl);
}
int cPinned = 0;
int cNormal = 0;
_DebugConsistencyCheck();
SetWindowRedraw(_hwndList, FALSE);
DEBUG_CODE(_fPopulating++);
//
// To populate the list, we toss the pinned items at the top,
// then let the enumerated items flow beneath them.
//
// Separator "items" don't get added to the listview. They
// are added to the special "separators list".
//
// WARNING! We are computing incrementally the same values as
// _ComputeListViewItemPosition. Keep the two in sync.
//
int iPos; // the slot we are trying to fill
int iEnum; // the item index we will fill it from
int y = 0; // where the next item should be placed
BOOL fSepSeen = FALSE; // have we seen a separator yet?
PaneItem *pitem; // the item that will fill it
_cSep = 0; // no separators (yet)
RECT rc;
GetClientRect(_hwndList, &rc);
//
// Subtract out the bonus separator used by SPP_PROGLIST
//
if (_iThemePart == SPP_PROGLIST)
{
rc.bottom -= _cySep;
}
// Note that the loop control must be a _dpaEnum.GetPtr(), not a
// _dpaEnum.FastGetPtr(), because iEnum can go past the end of the
// array if we do't have enough items to fill the view.
//
//
// The "while" condition is "there is room for another non-separator
// item and there are items remaining in the enumeration".
BOOL fCheckMaxLength = HasDynamicContent();
for (iPos = iEnum = 0;
(pitem = _dpaEnum.GetPtr(iEnum)) != NULL;
iEnum++)
{
if (fCheckMaxLength)
{
if (y + _cyTile > rc.bottom)
{
break;
}
// Once we hit a separator, check if we satisfied the number
// of normal items. We have to wait until a separator is
// hit, because _cNormalDesired can be zero; otherwise we
// would end up stopping before adding even the pinned items!
if (fSepSeen && cNormal >= _cNormalDesired)
{
break;
}
}
#ifdef DEBUG
// Make sure that we are in sync with _ComputeListViewItemPosition
POINT pt;
_ComputeListViewItemPosition(iPos, &pt);
ASSERT(pt.x == _cxMargin);
ASSERT(pt.y == y);
#endif
if (pitem->IsSeparator())
{
fSepSeen = TRUE;
// Add the separator, but only if it actually separate something.
// If this EVAL fires, it means somebody added a separator
// and MAX_SEPARATORS needs to be increased
if (iPos > 0 && EVAL(_cSep < ARRAYSIZE(_rgiSep)))
{
_rgiSep[_cSep++] = iPos++;
y += _cySepTile;
}
}
else
{
if (_InsertListViewItem(iPos, pitem) >= 0)
{
pitem->_iPos = iPos++;
y += _cyTile;
if (pitem->IsPinned())
{
cPinned++;
}
else
{
cNormal++;
}
}
}
}
//
// If the last item was a separator, then delete it
// since it's not actually separating anything.
//
if (_cSep && _rgiSep[_cSep-1] == iPos - 1)
{
_cSep--;
}
_cPinned = cPinned;
//
// Now put the items where they belong.
//
_RepositionItems();
DEBUG_CODE(_fPopulating--);
SetWindowRedraw(_hwndList, TRUE);
// Now, we need to go update our cached bitmap version of the start menu.
_SendNotify(_hwnd, SMN_NEEDREPAINT, NULL);
_DebugConsistencyCheck();
}
LRESULT SFTBarHost::_OnCreate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT rc;
GetClientRect(_hwnd, &rc);
if (_hTheme)
{
GetThemeMargins(_hTheme, NULL, _iThemePart, 0, TMT_CONTENTMARGINS, &rc, &_margins);
}
else
{
_margins.cyTopHeight = 2*GetSystemMetrics(SM_CXEDGE);
_margins.cxLeftWidth = 2*GetSystemMetrics(SM_CXEDGE);
_margins.cxRightWidth = 2*GetSystemMetrics(SM_CXEDGE);
}
//
// Now to create the listview.
//
DWORD dwStyle = WS_CHILD | WS_VISIBLE |
WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
// Do not set WS_TABSTOP; SFTBarHost handles tabbing
LVS_LIST |
LVS_SINGLESEL |
LVS_NOSCROLL |
LVS_SHAREIMAGELISTS;
if (_dwFlags & HOSTF_CANRENAME)
{
dwStyle |= LVS_EDITLABELS;
}
DWORD dwExStyle = 0;
_hwndList = CreateWindowEx(dwExStyle, WC_LISTVIEW, NULL, dwStyle,
_margins.cxLeftWidth, _margins.cyTopHeight, rc.right, rc.bottom, // no point in being too exact, we'll be resized later
_hwnd, NULL,
_Module.GetModuleInstance(), NULL);
if (!_hwndList)
return -1;
//
// Don't freak out if this fails. It just means that the accessibility
// stuff won't be perfect.
//
SetAccessibleSubclassWindow(_hwndList);
//
// Create two dummy columns. We will never display them, but they
// are necessary so that we have someplace to put our subtitle.
//
LVCOLUMN lvc;
lvc.mask = LVCF_WIDTH;
lvc.cx = 1;
ListView_InsertColumn(_hwndList, 0, &lvc);
ListView_InsertColumn(_hwndList, 1, &lvc);
//
// If we are topmost, then force the tooltip topmost, too.
// Otherwise we end up covering our own tooltip!
//
if (GetWindowExStyle(GetAncestor(_hwnd, GA_ROOT)) & WS_EX_TOPMOST)
{
HWND hwndTT = ListView_GetToolTips(_hwndList);
if (hwndTT)
{
SetWindowPos(hwndTT, HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
}
}
// Must do Marlett after doing the listview font, because we base the
// Marlett font metrics on the listview font metrics (so they match)
if (_dwFlags & HOSTF_CASCADEMENU)
{
if (!_CreateMarlett())
return -1;
}
// We can survive if these objects fail to be created
CoCreateInstance(CLSID_DragDropHelper, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(IDropTargetHelper, &_pdth));
CoCreateInstance(CLSID_DragDropHelper, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(IDragSourceHelper, &_pdsh));
//
// If this fails, no big whoop - you just don't get
// drag/drop, boo hoo.
//
RegisterDragDrop(_hwndList, this);
if (!_dpaEnum.Create(4))
return -1;
if (!_dpaEnumNew.Create(4))
return -1;
//-------------------------
// Imagelist goo
int iIconSize = ReadIconSize();
Shell_GetImageLists(iIconSize ? &_himl : NULL, iIconSize ? NULL : &_himl);
if (!_himl)
return -1;
// Preload values in case GetIconSize barfs
_cxIcon = GetSystemMetrics(iIconSize ? SM_CXICON : SM_CXSMICON);
_cyIcon = GetSystemMetrics(iIconSize ? SM_CYICON : SM_CYSMICON);
ImageList_GetIconSize(_himl, &_cxIcon, &_cyIcon);
//
// If we asked for the MEDIUM-sized icons, then create the real
// image list based on the system image list.
//
_iconsize = (ICONSIZE)iIconSize;
if (_iconsize == ICONSIZE_MEDIUM)
{
// These upcoming computations rely on the fact that ICONSIZE_LARGE
// and ICONSIZE_MEDIUM are both nonzero so when we fetched the icon
// sizes for ICONSIZE_MEDIUM, we got SM_CXICON (large).
COMPILETIME_ASSERT(ICONSIZE_LARGE && ICONSIZE_MEDIUM);
// SM_CXICON is the size of shell large icons. SM_CXSMICON is *not*
// the size of shell small icons! It is the size of caption small
// icons. Shell small icons are always 50% of shell large icons.
// We want to be halfway between shell small (50%) and shell
// large (100%); i.e., we want 75%.
_cxIcon = _cxIcon * 3 / 4;
_cyIcon = _cyIcon * 3 / 4;
//
// When the user is in Large Icon mode, we end up choosing 36x36
// (halfway between 24x24 and 48x48), but there is no 36x36 icon
// in the icon resource. But we do have a 32, which is close
// enough. (If we didn't do this, then the 36x36 icon would be
// the 32x32 icon stretched, which looks ugly.)
//
// So any square icon in the range 28..36 we round to 32.
//
if (_cxIcon == _cyIcon && _cxIcon >= 28 && _cxIcon <= 36)
{
_cxIcon = _cyIcon = 32;
}
// It is critical that we overwrite _himl even on failure, so our
// destructor doesn't try to destroy a system image list!
_himl = ImageList_Create(_cxIcon, _cyIcon, ImageList_GetFlags(_himl), 8, 2);
if (!_himl)
{
return -1;
}
}
ListView_SetImageList(_hwndList, _himl, LVSIL_NORMAL);
// Register for SHCNE_UPDATEIMAGE so we know when to reload our icons
_RegisterNotify(SFTHOST_HOSTNOTIFY_UPDATEIMAGE, SHCNE_UPDATEIMAGE, NULL, FALSE);
//-------------------------
_cxMargin = GetSystemMetrics(SM_CXEDGE);
_cyMargin = GetSystemMetrics(SM_CYEDGE);
_cyTilePadding = 0;
_ComputeTileMetrics();
//
// In the themed case, the designers want a narrow separator.
// In the nonthemed case, we need a fat separator because we need
// to draw an etch (which requires two pixels).
//
if (_hTheme)
{
SIZE siz={0};
GetThemePartSize(_hTheme, NULL, _iThemePartSep, 0, NULL, TS_TRUE, &siz);
_cySep = siz.cy;
}
else
{
_cySep = GetSystemMetrics(SM_CYEDGE);
}
_cySepTile = 4 * _cySep;
ASSERT(rc.left == 0 && rc.top == 0); // Should still be a client rectangle
_SetTileWidth(rc.right); // so rc.right = RCWIDTH and rc.bottom = RCHEIGHT
// In tile view, full-row-select really means full-tile-select
DWORD dwLvExStyle = LVS_EX_INFOTIP |
LVS_EX_FULLROWSELECT;
if (!GetSystemMetrics(SM_REMOTESESSION))
{
dwLvExStyle |= LVS_EX_DOUBLEBUFFER;
}
ListView_SetExtendedListViewStyleEx(_hwndList, dwLvExStyle,
dwLvExStyle);
if (!_hTheme)
{
ListView_SetTextColor(_hwndList, GetSysColor(COLOR_MENUTEXT));
_clrHot = GetSysColor(COLOR_MENUTEXT);
_clrBG = GetSysColor(COLOR_MENU); // default color for no theme case
_clrSubtitle = CLR_NONE;
}
else
{
COLORREF clrText;
GetThemeColor(_hTheme, _iThemePart, 0, TMT_HOTTRACKING, &_clrHot); // todo - use state
GetThemeColor(_hTheme, _iThemePart, 0, TMT_CAPTIONTEXT, &_clrSubtitle);
_clrBG = CLR_NONE;
GetThemeColor(_hTheme, _iThemePart, 0, TMT_TEXTCOLOR, &clrText);
ListView_SetTextColor(_hwndList, clrText);
ListView_SetOutlineColor(_hwndList, _clrHot);
}
ListView_SetBkColor(_hwndList, _clrBG);
ListView_SetTextBkColor(_hwndList, _clrBG);
ListView_SetView(_hwndList, LV_VIEW_TILE);
// USER will send us a WM_SIZE after the WM_CREATE, which will cause
// the listview to repopulate, if we chose to repopulate in the
// foreground.
return 0;
}
BOOL SFTBarHost::_CreateMarlett()
{
HDC hdc = GetDC(_hwndList);
if (hdc)
{
HFONT hfPrev = SelectFont(hdc, GetWindowFont(_hwndList));
if (hfPrev)
{
TEXTMETRIC tm;
if (GetTextMetrics(hdc, &tm))
{
LOGFONT lf;
ZeroMemory(&lf, sizeof(lf));
lf.lfHeight = tm.tmAscent;
lf.lfWeight = FW_NORMAL;
lf.lfCharSet = SYMBOL_CHARSET;
lstrcpy(lf.lfFaceName, TEXT("Marlett"));
_hfMarlett = CreateFontIndirect(&lf);
if (_hfMarlett)
{
SelectFont(hdc, _hfMarlett);
if (GetTextMetrics(hdc, &tm))
{
_tmAscentMarlett = tm.tmAscent;
SIZE siz;
if (GetTextExtentPoint(hdc, TEXT("8"), 1, &siz))
{
_cxMarlett = siz.cx;
}
}
}
}
SelectFont(hdc, hfPrev);
}
ReleaseDC(_hwndList, hdc);
}
return _cxMarlett;
}
void SFTBarHost::_CreateBoldFont()
{
if (!_hfBold)
{
HFONT hf = GetWindowFont(_hwndList);
if (hf)
{
LOGFONT lf;
if (GetObject(hf, sizeof(lf), &lf))
{
lf.lfWeight = FW_BOLD;
SHAdjustLOGFONT(&lf); // locale-specific adjustments
_hfBold = CreateFontIndirect(&lf);
}
}
}
}
void SFTBarHost::_ReloadText()
{
int iItem;
for (iItem = ListView_GetItemCount(_hwndList) - 1; iItem >= 0; iItem--)
{
TCHAR szText[MAX_PATH];
LVITEM lvi;
lvi.iItem = iItem;
lvi.iSubItem = 0;
lvi.mask = LVIF_PARAM | LVIF_TEXT;
lvi.pszText = szText;
lvi.cchTextMax = ARRAYSIZE(szText);
if (ListView_GetItem(_hwndList, &lvi))
{
PaneItem *pitem = _GetItemFromLVLParam(lvi.lParam);
if (!pitem)
{
break;
}
// Update the display name in case it changed behind our back.
// Note that this is not redundant with the creation of the items
// in _InsertListViewItem because this is done only on the second
// and subsequent enumeration. (We assume the first enumeration
// is just peachy.)
lvi.iItem = iItem;
lvi.iSubItem = 0;
lvi.mask = LVIF_TEXT;
lvi.pszText = _DisplayNameOfItem(pitem, SHGDN_NORMAL);
if (lvi.pszText)
{
if (StrCmpN(szText, lvi.pszText, ARRAYSIZE(szText)) != 0)
{
ListView_SetItem(_hwndList, &lvi);
_SendNotify(_hwnd, SMN_NEEDREPAINT, NULL);
}
SHFree(lvi.pszText);
}
}
}
}
void SFTBarHost::_RevalidateItems()
{
// If client does not require revalidation, then assume still valid
if (!(_dwFlags & HOSTF_REVALIDATE))
{
return;
}
int iItem;
for (iItem = ListView_GetItemCount(_hwndList) - 1; iItem >= 0; iItem--)
{
PaneItem *pitem = _GetItemFromLV(iItem);
if (!pitem || !IsItemStillValid(pitem))
{
_fEnumValid = FALSE;
break;
}
}
}
void SFTBarHost::_RevalidatePostPopup()
{
_RevalidateItems();
if (_dwFlags & HOSTF_RELOADTEXT)
{
SetTimer(_hwnd, IDT_RELOADTEXT, 250, NULL);
}
// If the list is still good, then don't bother redoing it
if (!_fEnumValid)
{
_EnumerateContents(FALSE);
}
}
void SFTBarHost::_EnumerateContents(BOOL fUrgent)
{
// If we have deferred refreshes until the window closes, then
// leave it alone.
if (!fUrgent && _fNeedsRepopulate)
{
return;
}
// If we're already enumerating, then just remember to do it again
if (_fBGTask)
{
// accumulate urgency so a low-priority request + an urgent request
// is treated as urgent
_fRestartUrgent |= fUrgent;
_fRestartEnum = TRUE;
return;
}
_fRestartEnum = FALSE;
_fRestartUrgent = FALSE;
// If the list is still good, then don't bother redoing it
if (_fEnumValid && !fUrgent)
{
return;
}
// This re-enumeration will make everything valid.
_fEnumValid = TRUE;
// Clear out all the leftover stuff from the previous enumeration
_dpaEnumNew.EnumCallbackEx(PaneItem::DPAEnumCallback, (void *)NULL);
_dpaEnumNew.DeleteAllPtrs();
// Let client do some work on the foreground thread
PrePopulate();
// Finish the enumeration either on the background thread (if requested)
// or on the foreground thread (if can't enumerate in the background).
HRESULT hr;
if (NeedBackgroundEnum())
{
if (_psched)
{
hr = S_OK;
}
else
{
// We need a separate task scheduler for each instance
hr = CoCreateInstance(CLSID_ShellTaskScheduler, NULL, CLSCTX_INPROC,
IID_PPV_ARG(IShellTaskScheduler, &_psched));
}
if (SUCCEEDED(hr))
{
CBGEnum *penum = new CBGEnum(this, fUrgent);
if (penum)
{
// We want to run at a priority slightly above normal
// because the user is sitting there waiting for the
// enumeration to complete.
#define ITSAT_BGENUM_PRIORITY (ITSAT_DEFAULT_PRIORITY + 0x1000)
hr = _psched->AddTask(penum, TOID_SFTBarHostBackgroundEnum, (DWORD_PTR)this, ITSAT_BGENUM_PRIORITY);
if (SUCCEEDED(hr))
{
_fBGTask = TRUE;
if (ListView_GetItemCount(_hwndList) == 0)
{
//
// Set a timer that will create the "please wait"
// animation if the enumeration takes too long.
//
_idtAni = IDT_ASYNCENUM;
SetTimer(_hwnd, _idtAni, 1000, NULL);
}
}
penum->Release();
}
}
}
if (!_fBGTask)
{
// Fallback: Do it on the foreground thread
_EnumerateContentsBackground();
_RepopulateList();
}
}
void SFTBarHost::_EnumerateContentsBackground()
{
// Start over
DEBUG_CODE(_fEnumerating = TRUE);
EnumItems();
DEBUG_CODE(_fEnumerating = FALSE);
#ifdef _ALPHA_
// Alpha compiler is lame
_dpaEnumNew.Sort((CDPA<PaneItem>::_PFNDPACOMPARE)_SortItemsAfterEnum, (LPARAM)this);
#else
_dpaEnumNew.SortEx(_SortItemsAfterEnum, this);
#endif
}
int CALLBACK SFTBarHost::_SortItemsAfterEnum(PaneItem *p1, PaneItem *p2, SFTBarHost *self)
{
//
// Put all pinned items (sorted by pin position) ahead of unpinned items.
//
if (p1->IsPinned())
{
if (p2->IsPinned())
{
return p1->GetPinPos() - p2->GetPinPos();
}
return -1;
}
else if (p2->IsPinned())
{
return +1;
}
//
// Both unpinned - let the client decide.
//
return self->CompareItems(p1, p2);
}
SFTBarHost::~SFTBarHost()
{
// We shouldn't be destroyed while in these temporary states.
// If this fires, it's possible that somebody incremented
// _fListUnstable/_fPopulating and forgot to decrement it.
ASSERT(!_fListUnstable);
ASSERT(!_fPopulating);
ATOMICRELEASE(_pdth);
ATOMICRELEASE(_pdsh);
ATOMICRELEASE(_psched);
ASSERT(_pdtoDragOut == NULL);
if (_dpaEnum)
{
_dpaEnum.DestroyCallbackEx(PaneItem::DPAEnumCallback, (void *)NULL);
}
if (_dpaEnumNew)
{
_dpaEnumNew.DestroyCallbackEx(PaneItem::DPAEnumCallback, (void *)NULL);
}
if (_IsPrivateImageList() && _himl)
{
ImageList_Destroy(_himl);
}
if (_hfList)
{
DeleteObject(_hfList);
}
if (_hfBold)
{
DeleteObject(_hfBold);
}
if (_hfMarlett)
{
DeleteObject(_hfMarlett);
}
if (_hBrushAni)
{
DeleteObject(_hBrushAni);
}
}
LRESULT SFTBarHost::_OnDestroy(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
UINT id;
for (id = 0; id < SFTHOST_MAXNOTIFY; id++)
{
UnregisterNotify(id);
}
if (_hwndList)
{
RevokeDragDrop(_hwndList);
}
return ::DefWindowProc(hwnd, uMsg, wParam, lParam);
}
LRESULT SFTBarHost::_OnNcDestroy(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// WARNING! "this" might be NULL (if WM_NCCREATE failed).
LRESULT lres = DefWindowProc(hwnd, uMsg, wParam, lParam);
SetWindowPtr0(hwnd, 0);
if (this) {
_hwndList = NULL;
_hwnd = NULL;
if (_psched)
{
// Remove all tasks now, and wait for them to finish
_psched->RemoveTasks(TOID_NULL, ITSAT_DEFAULT_LPARAM, TRUE);
ATOMICRELEASE(_psched);
}
Release();
}
return lres;
}
LRESULT SFTBarHost::_OnNotify(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPNMHDR pnm = reinterpret_cast<LPNMHDR>(lParam);
if (pnm->hwndFrom == _hwndList)
{
switch (pnm->code)
{
case NM_CUSTOMDRAW:
return _OnLVCustomDraw(CONTAINING_RECORD(
CONTAINING_RECORD(pnm, NMCUSTOMDRAW, hdr),
NMLVCUSTOMDRAW, nmcd));
case NM_CLICK:
return _OnLVNItemActivate(CONTAINING_RECORD(pnm, NMITEMACTIVATE, hdr));
case NM_RETURN:
return _ActivateItem(_GetLVCurSel(), AIF_KEYBOARD);
case NM_KILLFOCUS:
// On loss of focus, deselect all items so they all draw
// in the plain state.
ListView_SetItemState(_hwndList, -1, 0, LVIS_SELECTED | LVIS_FOCUSED);
break;
case LVN_GETINFOTIP:
return _OnLVNGetInfoTip(CONTAINING_RECORD(pnm, NMLVGETINFOTIP, hdr));
case LVN_BEGINDRAG:
case LVN_BEGINRDRAG:
return _OnLVNBeginDrag(CONTAINING_RECORD(pnm, NMLISTVIEW, hdr));
case LVN_BEGINLABELEDIT:
return _OnLVNBeginLabelEdit(CONTAINING_RECORD(pnm, NMLVDISPINFO, hdr));
case LVN_ENDLABELEDIT:
return _OnLVNEndLabelEdit(CONTAINING_RECORD(pnm, NMLVDISPINFO, hdr));
case LVN_KEYDOWN:
return _OnLVNKeyDown(CONTAINING_RECORD(pnm, NMLVKEYDOWN, hdr));
}
}
else
{
switch (pnm->code)
{
case SMN_INITIALUPDATE:
_EnumerateContents(FALSE);
break;
case SMN_POSTPOPUP:
_RevalidatePostPopup();
break;
case SMN_GETMINSIZE:
return _OnSMNGetMinSize(CONTAINING_RECORD(pnm, SMNGETMINSIZE, hdr));
break;
case SMN_FINDITEM:
return _OnSMNFindItem(CONTAINING_RECORD(pnm, SMNDIALOGMESSAGE, hdr));
case SMN_DISMISS:
return _OnSMNDismiss();
case SMN_APPLYREGION:
return HandleApplyRegion(_hwnd, _hTheme, (SMNMAPPLYREGION *)lParam, _iThemePart, 0);
case SMN_SHELLMENUDISMISSED:
_iCascading = -1;
return 0;
}
}
// Give derived class a chance to respond
return OnWndProc(hwnd, uMsg, wParam, lParam);
}
LRESULT SFTBarHost::_OnTimer(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch (wParam)
{
case IDT_ASYNCENUM:
KillTimer(hwnd, wParam);
// For some reason, we sometimes get spurious WM_TIMER messages,
// so ignore them if we aren't expecting them.
if (_idtAni)
{
_idtAni = 0;
if (_hwndList && !_hwndAni)
{
DWORD dwStyle = WS_CHILD | WS_VISIBLE |
WS_CLIPCHILDREN | WS_CLIPSIBLINGS |
ACS_AUTOPLAY | ACS_TIMER | ACS_TRANSPARENT;
RECT rcClient;
GetClientRect(_hwnd, &rcClient);
int x = (RECTWIDTH(rcClient) - ANIWND_WIDTH)/2; // IDA_SEARCH is ANIWND_WIDTH pix wide
int y = (RECTHEIGHT(rcClient) - ANIWND_HEIGHT)/2; // IDA_SEARCH is ANIWND_HEIGHT pix tall
_hwndAni = CreateWindow(ANIMATE_CLASS, NULL, dwStyle,
x, y, 0, 0,
_hwnd, NULL,
_Module.GetModuleInstance(), NULL);
if (_hwndAni)
{
SetWindowPos(_hwndAni, HWND_TOP, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
#define IDA_SEARCH 150 // from shell32
Animate_OpenEx(_hwndAni, GetModuleHandle(TEXT("SHELL32")), MAKEINTRESOURCE(IDA_SEARCH));
}
}
}
return 0;
case IDT_RELOADTEXT:
KillTimer(hwnd, wParam);
_ReloadText();
break;
case IDT_REFRESH:
KillTimer(hwnd, wParam);
PostMessage(hwnd, SFTBM_REFRESH, FALSE, 0);
break;
}
// Give derived class a chance to respond
return OnWndProc(hwnd, uMsg, wParam, lParam);
}
LRESULT SFTBarHost::_OnSetFocus(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (_hwndList)
{
SetFocus(_hwndList);
}
return 0;
}
LRESULT SFTBarHost::_OnEraseBackground(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
RECT rc;
GetClientRect(hwnd, &rc);
if (_hTheme)
DrawThemeBackground(_hTheme, (HDC)wParam, _iThemePart, 0, &rc, 0);
else
{
SHFillRectClr((HDC)wParam, &rc, _clrBG);
if (_iThemePart == SPP_PLACESLIST) // we set this even in non-theme case, its how we tell them apart
DrawEdge((HDC)wParam, &rc, EDGE_ETCHED, BF_LEFT);
}
return TRUE;
}
LRESULT SFTBarHost::_OnLVCustomDraw(LPNMLVCUSTOMDRAW plvcd)
{
_DebugConsistencyCheck();
switch (plvcd->nmcd.dwDrawStage)
{
case CDDS_PREPAINT:
return _OnLVPrePaint(plvcd);
case CDDS_ITEMPREPAINT:
return _OnLVItemPrePaint(plvcd);
case CDDS_ITEMPREPAINT | CDDS_SUBITEM:
return _OnLVSubItemPrePaint(plvcd);
case CDDS_ITEMPOSTPAINT:
return _OnLVItemPostPaint(plvcd);
case CDDS_POSTPAINT:
return _OnLVPostPaint(plvcd);
}
return CDRF_DODEFAULT;
}
//
// Listview makes it hard to detect whether you are in a real customdraw
// or a fake customdraw, since it frequently "gets confused" and gives
// you a 0x0 rectangle even though it really wants you to draw something.
//
// Even worse, within a single paint cycle, Listview uses multiple
// NMLVCUSTOMDRAW structures so you can't stash state inside the customdraw
// structure. You have to save it externally.
//
// The only trustworthy guy is CDDS_PREPAINT. Use his rectangle to
// determine whether this is a real or fake customdraw...
//
// What's even weirder is that inside a regular paint cycle, you
// can get re-entered with a sub-paint cycle, so we have to maintain
// a stack of "is the current customdraw cycle real or fake?" bits.
void SFTBarHost::_CustomDrawPush(BOOL fReal)
{
_dwCustomDrawState = (_dwCustomDrawState << 1) | fReal;
}
BOOL SFTBarHost::_IsRealCustomDraw()
{
return _dwCustomDrawState & 1;
}
void SFTBarHost::_CustomDrawPop()
{
_dwCustomDrawState >>= 1;
}
LRESULT SFTBarHost::_OnLVPrePaint(LPNMLVCUSTOMDRAW plvcd)
{
LRESULT lResult;
// Always ask for postpaint so we can maintain our customdraw stack
lResult = CDRF_NOTIFYITEMDRAW | CDRF_NOTIFYPOSTPAINT;
BOOL fReal = !IsRectEmpty(&plvcd->nmcd.rc);
_CustomDrawPush(fReal);
if (fReal)
{
if (_IsInsertionMarkActive())
{
if (_pdth)
{
_pdth->Show(FALSE);
}
}
}
return lResult;
}
//
// Hack! We want to know in _OnLvSubItemPrePaint whether the item
// is selected or not, We borrow the CDIS_CHECKED bit, which is
// otherwise used only by toolbar controls.
//
#define CDIS_WASSELECTED CDIS_CHECKED
LRESULT SFTBarHost::_OnLVItemPrePaint(LPNMLVCUSTOMDRAW plvcd)
{
LRESULT lResult = CDRF_DODEFAULT;
plvcd->nmcd.uItemState &= ~CDIS_WASSELECTED;
if (GetFocus() == _hwndList &&
(plvcd->nmcd.uItemState & CDIS_SELECTED))
{
plvcd->nmcd.uItemState |= CDIS_WASSELECTED;
// menu-highlighted tiles are always opaque
if (_hTheme)
{
plvcd->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
plvcd->clrFace = plvcd->clrTextBk = GetSysColor(COLOR_MENUHILIGHT);
}
else
{
plvcd->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
plvcd->clrFace = plvcd->clrTextBk = GetSysColor(COLOR_HIGHLIGHT);
}
}
// Turn off CDIS_SELECTED because it causes the icon to get alphablended
// and we don't want that. Turn off CDIS_FOCUS because that draws a
// focus rectangle and we don't want that either.
plvcd->nmcd.uItemState &= ~(CDIS_SELECTED | CDIS_FOCUS);
//
if (plvcd->nmcd.uItemState & CDIS_HOT && _clrHot != CLR_NONE)
plvcd->clrText = _clrHot;
// Turn off selection highlighting for everyone except
// the drop target highlight
if ((int)plvcd->nmcd.dwItemSpec != _iDragOver || !_pdtDragOver)
{
lResult |= LVCDRF_NOSELECT;
}
PaneItem *pitem = _GetItemFromLVLParam(plvcd->nmcd.lItemlParam);
if (!pitem)
{
// Sometimes ListView doesn't give us an lParam so we have to
// get it ourselves
pitem = _GetItemFromLV((int)plvcd->nmcd.dwItemSpec);
}
if (pitem)
{
if (IsBold(pitem))
{
_CreateBoldFont();
SelectFont(plvcd->nmcd.hdc, _hfBold);
lResult |= CDRF_NEWFONT;
}
if (pitem->IsCascade())
{
// Need subitem notification because that's what sets the colors
lResult |= CDRF_NOTIFYPOSTPAINT | CDRF_NOTIFYSUBITEMDRAW;
}
if (pitem->HasAccelerator())
{
// Need subitem notification because that's what sets the colors
lResult |= CDRF_NOTIFYPOSTPAINT | CDRF_NOTIFYSUBITEMDRAW;
}
if (pitem->HasSubtitle())
{
lResult |= CDRF_NOTIFYSUBITEMDRAW;
}
}
return lResult;
}
LRESULT SFTBarHost::_OnLVSubItemPrePaint(LPNMLVCUSTOMDRAW plvcd)
{
LRESULT lResult = CDRF_DODEFAULT;
if (plvcd->iSubItem == 1)
{
// Second line uses the regular font (first line was bold)
SelectFont(plvcd->nmcd.hdc, GetWindowFont(_hwndList));
lResult |= CDRF_NEWFONT;
if (GetFocus() == _hwndList &&
(plvcd->nmcd.uItemState & CDIS_WASSELECTED))
{
plvcd->clrText = GetSysColor(COLOR_HIGHLIGHTTEXT);
}
else
// Maybe there's a custom subtitle color
if (_clrSubtitle != CLR_NONE)
{
plvcd->clrText = _clrSubtitle;
}
else
{
plvcd->clrText = GetSysColor(COLOR_MENUTEXT);
}
}
return lResult;
}
// QUIRK! Listview often sends item postpaint messages even though we
// didn't ask for one. It does this because we set NOTIFYPOSTPAINT on
// the CDDS_PREPAINT notification ("please notify me when the entire
// listview is finished painting") and it thinks that that flag also
// turns on postpaint notifications for each item...
LRESULT SFTBarHost::_OnLVItemPostPaint(LPNMLVCUSTOMDRAW plvcd)
{
PaneItem *pitem = _GetItemFromLVLParam(plvcd->nmcd.lItemlParam);
if (_IsRealCustomDraw() && pitem)
{
RECT rc;
if (ListView_GetItemRect(_hwndList, plvcd->nmcd.dwItemSpec, &rc, LVIR_LABEL))
{
COLORREF clrBkPrev = SetBkColor(plvcd->nmcd.hdc, plvcd->clrFace);
COLORREF clrTextPrev = SetTextColor(plvcd->nmcd.hdc, plvcd->clrText);
int iModePrev = SetBkMode(plvcd->nmcd.hdc, TRANSPARENT);
BOOL fRTL = GetLayout(plvcd->nmcd.hdc) & LAYOUT_RTL;
if (pitem->IsCascade())
{
{
HFONT hfPrev = SelectFont(plvcd->nmcd.hdc, _hfMarlett);
if (hfPrev)
{
TCHAR chOut = fRTL ? TEXT('w') : TEXT('8');
UINT fuOptions = 0;
if (fRTL)
{
fuOptions |= ETO_RTLREADING;
}
ExtTextOut(plvcd->nmcd.hdc, rc.right - _cxMarlett,
rc.top + (rc.bottom - rc.top - _tmAscentMarlett)/2,
fuOptions, &rc, &chOut, 1, NULL);
SelectFont(plvcd->nmcd.hdc, hfPrev);
}
}
}
if (pitem->HasAccelerator() &&
(plvcd->nmcd.uItemState & CDIS_SHOWKEYBOARDCUES))
{
// Subtitles mess up our computations...
ASSERT(!pitem->HasSubtitle());
rc.right -= _cxMarlett; // Subtract out our margin
UINT uFormat = DT_VCENTER | DT_SINGLELINE | DT_PREFIXONLY |
DT_WORDBREAK | DT_EDITCONTROL | DT_WORD_ELLIPSIS;
if (fRTL)
{
uFormat |= DT_RTLREADING;
}
DrawText(plvcd->nmcd.hdc, pitem->_pszAccelerator, -1, &rc, uFormat);
rc.right += _cxMarlett; // restore it
}
SetBkMode(plvcd->nmcd.hdc, iModePrev);
SetTextColor(plvcd->nmcd.hdc, clrTextPrev);
SetBkColor(plvcd->nmcd.hdc, clrBkPrev);
}
}
return CDRF_DODEFAULT;
}
LRESULT SFTBarHost::_OnLVPostPaint(LPNMLVCUSTOMDRAW plvcd)
{
if (_IsRealCustomDraw())
{
_DrawInsertionMark(plvcd);
_DrawSeparators(plvcd);
if (_pdth)
{
_pdth->Show(TRUE);
}
}
_CustomDrawPop();
return CDRF_DODEFAULT;
}
LRESULT SFTBarHost::_OnUpdateUIState(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// Only need to do this when the Start Menu is visible; if not visible, then
// don't waste your time invalidating useless rectangles (and paging them in!)
if (IsWindowVisible(GetAncestor(_hwnd, GA_ROOT)))
{
// All UIS_SETs should happen when the Start Menu is hidden;
// we assume that the only thing we will be asked to do is to
// start showing the underlines
ASSERT(LOWORD(wParam) != UIS_SET);
DWORD dwLvExStyle = 0;
if (!GetSystemMetrics(SM_REMOTESESSION))
{
dwLvExStyle |= LVS_EX_DOUBLEBUFFER;
}
if ((ListView_GetExtendedListViewStyle(_hwndList) & LVS_EX_DOUBLEBUFFER) != dwLvExStyle)
{
ListView_SetExtendedListViewStyleEx(_hwndList, LVS_EX_DOUBLEBUFFER, dwLvExStyle);
}
int iItem;
for (iItem = ListView_GetItemCount(_hwndList) - 1; iItem >= 0; iItem--)
{
PaneItem *pitem = _GetItemFromLV(iItem);
if (pitem && pitem->HasAccelerator())
{
RECT rc;
if (ListView_GetItemRect(_hwndList, iItem, &rc, LVIR_LABEL))
{
// We need to repaint background because of cleartype double print issues
InvalidateRect(_hwndList, &rc, TRUE);
}
}
}
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
PaneItem *SFTBarHost::_GetItemFromLV(int iItem)
{
LVITEM lvi;
lvi.iItem = iItem;
lvi.iSubItem = 0;
lvi.mask = LVIF_PARAM;
if (iItem >= 0 && ListView_GetItem(_hwndList, &lvi))
{
PaneItem *pitem = _GetItemFromLVLParam(lvi.lParam);
return pitem;
}
return NULL;
}
LRESULT SFTBarHost::_OnMenuMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT lres;
if (_pcm3Pop && SUCCEEDED(_pcm3Pop->HandleMenuMsg2(uMsg, wParam, lParam, &lres)))
{
return lres;
}
if (_pcm2Pop && SUCCEEDED(_pcm2Pop->HandleMenuMsg(uMsg, wParam, lParam)))
{
return 0;
}
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
LRESULT SFTBarHost::_OnForwardMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
SHPropagateMessage(hwnd, uMsg, wParam, lParam, SPM_SEND | SPM_ONELEVEL);
// Give derived class a chance to get the message, too
return OnWndProc(hwnd, uMsg, wParam, lParam);
}
BOOL SFTBarHost::UnregisterNotify(UINT id)
{
ASSERT(id < SFTHOST_MAXNOTIFY);
if (id < SFTHOST_MAXNOTIFY && _rguChangeNotify[id])
{
UINT uChangeNotify = _rguChangeNotify[id];
_rguChangeNotify[id] = 0;
return SHChangeNotifyDeregister(uChangeNotify);
}
return FALSE;
}
BOOL SFTBarHost::_RegisterNotify(UINT id, LONG lEvents, LPCITEMIDLIST pidl, BOOL fRecursive)
{
ASSERT(id < SFTHOST_MAXNOTIFY);
if (id < SFTHOST_MAXNOTIFY)
{
UnregisterNotify(id);
SHChangeNotifyEntry fsne;
fsne.fRecursive = fRecursive;
fsne.pidl = pidl;
int fSources = SHCNRF_NewDelivery | SHCNRF_ShellLevel | SHCNRF_InterruptLevel;
if (fRecursive)
{
// SHCNRF_RecursiveInterrupt means "Please use a recursive FindFirstChangeNotify"
fSources |= SHCNRF_RecursiveInterrupt;
}
_rguChangeNotify[id] = SHChangeNotifyRegister(_hwnd, fSources, lEvents,
SFTBM_CHANGENOTIFY + id, 1, &fsne);
return _rguChangeNotify[id];
}
return FALSE;
}
//
// wParam = 0 if this is not an urgent refresh (can be postponed)
// wParam = 1 if this is urgent (must refresh even if menu is open)
//
LRESULT SFTBarHost::_OnRepopulate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
// Don't update the list now if we are visible, except if the list was empty
_fBGTask = FALSE;
if (wParam || !IsWindowVisible(_hwnd) || ListView_GetItemCount(_hwndList) == 0)
{
_RepopulateList();
}
else
{
_fNeedsRepopulate = TRUE;
}
if (_fRestartEnum)
{
_EnumerateContents(_fRestartUrgent);
}
return 0;
}
LRESULT SFTBarHost::_OnChangeNotify(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPITEMIDLIST *ppidl;
LONG lEvent;
LPSHChangeNotificationLock pshcnl;
pshcnl = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);
if (pshcnl)
{
UINT id = uMsg - SFTBM_CHANGENOTIFY;
if (id < SFTHOST_MAXCLIENTNOTIFY)
{
OnChangeNotify(id, lEvent, ppidl[0], ppidl[1]);
}
else if (id == SFTHOST_HOSTNOTIFY_UPDATEIMAGE)
{
_OnUpdateImage(ppidl[0], ppidl[1]);
}
else
{
// Our wndproc shouldn't have dispatched to us
ASSERT(0);
}
SHChangeNotification_Unlock(pshcnl);
}
return 0;
}
void SFTBarHost::_OnUpdateImage(LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra)
{
// Must use pidl and not pidlExtra because pidlExtra is sometimes NULL
SHChangeDWORDAsIDList *pdwidl = (SHChangeDWORDAsIDList *)pidl;
if (pdwidl->dwItem1 == 0xFFFFFFFF)
{
// Wholesale icon rebuild; just pitch everything and start over
::PostMessage(v_hwndTray, SBM_REBUILDMENU, 0, 0);
}
else
{
int iImage = SHHandleUpdateImage(pidlExtra);
if (iImage >= 0)
{
UpdateImage(iImage);
}
}
}
//
// See if anybody is using this image; if so, invalidate the cached bitmap.
//
void SFTBarHost::UpdateImage(int iImage)
{
ASSERT(!_IsPrivateImageList());
int iItem;
for (iItem = ListView_GetItemCount(_hwndList) - 1; iItem >= 0; iItem--)
{
LVITEM lvi;
lvi.iItem = iItem;
lvi.iSubItem = 0;
lvi.mask = LVIF_IMAGE;
if (ListView_GetItem(_hwndList, &lvi) && lvi.iImage == iImage)
{
// The cached bitmap is no good; an icon changed
_SendNotify(_hwnd, SMN_NEEDREPAINT, NULL);
break;
}
}
}
//
// wParam = 0 if this is not an urgent refresh (can be postponed)
// wParam = 1 if this is urgen (must refresh even if menu is open)
//
LRESULT SFTBarHost::_OnRefresh(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
_EnumerateContents((BOOL)wParam);
return 0;
}
LPTSTR _DisplayNameOf(IShellFolder *psf, LPCITEMIDLIST pidl, UINT shgno)
{
LPTSTR pszOut;
DisplayNameOfAsOLESTR(psf, pidl, shgno, &pszOut);
return pszOut;
}
LPTSTR SFTBarHost::_DisplayNameOfItem(PaneItem *pitem, UINT shgno)
{
IShellFolder *psf;
LPCITEMIDLIST pidl;
LPTSTR pszOut = NULL;
if (SUCCEEDED(_GetFolderAndPidl(pitem, &psf, &pidl)))
{
pszOut = DisplayNameOfItem(pitem, psf, pidl, (SHGNO)shgno);
psf->Release();
}
return pszOut;
}
HRESULT SFTBarHost::_GetUIObjectOfItem(PaneItem *pitem, REFIID riid, void * *ppv)
{
*ppv = NULL;
IShellFolder *psf;
LPCITEMIDLIST pidlItem;
HRESULT hr = _GetFolderAndPidl(pitem, &psf, &pidlItem);
if (SUCCEEDED(hr))
{
hr = psf->GetUIObjectOf(_hwnd, 1, &pidlItem, riid, NULL, ppv);
psf->Release();
}
return hr;
}
HRESULT SFTBarHost::_GetUIObjectOfItem(int iItem, REFIID riid, void * *ppv)
{
PaneItem *pitem = _GetItemFromLV(iItem);
if (pitem)
{
HRESULT hr = _GetUIObjectOfItem(pitem, riid, ppv);
return hr;
}
return E_FAIL;
}
HRESULT SFTBarHost::_GetFolderAndPidl(PaneItem *pitem, IShellFolder **ppsfOut, LPCITEMIDLIST *ppidlOut)
{
*ppsfOut = NULL;
*ppidlOut = NULL;
return pitem->IsSeparator() ? E_FAIL : GetFolderAndPidl(pitem, ppsfOut, ppidlOut);
}
//
// Given the coordinates of a context menu (lParam from WM_CONTEXTMENU),
// determine which item's context menu should be activated, or -1 if the
// context menu is not for us.
//
// Also, returns on success in *ppt the coordinates at which the
// context menu should be displayed.
//
int SFTBarHost::_ContextMenuCoordsToItem(LPARAM lParam, POINT *ppt)
{
int iItem;
ppt->x = GET_X_LPARAM(lParam);
ppt->y = GET_Y_LPARAM(lParam);
// If initiated from keyboard, act like they clicked on the center
// of the focused icon.
if (IS_WM_CONTEXTMENU_KEYBOARD(lParam))
{
iItem = _GetLVCurSel();
if (iItem >= 0)
{
RECT rc;
if (ListView_GetItemRect(_hwndList, iItem, &rc, LVIR_ICON))
{
MapWindowRect(_hwndList, NULL, &rc);
ppt->x = (rc.left+rc.right)/2;
ppt->y = (rc.top+rc.bottom)/2;
}
else
{
iItem = -1;
}
}
}
else
{
// Initiated from mouse; find the item they clicked on
LVHITTESTINFO hti;
hti.pt = *ppt;
MapWindowPoints(NULL, _hwndList, &hti.pt, 1);
iItem = ListView_HitTest(_hwndList, &hti);
}
return iItem;
}
LRESULT SFTBarHost::_OnContextMenu(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if(_AreChangesRestricted())
{
return 0;
}
TCHAR szBuf[MAX_PATH];
_DebugConsistencyCheck();
BOOL fSuccess = FALSE;
POINT pt;
int iItem = _ContextMenuCoordsToItem(lParam, &pt);
if (iItem >= 0)
{
PaneItem *pitem = _GetItemFromLV(iItem);
if (pitem)
{
// If we can't get the official shell context menu,
// then use a dummy one.
IContextMenu *pcm;
if (FAILED(_GetUIObjectOfItem(pitem, IID_PPV_ARG(IContextMenu, &pcm))))
{
pcm = s_EmptyContextMenu.GetContextMenu();
}
HMENU hmenu = ::CreatePopupMenu();
if (hmenu)
{
UINT uFlags = CMF_NORMAL;
if (GetKeyState(VK_SHIFT) < 0)
{
uFlags |= CMF_EXTENDEDVERBS;
}
if (_dwFlags & HOSTF_CANRENAME)
{
uFlags |= CMF_CANRENAME;
}
pcm->QueryContextMenu(hmenu, 0, IDM_QCM_MIN, IDM_QCM_MAX, uFlags);
// Remove "Create shortcut" from context menu because it creates
// the shortcut on the desktop, which the user can't see...
ContextMenu_DeleteCommandByName(pcm, hmenu, IDM_QCM_MIN, TEXT("link"));
// Remove "Cut" from context menu because we don't want objects
// to be deleted.
ContextMenu_DeleteCommandByName(pcm, hmenu, IDM_QCM_MIN, TEXT("cut"));
// Let clients override the "delete" option.
// Change "Delete" to "Remove from this list".
// If client doesn't support "delete" then nuke it outright.
// If client supports "delete" but the IContextMenu didn't create one,
// then create a fake one so we cn add the "Remove from list" option.
UINT uPosDelete = GetMenuIndexForCanonicalVerb(hmenu, pcm, IDM_QCM_MIN, TEXT("delete"));
UINT uiFlags = 0;
UINT idsDelete = AdjustDeleteMenuItem(pitem, &uiFlags);
if (idsDelete)
{
if (LoadString(_Module.GetResourceInstance(), idsDelete, szBuf, ARRAYSIZE(szBuf)))
{
if (uPosDelete != -1)
{
ModifyMenu(hmenu, uPosDelete, uiFlags | MF_BYPOSITION | MF_STRING, IDM_REMOVEFROMLIST, szBuf);
}
else
{
AppendMenu(hmenu, MF_SEPARATOR, -1, NULL);
AppendMenu(hmenu, uiFlags | MF_STRING, IDM_REMOVEFROMLIST, szBuf);
}
}
}
else
{
DeleteMenu(hmenu, uPosDelete, MF_BYPOSITION);
}
_SHPrettyMenu(hmenu);
ASSERT(_pcm2Pop == NULL); // Shouldn't be recursing
pcm->QueryInterface(IID_PPV_ARG(IContextMenu2, &_pcm2Pop));
ASSERT(_pcm3Pop == NULL); // Shouldn't be recursing
pcm->QueryInterface(IID_PPV_ARG(IContextMenu3, &_pcm3Pop));
int idCmd = TrackPopupMenuEx(hmenu,
TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTALIGN,
pt.x, pt.y, hwnd, NULL);
ATOMICRELEASE(_pcm2Pop);
ATOMICRELEASE(_pcm3Pop);
if (idCmd)
{
switch (idCmd)
{
case IDM_REMOVEFROMLIST:
lstrcpyn(szBuf, TEXT("delete"), ARRAYSIZE(szBuf));
break;
default:
ContextMenu_GetCommandStringVerb(pcm, idCmd - IDM_QCM_MIN, szBuf, ARRAYSIZE(szBuf));
break;
}
idCmd -= IDM_QCM_MIN;
CMINVOKECOMMANDINFOEX ici = {
sizeof(ici), // cbSize
CMIC_MASK_FLAG_LOG_USAGE | // this was an explicit user action
CMIC_MASK_ASYNCOK, // fMask
hwnd, // hwnd
(LPCSTR)IntToPtr(idCmd),// lpVerb
NULL, // lpParameters
NULL, // lpDirectory
SW_SHOWDEFAULT, // nShow
0, // dwHotKey
0, // hIcon
NULL, // lpTitle
(LPCWSTR)IntToPtr(idCmd),// lpVerbW
NULL, // lpParametersW
NULL, // lpDirectoryW
NULL, // lpTitleW
{ pt.x, pt.y }, // ptInvoke
};
if ((_dwFlags & HOSTF_CANRENAME) &&
StrCmpI(szBuf, TEXT("rename")) == 0)
{
_EditLabel(iItem);
}
else
{
ContextMenuInvokeItem(pitem, pcm, &ici, szBuf);
}
}
DestroyMenu(hmenu);
fSuccess = TRUE;
}
pcm->Release();
}
}
_DebugConsistencyCheck();
return fSuccess ? 0 : DefWindowProc(hwnd, uMsg, wParam, lParam);
}
void SFTBarHost::_EditLabel(int iItem)
{
_fAllowEditLabel = TRUE;
ListView_EditLabel(_hwndList, iItem);
_fAllowEditLabel = FALSE;
}
HRESULT SFTBarHost::ContextMenuInvokeItem(PaneItem *pitem, IContextMenu *pcm, CMINVOKECOMMANDINFOEX *pici, LPCTSTR pszVerb)
{
// Make sure none of our private menu items leaked through
ASSERT(PtrToLong(pici->lpVerb) >= 0);
return pcm->InvokeCommand(reinterpret_cast<LPCMINVOKECOMMANDINFO>(pici));
}
LRESULT SFTBarHost::_OnLVNItemActivate(LPNMITEMACTIVATE pnmia)
{
return _ActivateItem(pnmia->iItem, 0);
}
LRESULT SFTBarHost::_ActivateItem(int iItem, DWORD dwFlags)
{
// Activating a menu item indicates explicit user activity
Tray_UnlockStartPane();
PaneItem *pitem;
IShellFolder *psf;
LPCITEMIDLIST pidl;
DWORD dwCascadeFlags = 0;
if (dwFlags & AIF_KEYBOARD)
{
dwCascadeFlags = MPPF_KEYBOARD | MPPF_INITIALSELECT;
}
if (_OnCascade(iItem, dwCascadeFlags))
{
// We did the cascade thing; all finished!
}
else
if ((pitem = _GetItemFromLV(iItem)) &&
SUCCEEDED(_GetFolderAndPidl(pitem, &psf, &pidl)))
{
// See if the item is still valid.
// Do this only for SFGAO_FILESYSTEM objects because
// we can't be sure that other folders support SFGAO_VALIDATE,
// and besides, you can't resolve any other types of objects
// anyway...
DWORD dwAttr = SFGAO_FILESYSTEM | SFGAO_VALIDATE;
if (FAILED(psf->GetAttributesOf(1, &pidl, &dwAttr)) ||
(dwAttr & SFGAO_FILESYSTEM | SFGAO_VALIDATE) == SFGAO_FILESYSTEM ||
FAILED(_InvokeDefaultCommand(iItem, psf, pidl)))
{
// Object is bogus - offer to delete it
if ((_dwFlags & HOSTF_CANDELETE) && pitem->IsPinned())
{
_OfferDeleteBrokenItem(pitem, psf, pidl);
}
}
psf->Release();
}
return 0;
}
HRESULT SFTBarHost::_InvokeDefaultCommand(int iItem, IShellFolder *psf, LPCITEMIDLIST pidl)
{
HRESULT hr = SHInvokeDefaultCommand(GetShellWindow(), psf, pidl);
if (SUCCEEDED(hr))
{
if (_dwFlags & HOSTF_FIREUEMEVENTS)
{
_FireUEMPidlEvent(psf, pidl);
}
SMNMCOMMANDINVOKED ci;
ListView_GetItemRect(_hwndList, iItem, &ci.rcItem, LVIR_BOUNDS);
MapWindowRect(_hwndList, NULL, &ci.rcItem);
_SendNotify(_hwnd, SMN_COMMANDINVOKED, &ci.hdr);
}
return hr;
}
class OfferDelete
{
public:
LPTSTR _pszName;
LPITEMIDLIST _pidlFolder;
LPITEMIDLIST _pidlFull;
IStartMenuPin * _psmpin;
HWND _hwnd;
~OfferDelete()
{
SHFree(_pszName);
ILFree(_pidlFolder);
ILFree(_pidlFull);
}
BOOL _RepairBrokenItem();
void _ThreadProc();
static DWORD s_ThreadProc(LPVOID lpParameter)
{
OfferDelete *poffer = (OfferDelete *)lpParameter;
poffer->_ThreadProc();
delete poffer;
return 0;
}
};
BOOL OfferDelete::_RepairBrokenItem()
{
BOOL fSuccess = FALSE;
LPITEMIDLIST pidlNew;
HRESULT hr = _psmpin->Resolve(_hwnd, 0, _pidlFull, &pidlNew);
if (pidlNew)
{
ASSERT(hr == S_OK); // only the S_OK case should alloc a new pidl
// Update to reflect the new pidl
ILFree(_pidlFull);
_pidlFull = pidlNew;
// Re-invoke the default command; if it fails the second time,
// then I guess the Resolve didn't work after all.
IShellFolder *psf;
LPCITEMIDLIST pidlChild;
if (SUCCEEDED(SHBindToIDListParent(_pidlFull, IID_PPV_ARG(IShellFolder, &psf), &pidlChild)))
{
if (SUCCEEDED(SHInvokeDefaultCommand(_hwnd, psf, pidlChild)))
{
fSuccess = TRUE;
}
psf->Release();
}
}
return fSuccess;
}
void OfferDelete::_ThreadProc()
{
_hwnd = SHCreateWorkerWindow(NULL, NULL, 0, 0, NULL, NULL);
if (_hwnd)
{
if (SUCCEEDED(CoCreateInstance(CLSID_StartMenuPin, NULL, CLSCTX_INPROC_SERVER,
IID_PPV_ARG(IStartMenuPin, &_psmpin))))
{
//
// First try to repair it by invoking the shortcut tracking code.
// If that fails, then offer to delete.
if (!_RepairBrokenItem() &&
ShellMessageBox(_Module.GetResourceInstance(), NULL,
MAKEINTRESOURCE(IDS_SFTHOST_OFFERREMOVEITEM),
_pszName, MB_YESNO) == IDYES)
{
_psmpin->Modify(_pidlFull, NULL);
}
ATOMICRELEASE(_psmpin);
}
DestroyWindow(_hwnd);
}
}
void SFTBarHost::_OfferDeleteBrokenItem(PaneItem *pitem, IShellFolder *psf, LPCITEMIDLIST pidlChild)
{
//
// The offer is done on a separate thread because putting up modal
// UI while the Start Menu is open creates all sorts of weirdness.
// (The user might decide to switch to Classic Start Menu
// while the dialog is still up, and we get our infrastructure
// ripped out from underneath us and then USER faults inside
// MessageBox... Not good.)
//
OfferDelete *poffer = new OfferDelete;
if (poffer)
{
if ((poffer->_pszName = DisplayNameOfItem(pitem, psf, pidlChild, SHGDN_NORMAL)) != NULL &&
SUCCEEDED(SHGetIDListFromUnk(psf, &poffer->_pidlFolder)) &&
(poffer->_pidlFull = ILCombine(poffer->_pidlFolder, pidlChild)) != NULL &&
SHCreateThread(OfferDelete::s_ThreadProc, poffer, CTF_COINIT, NULL))
{
poffer = NULL; // thread took ownership
}
delete poffer;
}
}
BOOL ShowInfoTip()
{
// find out if infotips are on or off, from the registry settings
SHELLSTATE ss;
// force a refresh
SHGetSetSettings(&ss, 0, TRUE);
SHGetSetSettings(&ss, SSF_SHOWINFOTIP, FALSE);
return ss.fShowInfoTip;
}
// over-ridable method for getting the infotip on an item
void SFTBarHost::GetItemInfoTip(PaneItem *pitem, LPTSTR pszText, DWORD cch)
{
IShellFolder *psf;
LPCITEMIDLIST pidl;
if (pszText && cch)
{
*pszText = 0;
if (SUCCEEDED(_GetFolderAndPidl(pitem, &psf, &pidl)))
{
GetInfoTip(psf, pidl, pszText, cch);
}
psf->Release();
}
}
LRESULT SFTBarHost::_OnLVNGetInfoTip(LPNMLVGETINFOTIP plvn)
{
_DebugConsistencyCheck();
PaneItem *pitem;
if (ShowInfoTip() &&
(pitem = _GetItemFromLV(plvn->iItem)) &&
!pitem->IsCascade())
{
int cchName = (plvn->dwFlags & LVGIT_UNFOLDED) ? 0 : lstrlen(plvn->pszText);
if (cchName)
{
StrCatBuff(plvn->pszText, TEXT("\r\n"), plvn->cchTextMax);
cchName = lstrlen(plvn->pszText);
}
// If there is room in the buffer after we added CRLF, append the
// infotip text. We succeeded if there was nontrivial infotip text.
if (cchName < plvn->cchTextMax)
{
GetItemInfoTip(pitem, plvn->pszText + cchName, plvn->cchTextMax - cchName);
}
}
return 0;
}
LRESULT _SendNotify(HWND hwndFrom, UINT code, OPTIONAL NMHDR *pnm)
{
NMHDR nm;
if (pnm == NULL)
{
pnm = &nm;
}
pnm->hwndFrom = hwndFrom;
pnm->idFrom = GetDlgCtrlID(hwndFrom);
pnm->code = code;
return SendMessage(GetParent(hwndFrom), WM_NOTIFY, pnm->idFrom, (LPARAM)pnm);
}
//****************************************************************************
//
// Drag sourcing
//
// *** IDropSource::GiveFeedback ***
HRESULT SFTBarHost::GiveFeedback(DWORD dwEffect)
{
if (_fForceArrowCursor)
{
SetCursor(LoadCursor(NULL, IDC_ARROW));
return S_OK;
}
return DRAGDROP_S_USEDEFAULTCURSORS;
}
// *** IDropSource::QueryContinueDrag ***
HRESULT SFTBarHost::QueryContinueDrag(BOOL fEscapePressed, DWORD grfKeyState)
{
if (fEscapePressed ||
(grfKeyState & (MK_LBUTTON | MK_RBUTTON)) == (MK_LBUTTON | MK_RBUTTON))
{
return DRAGDROP_S_CANCEL;
}
if ((grfKeyState & (MK_LBUTTON | MK_RBUTTON)) == 0)
{
return DRAGDROP_S_DROP;
}
return S_OK;
}
LRESULT SFTBarHost::_OnLVNBeginDrag(LPNMLISTVIEW plv)
{
//If changes are restricted, don't allow drag and drop!
if(_AreChangesRestricted())
return 0;
_DebugConsistencyCheck();
ASSERT(_pdtoDragOut == NULL);
_pdtoDragOut = NULL;
PaneItem *pitem = _GetItemFromLV(plv->iItem);
ASSERT(pitem);
IDataObject *pdto;
if (pitem && SUCCEEDED(_GetUIObjectOfItem(pitem, IID_PPV_ARG(IDataObject, &pdto))))
{
POINT pt;
pt = plv->ptAction;
ClientToScreen(_hwndList, &pt);
if (_pdsh)
{
_pdsh->InitializeFromWindow(_hwndList, &pt, pdto);
}
CLIPFORMAT cfOFFSETS = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_SHELLIDLISTOFFSET);
POINT *apts = (POINT*)GlobalAlloc(GPTR, sizeof(POINT)*2);
if (NULL != apts)
{
POINT ptOrigin = {0};
POINT ptItem = {0};
ListView_GetOrigin(_hwndList, &ptOrigin);
apts[0].x = plv->ptAction.x + ptOrigin.x;
apts[0].y = plv->ptAction.y + ptOrigin.y;
ListView_GetItemPosition(_hwndList,plv->iItem,&ptItem);
apts[1].x = ptItem.x - apts[0].x;
apts[1].y = ptItem.y - apts[0].y;
HRESULT hr = DataObj_SetGlobal(pdto, cfOFFSETS, apts);
if (FAILED(hr))
{
GlobalFree((HGLOBAL)apts);
}
}
// We don't need to refcount _pdtoDragOut since its lifetime
// is the same as pdto.
_pdtoDragOut = pdto;
_iDragOut = plv->iItem;
_iPosDragOut = pitem->_iPos;
// Notice that DROPEFFECT_MOVE is explicitly forbidden.
// You cannot move things out of the control.
DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_COPY;
DoDragDrop(pdto, this, dwEffect, &dwEffect);
_pdtoDragOut = NULL;
pdto->Release();
}
return 0;
}
//
// Must perform validation of SFGAO_CANRENAME when the label edit begins
// because John Gray somehow can trick the listview into going into edit
// mode by clicking in the right magic place, so this is the only chance
// we get to reject things that aren't renamable...
//
LRESULT SFTBarHost::_OnLVNBeginLabelEdit(NMLVDISPINFO *plvdi)
{
LRESULT lres = 1;
PaneItem *pitem = _GetItemFromLVLParam(plvdi->item.lParam);
IShellFolder *psf;
LPCITEMIDLIST pidl;
if (_fAllowEditLabel &&
pitem && SUCCEEDED(_GetFolderAndPidl(pitem, &psf, &pidl)))
{
DWORD dwAttr = SFGAO_CANRENAME;
if (SUCCEEDED(psf->GetAttributesOf(1, &pidl, &dwAttr)) &&
(dwAttr & SFGAO_CANRENAME))
{
LPTSTR ptszName = _DisplayNameOf(psf, pidl,
SHGDN_INFOLDER | SHGDN_FOREDITING);
if (ptszName)
{
HWND hwndEdit = ListView_GetEditControl(_hwndList);
if (hwndEdit)
{
SetWindowText(hwndEdit, ptszName);
int cchLimit = MAX_PATH;
IItemNameLimits *pinl;
if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IItemNameLimits, &pinl))))
{
pinl->GetMaxLength(ptszName, &cchLimit);
pinl->Release();
}
Edit_LimitText(hwndEdit, cchLimit);
// use way-cool helper which pops up baloon tips if they enter an invalid folder....
SHLimitInputEdit(hwndEdit, psf);
// Block menu mode during editing so the user won't
// accidentally cancel out of rename mode just because
// they moved the mouse.
SMNMBOOL nmb;
nmb.f = TRUE;
_SendNotify(_hwnd, SMN_BLOCKMENUMODE, &nmb.hdr);
lres = 0;
}
SHFree(ptszName);
}
}
psf->Release();
}
return lres;
}
LRESULT SFTBarHost::_OnLVNEndLabelEdit(NMLVDISPINFO *plvdi)
{
// Unblock menu mode now that editing is over.
SMNMBOOL nmb;
nmb.f = FALSE;
_SendNotify(_hwnd, SMN_BLOCKMENUMODE, &nmb.hdr);
// If changing to NULL pointer, then user is cancelling
if (!plvdi->item.pszText)
return FALSE;
// Note: We allow the user to type blanks. Regfolder treats a blank
// name as "restore default name".
PathRemoveBlanks(plvdi->item.pszText);
PaneItem *pitem = _GetItemFromLVLParam(plvdi->item.lParam);
HRESULT hr = ContextMenuRenameItem(pitem, plvdi->item.pszText);
if (SUCCEEDED(hr))
{
LPTSTR ptszName = _DisplayNameOfItem(pitem, SHGDN_NORMAL);
if (ptszName)
{
ListView_SetItemText(_hwndList, plvdi->item.iItem, 0, ptszName);
_SendNotify(_hwnd, SMN_NEEDREPAINT, NULL);
}
}
else if (hr != HRESULT_FROM_WIN32(ERROR_CANCELLED))
{
_EditLabel(plvdi->item.iItem);
}
// Always return FALSE to prevent listview from changing the
// item text to what the user typed. If the rename succeeded,
// we manually set the name to the new name (which might not be
// the same as what the user typed).
return FALSE;
}
LRESULT SFTBarHost::_OnLVNKeyDown(LPNMLVKEYDOWN pkd)
{
// Plain F2 (no shift, ctrl or alt) = rename
if (pkd->wVKey == VK_F2 && GetKeyState(VK_SHIFT) >= 0 &&
GetKeyState(VK_CONTROL) >= 0 && GetKeyState(VK_MENU) >= 0 &&
(_dwFlags & HOSTF_CANRENAME))
{
int iItem = _GetLVCurSel();
if (iItem >= 0)
{
_EditLabel(iItem);
// cannot return TRUE because listview mistakenly thinks
// that all WM_KEYDOWNs lead to WM_CHARs (but this one doesn't)
}
}
return 0;
}
LRESULT SFTBarHost::_OnSMNGetMinSize(PSMNGETMINSIZE pgms)
{
// We need to synchronize here to get the proper size
if (_fBGTask && !HasDynamicContent())
{
// Wait for the enumeration to be done
while (TRUE)
{
MSG msg;
// Need to peek messages for all queues here or else WaitMessage will say
// that some messages are ready to be processed and we'll end up with an
// active loop
if (PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE))
{
if (PeekMessage(&msg, _hwnd, SFTBM_REPOPULATE, SFTBM_REPOPULATE, PM_REMOVE))
{
DispatchMessage(&msg);
break;
}
}
WaitMessage();
}
}
int cItems = _cPinnedDesired + _cNormalDesired;
int cSep = _cSep;
// if the repopulate hasn't happened yet, but we've got pinned items, we're going to have a separator
if (_cSep == 0 && _cPinnedDesired > 0)
cSep = 1;
int cy = (_cyTile * cItems) + (_cySepTile * cSep);
// add in theme margins
cy += _margins.cyTopHeight + _margins.cyBottomHeight;
// SPP_PROGLIST gets a bonus separator at the bottom
if (_iThemePart == SPP_PROGLIST)
{
cy += _cySep;
}
pgms->siz.cy = cy;
return 0;
}
LRESULT SFTBarHost::_OnSMNFindItem(PSMNDIALOGMESSAGE pdm)
{
LRESULT lres = _OnSMNFindItemWorker(pdm);
if (lres)
{
//
// If caller requested that the item also be selected, then do so.
//
if (pdm->flags & SMNDM_SELECT)
{
ListView_SetItemState(_hwndList, pdm->itemID,
LVIS_SELECTED | LVIS_FOCUSED,
LVIS_SELECTED | LVIS_FOCUSED);
if ((pdm->flags & SMNDM_FINDMASK) != SMNDM_HITTEST)
{
ListView_KeyboardSelected(_hwndList, pdm->itemID);
}
}
}
else
{
//
// If not found, then tell caller what our orientation is (vertical)
// and where the currently-selected item is.
//
pdm->flags |= SMNDM_VERTICAL;
int iItem = _GetLVCurSel();
RECT rc;
if (iItem >= 0 &&
ListView_GetItemRect(_hwndList, iItem, &rc, LVIR_BOUNDS))
{
pdm->pt.x = (rc.left + rc.right)/2;
pdm->pt.y = (rc.top + rc.bottom)/2;
}
else
{
pdm->pt.x = 0;
pdm->pt.y = 0;
}
}
return lres;
}
TCHAR SFTBarHost::GetItemAccelerator(PaneItem *pitem, int iItemStart)
{
TCHAR sz[2];
ListView_GetItemText(_hwndList, iItemStart, 0, sz, ARRAYSIZE(sz));
return CharUpperChar(sz[0]);
}
LRESULT SFTBarHost::_OnSMNFindItemWorker(PSMNDIALOGMESSAGE pdm)
{
LVFINDINFO lvfi;
LVHITTESTINFO lvhti;
switch (pdm->flags & SMNDM_FINDMASK)
{
case SMNDM_FINDFIRST:
L_SMNDM_FINDFIRST:
// Note: We can't just return item 0 because drag/drop pinning
// may have gotten the physical locations out of sync with the
// item numbers.
lvfi.vkDirection = VK_HOME;
lvfi.flags = LVFI_NEARESTXY;
pdm->itemID = ListView_FindItem(_hwndList, -1, &lvfi);
return pdm->itemID >= 0;
case SMNDM_FINDLAST:
// Note: We can't just return cItems-1 because drag/drop pinning
// may have gotten the physical locations out of sync with the
// item numbers.
lvfi.vkDirection = VK_END;
lvfi.flags = LVFI_NEARESTXY;
pdm->itemID = ListView_FindItem(_hwndList, -1, &lvfi);
return pdm->itemID >= 0;
case SMNDM_FINDNEAREST:
lvfi.pt = pdm->pt;
lvfi.vkDirection = VK_UP;
lvfi.flags = LVFI_NEARESTXY;
pdm->itemID = ListView_FindItem(_hwndList, -1, &lvfi);
return pdm->itemID >= 0;
case SMNDM_HITTEST:
lvhti.pt = pdm->pt;
pdm->itemID = ListView_HitTest(_hwndList, &lvhti);
return pdm->itemID >= 0;
case SMNDM_FINDFIRSTMATCH:
case SMNDM_FINDNEXTMATCH:
{
int iItemStart;
if ((pdm->flags & SMNDM_FINDMASK) == SMNDM_FINDFIRSTMATCH)
{
iItemStart = 0;
}
else
{
iItemStart = _GetLVCurSel() + 1;
}
TCHAR tch = CharUpperChar((TCHAR)pdm->pmsg->wParam);
int iItems = ListView_GetItemCount(_hwndList);
for (iItemStart; iItemStart < iItems; iItemStart++)
{
PaneItem *pitem = _GetItemFromLV(iItemStart);
if (GetItemAccelerator(pitem, iItemStart) == tch)
{
pdm->itemID = iItemStart;
return TRUE;
}
}
return FALSE;
}
break;
case SMNDM_FINDNEXTARROW:
if (pdm->pmsg->wParam == VK_UP)
{
pdm->itemID = ListView_GetNextItem(_hwndList, _GetLVCurSel(), LVNI_ABOVE);
return pdm->itemID >= 0;
}
if (pdm->pmsg->wParam == VK_DOWN)
{
// HACK! ListView_GetNextItem explicitly fails to find a "next item"
// if you tell it to start at -1 (no current item), so if there is no
// focus item, we have to change it to a SMNDM_FINDFIRST.
int iItem = _GetLVCurSel();
if (iItem == -1)
{
goto L_SMNDM_FINDFIRST;
}
pdm->itemID = ListView_GetNextItem(_hwndList, iItem, LVNI_BELOW);
return pdm->itemID >= 0;
}
if (pdm->flags & SMNDM_TRYCASCADE)
{
pdm->itemID = _GetLVCurSel();
return _OnCascade((int)pdm->itemID, MPPF_KEYBOARD | MPPF_INITIALSELECT);
}
return FALSE;
case SMNDM_INVOKECURRENTITEM:
{
int iItem = _GetLVCurSel();
if (iItem >= 0)
{
DWORD aif = 0;
if (pdm->flags & SMNDM_KEYBOARD)
{
aif |= AIF_KEYBOARD;
}
_ActivateItem(iItem, aif);
return TRUE;
}
}
return FALSE;
case SMNDM_OPENCASCADE:
{
DWORD mppf = 0;
if (pdm->flags & SMNDM_KEYBOARD)
{
mppf |= MPPF_KEYBOARD | MPPF_INITIALSELECT;
}
pdm->itemID = _GetLVCurSel();
return _OnCascade((int)pdm->itemID, mppf);
}
case SMNDM_FINDITEMID:
return TRUE;
default:
ASSERT(!"Unknown SMNDM command");
break;
}
return FALSE;
}
LRESULT SFTBarHost::_OnSMNDismiss()
{
if (_fNeedsRepopulate)
{
_RepopulateList();
}
return 0;
}
LRESULT SFTBarHost::_OnCascade(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
return _OnCascade((int)wParam, (DWORD)lParam);
}
BOOL SFTBarHost::_OnCascade(int iItem, DWORD dwFlags)
{
BOOL fSuccess = FALSE;
SMNTRACKSHELLMENU tsm;
tsm.dwFlags = dwFlags;
tsm.itemID = iItem;
if (iItem >= 0 &&
ListView_GetItemRect(_hwndList, iItem, &tsm.rcExclude, LVIR_BOUNDS))
{
PaneItem *pitem = _GetItemFromLV(iItem);
if (pitem && pitem->IsCascade())
{
if (SUCCEEDED(GetCascadeMenu(pitem, &tsm.psm)))
{
MapWindowRect(_hwndList, NULL, &tsm.rcExclude);
HWND hwnd = _hwnd;
_iCascading = iItem;
_SendNotify(_hwnd, SMN_TRACKSHELLMENU, &tsm.hdr);
tsm.psm->Release();
fSuccess = TRUE;
}
}
}
return fSuccess;
}
HRESULT SFTBarHost::QueryInterface(REFIID riid, void * *ppvOut)
{
static const QITAB qit[] = {
QITABENT(SFTBarHost, IDropTarget),
QITABENT(SFTBarHost, IDropSource),
QITABENT(SFTBarHost, IAccessible),
QITABENT(SFTBarHost, IDispatch), // IAccessible derives from IDispatch
{ 0 },
};
return QISearch(this, qit, riid, ppvOut);
}
ULONG SFTBarHost::AddRef()
{
return InterlockedIncrement(&_lRef);
}
ULONG SFTBarHost::Release()
{
ULONG cRef = InterlockedDecrement(&_lRef);
if (cRef)
return cRef;
delete this;
return 0;
}
void SFTBarHost::_SetDragOver(int iItem)
{
if (_iDragOver >= 0)
{
ListView_SetItemState(_hwndList, _iDragOver, 0, LVIS_DROPHILITED);
}
_iDragOver = iItem;
if (_iDragOver >= 0)
{
ListView_SetItemState(_hwndList, _iDragOver, LVIS_DROPHILITED, LVIS_DROPHILITED);
_tmDragOver = NonzeroGetTickCount();
}
else
{
_tmDragOver = 0;
}
}
void SFTBarHost::_ClearInnerDropTarget()
{
if (_pdtDragOver)
{
ASSERT(_iDragState == DRAGSTATE_ENTERED);
_pdtDragOver->DragLeave();
_pdtDragOver->Release();
_pdtDragOver = NULL;
DEBUG_CODE(_iDragState = DRAGSTATE_UNINITIALIZED);
}
_SetDragOver(-1);
}
HRESULT SFTBarHost::_TryInnerDropTarget(int iItem, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
HRESULT hr;
if (_iDragOver != iItem)
{
_ClearInnerDropTarget();
// Even if it fails, remember that we have this item so we don't
// query for the drop target again (and have it fail again).
_SetDragOver(iItem);
ASSERT(_pdtDragOver == NULL);
ASSERT(_iDragState == DRAGSTATE_UNINITIALIZED);
PaneItem *pitem = _GetItemFromLV(iItem);
if (pitem && pitem->IsDropTarget())
{
hr = _GetUIObjectOfItem(pitem, IID_PPV_ARG(IDropTarget, &_pdtDragOver));
if (SUCCEEDED(hr))
{
hr = _pdtDragOver->DragEnter(_pdtoDragIn, grfKeyState, ptl, pdwEffect);
if (SUCCEEDED(hr) && *pdwEffect)
{
DEBUG_CODE(_iDragState = DRAGSTATE_ENTERED);
}
else
{
DEBUG_CODE(_iDragState = DRAGSTATE_UNINITIALIZED);
ATOMICRELEASE(_pdtDragOver);
}
}
}
}
ASSERT(_iDragOver == iItem);
if (_pdtDragOver)
{
ASSERT(_iDragState == DRAGSTATE_ENTERED);
hr = _pdtDragOver->DragOver(grfKeyState, ptl, pdwEffect);
}
else
{
hr = E_FAIL; // No drop target
}
return hr;
}
void SFTBarHost::_PurgeDragDropData()
{
_SetInsertMarkPosition(-1);
_fForceArrowCursor = FALSE;
_ClearInnerDropTarget();
ATOMICRELEASE(_pdtoDragIn);
}
// *** IDropTarget::DragEnter ***
HRESULT SFTBarHost::DragEnter(IDataObject *pdto, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
if(_AreChangesRestricted())
{
*pdwEffect = DROPEFFECT_NONE;
return S_OK;
}
POINT pt = { ptl.x, ptl.y };
if (_pdth) {
_pdth->DragEnter(_hwnd, pdto, &pt, *pdwEffect);
}
return _DragEnter(pdto, grfKeyState, ptl, pdwEffect);
}
HRESULT SFTBarHost::_DragEnter(IDataObject *pdto, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
_PurgeDragDropData();
_fDragToSelf = SHIsSameObject(pdto, _pdtoDragOut);
_fInsertable = IsInsertable(pdto);
ASSERT(_pdtoDragIn == NULL);
_pdtoDragIn = pdto;
_pdtoDragIn->AddRef();
return DragOver(grfKeyState, ptl, pdwEffect);
}
// *** IDropTarget::DragOver ***
HRESULT SFTBarHost::DragOver(DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
if(_AreChangesRestricted())
{
*pdwEffect = DROPEFFECT_NONE;
return S_OK;
}
_DebugConsistencyCheck();
ASSERT(_pdtoDragIn);
POINT pt = { ptl.x, ptl.y };
if (_pdth) {
_pdth->DragOver(&pt, *pdwEffect);
}
_fForceArrowCursor = FALSE;
// Need to remember this because at the point of the drop, OLE gives
// us the keystate after the user releases the button, so we can't
// tell what kind of a drag operation the user performed!
_grfKeyStateLast = grfKeyState;
#ifdef DEBUG
if (_fDragToSelf)
{
ASSERT(_pdtoDragOut);
ASSERT(_iDragOut >= 0);
PaneItem *pitem = _GetItemFromLV(_iDragOut);
ASSERT(pitem && (pitem->_iPos == _iPosDragOut));
}
#endif
// Find the last item above the cursor position. This allows us
// to treat the entire blank space at the bottom as belonging to the
// last item, and separators end up belonging to the item immediately
// above them. Note that we don't bother testing item zero since
// he is always above everything (since he's the first item).
ScreenToClient(_hwndList, &pt);
POINT ptItem;
int cItems = ListView_GetItemCount(_hwndList);
int iItem;
for (iItem = cItems - 1; iItem >= 1; iItem--)
{
ListView_GetItemPosition(_hwndList, iItem, &ptItem);
if (ptItem.y <= pt.y)
{
break;
}
}
//
// We didn't bother checking item 0 because we knew his position
// (by treating him special, this also causes all negative coordinates
// to be treated as belonging to item zero also).
//
if (iItem <= 0)
{
ptItem.y = 0;
iItem = 0;
}
//
// Decide whether this is a drag-between or a drag-over...
//
// For computational purposes, we treat each tile as four
// equal-sized "units" tall. For each unit, we consider the
// possible actions in the order listed.
//
// +-----
// | 0 insert above, drop on, reject
// | ----
// | 1 drop on, reject
// | ----
// | 2 drop on, reject
// | ----
// | 3 insert below, drop on, reject
// +-----
//
// If the listview is empty, then treat as an
// insert before (imaginary) item zero; i.e., pin
// to top of the list.
//
UINT uUnit = 0;
if (_cyTile && cItems)
{
int dy = pt.y - ptItem.y;
// Peg out-of-bounds values to the nearest edge.
if (dy < 0) dy = 0;
if (dy >= _cyTile) dy = _cyTile - 1;
// Decide which unit we are in.
uUnit = 4 * dy / _cyTile;
ASSERT(uUnit < 4);
}
//
// Now determine the appropriate action depending on which unit
// we are in.
//
int iInsert = -1; // Assume not inserting
if (_fInsertable)
{
// Note! Spec says that if you are in the non-pinned part of
// the list, we draw the insert bar at the very bottom of
// the pinned area.
switch (uUnit)
{
case 0:
iInsert = min(iItem, _cPinned);
break;
case 3:
iInsert = min(iItem+1, _cPinned);
break;
}
}
//
// If inserting above or below isn't allowed, try dropping on.
//
if (iInsert < 0)
{
_SetInsertMarkPosition(-1); // Not inserting
// Up above, we let separators be hit-tested as if they
// belongs to the item above them. But that doesn't work for
// drops, so reject them now.
//
// Also reject attempts to drop on the nonexistent item zero,
// and don't let the user drop an item on itself.
if (InRange(pt.y, ptItem.y, ptItem.y + _cyTile - 1) &&
cItems &&
!(_fDragToSelf && _iDragOut == iItem) &&
SUCCEEDED(_TryInnerDropTarget(iItem, grfKeyState, ptl, pdwEffect)))
{
// Woo-hoo, happy joy!
}
else
{
// Note that we need to convert a failed drop into a DROPEFFECT_NONE
// rather than returning a flat-out error code, because if we return
// an error code, OLE will stop sending us drag/drop notifications!
*pdwEffect = DROPEFFECT_NONE;
}
// If the user is hovering over a cascadable item, then open it.
// First see if the user has hovered long enough...
if (_tmDragOver && (GetTickCount() - _tmDragOver) >= _GetCascadeHoverTime())
{
_tmDragOver = 0;
// Now see if it's cascadable
PaneItem *pitem = _GetItemFromLV(_iDragOver);
if (pitem && pitem->IsCascade())
{
// Must post this message because the cascading is modal
// and we have to return a result to OLE
PostMessage(_hwnd, SFTBM_CASCADE, _iDragOver, 0);
}
}
}
else
{
_ClearInnerDropTarget(); // Not dropping
if (_fDragToSelf)
{
// Even though we're going to return DROPEFFECT_LINK,
// tell the drag source (namely, ourselves) that we would
// much prefer a regular arrow cursor because this is
// a Move operation from the user's point of view.
_fForceArrowCursor = TRUE;
}
//
// If user is dropping to a place where nothing would change,
// then don't draw an insert mark.
//
if (IsInsertMarkPointless(iInsert))
{
_SetInsertMarkPosition(-1);
}
else
{
_SetInsertMarkPosition(iInsert);
}
// Sigh. MergedFolder (used by the merged Start Menu)
// won't let you create shortcuts, so we pretend that
// we're copying if the data object doesn't permit
// linking.
if (*pdwEffect & DROPEFFECT_LINK)
{
*pdwEffect = DROPEFFECT_LINK;
}
else
{
*pdwEffect = DROPEFFECT_COPY;
}
}
return S_OK;
}
// *** IDropTarget::DragLeave ***
HRESULT SFTBarHost::DragLeave()
{
if(_AreChangesRestricted())
{
return S_OK;
}
if (_pdth) {
_pdth->DragLeave();
}
_PurgeDragDropData();
return S_OK;
}
// *** IDropTarget::Drop ***
HRESULT SFTBarHost::Drop(IDataObject *pdto, DWORD grfKeyState, POINTL ptl, DWORD *pdwEffect)
{
if(_AreChangesRestricted())
{
*pdwEffect = DROPEFFECT_NONE;
return S_OK;
}
_DebugConsistencyCheck();
// Use the key state from the last DragOver call
grfKeyState = _grfKeyStateLast;
// Need to go through the whole _DragEnter thing again because who knows
// maybe the data object and coordinates of the drop are different from
// the ones we got in DragEnter/DragOver... We use _DragEnter, which
// bypasses the IDropTargetHelper::DragEnter.
//
_DragEnter(pdto, grfKeyState, ptl, pdwEffect);
POINT pt = { ptl.x, ptl.y };
if (_pdth) {
_pdth->Drop(pdto, &pt, *pdwEffect);
}
int iInsert = _iInsert;
_SetInsertMarkPosition(-1);
if (*pdwEffect)
{
ASSERT(_pdtoDragIn);
if (iInsert >= 0) // "add to pin" or "move"
{
BOOL fTriedMove = FALSE;
// First see if it was just a move of an existing pinned item
if (_fDragToSelf)
{
PaneItem *pitem = _GetItemFromLV(_iDragOut);
if (pitem)
{
if (pitem->IsPinned())
{
// Yup, it was a move - so move it.
if (SUCCEEDED(MovePinnedItem(pitem, iInsert)))
{
// We used to try to update all the item positions
// incrementally. This was a major pain in the neck.
//
// So now we just do a full refresh. Turns out that a
// full refresh is fast enough anyway.
//
PostMessage(_hwnd, SFTBM_REFRESH, TRUE, 0);
}
// We tried to move a pinned item (return TRUE even if
// we actually failed).
fTriedMove = TRUE;
}
}
}
if (!fTriedMove)
{
if (SUCCEEDED(InsertPinnedItem(_pdtoDragIn, iInsert)))
{
PostMessage(_hwnd, SFTBM_REFRESH, TRUE, 0);
}
}
}
else if (_pdtDragOver) // Not an insert, maybe it was a plain drop
{
ASSERT(_iDragState == DRAGSTATE_ENTERED);
_pdtDragOver->Drop(_pdtoDragIn, grfKeyState, ptl, pdwEffect);
}
}
_PurgeDragDropData();
_DebugConsistencyCheck();
return S_OK;
}
void SFTBarHost::_SetInsertMarkPosition(int iInsert)
{
if (_iInsert != iInsert)
{
_InvalidateInsertMark();
_iInsert = iInsert;
_InvalidateInsertMark();
}
}
BOOL SFTBarHost::_GetInsertMarkRect(LPRECT prc)
{
if (_iInsert >= 0)
{
GetClientRect(_hwndList, prc);
POINT pt;
_ComputeListViewItemPosition(_iInsert, &pt);
int iBottom = pt.y;
int cyEdge = GetSystemMetrics(SM_CYEDGE);
prc->top = iBottom - cyEdge;
prc->bottom = iBottom + cyEdge;
return TRUE;
}
return FALSE;
}
void SFTBarHost::_InvalidateInsertMark()
{
RECT rc;
if (_GetInsertMarkRect(&rc))
{
InvalidateRect(_hwndList, &rc, TRUE);
}
}
void SFTBarHost::_DrawInsertionMark(LPNMLVCUSTOMDRAW plvcd)
{
RECT rc;
if (_GetInsertMarkRect(&rc))
{
FillRect(plvcd->nmcd.hdc, &rc, GetSysColorBrush(COLOR_WINDOWTEXT));
}
}
void SFTBarHost::_DrawSeparator(HDC hdc, int x, int y)
{
RECT rc;
rc.left = x;
rc.top = y;
rc.right = rc.left + _cxTile;
rc.bottom = rc.top + _cySep;
if (!_hTheme)
{
DrawEdge(hdc, &rc, EDGE_ETCHED,BF_TOPLEFT);
}
else
{
DrawThemeBackground(_hTheme, hdc, _iThemePartSep, 0, &rc, 0);
}
}
void SFTBarHost::_DrawSeparators(LPNMLVCUSTOMDRAW plvcd)
{
POINT pt;
RECT rc;
for (int iSep = 0; iSep < _cSep; iSep++)
{
_ComputeListViewItemPosition(_rgiSep[iSep], &pt);
pt.y = pt.y - _cyTilePadding + (_cySepTile - _cySep + _cyTilePadding)/2;
_DrawSeparator(plvcd->nmcd.hdc, pt.x, pt.y);
}
// Also draw a bonus separator at the bottom of the list to separate
// the MFU list from the More Programs button.
if (_iThemePart == SPP_PROGLIST)
{
_ComputeListViewItemPosition(0, &pt);
GetClientRect(_hwndList, &rc);
rc.bottom -= _cySep;
_DrawSeparator(plvcd->nmcd.hdc, pt.x, rc.bottom);
}
}
//****************************************************************************
//
// Accessibility
//
PaneItem *SFTBarHost::_GetItemFromAccessibility(const VARIANT& varChild)
{
if (varChild.lVal)
{
return _GetItemFromLV(varChild.lVal - 1);
}
return NULL;
}
//
// The default accessibility object reports listview items as
// ROLE_SYSTEM_LISTITEM, but we know that we are really a menu.
//
// Our items are either ROLE_SYSTEM_MENUITEM or ROLE_SYSTEM_MENUPOPUP.
//
HRESULT SFTBarHost::get_accRole(VARIANT varChild, VARIANT *pvarRole)
{
HRESULT hr = _paccInner->get_accRole(varChild, pvarRole);
if (SUCCEEDED(hr) && V_VT(pvarRole) == VT_I4)
{
switch (V_I4(pvarRole))
{
case ROLE_SYSTEM_LIST:
V_I4(pvarRole) = ROLE_SYSTEM_MENUPOPUP;
break;
case ROLE_SYSTEM_LISTITEM:
V_I4(pvarRole) = ROLE_SYSTEM_MENUITEM;
break;
}
}
return hr;
}
HRESULT SFTBarHost::get_accState(VARIANT varChild, VARIANT *pvarState)
{
HRESULT hr = _paccInner->get_accState(varChild, pvarState);
if (SUCCEEDED(hr) && V_VT(pvarState) == VT_I4)
{
PaneItem *pitem = _GetItemFromAccessibility(varChild);
if (pitem && pitem->IsCascade())
{
V_I4(pvarState) |= STATE_SYSTEM_HASPOPUP;
}
}
return hr;
}
HRESULT SFTBarHost::get_accKeyboardShortcut(VARIANT varChild, BSTR *pszKeyboardShortcut)
{
if (varChild.lVal)
{
PaneItem *pitem = _GetItemFromAccessibility(varChild);
if (pitem)
{
return CreateAcceleratorBSTR(GetItemAccelerator(pitem, varChild.lVal - 1), pszKeyboardShortcut);
}
}
*pszKeyboardShortcut = NULL;
return E_NOT_APPLICABLE;
}
//
// Default action for cascading menus is Open/Close (depending on
// whether the item is already open); for regular items
// is Execute.
//
HRESULT SFTBarHost::get_accDefaultAction(VARIANT varChild, BSTR *pszDefAction)
{
*pszDefAction = NULL;
if (varChild.lVal)
{
PaneItem *pitem = _GetItemFromAccessibility(varChild);
if (pitem && pitem->IsCascade())
{
DWORD dwRole = varChild.lVal - 1 == _iCascading ? ACCSTR_CLOSE : ACCSTR_OPEN;
return GetRoleString(dwRole, pszDefAction);
}
return GetRoleString(ACCSTR_EXECUTE, pszDefAction);
}
return E_NOT_APPLICABLE;
}
HRESULT SFTBarHost::accDoDefaultAction(VARIANT varChild)
{
if (varChild.lVal)
{
PaneItem *pitem = _GetItemFromAccessibility(varChild);
if (pitem && pitem->IsCascade())
{
if (varChild.lVal - 1 == _iCascading)
{
_SendNotify(_hwnd, SMN_CANCELSHELLMENU);
return S_OK;
}
}
}
return CAccessible::accDoDefaultAction(varChild);
}
//****************************************************************************
//
// Debugging helpers
//
#ifdef FULL_DEBUG
void SFTBarHost::_DebugConsistencyCheck()
{
int i;
int citems;
if (_hwndList && !_fListUnstable)
{
//
// Check that the items in the listview are in their correct positions.
//
citems = ListView_GetItemCount(_hwndList);
for (i = 0; i < citems; i++)
{
PaneItem *pitem = _GetItemFromLV(i);
if (pitem)
{
// Make sure the item number and the iPos are in agreement
ASSERT(pitem->_iPos == _ItemNoToPos(i));
ASSERT(_PosToItemNo(pitem->_iPos) == i);
// Make sure the item is where it should be
POINT pt, ptShould;
_ComputeListViewItemPosition(pitem->_iPos, &ptShould);
ListView_GetItemPosition(_hwndList, i, &pt);
ASSERT(pt.x == ptShould.x);
ASSERT(pt.y == ptShould.y);
}
}
}
}
#endif
// iFile is the zero-based index of the file being requested
// or 0xFFFFFFFF if you don't care about any particular file
//
// puFiles receives the number of files in the HDROP
// or NULL if you don't care about the number of files
//
STDAPI_(HRESULT)
IDataObject_DragQueryFile(IDataObject *pdto, UINT iFile, LPTSTR pszBuf, UINT cch, UINT *puFiles)
{
static FORMATETC const feHdrop =
{ CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stgm;
HRESULT hr;
// Sigh. IDataObject::GetData has a bad prototype and says that
// the first parameter is a modifiable FORMATETC, even though it
// isn't.
hr = pdto->GetData(const_cast<FORMATETC*>(&feHdrop), &stgm);
if (SUCCEEDED(hr))
{
HDROP hdrop = reinterpret_cast<HDROP>(stgm.hGlobal);
if (puFiles)
{
*puFiles = DragQueryFile(hdrop, 0xFFFFFFFF, NULL, 0);
}
if (iFile != 0xFFFFFFFF)
{
hr = DragQueryFile(hdrop, iFile, pszBuf, cch) ? S_OK : E_FAIL;
}
ReleaseStgMedium(&stgm);
}
return hr;
}
/*
* If pidl has an alias, free the original pidl and return the alias.
* Otherwise, just return pidl unchanged.
*
* Expected usage is
*
* pidlTarget = ConvertToLogIL(pidlTarget);
*
*/
STDAPI_(LPITEMIDLIST) ConvertToLogIL(LPITEMIDLIST pidl)
{
LPITEMIDLIST pidlAlias = SHLogILFromFSIL(pidl);
if (pidlAlias)
{
ILFree(pidl);
return pidlAlias;
}
return pidl;
}
//****************************************************************************
//
STDAPI_(HFONT) LoadControlFont(HTHEME hTheme, int iPart, BOOL fUnderline, DWORD dwSizePercentage)
{
LOGFONT lf;
BOOL bSuccess;
if (hTheme)
{
bSuccess = SUCCEEDED(GetThemeFont(hTheme, NULL, iPart, 0, TMT_FONT, &lf));
}
else
{
bSuccess = SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, FALSE);
}
if (bSuccess)
{
// only apply size scaling factor in non-theme case, for themes it makes sense to specify the exact font in the theme
if (!hTheme && dwSizePercentage && dwSizePercentage != 100)
{
lf.lfHeight = (lf.lfHeight * (int)dwSizePercentage) / 100;
lf.lfWidth = 0; // get the closest based on aspect ratio
}
if (fUnderline)
{
lf.lfUnderline = TRUE;
}
return CreateFontIndirect(&lf);
}
return NULL;
}