ModernSettingsShellFolder.cpp

// Open-Shell Modern Settings shell folder
// Provides folder that contains all modern settings
//
// To open the folder press Win+R and type:
// shell:::{82E749ED-B971-4550-BAF7-06AA2BF7E836}

// Based on Explorer Data Provider Sample (https://docs.microsoft.com/en-us/windows/win32/shell/samples-explorerdataprovider)

#include"stdafx.h"
#include"ModernSettings.h"
#include"ModernSettingsShellFolder.h"
#include"ResourceHelper.h"
#include<propkey.h>
#include<strsafe.h>
#include<Uxtheme.h>

structColumnDescription
{
constwchar_t* name;
 PROPERTYKEY key;
};

staticconst ColumnDescription g_columnDescriptions[] =
{
 {L"Name", PKEY_ItemNameDisplay},
 {L"Keywords", PKEY_Keywords},
 {L"Filename", PKEY_FileName},
};

#defineMAGIC'SMSO'

#pragma pack(1)
structFVITEMID
{
 USHORT cb;
 DWORD magic;
 WORD size;
wchar_t data[1];
};
#pragma pack()

staticconst FVITEMID* PidlToItem(LPCITEMIDLIST pidl)
{
if (pidl)
 {
auto item = (const FVITEMID*)pidl;
if (item->cb && item->magic == MAGIC)
return item;
 }

returnnullptr;
}

ModernSettings::Setting GetModernSetting(LPCITEMIDLIST pidl)
{
auto item = PidlToItem(pidl);
if (item)
 {
auto settings = GetModernSettings();
if (settings)
return settings->get({ item->data, item->size / sizeof(wchar_t) });
 }

return {};
}

STDAPI StringToStrRet(PCWSTR pszName, STRRET* pStrRet)
{
 pStrRet->uType = STRRET_WSTR;
returnSHStrDup(pszName, &pStrRet->pOleStr);
}

// CModernSettingsShellFolderEnumIDList

classATL_NO_VTABLE CModernSettingsShellFolderEnumIDList :
 public CComObjectRoot,
 public IEnumIDList
{
public:
BEGIN_COM_MAP(CModernSettingsShellFolderEnumIDList)
COM_INTERFACE_ENTRY(IEnumIDList)
END_COM_MAP()

// IEnumIDList
 IFACEMETHODIMP Next(ULONG celt, PITEMID_CHILD* rgelt, ULONG* pceltFetched)
 {
 ULONG celtFetched = 0;

 HRESULT hr = (pceltFetched || celt <= 1) ? S_OK : E_INVALIDARG;
if (SUCCEEDED(hr))
 {
 ULONG i = 0;
while (SUCCEEDED(hr) && i < celt && m_item < m_items.size())
 {
 hr = m_parent->CreateChildID(m_items[m_item], &rgelt[i]);
if (SUCCEEDED(hr))
 {
 celtFetched++;
 i++;
 }

 m_item++;
 }
 }

if (pceltFetched)
 *pceltFetched = celtFetched;

return (celtFetched == celt) ? S_OK : S_FALSE;
 }
 IFACEMETHODIMP Skip(DWORD celt)
 {
 m_item += celt;
return S_OK;
 }
 IFACEMETHODIMP Reset()
 {
 m_item = 0;
return S_OK;
 }
 IFACEMETHODIMP Clone(IEnumIDList** ppenum)
 {
// this method is rarely used and it's acceptable to not implement it.
 *ppenum = NULL;
return E_NOTIMPL;
 }

voidInitialize(CModernSettingsShellFolder* parent)
 {
 m_parent = parent;

 m_settings = GetModernSettings();
if (m_settings)
 m_items = m_settings->enumerate();
 }

private:
 CComPtr<CModernSettingsShellFolder> m_parent;
 std::shared_ptr<ModernSettings> m_settings;
 std::vector<std::wstring_view> m_items;
 DWORD m_item = 0;
};

// Extract icon

