CRegFolder Class Reference

Inheritance diagram for CRegFolder:

Collaboration diagram for CRegFolder:

Public Member Functions
	CRegFolder ()
	~CRegFolder ()
HRESULT WINAPI	Initialize (PREGFOLDERINITDATA pInit, LPCITEMIDLIST pidlRoot)
const REQUIREDREGITEM *	IsRequiredItem (LPCITEMIDLIST pidl) const
STDMETHOD()	ParseDisplayName (HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName, ULONG *pchEaten, PIDLIST_RELATIVE *ppidl, ULONG *pdwAttributes) override
STDMETHOD()	EnumObjects (HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList) override
STDMETHOD()	BindToObject (PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) override
STDMETHOD()	BindToStorage (PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut) override
STDMETHOD()	CompareIDs (LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2) override
STDMETHOD()	CreateViewObject (HWND hwndOwner, REFIID riid, LPVOID *ppvOut) override
STDMETHOD()	GetAttributesOf (UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut) override
STDMETHOD()	GetUIObjectOf (HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT *prgfInOut, LPVOID *ppvOut) override
STDMETHOD()	GetDisplayNameOf (PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet) override
STDMETHOD()	SetNameOf (HWND hwndOwner, PCUITEMID_CHILD pidl, LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut) override
STDMETHOD()	GetDefaultSearchGUID (GUID *pguid) override
STDMETHOD()	EnumSearches (IEnumExtraSearch **ppenum) override
STDMETHOD()	GetDefaultColumn (DWORD dwRes, ULONG *pSort, ULONG *pDisplay) override
STDMETHOD()	GetDefaultColumnState (UINT iColumn, DWORD *pcsFlags) override
STDMETHOD()	GetDetailsEx (PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv) override
STDMETHOD()	GetDetailsOf (PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd) override
STDMETHOD()	MapColumnToSCID (UINT column, SHCOLUMNID *pscid) 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 ()
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 ()
Public Member Functions inherited from CRegFolderInfo
void	InitializeFolderInfo (const REGFOLDERINFO *pInfo)
const CLSID *	IsRegItem (LPCITEMIDLIST pidl) const
LPITEMIDLIST	CreateItem (size_t i) const
LPCWSTR	GetParsingPath () const
UINT	GetCLSIDOffset () const
PIDLTYPE	GetPidlType () const
UINT	GetRequiredItemsCount () const
const REQUIREDREGITEM &	GetAt (size_t i) const

Private Member Functions
HRESULT	GetGuidItemAttributes (LPCITEMIDLIST pidl, LPDWORD pdwAttributes)
BOOL	_IsInNameSpace (_In_ LPCITEMIDLIST pidl)

Private Attributes
IShellFolder *	m_pOuterFolder
CComHeapPtr< ITEMIDLIST >	m_pidlRoot

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
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
Public Attributes inherited from CRegFolderInfo
const REGFOLDERINFO *	m_pInfo

Detailed Description

Definition at line 308 of file CRegFolder.cpp.

Constructor & Destructor Documentation

CRegFolder()

CRegFolder::CRegFolder

(

)

Definition at line 368 of file CRegFolder.cpp.

{
}

~CRegFolder()

CRegFolder::~CRegFolder

(

)

Definition at line 372 of file CRegFolder.cpp.

{
}

Member Function Documentation

_IsInNameSpace()

BOOL CRegFolder::_IsInNameSpace ( _In_ LPCITEMIDLIST  pidl )

private

Definition at line 410 of file CRegFolder.cpp.

{
    CLSID clsid = *_ILGetGUIDPointer(pidl);
    if (IsEqualGUID(clsid, CLSID_Printers))
        return TRUE;
    if (IsEqualGUID(clsid, CLSID_ConnectionFolder))
        return TRUE;
    FIXME("Check registry\n");
    return TRUE;
}

Referenced by ParseDisplayName().

BindToObject()

HRESULT WINAPI CRegFolder::BindToObject ( PCUIDLIST_RELATIVE  pidl, LPBC  pbcReserved, REFIID  riid, LPVOID *  ppvOut  )

