CRegistryFolder Class Reference

#include <regfolder.h>

Inheritance diagram for CRegistryFolder:

Collaboration diagram for CRegistryFolder:

Public Member Functions
	CRegistryFolder ()
virtual	~CRegistryFolder ()
STDMETHOD()	EnumObjects (HWND hwndOwner, SHCONTF grfFlags, IEnumIDList **ppenumIDList) override
STDMETHOD()	GetDefaultColumnState (UINT iColumn, SHCOLSTATEF *pcsFlags) override
STDMETHOD()	GetDetailsEx (LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv) override
STDMETHOD()	GetDetailsOf (LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *psd) override
STDMETHOD()	MapColumnToSCID (UINT iColumn, SHCOLUMNID *pscid) override
STDMETHOD()	Initialize (PCIDLIST_ABSOLUTE pidl) override
STDMETHOD()	Initialize (PCIDLIST_ABSOLUTE pidl, PCWSTR ntPath, HKEY hRoot)
Public Member Functions inherited from CCommonFolder< CRegistryFolder, RegPidlEntry, CRegistryFolderExtractIcon >
	CCommonFolder ()
virtual	~CCommonFolder ()
STDMETHODIMP	ParseDisplayName (HWND hwndOwner, LPBC pbcReserved, LPOLESTR lpszDisplayName, ULONG *pchEaten, LPITEMIDLIST *ppidl, ULONG *pdwAttributes) override
STDMETHOD()	EnumObjects (HWND hwndOwner, SHCONTF grfFlags, IEnumIDList **ppenumIDList) PURE
STDMETHODIMP	BindToObject (LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, void **ppvOut) override
STDMETHODIMP	BindToStorage (LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, void **ppvObj) override
STDMETHODIMP	CompareIDs (LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2) override
STDMETHODIMP	CreateViewObject (HWND hwndOwner, REFIID riid, void **ppvOut) override
STDMETHODIMP	GetAttributesOf (UINT cidl, PCUITEMID_CHILD_ARRAY apidl, SFGAOF *rgfInOut) override
STDMETHODIMP	GetUIObjectOf (HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT *prgfInOut, void **ppvOut) override
STDMETHODIMP	GetDisplayNameOf (LPCITEMIDLIST pidl, SHGDNF uFlags, STRRET *lpName) override
STDMETHODIMP	SetNameOf (HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR lpszName, SHGDNF uFlags, LPITEMIDLIST *ppidlOut) override
STDMETHODIMP	GetDefaultSearchGUID (GUID *lpguid) override
STDMETHODIMP	EnumSearches (IEnumExtraSearch **ppenum) override
STDMETHODIMP	GetDefaultColumn (DWORD dwReserved, ULONG *pSort, ULONG *pDisplay) override
STDMETHOD()	GetDefaultColumnState (UINT iColumn, SHCOLSTATEF *pcsFlags) PURE
STDMETHOD()	GetDetailsEx (LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv) PURE
STDMETHOD()	GetDetailsOf (LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *psd) PURE
STDMETHOD()	MapColumnToSCID (UINT iColumn, SHCOLUMNID *pscid) PURE
STDMETHODIMP	GetClassID (CLSID *lpClassId) override
STDMETHODIMP	Initialize (PCIDLIST_ABSOLUTE pidl) override
STDMETHODIMP	GetCurFolder (PIDLIST_ABSOLUTE *pidl) override
Public Member Functions inherited from ATL::CComObjectRootEx< CComMultiThreadModelNoCS >
	~CComObjectRootEx ()
ULONG	InternalAddRef ()
ULONG	InternalRelease ()
void	Lock ()
void	Unlock ()
HRESULT	_AtlInitialConstruct ()
Public Member Functions inherited from ATL::CComObjectRootBase
	CComObjectRootBase ()
	~CComObjectRootBase ()