staticvoidBitmapDataToStraightAlpha(void* bits, UINT width, UINT height)
{
 RGBQUAD* data = (RGBQUAD*)bits;
for (UINT y = 0; y < height; y++)
 {
for (UINT x = 0; x < width; x++)
 {
auto alpha = data->rgbReserved;
if (alpha)
 {
 data->rgbBlue = (BYTE)((DWORD)data->rgbBlue * 255 / alpha);
 data->rgbGreen = (BYTE)((DWORD)data->rgbGreen * 255 / alpha);
 data->rgbRed = (BYTE)((DWORD)data->rgbRed * 255 / alpha);
 }
 data++;
 }
 }
}

HICON IconFromGlyph(UINT glyph, UINT size)
{
 ICONINFO info{};

 info.fIcon = TRUE;
 info.hbmMask = CreateBitmap(size, size, 1, 1, nullptr);

 BITMAPINFO bi{};
 bi.bmiHeader.biSize = sizeof(bi.bmiHeader);
 bi.bmiHeader.biWidth = size;
 bi.bmiHeader.biHeight = -((LONG)size);
 bi.bmiHeader.biPlanes = 1;
 bi.bmiHeader.biBitCount = 32;

void* bits = nullptr;
 info.hbmColor = CreateDIBSection(nullptr, &bi, 0, &bits, nullptr, 0);

 HDC dc = CreateCompatibleDC(nullptr);
SelectObject(dc, info.hbmColor);

 HFONT font = CreateFontW(size, 0, 0, 0, 400, 0, 0, 0, 1, 0, 0, 0, 0, IsWin11() ? L"Segoe Fluent Icons" : L"Segoe MDL2 Assets");
SelectObject(dc, font);

 RECT rc{};
 rc.right = size;
 rc.bottom = size;

auto theme = OpenThemeData(nullptr, L"CompositedWindow::Window");
 DTTOPTS opts{};
 opts.dwSize = sizeof(opts);
 opts.dwFlags = DTT_TEXTCOLOR | DTT_COMPOSITED;
 opts.crText = 0x00FFFFFF;
DrawThemeTextEx(theme, dc, 0, 0, (LPCWSTR)&glyph, 1, DT_CENTER | DT_VCENTER | DT_SINGLELINE, &rc, &opts);
CloseThemeData(theme);

DeleteObject(font);
DeleteDC(dc);

BitmapDataToStraightAlpha(bits, size, size);

 HICON retval = CreateIconIndirect(&info);

DeleteObject(info.hbmColor);
DeleteObject(info.hbmMask);

return retval;
}

classATL_NO_VTABLE GlyphExtractIcon :
 public CComObjectRoot,
 public IExtractIconW
{
public:

BEGIN_COM_MAP(GlyphExtractIcon)
COM_INTERFACE_ENTRY(IExtractIconW)
END_COM_MAP()

voidSetGlyph(USHORT glyph)
 {
 m_glyph = glyph;
 }

// IExtractIconW methods
 IFACEMETHODIMP GetIconLocation(UINT uFlags, _Out_writes_(cchMax) PWSTR pszIconFile, UINT cchMax, _Out_ int* piIndex, _Out_ UINT* pwFlags)
 {
StringCchCopy(pszIconFile, cchMax, L"OpenShell-ModernSettingIcon");
 *piIndex = m_glyph;
 *pwFlags = GIL_NOTFILENAME;
return S_OK;
 }
 IFACEMETHODIMP Extract(_In_ PCWSTR pszFile, UINT nIconIndex, _Out_opt_ HICON* phiconLarge, _Out_opt_ HICON* phiconSmall, UINT nIconSize)
 {
if (phiconLarge)
 *phiconLarge = IconFromGlyph(nIconIndex, LOWORD(nIconSize));
if (phiconSmall)
 *phiconSmall = IconFromGlyph(nIconIndex, HIWORD(nIconSize));
return S_OK;
 }

private:
 USHORT m_glyph = 0;
};


// CModernSettingsShellFolder

// IShellFolder methods

// Translates a display name into an item identifier list.
HRESULT CModernSettingsShellFolder::ParseDisplayName(HWND hwnd, IBindCtx* pbc, PWSTR pszName, ULONG* pchEaten, PIDLIST_RELATIVE* ppidl, ULONG* pdwAttributes)
{
return E_INVALIDARG;
}