override

Definition at line 488 of file CRegFolder.cpp.

{
    CComPtr<IPersistFolder> pFolder;
    HRESULT hr;
 
    if (!ppvOut || !pidl || !pidl->mkid.cb)
        return E_INVALIDARG;
 
    *ppvOut = NULL;
 
    GUID *pGUID = _ILGetGUIDPointer(pidl);
    if (!pGUID)
    {
        ERR("CRegFolder::BindToObject called for non guid item!\n");
        return E_INVALIDARG;
    }
 
    hr = SHELL32_BindToSF(m_pidlRoot, NULL, pidl, pGUID, riid, ppvOut);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    return S_OK;
}

BindToStorage()

HRESULT WINAPI CRegFolder::BindToStorage ( PCUIDLIST_RELATIVE  pidl, LPBC  pbcReserved, REFIID  riid, LPVOID *  ppvOut  )

override

Definition at line 512 of file CRegFolder.cpp.

{
    return E_NOTIMPL;
}

CompareIDs()

HRESULT WINAPI CRegFolder::CompareIDs ( LPARAM  lParam, PCUIDLIST_RELATIVE  pidl1, PCUIDLIST_RELATIVE  pidl2  )

override

Implements IShellFolder.

Definition at line 517 of file CRegFolder.cpp.

{
    if (!pidl1 || !pidl2 || pidl1->mkid.cb == 0 || pidl2->mkid.cb == 0)
    {
        ERR("Got an empty pidl!\n");
        return E_INVALIDARG;
    }
 
    GUID const *clsid1 = _ILGetGUIDPointer (pidl1);
    GUID const *clsid2 = _ILGetGUIDPointer (pidl2);
 
    if (!clsid1 && !clsid2)
    {
        ERR("Got no guid pidl!\n");
        return E_INVALIDARG;
    }
    else if (clsid1 && clsid2)
    {
        if (memcmp(clsid1, clsid2, sizeof(GUID)) == 0)
            return SHELL32_CompareChildren(this, lParam, pidl1, pidl2);
 
        return SHELL32_CompareDetails(this, lParam, pidl1, pidl2);
    }
 
    /* Guid folders come first compared to everything else */
    /* And Drives come before folders in My Computer */
    if (GetPidlType() == PT_COMPUTER_REGITEM)
        return MAKE_COMPARE_HRESULT(clsid1 ? 1 : -1);
    else
        return MAKE_COMPARE_HRESULT(clsid1 ? -1 : 1);
}

CreateViewObject()

HRESULT WINAPI CRegFolder::CreateViewObject ( HWND  hwndOwner, REFIID  riid, LPVOID *  ppvOut  )

override

Definition at line 549 of file CRegFolder.cpp.

{
    return E_NOTIMPL;
}

EnumObjects()

HRESULT WINAPI CRegFolder::EnumObjects ( HWND  hwndOwner, DWORD  dwFlags, LPENUMIDLIST *  ppEnumIDList  )

override

Definition at line 482 of file CRegFolder.cpp.

{
    return ShellObjectCreatorInit<CRegFolderEnum>(m_pInfo, m_pOuterFolder, dwFlags,
                                                  IID_PPV_ARG(IEnumIDList, ppEnumIDList));
}

EnumSearches()

HRESULT WINAPI CRegFolder::EnumSearches ( IEnumExtraSearch **  ppenum )

override

Implements IShellFolder2.

Definition at line 794 of file CRegFolder.cpp.

{
    return E_NOTIMPL;
}

GetAttributesOf()

HRESULT WINAPI CRegFolder::GetAttributesOf ( UINT  cidl, PCUITEMID_CHILD_ARRAY  apidl, DWORD *  rgfInOut  )

override

Definition at line 554 of file CRegFolder.cpp.