void	SetVoid (void *)
HRESULT	_AtlFinalConstruct ()
HRESULT	FinalConstruct ()
void	InternalFinalConstructAddRef ()
void	InternalFinalConstructRelease ()
void	FinalRelease ()
Public Member Functions inherited from IShellFolder2
HRESULT	GetDefaultSearchGUID ([out] GUID *lpguid)
HRESULT	EnumSearches ([out] IEnumExtraSearch **ppenum)
HRESULT	GetDefaultColumn ([in] DWORD dwReserved, [out] ULONG *pSort, [out] ULONG *pDisplay)
HRESULT	GetDefaultColumnState ([in] UINT iColumn, [out] SHCOLSTATEF *pcsFlags)
HRESULT	GetDetailsEx ([in] PCUITEMID_CHILD pidl, [in] const SHCOLUMNID *pscid, [out] VARIANT *pv)
HRESULT	GetDetailsOf ([in] PCUITEMID_CHILD pidl, [in] UINT iColumn, [out] SHELLDETAILS *psd)
HRESULT	MapColumnToSCID ([in] UINT iColumn, [in] SHCOLUMNID *pscid)
Public Member Functions inherited from IShellFolder
HRESULT	ParseDisplayName ([in] HWND hwndOwner, [in] LPBC pbcReserved, [in, string] LPOLESTR lpszDisplayName, [out] ULONG *pchEaten, [out] PIDLIST_RELATIVE *ppidl, [in, out, unique] ULONG *pdwAttributes)
HRESULT	EnumObjects ([in] HWND hwndOwner, [in] SHCONTF grfFlags, [out] IEnumIDList **ppenumIDList)
HRESULT	BindToObject ([in] PCUIDLIST_RELATIVE pidl, [in] LPBC pbcReserved, [in] REFIID riid, [out, iid_is(riid)] void **ppvOut)
HRESULT	BindToStorage ([in] PCUIDLIST_RELATIVE pidl, [in] LPBC pbcReserved, [in] REFIID riid, [out, iid_is(riid)] void **ppvObj)
HRESULT	CompareIDs ([in] LPARAM lParam, [in] PCUIDLIST_RELATIVE pidl1, [in] PCUIDLIST_RELATIVE pidl2)
HRESULT	CreateViewObject ([in] HWND hwndOwner, [in] REFIID riid, [out, iid_is(riid)] void **ppvOut)
HRESULT	GetAttributesOf ([in] UINT cidl, [in, size_is(cidl)] PCUITEMID_CHILD_ARRAY apidl, [in, out] SFGAOF *rgfInOut)
HRESULT	GetUIObjectOf ([in] HWND hwndOwner, [in] UINT cidl, [in, size_is(cidl)] PCUITEMID_CHILD_ARRAY apidl, [in] REFIID riid, [in, out, unique] UINT *prgfInOut, [out, iid_is(riid)] void **ppvOut)
HRESULT	GetDisplayNameOf ([in] PCUITEMID_CHILD pidl, [in] SHGDNF uFlags, [out] STRRET *lpName)
HRESULT	SetNameOf ([in] HWND hwnd, [in] PCUITEMID_CHILD pidl, [in, string] LPCOLESTR lpszName, [in] SHGDNF uFlags, [out] PITEMID_CHILD *ppidlOut)
Public Member Functions inherited from IUnknown
HRESULT	QueryInterface ([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG	AddRef ()
ULONG	Release ()
HRESULT	GetCurFolder ([out] PIDLIST_ABSOLUTE *ppidl)
HRESULT	Initialize ([in] PCIDLIST_ABSOLUTE pidl)
HRESULT	GetClassID ([out] CLSID *pClassID)

Protected Member Functions
STDMETHOD()	InternalBindToObject (PWSTR path, const RegPidlEntry *info, LPITEMIDLIST first, LPCITEMIDLIST rest, LPITEMIDLIST fullPidl, LPBC pbcReserved, IShellFolder **ppsfChild) override
STDMETHOD()	CompareIDs (LPARAM lParam, const RegPidlEntry *first, const RegPidlEntry *second)
	STDMETHOD_ (ULONG, ConvertAttributes)(const RegPidlEntry *entry
	STDMETHOD_ (BOOL, IsFolder)(const RegPidlEntry *info)
virtual HRESULT	GetInfoFromPidl (LPCITEMIDLIST pcidl, const RegPidlEntry **pentry)
HRESULT	FormatValueData (DWORD contentType, PVOID td, DWORD contentsLength, PCWSTR *strContents)
HRESULT	FormatContentsForDisplay (const RegPidlEntry *info, HKEY rootKey, LPCWSTR ntPath, PCWSTR *strContents)
Protected Member Functions inherited from CCommonFolder< CRegistryFolder, RegPidlEntry, CRegistryFolderExtractIcon >
STDMETHOD()	InternalBindToObject (PWSTR path, const RegPidlEntry *info, LPITEMIDLIST first, LPCITEMIDLIST rest, LPITEMIDLIST fullPidl, LPBC pbcReserved, IShellFolder **ppsfChild) PURE
STDMETHOD()	ResolveSymLink (const RegPidlEntry *info, LPITEMIDLIST *fullPidl)
STDMETHOD()	CompareIDs (LPARAM lParam, const RegPidlEntry *first, const RegPidlEntry *second) PURE
STDMETHOD()	CompareName (LPARAM lParam, const RegPidlEntry *first, const RegPidlEntry *second)
	STDMETHOD_ (ULONG, ConvertAttributes)(const RegPidlEntry *entry
	STDMETHOD_ (BOOL, IsFolder)(LPCITEMIDLIST pcidl)
	STDMETHOD_ (BOOL, IsFolder)(const RegPidlEntry *info) PURE
	STDMETHOD_ (BOOL, IsSymLink)(LPCITEMIDLIST pcidl)
	STDMETHOD_ (BOOL, IsSymLink)(const RegPidlEntry *info)
virtual HRESULT	GetInfoFromPidl (LPCITEMIDLIST pcidl, const RegPidlEntry **pentry) PURE

Protected Attributes
PULONG	inMask
Protected Attributes inherited from CCommonFolder< CRegistryFolder, RegPidlEntry, CRegistryFolderExtractIcon >
WCHAR	m_NtPath [MAX_PATH]
LPITEMIDLIST	m_shellPidl
PULONG inMask	PURE

Private Attributes
HKEY	m_hRoot

Additional Inherited Members
Public Types inherited from IShellFolder2
typedef struct IShellFolder2::SHCOLUMNID *	LPSHCOLUMNID
typedef const SHCOLUMNID *	LPCSHCOLUMNID
Public Types inherited from IShellFolder
enum	tagSHGDN {   SHGDN_NORMAL = 0 , SHGDN_INFOLDER = 1 , SHGDN_FOREDITING = 0x1000 , SHGDN_INCLUDE_NONFILESYS = 0x2000 ,   SHGDN_FORADDRESSBAR = 0x4000 , SHGDN_FORPARSING = 0x8000 }
enum	tagSHCONTF {   SHCONTF_FOLDERS = 32 , SHCONTF_NONFOLDERS = 64 , SHCONTF_INCLUDEHIDDEN = 128 , SHCONTF_INIT_ON_FIRST_NEXT = 256 ,   SHCONTF_NETPRINTERSRCH = 512 , SHCONTF_SHAREABLE = 1024 , SHCONTF_STORAGE = 2048 , SHCONTF_NAVIGATION_ENUM = 0x01000 ,   SHCONTF_FASTITEMS = 0x02000 , SHCONTF_FLATLIST = 0x04000 , SHCONTF_ENABLE_ASYNC = 0x08000 , SHCONTF_INCLUDESUPERHIDDEN = 0x10000 }
typedef IShellFolder *	LPSHELLFOLDER
typedef enum IShellFolder::tagSHGDN	SHGNO
typedef DWORD	SHGDNF
typedef DWORD	SHCONTF
typedef ULONG	SFGAOF
Public Types inherited from IUnknown
typedef IUnknown *	LPUNKNOWN
Public Types inherited from IPersistFolder2
typedef IPersistFolder2 *	LPPERSISTFOLDER2
Public Types inherited from IPersistFolder
typedef IPersistFolder *	LPPERSISTFOLDER
Public Types inherited from IPersist
typedef IPersist *	LPPERSIST
Static Public Member Functions inherited from CCommonFolder< CRegistryFolder, RegPidlEntry, CRegistryFolderExtractIcon >
static HRESULT CALLBACK	DefCtxMenuCallback (IShellFolder *, HWND, IDataObject *, UINT uMsg, WPARAM, LPARAM)
Static Public Member Functions inherited from ATL::CComObjectRootBase
static void WINAPI	ObjectMain (bool)
static const struct _ATL_CATMAP_ENTRY *	GetCategoryMap ()
static HRESULT WINAPI	InternalQueryInterface (void *pThis, const _ATL_INTMAP_ENTRY *pEntries, REFIID iid, void **ppvObject)
Public Attributes inherited from ATL::CComObjectRootBase
LONG	m_dwRef

Detailed Description

Definition at line 49 of file regfolder.h.

Constructor & Destructor Documentation

CRegistryFolder()

CRegistryFolder::CRegistryFolder

(

)

Definition at line 100 of file regfolder.cpp.

{
}

~CRegistryFolder()

CRegistryFolder::~CRegistryFolder ( )

virtual

Definition at line 104 of file regfolder.cpp.

{
}

Member Function Documentation

CompareIDs()

HRESULT CRegistryFolder::CompareIDs ( LPARAM  lParam, const RegPidlEntry *  first, const RegPidlEntry *  second  )

protected

Definition at line 387 of file regfolder.cpp.

{
    HRESULT hr;
 
    DWORD sortMode = lParam & 0xFFFF0000;
    DWORD column = lParam & 0x0000FFFF;
 
    if (sortMode == SHCIDS_ALLFIELDS)
    {
        if (column != 0)
            return E_INVALIDARG;
 
        int minsize = min(first->cb, second->cb);
        hr = MAKE_COMPARE_HRESULT(memcmp(second, first, minsize));
        if (hr != S_EQUAL)
            return hr;
 
        return MAKE_COMPARE_HRESULT(second->cb - first->cb);
    }
 
    switch (column)
    {
        case REGISTRY_COLUMN_NAME:
            return CompareName(lParam, first, second);
 
        case REGISTRY_COLUMN_TYPE:
        {
            if (first->entryType != second->entryType)
                return MAKE_COMPARE_HRESULT(second->entryType - first->entryType);
 
            if (first->entryType == REG_ENTRY_KEY)
            {
                if (first->contentsLength == 0 || second->contentsLength == 0)
                    return (first->contentsLength == 0) ? S_GREATERTHAN : S_LESSTHAN;
 
                PWSTR firstKey = (PWSTR)(((PBYTE)first) + FIELD_OFFSET(RegPidlEntry, entryName) + first->entryNameLength + sizeof(WCHAR));
                PWSTR secondKey = (PWSTR)(((PBYTE)second) + FIELD_OFFSET(RegPidlEntry, entryName) + second->entryNameLength + sizeof(WCHAR));
                return MAKE_COMPARE_HRESULT(lstrcmpW(firstKey, secondKey));
            }
 
            return CompareName(lParam, first, second);
        }
 
        case REGISTRY_COLUMN_VALUE:
        {
            PCWSTR firstContent, secondContent;
 
            if (FAILED_UNEXPECTEDLY(FormatContentsForDisplay(first, m_hRoot, m_NtPath, &firstContent)))
                return E_INVALIDARG;
 
            if (FAILED_UNEXPECTEDLY(FormatContentsForDisplay(second, m_hRoot, m_NtPath, &secondContent)))
                return E_INVALIDARG;
 
            hr = MAKE_COMPARE_HRESULT(lstrcmpW(firstContent, secondContent));
 
            CoTaskMemFree((LPVOID)firstContent);
            CoTaskMemFree((LPVOID)secondContent);
 
            return hr;
        }
    }
 
    DbgPrint("Unsupported sorting mode.\n");
    return E_INVALIDARG;
}

EnumObjects()

HRESULT STDMETHODCALLTYPE CRegistryFolder::EnumObjects ( HWND  hwndOwner, SHCONTF  grfFlags, IEnumIDList **  ppenumIDList  )

override

Implements IShellFolder.

Definition at line 109 of file regfolder.cpp.

{
    if (m_NtPath[0] == 0 && m_hRoot == NULL)
    {
        return GetEnumRegistryRoot(ppenumIDList);
    }
    else
    {
        return GetEnumRegistryKey(m_NtPath, m_hRoot, ppenumIDList);
    }
}

FormatContentsForDisplay()

HRESULT CRegistryFolder::FormatContentsForDisplay ( const RegPidlEntry *  info, HKEY  rootKey, LPCWSTR  ntPath, PCWSTR *  strContents  )

protected

Definition at line 601 of file regfolder.cpp.

{
    PVOID td = (((PBYTE)info) + FIELD_OFFSET(RegPidlEntry, entryName) + info->entryNameLength + sizeof(WCHAR));
 
    if (info->entryType == REG_ENTRY_VALUE_WITH_CONTENT)
    {
        if (info->contentsLength > 0)
        {
            return FormatValueData(info->contentType, td, info->contentsLength, strContents);
        }
    }
    else if (info->entryType == REG_ENTRY_VALUE)
    {
        PVOID valueData;
        DWORD valueLength;
        HRESULT hr = ReadRegistryValue(rootKey, ntPath, info->entryName, &valueData, &valueLength);
        if (FAILED_UNEXPECTEDLY(hr))
        {
            PCWSTR strEmpty = L"(Error reading value)";
            DWORD bufferLength = (wcslen(strEmpty) + 1) * sizeof(WCHAR);
            PWSTR strValue = (PWSTR)CoTaskMemAlloc(bufferLength);
            StringCbCopyW(strValue, bufferLength, strEmpty);
            *strContents = strValue;
            return S_OK;
        }
 
        if (valueLength > 0)
        {
            hr = FormatValueData(info->contentType, valueData, valueLength, strContents);
 
            CoTaskMemFree(valueData);
 
            return hr;
        }
    }
    else
    {
        PCWSTR strEmpty = L"";
        DWORD bufferLength = (wcslen(strEmpty) + 1) * sizeof(WCHAR);
        PWSTR strValue = (PWSTR)CoTaskMemAlloc(bufferLength);
        StringCbCopyW(strValue, bufferLength, strEmpty);
        *strContents = strValue;
        return S_OK;
    }
 
    PCWSTR strEmpty = L"(Empty)";
    DWORD bufferLength = (wcslen(strEmpty) + 1) * sizeof(WCHAR);
    PWSTR strValue = (PWSTR)CoTaskMemAlloc(bufferLength);
    StringCbCopyW(strValue, bufferLength, strEmpty);
    *strContents = strValue;
    return S_OK;
}

Referenced by CompareIDs(), GetDetailsEx(), and GetDetailsOf().

FormatValueData()

HRESULT CRegistryFolder::FormatValueData ( DWORD  contentType, PVOID  td, DWORD  contentsLength, PCWSTR *  strContents  )

protected

Definition at line 495 of file regfolder.cpp.

{
    switch (contentType)
    {
        case REG_NONE:
        {
            PCWSTR strTodo = L"";
            DWORD bufferLength = (wcslen(strTodo) + 1) * sizeof(WCHAR);
            PWSTR strValue = (PWSTR)CoTaskMemAlloc(bufferLength);
            StringCbCopyW(strValue, bufferLength, strTodo);
            *strContents = strValue;
            return S_OK;
        }
 
        case REG_SZ:
        case REG_EXPAND_SZ:
        {
            PWSTR strValue = (PWSTR)CoTaskMemAlloc(contentsLength + sizeof(WCHAR));
            StringCbCopyNW(strValue, contentsLength + sizeof(WCHAR), (LPCWSTR)td, contentsLength);
            *strContents = strValue;
            return S_OK;
        }
 
        case REG_MULTI_SZ:
        {
            PCWSTR separator = L" "; // To match regedit
            size_t sepChars = wcslen(separator);
            int strings = 0;
            int stringChars = 0;
 
            PCWSTR strData = (PCWSTR)td;
            while (*strData)
            {
                size_t len = wcslen(strData);
                stringChars += len;
                strData += len + 1; // Skips null-terminator
                strings++;
            }
 
            int cch = stringChars + (strings - 1) * sepChars + 1;
 
            PWSTR strValue = (PWSTR)CoTaskMemAlloc(cch * sizeof(WCHAR));
 
            strValue[0] = 0;
 
            strData = (PCWSTR)td;
            while (*strData)
            {
                StrCatW(strValue, strData);
                strData += wcslen(strData) + 1;
                if (*strData)
                    StrCatW(strValue, separator);
            }
 
            *strContents = strValue;
            return S_OK;
        }
 
        case REG_DWORD:
        {
            DWORD bufferLength = 64 * sizeof(WCHAR);
            PWSTR strValue = (PWSTR)CoTaskMemAlloc(bufferLength);
            StringCbPrintfW(strValue, bufferLength, L"0x%08x (%d)",
                *(DWORD*)td, *(DWORD*)td);
            *strContents = strValue;
            return S_OK;
        }
 
        case REG_QWORD:
        {
            DWORD bufferLength = 64 * sizeof(WCHAR);
            PWSTR strValue = (PWSTR)CoTaskMemAlloc(bufferLength);
            StringCbPrintfW(strValue, bufferLength, L"0x%016llx (%lld)",
                *(LARGE_INTEGER*)td, ((LARGE_INTEGER*)td)->QuadPart);
            *strContents = strValue;
            return S_OK;
        }
 
        case REG_BINARY:
        {
            DWORD bufferLength = (contentsLength * 3 + 1) * sizeof(WCHAR);
            PWSTR strValue = (PWSTR)CoTaskMemAlloc(bufferLength);
            PWSTR strTemp = strValue;
            PBYTE data = (PBYTE)td;
            for (DWORD i = 0; i < contentsLength; i++)
            {
                StringCbPrintfW(strTemp, bufferLength, L"%02x ", data[i]);
                strTemp += 3;
                bufferLength -= 3;
            }
            *strContents = strValue;
            return S_OK;
        }
 
        default:
        {
            PCWSTR strFormat = L"<Unimplemented value type %d>";
            DWORD bufferLength = (wcslen(strFormat) + 15) * sizeof(WCHAR);
            PWSTR strValue = (PWSTR)CoTaskMemAlloc(bufferLength);
            StringCbPrintfW(strValue, bufferLength, strFormat, contentType);
            *strContents = strValue;
            return S_OK;
        }
    }
}

Referenced by FormatContentsForDisplay().

GetDefaultColumnState()

HRESULT STDMETHODCALLTYPE CRegistryFolder::GetDefaultColumnState ( UINT  iColumn, SHCOLSTATEF *  pcsFlags  )

override

Implements IShellFolder2.

Definition at line 159 of file regfolder.cpp.

{
    switch (iColumn)
    {
        case REGISTRY_COLUMN_NAME:
            *pcsFlags = SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT;
            return S_OK;
 
        case REGISTRY_COLUMN_TYPE:
            *pcsFlags = SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT;
            return S_OK;
 
        case REGISTRY_COLUMN_VALUE:
            *pcsFlags = SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT | SHCOLSTATE_SLOW;
            return S_OK;
    }
 
    return E_INVALIDARG;
}

GetDetailsEx()

HRESULT STDMETHODCALLTYPE CRegistryFolder::GetDetailsEx ( LPCITEMIDLIST  pidl, const SHCOLUMNID *  pscid, VARIANT *  pv  )

override

Definition at line 181 of file regfolder.cpp.

{
    const RegPidlEntry * info;
 
    TRACE("GetDetailsEx\n");
 
    if (pidl)
    {
        HRESULT hr = GetInfoFromPidl(pidl, &info);
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
 
        static const GUID storage = PSGUID_STORAGE;
        if (IsEqualGUID(pscid->fmtid, storage))
        {
            if (pscid->pid == PID_STG_NAME)
            {
                if (info->entryNameLength > 0)
                {
                    return MakeVariantString(pv, info->entryName);
                }
                return  MakeVariantString(pv, L"(Default)");
            }
            else if (pscid->pid == PID_STG_STORAGETYPE)
            {
                if (info->entryType == REG_ENTRY_ROOT)
                {
                    return MakeVariantString(pv, L"Key");
                }
 
                if (info->entryType == REG_ENTRY_KEY)
                {
                    if (info->contentsLength > 0)
                    {
                        PWSTR td = (PWSTR)(((PBYTE)info) + FIELD_OFFSET(RegPidlEntry, entryName) + info->entryNameLength + sizeof(WCHAR));
 
                        return MakeVariantString(pv, td);
                    }
                    return MakeVariantString(pv, L"Key");
                }
 
                return MakeVariantString(pv, RegistryTypeNames[info->contentType]);
            }
            else if (pscid->pid == PID_STG_CONTENTS)
            {
                PCWSTR strValueContents;
 
                hr = FormatContentsForDisplay(info, m_hRoot, m_NtPath, &strValueContents);
                if (FAILED_UNEXPECTEDLY(hr))
                    return hr;
 
                if (hr == S_FALSE)
                {
                    V_VT(pv) = VT_EMPTY;
                    return S_OK;
                }
 
                hr = MakeVariantString(pv, strValueContents);
 
                CoTaskMemFree((PVOID)strValueContents);
 
                return hr;
 
            }
        }
    }
 
    return E_INVALIDARG;
}

GetDetailsOf()

HRESULT STDMETHODCALLTYPE CRegistryFolder::GetDetailsOf ( LPCITEMIDLIST  pidl, UINT  iColumn, SHELLDETAILS *  psd  )

override

Definition at line 254 of file regfolder.cpp.

{
    const RegPidlEntry * info;
 
    TRACE("GetDetailsOf\n");
 
    if (pidl)
    {
        HRESULT hr = GetInfoFromPidl(pidl, &info);
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
 
        switch (iColumn)
        {
            case REGISTRY_COLUMN_NAME:
            {
                psd->fmt = LVCFMT_LEFT;
 
                if (info->entryNameLength > 0)
                {
                    return MakeStrRetFromString(info->entryName, info->entryNameLength, &(psd->str));
                }
                return MakeStrRetFromString(L"(Default)", &(psd->str));
            }
 
            case REGISTRY_COLUMN_TYPE:
            {
                psd->fmt = LVCFMT_LEFT;
 
                if (info->entryType == REG_ENTRY_ROOT)
                {
                    return MakeStrRetFromString(L"Key", &(psd->str));
                }
 
                if (info->entryType == REG_ENTRY_KEY)
                {
                    if (info->contentsLength > 0)
                    {
                        PWSTR td = (PWSTR)(((PBYTE)info) + FIELD_OFFSET(RegPidlEntry, entryName) + info->entryNameLength + sizeof(WCHAR));
 
                        return MakeStrRetFromString(td, info->contentsLength, &(psd->str));
                    }
 
                    return MakeStrRetFromString(L"Key", &(psd->str));
                }
 
                return MakeStrRetFromString(RegistryTypeNames[info->contentType], &(psd->str));
            }
 
            case REGISTRY_COLUMN_VALUE:
            {
                psd->fmt = LVCFMT_LEFT;
 
                PCWSTR strValueContents;
 
                hr = FormatContentsForDisplay(info, m_hRoot, m_NtPath, &strValueContents);
                if (FAILED_UNEXPECTEDLY(hr))
                    return hr;
 
                if (hr == S_FALSE)
                {
                    return MakeStrRetFromString(L"(Empty)", &(psd->str));
                }
 
                hr = MakeStrRetFromString(strValueContents, &(psd->str));
 
                CoTaskMemFree((PVOID)strValueContents);
 
                return hr;
            }
        }
    }
    else
    {
        switch (iColumn)
        {
            case REGISTRY_COLUMN_NAME:
                psd->fmt = LVCFMT_LEFT;
                psd->cxChar = 30;
 
                // TODO: Make localizable
                MakeStrRetFromString(L"Object Name", &(psd->str));
                return S_OK;
 
            case REGISTRY_COLUMN_TYPE:
                psd->fmt = LVCFMT_LEFT;
                psd->cxChar = 20;
 
                // TODO: Make localizable
                MakeStrRetFromString(L"Content Type", &(psd->str));
                return S_OK;
 
            case REGISTRY_COLUMN_VALUE:
                psd->fmt = LVCFMT_LEFT;
                psd->cxChar = 20;
 
                // TODO: Make localizable
                MakeStrRetFromString(L"Value", &(psd->str));
                return S_OK;
        }
    }
 
    return E_INVALIDARG;
}

GetInfoFromPidl()

HRESULT CRegistryFolder::GetInfoFromPidl ( LPCITEMIDLIST  pcidl, const RegPidlEntry **  pentry  )

protectedvirtual

Reimplemented from CCommonFolder< CRegistryFolder, RegPidlEntry, CRegistryFolderExtractIcon >.

Definition at line 470 of file regfolder.cpp.

{
    if (!pcidl)
    {
        DbgPrint("PCIDL is NULL\n");
        return E_INVALIDARG;
    }
 
    RegPidlEntry * entry = (RegPidlEntry*) &(pcidl->mkid);
    if (entry->cb < sizeof(RegPidlEntry))
    {
        DbgPrint("PCIDL too small %l (required %l)\n", entry->cb, sizeof(RegPidlEntry));
        return E_INVALIDARG;
    }
 
    if (entry->magic != REGISTRY_PIDL_MAGIC)
    {
        DbgPrint("PCIDL magic mismatch %04x (expected %04x)\n", entry->magic, REGISTRY_PIDL_MAGIC);
        return E_INVALIDARG;
    }
 
    *pentry = entry;
    return S_OK;
}

Referenced by GetDetailsEx(), and GetDetailsOf().

Initialize() [1/2]

HRESULT STDMETHODCALLTYPE CRegistryFolder::Initialize ( PCIDLIST_ABSOLUTE  pidl )

override

Implements IPersistFolder.

Definition at line 141 of file regfolder.cpp.

{
    m_shellPidl = ILClone(pidl);
    m_hRoot = NULL;
 
    StringCbCopyW(m_NtPath, sizeof(m_NtPath), L"");
    return S_OK;
}

Initialize() [2/2]

HRESULT STDMETHODCALLTYPE CRegistryFolder::Initialize	(	PCIDLIST_ABSOLUTE	pidl,
		PCWSTR	ntPath,
		HKEY	hRoot
	)

Definition at line 150 of file regfolder.cpp.

{
    m_shellPidl = ILClone(pidl);
    m_hRoot = hRoot;
 
    StringCbCopyW(m_NtPath, sizeof(m_NtPath), ntPath);
    return S_OK;
}

InternalBindToObject()

HRESULT STDMETHODCALLTYPE CRegistryFolder::InternalBindToObject ( PWSTR  path, const RegPidlEntry *  info, LPITEMIDLIST  first, LPCITEMIDLIST  rest, LPITEMIDLIST  fullPidl, LPBC  pbcReserved, IShellFolder **  ppsfChild  )

overrideprotected

Definition at line 124 of file regfolder.cpp.

{
    if (wcslen(m_NtPath) == 0 && m_hRoot == NULL)
    {
        return ShellObjectCreatorInit<CRegistryFolder>(fullPidl, L"", info->rootKey, IID_PPV_ARG(IShellFolder, ppsfChild));
    }
 
    return ShellObjectCreatorInit<CRegistryFolder>(fullPidl, path, m_hRoot, IID_PPV_ARG(IShellFolder, ppsfChild));
}

MapColumnToSCID()

HRESULT STDMETHODCALLTYPE CRegistryFolder::MapColumnToSCID ( UINT  iColumn, SHCOLUMNID *  pscid  )

override

Implements IShellFolder2.

Definition at line 362 of file regfolder.cpp.

{
    static const GUID storage = PSGUID_STORAGE;
    switch (iColumn)
    {
        case REGISTRY_COLUMN_NAME:
            pscid->fmtid = storage;
            pscid->pid = PID_STG_NAME;
            return S_OK;
 
        case REGISTRY_COLUMN_TYPE:
            pscid->fmtid = storage;
            pscid->pid = PID_STG_STORAGETYPE;
            return S_OK;
 
        case REGISTRY_COLUMN_VALUE:
            pscid->fmtid = storage;
            pscid->pid = PID_STG_CONTENTS;
            return S_OK;
    }
    return E_INVALIDARG;
}

STDMETHOD_() [1/2]

CRegistryFolder::STDMETHOD_ ( BOOL  , IsFolder    ) const

protected

STDMETHOD_() [2/2]

CRegistryFolder::STDMETHOD_ ( ULONG  , ConvertAttributes    ) const

protected

Member Data Documentation

inMask

PULONG CRegistryFolder::inMask

protected

Definition at line 104 of file regfolder.h.

m_hRoot

HKEY CRegistryFolder::m_hRoot

private

Definition at line 53 of file regfolder.h.

Referenced by CompareIDs(), EnumObjects(), GetDetailsEx(), GetDetailsOf(), Initialize(), and InternalBindToObject().

---

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

• dll/shellext/ntobjshex/regfolder.h
• dll/shellext/ntobjshex/regfolder.cpp