// Allows a client to determine the contents of a folder by
// creating an item identifier enumeration object and returning
// its IEnumIDList interface. The methods supported by that
// interface can then be used to enumerate the folder's contents.
HRESULT CModernSettingsShellFolder::EnumObjects(HWND /* hwnd */, DWORD grfFlags, IEnumIDList** ppenumIDList)
{
 CComObject<CModernSettingsShellFolderEnumIDList>* enumIdList;
auto hr = CComObject<CModernSettingsShellFolderEnumIDList>::CreateInstance(&enumIdList);
if (SUCCEEDED(hr))
 {
 enumIdList->Initialize(this);
 hr = enumIdList->QueryInterface(IID_PPV_ARGS(ppenumIDList));
 }

return hr;
}

// Factory for handlers for the specified item.
HRESULT CModernSettingsShellFolder::BindToObject(PCUIDLIST_RELATIVE pidl, IBindCtx* pbc, REFIID riid, void** ppv)
{
return E_NOINTERFACE;
}

HRESULT CModernSettingsShellFolder::BindToStorage(PCUIDLIST_RELATIVE pidl, IBindCtx* pbc, REFIID riid, void** ppv)
{
returnBindToObject(pidl, pbc, riid, ppv);
}

// Called to determine the equivalence and/or sort order of two idlists.
HRESULT CModernSettingsShellFolder::CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
{
 UINT column = LOWORD(lParam);
returnMAKE_HRESULT(SEVERITY_SUCCESS, 0, (USHORT)(StrCmp(GetColumnDisplayName(pidl1, column).data(), GetColumnDisplayName(pidl2, column).data())));
}

// Called by the Shell to create the View Object and return it.
HRESULT CModernSettingsShellFolder::CreateViewObject(HWND hwnd, REFIID riid, void** ppv)
{
 HRESULT hr = E_NOINTERFACE;
 *ppv = NULL;

if (riid == IID_IShellView)
 {
 SFV_CREATE csfv = { sizeof(csfv), 0 };
 hr = QueryInterface(IID_PPV_ARGS(&csfv.pshf));
if (SUCCEEDED(hr))
 {
 hr = SHCreateShellFolderView(&csfv, (IShellView**)ppv);
 csfv.pshf->Release();
 }
 }

return hr;
}

// Retrieves the attributes of one or more file objects or subfolders.
HRESULT CModernSettingsShellFolder::GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, ULONG* rgfInOut)
{
 *rgfInOut &= SFGAO_CANLINK;
return S_OK;
}

// Retrieves an OLE interface that can be used to carry out
// actions on the specified file objects or folders.
HRESULT CModernSettingsShellFolder::GetUIObjectOf(HWND hwnd, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT* /* prgfInOut */, void** ppv)
{
 HRESULT hr = E_NOINTERFACE;
 *ppv = nullptr;

if (riid == IID_IContextMenu)
 {
// The default context menu will call back for IQueryAssociations to determine the
// file associations with which to populate the menu.
const DEFCONTEXTMENU dcm = { hwnd, nullptr, m_pidl, static_cast<IShellFolder2*>(this), cidl, apidl, nullptr, 0, nullptr };
 hr = SHCreateDefaultContextMenu(&dcm, riid, ppv);
 }
elseif (riid == IID_IExtractIconW)
 {
 hr = E_INVALIDARG;

auto s = GetModernSetting(*apidl);
if (s)
 {
if (!s.icon.empty())
 {
 CComPtr<IDefaultExtractIconInit> pdxi;
 hr = SHCreateDefaultExtractIcon(IID_PPV_ARGS(&pdxi));
if (SUCCEEDED(hr))
 {
 WCHAR icon_path[MAX_PATH];

StringCchCopy(icon_path, _countof(icon_path), s.icon.data());
auto location = PathParseIconLocation(icon_path);

 hr = pdxi->SetNormalIcon(icon_path, location);
if (SUCCEEDED(hr))
 hr = pdxi->QueryInterface(riid, ppv);
 }
 }
else
 {
auto glyph = !s.glyph.empty() ? s.glyph.front() : 0xe115;

 CComObject<GlyphExtractIcon>* extract;
 hr = CComObject<GlyphExtractIcon>::CreateInstance(&extract);
if (SUCCEEDED(hr))
 {
 extract->SetGlyph(glyph);
 hr = extract->QueryInterface(riid, ppv);
 }
 }
 }
 }
elseif (riid == IID_IDataObject)
 {
 hr = SHCreateDataObject(m_pidl, cidl, apidl, nullptr, riid, ppv);
 }
elseif (riid == IID_IQueryAssociations)
 {
 WCHAR szFolderViewImplClassID[64];
 hr = StringFromGUID2(CLSID_ModernSettingsShellFolder, szFolderViewImplClassID, ARRAYSIZE(szFolderViewImplClassID));
if (SUCCEEDED(hr))
 {
const ASSOCIATIONELEMENT assocItem = { ASSOCCLASS_CLSID_STR, nullptr, szFolderViewImplClassID };
 hr = AssocCreateForClasses(&assocItem, 1, riid, ppv);
 }
 }

return hr;
}