{
    if (!rgfInOut || !cidl || !apidl)
        return E_INVALIDARG;
 
    if (*rgfInOut == 0)
        *rgfInOut = ~0;
 
    while(cidl > 0 && *apidl)
    {
        if (_ILIsSpecialFolder(*apidl))
            GetGuidItemAttributes(*apidl, rgfInOut);
        else
            ERR("Got unknown pidl\n");
        apidl++;
        cidl--;
    }
 
    /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
    *rgfInOut &= ~SFGAO_VALIDATE;
 
    return S_OK;
}

GetDefaultColumn()

HRESULT WINAPI CRegFolder::GetDefaultColumn ( DWORD  dwRes, ULONG *  pSort, ULONG *  pDisplay  )

override

Implements IShellFolder2.

Definition at line 799 of file CRegFolder.cpp.

{
    if (pSort)
        *pSort = 0;
    if (pDisplay)
        *pDisplay = 0;
 
    return S_OK;
}

GetDefaultColumnState()

HRESULT WINAPI CRegFolder::GetDefaultColumnState ( UINT  iColumn, DWORD *  pcsFlags  )

override

Implements IShellFolder2.

Definition at line 809 of file CRegFolder.cpp.

{
    if (iColumn >= REGFOLDERCOLUMNCOUNT)
        return E_INVALIDARG;
    *pcsFlags = SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT;
    return S_OK;
}

GetDefaultSearchGUID()

HRESULT WINAPI CRegFolder::GetDefaultSearchGUID ( GUID *  pguid )

override

Implements IShellFolder2.

Definition at line 789 of file CRegFolder.cpp.

{
    return E_NOTIMPL;
}

GetDetailsEx()

HRESULT WINAPI CRegFolder::GetDetailsEx ( PCUITEMID_CHILD  pidl, const SHCOLUMNID *  pscid, VARIANT *  pv  )

override

Implements IShellFolder2.

Definition at line 817 of file CRegFolder.cpp.

{
    return E_NOTIMPL;
}

GetDetailsOf()

HRESULT WINAPI CRegFolder::GetDetailsOf ( PCUITEMID_CHILD  pidl, UINT  iColumn, SHELLDETAILS *  psd  )

override

Implements IShellFolder2.

Definition at line 822 of file CRegFolder.cpp.