// Retrieves the display name for the specified file object or subfolder.
HRESULT CModernSettingsShellFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, SHGDNF shgdnFlags, STRRET* pName)
{
auto setting = GetModernSetting(pidl);
if (!setting)
return E_INVALIDARG;

 HRESULT hr = S_OK;

if (shgdnFlags & SHGDN_FORPARSING)
 {
if (shgdnFlags & SHGDN_INFOLDER)
 {
// This form of the display name needs to be handled by ParseDisplayName.
 hr = StringToStrRet(setting.fileName.data(), pName);
 }
else
 {
 WCHAR szDisplayName[MAX_PATH];
 CComString pszThisFolder;
 hr = SHGetNameFromIDList(m_pidl, (shgdnFlags & SHGDN_FORADDRESSBAR) ? SIGDN_DESKTOPABSOLUTEEDITING : SIGDN_DESKTOPABSOLUTEPARSING, &pszThisFolder);
if (SUCCEEDED(hr))
 {
StringCchCopy(szDisplayName, ARRAYSIZE(szDisplayName), pszThisFolder);
StringCchCat(szDisplayName, ARRAYSIZE(szDisplayName), L"\\");
StringCchCat(szDisplayName, ARRAYSIZE(szDisplayName), setting.fileName.data());

 hr = StringToStrRet(szDisplayName, pName);
 }
 }
 }
else
 {
 hr = StringToStrRet(setting.description.data(), pName);
 }

return hr;
}

// Sets the display name of a file object or subfolder, changing the item identifier in the process.
HRESULT CModernSettingsShellFolder::SetNameOf(HWND /* hwnd */, PCUITEMID_CHILD /* pidl */, PCWSTR /* pszName */, DWORD /* uFlags */, PITEMID_CHILD* ppidlOut)
{
 *ppidlOut = NULL;
return E_NOTIMPL;
}

// IShellFolder2 methods

// Requests the GUID of the default search object for the folder.
HRESULT CModernSettingsShellFolder::GetDefaultSearchGUID(GUID* /* pguid */)
{
return E_NOTIMPL;
}

HRESULT CModernSettingsShellFolder::EnumSearches(IEnumExtraSearch** ppEnum)
{
 *ppEnum = NULL;
return E_NOINTERFACE;
}

// Retrieves the default sorting and display column (indices from GetDetailsOf).
HRESULT CModernSettingsShellFolder::GetDefaultColumn(DWORD /* dwRes */, ULONG* pSort, ULONG* pDisplay)
{
 *pSort = 0;
 *pDisplay = 0;
return S_OK;
}

// Retrieves the default state for a specified column.
HRESULT CModernSettingsShellFolder::GetDefaultColumnState(UINT iColumn, SHCOLSTATEF* pcsFlags)
{
if (iColumn < _countof(g_columnDescriptions))
 {
 *pcsFlags = SHCOLSTATE_ONBYDEFAULT | SHCOLSTATE_TYPE_STR;
return S_OK;
 }

return E_INVALIDARG;
}