{
    if (!psd)
        return E_INVALIDARG;
 
    if (!pidl)
    {
        TRACE("CRegFolder has no column info\n");
        return E_INVALIDARG;
    }
 
    GUID const *clsid = _ILGetGUIDPointer (pidl);
 
    if (!clsid)
    {
        ERR("Pidl is not reg item!\n");
        return E_INVALIDARG;
    }
 
    switch(iColumn)
    {
        case COL_NAME:
            return GetDisplayNameOf(pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
        case COL_TYPE:
            return SHSetStrRet(&psd->str, IDS_SYSTEMFOLDER);
        case COL_INFOTIP:
            HKEY hKey;
            if (!HCR_RegOpenClassIDKey(*clsid, &hKey))
                return SHSetStrRet(&psd->str, "");
 
            psd->str.cStr[0] = 0x00;
            psd->str.uType = STRRET_CSTR;
            RegLoadMUIStringA(hKey, "InfoTip", psd->str.cStr, MAX_PATH, NULL, 0, NULL);
            RegCloseKey(hKey);
            return S_OK;
        default:
            /* Return an empty string when we area asked for a column we don't support.
               Only  the regfolder is supposed to do this as it supports less columns compared to other folder
               and its contents are supposed to be presented alongside items that support more columns. */
            return SHSetStrRet(&psd->str, "");
    }
    return E_FAIL;
}

GetDisplayNameOf()

HRESULT WINAPI CRegFolder::GetDisplayNameOf ( PCUITEMID_CHILD  pidl, DWORD  dwFlags, LPSTRRET  strRet  )

override

Definition at line 617 of file CRegFolder.cpp.

{
    if (!strRet || (!_ILIsSpecialFolder(pidl) && pidl != NULL))
        return E_INVALIDARG;
 
    if (!pidl || !pidl->mkid.cb)
    {
        if (IS_SHGDN_FOR_PARSING(dwFlags))
        {
            if (GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER)
            {
                TRACE("GDNO returning INFOLDER instead of %#x\n", GET_SHGDN_RELATION(dwFlags));
            }
            LPWSTR pszPath = (LPWSTR)CoTaskMemAlloc((2 + 38 + 1) * sizeof(WCHAR));
            if (!pszPath)
                return E_OUTOFMEMORY;
            /* parsing name like ::{...} */
            pszPath[0] = ':';
            pszPath[1] = ':';
            SHELL32_GUIDToStringW(m_pInfo->clsid, &pszPath[2]);
            strRet->uType = STRRET_WSTR;
            strRet->pOleStr = pszPath;
            return S_OK;
        }
        else
        {
            BOOL bRet;
            WCHAR wstrName[MAX_PATH+1];
            bRet = HCR_GetClassNameW(m_pInfo->clsid, wstrName, MAX_PATH);
            if (!bRet)
                return E_FAIL;
 
            return SHSetStrRet(strRet, wstrName);
        }
    }
 
    HRESULT hr;
    GUID const *clsid = _ILGetGUIDPointer (pidl);
 
    /* First of all check if we need to query the name from the child item */
    if (GET_SHGDN_FOR (dwFlags) == SHGDN_FORPARSING &&
        GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL)
    {
        int bWantsForParsing = FALSE;
 
        /*
            * We can only get a filesystem path from a shellfolder if the
            *  value WantsFORPARSING in CLSID\\{...}\\shellfolder exists.
            *
            * Exception: The MyComputer folder doesn't have this key,
            *   but any other filesystem backed folder it needs it.
            */
        if (IsEqualIID (*clsid, CLSID_MyComputer))
        {
            bWantsForParsing = TRUE;
        }
        else
        {
            HKEY hkeyClass;
            if (HCR_RegOpenClassIDKey(*clsid, &hkeyClass))
            {
                LONG res = SHGetValueW(hkeyClass, L"Shellfolder", L"WantsForParsing", NULL, NULL, NULL);
                bWantsForParsing = (res == ERROR_SUCCESS);
                RegCloseKey(hkeyClass);
            }
        }
 
        if (bWantsForParsing)
        {
            /*
             * we need the filesystem path to the destination folder.
             * Only the folder itself can know it
             */
            return SHELL32_GetDisplayNameOfChild (this, pidl, dwFlags, strRet);
        }
    }
 
    /* Allocate the buffer for the result */
    SIZE_T cchPath = MAX_PATH + 1;
    LPWSTR pszPath = (LPWSTR)CoTaskMemAlloc(cchPath * sizeof(WCHAR));
    if (!pszPath)
        return E_OUTOFMEMORY;
 
    hr = S_OK;
 
    if (GET_SHGDN_FOR (dwFlags) == SHGDN_FORPARSING)
    {
        SIZE_T pathlen = 0;
        PWCHAR pItemName = pszPath; // GET_SHGDN_RELATION(dwFlags) == SHGDN_INFOLDER
        if (GET_SHGDN_RELATION(dwFlags) != SHGDN_INFOLDER)
        {
            hr = StringCchCopyW(pszPath, cchPath, GetParsingPath());
            if (SUCCEEDED(hr))
            {
                pathlen = wcslen(pszPath);
                pItemName = &pszPath[pathlen];
                if (pathlen)
                {
                    if (++pathlen < cchPath)
                        *pItemName++ = L'\\';
                    else
                        hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
                }
            }
        }
 
        if (SUCCEEDED(hr) && pathlen + 2 + 38 + 1 < cchPath)
        {
            /* parsing name like ::{...} */
            pItemName[0] = L':';
            pItemName[1] = L':';
            SHELL32_GUIDToStringW(*clsid, &pItemName[2]);
        }
        else
        {
            hr = HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER);
        }
    }
    else
    {
        /* user friendly name */
        if (!HCR_GetClassNameW(*clsid, pszPath, cchPath))
            hr = E_FAIL;
    }
 
    if (SUCCEEDED(hr))
    {
        strRet->uType = STRRET_WSTR;
        strRet->pOleStr = pszPath;
    }
    else
    {
        CoTaskMemFree(pszPath);
    }
 
    return hr;
}

Referenced by GetDetailsOf().

GetGuidItemAttributes()

HRESULT CRegFolder::GetGuidItemAttributes ( LPCITEMIDLIST  pidl, LPDWORD  pdwAttributes  )

private

Definition at line 388 of file CRegFolder.cpp.

{
    DWORD dwAttributes = *pdwAttributes;
 
    /* First try to get them from the registry */
    if (!HCR_GetFolderAttributes(pidl, pdwAttributes))
    {
        /* We couldn't get anything */
        *pdwAttributes = 0;
    }
 
    /* Items have more attributes when on desktop */
    if (_ILIsDesktop(m_pidlRoot))
    {
        *pdwAttributes |= (dwAttributes & (SFGAO_CANLINK|SFGAO_CANDELETE|SFGAO_CANRENAME|SFGAO_HASPROPSHEET));
    }
 
    /* In any case, links can be created */
    *pdwAttributes |= (dwAttributes & SFGAO_CANLINK);
    return S_OK;
}

Referenced by GetAttributesOf(), and ParseDisplayName().

GetUIObjectOf()

HRESULT WINAPI CRegFolder::GetUIObjectOf ( HWND  hwndOwner, UINT  cidl, PCUITEMID_CHILD_ARRAY  apidl, REFIID  riid, UINT *  prgfInOut, LPVOID *  ppvOut  )

override

Definition at line 578 of file CRegFolder.cpp.

{
    LPVOID pObj = NULL;
    HRESULT hr = E_INVALIDARG;
 
    if (!ppvOut)
        return hr;
 
    *ppvOut = NULL;
 
    if ((IsEqualIID (riid, IID_IExtractIconA) || IsEqualIID (riid, IID_IExtractIconW)) && (cidl == 1))
    {
        hr = CGuidItemExtractIcon_CreateInstance(apidl[0], riid, &pObj);
    }
    else if (IsEqualIID (riid, IID_IContextMenu) && (cidl >= 1))
    {
        if (!_ILGetGUIDPointer (apidl[0]))
        {
            ERR("Got non guid item!\n");
            return E_FAIL;
        }
 
        hr = CRegItemContextMenu_CreateInstance(m_pidlRoot, hwndOwner, cidl, apidl, static_cast<IShellFolder*>(this), (IContextMenu**)&pObj);
    }
    else if (IsEqualIID (riid, IID_IDataObject) && (cidl >= 1))
    {
        hr = IDataObject_Constructor (hwndOwner, m_pidlRoot, apidl, cidl, TRUE, (IDataObject **)&pObj);
    }
    else
    {
        hr = E_NOINTERFACE;
    }
 
    *ppvOut = pObj;
    return hr;
 
}

Initialize()

HRESULT WINAPI CRegFolder::Initialize	(	PREGFOLDERINITDATA	pInit,
		LPCITEMIDLIST	pidlRoot
	)

Definition at line 376 of file CRegFolder.cpp.

{
    InitializeFolderInfo(pInit->pInfo);
    m_pOuterFolder = pInit->psfOuter;
 
    m_pidlRoot.Attach(ILClone(pidlRoot));
    if (!m_pidlRoot)
        return E_OUTOFMEMORY;
 
    return S_OK;
}

IsRequiredItem()

const REQUIREDREGITEM * CRegFolder::IsRequiredItem ( LPCITEMIDLIST  pidl ) const

inline

Definition at line 325 of file CRegFolder.cpp.

        {
            const CLSID* const pCLSID = IsRegItem(pidl);
            for (size_t i = 0; pCLSID && i < GetRequiredItemsCount(); ++i)
            {
                const REQUIREDREGITEM &item = GetAt(i);
                if (item.clsid == *pCLSID)
                    return &item;
            }
            return NULL;
        }

Referenced by RegFolderContextMenuCallback().

MapColumnToSCID()

HRESULT WINAPI CRegFolder::MapColumnToSCID ( UINT  column, SHCOLUMNID *  pscid  )

override

Implements IShellFolder2.

Definition at line 866 of file CRegFolder.cpp.