// Retrieves detailed information, identified by a property set ID (FMTID) and property ID (PID), on an item in a Shell folder.
HRESULT CModernSettingsShellFolder::GetDetailsEx(PCUITEMID_CHILD pidl, const PROPERTYKEY* pkey, VARIANT* pv)
{
for (constauto& desc : g_columnDescriptions)
 {
if (IsEqualPropertyKey(*pkey, desc.key))
 {
auto str = GetColumnDisplayName(pidl, (UINT)std::distance(g_columnDescriptions, &desc));

 pv->vt = VT_BSTR;
 pv->bstrVal = SysAllocString(str.data());
return pv->bstrVal ? S_OK : E_OUTOFMEMORY;
 }
 }

return S_OK;
}

// Retrieves detailed information, identified by a column index, on an item in a Shell folder.
HRESULT CModernSettingsShellFolder::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS* pDetails)
{
 pDetails->cxChar = 24;

if (!pidl)
 {
// No item means we're returning information about the column itself.

if (iColumn >= _countof(g_columnDescriptions))
 {
// GetDetailsOf is called with increasing column indices until failure.
return E_FAIL;
 }

 pDetails->fmt = LVCFMT_LEFT;
returnStringToStrRet(g_columnDescriptions[iColumn].name, &pDetails->str);
 }

auto str = GetColumnDisplayName(pidl, iColumn);
returnStringToStrRet(str.data(), &pDetails->str);
}

// Converts a column name to the appropriate property set ID (FMTID) and property ID (PID).
HRESULT CModernSettingsShellFolder::MapColumnToSCID(UINT iColumn, PROPERTYKEY* pkey)
{
if (iColumn < _countof(g_columnDescriptions))
 {
 *pkey = g_columnDescriptions[iColumn].key;
return S_OK;
 }

return E_FAIL;
}

// IPersist method
HRESULT CModernSettingsShellFolder::GetClassID(CLSID* pClassID)
{
 *pClassID = CLSID_ModernSettingsShellFolder;
return S_OK;
}

// IPersistFolder method
HRESULT CModernSettingsShellFolder::Initialize(PCIDLIST_ABSOLUTE pidl)
{
 m_pidl = pidl;
return m_pidl ? S_OK : E_FAIL;
}

// IPersistFolder2 methods
// Retrieves the PIDLIST_ABSOLUTE for the folder object.
HRESULT CModernSettingsShellFolder::GetCurFolder(PIDLIST_ABSOLUTE* ppidl)
{
 *ppidl = NULL;
 HRESULT hr = m_pidl ? S_OK : E_FAIL;
if (SUCCEEDED(hr))
 {
 *ppidl = ILCloneFull(m_pidl);
 hr = *ppidl ? S_OK : E_OUTOFMEMORY;
 }
return hr;
}

HRESULT CModernSettingsShellFolder::CreateChildID(const std::wstring_view& fileName, PITEMID_CHILD* ppidl)
{
auto size = fileName.size() * sizeof(wchar_t);

// Sizeof an object plus the next cb plus the characters in the string.
 UINT nIDSize = sizeof(FVITEMID) + sizeof(USHORT) + (WORD)size;

// Allocate and zero the memory.
 FVITEMID* lpMyObj = (FVITEMID*)CoTaskMemAlloc(nIDSize);

 HRESULT hr = lpMyObj ? S_OK : E_OUTOFMEMORY;
if (SUCCEEDED(hr))
 {
ZeroMemory(lpMyObj, nIDSize);
 lpMyObj->cb = static_cast<short>(nIDSize - sizeof(lpMyObj->cb));
 lpMyObj->magic = MAGIC;
 lpMyObj->size = (WORD)size;
memcpy(lpMyObj->data, fileName.data(), size);

 *ppidl = (PITEMID_CHILD)lpMyObj;
 }

return hr;
}

std::wstring_view CModernSettingsShellFolder::GetColumnDisplayName(PCUITEMID_CHILD pidl, UINT iColumn)
{
auto setting = GetModernSetting(pidl);
if (setting)
 {
switch (iColumn)
 {
case0:
return setting.description;
case1:
return setting.keywords;
case2:
return setting.fileName;
 }
 }

return {};
}