{
    return E_NOTIMPL;
}

ParseDisplayName()

HRESULT WINAPI CRegFolder::ParseDisplayName ( HWND  hwndOwner, LPBC  pbc, LPOLESTR  lpszDisplayName, ULONG *  pchEaten, PIDLIST_RELATIVE *  ppidl, ULONG *  pdwAttributes  )

override

Implements IShellFolder.

Definition at line 421 of file CRegFolder.cpp.

{
    if (!ppidl)
        return E_INVALIDARG;
 
    *ppidl = NULL;
 
    if (!lpszDisplayName)
        return E_INVALIDARG;
 
    if (lpszDisplayName[0] != L':' || lpszDisplayName[1] != L':')
    {
        FIXME("What should we do here?\n");
        return E_FAIL;
    }
 
    LPWSTR pch, pchNextOfComma = NULL;
    for (pch = &lpszDisplayName[2]; *pch && *pch != L'\\'; ++pch)
    {
        if (*pch == L',' && !pchNextOfComma)
            pchNextOfComma = pch + 1;
    }
 
    CLSID clsid;
    if (!GUIDFromStringW(&lpszDisplayName[2], &clsid))
        return CO_E_CLASSSTRING;
 
    if (pchNextOfComma)
    {
        FIXME("Delegate folder\n");
        return E_FAIL;
    }
 
    CComHeapPtr<ITEMIDLIST> pidlTemp(CreateRegItem(GetPidlType(), clsid));
    if (!pidlTemp)
        return E_OUTOFMEMORY;
 
    if (!_IsInNameSpace(pidlTemp) && !(BindCtx_GetMode(pbc, 0) & STGM_CREATE))
        return E_INVALIDARG;
 
    *ppidl = pidlTemp.Detach();
 
    if (!*pch)
    {
        if (pdwAttributes && *pdwAttributes)
            GetGuidItemAttributes(*ppidl, pdwAttributes);
 
        return S_OK;
    }
 
    HRESULT hr = SHELL32_ParseNextElement(this, hwndOwner, pbc, ppidl, pch + 1, pchEaten,
                                          pdwAttributes);
    if (FAILED(hr))
    {
        ILFree(*ppidl);
        *ppidl = NULL;
    }
    return hr;
}

SetNameOf()

HRESULT WINAPI CRegFolder::SetNameOf ( HWND  hwndOwner, PCUITEMID_CHILD  pidl, LPCOLESTR  lpName, DWORD  dwFlags, PITEMID_CHILD *  pPidlOut  )

override

Implements IShellFolder.

Definition at line 755 of file CRegFolder.cpp.

{
    GUID const *clsid = _ILGetGUIDPointer (pidl);
    LPOLESTR pStr;
    HRESULT hr;
    WCHAR szName[100];
 
    if (!clsid)
    {
        ERR("Pidl is not reg item!\n");
        return E_FAIL;
    }
 
    hr = StringFromCLSID(*clsid, &pStr);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    swprintf(szName, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\%s", pStr);
 
    DWORD cbData = (wcslen(lpName) + 1) * sizeof(WCHAR);
    LONG res = SHSetValueW(HKEY_CURRENT_USER, szName, NULL, RRF_RT_REG_SZ, lpName, cbData);
 
    CoTaskMemFree(pStr);
 
    if (res == ERROR_SUCCESS)
    {
        return pPidlOut ? SHILClone(pidl, pPidlOut) : S_OK;
    }
 
    return E_FAIL;
}

Member Data Documentation

m_pidlRoot

CComHeapPtr<ITEMIDLIST> CRegFolder::m_pidlRoot

private

Definition at line 315 of file CRegFolder.cpp.

Referenced by BindToObject(), GetGuidItemAttributes(), GetUIObjectOf(), and Initialize().

m_pOuterFolder

IShellFolder* CRegFolder::m_pOuterFolder

private

Definition at line 314 of file CRegFolder.cpp.

Referenced by EnumObjects(), and Initialize().

---

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

• dll/win32/shell32/folders/CRegFolder.cpp